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

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

@@ -0,0 +1,106 @@
+
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+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/tools/languageModelToolsService';
+import { RunInTerminalTool } from './runInTerminalTool.js';
+import { TerminalToolId } from './toolIds.js';
+import { timeout, raceCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+
+const AwaitTerminalToolData = {
+    id: TerminalToolId.AwaitTerminal,
+    toolReferenceName: "awaitTerminal",
+    displayName: ( localize(12350, "Await Terminal")),
+    modelDescription: "Wait for a background terminal command to complete. Returns the output, exit code, or timeout status.",
+    icon: Codicon.terminal,
+    source: ToolDataSource.Internal,
+    inputSchema: {
+        type: "object",
+        properties: {
+            id: {
+                type: "string",
+                description: `The ID of the terminal to await (returned by ${TerminalToolId.RunInTerminal} when isBackground=true).`
+            },
+            timeout: {
+                type: "number",
+                description: "Timeout in milliseconds. If the command does not complete within this time, returns the output collected so far with a timeout indicator. Use 0 for no timeout."
+            }
+        },
+        required: ["id", "timeout"]
+    }
+};
+class AwaitTerminalTool extends Disposable {
+    async prepareToolInvocation(_context, _token) {
+        return {
+            invocationMessage: ( localize(12351, "Awaiting terminal completion")),
+            pastTenseMessage: ( localize(12352, "Awaited terminal completion"))
+        };
+    }
+    async invoke(invocation, _countTokens, _progress, token) {
+        const args = invocation.parameters;
+        const execution = RunInTerminalTool.getExecution(args.id);
+        if (!execution) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: `Error: No active terminal execution found with ID ${args.id}. The terminal may have already completed or the ID is invalid.`
+                }]
+            };
+        }
+        try {
+            let result;
+            const timeoutMs = Math.max(0, args.timeout);
+            const hasTimeout = timeoutMs > 0;
+            if (hasTimeout) {
+                const timeoutPromise = timeout(timeoutMs).then(() => ({
+                    type: "timeout"
+                }));
+                const completionPromise = raceCancellationError(execution.completionPromise, token).then(r => ({
+                    type: "completed",
+                    result: r
+                }));
+                const raceResult = await Promise.race([completionPromise, timeoutPromise]);
+                if (raceResult.type === "timeout") {
+                    const partialOutput = execution.getOutput();
+                    return {
+                        toolMetadata: {
+                            exitCode: undefined,
+                            timedOut: true
+                        },
+                        content: [{
+                            kind: "text",
+                            value: `Terminal ${args.id} timed out after ${timeoutMs}ms. Output collected so far:\n${partialOutput}`
+                        }]
+                    };
+                }
+                result = raceResult.result;
+            } else {
+                result = await raceCancellationError(execution.completionPromise, token);
+            }
+            const output = execution.getOutput();
+            const exitCodeText = result.exitCode !== undefined ? ` (exit code: ${result.exitCode})` : "";
+            return {
+                toolMetadata: {
+                    exitCode: result.exitCode
+                },
+                content: [{
+                    kind: "text",
+                    value: `Terminal ${args.id} completed${exitCodeText}:\n${output}`
+                }]
+            };
+        } catch (e) {
+            if (e instanceof CancellationError) {
+                throw e;
+            }
+            return {
+                content: [{
+                    kind: "text",
+                    value: `Error awaiting terminal ${args.id}: ${e instanceof Error ? e.message : String(e)}`
+                }]
+            };
+        }
+    }
+}
+
+export { AwaitTerminalTool, AwaitTerminalToolData };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.d.ts

@@ -21,8 +21,8 @@ export declare class CommandLineAutoApprover extends Disposable {
     private readonly _npmScriptAutoApprover;
     constructor(_configurationService: IConfigurationService, instantiationService: IInstantiationService, _terminalChatService: ITerminalChatService);
     updateConfiguration(): void;
-    isCommandAutoApproved(command: string, shell: string, os: OperatingSystem, cwd: URI | undefined, chatSessionId?: string): Promise<ICommandApprovalResultWithReason>;
-    isCommandLineAutoApproved(commandLine: string, chatSessionId?: string): ICommandApprovalResultWithReason;
+    isCommandAutoApproved(command: string, shell: string, os: OperatingSystem, cwd: URI | undefined, chatSessionResource?: URI): Promise<ICommandApprovalResultWithReason>;
+    isCommandLineAutoApproved(commandLine: string, chatSessionResource?: URI): ICommandApprovalResultWithReason;
     private _getSessionRules;
     private _commandMatchesRule;
     private _mapAutoApproveConfigToRules;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.js

@@ -26,9 +26,7 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
         this._npmScriptAutoApprover = this._register(instantiationService.createInstance(NpmScriptAutoApprover));
         this.updateConfiguration();
         this._register(this._configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration(TerminalChatAgentToolsSettingId.AutoApprove) ||
-                e.affectsConfiguration(TerminalChatAgentToolsSettingId.IgnoreDefaultAutoApproveRules) ||
-                e.affectsConfiguration(TerminalChatAgentToolsSettingId.DeprecatedAutoApproveCompatible)) {
+            if (e.affectsConfiguration(TerminalChatAgentToolsSettingId.AutoApprove) || e.affectsConfiguration(TerminalChatAgentToolsSettingId.IgnoreDefaultAutoApproveRules) || e.affectsConfiguration(TerminalChatAgentToolsSettingId.DeprecatedAutoApproveCompatible)) {
                 this.updateConfiguration();
             }
         }));
