@codingame/monaco-vscode-api 1.83.16 → 1.85.0-next.1

package/vscode/src/vs/platform/terminal/common/capabilities/commandDetectionCapability.js

@@ -1,8 +1,10 @@
-import { __decorate } from '../../../../../../../external/tslib/tslib.es6.js';
-import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
 import { debounce } from 'monaco-editor/esm/vs/base/common/decorators.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Disposable, MandatoryMutableDisposable, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { PartialTerminalCommand, TerminalCommand } from './commandDetection/terminalCommand.js';
 class CommandDetectionCapability extends Disposable {
     get commands() { return this._commands; }
     get executingCommand() { return this._currentCommand.command; }
@@ -38,8 +40,7 @@ class CommandDetectionCapability extends Disposable {
         this._logService = _logService;
         this.type = 2 ;
         this._commands = [];
-        this._currentCommand = {};
-        this._isWindowsPty = false;
+        this._currentCommand = ( new PartialTerminalCommand(this._terminal));
         this._commandMarkers = [];
         this.__isCommandStorageDisabled = false;
         this._onCommandStarted = this._register(( new Emitter()));
@@ -54,18 +55,31 @@ class CommandDetectionCapability extends Disposable {
         this.onCommandInvalidated = this._onCommandInvalidated.event;
         this._onCurrentCommandInvalidated = this._register(( new Emitter()));
         this.onCurrentCommandInvalidated = this._onCurrentCommandInvalidated.event;
+        const that = this;
+        this._ptyHeuristicsHooks = new (class {
+            get onCurrentCommandInvalidatedEmitter() { return that._onCurrentCommandInvalidated; }
+            get onCommandStartedEmitter() { return that._onCommandStarted; }
+            get onCommandExecutedEmitter() { return that._onCommandExecuted; }
+            get dimensions() { return that._dimensions; }
+            get isCommandStorageDisabled() { return that.__isCommandStorageDisabled; }
+            get commandMarkers() { return that._commandMarkers; }
+            set commandMarkers(value) { that._commandMarkers = value; }
+            get clearCommandsInViewport() { return that._clearCommandsInViewport.bind(that); }
+            commitCommandFinished() {
+                that._commitCommandFinished?.flush();
+                that._commitCommandFinished = undefined;
+            }
+        });
+        this._ptyHeuristics = this._register(( new MandatoryMutableDisposable(( new UnixPtyHeuristics(this._terminal, this, this._ptyHeuristicsHooks, this._logService)))));
         this._dimensions = {
             cols: this._terminal.cols,
             rows: this._terminal.rows
         };
         this._register(this._terminal.onResize(e => this._handleResize(e)));
         this._register(this._terminal.onCursorMove(() => this._handleCursorMove()));
-        this._setupClearListeners();
     }
     _handleResize(e) {
-        if (this._isWindowsPty) {
-            this._preHandleResizeWindows(e);
-        }
+        this._ptyHeuristics.value.preHandleResize?.(e);
         this._dimensions.cols = e.cols;
         this._dimensions.rows = e.rows;
     }
@@ -78,53 +92,6 @@ class CommandDetectionCapability extends Disposable {
             }
         }
     }
