@codingame/monaco-vscode-chat-service-override 29.1.0 → 30.0.0

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

@@ -18,7 +18,7 @@ const GetTaskOutputToolData = {
     id: TerminalToolId.GetTaskOutput,
     toolReferenceName: "getTaskOutput",
     legacyToolReferenceFullNames: ["runTasks/getTaskOutput"],
-    displayName: ( localize(13879, "Get Task Output")),
+    displayName: ( localize(13954, "Get Task Output")),
     modelDescription: "Get the output of a task",
     source: ToolDataSource.Internal,
     when: TasksAvailableContext,
@@ -65,19 +65,19 @@ let GetTaskOutputTool = class GetTaskOutputTool extends Disposable {
         );
         if (!task) {
             return {
-                invocationMessage: ( new MarkdownString(( localize(13880, "Task not found: `{0}`", args.id))))
+                invocationMessage: ( new MarkdownString(( localize(13955, "Task not found: `{0}`", args.id))))
             };
         }
         const taskLabel = task._label;
         const activeTasks = await this._tasksService.getActiveTasks();
         if (activeTasks.includes(task)) {
             return {
-                invocationMessage: ( new MarkdownString(( localize(13881, "The task `{0}` is already running.", taskLabel))))
+                invocationMessage: ( new MarkdownString(( localize(13956, "The task `{0}` is already running.", taskLabel))))
             };
         }
         return {
-            invocationMessage: ( new MarkdownString(( localize(13882, "Checking output for task `{0}`", taskLabel)))),
-            pastTenseMessage: ( new MarkdownString(( localize(13883, "Checked output for task `{0}`", taskLabel))))
+            invocationMessage: ( new MarkdownString(( localize(13957, "Checking output for task `{0}`", taskLabel)))),
+            pastTenseMessage: ( new MarkdownString(( localize(13958, "Checked output for task `{0}`", taskLabel))))
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {
@@ -97,7 +97,7 @@ let GetTaskOutputTool = class GetTaskOutputTool extends Disposable {
                     kind: "text",
                     value: `Task not found: ${args.id}`
                 }],
-                toolResultMessage: ( new MarkdownString(( localize(13880, "Task not found: `{0}`", args.id))))
+                toolResultMessage: ( new MarkdownString(( localize(13955, "Task not found: `{0}`", args.id))))
             };
         }
         const dependencyTasks = await resolveDependencyTasks(task, args.workspaceFolder, this._configurationService, this._tasksService);
@@ -112,7 +112,7 @@ let GetTaskOutputTool = class GetTaskOutputTool extends Disposable {
                     kind: "text",
                     value: `Terminal not found for task ${taskLabel}`
                 }],
-                toolResultMessage: ( new MarkdownString(( localize(13884, "Terminal not found for task `{0}`", taskLabel))))
+                toolResultMessage: ( new MarkdownString(( localize(13959, "Terminal not found for task `{0}`", taskLabel))))
             };
         }
         const startMarkersByTerminalInstanceId = task.configurationProperties.isBackground ? ( new Map()) : undefined;

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

@@ -57,7 +57,7 @@ let RunTaskTool = class RunTaskTool {
                     kind: "text",
                     value: `Task not found: ${args.id}`
                 }],
-                toolResultMessage: ( new MarkdownString(( localize(13885, "Task not found: `{0}`", args.id))))
+                toolResultMessage: ( new MarkdownString(( localize(13960, "Task not found: `{0}`", args.id))))
             };
         }
         const taskLabel = task._label;
@@ -68,7 +68,7 @@ let RunTaskTool = class RunTaskTool {
                     kind: "text",
                     value: `The task ${taskLabel} is already running.`
                 }],
-                toolResultMessage: ( new MarkdownString(( localize(13886, "The task `{0}` is already running.", taskLabel))))
+                toolResultMessage: ( new MarkdownString(( localize(13961, "The task `{0}` is already running.", taskLabel))))
             };
         }
         const dependencyTasks = await resolveDependencyTasks(task, args.workspaceFolder, this._configurationService, this._tasksService);
@@ -94,7 +94,7 @@ let RunTaskTool = class RunTaskTool {
                         kind: "text",
                         value: `Task started but no terminal was found for: ${taskLabel}`
                     }],
-                    toolResultMessage: ( new MarkdownString(( localize(13887, "Task started but no terminal was found for: `{0}`", taskLabel))))
+                    toolResultMessage: ( new MarkdownString(( localize(13962, "Task started but no terminal was found for: `{0}`", taskLabel))))
                 };
             }
             const terminals = this._terminalService.instances.filter(t => ( resources.some(r => r.path === t.resource.path && r.scheme === t.resource.scheme)));
@@ -104,7 +104,7 @@ let RunTaskTool = class RunTaskTool {
                         kind: "text",
                         value: `Task started but no terminal was found for: ${taskLabel}`
                     }],
