@codingame/monaco-vscode-xterm-common 33.0.9 → 34.0.1

package/vscode/src/vs/workbench/contrib/terminal/common/terminalEnvironment.js

@@ -0,0 +1,321 @@
+
+import { isAbsolute, join, basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import { URI, uriToFsPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { sanitizeProcessEnvironment } from '@codingame/monaco-vscode-api/vscode/vs/base/common/processes';
+import { WindowsShellType, TerminalSettingId, ShellIntegrationTimeoutOverride } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal';
+import { isWindows, isMacintosh, language, OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { sanitizeCwd, escapeNonWindowsPath } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminalEnvironment';
+import { isString, isNumber } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+
+function mergeEnvironments(parent, other) {
+    if (!other) {
+        return;
+    }
+    if (isWindows) {
+        for (const configKey in other) {
+            let actualKey = configKey;
+            for (const envKey in parent) {
+                if (configKey.toLowerCase() === envKey.toLowerCase()) {
+                    actualKey = envKey;
+                    break;
+                }
+            }
+            const value = other[configKey];
+            if (value !== undefined) {
+                _mergeEnvironmentValue(parent, actualKey, value);
+            }
+        }
+    } else {
+        ( Object.keys(other)).forEach(key => {
+            const value = other[key];
+            if (value !== undefined) {
+                _mergeEnvironmentValue(parent, key, value);
+            }
+        });
+    }
+}
+function _mergeEnvironmentValue(env, key, value) {
+    if (isString(value)) {
+        env[key] = value;
+    } else {
+        delete env[key];
+    }
+}
+function addTerminalEnvironmentKeys(env, version, locale, detectLocale) {
+    env["TERM_PROGRAM"] = "vscode";
+    if (version) {
+        env["TERM_PROGRAM_VERSION"] = version;
+    }
+    if (shouldSetLangEnvVariable(env, detectLocale)) {
+        env["LANG"] = getLangEnvVariable(locale);
+    }
+    env["COLORTERM"] = "truecolor";
+}
+function mergeNonNullKeys(env, other) {
+    if (!other) {
+        return;
+    }
+    for (const key of ( Object.keys(other))) {
+        const value = other[key];
+        if (value !== undefined && value !== null) {
+            env[key] = value;
+        }
+    }
+}
+async function resolveConfigurationVariables(variableResolver, env) {
+    await Promise.all(( Object.entries(env).map(async ([key, value]) => {
+        if (isString(value)) {
+            try {
+                env[key] = await variableResolver(value);
+            } catch (e) {
+                env[key] = value;
+            }
+        }
+    })));
+    return env;
+}
+function shouldSetLangEnvVariable(env, detectLocale) {
+    if (detectLocale === "on") {
+        return true;
+    }
+    if (detectLocale === "auto") {
+        const lang = env["LANG"];
+        return !lang || (lang.search(/\.UTF\-8$/) === -1 && lang.search(/\.utf8$/) === -1 && lang.search(/\.euc.+/) === -1);
+    }
+    return false;
+}
+function getLangEnvVariable(locale) {
+    const parts = locale ? locale.split("-") : [];
+    const n = parts.length;
+    if (n === 0) {
+        return "en_US.UTF-8";
+    }
+    if (n === 1) {
+        const languageVariants = {
+            af: "ZA",
+            am: "ET",
+            be: "BY",
+            bg: "BG",
+            ca: "ES",
+            cs: "CZ",
+            da: "DK",
+            de: "DE",
+            el: "GR",
+            en: "US",
+            es: "ES",
+            et: "EE",
+            eu: "ES",
+            fi: "FI",
+            fr: "FR",
+            he: "IL",
+            hr: "HR",
+            hu: "HU",
+            hy: "AM",
+            is: "IS",
+            it: "IT",
+            ja: "JP",
+            kk: "KZ",
+            ko: "KR",
+            lt: "LT",
+            nl: "NL",
+            no: "NO",
+            pl: "PL",
+            pt: "BR",
+            ro: "RO",
+            ru: "RU",
+            sk: "SK",
+            sl: "SI",
+            sr: "YU",
+            sv: "SE",
+            tr: "TR",
+            uk: "UA",
+            zh: "CN"
+        };
+        if (Object.prototype.hasOwnProperty.call(languageVariants, parts[0])) {
+            parts.push(languageVariants[parts[0]]);
+        }
+    } else {
+        parts[1] = parts[1].toUpperCase();
+    }
+    return parts.join("_") + ".UTF-8";
+}
+async function getCwd(shell, userHome, variableResolver, root, customCwd, logService) {
+    if (shell.cwd) {
+        const unresolved = (typeof shell.cwd === "object") ? shell.cwd.fsPath : shell.cwd;
+        const resolved = await _resolveCwd(unresolved, variableResolver);
+        return sanitizeCwd(resolved || unresolved);
+    }
+    let cwd;
+    if (!shell.ignoreConfigurationCwd && customCwd) {
+        if (variableResolver) {
+            customCwd = await _resolveCwd(customCwd, variableResolver, logService);
+        }
+        if (customCwd) {
+            if (isAbsolute(customCwd)) {
+                cwd = customCwd;
+            } else if (root) {
+                cwd = join(root.fsPath, customCwd);
+            }
+        }
+    }
+    if (!cwd) {
+        cwd = root ? root.fsPath : userHome || "";
+    }
+    return sanitizeCwd(cwd);
+}
+async function _resolveCwd(cwd, variableResolver, logService) {
+    if (variableResolver) {
+        try {
+            return await variableResolver(cwd);
+        } catch (e) {
+            logService?.error("Could not resolve terminal cwd", e);
+            return undefined;
+        }
+    }
+    return cwd;
+}
+function createVariableResolver(lastActiveWorkspace, env, configurationResolverService) {
+    if (!configurationResolverService) {
+        return undefined;
+    }
+    return str => configurationResolverService.resolveWithEnvironment(env, lastActiveWorkspace, str);
+}
+async function createTerminalEnvironment(
+    shellLaunchConfig,
+    envFromConfig,
+    variableResolver,
+    version,
+    detectLocale,
+    baseEnv
+) {
+    const env = {};
+    if (shellLaunchConfig.strictEnv) {
+        mergeNonNullKeys(env, shellLaunchConfig.env);
+    } else {
+        mergeNonNullKeys(env, baseEnv);
+        const allowedEnvFromConfig = {
+            ...envFromConfig
+        };
+        if (variableResolver) {
+            if (allowedEnvFromConfig) {
+                await resolveConfigurationVariables(variableResolver, allowedEnvFromConfig);
+            }
+            if (shellLaunchConfig.env) {
+                await resolveConfigurationVariables(variableResolver, shellLaunchConfig.env);
+            }
+        }
+        if (isMacintosh) {
+            if (env["VSCODE_NODE_OPTIONS"]) {
+                env["NODE_OPTIONS"] = env["VSCODE_NODE_OPTIONS"];
+                delete env["VSCODE_NODE_OPTIONS"];
+            }
+            if (env["VSCODE_NODE_REPL_EXTERNAL_MODULE"]) {
+                env["NODE_REPL_EXTERNAL_MODULE"] = env["VSCODE_NODE_REPL_EXTERNAL_MODULE"];
+                delete env["VSCODE_NODE_REPL_EXTERNAL_MODULE"];
+            }
+        }
+        sanitizeProcessEnvironment(env, "VSCODE_IPC_HOOK_CLI");
+        mergeEnvironments(env, allowedEnvFromConfig);
+        mergeEnvironments(env, shellLaunchConfig.env);
+        addTerminalEnvironmentKeys(env, version, language, detectLocale);
+    }
+    return env;
+}
+async function preparePathForShell(
+    resource,
+    executable,
+    title,
+    shellType,
+    backend,
+    os,
+    isWindowsFrontend = isWindows
+) {
+    let originalPath;
+    if (isString(resource)) {
+        originalPath = resource;
+    } else {
+        originalPath = resource.fsPath;
+        if (isWindowsFrontend && os !== OperatingSystem.Windows) {
+            originalPath = originalPath.replace(/\\/g, "/");
+        } else if (!isWindowsFrontend && os === OperatingSystem.Windows) {
+            originalPath = originalPath.replace(/\//g, "\\");
+        }
+    }
+    if (!executable) {
+        return originalPath;
+    }
+    const hasSpace = originalPath.includes(" ");
+    const hasParens = originalPath.includes("(") || originalPath.includes(")");
+    const pathBasename = basename(executable, ".exe");
+    const isPowerShell = pathBasename === "pwsh" || title === "pwsh" || pathBasename === "powershell" || title === "powershell";
+    if (isPowerShell && (hasSpace || originalPath.includes("'"))) {
+        return `& '${originalPath.replace(/'/g, "''")}'`;
+    }
+    if (hasParens && isPowerShell) {
+        return `& '${originalPath}'`;
+    }
+    if (os === OperatingSystem.Windows) {
+        if (shellType !== undefined) {
+            if (shellType === WindowsShellType.GitBash) {
+                return escapeNonWindowsPath(originalPath.replace(/\\/g, "/"), shellType);
+            } else if (shellType === WindowsShellType.Wsl) {
+                return backend?.getWslPath(originalPath, "win-to-unix") || originalPath;
+            } else if (hasSpace) {
+                return `"${originalPath}"`;
+            }
+            return originalPath;
+        }
+        const lowerExecutable = executable.toLowerCase();
+        if (lowerExecutable.includes("wsl") || (lowerExecutable.includes("bash.exe") && !lowerExecutable.toLowerCase().includes("git"))) {
+            return backend?.getWslPath(originalPath, "win-to-unix") || originalPath;
+        } else if (hasSpace) {
+            return `"${originalPath}"`;
+        }
+        return originalPath;
+    }
+    return escapeNonWindowsPath(originalPath, shellType);
+}
+function getWorkspaceForTerminal(cwd, workspaceContextService, historyService) {
+    const cwdUri = isString(cwd) ? ( URI.parse(cwd)) : cwd;
+    let workspaceFolder = cwdUri ? workspaceContextService.getWorkspaceFolder(cwdUri) ?? undefined : undefined;
+    if (!workspaceFolder) {
+        const activeWorkspaceRootUri = historyService.getLastActiveWorkspaceRoot();
+        workspaceFolder = activeWorkspaceRootUri ? workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri) ?? undefined : undefined;
+    }
+    return workspaceFolder;
+}
+async function getUriLabelForShell(uri, backend, shellType, os, isWindowsFrontend = isWindows) {
+    let path = isString(uri) ? uri : uri.fsPath;
+    if (os === OperatingSystem.Windows) {
+        if (shellType === WindowsShellType.Wsl) {
+            return backend.getWslPath(path.replaceAll("/", "\\"), "win-to-unix");
+        } else if (shellType === WindowsShellType.GitBash) {
+            return path.replaceAll("\\", "/").replace(/^([a-zA-Z]):\//, "/$1/");
+        } else {
+            path = isString(uri) ? path : uriToFsPath(uri, true);
+            return !isWindowsFrontend ? path.replaceAll("/", "\\") : path;
+        }
+    } else {
+        return isWindowsFrontend ? path.replaceAll("\\", "/") : path;
+    }
+}
+function getShellIntegrationTimeout(configurationService, siInjectionEnabled, isRemote, processReadyTimestamp) {
+    const timeoutValue = configurationService.getValue(TerminalSettingId.ShellIntegrationTimeout);
+    let timeoutMs;
+    if (isNumber(timeoutValue) && timeoutValue === ShellIntegrationTimeoutOverride.DisableForTests) {
+        timeoutMs = 0;
+    } else if (!isNumber(timeoutValue) || timeoutValue < 0) {
+        timeoutMs = siInjectionEnabled ? 5000 : (isRemote ? 3000 : 2000);
+    } else if (timeoutValue === 0) {
+        timeoutMs = 0;
+    } else {
+        timeoutMs = Math.max(timeoutValue, 500);
+    }
+    if (processReadyTimestamp !== undefined) {
+        const elapsed = Date.now() - processReadyTimestamp;
+        timeoutMs = Math.max(0, timeoutMs - elapsed);
+    }
+    return timeoutMs;
+}
+
+export { addTerminalEnvironmentKeys, createTerminalEnvironment, createVariableResolver, getCwd, getLangEnvVariable, getShellIntegrationTimeout, getUriLabelForShell, getWorkspaceForTerminal, mergeEnvironments, preparePathForShell, shouldSetLangEnvVariable };

package/vscode/src/vs/workbench/contrib/terminalContrib/chat/browser/terminalChat.d.ts

@@ -0,0 +1,78 @@
+import { MenuId } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { RawContextKey } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey";
+export declare enum TerminalChatCommandId {
+    Start = "workbench.action.terminal.chat.start",
+    Close = "workbench.action.terminal.chat.close",
+    MakeRequest = "workbench.action.terminal.chat.makeRequest",
+    Cancel = "workbench.action.terminal.chat.cancel",
+    RunCommand = "workbench.action.terminal.chat.runCommand",
+    RunFirstCommand = "workbench.action.terminal.chat.runFirstCommand",
+    InsertCommand = "workbench.action.terminal.chat.insertCommand",
+    InsertFirstCommand = "workbench.action.terminal.chat.insertFirstCommand",
+    ViewInChat = "workbench.action.terminal.chat.viewInChat",
+    RerunRequest = "workbench.action.terminal.chat.rerunRequest",
+    ViewHiddenChatTerminals = "workbench.action.terminal.chat.viewHiddenChatTerminals",
+    OpenTerminalSettingsLink = "workbench.action.terminal.chat.openTerminalSettingsLink",
+    DisableSessionAutoApproval = "workbench.action.terminal.chat.disableSessionAutoApproval",
+    FocusMostRecentChatTerminalOutput = "workbench.action.terminal.chat.focusMostRecentChatTerminalOutput",
+    FocusMostRecentChatTerminal = "workbench.action.terminal.chat.focusMostRecentChatTerminal",
+    ToggleChatTerminalOutput = "workbench.action.terminal.chat.toggleChatTerminalOutput",
+    FocusChatInstanceAction = "workbench.action.terminal.chat.focusChatInstance",
+    ContinueInBackground = "workbench.action.terminal.chat.continueInBackground"
+}
+export declare const MENU_TERMINAL_CHAT_WIDGET_INPUT_SIDE_TOOLBAR: MenuId;
+export declare const MENU_TERMINAL_CHAT_WIDGET_STATUS: MenuId;
+export declare const MENU_TERMINAL_CHAT_WIDGET_TOOLBAR: MenuId;
+export declare const MENU_CHAT_TERMINAL_TOOL_PROGRESS: MenuId;
+export declare enum TerminalChatContextKeyStrings {
+    ChatFocus = "terminalChatFocus",
+    ChatVisible = "terminalChatVisible",
+    ChatActiveRequest = "terminalChatActiveRequest",
+    ChatInputHasText = "terminalChatInputHasText",
+    ChatAgentRegistered = "terminalChatAgentRegistered",
+    ChatResponseEditorFocused = "terminalChatResponseEditorFocused",
+    ChatResponseContainsCodeBlock = "terminalChatResponseContainsCodeBlock",
+    ChatResponseContainsMultipleCodeBlocks = "terminalChatResponseContainsMultipleCodeBlocks",
+    ChatResponseSupportsIssueReporting = "terminalChatResponseSupportsIssueReporting",
+    ChatSessionResponseVote = "terminalChatSessionResponseVote",
+    ChatHasTerminals = "hasChatTerminals",
+    ChatHasHiddenTerminals = "hasHiddenChatTerminals",
+    ChatToolHasInstance = "chatTerminalToolHasInstance",
+    ChatToolCanContinueInBackground = "chatTerminalToolCanContinueInBackground",
+    ChatToolHasOutput = "chatTerminalToolHasOutput",
+    ChatToolUsesCollapsible = "chatTerminalToolUsesCollapsible",
+    ChatToolIsHiddenTerminal = "chatTerminalToolIsHiddenTerminal",
+    ChatToolOutputExpanded = "chatTerminalToolOutputExpanded"
+}
+export declare namespace TerminalChatContextKeys {
+    /** Whether the chat widget is focused */
+    const focused: RawContextKey<boolean>;
+    /** Whether the chat widget is visible */
+    const visible: RawContextKey<boolean>;
+    /** Whether there is an active chat request */
+    const requestActive: RawContextKey<boolean>;
+    /** Whether the chat input has text */
+    const inputHasText: RawContextKey<boolean>;
+    /** The chat response contains at least one code block */
+    const responseContainsCodeBlock: RawContextKey<boolean>;
+    /** The chat response contains multiple code blocks */
+    const responseContainsMultipleCodeBlocks: RawContextKey<boolean>;
+    /** A chat agent exists for the terminal location */
+    const hasChatAgent: RawContextKey<boolean>;
+    /** Has terminals created via chat */
+    const hasChatTerminals: RawContextKey<boolean>;
+    /** Has hidden chat terminals */
+    const hasHiddenChatTerminals: RawContextKey<boolean>;
+    /** Whether the per-instance terminal tool progress part has a terminal instance attached */
+    const chatToolHasInstance: RawContextKey<boolean>;
+    /** Whether the continue-in-background action is available */
+    const chatToolCanContinueInBackground: RawContextKey<boolean>;
+    /** Whether terminal output is available for display */
+    const chatToolHasOutput: RawContextKey<boolean>;
+    /** Whether the terminal tool uses a collapsible wrapper */
+    const chatToolUsesCollapsible: RawContextKey<boolean>;
+    /** Whether the associated terminal is hidden from the user */
+    const chatToolIsHiddenTerminal: RawContextKey<boolean>;
+    /** Whether the terminal output section is currently expanded */
+    const chatToolOutputExpanded: RawContextKey<boolean>;
+}

package/vscode/src/vs/workbench/contrib/terminalContrib/chat/browser/terminalChat.js

@@ -0,0 +1,83 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { RawContextKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+
+var TerminalChatCommandId;
+(function(TerminalChatCommandId) {
+    TerminalChatCommandId["Start"] = "workbench.action.terminal.chat.start";
+    TerminalChatCommandId["Close"] = "workbench.action.terminal.chat.close";
+    TerminalChatCommandId["MakeRequest"] = "workbench.action.terminal.chat.makeRequest";
+    TerminalChatCommandId["Cancel"] = "workbench.action.terminal.chat.cancel";
+    TerminalChatCommandId["RunCommand"] = "workbench.action.terminal.chat.runCommand";
+    TerminalChatCommandId["RunFirstCommand"] = "workbench.action.terminal.chat.runFirstCommand";
+    TerminalChatCommandId["InsertCommand"] = "workbench.action.terminal.chat.insertCommand";
+    TerminalChatCommandId["InsertFirstCommand"] = "workbench.action.terminal.chat.insertFirstCommand";
+    TerminalChatCommandId["ViewInChat"] = "workbench.action.terminal.chat.viewInChat";
+    TerminalChatCommandId["RerunRequest"] = "workbench.action.terminal.chat.rerunRequest";
+    TerminalChatCommandId["ViewHiddenChatTerminals"] = "workbench.action.terminal.chat.viewHiddenChatTerminals";
+    TerminalChatCommandId["OpenTerminalSettingsLink"] = "workbench.action.terminal.chat.openTerminalSettingsLink";
+    TerminalChatCommandId["DisableSessionAutoApproval"] = "workbench.action.terminal.chat.disableSessionAutoApproval";
+    TerminalChatCommandId["FocusMostRecentChatTerminalOutput"] = "workbench.action.terminal.chat.focusMostRecentChatTerminalOutput";
+    TerminalChatCommandId["FocusMostRecentChatTerminal"] = "workbench.action.terminal.chat.focusMostRecentChatTerminal";
+    TerminalChatCommandId["ToggleChatTerminalOutput"] = "workbench.action.terminal.chat.toggleChatTerminalOutput";
+    TerminalChatCommandId["FocusChatInstanceAction"] = "workbench.action.terminal.chat.focusChatInstance";
+    TerminalChatCommandId["ContinueInBackground"] = "workbench.action.terminal.chat.continueInBackground";
+})(TerminalChatCommandId || (TerminalChatCommandId = {}));
+const MENU_TERMINAL_CHAT_WIDGET_INPUT_SIDE_TOOLBAR = MenuId.for("terminalChatWidget");
+const MENU_TERMINAL_CHAT_WIDGET_STATUS = MenuId.for("terminalChatWidget.status");
+MenuId.for("terminalChatWidget.toolbar");
+MenuId.for("chatTerminalToolProgress");
+var TerminalChatContextKeyStrings;
+(function(TerminalChatContextKeyStrings) {
+    TerminalChatContextKeyStrings["ChatFocus"] = "terminalChatFocus";
+    TerminalChatContextKeyStrings["ChatVisible"] = "terminalChatVisible";
+    TerminalChatContextKeyStrings["ChatActiveRequest"] = "terminalChatActiveRequest";
+    TerminalChatContextKeyStrings["ChatInputHasText"] = "terminalChatInputHasText";
+    TerminalChatContextKeyStrings["ChatAgentRegistered"] = "terminalChatAgentRegistered";
+    TerminalChatContextKeyStrings["ChatResponseEditorFocused"] = "terminalChatResponseEditorFocused";
+    TerminalChatContextKeyStrings["ChatResponseContainsCodeBlock"] = "terminalChatResponseContainsCodeBlock";
+    TerminalChatContextKeyStrings["ChatResponseContainsMultipleCodeBlocks"] = "terminalChatResponseContainsMultipleCodeBlocks";
+    TerminalChatContextKeyStrings["ChatResponseSupportsIssueReporting"] = "terminalChatResponseSupportsIssueReporting";
+    TerminalChatContextKeyStrings["ChatSessionResponseVote"] = "terminalChatSessionResponseVote";
+    TerminalChatContextKeyStrings["ChatHasTerminals"] = "hasChatTerminals";
+    TerminalChatContextKeyStrings["ChatHasHiddenTerminals"] = "hasHiddenChatTerminals";
+    TerminalChatContextKeyStrings["ChatToolHasInstance"] = "chatTerminalToolHasInstance";
+    TerminalChatContextKeyStrings["ChatToolCanContinueInBackground"] = "chatTerminalToolCanContinueInBackground";
+    TerminalChatContextKeyStrings["ChatToolHasOutput"] = "chatTerminalToolHasOutput";
+    TerminalChatContextKeyStrings["ChatToolUsesCollapsible"] = "chatTerminalToolUsesCollapsible";
+    TerminalChatContextKeyStrings["ChatToolIsHiddenTerminal"] = "chatTerminalToolIsHiddenTerminal";
+    TerminalChatContextKeyStrings["ChatToolOutputExpanded"] = "chatTerminalToolOutputExpanded";
+})(TerminalChatContextKeyStrings || (TerminalChatContextKeyStrings = {}));
+var TerminalChatContextKeys;
+(function(TerminalChatContextKeys) {
+    TerminalChatContextKeys.focused = ( new RawContextKey(TerminalChatContextKeyStrings.ChatFocus, false, ( localize(14584, "Whether the chat view is focused."))));
+    TerminalChatContextKeys.visible = ( new RawContextKey(TerminalChatContextKeyStrings.ChatVisible, false, ( localize(14585, "Whether the chat view is visible."))));
+    TerminalChatContextKeys.requestActive = ( new RawContextKey(TerminalChatContextKeyStrings.ChatActiveRequest, false, ( localize(14586, "Whether there is an active chat request."))));
+    TerminalChatContextKeys.inputHasText = ( new RawContextKey(TerminalChatContextKeyStrings.ChatInputHasText, false, ( localize(14587, "Whether the chat input has text."))));
+    TerminalChatContextKeys.responseContainsCodeBlock = ( new RawContextKey(
+        TerminalChatContextKeyStrings.ChatResponseContainsCodeBlock,
+        false,
+        ( localize(14588, "Whether the chat response contains a code block."))
+    ));
+    TerminalChatContextKeys.responseContainsMultipleCodeBlocks = ( new RawContextKey(
+        TerminalChatContextKeyStrings.ChatResponseContainsMultipleCodeBlocks,
+        false,
+        ( localize(14589, "Whether the chat response contains multiple code blocks."))
+    ));
+    TerminalChatContextKeys.hasChatAgent = ( new RawContextKey(TerminalChatContextKeyStrings.ChatAgentRegistered, false, ( localize(14590, "Whether a chat agent is registered for the terminal location."))));
+    TerminalChatContextKeys.hasChatTerminals = ( new RawContextKey(TerminalChatContextKeyStrings.ChatHasTerminals, false, ( localize(14591, "Whether there are any chat terminals."))));
+    TerminalChatContextKeys.hasHiddenChatTerminals = ( new RawContextKey(
+        TerminalChatContextKeyStrings.ChatHasHiddenTerminals,
+        false,
+        ( localize(14592, "Whether there are any hidden chat terminals."))
+    ));
+    TerminalChatContextKeys.chatToolHasInstance = ( new RawContextKey(TerminalChatContextKeyStrings.ChatToolHasInstance, false));
+    TerminalChatContextKeys.chatToolCanContinueInBackground = ( new RawContextKey(TerminalChatContextKeyStrings.ChatToolCanContinueInBackground, false));
+    TerminalChatContextKeys.chatToolHasOutput = ( new RawContextKey(TerminalChatContextKeyStrings.ChatToolHasOutput, false));
+    TerminalChatContextKeys.chatToolUsesCollapsible = ( new RawContextKey(TerminalChatContextKeyStrings.ChatToolUsesCollapsible, false));
+    TerminalChatContextKeys.chatToolIsHiddenTerminal = ( new RawContextKey(TerminalChatContextKeyStrings.ChatToolIsHiddenTerminal, false));
+    TerminalChatContextKeys.chatToolOutputExpanded = ( new RawContextKey(TerminalChatContextKeyStrings.ChatToolOutputExpanded, false));
+})(TerminalChatContextKeys || (TerminalChatContextKeys = {}));
+
+export { MENU_TERMINAL_CHAT_WIDGET_INPUT_SIDE_TOOLBAR, MENU_TERMINAL_CHAT_WIDGET_STATUS, TerminalChatCommandId, TerminalChatContextKeyStrings, TerminalChatContextKeys };

package/vscode/src/vs/workbench/contrib/terminalContrib/stickyScroll/browser/terminalStickyScrollColorRegistry.js

@@ -3,7 +3,7 @@ import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { registerColor } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
 
 const terminalStickyScrollBackground = registerColor("terminalStickyScroll.background", null, ( localize(
-    14811,
+    15018,
     "The background color of the sticky scroll overlay in the terminal."
 )));
 const terminalStickyScrollHoverBackground = registerColor("terminalStickyScrollHover.background", {
@@ -12,7 +12,7 @@ const terminalStickyScrollHoverBackground = registerColor("terminalStickyScrollH
     hcDark: "#E48B39",
     hcLight: "#0f4a85"
 }, ( localize(
-    14812,
+    15019,
     "The background color of the sticky scroll overlay in the terminal when hovered."
 )));
 registerColor("terminalStickyScroll.border", {
@@ -20,6 +20,6 @@ registerColor("terminalStickyScroll.border", {
     light: null,
     hcDark: "#6fc3df",
     hcLight: "#0f4a85"
-}, ( localize(14813, "The border of the sticky scroll overlay in the terminal.")));
+}, ( localize(15020, "The border of the sticky scroll overlay in the terminal.")));
 
 export { terminalStickyScrollBackground, terminalStickyScrollHoverBackground };

package/vscode/src/vs/workbench/contrib/terminalContrib/stickyScroll/browser/terminalStickyScrollOverlay.js

@@ -304,19 +304,19 @@ let TerminalStickyScrollOverlay = class TerminalStickyScrollOverlay extends Disp
         this._element = $(".terminal-sticky-scroll", undefined, hoverOverlay);
         this._xterm.raw.element.parentElement.append(this._element);
         this._register(toDisposable(() => this._element?.remove()));
-        let hoverTitle = ( localize(14814, "Navigate to Command"));
+        let hoverTitle = ( localize(15021, "Navigate to Command"));
         const scrollToPreviousCommandKeybinding = this._keybindingService.lookupKeybinding(TerminalCommandId.ScrollToPreviousCommand);
         if (scrollToPreviousCommandKeybinding) {
             const label = scrollToPreviousCommandKeybinding.getLabel();
             if (label) {
-                hoverTitle += "\n" + ( localize(14815, "{0} ({1})", terminalStrings.scrollToPreviousCommand.value, label));
+                hoverTitle += "\n" + ( localize(15022, "{0} ({1})", terminalStrings.scrollToPreviousCommand.value, label));
             }
         }
         const scrollToNextCommandKeybinding = this._keybindingService.lookupKeybinding(TerminalCommandId.ScrollToNextCommand);
         if (scrollToNextCommandKeybinding) {
             const label = scrollToNextCommandKeybinding.getLabel();
             if (label) {
-                hoverTitle += "\n" + ( localize(14815, "{0} ({1})", terminalStrings.scrollToNextCommand.value, label));
+                hoverTitle += "\n" + ( localize(15022, "{0} ({1})", terminalStrings.scrollToNextCommand.value, label));
             }
         }
         hoverOverlay.title = hoverTitle;