@codingame/monaco-vscode-xterm-common 24.1.0

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalTooltip.d.ts

@@ -0,0 +1,10 @@
+import { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import { MarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent";
+import type { IHoverAction } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hover";
+import { type IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+export declare function getInstanceHoverInfo(instance: ITerminalInstance, storageService: IStorageService): {
+    content: MarkdownString;
+    actions: IHoverAction[];
+};
+export declare function getShellProcessTooltip(instance: ITerminalInstance, showDetailed: boolean): string;
+export declare function refreshShellIntegrationInfoStatus(instance: ITerminalInstance): void;

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalTooltip.js

@@ -0,0 +1,112 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { asArray } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities';
+import { TerminalStatus } from './terminalStatusList.js';
+import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { TerminalStorageKeys } from '../common/terminalStorageKeys.js';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+
+function getInstanceHoverInfo(instance, storageService) {
+    const showDetailed = parseInt(storageService.get(TerminalStorageKeys.TabsShowDetailed, StorageScope.APPLICATION) ?? '0');
+    let statusString = '';
+    const statuses = instance.statusList.statuses;
+    const actions = [];
+    for (const status of statuses) {
+        if (showDetailed) {
+            if (status.detailedTooltip ?? status.tooltip) {
+                statusString += `\n\n---\n\n${status.icon ? `$(${status.icon?.id}) ` : ''}` + (status.detailedTooltip ?? status.tooltip ?? '');
+            }
+        }
+        else {
+            if (status.tooltip) {
+                statusString += `\n\n---\n\n${status.icon ? `$(${status.icon?.id}) ` : ''}` + (status.tooltip ?? '');
+            }
+        }
+        if (status.hoverActions) {
+            actions.push(...status.hoverActions);
+        }
+    }
+    actions.push({
+        commandId: 'toggleDetailedInfo',
+        label: showDetailed ? ( localize(11634, 'Hide Details')) : ( localize(11635, 'Show Details')),
+        run() {
+            storageService.store(TerminalStorageKeys.TabsShowDetailed, (showDetailed + 1) % 2, StorageScope.APPLICATION, StorageTarget.USER);
+        },
+    });
+    const shellProcessString = getShellProcessTooltip(instance, !!showDetailed);
+    const content = ( new MarkdownString(
+        instance.title + shellProcessString + statusString,
+        { supportThemeIcons: true }
+    ));
+    return { content, actions };
+}
+function getShellProcessTooltip(instance, showDetailed) {
+    const lines = [];
+    if (instance.processId && instance.processId > 0) {
+        lines.push(( localize(11636, "Process ID ({0}): {1}", 'PID', instance.processId)) + '\n');
+    }
+    if (instance.shellLaunchConfig.executable) {
+        let commandLine = '';
+        if (!showDetailed && instance.shellLaunchConfig.executable.length > 32) {
+            const base = basename(instance.shellLaunchConfig.executable);
+            const sepIndex = instance.shellLaunchConfig.executable.length - base.length - 1;
+            const sep = instance.shellLaunchConfig.executable.substring(sepIndex, sepIndex + 1);
+            commandLine += `…${sep}${base}`;
+        }
+        else {
+            commandLine += instance.shellLaunchConfig.executable;
+        }
+        const args = ( asArray(instance.injectedArgs || instance.shellLaunchConfig.args || []).map(x => x.match(/\s/) ? `'${x}'` : x)).join(' ');
+        if (args) {
+            commandLine += ` ${args}`;
+        }
+        lines.push(( localize(11637, 'Command line: {0}', commandLine)));
+    }
+    return lines.length ? `\n\n---\n\n${lines.join('\n')}` : '';
+}
+function refreshShellIntegrationInfoStatus(instance) {
+    if (!instance.xterm) {
+        return;
+    }
+    const cmdDetectionType = (instance.capabilities.get(TerminalCapability.CommandDetection)?.hasRichCommandDetection
+        ? ( localize(11638, 'Rich'))
+        : ( instance.capabilities.has(TerminalCapability.CommandDetection))
+            ? ( localize(11639, 'Basic'))
+            : instance.usedShellIntegrationInjection
+                ? ( localize(11640, "Injection failed to activate"))
+                : ( localize(11641, 'No')));
+    const detailedAdditions = [];
+    if (instance.shellType) {
+        detailedAdditions.push(`Shell type: \`${instance.shellType}\``);
+    }
+    const cwd = instance.cwd;
+    if (cwd) {
+        detailedAdditions.push(`Current working directory: \`${cwd}\``);
+    }
+    const seenSequences = Array.from(instance.xterm.shellIntegration.seenSequences);
+    if (seenSequences.length > 0) {
+        detailedAdditions.push(`Seen sequences: ${( seenSequences.map(e => `\`${e}\``)).join(', ')}`);
+    }
+    const promptType = instance.capabilities.get(TerminalCapability.PromptTypeDetection)?.promptType;
+    if (promptType) {
+        detailedAdditions.push(`Prompt type: \`${promptType}\``);
+    }
+    const combinedString = instance.capabilities.get(TerminalCapability.CommandDetection)?.promptInputModel.getCombinedString();
+    if (combinedString !== undefined) {
+        detailedAdditions.push(`Prompt input: \`\`\`${combinedString}\`\`\``);
+    }
+    const detailedAdditionsString = detailedAdditions.length > 0
+        ? '\n\n' + ( detailedAdditions.map(e => `- ${e}`)).join('\n')
+        : '';
+    instance.statusList.add({
+        id: TerminalStatus.ShellIntegrationInfo,
+        severity: Severity.Info,
+        tooltip: `${( localize(11642, "Shell integration"))}: ${cmdDetectionType}`,
+        detailedTooltip: `${( localize(11642, "Shell integration"))}: ${cmdDetectionType}${detailedAdditionsString}`
+    });
+}
+
+export { getInstanceHoverInfo, getShellProcessTooltip, refreshShellIntegrationInfoStatus };

