@codingame/monaco-vscode-xterm-common 37.2.0 → 37.3.1

package/vscode/src/vs/platform/terminal/common/environmentVariableCollection.js

@@ -1,218 +0,0 @@
-
-import { isWindows } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
-import { EnvironmentVariableMutatorType } from './environmentVariable.js';
-
-const mutatorTypeToLabelMap = ( new Map([
-    [EnvironmentVariableMutatorType.Append, "APPEND"],
-    [EnvironmentVariableMutatorType.Prepend, "PREPEND"],
-    [EnvironmentVariableMutatorType.Replace, "REPLACE"]
-]));
-const PYTHON_ACTIVATION_VARS_PATTERN = /^VSCODE_PYTHON_(PWSH|ZSH|BASH|FISH)_ACTIVATE/;
-const PYTHON_ENV_EXTENSION_ID = "ms-python.vscode-python-envs";
-class MergedEnvironmentVariableCollection {
-    constructor(collections) {
-        this.collections = collections;
-        this.map = ( new Map());
-        this.descriptionMap = ( new Map());
-        collections.forEach((collection, extensionIdentifier) => {
-            this.populateDescriptionMap(collection, extensionIdentifier);
-            const it = collection.map.entries();
-            let next = it.next();
-            while (!next.done) {
-                const mutator = next.value[1];
-                const key = next.value[0];
-                if (this.blockPythonActivationVar(key, extensionIdentifier)) {
-                    next = it.next();
-                    continue;
-                }
-                let entry = this.map.get(key);
-                if (!entry) {
-                    entry = [];
-                    this.map.set(key, entry);
-                }
-                if (entry.length > 0 && entry[0].type === EnvironmentVariableMutatorType.Replace) {
-                    next = it.next();
-                    continue;
-                }
-                const extensionMutator = {
-                    extensionIdentifier,
-                    value: mutator.value,
-                    type: mutator.type,
-                    scope: mutator.scope,
-                    variable: mutator.variable,
-                    options: mutator.options
-                };
-                if (!extensionMutator.scope) {
-                    delete extensionMutator.scope;
-                }
-                entry.unshift(extensionMutator);
-                next = it.next();
-            }
-        });
-    }
-    async applyToProcessEnvironment(env, scope, variableResolver) {
-        let lowerToActualVariableNames;
-        if (isWindows) {
-            lowerToActualVariableNames = {};
-            ( Object.keys(env)).forEach(e => lowerToActualVariableNames[e.toLowerCase()] = e);
-        }
-        for (const [variable, mutators] of this.getVariableMap(scope)) {
-            const actualVariable = isWindows ? lowerToActualVariableNames[variable.toLowerCase()] || variable : variable;
-            for (const mutator of mutators) {
-                const value = variableResolver ? await variableResolver(mutator.value) : mutator.value;
-                if (this.blockPythonActivationVar(mutator.variable, mutator.extensionIdentifier)) {
-                    continue;
-                }
-                if (mutator.options?.applyAtProcessCreation ?? true) {
-                    switch (mutator.type) {
-                    case EnvironmentVariableMutatorType.Append:
-                        env[actualVariable] = (env[actualVariable] || "") + value;
-                        break;
-                    case EnvironmentVariableMutatorType.Prepend:
-                        env[actualVariable] = value + (env[actualVariable] || "");
-                        break;
-                    case EnvironmentVariableMutatorType.Replace:
-                        env[actualVariable] = value;
-                        break;
-                    }
-                }
-                if (mutator.options?.applyAtShellIntegration ?? false) {
-                    const key = `VSCODE_ENV_${mutatorTypeToLabelMap.get(mutator.type)}`;
-                    env[key] = (env[key] ? env[key] + ":" : "") + variable + "=" + this._encodeColons(value);
-                }
-            }
-        }
-    }
-    _encodeColons(value) {
-        return value.replaceAll(":", "\\x3a");
-    }
-    blockPythonActivationVar(variable, extensionIdentifier) {
-        if (PYTHON_ACTIVATION_VARS_PATTERN.test(variable) && PYTHON_ENV_EXTENSION_ID !== extensionIdentifier) {
-            return true;
-        }
-        return false;
-    }
-    diff(other, scope) {
-        const added = ( new Map());
-        const changed = ( new Map());
-        const removed = ( new Map());
-        other.getVariableMap(scope).forEach((otherMutators, variable) => {
-            const currentMutators = this.getVariableMap(scope).get(variable);
-            const result = getMissingMutatorsFromArray(otherMutators, currentMutators);
-            if (result) {
-                added.set(variable, result);
-            }
-        });
-        this.getVariableMap(scope).forEach((currentMutators, variable) => {
-            const otherMutators = other.getVariableMap(scope).get(variable);
-            const result = getMissingMutatorsFromArray(currentMutators, otherMutators);
-            if (result) {
-                removed.set(variable, result);
-            }
-        });
-        this.getVariableMap(scope).forEach((currentMutators, variable) => {
-            const otherMutators = other.getVariableMap(scope).get(variable);
-            const result = getChangedMutatorsFromArray(currentMutators, otherMutators);
-            if (result) {
-                changed.set(variable, result);
-            }
-        });
-        if (added.size === 0 && changed.size === 0 && removed.size === 0) {
-            return undefined;
-        }
-        return {
-            added,
-            changed,
-            removed
-        };
-    }
-    getVariableMap(scope) {
-        const result = ( new Map());
-        for (const mutators of ( this.map.values())) {
-            const filteredMutators = mutators.filter(m => filterScope(m, scope));
-            if (filteredMutators.length > 0) {
-                result.set(filteredMutators[0].variable, filteredMutators);
-            }
-        }
-        return result;
-    }
-    getDescriptionMap(scope) {
-        const result = ( new Map());
-        for (const mutators of ( this.descriptionMap.values())) {
-            const filteredMutators = mutators.filter(m => filterScope(m, scope, true));
-            for (const mutator of filteredMutators) {
-                result.set(mutator.extensionIdentifier, mutator.description);
-            }
-        }
-        return result;
-    }
-    populateDescriptionMap(collection, extensionIdentifier) {
-        if (!collection.descriptionMap) {
-            return;
-        }
-        const it = collection.descriptionMap.entries();
-        let next = it.next();
-        while (!next.done) {
-            const mutator = next.value[1];
-            const key = next.value[0];
-            let entry = this.descriptionMap.get(key);
-            if (!entry) {
-                entry = [];
-                this.descriptionMap.set(key, entry);
-            }
-            const extensionMutator = {
-                extensionIdentifier,
-                scope: mutator.scope,
-                description: mutator.description
-            };
-            if (!extensionMutator.scope) {
-                delete extensionMutator.scope;
-            }
-            entry.push(extensionMutator);
-            next = it.next();
-        }
-    }
-}
-function filterScope(mutator, scope, strictFilter = false) {
-    if (!mutator.scope) {
-        if (strictFilter) {
-            return scope === mutator.scope;
-        }
-        return true;
-    }
-    if (mutator.scope.workspaceFolder && scope?.workspaceFolder && mutator.scope.workspaceFolder.index === scope.workspaceFolder.index) {
-        return true;
-    }
-    return false;
-}
-function getMissingMutatorsFromArray(current, other) {
-    if (!other) {
-        return current;
-    }
-    const otherMutatorExtensions = ( new Set());
-    other.forEach(m => otherMutatorExtensions.add(m.extensionIdentifier));
-    const result = [];
-    current.forEach(mutator => {
-        if (!( otherMutatorExtensions.has(mutator.extensionIdentifier))) {
-            result.push(mutator);
-        }
-    });
-    return result.length === 0 ? undefined : result;
-}
-function getChangedMutatorsFromArray(current, other) {
-    if (!other) {
-        return undefined;
-    }
-    const otherMutatorExtensions = ( new Map());
-    other.forEach(m => otherMutatorExtensions.set(m.extensionIdentifier, m));
-    const result = [];
-    current.forEach(mutator => {
-        const otherMutator = otherMutatorExtensions.get(mutator.extensionIdentifier);
-        if (otherMutator && (mutator.type !== otherMutator.type || mutator.value !== otherMutator.value || mutator.scope?.workspaceFolder?.index !== otherMutator.scope?.workspaceFolder?.index)) {
-            result.push(otherMutator);
-        }
-    });
-    return result.length === 0 ? undefined : result;
-}
-
-export { MergedEnvironmentVariableCollection };

