@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/commandParsers/sedFileWriteParser.d.ts

@@ -0,0 +1,26 @@
+import { ICommandFileWriteParser } from "./commandFileWriteParser.js";
+/**
+ * Parser for detecting file writes from `sed` commands using in-place editing.
+ *
+ * Handles:
+ * - `sed -i 's/foo/bar/' file.txt` (GNU)
+ * - `sed -i.bak 's/foo/bar/' file.txt` (GNU with backup suffix)
+ * - `sed -i '' 's/foo/bar/' file.txt` (macOS/BSD with empty backup suffix)
+ * - `sed --in-place 's/foo/bar/' file.txt` (GNU long form)
+ * - `sed --in-place=.bak 's/foo/bar/' file.txt` (GNU long form with backup)
+ * - `sed -I 's/foo/bar/' file.txt` (BSD case-insensitive variant)
+ */
+export declare class SedFileWriteParser implements ICommandFileWriteParser {
+    readonly commandName = "sed";
+    canHandle(commandText: string): boolean;
+    extractFileWrites(commandText: string): string[];
+    /**
+     * Tokenizes a command into individual arguments, handling quotes and escapes.
+     */
+    private _tokenizeCommand;
+    /**
+     * Extracts file targets from tokenized sed command arguments.
+     * Files are generally the last non-option, non-script arguments.
+     */
+    private _extractFileTargets;
+}

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/commandParsers/sedFileWriteParser.js

@@ -0,0 +1,142 @@
+
+
+class SedFileWriteParser {
+    constructor() {
+        this.commandName = 'sed';
+    }
+    canHandle(commandText) {
+        if (!commandText.match(/^sed\s+/)) {
+            return false;
+        }
+        const inPlaceRegex = /(?:^|\s)(-[a-zA-Z]*[iI][a-zA-Z]*\S*|--in-place(?:=\S*)?|(-i|-I)\s*'[^']*'|(-i|-I)\s*"[^"]*")(?:\s|$)/;
+        return inPlaceRegex.test(commandText);
+    }
+    extractFileWrites(commandText) {
+        const tokens = this._tokenizeCommand(commandText);
+        return this._extractFileTargets(tokens);
+    }
+    _tokenizeCommand(commandText) {
+        const tokens = [];
+        let current = '';
+        let inSingleQuote = false;
+        let inDoubleQuote = false;
+        let escaped = false;
+        for (let i = 0; i < commandText.length; i++) {
+            const char = commandText[i];
+            if (escaped) {
+                current += char;
+                escaped = false;
+                continue;
+            }
+            if (char === '\\' && !inSingleQuote) {
+                escaped = true;
+                current += char;
+                continue;
+            }
+            if (char === '\'' && !inDoubleQuote) {
+                inSingleQuote = !inSingleQuote;
+                current += char;
+                continue;
+            }
+            if (char === '"' && !inSingleQuote) {
+                inDoubleQuote = !inDoubleQuote;
+                current += char;
+                continue;
+            }
+            if (/\s/.test(char) && !inSingleQuote && !inDoubleQuote) {
+                if (current) {
+                    tokens.push(current);
+                    current = '';
+                }
+                continue;
+            }
+            current += char;
+        }
+        if (current) {
+            tokens.push(current);
+        }
+        return tokens;
+    }
+    _extractFileTargets(tokens) {
+        if (tokens.length === 0 || tokens[0] !== 'sed') {
+            return [];
+        }
+        const files = [];
+        let i = 1;
+        let foundScript = false;
+        while (i < tokens.length) {
+            const token = tokens[i];
+            if (token.startsWith('--')) {
+                if (token === '--in-place' || token.startsWith('--in-place=')) {
+                    i++;
+                    continue;
+                }
+                if (token === '--expression' || token === '--file') {
+                    i += 2;
+                    foundScript = true;
+                    continue;
+                }
+                if (token.startsWith('--expression=') || token.startsWith('--file=')) {
+                    i++;
+                    foundScript = true;
+                    continue;
+                }
+                i++;
+                continue;
+            }
+            if (token.startsWith('-') && token.length > 1 && token[1] !== '-') {
+                const flags = token.slice(1);
+                const iIndex = flags.indexOf('i');
+                const IIndex = flags.indexOf('I');
+                const inPlaceIndex = iIndex >= 0 ? iIndex : IIndex;
+                if (inPlaceIndex >= 0 && inPlaceIndex < flags.length - 1) {
+                    i++;
+                    continue;
+                }
+                if ((flags.endsWith('i') || flags.endsWith('I')) && i + 1 < tokens.length) {
+                    const nextToken = tokens[i + 1];
+                    if (nextToken === '\'\'' || nextToken === '""') {
+                        i += 2;
+                        continue;
+                    }
+                    if ((nextToken.startsWith('\'') && nextToken.endsWith('\'')) || (nextToken.startsWith('"') && nextToken.endsWith('"'))) {
+                        const unquoted = nextToken.slice(1, -1);
+                        if (unquoted.startsWith('.') && unquoted.length <= 10 && !unquoted.includes('/')) {
+                            i += 2;
+                            continue;
+                        }
+                    }
+                }
+                if (flags.includes('e') || flags.includes('f')) {
+                    const eIndex = flags.indexOf('e');
+                    const fIndex = flags.indexOf('f');
+                    const optIndex = eIndex >= 0 ? eIndex : fIndex;
+                    if (optIndex < flags.length - 1) {
+                        foundScript = true;
+                        i++;
+                        continue;
+                    }
+                    foundScript = true;
+                    i += 2;
+                    continue;
+                }
+                i++;
+                continue;
+            }
+            if (!foundScript) {
+                foundScript = true;
+                i++;
+                continue;
+            }
+            let file = token;
+            if ((file.startsWith('\'') && file.endsWith('\'')) || (file.startsWith('"') && file.endsWith('"'))) {
+                file = file.slice(1, -1);
+            }
+            files.push(file);
+            i++;
+        }
+        return files;
+    }
+}
+
+export { SedFileWriteParser };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/basicExecuteStrategy.d.ts

