@codingame/monaco-vscode-chat-service-override 20.5.0 → 21.0.0

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

@@ -1,12 +1,18 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { DeferredPromise, disposableTimeout, timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { raceTimeout, DeferredPromise, disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
-import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { DisposableStore, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { TerminalCapability } from '@codingame/monaco-vscode-a9da9abe-278d-5ce6-9418-99c7c07c5c37-common/vscode/vs/platform/terminal/common/capabilities/capabilities';
+import { PromptInputState } from '@codingame/monaco-vscode-88141f48-1af9-57ef-a278-f4b2ff6128fa-common/vscode/vs/platform/terminal/common/capabilities/commandDetection/promptInputModel';
+import { TerminalSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal';
+import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
 import { ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-a175bd1a-4858-5944-9ae5-fb73305dcb13-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
 
 var ToolTerminalCreator_1;
 var ShellLaunchType;
@@ -24,33 +30,66 @@ var ShellIntegrationQuality;
 let ToolTerminalCreator = class ToolTerminalCreator {
     static { ToolTerminalCreator_1 = this; }
     static { this._lastSuccessfulShell = ShellLaunchType.Unknown; }
-    constructor(_terminalService) {
+    constructor(_configurationService, _logService, _terminalService) {
+        this._configurationService = _configurationService;
+        this._logService = _logService;
         this._terminalService = _terminalService;
     }
-    async createTerminal(token) {
-        const instance = await this._createCopilotTerminal();
+    async createTerminal(shell, token) {
+        const instance = await this._createCopilotTerminal(shell);
         const toolTerminal = {
             instance,
             shellIntegrationQuality: ShellIntegrationQuality.None,
         };
-        if (ToolTerminalCreator_1._lastSuccessfulShell <= ShellLaunchType.Default) {
-            const shellIntegrationQuality = await this._waitForShellIntegration(instance, 5000);
+        const siInjectionEnabled = this._configurationService.getValue(TerminalSettingId.ShellIntegrationEnabled);
+        const configuredTimeout = this._configurationService.getValue(TerminalChatAgentToolsSettingId.ShellIntegrationTimeout);
+        let waitTime;
+        if (configuredTimeout === undefined || typeof configuredTimeout !== 'number' || configuredTimeout < 0) {
+            waitTime = siInjectionEnabled ? 5000 : (instance.isRemote ? 3000 : 2000);
+        }
+        else {
+            waitTime = Math.max(configuredTimeout, 500);
+        }
+        if (ToolTerminalCreator_1._lastSuccessfulShell !== ShellLaunchType.Fallback ||
+            siInjectionEnabled) {
+            this._logService.info(`ToolTerminalCreator#createTerminal: Waiting ${waitTime}ms for shell integration`);
+            const shellIntegrationQuality = await this._waitForShellIntegration(instance, waitTime);
             if (token.isCancellationRequested) {
                 instance.dispose();
                 throw ( new CancellationError());
             }
+            if (shellIntegrationQuality === ShellIntegrationQuality.Rich) {
+                const commandDetection = instance.capabilities.get(TerminalCapability.CommandDetection);
+                if (commandDetection?.promptInputModel.state === PromptInputState.Unknown) {
+                    this._logService.info(`ToolTerminalCreator#createTerminal: Waiting up to 2s for PromptInputModel state to change`);
+                    await raceTimeout(Event.toPromise(commandDetection.onCommandStarted), 2000);
+                }
+            }
             if (shellIntegrationQuality !== ShellIntegrationQuality.None) {
                 ToolTerminalCreator_1._lastSuccessfulShell = ShellLaunchType.Default;
                 toolTerminal.shellIntegrationQuality = shellIntegrationQuality;
                 return toolTerminal;
             }
         }
+        else {
+            this._logService.info(`ToolTerminalCreator#createTerminal: Skipping wait for shell integration - last successful launch type ${ToolTerminalCreator_1._lastSuccessfulShell}`);
+        }
         ToolTerminalCreator_1._lastSuccessfulShell = ShellLaunchType.Fallback;
         return toolTerminal;
     }
-    _createCopilotTerminal() {
+    refreshShellIntegrationQuality(toolTerminal) {
+        const commandDetection = toolTerminal.instance.capabilities.get(TerminalCapability.CommandDetection);
+        if (commandDetection) {
+            if (toolTerminal.shellIntegrationQuality === ShellIntegrationQuality.None ||
+                toolTerminal.shellIntegrationQuality === ShellIntegrationQuality.Basic) {
+                toolTerminal.shellIntegrationQuality = commandDetection.hasRichCommandDetection ? ShellIntegrationQuality.Rich : ShellIntegrationQuality.Basic;
+            }
+        }
+    }
+    _createCopilotTerminal(shell) {
         return this._terminalService.createTerminal({
             config: {
+                executable: shell,
                 icon: ThemeIcon.fromId(Codicon.chatSparkle.id),
                 hideFromUser: true,
                 env: {
@@ -60,55 +99,59 @@ let ToolTerminalCreator = class ToolTerminalCreator {
         });
     }
     _waitForShellIntegration(instance, timeoutMs) {
-        const dataFinished = ( new DeferredPromise());
-        const deferred = ( new DeferredPromise());
-        const timer = disposableTimeout(() => deferred.complete(ShellIntegrationQuality.None), timeoutMs);
+        const store = ( new DisposableStore());
+        const result = ( new DeferredPromise());
+        const siNoneTimer = store.add(( new MutableDisposable()));
+        siNoneTimer.value = disposableTimeout(() => {
+            this._logService.info(`ToolTerminalCreator#_waitForShellIntegration: Timed out ${timeoutMs}ms, using no SI`);
+            result.complete(ShellIntegrationQuality.None);
+        }, timeoutMs);
         if (instance.capabilities.get(TerminalCapability.CommandDetection)?.hasRichCommandDetection) {
-            timer.dispose();
-            deferred.complete(ShellIntegrationQuality.Rich);
+            siNoneTimer.clear();
+            this._logService.info(`ToolTerminalCreator#_waitForShellIntegration: Rich SI available immediately`);
+            result.complete(ShellIntegrationQuality.Rich);
         }
         else {
-            const onSetRichCommandDetection = this._terminalService.createOnInstanceCapabilityEvent(TerminalCapability.CommandDetection, e => e.onSetRichCommandDetection);
-            const richCommandDetectionListener = onSetRichCommandDetection.event((e) => {
+            const onSetRichCommandDetection = store.add(this._terminalService.createOnInstanceCapabilityEvent(TerminalCapability.CommandDetection, e => e.onSetRichCommandDetection));
+            store.add(onSetRichCommandDetection.event((e) => {
                 if (e.instance !== instance) {
                     return;
                 }
-                deferred.complete(ShellIntegrationQuality.Rich);
-            });
-            const store = ( new DisposableStore());
+                siNoneTimer.clear();
+                this._logService.info(`ToolTerminalCreator#_waitForShellIntegration: Rich SI available eventually`);
+                result.complete(ShellIntegrationQuality.Rich);
+            }));
             const commandDetection = instance.capabilities.get(TerminalCapability.CommandDetection);
             if (commandDetection) {
-                timer.dispose();
-                Promise.race([
-                    dataFinished.p,
-                    timeout(200)
-                ]).then(() => {
-                    if (!deferred.isResolved) {
-                        deferred.complete(ShellIntegrationQuality.Basic);
-                    }
-                });
+                siNoneTimer.clear();
+                store.add(disposableTimeout(() => {
+                    this._logService.info(`ToolTerminalCreator#_waitForShellIntegration: Timed out 200ms, using basic SI`);
+                    result.complete(ShellIntegrationQuality.Basic);
+                }, 200));
             }
             else {
                 store.add(instance.capabilities.onDidAddCapabilityType(e => {
                     if (e === TerminalCapability.CommandDetection) {
-                        timer.dispose();
-                        Promise.race([
-                            dataFinished.p,
-                            timeout(200)
-                        ]).then(() => deferred.complete(ShellIntegrationQuality.Basic));
+                        siNoneTimer.clear();
+                        store.add(disposableTimeout(() => {
+                            this._logService.info(`ToolTerminalCreator#_waitForShellIntegration: Timed out 200ms, using basic SI (via listener)`);
+                            result.complete(ShellIntegrationQuality.Basic);
+                        }, 200));
                     }
                 }));
             }
-            deferred.p.finally(() => {
-                store.dispose();
-                richCommandDetectionListener.dispose();
-            });
         }
-        return deferred.p;
+        result.p.finally(() => {
+            this._logService.info(`ToolTerminalCreator#_waitForShellIntegration: Promise complete, disposing store`);
+            store.dispose();
+        });
+        return result.p;
     }
 };
 ToolTerminalCreator = ToolTerminalCreator_1 = ( __decorate([
-    ( __param(0, ITerminalService))
+    ( __param(0, IConfigurationService)),
+    ( __param(1, ITerminalLogService)),
+    ( __param(2, ITerminalService))
 ], ToolTerminalCreator));
 
 export { ShellIntegrationQuality, ToolTerminalCreator };

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

@@ -0,0 +1,11 @@
+import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { type IPreparedToolInvocation, type IToolData, type IToolImpl, type IToolInvocation, type IToolInvocationPreparationContext, type IToolResult, type CountTokensCallback, type ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService";
+import { ITerminalService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+export declare const GetTerminalLastCommandToolData: IToolData;
+export declare class GetTerminalLastCommandTool extends Disposable implements IToolImpl {
+    private readonly _terminalService;
+    constructor(_terminalService: ITerminalService);
+    prepareToolInvocation(context: IToolInvocationPreparationContext, token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
+}

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

@@ -0,0 +1,106 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { TerminalCapability } from '@codingame/monaco-vscode-a9da9abe-278d-5ce6-9418-99c7c07c5c37-common/vscode/vs/platform/terminal/common/capabilities/capabilities';
+import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
+import { ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
+
+const GetTerminalLastCommandToolData = {
+    id: 'terminal_last_command',
+    toolReferenceName: 'terminalLastCommand',
+    displayName: ( localize(11434, 'Get Terminal Last Command')),
+    modelDescription: 'Get the last command run in the active terminal.',
+    source: ToolDataSource.Internal,
+    icon: Codicon.terminal,
+};
+let GetTerminalLastCommandTool = class GetTerminalLastCommandTool extends Disposable {
+    constructor(_terminalService) {
+        super();
+        this._terminalService = _terminalService;
+    }
+    async prepareToolInvocation(context, token) {
+        return {
+            invocationMessage: ( localize(11435, "Getting last terminal command")),
+            pastTenseMessage: ( localize(11436, "Got last terminal command")),
+        };
+    }
+    async invoke(invocation, _countTokens, _progress, token) {
+        const activeInstance = this._terminalService.activeInstance;
+        if (!activeInstance) {
+            return {
+                content: [{
+                        kind: 'text',
+                        value: 'No active terminal instance found.'
+                    }]
+            };
+        }
+        const commandDetection = activeInstance.capabilities.get(TerminalCapability.CommandDetection);
+        if (!commandDetection) {
+            return {
+                content: [{
+                        kind: 'text',
+                        value: 'No command detection capability available in the active terminal.'
+                    }]
+            };
+        }
+        const executingCommand = commandDetection.executingCommand;
+        if (executingCommand) {
+            const userPrompt = [];
+            userPrompt.push('The following command is currently executing in the terminal:');
+            userPrompt.push(executingCommand);
+            const cwd = commandDetection.cwd;
+            if (cwd) {
+                userPrompt.push('It is running in the directory:');
+                userPrompt.push(cwd);
+            }
+            return {
+                content: [{
+                        kind: 'text',
+                        value: userPrompt.join('\n')
+                    }]
+            };
+        }
+        const commands = commandDetection.commands;
+        if (!commands || commands.length === 0) {
+            return {
+                content: [{
+                        kind: 'text',
+                        value: 'No command has been run in the active terminal.'
+                    }]
+            };
+        }
+        const lastCommand = commands[commands.length - 1];
+        const userPrompt = [];
+        if (lastCommand.command) {
+            userPrompt.push('The following is the last command run in the terminal:');
+            userPrompt.push(lastCommand.command);
+        }
+        if (lastCommand.cwd) {
+            userPrompt.push('It was run in the directory:');
+            userPrompt.push(lastCommand.cwd);
+        }
+        if (lastCommand.exitCode !== undefined) {
+            userPrompt.push(`It exited with code: ${lastCommand.exitCode}`);
+        }
+        if (lastCommand.hasOutput() && lastCommand.getOutput) {
+            const output = lastCommand.getOutput();
+            if (output && output.trim().length > 0) {
+                userPrompt.push('It has the following output:');
+                userPrompt.push(output);
+            }
+        }
+        return {
+            content: [{
+                    kind: 'text',
+                    value: userPrompt.join('\n')
+                }]
+        };
+    }
+};
+GetTerminalLastCommandTool = ( __decorate([
+    ( __param(0, ITerminalService))
+], GetTerminalLastCommandTool));
+
+export { GetTerminalLastCommandTool, GetTerminalLastCommandToolData };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/{getTerminalOutputTool.js → tools/getTerminalOutputTool.js}

@@ -1,4 +1,5 @@
 
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
@@ -7,8 +8,9 @@ import { RunInTerminalTool } from './runInTerminalTool.js';
 const GetTerminalOutputToolData = {
     id: 'get_terminal_output',
     toolReferenceName: 'getTerminalOutput',
-    displayName: ( localize(11261, 'Get Terminal Output')),
+    displayName: ( localize(11437, 'Get Terminal Output')),
     modelDescription: 'Get the output of a terminal command previously started with run_in_terminal',
+    icon: Codicon.terminal,
     source: ToolDataSource.Internal,
     inputSchema: {
         type: 'object',
@@ -26,8 +28,8 @@ const GetTerminalOutputToolData = {
 class GetTerminalOutputTool extends Disposable {
     async prepareToolInvocation(context, token) {
         return {
-            invocationMessage: ( localize(11262, "Checking background terminal output")),
-            pastTenseMessage: ( localize(11263, "Checked background terminal output")),
+            invocationMessage: ( localize(11438, "Checking background terminal output")),
+            pastTenseMessage: ( localize(11439, "Checked background terminal output")),
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {

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

@@ -0,0 +1,11 @@
+import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { type IPreparedToolInvocation, type IToolData, type IToolImpl, type IToolInvocation, type IToolInvocationPreparationContext, type IToolResult, type CountTokensCallback, type ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService";
+import { ITerminalService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+export declare const GetTerminalSelectionToolData: IToolData;
+export declare class GetTerminalSelectionTool extends Disposable implements IToolImpl {
+    private readonly _terminalService;
+    constructor(_terminalService: ITerminalService);
+    prepareToolInvocation(context: IToolInvocationPreparationContext, token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
+}

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

@@ -0,0 +1,59 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
+import { ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
+
+const GetTerminalSelectionToolData = {
+    id: 'terminal_selection',
+    toolReferenceName: 'terminalSelection',
+    displayName: ( localize(11440, 'Get Terminal Selection')),
+    modelDescription: 'Get the current selection in the active terminal.',
+    source: ToolDataSource.Internal,
+    icon: Codicon.terminal,
+};
+let GetTerminalSelectionTool = class GetTerminalSelectionTool extends Disposable {
+    constructor(_terminalService) {
+        super();
+        this._terminalService = _terminalService;
+    }
+    async prepareToolInvocation(context, token) {
+        return {
+            invocationMessage: ( localize(11441, "Reading terminal selection")),
+            pastTenseMessage: ( localize(11442, "Read terminal selection")),
+        };
+    }
+    async invoke(invocation, _countTokens, _progress, token) {
+        const activeInstance = this._terminalService.activeInstance;
+        if (!activeInstance) {
+            return {
+                content: [{
+                        kind: 'text',
+                        value: 'No active terminal instance found.'
+                    }]
+            };
+        }
+        const selection = activeInstance.selection;
+        if (!selection) {
+            return {
+                content: [{
+                        kind: 'text',
+                        value: 'No text is currently selected in the active terminal.'
+                    }]
+            };
+        }
+        return {
+            content: [{
+                    kind: 'text',
+                    value: `The active terminal's selection:\n${selection}`
+                }]
+        };
+    }
+};
+GetTerminalSelectionTool = ( __decorate([
+    ( __param(0, ITerminalService))
+], GetTerminalSelectionTool));
+
+export { GetTerminalSelectionTool, GetTerminalSelectionToolData };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/monitoring/outputMonitor.d.ts

@@ -0,0 +1,57 @@
+import { 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 { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+import { IToolInvocationContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService";
+import { ITaskService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/taskService.service";
+import { IPollingResult, OutputMonitorState, IExecution } from "./types.js";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+export interface IOutputMonitor extends Disposable {
+    readonly pollingResult: IPollingResult & {
+        pollDurationMs: number;
+    } | undefined;
+    readonly outputMonitorTelemetryCounters: IOutputMonitorTelemetryCounters;
+    readonly onDidFinishCommand: Event<void>;
+}
+export interface IOutputMonitorTelemetryCounters {
+    inputToolManualAcceptCount: number;
+    inputToolManualRejectCount: number;
+    inputToolManualChars: number;
+}
+export declare class OutputMonitor extends Disposable implements IOutputMonitor {
+    private readonly _execution;
+    private readonly _pollFn;
+    private readonly _languageModelsService;
+    private readonly _taskService;
+    private readonly _chatService;
+    private readonly _chatWidgetService;
+    private _state;
+    get state(): OutputMonitorState;
+    private _lastPromptMarker;
+    private _lastPrompt;
+    private _promptPart;
+    private _pollingResult;
+    get pollingResult(): IPollingResult & {
+        pollDurationMs: number;
+    } | undefined;
+    private readonly _outputMonitorTelemetryCounters;
+    get outputMonitorTelemetryCounters(): Readonly<IOutputMonitorTelemetryCounters>;
+    private readonly _onDidFinishCommand;
+    readonly onDidFinishCommand: Event<void>;
+    constructor(_execution: IExecution, _pollFn: ((execution: IExecution, token: CancellationToken, taskService: ITaskService) => Promise<IPollingResult | undefined>) | undefined, invocationContext: IToolInvocationContext, token: CancellationToken, command: string, _languageModelsService: ILanguageModelsService, _taskService: ITaskService, _chatService: IChatService, _chatWidgetService: IChatWidgetService);
+    private _startMonitoring;
+    private _handleIdleState;
+    private _handleTimeoutState;
+    /**
+     * Single bounded polling pass that returns when:
+     *  - terminal becomes inactive/idle, or
+     *  - timeout window elapses.
+     */
+    private _waitForIdle;
+    private _promptForMorePolling;
+    private _assessOutputForErrors;
+    private _determineUserInputOptions;
+    private _selectAndHandleOption;
+    private _confirmRunInTerminal;
+}