package/vscode/src/vs/platform/terminal/common/terminalRecorder.d.ts

@@ -1,14 +0,0 @@
-import { IPtyHostProcessReplayEvent } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities";
-import { ReplayEntry } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminalProcess";
-export interface IRemoteTerminalProcessReplayEvent {
-    events: ReplayEntry[];
-}
-export declare class TerminalRecorder {
-    private _entries;
-    private _totalDataLength;
-    constructor(cols: number, rows: number);
-    handleResize(cols: number, rows: number): void;
-    handleData(data: string): void;
-    generateReplayEventSync(): IPtyHostProcessReplayEvent;
-    generateReplayEvent(): Promise<IPtyHostProcessReplayEvent>;
-}

package/vscode/src/vs/platform/terminal/common/terminalRecorder.js

@@ -1,84 +0,0 @@
-
-
-var Constants;
-(function(Constants) {
-    Constants[Constants["MaxRecorderDataSize"] = 10485760] = "MaxRecorderDataSize";
-})(Constants || (Constants = {}));
-class TerminalRecorder {
-    constructor(cols, rows) {
-        this._totalDataLength = 0;
-        this._entries = [{
-            cols,
-            rows,
-            data: []
-        }];
-    }
-    handleResize(cols, rows) {
-        if (this._entries.length > 0) {
-            const lastEntry = this._entries[this._entries.length - 1];
-            if (lastEntry.data.length === 0) {
-                this._entries.pop();
-            }
-        }
-        if (this._entries.length > 0) {
-            const lastEntry = this._entries[this._entries.length - 1];
-            if (lastEntry.cols === cols && lastEntry.rows === rows) {
-                return;
-            }
-            if (lastEntry.cols === 0 && lastEntry.rows === 0) {
-                lastEntry.cols = cols;
-                lastEntry.rows = rows;
-                return;
-            }
-        }
-        this._entries.push({
-            cols,
-            rows,
-            data: []
-        });
-    }
-    handleData(data) {
-        const lastEntry = this._entries[this._entries.length - 1];
-        lastEntry.data.push(data);
-        this._totalDataLength += data.length;
-        while (this._totalDataLength > Constants.MaxRecorderDataSize) {
-            const firstEntry = this._entries[0];
-            const remainingToDelete = this._totalDataLength - Constants.MaxRecorderDataSize;
-            if (remainingToDelete >= firstEntry.data[0].length) {
-                this._totalDataLength -= firstEntry.data[0].length;
-                firstEntry.data.shift();
-                if (firstEntry.data.length === 0) {
-                    this._entries.shift();
-                }
-            } else {
-                firstEntry.data[0] = firstEntry.data[0].substr(remainingToDelete);
-                this._totalDataLength -= remainingToDelete;
-            }
-        }
-    }
-    generateReplayEventSync() {
-        this._entries.forEach(entry => {
-            if (entry.data.length > 0) {
-                entry.data = [entry.data.join("")];
-            }
-        });
-        return {
-            events: ( this._entries.map(entry => ({
-                cols: entry.cols,
-                rows: entry.rows,
-                data: entry.data[0] ?? ""
-            }))),
-            commands: {
-                isWindowsPty: false,
-                hasRichCommandDetection: false,
-                commands: [],
-                promptInputModel: undefined
-            }
-        };
-    }
-    async generateReplayEvent() {
-        return this.generateReplayEventSync();
-    }
-}
-
-export { TerminalRecorder };

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