@@ -1,5 +1,6 @@
 import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import type { ICommandDetectionCapability } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities";
 import { ITerminalLogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service";
 import { type ITerminalExecuteStrategy, type ITerminalExecuteStrategyResult } from "./executeStrategy.js";
@@ -27,7 +28,7 @@ import { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbe
  * output. We lean on the LLM to be able to differentiate the actual output from prompts and bad
  * output when it's not ideal.
  */
-export declare class BasicExecuteStrategy implements ITerminalExecuteStrategy {
+export declare class BasicExecuteStrategy extends Disposable implements ITerminalExecuteStrategy {
     private readonly _instance;
     private readonly _hasReceivedUserInput;
     private readonly _commandDetection;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/basicExecuteStrategy.js

@@ -2,21 +2,22 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { isNumber } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
 import { trackIdleOnPrompt, waitForIdle } from './executeStrategy.js';
 import { createAltBufferPromise, setupRecreatingStartMarker } from './strategyHelpers.js';
 
-let BasicExecuteStrategy = class BasicExecuteStrategy {
+let BasicExecuteStrategy = class BasicExecuteStrategy extends Disposable {
     constructor(_instance, _hasReceivedUserInput, _commandDetection, _logService) {
+        super();
         this._instance = _instance;
         this._hasReceivedUserInput = _hasReceivedUserInput;
         this._commandDetection = _commandDetection;
         this._logService = _logService;
-        this.type = 'basic';
-        this._startMarker = ( new MutableDisposable());
-        this._onDidCreateStartMarker = ( new Emitter());
+        this.type = "basic";
+        this._startMarker = this._register(( new MutableDisposable()));
+        this._onDidCreateStartMarker = this._register(( new Emitter()));
         this.onDidCreateStartMarker = this._onDidCreateStartMarker.event;
     }
     async execute(commandLine, token, commandId) {
@@ -25,67 +26,80 @@ let BasicExecuteStrategy = class BasicExecuteStrategy {
             const idlePromptPromise = trackIdleOnPrompt(this._instance, 1000, store);
             const onDone = Promise.race([
                 Event.toPromise(this._commandDetection.onCommandFinished, store).then(e => {
-                    this._log('onDone 1 of 2 via end event, waiting for short idle prompt');
+                    this._log("onDone 1 of 2 via end event, waiting for short idle prompt");
                     return idlePromptPromise.then(() => {
-                        this._log('onDone 2 of 2 via short idle prompt');
+                        this._log("onDone 2 of 2 via short idle prompt");
                         return {
-                            'type': 'success',
+                            "type": "success",
                             command: e
                         };
                     });
                 }),
                 Event.toPromise(token.onCancellationRequested, store).then(() => {
-                    this._log('onDone via cancellation');
+                    this._log("onDone via cancellation");
                 }),
                 Event.toPromise(this._instance.onDisposed, store).then(() => {
-                    this._log('onDone via terminal disposal');
-                    return { type: 'disposal' };
+                    this._log("onDone via terminal disposal");
+                    return {
+                        type: "disposal"
+                    };
                 }),
                 trackIdleOnPrompt(this._instance, 3000, store).then(() => {
-                    this._log('onDone long idle prompt');
-                }),
+                    this._log("onDone long idle prompt");
+                })
             ]);
-            this._log('Waiting for xterm');
+            this._log("Waiting for xterm");
             const xterm = await this._instance.xtermReadyPromise;
             if (!xterm) {
-                throw ( new Error('Xterm is not available'));
+                throw ( new Error("Xterm is not available"));
             }
             const alternateBufferPromise = createAltBufferPromise(xterm, store, this._log.bind(this));
-            this._log('Waiting for idle');
+            this._log("Waiting for idle");
             await waitForIdle(this._instance.onData, 1000);
-            setupRecreatingStartMarker(xterm, this._startMarker, m => this._onDidCreateStartMarker.fire(m), store, this._log.bind(this));
+            setupRecreatingStartMarker(
+                xterm,
+                this._startMarker,
+                m => this._onDidCreateStartMarker.fire(m),
+                store,
+                this._log.bind(this)
+            );
             if (this._hasReceivedUserInput()) {
-                this._log('Command timed out, sending SIGINT and retrying');
-                await this._instance.sendText('\x03', false);
+                this._log("Command timed out, sending SIGINT and retrying");
+                await this._instance.sendText("\u0003", false);
                 await waitForIdle(this._instance.onData, 100);
             }
             if (commandId) {
-                this._log(`In basic execute strategy: skipping pre-bound command id ${commandId} because basic shell integration executes via sendText`);
+                this._log(
+                    `In basic execute strategy: skipping pre-bound command id ${commandId} because basic shell integration executes via sendText`
+                );
             }
             this._log(`Executing command line \`${commandLine}\``);
             this._instance.sendText(commandLine, true);
-            this._log('Waiting for done event');
-            const onDoneResult = await Promise.race([onDone, alternateBufferPromise.then(() => ({ type: 'alternateBuffer' }))]);
-            if (onDoneResult && onDoneResult.type === 'disposal') {
-                throw ( new Error('The terminal was closed'));
+            this._log("Waiting for done event");
+            const onDoneResult = await Promise.race([onDone, alternateBufferPromise.then(() => ({
+                type: "alternateBuffer"
+            }))]);
+            if (onDoneResult && onDoneResult.type === "disposal") {
+                throw ( new Error("The terminal was closed"));
             }
-            if (onDoneResult && onDoneResult.type === 'alternateBuffer') {
-                this._log('Detected alternate buffer entry, skipping output capture');
+            if (onDoneResult && onDoneResult.type === "alternateBuffer") {
+                this._log("Detected alternate buffer entry, skipping output capture");
                 return {
                     output: undefined,
                     exitCode: undefined,
-                    error: 'alternateBuffer',
+                    error: "alternateBuffer",
                     didEnterAltBuffer: true
                 };
             }
-            const finishedCommand = onDoneResult && onDoneResult.type === 'success' ? onDoneResult.command : undefined;
+            const finishedCommand = onDoneResult && onDoneResult.type === "success" ? onDoneResult.command : undefined;
             if (finishedCommand) {
-                this._log(`Finished command id=${finishedCommand.id ?? 'none'} for requested=${commandId ?? 'none'}`);
-            }
-            else if (commandId) {
+                this._log(
+                    `Finished command id=${finishedCommand.id ?? "none"} for requested=${commandId ?? "none"}`
+                );
+            } else if (commandId) {
                 this._log(`No finished command surfaced for requested=${commandId}`);
             }
-            this._log('Waiting for idle');
+            this._log("Waiting for idle");
             await waitForIdle(this._instance.onData, 1000);
             if (token.isCancellationRequested) {
                 throw ( new CancellationError());
@@ -96,22 +110,21 @@ let BasicExecuteStrategy = class BasicExecuteStrategy {
             if (finishedCommand) {
                 const commandOutput = finishedCommand?.getOutput();
                 if (commandOutput !== undefined) {
-                    this._log('Fetched output via finished command');
+                    this._log("Fetched output via finished command");
                     output = commandOutput;
                 }
             }
             if (output === undefined) {
                 try {
                     output = xterm.getContentsAsText(this._startMarker.value, endMarker);
-                    this._log('Fetched output via markers');
-                }
-                catch {
-                    this._log('Failed to fetch output via markers');
-                    additionalInformationLines.push('Failed to retrieve command output');
+                    this._log("Fetched output via markers");
+                } catch {
+                    this._log("Failed to fetch output via markers");
+                    additionalInformationLines.push("Failed to retrieve command output");
                 }
             }
             if (output !== undefined && output.trim().length === 0) {
-                additionalInformationLines.push('Command produced no output');
+                additionalInformationLines.push("Command produced no output");
             }
             const exitCode = finishedCommand?.exitCode;
             if (isNumber(exitCode) && exitCode > 0) {
@@ -119,11 +132,10 @@ let BasicExecuteStrategy = class BasicExecuteStrategy {
             }
             return {
                 output,
-                additionalInformation: additionalInformationLines.length > 0 ? additionalInformationLines.join('\n') : undefined,
-                exitCode,
+                additionalInformation: additionalInformationLines.length > 0 ? additionalInformationLines.join("\n") : undefined,
+                exitCode
             };
-        }
-        finally {
+        } finally {
             store.dispose();
         }
     }
@@ -131,8 +143,6 @@ let BasicExecuteStrategy = class BasicExecuteStrategy {
         this._logService.debug(`RunInTerminalTool#Basic: ${message}`);
     }
 };
-BasicExecuteStrategy = ( __decorate([
-    ( __param(3, ITerminalLogService))
-], BasicExecuteStrategy));
+BasicExecuteStrategy = ( __decorate([( __param(3, ITerminalLogService))], BasicExecuteStrategy));
 
 export { BasicExecuteStrategy };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/executeStrategy.d.ts

@@ -1,9 +1,9 @@
 import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import type { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
-import { DisposableStore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { DisposableStore, type IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import type { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
 import type { IMarker as IXtermMarker } from "@xterm/xterm";
-export interface ITerminalExecuteStrategy {
+export interface ITerminalExecuteStrategy extends IDisposable {
     readonly type: "rich" | "basic" | "none";
     /**
      * Executes a command line and gets a result designed to be passed directly to an LLM. The

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/executeStrategy.js

@@ -12,41 +12,71 @@ async function waitForIdle(onData, idleDurationMs) {
 }
 function detectsCommonPromptPattern(cursorLine) {
     if (cursorLine.trim().length === 0) {
-        return { detected: false, reason: 'Content is empty or contains only whitespace' };
+        return {
+            detected: false,
+            reason: "Content is empty or contains only whitespace"
+        };
     }
     if (/PS\s+[A-Z]:\\.*>\s*$/.test(cursorLine)) {
-        return { detected: true, reason: `PowerShell prompt pattern detected: "${cursorLine}"` };
+        return {
+            detected: true,
+            reason: `PowerShell prompt pattern detected: "${cursorLine}"`
+        };
     }
     if (/^[A-Z]:\\.*>\s*$/.test(cursorLine)) {
-        return { detected: true, reason: `Command Prompt pattern detected: "${cursorLine}"` };
+        return {
+            detected: true,
+            reason: `Command Prompt pattern detected: "${cursorLine}"`
+        };
     }
     if (/\$\s*$/.test(cursorLine)) {
-        return { detected: true, reason: `Bash-style prompt pattern detected: "${cursorLine}"` };
+        return {
+            detected: true,
+            reason: `Bash-style prompt pattern detected: "${cursorLine}"`
+        };
     }
     if (/#\s*$/.test(cursorLine)) {
-        return { detected: true, reason: `Root prompt pattern detected: "${cursorLine}"` };
+        return {
+            detected: true,
+            reason: `Root prompt pattern detected: "${cursorLine}"`
+        };
     }
     if (/^>>>\s*$/.test(cursorLine)) {
-        return { detected: true, reason: `Python REPL prompt pattern detected: "${cursorLine}"` };
+        return {
+            detected: true,
+            reason: `Python REPL prompt pattern detected: "${cursorLine}"`
+        };
     }
     if (/\u276f\s*$/.test(cursorLine)) {
-        return { detected: true, reason: `Starship prompt pattern detected: "${cursorLine}"` };
+        return {
+            detected: true,
+            reason: `Starship prompt pattern detected: "${cursorLine}"`
+        };
     }
     if (/[>%]\s*$/.test(cursorLine)) {
-        return { detected: true, reason: `Generic prompt pattern detected: "${cursorLine}"` };
+        return {
+            detected: true,
+            reason: `Generic prompt pattern detected: "${cursorLine}"`
+        };
     }
-    return { detected: false, reason: `No common prompt pattern found in last line: "${cursorLine}"` };
+    return {
+        detected: false,
+        reason: `No common prompt pattern found in last line: "${cursorLine}"`
+    };
 }
 async function waitForIdleWithPromptHeuristics(onData, instance, idlePollIntervalMs, extendedTimeoutMs) {
     await waitForIdle(onData, idlePollIntervalMs);
     const xterm = await instance.xtermReadyPromise;
     if (!xterm) {
-        return { detected: false, reason: `Xterm not available, using ${idlePollIntervalMs}ms timeout` };
+        return {
+            detected: false,
+            reason: `Xterm not available, using ${idlePollIntervalMs}ms timeout`
+        };
     }
     const startTime = Date.now();
     while (Date.now() - startTime < extendedTimeoutMs) {
         try {
-            let content = '';
+            let content = "";
             const buffer = xterm.raw.buffer.active;
             const line = buffer.getLine(buffer.baseY + buffer.cursorY);
             if (line) {
@@ -56,22 +86,28 @@ async function waitForIdleWithPromptHeuristics(onData, instance, idlePollInterva
             if (promptResult.detected) {
                 return promptResult;
             }
-        }
-        catch (error) {
-        }
-        await waitForIdle(onData, Math.min(idlePollIntervalMs, extendedTimeoutMs - (Date.now() - startTime)));
+        } catch (error) {}
+        await waitForIdle(
+            onData,
+            Math.min(idlePollIntervalMs, extendedTimeoutMs - (Date.now() - startTime))
+        );
     }
     try {
-        let content = '';
+        let content = "";
         const buffer = xterm.raw.buffer.active;
         const line = buffer.getLine(buffer.baseY + buffer.cursorY);
         if (line) {
-            content = line.translateToString(true) + '\n';
+            content = line.translateToString(true) + "\n";
         }
-        return { detected: false, reason: `Extended timeout reached without prompt detection. Last line: "${content.trim()}"` };
-    }
-    catch (error) {
-        return { detected: false, reason: `Extended timeout reached. Error reading terminal content: ${error}` };
+        return {
+            detected: false,
+            reason: `Extended timeout reached without prompt detection. Last line: "${content.trim()}"`
+        };
+    } catch (error) {
+        return {
+            detected: false,
+            reason: `Extended timeout reached. Error reading terminal content: ${error}`
+        };
     }
 }
 async function trackIdleOnPrompt(instance, idleDurationMs, store) {
@@ -90,7 +126,7 @@ async function trackIdleOnPrompt(instance, idleDurationMs, store) {
         scheduler.schedule();
     }, 1000)));
     let TerminalState;
-    (function (TerminalState) {
+    (function(TerminalState) {
         TerminalState[TerminalState["Initial"] = 0] = "Initial";
         TerminalState[TerminalState["Prompt"] = 1] = "Prompt";
         TerminalState[TerminalState["Executing"] = 2] = "Executing";
@@ -99,28 +135,24 @@ async function trackIdleOnPrompt(instance, idleDurationMs, store) {
     store.add(onData(e => {
         const matches = e.matchAll(/(?:\x1b\]|\x9d)[16]33;(?<type>[ACD])(?:;.*)?(?:\x1b\\|\x07|\x9c)/g);
         for (const match of matches) {
-            if (match.groups?.type === 'A') {
+            if (match.groups?.type === "A") {
                 if (state === 0 ) {
                     state = 1 ;
-                }
-                else if (state === 2 ) {
+                } else if (state === 2 ) {
                     state = 3 ;
                 }
-            }
-            else if (match.groups?.type === 'C' || match.groups?.type === 'D') {
+            } else if (match.groups?.type === "C" || match.groups?.type === "D") {
                 state = 2 ;
             }
         }
         if (state === 3 ) {
             promptFallbackScheduler.cancel();
             scheduler.schedule();
-        }
-        else {
+        } else {
             scheduler.cancel();
             if (state === 0  || state === 1 ) {
                 promptFallbackScheduler.schedule();
-            }
-            else {
+            } else {
                 promptFallbackScheduler.cancel();
             }
         }

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/noneExecuteStrategy.d.ts

@@ -1,5 +1,6 @@
 import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { ITerminalLogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service";
 import { type ITerminalExecuteStrategy, type ITerminalExecuteStrategyResult } from "./executeStrategy.js";
 import type { IMarker as IXtermMarker } from "@xterm/xterm";
@@ -10,7 +11,7 @@ import { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbe
  * with `sendText` instead of `shellIntegration.executeCommand` and relying on idle events instead
  * of execution events.
  */
-export declare class NoneExecuteStrategy implements ITerminalExecuteStrategy {
+export declare class NoneExecuteStrategy extends Disposable implements ITerminalExecuteStrategy {
     private readonly _instance;
     private readonly _hasReceivedUserInput;
     private readonly _logService;