-    _setupClearListeners() {
-        this._register(this.onBeforeCommandFinished(command => {
-            if (this._isWindowsPty) {
-                if (command.command.trim().toLowerCase() === 'clear' || command.command.trim().toLowerCase() === 'cls') {
-                    this._clearCommandsInViewport();
-                    this._currentCommand.isInvalid = true;
-                    this._onCurrentCommandInvalidated.fire({ reason: "windows"  });
-                }
-            }
-        }));
-        this._terminal.parser.registerCsiHandler({ final: 'J' }, params => {
-            if (!this._isWindowsPty) {
-                if (params.length >= 1 && (params[0] === 2 || params[0] === 3)) {
-                    this._clearCommandsInViewport();
-                }
-            }
-            return false;
-        });
-    }
-    _preHandleResizeWindows(e) {
-        const baseY = this._terminal.buffer.active.baseY;
-        const rowsDifference = e.rows - this._dimensions.rows;
-        if (rowsDifference > 0) {
-            this._waitForCursorMove().then(() => {
-                const potentialShiftedLineCount = Math.min(rowsDifference, baseY);
-                for (let i = this.commands.length - 1; i >= 0; i--) {
-                    const command = this.commands[i];
-                    if (!command.marker || command.marker.line < baseY || command.commandStartLineContent === undefined) {
-                        break;
-                    }
-                    const line = this._terminal.buffer.active.getLine(command.marker.line);
-                    if (!line || line.translateToString(true) === command.commandStartLineContent) {
-                        continue;
-                    }
-                    const shiftedY = command.marker.line - potentialShiftedLineCount;
-                    const shiftedLine = this._terminal.buffer.active.getLine(shiftedY);
-                    if (shiftedLine?.translateToString(true) !== command.commandStartLineContent) {
-                        continue;
-                    }
-                    this._terminal._core._bufferService.buffer.lines.onDeleteEmitter.fire({
-                        index: this._terminal.buffer.active.baseY,
-                        amount: potentialShiftedLineCount
-                    });
-                }
-            });
-        }
-    }
     _clearCommandsInViewport() {
         let count = 0;
         for (let i = this._commands.length - 1; i >= 0; i--) {
@@ -138,43 +105,68 @@ class CommandDetectionCapability extends Disposable {
             this._onCommandInvalidated.fire(this._commands.splice(this._commands.length - count, count));
         }
     }
-    _waitForCursorMove() {
-        const cursorX = this._terminal.buffer.active.cursorX;
-        const cursorY = this._terminal.buffer.active.cursorY;
-        let totalDelay = 0;
-        return ( new Promise((resolve, reject) => {
-            const interval = setInterval(() => {
-                if (cursorX !== this._terminal.buffer.active.cursorX || cursorY !== this._terminal.buffer.active.cursorY) {
-                    resolve();
-                    clearInterval(interval);
-                    return;
-                }
-                totalDelay += 10;
-                if (totalDelay > 1000) {
-                    clearInterval(interval);
-                    resolve();
-                }
-            }, 10);
-        }));
-    }
     setCwd(value) {
         this._cwd = value;
     }
     setIsWindowsPty(value) {
-        this._isWindowsPty = value;
+        if (value && !(this._ptyHeuristics.value instanceof WindowsPtyHeuristics)) {
+            const that = this;
+            this._ptyHeuristics.value = ( new WindowsPtyHeuristics(this._terminal, this, new (class {
+                get onCurrentCommandInvalidatedEmitter() { return that._onCurrentCommandInvalidated; }
+                get onCommandStartedEmitter() { return that._onCommandStarted; }
+                get onCommandExecutedEmitter() { return that._onCommandExecuted; }
+                get dimensions() { return that._dimensions; }
+                get isCommandStorageDisabled() { return that.__isCommandStorageDisabled; }
+                get commandMarkers() { return that._commandMarkers; }
+                set commandMarkers(value) { that._commandMarkers = value; }
+                get clearCommandsInViewport() { return that._clearCommandsInViewport.bind(that); }
+                commitCommandFinished() {
+                    that._commitCommandFinished?.flush();
+                    that._commitCommandFinished = undefined;
+                }
+            }), this._logService));
+        }
+        else if (!value && !(this._ptyHeuristics.value instanceof UnixPtyHeuristics)) {
+            this._ptyHeuristics.value = ( new UnixPtyHeuristics(this._terminal, this, this._ptyHeuristicsHooks, this._logService));
+        }
     }
     setIsCommandStorageDisabled() {
         this.__isCommandStorageDisabled = true;
     }
+    getCommandForLine(line) {
+        if (this._currentCommand.promptStartMarker && line >= this._currentCommand.promptStartMarker?.line) {
+            return this._currentCommand;
+        }
+        if (this._commands.length === 0) {
+            return undefined;
+        }
+        if ((this._commands[0].promptStartMarker ?? this._commands[0].marker).line > line) {
+            return undefined;
+        }
+        for (let i = this.commands.length - 1; i >= 0; i--) {
+            if ((this.commands[i].promptStartMarker ?? this.commands[i].marker).line <= line) {
+                return this.commands[i];
+            }
+        }
+        return undefined;
+    }
     getCwdForLine(line) {
         if (this._currentCommand.promptStartMarker && line >= this._currentCommand.promptStartMarker?.line) {
             return this._cwd;
         }
-        const reversed = [...this._commands].reverse();
-        return reversed.find(c => c.marker.line <= line - 1)?.cwd;
+        const command = this.getCommandForLine(line);
+        if (command && 'cwd' in command) {
+            return command.cwd;
+        }
+        return undefined;
     }
     handlePromptStart(options) {
-        this._currentCommand.promptStartMarker = options?.marker || this._terminal.registerMarker(0);
+        const lastCommand = this.commands.at(-1);
+        if (lastCommand?.endMarker && lastCommand?.executedMarker && lastCommand.endMarker.line === lastCommand.executedMarker.line) {
+            this._logService.debug('CommandDetectionCapability#handlePromptStart adjusted commandFinished', `${lastCommand.endMarker.line} -> ${lastCommand.executedMarker.line + 1}`);
+            lastCommand.endMarker = cloneMarker(this._terminal, lastCommand.executedMarker, 1);
+        }
+        this._currentCommand.promptStartMarker = options?.marker || (lastCommand?.endMarker ? cloneMarker(this._terminal, lastCommand.endMarker) : this._terminal.registerMarker(0));
         this._logService.debug('CommandDetectionCapability#handlePromptStart', this._terminal.buffer.active.cursorX, this._currentCommand.promptStartMarker?.line);
     }
     handleContinuationStart() {
@@ -212,46 +204,7 @@ class CommandDetectionCapability extends Disposable {
             this._logService.debug('CommandDetectionCapability#handleCommandStart', this._currentCommand.commandStartX, this._currentCommand.commandStartMarker?.line);
             return;
         }
-        if (this._isWindowsPty) {
-            this._handleCommandStartWindows();
-            return;
-        }
-        this._currentCommand.commandStartX = this._terminal.buffer.active.cursorX;
-        this._currentCommand.commandStartMarker = options?.marker || this._terminal.registerMarker(0);
-        this._currentCommand.commandExecutedMarker?.dispose();
-        this._currentCommand.commandExecutedMarker = undefined;
-        this._currentCommand.commandExecutedX = undefined;
-        for (const m of this._commandMarkers) {
-            m.dispose();
-        }
-        this._commandMarkers.length = 0;
-        this._onCommandStarted.fire({ marker: options?.marker || this._currentCommand.commandStartMarker, markProperties: options?.markProperties });
-        this._logService.debug('CommandDetectionCapability#handleCommandStart', this._currentCommand.commandStartX, this._currentCommand.commandStartMarker?.line);
-    }
-    _handleCommandStartWindows() {
-        this._currentCommand.commandStartX = this._terminal.buffer.active.cursorX;
-        this._commandMarkers.length = 0;
-        timeout(0).then(() => {
-            if (!this._currentCommand.commandExecutedMarker) {
-                this._onCursorMoveListener = this._terminal.onCursorMove(() => {
-                    if (this._commandMarkers.length === 0 || this._commandMarkers[this._commandMarkers.length - 1].line !== this._terminal.buffer.active.cursorY) {
-                        const marker = this._terminal.registerMarker(0);
-                        if (marker) {
-                            this._commandMarkers.push(marker);
-                        }
-                    }
-                });
-            }
-            this._currentCommand.commandStartMarker = this._terminal.registerMarker(0);
-            if (this._currentCommand.commandStartMarker) {
-                const line = this._terminal.buffer.active.getLine(this._currentCommand.commandStartMarker.line);
-                if (line) {
-                    this._currentCommand.commandStartLineContent = line.translateToString(true);
-                }
-            }
-            this._onCommandStarted.fire({ marker: this._currentCommand.commandStartMarker });
-            this._logService.debug('CommandDetectionCapability#_handleCommandStartWindows', this._currentCommand.commandStartX, this._currentCommand.commandStartMarker?.line);
-        });
+        this._ptyHeuristics.value.handleCommandStart(options);
     }
     handleGenericCommand(options) {
         if (options?.markProperties?.disableCommandStorage) {
@@ -263,165 +216,50 @@ class CommandDetectionCapability extends Disposable {
         this.handleCommandFinished(undefined, options);
     }
     handleCommandExecuted(options) {
-        if (this._isWindowsPty) {
-            this._handleCommandExecutedWindows();
-            return;
-        }
-        this._currentCommand.commandExecutedMarker = options?.marker || this._terminal.registerMarker(0);
-        this._currentCommand.commandExecutedX = this._terminal.buffer.active.cursorX;
-        this._logService.debug('CommandDetectionCapability#handleCommandExecuted', this._currentCommand.commandExecutedX, this._currentCommand.commandExecutedMarker?.line);
-        if (!this._currentCommand.commandStartMarker || !this._currentCommand.commandExecutedMarker || this._currentCommand.commandStartX === undefined) {
-            return;
-        }
-        this._currentCommand.command = this.__isCommandStorageDisabled ? '' : this._terminal.buffer.active.getLine(this._currentCommand.commandStartMarker.line)?.translateToString(true, this._currentCommand.commandStartX, this._currentCommand.commandRightPromptStartX).trim();
-        let y = this._currentCommand.commandStartMarker.line + 1;
-        const commandExecutedLine = this._currentCommand.commandExecutedMarker.line;
-        for (; y < commandExecutedLine; y++) {
-            const line = this._terminal.buffer.active.getLine(y);
-            if (line) {
-                const continuation = this._currentCommand.continuations?.find(e => e.marker.line === y);
-                if (continuation) {
-                    this._currentCommand.command += '\n';
-                }
-                const startColumn = continuation?.end ?? 0;
-                this._currentCommand.command += line.translateToString(true, startColumn);
-            }
-        }
-        if (y === commandExecutedLine) {
-            this._currentCommand.command += this._terminal.buffer.active.getLine(commandExecutedLine)?.translateToString(true, undefined, this._currentCommand.commandExecutedX) || '';
-        }
-        this._onCommandExecuted.fire();
-    }
-    _handleCommandExecutedWindows() {
-        this._onCursorMoveListener?.dispose();
-        this._onCursorMoveListener = undefined;
-        this._evaluateCommandMarkersWindows();
-        this._currentCommand.commandExecutedX = this._terminal.buffer.active.cursorX;
-        this._onCommandExecuted.fire();
-        this._logService.debug('CommandDetectionCapability#handleCommandExecuted', this._currentCommand.commandExecutedX, this._currentCommand.commandExecutedMarker?.line);
-    }
-    invalidateCurrentCommand(request) {
-        this._currentCommand.isInvalid = true;
-        this._onCurrentCommandInvalidated.fire(request);
+        this._ptyHeuristics.value.handleCommandExecuted(options);
     }
     handleCommandFinished(exitCode, options) {
-        if (this._isWindowsPty) {
-            this._preHandleCommandFinishedWindows();
-        }
-        this._currentCommand.commandFinishedMarker = options?.marker || this._terminal.registerMarker(0);
-        let command = this._currentCommand.command;
-        this._logService.debug('CommandDetectionCapability#handleCommandFinished', this._terminal.buffer.active.cursorX, this._currentCommand.commandFinishedMarker?.line, this._currentCommand.command, this._currentCommand);
-        this._exitCode = exitCode;
-        if (this._exitCode === undefined) {
+        this._ptyHeuristics.value.preHandleCommandFinished?.();
+        this._logService.debug('CommandDetectionCapability#handleCommandFinished', this._terminal.buffer.active.cursorX, options?.marker?.line, this._currentCommand.command, this._currentCommand);
+        if (exitCode === undefined) {
             const lastCommand = this.commands.length > 0 ? this.commands[this.commands.length - 1] : undefined;
-            if (command && command.length > 0 && lastCommand?.command === command) {
-                this._exitCode = lastCommand.exitCode;
+            if (this._currentCommand.command && this._currentCommand.command.length > 0 && lastCommand?.command === this._currentCommand.command) {
+                exitCode = lastCommand.exitCode;
             }
         }
         if (this._currentCommand.commandStartMarker === undefined || !this._terminal.buffer.active) {
             return;
         }
-        if (this._exitCode === undefined && command === undefined) {
-            command = '';
-        }
-        if ((command !== undefined && !command.startsWith('\\')) || this._handleCommandStartOptions?.ignoreCommandLine) {
-            const buffer = this._terminal.buffer.active;
-            const timestamp = Date.now();
-            const executedMarker = this._currentCommand.commandExecutedMarker;
-            const endMarker = this._currentCommand.commandFinishedMarker;
-            const newCommand = {
-                command: this._handleCommandStartOptions?.ignoreCommandLine ? '' : (command || ''),
-                isTrusted: !!this._currentCommand.isTrusted,
-                marker: this._currentCommand.commandStartMarker,
-                endMarker,
-                executedMarker,
-                timestamp,
-                cwd: this._cwd,
-                exitCode: this._exitCode,
-                commandStartLineContent: this._currentCommand.commandStartLineContent,
-                hasOutput: () => !executedMarker?.isDisposed && !endMarker?.isDisposed && !!(executedMarker && endMarker && executedMarker?.line < endMarker.line),
-                getOutput: () => getOutputForCommand(executedMarker, endMarker, buffer),
-                getOutputMatch: (outputMatcher) => getOutputMatchForCommand(this._isWindowsPty && (executedMarker?.line === endMarker?.line) ? this._currentCommand.commandStartMarker : executedMarker, endMarker, buffer, this._terminal.cols, outputMatcher),
-                markProperties: options?.markProperties
-            };
+        this._currentCommand.commandFinishedMarker = options?.marker || this._terminal.registerMarker(0);
+        this._ptyHeuristics.value.postHandleCommandFinished?.();
+        const newCommand = this._currentCommand.promoteToFullCommand(this._cwd, exitCode, this._handleCommandStartOptions?.ignoreCommandLine ?? false, options?.markProperties);
+        if (newCommand) {
             this._commands.push(newCommand);
-            this._logService.debug('CommandDetectionCapability#onCommandFinished', newCommand);
-            this._onBeforeCommandFinished.fire(newCommand);
-            if (!this._currentCommand.isInvalid) {
-                this._onCommandFinished.fire(newCommand);
-            }
+            this._commitCommandFinished = ( new RunOnceScheduler(() => {
+                this._onBeforeCommandFinished.fire(newCommand);
+                if (!this._currentCommand.isInvalid) {
+                    this._logService.debug('CommandDetectionCapability#onCommandFinished', newCommand);
+                    this._onCommandFinished.fire(newCommand);
+                }
+            }, 50));
+            this._commitCommandFinished.schedule();
         }
-        this._currentCommand.previousCommandMarker = this._currentCommand.commandStartMarker;
-        this._currentCommand = {};
+        this._currentCommand = ( new PartialTerminalCommand(this._terminal));
         this._handleCommandStartOptions = undefined;
     }
-    _preHandleCommandFinishedWindows() {
-        if (this._currentCommand.commandExecutedMarker) {
-            return;
-        }
-        if (this._commandMarkers.length === 0) {
-            if (!this._currentCommand.commandStartMarker) {
-                this._currentCommand.commandStartMarker = this._terminal.registerMarker(0);
-            }
-            if (this._currentCommand.commandStartMarker) {
-                this._commandMarkers.push(this._currentCommand.commandStartMarker);
-            }
-        }
-        this._evaluateCommandMarkersWindows();
-    }
-    _evaluateCommandMarkersWindows() {
-        if (this._commandMarkers.length === 0) {
-            return;
-        }
-        this._commandMarkers = this._commandMarkers.sort((a, b) => a.line - b.line);
-        this._currentCommand.commandStartMarker = this._commandMarkers[0];
-        if (this._currentCommand.commandStartMarker) {
-            const line = this._terminal.buffer.active.getLine(this._currentCommand.commandStartMarker.line);
-            if (line) {
-                this._currentCommand.commandStartLineContent = line.translateToString(true);
-            }
-        }
-        this._currentCommand.commandExecutedMarker = this._commandMarkers[this._commandMarkers.length - 1];
-    }
     setCommandLine(commandLine, isTrusted) {
         this._logService.debug('CommandDetectionCapability#setCommandLine', commandLine, isTrusted);
         this._currentCommand.command = commandLine;
         this._currentCommand.isTrusted = isTrusted;
     }
     serialize() {
-        const commands = ( this.commands.map(e => {
-            return {
-                startLine: e.marker?.line,
-                startX: undefined,
-                endLine: e.endMarker?.line,
-                executedLine: e.executedMarker?.line,
-                command: this.__isCommandStorageDisabled ? '' : e.command,
-                isTrusted: e.isTrusted,
-                cwd: e.cwd,
-                exitCode: e.exitCode,
-                commandStartLineContent: e.commandStartLineContent,
-                timestamp: e.timestamp,
-                markProperties: e.markProperties,
-                aliases: e.aliases
-            };
-        }));
-        if (this._currentCommand.commandStartMarker) {
-            commands.push({
-                startLine: this._currentCommand.commandStartMarker.line,
-                startX: this._currentCommand.commandStartX,
-                endLine: undefined,
-                executedLine: undefined,
-                command: '',
-                isTrusted: true,
-                cwd: this._cwd,
-                exitCode: undefined,
-                commandStartLineContent: undefined,
-                timestamp: 0,
-                markProperties: undefined
-            });
+        const commands = ( this.commands.map(e => e.serialize(this.__isCommandStorageDisabled)));
+        const partialCommand = this._currentCommand.serialize(this._cwd);
+        if (partialCommand) {
+            commands.push(partialCommand);
         }
         return {
-            isWindowsPty: this._isWindowsPty,
+            isWindowsPty: this._ptyHeuristics.value instanceof WindowsPtyHeuristics,
             commands
         };
     }
@@ -431,35 +269,22 @@ class CommandDetectionCapability extends Disposable {
         }
         const buffer = this._terminal.buffer.normal;
         for (const e of serialized.commands) {
-            const marker = e.startLine !== undefined ? this._terminal.registerMarker(e.startLine - (buffer.baseY + buffer.cursorY)) : undefined;
-            if (!marker) {
-                continue;
-            }
             if (!e.endLine) {
-                this._currentCommand.commandStartMarker = marker;
+                const marker = e.startLine !== undefined ? this._terminal.registerMarker(e.startLine - (buffer.baseY + buffer.cursorY)) : undefined;
+                if (!marker) {
+                    continue;
+                }
+                this._currentCommand.commandStartMarker = e.startLine !== undefined ? this._terminal.registerMarker(e.startLine - (buffer.baseY + buffer.cursorY)) : undefined;
                 this._currentCommand.commandStartX = e.startX;
+                this._currentCommand.promptStartMarker = e.promptStartLine !== undefined ? this._terminal.registerMarker(e.promptStartLine - (buffer.baseY + buffer.cursorY)) : undefined;
                 this._cwd = e.cwd;
                 this._onCommandStarted.fire({ marker });
                 continue;
             }
-            const endMarker = e.endLine !== undefined ? this._terminal.registerMarker(e.endLine - (buffer.baseY + buffer.cursorY)) : undefined;
-            const executedMarker = e.executedLine !== undefined ? this._terminal.registerMarker(e.executedLine - (buffer.baseY + buffer.cursorY)) : undefined;
-            const newCommand = {
-                command: this.__isCommandStorageDisabled ? '' : e.command,
-                isTrusted: e.isTrusted,
-                marker,
-                endMarker,
-                executedMarker,
-                timestamp: e.timestamp,
-                cwd: e.cwd,
-                commandStartLineContent: e.commandStartLineContent,
-                exitCode: e.exitCode,
-                hasOutput: () => !executedMarker?.isDisposed && !endMarker?.isDisposed && !!(executedMarker && endMarker && executedMarker.line < endMarker.line),
-                getOutput: () => getOutputForCommand(executedMarker, endMarker, buffer),
-                getOutputMatch: (outputMatcher) => getOutputMatchForCommand(this._isWindowsPty && (executedMarker?.line === endMarker?.line) ? marker : executedMarker, endMarker, buffer, this._terminal.cols, outputMatcher),
-                markProperties: e.markProperties,
-                wasReplayed: true
-            };
+            const newCommand = TerminalCommand.deserialize(this._terminal, e, this.__isCommandStorageDisabled);
+            if (!newCommand) {
+                continue;
+            }
             this._commands.push(newCommand);
             this._logService.debug('CommandDetectionCapability#onCommandFinished', newCommand);
             this._onCommandFinished.fire(newCommand);
@@ -469,98 +294,358 @@ class CommandDetectionCapability extends Disposable {
 CommandDetectionCapability.__decorator = ( __decorate([
     debounce(500)
 ], CommandDetectionCapability.prototype, "_handleCursorMove", null));
-function getOutputForCommand(executedMarker, endMarker, buffer) {
-    if (!executedMarker || !endMarker) {
-        return undefined;
+class UnixPtyHeuristics extends Disposable {
+    constructor(_terminal, _capability, _hooks, _logService) {
+        super();
+        this._terminal = _terminal;
+        this._capability = _capability;
+        this._hooks = _hooks;
+        this._logService = _logService;
+        this._register(_terminal.parser.registerCsiHandler({ final: 'J' }, params => {
+            if (params.length >= 1 && (params[0] === 2 || params[0] === 3)) {
+                _hooks.clearCommandsInViewport();
+            }
+            return false;
+        }));
     }
-    const startLine = executedMarker.line;
-    const endLine = endMarker.line;
-    if (startLine === endLine) {
-        return undefined;
+    async handleCommandStart(options) {
+        this._hooks.commitCommandFinished();
+        const currentCommand = this._capability.currentCommand;
+        currentCommand.commandStartX = this._terminal.buffer.active.cursorX;
+        currentCommand.commandStartMarker = options?.marker || this._terminal.registerMarker(0);
+        currentCommand.commandExecutedMarker?.dispose();
+        currentCommand.commandExecutedMarker = undefined;
+        currentCommand.commandExecutedX = undefined;
+        for (const m of this._hooks.commandMarkers) {
+            m.dispose();
+        }
+        this._hooks.commandMarkers.length = 0;
+        this._hooks.onCommandStartedEmitter.fire({ marker: options?.marker || currentCommand.commandStartMarker, markProperties: options?.markProperties });
+        this._logService.debug('CommandDetectionCapability#handleCommandStart', currentCommand.commandStartX, currentCommand.commandStartMarker?.line);
     }
-    let output = '';
-    let line;
-    for (let i = startLine; i < endLine; i++) {
-        line = buffer.getLine(i);
-        if (!line) {
-            continue;
+    handleCommandExecuted(options) {
+        const currentCommand = this._capability.currentCommand;
+        currentCommand.commandExecutedMarker = options?.marker || this._terminal.registerMarker(0);
+        currentCommand.commandExecutedX = this._terminal.buffer.active.cursorX;
+        this._logService.debug('CommandDetectionCapability#handleCommandExecuted', currentCommand.commandExecutedX, currentCommand.commandExecutedMarker?.line);
+        if (!currentCommand.commandStartMarker || !currentCommand.commandExecutedMarker || currentCommand.commandStartX === undefined) {
+            return;
+        }
+        currentCommand.command = this._hooks.isCommandStorageDisabled ? '' : this._terminal.buffer.active.getLine(currentCommand.commandStartMarker.line)?.translateToString(true, currentCommand.commandStartX, currentCommand.commandRightPromptStartX).trim();
+        let y = currentCommand.commandStartMarker.line + 1;
+        const commandExecutedLine = currentCommand.commandExecutedMarker.line;
+        for (; y < commandExecutedLine; y++) {
+            const line = this._terminal.buffer.active.getLine(y);
+            if (line) {
+                const continuation = currentCommand.continuations?.find(e => e.marker.line === y);
+                if (continuation) {
+                    currentCommand.command += '\n';
+                }
+                const startColumn = continuation?.end ?? 0;
+                currentCommand.command += line.translateToString(true, startColumn);
+            }
+        }
+        if (y === commandExecutedLine) {
+            currentCommand.command += this._terminal.buffer.active.getLine(commandExecutedLine)?.translateToString(true, undefined, currentCommand.commandExecutedX) || '';
         }
-        output += line.translateToString(!line.isWrapped) + (line.isWrapped ? '' : '\n');
+        this._hooks.onCommandExecutedEmitter.fire();
     }
-    return output === '' ? undefined : output;
 }
-function getOutputMatchForCommand(executedMarker, endMarker, buffer, cols, outputMatcher) {
-    if (!executedMarker || !endMarker) {
-        return undefined;
+let WindowsPtyHeuristics = class WindowsPtyHeuristics extends Disposable {
+    constructor(_terminal, _capability, _hooks, _logService) {
+        super();
+        this._terminal = _terminal;
+        this._capability = _capability;
+        this._hooks = _hooks;
+        this._logService = _logService;
+        this._onCursorMoveListener = this._register(( new MutableDisposable()));
+        this._recentlyPerformedCsiJ = false;
+        this._tryAdjustCommandStartMarkerScannedLineCount = 0;
+        this._tryAdjustCommandStartMarkerPollCount = 0;
+        this._register(_terminal.parser.registerCsiHandler({ final: 'J' }, params => {
+            if (params.length >= 1 && (params[0] === 2 || params[0] === 3)) {
+                this._recentlyPerformedCsiJ = true;
+                this._hooks.clearCommandsInViewport();
+            }
+            return false;
+        }));
+        this._register(this._capability.onBeforeCommandFinished(command => {
+            if (this._recentlyPerformedCsiJ) {
+                this._recentlyPerformedCsiJ = false;
+                return;
+            }
+            if (command.command.trim().toLowerCase() === 'clear' || command.command.trim().toLowerCase() === 'cls') {
+                this._tryAdjustCommandStartMarkerScheduler?.cancel();
+                this._tryAdjustCommandStartMarkerScheduler = undefined;
+                this._hooks.clearCommandsInViewport();
+                this._capability.currentCommand.isInvalid = true;
+                this._hooks.onCurrentCommandInvalidatedEmitter.fire({ reason: "windows"  });
+            }
+        }));
     }
-    const endLine = endMarker.line;
-    if (endLine === -1) {
-        return undefined;
+    preHandleResize(e) {
+        const baseY = this._terminal.buffer.active.baseY;
+        const rowsDifference = e.rows - this._hooks.dimensions.rows;
+        if (rowsDifference > 0) {
+            this._waitForCursorMove().then(() => {
+                const potentialShiftedLineCount = Math.min(rowsDifference, baseY);
+                for (let i = this._capability.commands.length - 1; i >= 0; i--) {
+                    const command = this._capability.commands[i];
+                    if (!command.marker || command.marker.line < baseY || command.commandStartLineContent === undefined) {
+                        break;
+                    }
+                    const line = this._terminal.buffer.active.getLine(command.marker.line);
+                    if (!line || line.translateToString(true) === command.commandStartLineContent) {
+                        continue;
+                    }
+                    const shiftedY = command.marker.line - potentialShiftedLineCount;
+                    const shiftedLine = this._terminal.buffer.active.getLine(shiftedY);
+                    if (shiftedLine?.translateToString(true) !== command.commandStartLineContent) {
+                        continue;
+                    }
+                    this._terminal._core._bufferService.buffer.lines.onDeleteEmitter.fire({
+                        index: this._terminal.buffer.active.baseY,
+                        amount: potentialShiftedLineCount
+                    });
+                }
+            });
+        }
     }
-    const startLine = Math.max(executedMarker.line, 0);
-    const matcher = outputMatcher.lineMatcher;
-    const linesToCheck = typeof matcher === 'string' ? 1 : outputMatcher.length || countNewLines(matcher);
-    const lines = [];
-    let match;
-    if (outputMatcher.anchor === 'bottom') {
-        for (let i = endLine - (outputMatcher.offset || 0); i >= startLine; i--) {
-            let wrappedLineStart = i;
-            const wrappedLineEnd = i;
-            while (wrappedLineStart >= startLine && buffer.getLine(wrappedLineStart)?.isWrapped) {
-                wrappedLineStart--;
+    async handleCommandStart() {
+        this._capability.currentCommand.commandStartX = this._terminal.buffer.active.cursorX;
+        this._hooks.commandMarkers.length = 0;
+        const initialCommandStartMarker = this._capability.currentCommand.commandStartMarker = (this._capability.currentCommand.promptStartMarker
+            ? cloneMarker(this._terminal, this._capability.currentCommand.promptStartMarker)
+            : this._terminal.registerMarker(0));
+        this._capability.currentCommand.commandStartX = 0;
+        this._tryAdjustCommandStartMarkerScannedLineCount = 0;
+        this._tryAdjustCommandStartMarkerPollCount = 0;
+        this._tryAdjustCommandStartMarkerScheduler = ( new RunOnceScheduler(
+            () => this._tryAdjustCommandStartMarker(initialCommandStartMarker),
+            20
+        ));
+        this._tryAdjustCommandStartMarkerScheduler.schedule();
+    }
+    _tryAdjustCommandStartMarker(start) {
+        if (this._store.isDisposed) {
+            return;
+        }
+        const buffer = this._terminal.buffer.active;
+        let scannedLineCount = this._tryAdjustCommandStartMarkerScannedLineCount;
+        while (scannedLineCount < 5  && start.line + scannedLineCount < buffer.baseY + this._terminal.rows) {
+            if (this._cursorOnNextLine()) {
+                const prompt = this._getWindowsPrompt(start.line + scannedLineCount);
+                if (prompt) {
+                    const adjustedPrompt = typeof prompt === 'string' ? prompt : prompt.prompt;
+                    this._capability.currentCommand.commandStartMarker = this._terminal.registerMarker(0);
+                    if (typeof prompt === 'object' && prompt.likelySingleLine) {
+                        this._logService.debug('CommandDetectionCapability#_tryAdjustCommandStartMarker adjusted promptStart', `${this._capability.currentCommand.promptStartMarker?.line} -> ${this._capability.currentCommand.commandStartMarker.line}`);
+                        this._capability.currentCommand.promptStartMarker?.dispose();
+                        this._capability.currentCommand.promptStartMarker = cloneMarker(this._terminal, this._capability.currentCommand.commandStartMarker);
+                        const lastCommand = this._capability.commands.at(-1);
+                        if (lastCommand && this._capability.currentCommand.commandStartMarker.line !== lastCommand.endMarker?.line) {
+                            lastCommand.endMarker?.dispose();
+                            lastCommand.endMarker = cloneMarker(this._terminal, this._capability.currentCommand.commandStartMarker);
+                        }
+                    }
+                    this._capability.currentCommand.commandStartX = adjustedPrompt.length;
+                    this._logService.debug('CommandDetectionCapability#_tryAdjustCommandStartMarker adjusted commandStart', `${start.line} -> ${this._capability.currentCommand.commandStartMarker.line}:${this._capability.currentCommand.commandStartX}`);
+                    this._flushPendingHandleCommandStartTask();
+                    return;
+                }
             }
-            i = wrappedLineStart;
-            lines.unshift(getXtermLineContent(buffer, wrappedLineStart, wrappedLineEnd, cols));
-            if (!match) {
-                match = lines[0].match(matcher);
+            scannedLineCount++;
+        }
+        if (scannedLineCount < 5 ) {
+            this._tryAdjustCommandStartMarkerScannedLineCount = scannedLineCount;
+            if (this._tryAdjustCommandStartMarkerPollCount < 50 ) {
+                this._tryAdjustCommandStartMarkerScheduler?.schedule();
             }
-            if (lines.length >= linesToCheck) {
-                break;
+            else {
+                this._flushPendingHandleCommandStartTask();
             }
         }
+        else {
+            this._flushPendingHandleCommandStartTask();
+        }
     }
-    else {
-        for (let i = startLine + (outputMatcher.offset || 0); i < endLine; i++) {
-            const wrappedLineStart = i;
-            let wrappedLineEnd = i;
-            while (wrappedLineEnd + 1 < endLine && buffer.getLine(wrappedLineEnd + 1)?.isWrapped) {
-                wrappedLineEnd++;
+    _flushPendingHandleCommandStartTask() {
+        if (this._tryAdjustCommandStartMarkerScheduler) {
+            this._tryAdjustCommandStartMarkerPollCount = 50 ;
+            this._tryAdjustCommandStartMarkerScheduler.flush();
+            this._tryAdjustCommandStartMarkerScheduler = undefined;
+        }
+        this._hooks.commitCommandFinished();
+        if (!this._capability.currentCommand.commandExecutedMarker) {
+            this._onCursorMoveListener.value = this._terminal.onCursorMove(() => {
+                if (this._hooks.commandMarkers.length === 0 || this._hooks.commandMarkers[this._hooks.commandMarkers.length - 1].line !== this._terminal.buffer.active.cursorY) {
+                    const marker = this._terminal.registerMarker(0);
+                    if (marker) {
+                        this._hooks.commandMarkers.push(marker);
+                    }
+                }
+            });
+        }
+        if (this._capability.currentCommand.commandStartMarker) {
+            const line = this._terminal.buffer.active.getLine(this._capability.currentCommand.commandStartMarker.line);
+            if (line) {
+                this._capability.currentCommand.commandStartLineContent = line.translateToString(true);
+            }
+        }
+        this._hooks.onCommandStartedEmitter.fire({ marker: this._capability.currentCommand.commandStartMarker });
+        this._logService.debug('CommandDetectionCapability#_handleCommandStartWindows', this._capability.currentCommand.commandStartX, this._capability.currentCommand.commandStartMarker?.line);
+    }
+    handleCommandExecuted(options) {
+        if (this._tryAdjustCommandStartMarkerScheduler) {
+            this._flushPendingHandleCommandStartTask();
+        }
+        this._onCursorMoveListener.clear();
+        this._evaluateCommandMarkers();
+        this._capability.currentCommand.commandExecutedX = this._terminal.buffer.active.cursorX;
+        this._hooks.onCommandExecutedEmitter.fire();
+        this._logService.debug('CommandDetectionCapability#handleCommandExecuted', this._capability.currentCommand.commandExecutedX, this._capability.currentCommand.commandExecutedMarker?.line);
+    }
+    preHandleCommandFinished() {
+        if (this._capability.currentCommand.commandExecutedMarker) {
+            return;
+        }
+        if (this._hooks.commandMarkers.length === 0) {
+            if (!this._capability.currentCommand.commandStartMarker) {
+                this._capability.currentCommand.commandStartMarker = this._terminal.registerMarker(0);
+            }
+            if (this._capability.currentCommand.commandStartMarker) {
+                this._hooks.commandMarkers.push(this._capability.currentCommand.commandStartMarker);
+            }
+        }
+        this._evaluateCommandMarkers();
+    }
+    postHandleCommandFinished() {
+        const currentCommand = this._capability.currentCommand;
+        const commandText = currentCommand.command;
+        const commandLine = currentCommand.commandStartMarker?.line;
+        const executedLine = currentCommand.commandExecutedMarker?.line;
+        if (!commandText || commandText.length === 0 ||
+            commandLine === undefined || commandLine === -1 ||
+            executedLine === undefined || executedLine === -1) {
+            return;
+        }
+        let current = 0;
+        let found = false;
+        for (let i = commandLine; i <= executedLine; i++) {
+            const line = this._terminal.buffer.active.getLine(i);
+            if (!line) {
+                break;
             }
-            i = wrappedLineEnd;
-            lines.push(getXtermLineContent(buffer, wrappedLineStart, wrappedLineEnd, cols));
-            if (!match) {
-                match = lines[lines.length - 1].match(matcher);
+            const text = line.translateToString(true);
+            for (let j = 0; j < text.length; j++) {
+                while (commandText.length < current && commandText[current] === ' ') {
+                    current++;
+                }
+                if (text[j] === commandText[current]) {
+                    current++;
+                }
+                if (current === commandText.length) {
+                    const wrapsToNextLine = j >= this._terminal.cols - 1;
+                    currentCommand.commandExecutedMarker = this._terminal.registerMarker(i - (this._terminal.buffer.active.baseY + this._terminal.buffer.active.cursorY) + (wrapsToNextLine ? 1 : 0));
+                    currentCommand.commandExecutedX = wrapsToNextLine ? 0 : j + 1;
+                    found = true;
+                    break;
+                }
             }
-            if (lines.length >= linesToCheck) {
+            if (found) {
                 break;
             }
         }
     }
-    return match ? { regexMatch: match, outputLines: lines } : undefined;
-}
-function getXtermLineContent(buffer, lineStart, lineEnd, cols) {
-    const maxLineLength = Math.max(2048 / cols * 2);
-    lineEnd = Math.min(lineEnd, lineStart + maxLineLength);
-    let content = '';
-    for (let i = lineStart; i <= lineEnd; i++) {
-        const line = buffer.getLine(i);
-        if (line) {
-            content += line.translateToString(true, 0, cols);
+    _evaluateCommandMarkers() {
+        if (this._hooks.commandMarkers.length === 0) {
+            return;
         }
+        this._hooks.commandMarkers = this._hooks.commandMarkers.sort((a, b) => a.line - b.line);
+        this._capability.currentCommand.commandStartMarker = this._hooks.commandMarkers[0];
+        if (this._capability.currentCommand.commandStartMarker) {
+            const line = this._terminal.buffer.active.getLine(this._capability.currentCommand.commandStartMarker.line);
+            if (line) {
+                this._capability.currentCommand.commandStartLineContent = line.translateToString(true);
+            }
+        }
+        this._capability.currentCommand.commandExecutedMarker = this._hooks.commandMarkers[this._hooks.commandMarkers.length - 1];
+        this._hooks.onCommandExecutedEmitter.fire();
     }
-    return content;
-}
-function countNewLines(regex) {
-    if (!regex.multiline) {
-        return 1;
-    }
-    const source = regex.source;
-    let count = 1;
-    let i = source.indexOf('\\n');
-    while (i !== -1) {
-        count++;
-        i = source.indexOf('\\n', i + 1);
-    }
-    return count;
+    _cursorOnNextLine() {
+        const lastCommand = this._capability.commands.at(-1);
+        if (!lastCommand) {
+            return true;
+        }
+        const cursorYAbsolute = this._terminal.buffer.active.baseY + this._terminal.buffer.active.cursorY;
+        const lastCommandYAbsolute = (lastCommand.endMarker ? lastCommand.endMarker.line : lastCommand.marker?.line) ?? -1;
+        return cursorYAbsolute > lastCommandYAbsolute;
+    }
+    _waitForCursorMove() {
+        const cursorX = this._terminal.buffer.active.cursorX;
+        const cursorY = this._terminal.buffer.active.cursorY;
+        let totalDelay = 0;
+        return ( new Promise((resolve, reject) => {
+            const interval = setInterval(() => {
+                if (cursorX !== this._terminal.buffer.active.cursorX || cursorY !== this._terminal.buffer.active.cursorY) {
+                    resolve();
+                    clearInterval(interval);
+                    return;
+                }
+                totalDelay += 10;
+                if (totalDelay > 1000) {
+                    clearInterval(interval);
+                    resolve();
+                }
+            }, 10);
+        }));
+    }
+    _getWindowsPrompt(y = this._terminal.buffer.active.baseY + this._terminal.buffer.active.cursorY) {
+        const line = this._terminal.buffer.active.getLine(y);
+        if (!line) {
+            return;
+        }
+        const lineText = line.translateToString(true);
+        if (!lineText) {
+            return;
+        }
+        const pwshPrompt = lineText.match(/(?<prompt>(\(.+\)\s)?(?:PS.+>\s?))/)?.groups?.prompt;
+        if (pwshPrompt) {
+            const adjustedPrompt = this._adjustPrompt(pwshPrompt, lineText, '>');
+            if (adjustedPrompt) {
+                return {
+                    prompt: adjustedPrompt,
+                    likelySingleLine: true
+                };
+            }
+        }
+        const customPrompt = lineText.match(/.*\u276f(?=[^\u276f]*$)/g)?.[0];
+        if (customPrompt) {
+            const adjustedPrompt = this._adjustPrompt(customPrompt, lineText, '\u276f');
+            if (adjustedPrompt) {
+                return adjustedPrompt;
+            }
+        }
+        const cmdMatch = lineText.match(/^(?<prompt>(\(.+\)\s)?(?:[A-Z]:\\.*>))/);
+        return cmdMatch?.groups?.prompt ? {
+            prompt: cmdMatch.groups.prompt,
+            likelySingleLine: true
+        } : undefined;
+    }
+    _adjustPrompt(prompt, lineText, char) {
+        if (!prompt) {
+            return;
+        }
+        if (lineText === prompt && prompt.endsWith(char)) {
+            prompt += ' ';
+        }
+        return prompt;
+    }
+};
+WindowsPtyHeuristics = ( __decorate([
+    ( __param(3, ILogService))
+], WindowsPtyHeuristics));
+function cloneMarker(xterm, marker, offset = 0) {
+    return xterm.registerMarker(marker.line - (xterm.buffer.active.baseY + xterm.buffer.active.cursorY) + offset);
 }
 export { CommandDetectionCapability };