-                    toolResultMessage: ( new MarkdownString(( localize(13887, "Task started but no terminal was found for: `{0}`", taskLabel))))
+                    toolResultMessage: ( new MarkdownString(( localize(13962, "Task started but no terminal was found for: `{0}`", taskLabel))))
                 };
             }
             const store = ( new DisposableStore());
@@ -179,29 +179,29 @@ let RunTaskTool = class RunTaskTool {
         );
         if (!task) {
             return {
-                invocationMessage: ( new MarkdownString(( localize(13885, "Task not found: `{0}`", args.id))))
+                invocationMessage: ( new MarkdownString(( localize(13960, "Task not found: `{0}`", args.id))))
             };
         }
         const taskLabel = task._label;
         const activeTasks = await this._tasksService.getActiveTasks();
         if (task && activeTasks.includes(task)) {
             return {
-                invocationMessage: ( new MarkdownString(( localize(13888, "The task is already running."))))
+                invocationMessage: ( new MarkdownString(( localize(13963, "The task is already running."))))
             };
         }
         if (await this._isTaskActive(task)) {
             return {
-                invocationMessage: ( new MarkdownString(( localize(13889, "`{0}` is already running.", taskLabel)))),
-                pastTenseMessage: ( new MarkdownString(( localize(13890, "`{0}` was already running.", taskLabel)))),
+                invocationMessage: ( new MarkdownString(( localize(13964, "`{0}` is already running.", taskLabel)))),
+                pastTenseMessage: ( new MarkdownString(( localize(13965, "`{0}` was already running.", taskLabel)))),
                 confirmationMessages: undefined
             };
         }
         return {
-            invocationMessage: ( new MarkdownString(( localize(13891, "Running `{0}`", taskLabel)))),
-            pastTenseMessage: ( new MarkdownString(task?.configurationProperties.isBackground ? ( localize(13892, "Started `{0}`", taskLabel)) : ( localize(13893, "Ran `{0}`", taskLabel)))),
+            invocationMessage: ( new MarkdownString(( localize(13966, "Running `{0}`", taskLabel)))),
+            pastTenseMessage: ( new MarkdownString(task?.configurationProperties.isBackground ? ( localize(13967, "Started `{0}`", taskLabel)) : ( localize(13968, "Ran `{0}`", taskLabel)))),
             confirmationMessages: task ? {
-                title: ( localize(13894, "Allow task run?")),
-                message: ( localize(13895, "Allow to run the task `{0}`?", taskLabel))
+                title: ( localize(13969, "Allow task run?")),
+                message: ( localize(13970, "Allow to run the task `{0}`?", taskLabel))
             } : undefined
         };
     }
