src/vs/platform/agentHost/node/osc633Parser.ts
348 LOC · 333 covered · 15 uncovered · 70 ranges · 2283 concepts · 32 introducers · 1064 tests
File neighbourhood
The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
1
>
/*---------------------------------------------------------------------------------------------
osc633Parser.ts ×8
2
>
* Copyright (c) Microsoft Corporation. All rights reserved.
3
>
* Licensed under the MIT License. See License.txt in the project root for license information.
4
>
*--------------------------------------------------------------------------------------------*/
5
>
6
>
/**
7
>
* Lightweight parser for OSC 633 (VS Code shell integration) sequences in raw
8
>
* PTY output. Designed for the agent host where we don't have a full xterm.js
9
>
* instance - it scans data chunks for the sequences, extracts events, and
10
>
* removes the sequences from the data stream.
11
>
*
12
>
* Handles partial sequences that span across data chunk boundaries.
13
>
*/
14
>
15
>
/** OSC 633 event types we care about. */
16
>
export const enum Osc633EventType {
17
>
/** 633;A - Prompt start. Used to detect shell integration is active. */
18
>
PromptStart,
19
>
/** 633;B - Command start (where user inputs command). */
20
>
CommandStart,
21
>
/** 633;C - Command executed (output begins). */
22
>
CommandExecuted,
23
>
/** 633;D[;exitCode] - Command finished. */
24
>
CommandFinished,
25
>
/** 633;E;commandLine[;nonce] - Explicit command line. */
26
>
CommandLine,
27
>
/** 633;P;Key=Value - Property (e.g. Cwd). */
28
>
Property,
29
>
}
30
>
31
>
export interface IOsc633PromptStartEvent {
32
>
type: Osc633EventType.PromptStart;
33
>
}
34
>
35
>
export interface IOsc633CommandStartEvent {
36
>
type: Osc633EventType.CommandStart;
37
>
}
38
>
39
>
export interface IOsc633CommandExecutedEvent {
40
>
type: Osc633EventType.CommandExecuted;
41
>
}
42
>
43
>
export interface IOsc633CommandFinishedEvent {
44
>
type: Osc633EventType.CommandFinished;
45
>
exitCode: number | undefined;
46
>
}
47
>
48
>
export interface IOsc633CommandLineEvent {
49
>
type: Osc633EventType.CommandLine;
50
>
commandLine: string;
51
>
nonce: string | undefined;
52
>
}
53
>
54
>
export interface IOsc633PropertyEvent {
55
>
type: Osc633EventType.Property;
56
>
key: string;
57
>
value: string;
58
>
}
59
>
60
>
export type Osc633Event =
61
>
| IOsc633PromptStartEvent
62
>
| IOsc633CommandStartEvent
63
>
| IOsc633CommandExecutedEvent
64
>
| IOsc633CommandFinishedEvent
65
>
| IOsc633CommandLineEvent
66
>
| IOsc633PropertyEvent;
67
>
68
>
export interface IOsc633ParseResult {
69
>
/** Data with all OSC 633 sequences stripped. */
70
>
cleanedData: string;
71
>
/** Parsed events in order of appearance. */
72
>
events: Osc633Event[];
73
>
}
74
>
75
>
/**
76
>
* A single segment of parsed PTY data: either a run of cleaned output data or
77
>
* an OSC 633 event. Segments are emitted in stream order so that output which
78
>
* arrives before an event (e.g. a `CommandFinished` marker) can be attributed
79
>
* to the command before the event is handled — see {@link Osc633Parser.parseSegments}.
80
>
*/
81
>
export type Osc633ParseSegment =
82
>
| { readonly kind: 'data'; readonly data: string }
83
>
| { readonly kind: 'event'; readonly event: Osc633Event };
84
>
85
>
/**
86
>
* Decode escaped values in OSC 633 messages.
87
>
* Handles `\\` -> `\` and `\xAB` -> character with code 0xAB.
88
>
*/
90
>
if (message.indexOf('\\') === -1) {
92
>
}
94
>
/\\(\\|x([0-9a-f]{2}))/gi,
95
>
(_match: string, op: string, hex?: string) => hex ? String.fromCharCode(parseInt(hex, 16)) : op,
96
>
);
97
>
}
100
>
const semiIdx = payload.indexOf(';');
101
>
if ((semiIdx === -1 ? payload.length : semiIdx) !== 1) {
102
return undefined;
103
}
105
>
const command = payload[0];
106
>
const argsRaw = semiIdx === -1 ? '' : payload.substring(semiIdx + 1);
107
>
108
>
switch (command) {
109
>
case 'A':
117
>
return {
118
>
type: Osc633EventType.CommandFinished,
119
>
exitCode: exitCode !== undefined && !isNaN(exitCode) ? exitCode : undefined,
120
>
};
121
>
}
124
>
const commandLine = deserializeOscMessage(nonceIdx === -1 ? argsRaw : argsRaw.substring(0, nonceIdx));
125
>
const nonce = nonceIdx === -1 ? undefined : argsRaw.substring(nonceIdx + 1);
126
>
return { type: Osc633EventType.CommandLine, commandLine, nonce };
127
>
}
130
>
const eqIdx = deserialized.indexOf('=');
131
>
if (eqIdx === -1) {
133
>
}
135
>
type: Osc633EventType.Property,
136
>
key: deserialized.substring(0, eqIdx),
137
>
value: deserialized.substring(eqIdx + 1),
138
>
};
139
>
}
141
return undefined;
143
>
}
145
>
// OSC introducer is ESC ] (0x1b 0x5d)
146
>
const ESC = '\x1b';
147
>
const OSC_START = ESC + ']';
148
>
// Terminators: BEL (0x07) or ST (ESC \)
149
>
const BEL = '\x07';
150
>
const ST = ESC + '\\';
151
>
152
>
/**
153
>
* Stateful parser that handles data chunks, correctly dealing with
154
>
* partial sequences that span multiple chunks.
155
>
*/
156
>
export class Osc633Parser {
157
>
/** Buffer for an incomplete OSC sequence (from ESC] up to but not including the terminator). */
osc633Parser.ts ×5
158
>
private _pendingOsc = '';
159
>
/** Whether we are currently accumulating an OSC sequence. */
160
>
private _inOsc = false;
161
>
/** Set when the previous chunk ended with ESC inside an OSC body (potential ST start). */
162
>
private _pendingEscInOsc = false;
164
>
/**
165
>
* Parse a chunk of PTY data.
166
>
* Returns cleaned data (all OSC 633 sequences removed) and extracted events.
167
>
*
168
>
* This is a convenience view over {@link parseSegments} that concatenates the
169
>
* cleaned-data segments and collects the events. Callers that need to know
170
>
* whether a run of output arrived before or after an event (for correct
171
>
* command-output attribution) should use {@link parseSegments} instead.
172
>
*/
173
>
parse(data: string): IOsc633ParseResult {
175
>
let cleanedData = '';
176
>
for (const segment of this.parseSegments(data)) {
181
>
}
184
>
}
186
>
/**
187
>
* Parse a chunk of PTY data into an ordered list of segments, preserving the
188
>
* relative order of cleaned output data and OSC 633 events as they appear in
189
>
* the stream. Handles partial sequences that span multiple chunks.
190
>
*
191
>
* Preserving order matters because a single PTY read frequently contains a
192
>
* command's output immediately followed by its `CommandFinished` marker;
193
>
* consumers must append that output to the command before handling the
194
>
* finished event, otherwise the output is lost from the command result.
195
>
*/
196
>
parseSegments(data: string): Osc633ParseSegment[] {
198
>
let pending = '';
199
>
200
>
const appendData = (value: string): void => {
201
>
pending += value;
202
>
};
203
>
const flushData = (): void => {
204
>
if (pending.length > 0) {
206
>
pending = '';
207
>
}
209
>
const emitEvent = (event: Osc633Event): void => {
211
>
segments.push({ kind: 'event', event });
212
>
};
214
>
if (!this._inOsc && data.indexOf(OSC_START) === -1) {
216
>
flushData();
217
>
return segments;
218
>
}
220
>
let i = 0;
221
>
222
>
while (i < data.length) {
223
>
if (this._inOsc) {
225
>
if (this._pendingEscInOsc) {
227
>
if (data[i] === '\\') {
228
>
// ESC \ = ST terminator, sequence is complete.
229
>
i++;
230
>
this._inOsc = false;
231
>
const payload = this._pendingOsc;
232
>
this._pendingOsc = '';
233
>
this._handleOscPayload(payload, emitEvent, appendData, ST);
234
>
continue;
235
>
}
236
// ESC was not followed by \, malformed: complete the OSC anyway.
237
this._inOsc = false;
238
const payload = this._pendingOsc;
239
this._pendingOsc = '';
240
this._handleOscPayload(payload, emitEvent, appendData);
241
continue;
242
}
244
>
// We're inside an OSC sequence, look for the terminator.
245
>
const result = this._consumeOscBody(data, i);
246
>
i = result.nextIndex;
247
>
if (result.complete) {
248
>
this._inOsc = false;
249
>
const payload = this._pendingOsc;
250
>
this._pendingOsc = '';
251
>
this._handleOscPayload(payload, emitEvent, appendData, result.terminator);
252
>
} else if (result.pendingEsc) {
253
this._pendingEscInOsc = true;
254
}
255
>
// If not complete, _pendingOsc has been extended, and we're at end of data.
osc633Parser.ts ×3
256
>
continue;
257
>
}
259
>
// Look for the next ESC ] which starts an OSC sequence
260
>
const escIdx = data.indexOf(OSC_START, i);
261
>
if (escIdx === -1) {
263
>
i = data.length;
264
>
continue;
265
>
}
267
>
// Copy everything before the OSC start to cleaned output.
268
>
appendData(data.substring(i, escIdx));
269
>
270
>
// Start of OSC: check if it's 633.
271
>
i = escIdx + 2; // skip past ESC ]
272
>
this._pendingOsc = '';
273
>
this._inOsc = true;
274
>
275
>
// Try to consume the OSC body in this same chunk.
276
>
const result = this._consumeOscBody(data, i);
277
>
i = result.nextIndex;
278
>
if (result.complete) {
280
>
const payload = this._pendingOsc;
281
>
this._pendingOsc = '';
282
>
// If it's a 633 sequence, extract event; otherwise put it back in cleaned.
283
>
this._handleOscPayload(payload, emitEvent, appendData, result.terminator);
286
>
}
288
>
}
289
>
290
>
flushData();
291
>
return segments;
294
>
/**
295
>
* Consume characters from the OSC body, appending to _pendingOsc until a
296
>
* terminator (BEL or ST) is found.
297
>
*/
298
>
private _consumeOscBody(data: string, startIdx: number): { nextIndex: number; complete: boolean; pendingEsc?: boolean; terminator?: string } {
300
>
const escIdx = data.indexOf(ESC, startIdx);
301
>
302
>
if (belIdx !== -1 && (escIdx === -1 || belIdx < escIdx)) {
304
>
return { nextIndex: belIdx + 1, complete: true, terminator: BEL };
305
>
}
307
>
if (escIdx !== -1) {
310
>
return { nextIndex: data.length, complete: false, pendingEsc: true };
311
>
}
313
>
this._pendingOsc += data.substring(startIdx, escIdx);
314
>
if (data[escIdx + 1] === '\\') {
315
>
return { nextIndex: escIdx + 2, complete: true, terminator: ST };
316
>
}
317
318
return { nextIndex: escIdx, complete: true };
319
}
321
>
this._pendingOsc += data.substring(startIdx);
322
>
return { nextIndex: data.length, complete: false };
325
>
/**
326
>
* Process a complete OSC payload. If it's a 633; sequence, extract the
327
>
* event via {@link emitEvent}. Otherwise, reconstruct the original bytes and
328
>
* pass them through to the cleaned output via {@link appendData}.
329
>
*/
330
>
private _handleOscPayload(
332
>
emitEvent: (event: Osc633Event) => void,
333
>
appendData: (data: string) => void,
334
>
terminator = BEL,
335
>
): void {
336
>
if (payload.startsWith('633;')) {
338
>
const event = parseOsc633Payload(oscContent);
339
>
if (event) {
341
>
}
345
>
appendData(OSC_START + payload + terminator);
346
>
}