@codingame/monaco-vscode-xterm-common 30.0.0 → 31.0.0

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

@@ -0,0 +1,237 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, DisposableMap, toDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { AgentHostPty } from './agentHostPty.js';
+import { AhpTerminalCommandSource } from './ahpTerminalCommandSource.js';
+import { ITerminalService, ITerminalChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
+import { ITerminalProfileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal.service';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+
+const AGENT_HOST_PROFILE_EXT_ID = "vscode.agent-host-terminal";
+let AgentHostTerminalService = class AgentHostTerminalService extends Disposable {
+    constructor(
+        _terminalService,
+        _terminalChatService,
+        _terminalProfileService,
+        _quickInputService
+    ) {
+        super();
+        this._terminalService = _terminalService;
+        this._terminalChatService = _terminalChatService;
+        this._terminalProfileService = _terminalProfileService;
+        this._quickInputService = _quickInputService;
+        this._entries = [];
+        this._usedHosts = ( new Set());
+        this._profileRegistrations = this._register(( new DisposableMap()));
+        this._profiles = observableValue("agentHostTerminalProfiles", []);
+        this.profiles = this._profiles;
+        this._revivedInstances = ( new Map());
+    }
+    registerEntry(entry) {
+        this._entries.push(entry);
+        this._reconcile();
+        return toDisposable(() => {
+            const idx = this._entries.indexOf(entry);
+            if (idx >= 0) {
+                this._entries.splice(idx, 1);
+                this._reconcile();
+            }
+        });
+    }
+    getProfileForConnection(address) {
+        const entry = this._entries.find(e => e.address === address);
+        if (!entry) {
+            return undefined;
+        }
+        if (!( this._profileRegistrations.has(address))) {
+            this._usedHosts.add(address);
+            this._reconcile();
+        }
+        return this._profiles.get().find(p => p.address === address);
+    }
+    setDefaultCwd(cwd) {
+        this._defaultCwd = cwd;
+    }
+    _reconcile() {
+        const entries = this._entries;
+        const desiredProfiles = ( new Map());
+        if (entries.length === 0)
+            ; else if (entries.length === 1) {
+            desiredProfiles.set(entries[0].address, entries[0]);
+        } else {
+            let displaying = 0;
+            for (const address of this._usedHosts) {
+                const entry = entries.find(e => e.address === address);
+                if (entry) {
+                    displaying++;
+                    desiredProfiles.set(entry.address, entry);
+                }
+            }
+            if (displaying === entries.length - 1) {
+                const missing = entries.find(e => !( this._usedHosts.has(e.address)));
+                if (missing) {
+                    desiredProfiles.set(missing.address, missing);
+                }
+            } else if (displaying < entries.length) {
+                desiredProfiles.set("__quickpick__", {
+                    name: ( localize(13463, "Agent Host…")),
+                    address: "__quickpick__",
+                    getConnection: () => undefined
+                });
+            }
+        }
+        for (const [key, entry] of desiredProfiles) {
+            if (!( this._profileRegistrations.has(key))) {
+                this._registerProfile(key, entry, entries);
+            }
+        }
+        for (const key of ( this._profileRegistrations.keys())) {
+            if (!( desiredProfiles.has(key))) {
+                this._profileRegistrations.deleteAndDispose(key);
+            }
+        }
+        const infos = [];
+        for (const [key] of desiredProfiles) {
+            infos.push({
+                extensionIdentifier: AGENT_HOST_PROFILE_EXT_ID,
+                profileId: key,
+                title: key === "__quickpick__" ? ( localize(13463, "Agent Host…")) : ( localize(13464, "Agent Host ({0})", desiredProfiles.get(key).name)),
+                address: key
+            });
+        }
+        transaction(tx => {
+            this._profiles.set(infos, tx);
+        });
+    }
+    _registerProfile(key, entry, allEntries) {
+        const provider = {
+            createContributedTerminalProfile: async options => {
+                let connection;
+                let displayName = entry.name;
+                if (key === "__quickpick__") {
+                    const picks = ( allEntries.map(e => ({
+                        label: ( localize(13464, "Agent Host ({0})", e.name)),
+                        address: e.address,
+                        hostName: e.name
+                    })));
+                    const pick = await this._quickInputService.pick(picks, {
+                        placeHolder: ( localize(13465, "Select an agent host to open a terminal on"))
+                    });
+                    if (!pick) {
+                        return;
+                    }
+                    this._usedHosts.add(pick.address);
+                    this._reconcile();
+                    displayName = pick.hostName;
+                    connection = allEntries.find(e => e.address === pick.address)?.getConnection();
+                } else {
+                    connection = entry.getConnection();
+                }
+                if (!connection) {
+                    return;
+                }
+                await this.createTerminal(connection, {
+                    name: ( localize(13464, "Agent Host ({0})", displayName)),
+                    cwd: options.cwd ? (typeof options.cwd === "string" ? URI.file(options.cwd) : options.cwd) : this._defaultCwd,
+                    location: options.location
+                });
+            }
+        };
+        const title = key === "__quickpick__" ? ( localize(13463, "Agent Host…")) : ( localize(13464, "Agent Host ({0})", entry.name));
+        const store = ( new DisposableStore());
+        store.add(
+            this._terminalProfileService.registerTerminalProfileProvider(AGENT_HOST_PROFILE_EXT_ID, key, provider)
+        );
+        store.add(this._terminalProfileService.registerInternalContributedProfile({
+            extensionIdentifier: AGENT_HOST_PROFILE_EXT_ID,
+            id: key,
+            title,
+            icon: "remote"
+        }));
+        this._profileRegistrations.set(key, store);
+    }
+    async createTerminalForEntry(address, options) {
+        const entry = this._entries.find(e => e.address === address);
+        if (!entry) {
+            return undefined;
+        }
+        const connection = entry.getConnection();
+        if (!connection) {
+            return undefined;
+        }
+        return this.createTerminal(connection, options);
+    }
+    async createTerminal(connection, options) {
+        const terminalUri = ( URI.from({
+            scheme: "agenthost-terminal",
+            path: `/${generateUuid()}`
+        }));
+        const name = options?.name ?? ( localize(13466, "Agent Host Terminal"));
+        return this._terminalService.createTerminal({
+            config: {
+                customPtyImplementation: (id, cols, rows) => {
+                    const pty = ( new AgentHostPty(id, connection, terminalUri, {
+                        name,
+                        cwd: options?.cwd
+                    }));
+                    if (cols > 0 && rows > 0) {
+                        pty.resize(cols, rows);
+                    }
+                    return pty;
+                },
+                name,
+                icon: {
+                    id: "remote"
+                },
+                isFeatureTerminal: false
+            },
+            location: options?.location
+        });
+    }
+    async reviveTerminal(connection, terminalUri, terminalToolSessionId) {
+        const key = ( terminalUri.toString());
+        const existing = this._revivedInstances.get(key);
+        if (existing) {
+            return existing;
+        }
+        const store = ( new DisposableStore());
+        const commandSource = store.add(( new AhpTerminalCommandSource()));
+        store.add(
+            this._terminalChatService.registerAhpCommandSource(terminalToolSessionId, commandSource)
+        );
+        const instance = await this._terminalService.createTerminal({
+            config: {
+                customPtyImplementation: (id, cols, rows) => {
+                    const pty = ( new AgentHostPty(id, connection, terminalUri, {
+                        attachOnly: true
+                    }));
+                    if (cols > 0 && rows > 0) {
+                        pty.resize(cols, rows);
+                    }
+                    if (!store.isDisposed) {
+                        commandSource.connect(instance, pty);
+                    }
+                    return pty;
+                },
+                name: ( localize(13467, "Agent Host Terminal")),
+                isFeatureTerminal: true
+            }
+        });
+        this._terminalChatService.registerTerminalInstanceWithToolSession(terminalToolSessionId, instance);
+        this._revivedInstances.set(key, instance);
+        instance.store.add(store);
+        this._register(instance.onDisposed(() => {
+            this._revivedInstances.delete(key);
+        }));
+        return instance;
+    }
+};
+AgentHostTerminalService = ( __decorate([( __param(0, ITerminalService)), ( __param(1, ITerminalChatService)), ( __param(2, ITerminalProfileService)), ( __param(3, IQuickInputService))], AgentHostTerminalService));
+
+export { AgentHostTerminalService };

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

@@ -0,0 +1,111 @@
+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 type { IMarker } from "@xterm/xterm";
+import { type ITerminalCommand, type IMarkProperties } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities";
+import type { ITerminalOutputMatch, ITerminalOutputMatcher } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal";
+import type { IAhpTerminalCommandSource, ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import { AhpCommandMarkKind, type AgentHostPty } from "./agentHostPty.js";
+/**
+ * An implementation of {@link ITerminalCommand} backed by AHP protocol data
+ * rather than local shell integration markers. For streaming commands (arriving
+ * after initial subscription), real xterm markers are registered via
+ * {@link ITerminalInstance.registerMarker}. For replayed commands (from state
+ * snapshot), stored VT output is used as a fallback since marker positions are
+ * unreliable during bulk replay.
+ */
+export declare class AhpTerminalCommand implements ITerminalCommand {
+    command: string;
+    readonly commandLineConfidence: "low" | "medium" | "high";
+    readonly isTrusted: boolean;
+    timestamp: number;
+    duration: number;
+    readonly id: string;
+    readonly cwd: string | undefined;
+    exitCode: number | undefined;
+    readonly commandStartLineContent: string | undefined;
+    readonly markProperties: IMarkProperties | undefined;
+    readonly executedX: number | undefined;
+    readonly startX: number | undefined;
+    readonly promptStartMarker?: IMarker;
+    readonly marker?: IMarker;
+    readonly aliases?: string[][];
+    readonly wasReplayed?: boolean;
+    /**
+     * Lazily resolved executed marker. Uses a getter so that the marker is
+     * resolved on first access rather than at construction time, giving xterm
+     * a chance to flush the SetMark sequence through its async write queue.
+     */
+    get executedMarker(): IMarker | undefined;
+    private _executedMarker;
+    /**
+     * Lazily resolved end marker, same rationale as {@link executedMarker}.
+     */
+    get endMarker(): IMarker | undefined;
+    set endMarker(value: IMarker | undefined);
+    private _endMarker;
+    private _isComplete;
+    /**
+     * Stored VT output from the AHP content part. Used as a fallback when
+     * xterm markers are not available (e.g. during content replay).
+     */
+    private _storedOutput;
+    /**
+     * Optional function to lazily resolve markers from the terminal's
+     * {@link IBufferMarkCapability}. Set during construction.
+     */
+    private readonly _resolveMarker?;
+    constructor(commandId: string, commandLine: string, timestamp: number, options?: {
+        resolveMarker?: (kind: AhpCommandMarkKind) => IMarker | undefined;
+        storedOutput?: string;
+        wasReplayed?: boolean;
+    });
+    extractCommandLine(): string;
+    getOutput(): string | undefined;
+    /**
+     * Get the raw VT output (with ANSI escape codes preserved).
+     * Used by the terminal mirror for rendering.
+     */
+    getRawOutput(): string | undefined;
+    hasOutput(): boolean;
+    getOutputMatch(_outputMatcher: ITerminalOutputMatcher): ITerminalOutputMatch | undefined;
+    getPromptRowCount(): number;
+    getCommandRowCount(): number;
+    /**
+     * Append VT output to the stored output buffer. Called during streaming
+     * as `terminal/data` actions arrive.
+     */
+    appendOutput(data: string): void;
+    /**
+     * Mark this command as finished with the given exit code and duration.
+     */
+    finish(exitCode: number | undefined, durationMs: number | undefined): void;
+}
+/**
+ * A command detection source for AHP terminals. Listens to
+ * {@link AgentHostPty} command lifecycle events and maintains a list of
+ * {@link AhpTerminalCommand} objects, exposing an interface compatible with
+ * {@link IAhpTerminalCommandSource}.
+ */
+export declare class AhpTerminalCommandSource extends Disposable implements IAhpTerminalCommandSource {
+    private readonly _commands;
+    private _executingCommand;
+    private readonly _onCommandExecuted;
+    readonly onCommandExecuted: Event<ITerminalCommand>;
+    private readonly _onCommandFinished;
+    readonly onCommandFinished: Event<ITerminalCommand>;
+    private _terminalInstance;
+    get commands(): readonly ITerminalCommand[];
+    get executingCommandObject(): ITerminalCommand | undefined;
+    connect(terminalInstance: ITerminalInstance, pty: AgentHostPty): void;
+    getCommandById(id: string): ITerminalCommand | undefined;
+    /**
+     * Resolves an xterm marker by its AHP command mark ID from the
+     * {@link IBufferMarkCapability}. The marker is placed by xterm's OSC 633
+     * parser when it processes the SetMark sequence injected by
+     * {@link AgentHostPty}, so it is always at the correct cursor position
+     * regardless of whether the data was replayed or streamed.
+     */
+    private _resolveMarkById;
+    private _handleCommandExecuted;
+    private _handleCommandFinished;
+}

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

@@ -0,0 +1,138 @@
+
+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 { removeAnsiEscapeCodes } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities';
+import { AhpCommandMarkKind, getAhpCommandMarkId } from './agentHostPty.js';
+
+class AhpTerminalCommand {
+    get executedMarker() {
+        if (this._executedMarker === undefined && this._resolveMarker) {
+            this._executedMarker = this._resolveMarker(AhpCommandMarkKind.Executed);
+        }
+        return this._executedMarker;
+    }
+    get endMarker() {
+        if (this._endMarker === undefined && this._isComplete && this._resolveMarker) {
+            this._endMarker = this._resolveMarker(AhpCommandMarkKind.End);
+        }
+        return this._endMarker;
+    }
+    set endMarker(value) {
+        this._endMarker = value;
+    }
+    constructor(commandId, commandLine, timestamp, options) {
+        this.commandLineConfidence = "high";
+        this.isTrusted = false;
+        this.duration = 0;
+        this.cwd = undefined;
+        this.exitCode = undefined;
+        this.commandStartLineContent = undefined;
+        this.markProperties = undefined;
+        this.executedX = undefined;
+        this.startX = undefined;
+        this._isComplete = false;
+        this.id = commandId;
+        this.command = commandLine;
+        this.timestamp = timestamp;
+        this._resolveMarker = options?.resolveMarker;
+        this._storedOutput = options?.storedOutput;
+        this.wasReplayed = options?.wasReplayed;
+    }
+    extractCommandLine() {
+        return this.command;
+    }
+    getOutput() {
+        return this._storedOutput !== undefined ? removeAnsiEscapeCodes(this._storedOutput) : undefined;
+    }
+    getRawOutput() {
+        return this._storedOutput;
+    }
+    hasOutput() {
+        if (this._storedOutput !== undefined) {
+            return this._storedOutput.length > 0;
+        }
+        return false;
+    }
+    getOutputMatch(_outputMatcher) {
+        return undefined;
+    }
+    getPromptRowCount() {
+        return 1;
+    }
+    getCommandRowCount() {
+        return 1;
+    }
+    appendOutput(data) {
+        if (this._storedOutput === undefined) {
+            this._storedOutput = data;
+        } else {
+            this._storedOutput += data;
+        }
+    }
+    finish(exitCode, durationMs) {
+        this.exitCode = exitCode;
+        this.duration = durationMs ?? 0;
+        this._isComplete = true;
+    }
+}
+class AhpTerminalCommandSource extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._commands = [];
+        this._onCommandExecuted = this._register(( new Emitter()));
+        this.onCommandExecuted = this._onCommandExecuted.event;
+        this._onCommandFinished = this._register(( new Emitter()));
+        this.onCommandFinished = this._onCommandFinished.event;
+    }
+    get commands() {
+        return this._commands;
+    }
+    get executingCommandObject() {
+        return this._executingCommand;
+    }
+    connect(terminalInstance, pty) {
+        this._terminalInstance = terminalInstance;
+        this._register(pty.onCommandExecuted(e => this._handleCommandExecuted(e)));
+        this._register(pty.onCommandFinished(e => this._handleCommandFinished(e)));
+        this._register(terminalInstance.onWillData(data => {
+            if (this._executingCommand && !this._executingCommand.wasReplayed) {
+                this._executingCommand.appendOutput(data);
+            }
+        }));
+    }
+    getCommandById(id) {
+        if (this._executingCommand?.id === id) {
+            return this._executingCommand;
+        }
+        return this._commands.find(c => c.id === id);
+    }
+    _resolveMarkById(commandId, kind) {
+        const markId = getAhpCommandMarkId(commandId, kind);
+        const bufferMarkCapability = this._terminalInstance?.capabilities.get(TerminalCapability.BufferMarkDetection);
+        return bufferMarkCapability?.getMark(markId);
+    }
+    _handleCommandExecuted(event) {
+        const command = ( new AhpTerminalCommand(event.commandId, event.commandLine, event.timestamp, {
+            resolveMarker: kind => this._resolveMarkById(event.commandId, kind),
+            storedOutput: event.storedOutput,
+            wasReplayed: event.storedOutput !== undefined
+        }));
+        this._executingCommand = command;
+        this._onCommandExecuted.fire(command);
+    }
+    _handleCommandFinished(event) {
+        const command = this._executingCommand?.id === event.commandId ? this._executingCommand : this._commands.find(c => c.id === event.commandId);
+        if (!command) {
+            return;
+        }
+        command.finish(event.exitCode, event.durationMs);
+        if (this._executingCommand === command) {
+            this._executingCommand = undefined;
+            this._commands.push(command);
+        }
+        this._onCommandFinished.fire(command);
+    }
+}
+
+export { AhpTerminalCommand, AhpTerminalCommandSource };

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

@@ -24,7 +24,7 @@ let EnvironmentVariableInfoStale = class EnvironmentVariableInfoStale {
         addExtensionIdentifiers(extSet, ( this._diff.removed.values()));
         addExtensionIdentifiers(extSet, ( this._diff.changed.values()));
         let message = ( localize(
-            13332,
+            13472,
             "The following extensions want to relaunch the terminal to contribute to its environment:"
         ));
         message += getMergedDescription(this._collection, scope, this._extensionService, extSet);
@@ -32,7 +32,7 @@ let EnvironmentVariableInfoStale = class EnvironmentVariableInfoStale {
     }
     _getActions() {
         return [{
-            label: ( localize(13333, "Relaunch Terminal")),
+            label: ( localize(13473, "Relaunch Terminal")),
             run: () => this._terminalService.getInstanceFromId(this._terminalId)?.relaunch(),
             commandId: TerminalCommandId.Relaunch
         }];
@@ -59,7 +59,7 @@ let EnvironmentVariableInfoChangesActive = class EnvironmentVariableInfoChangesA
         const extSet = ( new Set());
         addExtensionIdentifiers(extSet, ( this._collection.getVariableMap(scope).values()));
         let message = ( localize(
-            13334,
+            13474,
             "The following extensions have contributed to this terminal's environment:"
         ));
         message += getMergedDescription(this._collection, scope, this._extensionService, extSet);
@@ -67,7 +67,7 @@ let EnvironmentVariableInfoChangesActive = class EnvironmentVariableInfoChangesA
     }
     _getActions(scope) {
         return [{
-            label: ( localize(13335, "Show Environment Contributions")),
+            label: ( localize(13475, "Show Environment Contributions")),
             run: () => this._commandService.executeCommand(TerminalCommandId.ShowEnvironmentContributions, scope),
             commandId: TerminalCommandId.ShowEnvironmentContributions
         }];
@@ -95,7 +95,7 @@ function getMergedDescription(collection, scope, extensionService, extSet) {
         }
         const workspaceDescription = workspaceDescriptions.get(ext);
         if (workspaceDescription) {
-            const workspaceSuffix = globalDescription ? ` (${( localize(13336, "workspace"))})` : "";
+            const workspaceSuffix = globalDescription ? ` (${( localize(13476, "workspace"))})` : "";
             message.push(`\n- \`${getExtensionName(ext, extensionService)}${workspaceSuffix}\``);
             message.push(`: ${workspaceDescription}`);
         }