@@ -37,38 +35,43 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
         let configValue = this._configurationService.getValue(TerminalChatAgentToolsSettingId.AutoApprove);
         const configInspectValue = this._configurationService.inspect(TerminalChatAgentToolsSettingId.AutoApprove);
         const deprecatedValue = this._configurationService.getValue(TerminalChatAgentToolsSettingId.DeprecatedAutoApproveCompatible);
-        if (deprecatedValue && typeof deprecatedValue === 'object' && configValue && typeof configValue === 'object') {
+        if (deprecatedValue && typeof deprecatedValue === "object" && configValue && typeof configValue === "object") {
             configValue = {
                 ...configValue,
                 ...deprecatedValue
             };
         }
-        const { denyListRules, allowListRules, allowListCommandLineRules, denyListCommandLineRules } = this._mapAutoApproveConfigToRules(configValue, configInspectValue);
+        const {
+            denyListRules,
+            allowListRules,
+            allowListCommandLineRules,
+            denyListCommandLineRules
+        } = this._mapAutoApproveConfigToRules(configValue, configInspectValue);
         this._allowListRules = allowListRules;
         this._denyListRules = denyListRules;
         this._allowListCommandLineRules = allowListCommandLineRules;
         this._denyListCommandLineRules = denyListCommandLineRules;
     }