package/vscode/src/vs/workbench/contrib/terminal/browser/xterm/lineDataEventAddon.d.ts

@@ -0,0 +1,17 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import type { Terminal as XTermTerminal, ITerminalAddon } from "@xterm/xterm";
+/**
+ * Provides extensions to the xterm object in a modular, testable way.
+ */
+export declare class LineDataEventAddon extends Disposable implements ITerminalAddon {
+    private readonly _initializationPromise?;
+    private _xterm?;
+    private _isOsSet;
+    private readonly _onLineData;
+    readonly onLineData: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<string>;
+    constructor(_initializationPromise?: Promise<void> | undefined);
+    activate(xterm: XTermTerminal): Promise<void>;
+    setOperatingSystem(os: OperatingSystem): void;
+    private _sendLineData;
+}

package/vscode/src/vs/workbench/contrib/terminal/browser/xterm/lineDataEventAddon.js

@@ -0,0 +1,59 @@
+
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+
+class LineDataEventAddon extends Disposable {
+    constructor(_initializationPromise) {
+        super();
+        this._initializationPromise = _initializationPromise;
+        this._isOsSet = false;
+        this._onLineData = this._register(( new Emitter()));
+        this.onLineData = this._onLineData.event;
+    }
+    async activate(xterm) {
+        this._xterm = xterm;
+        const buffer = xterm.buffer;
+        await this._initializationPromise;
+        this._register(xterm.onLineFeed(() => {
+            const newLine = buffer.active.getLine(buffer.active.baseY + buffer.active.cursorY);
+            if (newLine && !newLine.isWrapped) {
+                this._sendLineData(buffer.active, buffer.active.baseY + buffer.active.cursorY - 1);
+            }
+        }));
+        this._register(toDisposable(() => {
+            this._sendLineData(buffer.active, buffer.active.baseY + buffer.active.cursorY);
+        }));
+    }
+    setOperatingSystem(os) {
+        if (this._isOsSet || !this._xterm) {
+            return;
+        }
+        this._isOsSet = true;
+        if (os === OperatingSystem.Windows) {
+            const xterm = this._xterm;
+            this._register(xterm.parser.registerCsiHandler({ final: 'H' }, () => {
+                const buffer = xterm.buffer;
+                this._sendLineData(buffer.active, buffer.active.baseY + buffer.active.cursorY);
+                return false;
+            }));
+        }
+    }
+    _sendLineData(buffer, lineIndex) {
+        let line = buffer.getLine(lineIndex);
+        if (!line) {
+            return;
+        }
+        let lineData = line.translateToString(true);
+        while (lineIndex > 0 && line.isWrapped) {
+            line = buffer.getLine(--lineIndex);
+            if (!line) {
+                break;
+            }
+            lineData = line.translateToString(false) + lineData;
+        }
+        this._onLineData.fire(lineData);
+    }
+}
+
+export { LineDataEventAddon };

package/vscode/src/vs/workbench/contrib/terminal/common/terminalEnvironment.d.ts