@@ -211,9 +211,9 @@ const RunTaskToolData = {
     id: TerminalToolId.RunTask,
     toolReferenceName: "runTask",
     legacyToolReferenceFullNames: ["runTasks/runTask"],
-    displayName: ( localize(13896, "Run Task")),
+    displayName: ( localize(13971, "Run Task")),
     modelDescription: `Runs a VS Code task.\n\n- If you see that an appropriate task exists for building or running code, prefer to use this tool to run the task instead of using the ${TerminalToolId.RunInTerminal} tool.\n- Make sure that any appropriate build or watch task is running before trying to run tests or execute code.\n- If the user asks to run a task, use this tool to do so.`,
-    userDescription: ( localize(13897, "Run tasks in the workspace")),
+    userDescription: ( localize(13972, "Run tasks in the workspace")),
     icon: Codicon.tools,
     source: ToolDataSource.Internal,
     when: TasksAvailableContext,

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

@@ -26,7 +26,7 @@ function toolResultMessageFromResponse(
 ) {
     let resultSummary = "";
     if (result?.exitCode) {
-        resultSummary = ( localize(13898, "Task `{0}` failed with exit code {1}.", taskLabel, result.exitCode));
+        resultSummary = ( localize(13973, "Task `{0}` failed with exit code {1}.", taskLabel, result.exitCode));
     } else {
         resultSummary += `\`${taskLabel}\` task `;
         const problemCount = toolResultDetails.length;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxService.d.ts

@@ -1,3 +1,5 @@
+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 { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
@@ -6,31 +8,79 @@ import { IEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/plat
 import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { IRemoteAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
-import { ITrustedDomainService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/url/common/trustedDomainService.service";
 import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
 import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
 import { ILifecycleService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { ISandboxHelperService } from "@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/sandboxHelperService.service";
+import { TerminalCapability } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
 import { ITerminalSandboxService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxService.service";
 export interface ITerminalSandboxResolvedNetworkDomains {
     allowedDomains: string[];
     deniedDomains: string[];
 }
+export declare enum TerminalSandboxPrerequisiteCheck {
+    Config = "config",
+    Dependencies = "dependencies"
+}
+export interface ITerminalSandboxPrerequisiteCheckResult {
+    enabled: boolean;
+    sandboxConfigPath: string | undefined;
+    failedCheck: TerminalSandboxPrerequisiteCheck | undefined;
+    missingDependencies?: string[];
+}
+/**
+ * Abstraction over terminal operations needed by the install flow.
+ * Provided by the browser-layer caller so the common-layer service
+ * does not import browser types directly.
+ */
+export interface ISandboxDependencyInstallTerminal {
+    sendText(text: string, addNewLine?: boolean): Promise<void>;
+    focus(): void;
+    capabilities: {
+        get(id: TerminalCapability.CommandDetection): {
+            onCommandFinished: Event<{
+                exitCode: number | undefined;
+            }>;
+        } | undefined;
+        onDidAddCapability: Event<{
+            id: TerminalCapability;
+        }>;
+    };
+    onDidInputData: Event<string>;
+    onDisposed: Event<unknown>;
+}
+export interface ISandboxDependencyInstallOptions {
+    /**
+     * Creates or obtains a terminal for running the install command.
+     */
+    createTerminal(): Promise<ISandboxDependencyInstallTerminal>;
+    /**
+     * Focuses the terminal for password entry.
+     */
+    focusTerminal(terminal: ISandboxDependencyInstallTerminal): Promise<void>;
+}
+export interface ISandboxDependencyInstallResult {
+    exitCode: number | undefined;
+}
 export declare class TerminalSandboxService extends Disposable implements ITerminalSandboxService {
     private readonly _configurationService;
     private readonly _fileService;
     private readonly _environmentService;
     private readonly _logService;
     private readonly _remoteAgentService;
-    private readonly _trustedDomainService;
     private readonly _workspaceContextService;
     private readonly _productService;
     private readonly _lifecycleService;
+    private readonly _sandboxHelperService;
+    private readonly _chatService;
     readonly _serviceBrand: undefined;
     private _srtPath;
     private _rgPath;
     private _srtPathResolved;
     private _execPath?;
     private _sandboxConfigPath;
+    private _sandboxDependencyStatus;
     private _needsForceUpdateConfigFile;
     private _tempDir;
     private _sandboxSettingsId;
@@ -40,14 +90,24 @@ export declare class TerminalSandboxService extends Disposable implements ITermi
     private _os;
     private _defaultWritePaths;
     private static readonly _sandboxTempDirName;
-    constructor(_configurationService: IConfigurationService, _fileService: IFileService, _environmentService: IEnvironmentService, _logService: ILogService, _remoteAgentService: IRemoteAgentService, _trustedDomainService: ITrustedDomainService, _workspaceContextService: IWorkspaceContextService, _productService: IProductService, _lifecycleService: ILifecycleService);
+    constructor(_configurationService: IConfigurationService, _fileService: IFileService, _environmentService: IEnvironmentService, _logService: ILogService, _remoteAgentService: IRemoteAgentService, _workspaceContextService: IWorkspaceContextService, _productService: IProductService, _lifecycleService: ILifecycleService, _sandboxHelperService: ISandboxHelperService, _chatService: IChatService);
     isEnabled(): Promise<boolean>;
     getOS(): Promise<OperatingSystem>;
-    wrapCommand(command: string): string;
+    wrapCommand(command: string, requestUnsandboxedExecution?: boolean): string;
     getTempDir(): URI | undefined;
     setNeedsForceUpdateConfigFile(): void;
+    checkForSandboxingPrereqs(forceRefresh?: boolean): Promise<ITerminalSandboxPrerequisiteCheckResult>;
     getSandboxConfigPath(forceRefresh?: boolean): Promise<string | undefined>;
+    private _checkSandboxDependencies;
+    getMissingSandboxDependencies(): Promise<string[]>;
+    installMissingSandboxDependencies(missingDependencies: string[], sessionResource: URI | undefined, token: CancellationToken, options: ISandboxDependencyInstallOptions): Promise<ISandboxDependencyInstallResult>;
+    /**
+     * Shows a chat elicitation that keeps the "Install" flow grounded in chat while
+     * the user focuses the terminal and types a sudo password.
+     */
+    private _createMissingDependencyPasswordPrompt;
     private _quoteShellArgument;
+    private _isSandboxConfiguredEnabled;
     private _resolveSrtPath;
     private _createSandboxConfig;
     private _pathJoin;
@@ -56,6 +116,7 @@ export declare class TerminalSandboxService extends Disposable implements ITermi
     private _getSandboxTempDirPath;
     private _getSandboxWindowTempDirName;
     getResolvedNetworkDomains(): ITerminalSandboxResolvedNetworkDomains;
-    private _addTrustedDomainsToAllowedDomains;
     private _updateAllowWritePathsWithWorkspaceFolders;
+    private _resolveSandboxDependencyStatus;
+    private _getSettingValue;
 }