-    async isCommandAutoApproved(command, shell, os, cwd, chatSessionId) {
+    async isCommandAutoApproved(command, shell, os, cwd, chatSessionResource) {
         if (transientEnvVarRegex.test(command)) {
             return {
-                result: 'denied',
+                result: "denied",
                 reason: `Command '${command}' is denied because it contains transient environment variables`
             };
         }
         for (const rule of this._denyListRules) {
             if (this._commandMatchesRule(rule, command, shell, os)) {
                 return {
-                    result: 'denied',
+                    result: "denied",
                     rule,
                     reason: `Command '${command}' is denied by deny list rule: ${rule.sourceText}`
                 };
             }
         }
-        for (const rule of this._getSessionRules(chatSessionId).allowListRules) {
+        for (const rule of this._getSessionRules(chatSessionResource).allowListRules) {
             if (this._commandMatchesRule(rule, command, shell, os)) {
                 return {
-                    result: 'approved',
+                    result: "approved",
                     rule,
                     reason: `Command '${command}' is approved by session allow list rule: ${rule.sourceText}`
                 };
@@ -77,7 +80,7 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
         for (const rule of this._allowListRules) {
             if (this._commandMatchesRule(rule, command, shell, os)) {
                 return {
-                    result: 'approved',
+                    result: "approved",
                     rule,
                     reason: `Command '${command}' is approved by allow list rule: ${rule.sourceText}`
                 };
@@ -86,30 +89,33 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
         const npmScriptResult = await this._npmScriptAutoApprover.isCommandAutoApproved(command, cwd);
         if (npmScriptResult.isAutoApproved) {
             return {
-                result: 'approved',
-                rule: { type: 'npmScript', npmScriptResult },
+                result: "approved",
+                rule: {
+                    type: "npmScript",
+                    npmScriptResult
+                },
                 reason: `Command '${command}' is approved as npm script '${npmScriptResult.scriptName}' is defined in package.json`
             };
         }
         return {
-            result: 'noMatch',
+            result: "noMatch",
             reason: `Command '${command}' has no matching auto approve entries`
         };
     }
-    isCommandLineAutoApproved(commandLine, chatSessionId) {
+    isCommandLineAutoApproved(commandLine, chatSessionResource) {
         for (const rule of this._denyListCommandLineRules) {
             if (rule.regex.test(commandLine)) {
                 return {
-                    result: 'denied',
+                    result: "denied",
                     rule,
                     reason: `Command line '${commandLine}' is denied by deny list rule: ${rule.sourceText}`
                 };
             }
         }
-        for (const rule of this._getSessionRules(chatSessionId).allowListCommandLineRules) {
+        for (const rule of this._getSessionRules(chatSessionResource).allowListCommandLineRules) {
             if (rule.regex.test(commandLine)) {
                 return {
-                    result: 'approved',
+                    result: "approved",
                     rule,
                     reason: `Command line '${commandLine}' is approved by session allow list rule: ${rule.sourceText}`
                 };
@@ -118,67 +124,113 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
         for (const rule of this._allowListCommandLineRules) {
             if (rule.regex.test(commandLine)) {
                 return {
-                    result: 'approved',
+                    result: "approved",
                     rule,
                     reason: `Command line '${commandLine}' is approved by allow list rule: ${rule.sourceText}`
                 };
             }
         }
         return {
-            result: 'noMatch',
+            result: "noMatch",
             reason: `Command line '${commandLine}' has no matching auto approve entries`
         };
     }
-    _getSessionRules(chatSessionId) {
+    _getSessionRules(chatSessionResource) {
         const denyListRules = [];
         const allowListRules = [];
         const allowListCommandLineRules = [];
         const denyListCommandLineRules = [];
-        if (!chatSessionId) {
-            return { denyListRules, allowListRules, allowListCommandLineRules, denyListCommandLineRules };
+        if (!chatSessionResource) {
+            return {
+                denyListRules,
+                allowListRules,
+                allowListCommandLineRules,
+                denyListCommandLineRules
+            };
         }
-        const sessionRulesConfig = this._terminalChatService.getSessionAutoApproveRules(chatSessionId);
+        const sessionRulesConfig = this._terminalChatService.getSessionAutoApproveRules(chatSessionResource);
         for (const [key, value] of Object.entries(sessionRulesConfig)) {
-            if (typeof value === 'boolean') {
-                const { regex, regexCaseInsensitive } = this._convertAutoApproveEntryToRegex(key);
+            if (typeof value === "boolean") {
+                const {
+                    regex,
+                    regexCaseInsensitive
+                } = this._convertAutoApproveEntryToRegex(key);
                 if (value === true) {
-                    allowListRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget: 'session', isDefaultRule: false });
-                }
-                else if (value === false) {
-                    denyListRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget: 'session', isDefaultRule: false });
+                    allowListRules.push({
+                        regex,
+                        regexCaseInsensitive,
+                        sourceText: key,
+                        sourceTarget: "session",
+                        isDefaultRule: false
+                    });
+                } else if (value === false) {
+                    denyListRules.push({
+                        regex,
+                        regexCaseInsensitive,
+                        sourceText: key,
+                        sourceTarget: "session",
+                        isDefaultRule: false
+                    });
                 }
-            }
-            else if (typeof value === 'object' && value !== null) {
+            } else if (typeof value === "object" && value !== null) {
                 const objectValue = value;
-                if (typeof objectValue.approve === 'boolean') {
-                    const { regex, regexCaseInsensitive } = this._convertAutoApproveEntryToRegex(key);
+                if (typeof objectValue.approve === "boolean") {
+                    const {
+                        regex,
+                        regexCaseInsensitive
+                    } = this._convertAutoApproveEntryToRegex(key);
                     if (objectValue.approve === true) {
                         if (objectValue.matchCommandLine === true) {
-                            allowListCommandLineRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget: 'session', isDefaultRule: false });
-                        }
-                        else {
-                            allowListRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget: 'session', isDefaultRule: false });
+                            allowListCommandLineRules.push({
+                                regex,
+                                regexCaseInsensitive,
+                                sourceText: key,
+                                sourceTarget: "session",
+                                isDefaultRule: false
+                            });
+                        } else {
+                            allowListRules.push({
+                                regex,
+                                regexCaseInsensitive,
+                                sourceText: key,
+                                sourceTarget: "session",
+                                isDefaultRule: false
+                            });
                         }
-                    }
-                    else if (objectValue.approve === false) {
+                    } else if (objectValue.approve === false) {
                         if (objectValue.matchCommandLine === true) {
-                            denyListCommandLineRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget: 'session', isDefaultRule: false });
-                        }
-                        else {
-                            denyListRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget: 'session', isDefaultRule: false });
+                            denyListCommandLineRules.push({
+                                regex,
+                                regexCaseInsensitive,
+                                sourceText: key,
+                                sourceTarget: "session",
+                                isDefaultRule: false
+                            });
+                        } else {
+                            denyListRules.push({
+                                regex,
+                                regexCaseInsensitive,
+                                sourceText: key,
+                                sourceTarget: "session",
+                                isDefaultRule: false
+                            });
                         }
                     }
                 }
             }
         }
-        return { denyListRules, allowListRules, allowListCommandLineRules, denyListCommandLineRules };
+        return {
+            denyListRules,
+            allowListRules,
+            allowListCommandLineRules,
+            denyListCommandLineRules
+        };
     }
     _commandMatchesRule(rule, command, shell, os) {
         const isPwsh = isPowerShell(shell, os);
         if ((isPwsh ? rule.regexCaseInsensitive : rule.regex).test(command)) {
             return true;
-        }
-        else if (isPwsh && command.startsWith('(')) {
+        } else if (isPwsh && command.startsWith("(")) {
             if (rule.regexCaseInsensitive.test(command.slice(1))) {
                 return true;
             }
@@ -186,7 +238,7 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
         return false;
     }
     _mapAutoApproveConfigToRules(config, configInspectValue) {
-        if (!config || typeof config !== 'object') {
+        if (!config || typeof config !== "object") {
             return {
                 denyListRules: [],
                 allowListRules: [],
@@ -201,51 +253,78 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
         const ignoreDefaults = this._configurationService.getValue(TerminalChatAgentToolsSettingId.IgnoreDefaultAutoApproveRules) === true;
         for (const [key, value] of Object.entries(config)) {
             const defaultValue = configInspectValue?.default?.value;
-            const isDefaultRule = !!(isObject(defaultValue) &&
-                Object.prototype.hasOwnProperty.call(defaultValue, key) &&
-                structuralEquals(defaultValue[key], value));
+            const isDefaultRule = !!(isObject(defaultValue) && Object.prototype.hasOwnProperty.call(defaultValue, key) && structuralEquals(defaultValue[key], value));
             function checkTarget(inspectValue) {
-                return (isObject(inspectValue) &&
-                    Object.prototype.hasOwnProperty.call(inspectValue, key) &&
-                    structuralEquals(inspectValue[key], value));
+                return (isObject(inspectValue) && Object.prototype.hasOwnProperty.call(inspectValue, key) && structuralEquals(inspectValue[key], value));
             }
-            const sourceTarget = (checkTarget(configInspectValue.workspaceFolder) ? ConfigurationTarget.WORKSPACE_FOLDER
-                : checkTarget(configInspectValue.workspaceValue) ? ConfigurationTarget.WORKSPACE
-                    : checkTarget(configInspectValue.userRemoteValue) ? ConfigurationTarget.USER_REMOTE
-                        : checkTarget(configInspectValue.userLocalValue) ? ConfigurationTarget.USER_LOCAL
-                            : checkTarget(configInspectValue.userValue) ? ConfigurationTarget.USER
-                                : checkTarget(configInspectValue.applicationValue) ? ConfigurationTarget.APPLICATION
-                                    : ConfigurationTarget.DEFAULT);
+            const sourceTarget = (checkTarget(configInspectValue.workspaceFolder) ? ConfigurationTarget.WORKSPACE_FOLDER : checkTarget(configInspectValue.workspaceValue) ? ConfigurationTarget.WORKSPACE : checkTarget(configInspectValue.userRemoteValue) ? ConfigurationTarget.USER_REMOTE : checkTarget(configInspectValue.userLocalValue) ? ConfigurationTarget.USER_LOCAL : checkTarget(configInspectValue.userValue) ? ConfigurationTarget.USER : checkTarget(configInspectValue.applicationValue) ? ConfigurationTarget.APPLICATION : ConfigurationTarget.DEFAULT);
             if (ignoreDefaults && isDefaultRule && sourceTarget === ConfigurationTarget.DEFAULT) {
                 continue;
             }
-            if (typeof value === 'boolean') {
-                const { regex, regexCaseInsensitive } = this._convertAutoApproveEntryToRegex(key);
+            if (typeof value === "boolean") {
+                const {
+                    regex,
+                    regexCaseInsensitive
+                } = this._convertAutoApproveEntryToRegex(key);
                 if (value === true) {
-                    allowListRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget, isDefaultRule });
+                    allowListRules.push({
+                        regex,
+                        regexCaseInsensitive,
+                        sourceText: key,
+                        sourceTarget,
+                        isDefaultRule
+                    });
+                } else if (value === false) {
+                    denyListRules.push({
+                        regex,
+                        regexCaseInsensitive,
+                        sourceText: key,
+                        sourceTarget,
+                        isDefaultRule
+                    });
                 }
-                else if (value === false) {
-                    denyListRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget, isDefaultRule });
-                }
-            }
-            else if (typeof value === 'object' && value !== null) {
+            } else if (typeof value === "object" && value !== null) {
                 const objectValue = value;
-                if (typeof objectValue.approve === 'boolean') {
-                    const { regex, regexCaseInsensitive } = this._convertAutoApproveEntryToRegex(key);
+                if (typeof objectValue.approve === "boolean") {
+                    const {
+                        regex,
+                        regexCaseInsensitive
+                    } = this._convertAutoApproveEntryToRegex(key);
                     if (objectValue.approve === true) {
                         if (objectValue.matchCommandLine === true) {
-                            allowListCommandLineRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget, isDefaultRule });
-                        }
-                        else {
-                            allowListRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget, isDefaultRule });
+                            allowListCommandLineRules.push({
+                                regex,
+                                regexCaseInsensitive,
+                                sourceText: key,
+                                sourceTarget,
+                                isDefaultRule
+                            });
+                        } else {
+                            allowListRules.push({
+                                regex,
+                                regexCaseInsensitive,
+                                sourceText: key,
+                                sourceTarget,
+                                isDefaultRule
+                            });
                         }
-                    }
-                    else if (objectValue.approve === false) {
+                    } else if (objectValue.approve === false) {
                         if (objectValue.matchCommandLine === true) {
-                            denyListCommandLineRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget, isDefaultRule });
-                        }
-                        else {
-                            denyListRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget, isDefaultRule });
+                            denyListCommandLineRules.push({
+                                regex,
+                                regexCaseInsensitive,
+                                sourceText: key,
+                                sourceTarget,
+                                isDefaultRule
+                            });
+                        } else {
+                            denyListRules.push({
+                                regex,
+                                regexCaseInsensitive,
+                                sourceText: key,
+                                sourceTarget,
+                                isDefaultRule
+                            });
                         }
                     }
                 }