@@ -1,22 +0,0 @@
-import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { IAgentConnection } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService";
-import type { IChatTerminalOutputSource } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
-/**
- * Read-only view of an AHP output channel. Unlike {@link AgentHostPty}, this
- * does not create a terminal process or an {@code ITerminalInstance}; chat
- * renders the accumulated plain-text state in its own detached xterm.
- */
-export declare class AgentHostOutputChannel extends Disposable implements IChatTerminalOutputSource {
-    private readonly _onDidChange;
-    readonly onDidChange: Event<void>;
-    private _output;
-    get output(): string;
-    private _hasExited;
-    get hasExited(): boolean;
-    private _exitCode;
-    get exitCode(): number | undefined;
-    constructor(connection: IAgentConnection, terminalUri: URI);
-    private _acceptState;
-}

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

@@ -1,48 +0,0 @@
-
-import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-root/state';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/state';
-import { TerminalLifecycleStatus } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-terminal/state';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/state';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-resource-watch/state';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation/state';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation-run/state';
-import { StateComponents } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
-
-class AgentHostOutputChannel extends Disposable {
-    get output() {
-        return this._output;
-    }
-    get hasExited() {
-        return this._hasExited;
-    }
-    get exitCode() {
-        return this._exitCode;
-    }
-    constructor(connection, terminalUri) {
-        super();
-        this._onDidChange = this._register(( new Emitter()));
-        this.onDidChange = this._onDidChange.event;
-        this._output = "";
-        this._hasExited = false;
-        const subscriptionRef = this._register(
-            connection.getSubscription(StateComponents.Terminal, terminalUri, "AgentHostOutputChannel")
-        );
-        const subscription = subscriptionRef.object;
-        if (subscription.value && !(subscription.value instanceof Error)) {
-            this._acceptState(subscription.value);
-        }
-        this._register(subscription.onDidChange(state => this._acceptState(state)));
-    }
-    _acceptState(state) {
-        this._output = ( state.content.map(part => part.type === "command" ? part.output : part.value)).join("").replace(/\r?\n/g, "\r\n");
-        const lifecycle = state.lifecycle;
-        this._hasExited = lifecycle.status === TerminalLifecycleStatus.Exited;
-        this._exitCode = lifecycle.status === TerminalLifecycleStatus.Exited ? lifecycle.exitCode : undefined;
-        this._onDidChange.fire();
-    }
-}
-
-export { AgentHostOutputChannel };

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