@@ -0,0 +1,38 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IWorkspaceFolder } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IConfigurationResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolver.service";
+import { IShellLaunchConfig, ITerminalBackend, ITerminalEnvironment, TerminalShellType } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal";
+import { IProcessEnvironment, OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import { IHistoryService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/history/common/history.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+export declare function mergeEnvironments(parent: IProcessEnvironment, other: ITerminalEnvironment | undefined): void;
+export declare function addTerminalEnvironmentKeys(env: IProcessEnvironment, version: string | undefined, locale: string | undefined, detectLocale: "auto" | "off" | "on"): void;
+export declare function shouldSetLangEnvVariable(env: IProcessEnvironment, detectLocale: "auto" | "off" | "on"): boolean;
+export declare function getLangEnvVariable(locale?: string): string;
+export declare function getCwd(shell: IShellLaunchConfig, userHome: string | undefined, variableResolver: VariableResolver | undefined, root: URI | undefined, customCwd: string | undefined, logService?: ILogService): Promise<string>;
+export type VariableResolver = (str: string) => Promise<string>;
+export declare function createVariableResolver(lastActiveWorkspace: IWorkspaceFolder | undefined, env: IProcessEnvironment, configurationResolverService: IConfigurationResolverService | undefined): VariableResolver | undefined;
+export declare function createTerminalEnvironment(shellLaunchConfig: IShellLaunchConfig, envFromConfig: ITerminalEnvironment | undefined, variableResolver: VariableResolver | undefined, version: string | undefined, detectLocale: "auto" | "off" | "on", baseEnv: IProcessEnvironment): Promise<IProcessEnvironment>;
+/**
+ * Takes a path and returns the properly escaped path to send to a given shell. On Windows, this
+ * included trying to prepare the path for WSL if needed.
+ *
+ * @param originalPath The path to be escaped and formatted.
+ * @param executable The executable off the shellLaunchConfig.
+ * @param title The terminal's title.
+ * @param shellType The type of shell the path is being sent to.
+ * @param backend The backend for the terminal.
+ * @param isWindowsFrontend Whether the frontend is Windows, this is only exposed for injection via
+ * tests.
+ * @returns An escaped version of the path to be executed in the terminal.
+ */
+export declare function preparePathForShell(resource: string | URI, executable: string | undefined, title: string, shellType: TerminalShellType | undefined, backend: Pick<ITerminalBackend, "getWslPath"> | undefined, os: OperatingSystem | undefined, isWindowsFrontend?: boolean): Promise<string>;
+export declare function getWorkspaceForTerminal(cwd: URI | string | undefined, workspaceContextService: IWorkspaceContextService, historyService: IHistoryService): IWorkspaceFolder | undefined;
+export declare function getUriLabelForShell(uri: URI | string, backend: Pick<ITerminalBackend, "getWslPath">, shellType?: TerminalShellType, os?: OperatingSystem, isWindowsFrontend?: boolean): Promise<string>;
+/**
+ * Gets the unified duration to wait for shell integration after the terminal launches before
+ * declaring the terminal lacks shell integration.
+ */
+export declare function getShellIntegrationTimeout(configurationService: IConfigurationService, siInjectionEnabled: boolean, isRemote: boolean, processReadyTimestamp?: number): number;

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

@@ -0,0 +1,319 @@
+
+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 } 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 < 0) {
+        timeoutMs = siInjectionEnabled ? 5000 : (isRemote ? 3000 : 2000);
+    }
+    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/terminal/common/terminalStorageKeys.d.ts

@@ -0,0 +1,12 @@
+export declare enum TerminalStorageKeys {
+    SuggestedRendererType = "terminal.integrated.suggestedRendererType",
+    TabsListWidthHorizontal = "tabs-list-width-horizontal",
+    TabsListWidthVertical = "tabs-list-width-vertical",
+    TabsShowDetailed = "terminal.integrated.tabs.showDetailed",
+    DeprecatedEnvironmentVariableCollections = "terminal.integrated.environmentVariableCollections",
+    EnvironmentVariableCollections = "terminal.integrated.environmentVariableCollectionsV2",
+    TerminalBufferState = "terminal.integrated.bufferState",
+    TerminalLayoutInfo = "terminal.integrated.layoutInfo",
+    PinnedRecentCommandsPrefix = "terminal.pinnedRecentCommands",
+    TerminalSuggestSize = "terminal.integrated.suggestSize"
+}

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

@@ -0,0 +1,17 @@
+
+
+var TerminalStorageKeys;
+(function (TerminalStorageKeys) {
+    TerminalStorageKeys["SuggestedRendererType"] = "terminal.integrated.suggestedRendererType";
+    TerminalStorageKeys["TabsListWidthHorizontal"] = "tabs-list-width-horizontal";
+    TerminalStorageKeys["TabsListWidthVertical"] = "tabs-list-width-vertical";
+    TerminalStorageKeys["TabsShowDetailed"] = "terminal.integrated.tabs.showDetailed";
+    TerminalStorageKeys["DeprecatedEnvironmentVariableCollections"] = "terminal.integrated.environmentVariableCollections";
+    TerminalStorageKeys["EnvironmentVariableCollections"] = "terminal.integrated.environmentVariableCollectionsV2";
+    TerminalStorageKeys["TerminalBufferState"] = "terminal.integrated.bufferState";
+    TerminalStorageKeys["TerminalLayoutInfo"] = "terminal.integrated.layoutInfo";
+    TerminalStorageKeys["PinnedRecentCommandsPrefix"] = "terminal.pinnedRecentCommands";
+    TerminalStorageKeys["TerminalSuggestSize"] = "terminal.integrated.suggestSize";
+})(TerminalStorageKeys || (TerminalStorageKeys = {}));
+
+export { TerminalStorageKeys };

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

@@ -0,0 +1,58 @@
+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"
+}
+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 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"
+}
+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>;
+}