@codingame/monaco-vscode-katex-common 30.0.1 → 31.0.1

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

@@ -0,0 +1,256 @@
+
+import { Separator } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { coalesce } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { win32, posix } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import { OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { escapeRegExpCharacters } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { isAutoApproveRule } from './tools/commandLineAnalyzer/commandLineAnalyzer.js';
+
+function isPowerShell(envShell, os) {
+    if (os === OperatingSystem.Windows) {
+        return /^(?:powershell|pwsh)(?:-preview)?$/i.test(win32.basename(envShell).replace(/\.exe$/i, ""));
+    }
+    return /^(?:powershell|pwsh)(?:-preview)?$/.test(posix.basename(envShell));
+}
+function isWindowsPowerShell(envShell) {
+    return envShell.endsWith("System32\\WindowsPowerShell\\v1.0\\powershell.exe");
+}
+function isZsh(envShell, os) {
+    if (os === OperatingSystem.Windows) {
+        return /^zsh(?:\.exe)?$/i.test(win32.basename(envShell));
+    }
+    return /^zsh$/.test(posix.basename(envShell));
+}
+function isBash(envShell, os) {
+    if (os === OperatingSystem.Windows) {
+        return /^bash(?:\.exe)?$/i.test(win32.basename(envShell));
+    }
+    return /^bash$/.test(posix.basename(envShell));
+}
+function isFish(envShell, os) {
+    if (os === OperatingSystem.Windows) {
+        return /^fish(?:\.exe)?$/i.test(win32.basename(envShell));
+    }
+    return /^fish$/.test(posix.basename(envShell));
+}
+const TRUNCATION_MESSAGE = "\n\n[... PREVIOUS OUTPUT TRUNCATED ...]\n\n";
+function truncateOutputKeepingTail(output, maxLength) {
+    if (output.length <= maxLength) {
+        return output;
+    }
+    const truncationMessageLength = TRUNCATION_MESSAGE.length;
+    if (truncationMessageLength >= maxLength) {
+        return TRUNCATION_MESSAGE.slice(TRUNCATION_MESSAGE.length - maxLength);
+    }
+    const availableLength = maxLength - truncationMessageLength;
+    const endPortion = output.slice(-availableLength);
+    return TRUNCATION_MESSAGE + endPortion;
+}
+function normalizeTerminalCommandForDisplay(commandLine) {
+    return commandLine.replace(/\\(["'\/])/g, "$1");
+}
+function buildCommandDisplayText(command) {
+    const normalized = normalizeTerminalCommandForDisplay(command).replace(/\r\n|\r|\n/g, " ");
+    return normalized.length > 80 ? normalized.substring(0, 77) + "..." : normalized;
+}
+function normalizeCommandForExecution(command) {
+    return command.replace(/\r\n|\r|\n/g, " ").trim();
+}
+function generateAutoApproveActions(commandLine, subCommands, autoApproveResult) {
+    const actions = [];
+    const canCreateAutoApproval = (autoApproveResult.subCommandResults.every(e => e.result !== "denied") && autoApproveResult.commandLineResult.result !== "denied");
+    if (canCreateAutoApproval) {
+        const unapprovedSubCommands = subCommands.filter((_, index) => {
+            return autoApproveResult.subCommandResults[index].result !== "approved";
+        });
+        const neverAutoApproveCommands = ( new Set([
+        "bash", "sh", "zsh", "fish", "ksh", "csh", "tcsh", "dash", "pwsh", "powershell", "powershell.exe", "cmd", "cmd.exe",
+        "python", "python3", "node", "ruby", "perl", "php", "lua",
+        "eval", "exec", "source", "sudo", "su", "doas",
+        "curl", "wget", "invoke-restmethod", "invoke-webrequest", "irm", "iwr"]));
+        const commandsWithSubcommands = ( new Set([
+            "git",
+            "npm",
+            "npx",
+            "yarn",
+            "docker",
+            "kubectl",
+            "cargo",
+            "dotnet",
+            "mvn",
+            "gradle"
+        ]));
+        const commandsWithSubSubCommands = ( new Set(["npm run", "yarn run"]));
+        const findNextNonFlagArg = (parts, startIndex) => {
+            for (let i = startIndex; i < parts.length; i++) {
+                if (!parts[i].startsWith("-")) {
+                    return i;
+                }
+            }
+            return undefined;
+        };
+        const subCommandsToSuggest = Array.from(( new Set(coalesce(( unapprovedSubCommands.map(command => {
+            const parts = command.trim().split(/\s+/);
+            const baseCommand = parts[0].toLowerCase();
+            if (( neverAutoApproveCommands.has(baseCommand))) {
+                return undefined;
+            }
+            if (( commandsWithSubcommands.has(baseCommand))) {
+                const subCommandIndex = findNextNonFlagArg(parts, 1);
+                if (subCommandIndex !== undefined) {
+                    const baseSubCommand = `${parts[0]} ${parts[subCommandIndex]}`.toLowerCase();
+                    if (( commandsWithSubSubCommands.has(baseSubCommand))) {
+                        const subSubCommandIndex = findNextNonFlagArg(parts, subCommandIndex + 1);
+                        if (subSubCommandIndex !== undefined) {
+                            return parts.slice(0, subSubCommandIndex + 1).join(" ");
+                        }
+                        return undefined;
+                    } else {
+                        return parts.slice(0, subCommandIndex + 1).join(" ");
+                    }
+                }
+                return undefined;
+            } else {
+                return parts[0];
+            }
+        }))))));
+        if (subCommandsToSuggest.length > 0) {
+            let subCommandLabel;
+            if (subCommandsToSuggest.length === 1) {
+                subCommandLabel = `\`${subCommandsToSuggest[0]} \u2026\``;
+            } else {
+                subCommandLabel = `Commands ${( subCommandsToSuggest.map(e => `\`${e} \u2026\``)).join(", ")}`;
+            }
+            actions.push({
+                label: `Allow ${subCommandLabel} in this Session`,
+                data: {
+                    type: "newRule",
+                    rule: ( subCommandsToSuggest.map(key => ({
+                        key,
+                        value: true,
+                        scope: "session"
+                    })))
+                }
+            });
+            actions.push({
+                label: `Allow ${subCommandLabel} in this Workspace`,
+                data: {
+                    type: "newRule",
+                    rule: ( subCommandsToSuggest.map(key => ({
+                        key,
+                        value: true,
+                        scope: "workspace"
+                    })))
+                }
+            });
+            actions.push({
+                label: `Always Allow ${subCommandLabel}`,
+                data: {
+                    type: "newRule",
+                    rule: ( subCommandsToSuggest.map(key => ({
+                        key,
+                        value: true,
+                        scope: "user"
+                    })))
+                }
+            });
+        }
+        if (actions.length > 0) {
+            actions.push(( new Separator()));
+        }
+        const firstSubcommandFirstWord = unapprovedSubCommands.length > 0 ? unapprovedSubCommands[0].split(" ")[0] : "";
+        if (firstSubcommandFirstWord !== commandLine && !( commandsWithSubcommands.has(commandLine)) && !( commandsWithSubSubCommands.has(commandLine))) {
+            actions.push({
+                label: ( localize(13997, "Allow Exact Command Line in this Session")),
+                data: {
+                    type: "newRule",
+                    rule: {
+                        key: `/^${escapeRegExpCharacters(commandLine)}$/`,
+                        value: {
+                            approve: true,
+                            matchCommandLine: true
+                        },
+                        scope: "session"
+                    }
+                }
+            });
+            actions.push({
+                label: ( localize(13998, "Allow Exact Command Line in this Workspace")),
+                data: {
+                    type: "newRule",
+                    rule: {
+                        key: `/^${escapeRegExpCharacters(commandLine)}$/`,
+                        value: {
+                            approve: true,
+                            matchCommandLine: true
+                        },
+                        scope: "workspace"
+                    }
+                }
+            });
+            actions.push({
+                label: ( localize(13999, "Always Allow Exact Command Line")),
+                data: {
+                    type: "newRule",
+                    rule: {
+                        key: `/^${escapeRegExpCharacters(commandLine)}$/`,
+                        value: {
+                            approve: true,
+                            matchCommandLine: true
+                        },
+                        scope: "user"
+                    }
+                }
+            });
+        }
+    }
+    if (actions.length > 0) {
+        actions.push(( new Separator()));
+    }
+    actions.push({
+        label: ( localize(14000, "Allow All Commands in this Session")),
+        tooltip: ( localize(14001, "Allow this tool to run in this session without confirmation.")),
+        data: {
+            type: "sessionApproval"
+        }
+    });
+    actions.push(( new Separator()));
+    actions.push({
+        label: ( localize(14002, "Configure Auto Approve...")),
+        data: {
+            type: "configure"
+        }
+    });
+    return actions;
+}
+function dedupeRules(rules) {
+    return rules.filter((result, index, array) => {
+        if (!isAutoApproveRule(result.rule)) {
+            return false;
+        }
+        const sourceText = result.rule.sourceText;
+        return array.findIndex(r => isAutoApproveRule(r.rule) && r.rule.sourceText === sourceText) === index;
+    });
+}
+function extractCdPrefix(commandLine, shell, os) {
+    const isPwsh = isPowerShell(shell, os);
+    const cdPrefixMatch = commandLine.match(
+        isPwsh ? /^(?:cd(?: \/d)?|Set-Location(?: -Path)?) (?<dir>[^\s]+) ?(?:&&|;)\s+(?<suffix>.+)$/i : /^cd (?<dir>[^\s]+) &&\s+(?<suffix>.+)$/
+    );
+    const cdDir = cdPrefixMatch?.groups?.dir;
+    const cdSuffix = cdPrefixMatch?.groups?.suffix;
+    if (cdDir && cdSuffix) {
+        let cdDirPath = cdDir;
+        if (cdDirPath.startsWith("\"") && cdDirPath.endsWith("\"")) {
+            cdDirPath = cdDirPath.slice(1, -1);
+        }
+        return {
+            directory: cdDirPath,
+            command: cdSuffix
+        };
+    }
+    return undefined;
+}
+
+export { TRUNCATION_MESSAGE, buildCommandDisplayText, dedupeRules, extractCdPrefix, generateAutoApproveActions, isBash, isFish, isPowerShell, isWindowsPowerShell, isZsh, normalizeCommandForExecution, normalizeTerminalCommandForDisplay, truncateOutputKeepingTail };

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

@@ -0,0 +1,42 @@
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import type { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import { ShellIntegrationQuality } from "./toolTerminalCreator.js";
+export declare class RunInTerminalToolTelemetry {
+    private readonly _telemetryService;
+    constructor(_telemetryService: ITelemetryService);
+    logPrepare(state: {
+        terminalToolSessionId: string | undefined;
+        subCommands: string[];
+        autoApproveAllowed: "allowed" | "needsOptIn" | "off";
+        autoApproveResult: "approved" | "denied" | "manual";
+        autoApproveReason: "subCommand" | "commandLine" | undefined;
+        autoApproveDefault: boolean | undefined;
+    }): void;
+    logInvoke(instance: ITerminalInstance, state: {
+        terminalToolSessionId: string | undefined;
+        didUserEditCommand: boolean;
+        didToolEditCommand: boolean;
+        error: string | undefined;
+        isBackground: boolean;
+        isNewSession: boolean;
+        isSandboxWrapped: boolean;
+        requestUnsandboxedExecutionReason: string | undefined;
+        shellIntegrationQuality: ShellIntegrationQuality;
+        outputLineCount: number;
+        timingConnectMs: number;
+        timingExecuteMs: number;
+        pollDurationMs: number | undefined;
+        terminalExecutionIdleBeforeTimeout: boolean | undefined;
+        exitCode: number | undefined;
+        inputUserChars: number;
+        inputUserSigint: boolean;
+        inputToolManualAcceptCount: number | undefined;
+        inputToolManualRejectCount: number | undefined;
+        inputToolManualChars: number | undefined;
+        inputToolAutoAcceptCount: number | undefined;
+        inputToolAutoChars: number | undefined;
+        inputToolManualShownCount: number | undefined;
+        inputToolFreeFormInputShownCount: number | undefined;
+        inputToolFreeFormInputCount: number | undefined;
+    }): void;
+}

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

@@ -0,0 +1,94 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { TelemetryTrustedValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetryUtils';
+import { ShellIntegrationQuality } from './toolTerminalCreator.js';
+
+let RunInTerminalToolTelemetry = class RunInTerminalToolTelemetry {
+    constructor(_telemetryService) {
+        this._telemetryService = _telemetryService;
+    }
+    logPrepare(state) {
+        const subCommandsSanitized = ( state.subCommands.map(e => {
+            const commandName = e.split(" ")[0];
+            let sanitizedCommandName = commandName.toLowerCase();
+            if (!( commandAllowList.has(sanitizedCommandName))) {
+                if (/^(?:[A-Z][a-z0-9]+)+(?:-(?:[A-Z][a-z0-9]+))*$/.test(commandName)) {
+                    sanitizedCommandName = "(unknown:pwsh)";
+                } else if (/^[a-z0-9_\-\.\\\/:;]+$/i.test(commandName)) {
+                    const properties = [];
+                    if (/[a-z]/.test(commandName)) {
+                        properties.push("ascii_lower");
+                    }
+                    if (/[A-Z]/.test(commandName)) {
+                        properties.push("ascii_upper");
+                    }
+                    if (/[0-9]/.test(commandName)) {
+                        properties.push("numeric");
+                    }
+                    const chars = [];
+                    for (const c of [".", "-", "_", "/", "\\", ":", ";"]) {
+                        if (commandName.includes(c)) {
+                            chars.push(c);
+                        }
+                    }
+                    sanitizedCommandName = `(unknown:${properties.join(",")}:${chars.join("")})`;
+                } else if (/[^\x00-\x7F]/.test(commandName)) {
+                    sanitizedCommandName = "(unknown:unicode)";
+                } else {
+                    sanitizedCommandName = "(unknown)";
+                }
+            }
+            return sanitizedCommandName;
+        }));
+        this._telemetryService.publicLog2("toolUse.runInTerminal.prepare", {
+            terminalToolSessionId: state.terminalToolSessionId,
+            subCommands: ( new TelemetryTrustedValue(JSON.stringify(subCommandsSanitized))),
+            autoApproveAllowed: state.autoApproveAllowed,
+            autoApproveResult: state.autoApproveResult,
+            autoApproveReason: state.autoApproveReason,
+            autoApproveDefault: state.autoApproveDefault
+        });
+    }
+    logInvoke(instance, state) {
+        this._telemetryService.publicLog2("toolUse.runInTerminal", {
+            terminalSessionId: instance.sessionId,
+            terminalToolSessionId: state.terminalToolSessionId,
+            result: state.error ?? "success",
+            strategy: state.shellIntegrationQuality === ShellIntegrationQuality.Rich ? 2 : state.shellIntegrationQuality === ShellIntegrationQuality.Basic ? 1 : 0,
+            userEditedCommand: state.didUserEditCommand ? 1 : 0,
+            toolEditedCommand: state.didToolEditCommand ? 1 : 0,
+            isBackground: state.isBackground ? 1 : 0,
+            isNewSession: state.isNewSession ? 1 : 0,
+            isSandbox: state.isSandboxWrapped ? 1 : 0,
+            requestUnsandboxedExecutionReason: state.requestUnsandboxedExecutionReason,
+            outputLineCount: state.outputLineCount,
+            nonZeroExitCode: state.exitCode === undefined ? -1 : state.exitCode === 0 ? 0 : 1,
+            exitCodeValue: state.exitCode ?? -1,
+            timingConnectMs: state.timingConnectMs,
+            timingExecuteMs: state.timingExecuteMs,
+            pollDurationMs: state.pollDurationMs ?? 0,
+            terminalExecutionIdleBeforeTimeout: state.terminalExecutionIdleBeforeTimeout ?? false,
+            inputUserChars: state.inputUserChars,
+            inputUserSigint: state.inputUserSigint,
+            inputToolManualAcceptCount: state.inputToolManualAcceptCount ?? 0,
+            inputToolManualRejectCount: state.inputToolManualRejectCount ?? 0,
+            inputToolManualChars: state.inputToolManualChars ?? 0,
+            inputToolManualShownCount: state.inputToolManualShownCount ?? 0,
+            inputToolFreeFormInputShownCount: state.inputToolFreeFormInputShownCount ?? 0,
+            inputToolFreeFormInputCount: state.inputToolFreeFormInputCount ?? 0
+        });
+    }
+};
+RunInTerminalToolTelemetry = ( __decorate([( __param(0, ITelemetryService))], RunInTerminalToolTelemetry));
+const commandAllowList = ( new Set([
+"!", "@", "#", "$", "%", "^", "&", "*", "(", ")", "~", "{", "}", "<", ">",
+".", "7z", "alias", "assoc", "attrib", "awk", "basename", "bg", "blkid", "bunzip2", "bzip2", "cat", "cd", "certutil", "chkdsk", "chmod", "chown", "cipher", "clear", "cls", "cmp", "column", "comm", "compact", "compress", "copy", "cp", "curl", "cut", "date", "dd", "del", "df", "diff", "dig", "dir", "dirname", "diskpart", "dism", "disown", "du", "echo", "env", "erase", "eval", "expand", "export", "fc", "fdisk", "fg", "file", "find", "findstr", "fmt", "fold", "forfiles", "format", "free", "fsck", "git", "gpupdate", "grep", "groupadd", "groups", "gunzip", "gzip", "hash", "head", "hexdump", "history", "host", "htop", "icacls", "id", "ifconfig", "iostat", "ip", "ipconfig", "iptables", "jobs", "jq", "kill", "killall", "less", "ln", "locate", "ls", "lsblk", "lscpu", "lsof", "man", "mkdir", "mklink", "more", "mount", "move", "mv", "nbtstat", "nc/netcat", "net", "netstat", "nice", "nl", "nohup", "nslookup", "nslookup", "od", "passwd", "paste", "pathping", "pause", "pgrep", "ping", "pkill", "powercfg", "pr", "printenv", "ps", "pwd", "query", "rar", "readlink", "realpath", "reg", "rem", "ren", "rename", "renice", "rev", "rm", "rmdir", "robocopy", "route", "rsync", "sc", "schtasks", "scp", "sed", "seq", "set", "setx", "sfc", "shred", "shuf", "shutdown", "sleep", "sort", "source", "split", "ss", "ssh", "stat", "strings", "su", "subst", "sudo", "systeminfo", "tac", "tail", "tar", "tee", "telnet", "test", "time", "top", "touch", "tr", "traceroute", "tracert", "tree", "true", "truncate", "type", "type", "umask", "umount", "unalias", "uname", "uncompress", "unexpand", "uniq", "unlink", "unrar", "unzip", "uptime", "useradd", "usermod", "vmstat", "vol", "watch", "wc", "wget", "where", "whereis", "which", "who", "whoami", "wmic", "xargs", "xcopy", "xxd", "xz", "yes", "zcat", "zip", "zless", "zmore",
+"bitbucket", "bzr", "cvs", "gh", "git", "glab", "hg", "svn", "fossil", "p4",
+"adb", "ansible", "apk", "apt-get", "apt", "aws", "az", "brew", "bundle", "cargo", "choco", "clang", "cmake", "composer", "conan", "conda", "dnf", "docker-compose", "docker", "dotnet", "emacs", "esbuild", "eslint", "flatpak", "flutter", "fnm", "g++", "gcc", "gcloud", "go", "gradle", "helm", "java", "javac", "jest", "julia", "kotlin", "kubectl", "lua", "make", "mocha", "mvn", "n", "nano", "node", "npm", "nvm", "pacman", "perl", "php", "phpunit", "pip", "pipenv", "pnpm", "pod", "podman", "poetry", "python", "r", "rollup", "ruby", "rustc", "rustup", "snap", "swift", "terraform", "tsc", "tslint", "vagrant", "vcpkg", "vi", "vim", "vite", "vitest", "webpack", "yarn", "yum", "zypper",
+"aider", "amp", "claude", "codex", "copilot", "gemini", "toad", "q",
+"taskkill", "taskkill.exe",
+"add-content", "compare-object", "convertfrom-json", "convertto-json", "copy-item", "format-custom", "format-list", "format-table", "format-wide", "get-childitem", "get-command", "get-content", "get-date", "get-help", "get-location", "get-process", "get-random", "get-service", "invoke-expression", "invoke-restmethod", "invoke-webrequest", "join-path", "measure-command", "measure-object", "move-item", "new-item", "out-file", "remove-item", "restart-computer", "select-object", "select-string", "select-xml", "set-acl", "set-content", "set-itemproperty", "sort-object", "split-path", "start-process", "start-sleep", "stop-process", "test-path", "write-host", "write-output",
+"iex", "irm", "iwr", "rd", "ri", "sp", "spps"]));
+
+export { RunInTerminalToolTelemetry };

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

@@ -0,0 +1,42 @@
+import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import { IAccessibilityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { ITerminalProfile } 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 { type ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import { ITerminalService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+export declare enum ShellIntegrationQuality {
+    None = "none",
+    Basic = "basic",
+    Rich = "rich"
+}
+export interface IToolTerminal {
+    instance: ITerminalInstance;
+    shellIntegrationQuality: ShellIntegrationQuality;
+    receivedUserInput?: boolean;
+    isBackground?: boolean;
+}
+export declare class ToolTerminalCreator {
+    private readonly _accessibilityService;
+    private readonly _configurationService;
+    private readonly _logService;
+    private readonly _terminalService;
+    /**
+     * The shell preference cached for the lifetime of the window. This allows skipping previous
+     * shell approaches that failed in previous runs to save time.
+     */
+    private static _lastSuccessfulShell;
+    constructor(_accessibilityService: IAccessibilityService, _configurationService: IConfigurationService, _logService: ITerminalLogService, _terminalService: ITerminalService);
+    createTerminal(shellOrProfile: string | ITerminalProfile, os: OperatingSystem, token: CancellationToken): Promise<IToolTerminal>;
+    /**
+     * Synchronously update shell integration quality based on the terminal instance's current
+     * capabilities. This is a defensive change to avoid no shell integration being sticky
+     * https://github.com/microsoft/vscode/issues/260880
+     *
+     * Only upgrade quality just in case.
+     */
+    refreshShellIntegrationQuality(toolTerminal: IToolTerminal): void;
+    private _createCopilotTerminal;
+    private _waitForShellIntegration;
+}

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

@@ -0,0 +1,221 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+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 { 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 { isNumber, isObject, hasKey, isString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { IAccessibilityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities';
+import { PromptInputState } from '@codingame/monaco-vscode-api/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 { getShellIntegrationTimeout } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminalEnvironment';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+import { isBash, isZsh, isFish, isPowerShell } from './runInTerminalHelpers.js';
+
+var ToolTerminalCreator_1;
+var ShellLaunchType;
+(function(ShellLaunchType) {
+    ShellLaunchType[ShellLaunchType["Unknown"] = 0] = "Unknown";
+    ShellLaunchType[ShellLaunchType["Default"] = 1] = "Default";
+    ShellLaunchType[ShellLaunchType["Fallback"] = 2] = "Fallback";
+})(ShellLaunchType || (ShellLaunchType = {}));
+var ShellIntegrationQuality;
+(function(ShellIntegrationQuality) {
+    ShellIntegrationQuality["None"] = "none";
+    ShellIntegrationQuality["Basic"] = "basic";
+    ShellIntegrationQuality["Rich"] = "rich";
+})(ShellIntegrationQuality || (ShellIntegrationQuality = {}));
+let ToolTerminalCreator = class ToolTerminalCreator {
+    static {
+        ToolTerminalCreator_1 = this;
+    }
+    static {
+        this._lastSuccessfulShell = ShellLaunchType.Unknown;
+    }
+    constructor(
+        _accessibilityService,
+        _configurationService,
+        _logService,
+        _terminalService
+    ) {
+        this._accessibilityService = _accessibilityService;
+        this._configurationService = _configurationService;
+        this._logService = _logService;
+        this._terminalService = _terminalService;
+    }
+    async createTerminal(shellOrProfile, os, token) {
+        const instance = await this._createCopilotTerminal(shellOrProfile, os);
+        const toolTerminal = {
+            instance,
+            shellIntegrationQuality: ShellIntegrationQuality.None
+        };
+        let processReadyTimestamp = 0;
+        const initResult = await Promise.any([
+            instance.processReady.then(() => processReadyTimestamp = Date.now()),
+            Event.toPromise(instance.onExit)
+        ]);
+        if (!isNumber(initResult) && isObject(initResult) && hasKey(initResult, {
+            message: true
+        })) {
+            throw ( new Error(initResult.message));
+        }
+        const siInjectionEnabled = this._configurationService.getValue(TerminalSettingId.ShellIntegrationEnabled) === true;
+        const waitTime = getShellIntegrationTimeout(
+            this._configurationService,
+            siInjectionEnabled,
+            instance.hasRemoteAuthority,
+            processReadyTimestamp
+        );
+        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`
+                    );
+                    const didStart = await raceTimeout(Event.toPromise(commandDetection.onCommandStarted), 2000);
+                    if (!didStart) {
+                        this._logService.info(
+                            `ToolTerminalCreator#createTerminal: PromptInputModel state did not change within timeout`
+                        );
+                    }
+                }
+            }
+            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;
+    }
+    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(shellOrProfile, os) {
+        const shellPath = isString(shellOrProfile) ? shellOrProfile : shellOrProfile.path;
+        const env = {
+            GIT_PAGER: "cat",
+            GIT_MERGE_AUTOEDIT: "no",
+            GIT_EDITOR: ":"
+        };
+        const preventShellHistory = this._configurationService.getValue(TerminalChatAgentToolsSettingId.PreventShellHistory) === true;
+        if (preventShellHistory) {
+            if (isBash(shellPath, os) || isZsh(shellPath, os) || isFish(shellPath, os) || isPowerShell(shellPath, os)) {
+                env["VSCODE_PREVENT_SHELL_HISTORY"] = "1";
+            }
+        }
+        const config = {
+            icon: ThemeIcon.fromId(Codicon.chatSparkle.id),
+            hideFromUser: true,
+            forcePersist: true,
+            env
+        };
+        if (isString(shellOrProfile)) {
+            config.executable = shellOrProfile;
+        } else {
+            config.executable = shellOrProfile.path;
+            config.args = shellOrProfile.args;
+            config.icon = shellOrProfile.icon ?? config.icon;
+            config.color = shellOrProfile.color;
+            config.env = {
+                ...config.env,
+                ...shellOrProfile.env
+            };
+        }
+        return this._terminalService.createTerminal({
+            config
+        });
+    }
+    _waitForShellIntegration(instance, timeoutMs) {
+        const store = ( new DisposableStore());
+        const result = ( new DeferredPromise());
+        const isScreenReaderOptimized = this._accessibilityService.isScreenReaderOptimized();
+        const effectiveTimeoutMs = timeoutMs > 0 && isScreenReaderOptimized ? timeoutMs + 3000 : timeoutMs;
+        this._logService.info(
+            `ToolTerminalCreator#_waitForShellIntegration: base ${timeoutMs}ms, effective ${effectiveTimeoutMs}ms, screenReaderOptimized=${isScreenReaderOptimized}`
+        );
+        const siNoneTimer = store.add(( new MutableDisposable()));
+        siNoneTimer.value = disposableTimeout(() => {
+            this._logService.info(
+                `ToolTerminalCreator#_waitForShellIntegration: Timed out ${effectiveTimeoutMs}ms, using no SI`
+            );
+            result.complete(ShellIntegrationQuality.None);
+        }, effectiveTimeoutMs);
+        if (instance.capabilities.get(TerminalCapability.CommandDetection)?.hasRichCommandDetection) {
+            siNoneTimer.clear();
+            this._logService.info(
+                `ToolTerminalCreator#_waitForShellIntegration: Rich SI available immediately`
+            );
+            result.complete(ShellIntegrationQuality.Rich);
+        } else {
+            const onSetRichCommandDetection = store.add(
+                this._terminalService.createOnInstanceCapabilityEvent(TerminalCapability.CommandDetection, e => e.onSetRichCommandDetection)
+            );
+            store.add(onSetRichCommandDetection.event(e => {
+                if (e.instance !== instance) {
+                    return;
+                }
+                siNoneTimer.clear();
+                this._logService.info(
+                    `ToolTerminalCreator#_waitForShellIntegration: Rich SI available eventually`
+                );
+                result.complete(ShellIntegrationQuality.Rich);
+            }));
+            const commandDetection = instance.capabilities.get(TerminalCapability.CommandDetection);
+            if (commandDetection) {
+                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.onDidAddCommandDetectionCapability(e => {
+                    siNoneTimer.clear();
+                    store.add(disposableTimeout(() => {
+                        this._logService.info(
+                            `ToolTerminalCreator#_waitForShellIntegration: Timed out 200ms, using basic SI (via listener)`
+                        );
+                        result.complete(ShellIntegrationQuality.Basic);
+                    }, 200));
+                }));
+            }
+        }
+        result.p.finally(() => {
+            this._logService.info(
+                `ToolTerminalCreator#_waitForShellIntegration: Promise complete, disposing store`
+            );
+            store.dispose();
+        });
+        return result.p;
+    }
+};
+ToolTerminalCreator = ToolTerminalCreator_1 = ( __decorate([( __param(0, IAccessibilityService)), ( __param(1, IConfigurationService)), ( __param(2, ITerminalLogService)), ( __param(3, ITerminalService))], ToolTerminalCreator));
+
+export { ShellIntegrationQuality, ToolTerminalCreator };