@@ -1,129 +0,0 @@
-import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
-import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { IProcessPropertyMap, ITerminalChildProcess, ITerminalLaunchError, ITerminalLaunchResult, ProcessPropertyType } 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 { IAgentConnection } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService";
-import { BasePty } from "../common/basePty.js";
-/**
- * Options for creating a new terminal on an agent host.
- */
-export interface IAgentHostPtyOptions {
-    /** Human-readable terminal name. */
-    readonly name?: string;
-    /** Initial working directory URI. */
-    readonly cwd?: URI;
-    /**
-     * When true, attach to an existing terminal on the agent host instead of
-     * creating a new one. The terminal must already exist server-side (e.g.
-     * created by a tool). The pty will subscribe to its state and replay
-     * content without calling `createTerminal`.
-     */
-    readonly attachOnly?: boolean;
-}
-export interface IAgentHostPtyCommandExecutedEvent {
-    readonly commandId: string;
-    readonly commandLine: string;
-    readonly timestamp: number;
-    /** The stored VT output for this command (present during content replay). */
-    readonly storedOutput?: string;
-}
-export interface IAgentHostPtyCommandFinishedEvent {
-    readonly commandId: string;
-    readonly exitCode?: number;
-    readonly durationMs?: number;
-}
-export declare enum AhpCommandMarkKind {
-    Executed = "s",
-    End = "e"
-}
-/**
- * Generates the mark ID used to correlate SetMark VT codes with xterm markers
- * via {@link IBufferMarkCapability.getMark}.
- */
-export declare function getAhpCommandMarkId(commandId: string, kind: AhpCommandMarkKind): string;
-/**
- * A pseudo-terminal backed by an Agent Host Protocol terminal subscription.
- *
- * Uses `customPtyImplementation` on `IShellLaunchConfig` so the
- * `TerminalProcessManager` bypasses the pty host backend entirely.
- *
- * Data flow:
- *   terminal/data   →  onProcessData
- *   terminal/exited →  onProcessExit
- *   input(data)     →  dispatch terminal/input
- *   resize(c,r)     →  dispatch terminal/resized
- *   shutdown()      →  disposeTerminal command
- */
-export declare class AgentHostPty extends BasePty implements ITerminalChildProcess {
-    private _connection;
-    private readonly _terminalUri;
-    private readonly _options;
-    private readonly _logService;
-    private readonly _startBarrier;
-    private readonly _lifetime;
-    private readonly _subscription;
-    private _terminalCreation;
-    private _initialCwd;
-    private _didSignalReady;
-    private readonly _onCommandExecuted;
-    readonly onCommandExecuted: Event<IAgentHostPtyCommandExecutedEvent>;
-    private readonly _onCommandFinished;
-    readonly onCommandFinished: Event<IAgentHostPtyCommandFinishedEvent>;
-    private readonly _onSupportsCommandDetection;
-    readonly onSupportsCommandDetection: Event<void>;
-    private _supportsCommandDetection;
-    get supportsCommandDetection(): boolean;
-    /**
-     * Command IDs for sentinel commands that should be suppressed from shell
-     * integration events. When the copilot shell tools fall back to sentinel-
-     * based exit code detection, shell integration may also detect the sentinel
-     * echo as a real command — we filter those out here.
-     */
-    private readonly _suppressedCommandIds;
-    constructor(id: number, _connection: IAgentConnection, _terminalUri: URI, _options: IAgentHostPtyOptions | undefined, _logService: ITerminalLogService);
-    start(): Promise<ITerminalLaunchError | ITerminalLaunchResult | undefined>;
-    private _clearTerminalCreation;
-    private _signalReady;
-    private _handleAction;
-    /**
-     * Replays structured terminal content parts from the initial state snapshot.
-     * Emits command lifecycle events for command parts so that consumers
-     * (e.g. {@link AhpTerminalCommandSource}) can reconstruct command history.
-     */
-    private _replayContent;
-    /**
-     * Resolves a cwd URI for sending over the protocol. Agent-host URIs
-     * are unwrapped to their original URI via {@link fromAgentHostUri}.
-     */
-    private _resolveCwdForProtocol;
-    private _createSubscription;
-    private _waitForHydration;
-    input(data: string): void;
-    resize(cols: number, rows: number): void;
-    shutdown(_immediate: boolean): void;
-    private _requestHostTerminalDisposal;
-    private _disposeHostTerminal;
-    private _logHostDisposalError;
-    private _exitAndDispose;
-    getInitialCwd(): Promise<string>;
-    getCwd(): Promise<string>;
-    clearBuffer(): Promise<void>;
-    acknowledgeDataEvent(_charCount: number): void;
-    setUnicodeVersion(_version: "6" | "11"): Promise<void>;
-    processBinary(_data: string): Promise<void>;
-    sendSignal(_signal: string): void;
-    refreshProperty<T extends ProcessPropertyType>(type: T): Promise<IProcessPropertyMap[T]>;
-    updateProperty<T extends ProcessPropertyType>(_type: T, _value: IProcessPropertyMap[T]): Promise<void>;
-    /**
-     * Reconnect this pty to a new agent host connection. Tears down the
-     * old subscription and re-subscribes with the new connection, replaying
-     * content from the server-side snapshot. Terminal output during the
-     * disconnect gap is a stream (not state), so some loss is expected.
-     *
-     * @returns `true` if reconnection succeeded, `false` otherwise.
-     */
-    reconnect(newConnection: IAgentConnection): Promise<boolean>;
-    /** The terminal URI this pty is subscribed to. */
-    get terminalUri(): URI;
-    dispose(): void;
-}