@@ -260,10 +339,16 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
     }
     _convertAutoApproveEntryToRegex(value) {
         const regex = this._doConvertAutoApproveEntryToRegex(value);
-        if (regex.flags.includes('i')) {
-            return { regex, regexCaseInsensitive: regex };
+        if (regex.flags.includes("i")) {
+            return {
+                regex,
+                regexCaseInsensitive: regex
+            };
         }
-        return { regex, regexCaseInsensitive: ( new RegExp(regex.source, regex.flags + 'i')) };
+        return {
+            regex,
+            regexCaseInsensitive: ( new RegExp(regex.source, regex.flags + "i"))
+        };
     }
     _doConvertAutoApproveEntryToRegex(value) {
         const regexMatch = value.match(/^\/(?<pattern>.+)\/(?<flags>[dgimsuvy]*)$/);
@@ -271,9 +356,9 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
         if (regexPattern) {
             let flags = regexMatch.groups?.flags;
             if (flags) {
-                flags = flags.replaceAll('g', '');
+                flags = flags.replaceAll("g", "");
             }
-            if (regexPattern === '.*') {
+            if (regexPattern === ".*") {
                 return ( new RegExp(regexPattern));
             }
             try {
@@ -282,19 +367,18 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
                     return neverMatchRegex;
                 }
                 return regex;
-            }
-            catch (error) {
+            } catch (error) {
                 return neverMatchRegex;
             }
         }
-        if (value === '') {
+        if (value === "") {
             return neverMatchRegex;
         }
         let sanitizedValue;
-        if (value.includes('/') || value.includes('\\')) {
-            let pattern = value.replace(/[/\\]/g, '%%PATH_SEP%%');
+        if (value.includes("/") || value.includes("\\")) {
+            let pattern = value.replace(/[/\\]/g, "%%PATH_SEP%%");
             pattern = escapeRegExpCharacters(pattern);
-            pattern = pattern.replace(/%%PATH_SEP%%*/g, '[/\\\\]');
+            pattern = pattern.replace(/%%PATH_SEP%%*/g, "[/\\\\]");
             sanitizedValue = `^(?:\\.[/\\\\])?${pattern}`;
         }
         else {
@@ -303,10 +387,6 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
         return ( new RegExp(`^${sanitizedValue}\\b`));
     }
 };
-CommandLineAutoApprover = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, IInstantiationService)),
-    ( __param(2, ITerminalChatService))
-], CommandLineAutoApprover));
+CommandLineAutoApprover = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IInstantiationService)), ( __param(2, ITerminalChatService))], CommandLineAutoApprover));
 
 export { CommandLineAutoApprover };