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

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

@@ -1,345 +0,0 @@
-
-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 { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
-import { AgentHostPty } from './agentHostPty.js';
-import { AgentHostOutputChannel } from './agentHostOutputChannel.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,
-        _logService
-    ) {
-        super();
-        this._terminalService = _terminalService;
-        this._terminalChatService = _terminalChatService;
-        this._terminalProfileService = _terminalProfileService;
-        this._quickInputService = _quickInputService;
-        this._logService = _logService;
-        this._entries = [];
-        this._usedHosts = ( new Set());
-        this._profileRegistrations = this._register(( new DisposableMap()));
-        this._profiles = observableValue("agentHostTerminalProfiles", []);
-        this.profiles = this._profiles;
-        this._revivedInstances = ( new Map());
-        this._activePtys = ( new Map());
-        this._pendingRevives = ( 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(16804, "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(16804, "Agent Host…")) : ( localize(16805, "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(16805, "Agent Host ({0})", e.name)),
-                        address: e.address,
-                        hostName: e.name
-                    })));
-                    const pick = await this._quickInputService.pick(picks, {
-                        placeHolder: ( localize(16806, "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(16805, "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(16804, "Agent Host…")) : ( localize(16805, "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(16807, "Agent Host Terminal"));
-        const key = ( terminalUri.toString());
-        const ptyRegistration = this._createPtyRegistration(key, connection.clientId);
-        let instance;
-        try {
-            instance = await this._terminalService.createTerminal({
-                config: {
-                    customPtyImplementation: (id, cols, rows) => {
-                        const pty = ( new AgentHostPty(id, connection, terminalUri, {
-                            name,
-                            cwd: options?.cwd
-                        }, this._logService));
-                        if (cols > 0 && rows > 0) {
-                            pty.resize(cols, rows);
-                        }
-                        ptyRegistration.setPty(pty);
-                        return pty;
-                    },
-                    name,
-                    icon: {
-                        id: "remote"
-                    },
-                    isFeatureTerminal: false
-                },
-                location: options?.location
-            });
-        } catch (error) {
-            ptyRegistration.dispose();
-            throw error;
-        }
-        this._registerInstancePtyCleanup(instance, key, ptyRegistration);
-        return instance;
-    }
-    async reviveTerminal(connection, terminalUri, terminalToolSessionId) {
-        const key = ( terminalUri.toString());
-        const pending = this._pendingRevives.get(key);
-        if (pending) {
-            return pending;
-        }
-        const revive = this._doReviveTerminal(connection, terminalUri, terminalToolSessionId, key).finally(() => {
-            if (this._pendingRevives.get(key) === revive) {
-                this._pendingRevives.delete(key);
-            }
-        });
-        this._pendingRevives.set(key, revive);
-        return revive;
-    }
-    attachOutputTerminal(connection, terminalUri, terminalToolSessionId) {
-        const store = ( new DisposableStore());
-        const source = store.add(( new AgentHostOutputChannel(connection, terminalUri)));
-        store.add(
-            this._terminalChatService.registerOutputSource(terminalToolSessionId, source)
-        );
-        return store;
-    }
-    async _doReviveTerminal(connection, terminalUri, terminalToolSessionId, key) {
-        const existing = this._revivedInstances.get(key);
-        if (existing) {
-            return existing;
-        }
-        const store = ( new DisposableStore());
-        const commandSource = store.add(( new AhpTerminalCommandSource()));
-        const ptyRegistration = this._createPtyRegistration(key, connection.clientId);
-        const instancePromise = Promise.resolve().then(() => this._terminalService.createTerminal({
-            config: {
-                customPtyImplementation: (id, cols, rows) => {
-                    const pty = ( new AgentHostPty(id, connection, terminalUri, {
-                        attachOnly: true
-                    }, this._logService));
-                    if (cols > 0 && rows > 0) {
-                        pty.resize(cols, rows);
-                    }
-                    if (!store.isDisposed) {
-                        commandSource.connect(instance, pty);
-                    }
-                    ptyRegistration.setPty(pty);
-                    return pty;
-                },
-                name: ( localize(16808, "Agent Host Terminal")),
-                isFeatureTerminal: true,
-                hideFromUser: true
-            }
-        }));
-        store.add(
-            this._terminalChatService.registerAhpCommandSource(terminalToolSessionId, commandSource, instancePromise)
-        );
-        let instance;
-        try {
-            instance = await instancePromise;
-        } catch (error) {
-            store.dispose();
-            ptyRegistration.dispose();
-            throw error;
-        }
-        this._terminalChatService.registerTerminalInstanceWithToolSession(terminalToolSessionId, instance);
-        this._revivedInstances.set(key, instance);
-        instance.store.add(store);
-        this._registerInstancePtyCleanup(instance, key, ptyRegistration);
-        return instance;
-    }
-    _createPtyRegistration(key, clientId) {
-        let pty;
-        let isDisposed = false;
-        return {
-            setPty: value => {
-                if (isDisposed) {
-                    value.dispose();
-                    return;
-                }
-                pty = value;
-                this._activePtys.set(key, {
-                    pty,
-                    clientId
-                });
-            },
-            dispose: () => {
-                if (isDisposed) {
-                    return;
-                }
-                isDisposed = true;
-                if (this._activePtys.get(key)?.pty === pty) {
-                    this._activePtys.delete(key);
-                }
-                pty?.dispose();
-            }
-        };
-    }
-    _registerInstancePtyCleanup(instance, key, ptyRegistration) {
-        const cleanup = () => {
-            if (this._revivedInstances.get(key) === instance) {
-                this._revivedInstances.delete(key);
-            }
-            ptyRegistration.dispose();
-        };
-        if (instance.isDisposed) {
-            cleanup();
-        } else {
-            instance.store.add(instance.onDisposed(cleanup));
-        }
-    }
-    async reconnectTerminals(newConnection, oldClientId) {
-        const entries = [...this._activePtys.entries()].filter(([, entry]) => entry.clientId === oldClientId);
-        const total = entries.length;
-        let recovered = 0;
-        const promises = [];
-        for (const [key, entry] of entries) {
-            promises.push(entry.pty.reconnect(newConnection).then(success => {
-                if (success) {
-                    recovered++;
-                    entry.clientId = newConnection.clientId;
-                } else {
-                    this._logService.warn(`[AgentHostTerminalService] Failed to reconnect terminal: ${key}`);
-                }
-            }));
-        }
-        await Promise.all(promises);
-        return {
-            recovered,
-            total
-        };
-    }
-};
-AgentHostTerminalService = ( __decorate([( __param(0, ITerminalService)), ( __param(1, ITerminalChatService)), ( __param(2, ITerminalProfileService)), ( __param(3, IQuickInputService)), ( __param(4, ITerminalLogService))], AgentHostTerminalService));
-
-export { AgentHostTerminalService };

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

@@ -1,111 +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 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

@@ -1,138 +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 { 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.d.ts

@@ -1,28 +0,0 @@
-import { IEnvironmentVariableInfo } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/environmentVariable";
-import { ITerminalStatus } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal";
-import { ITerminalService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
-import { EnvironmentVariableScope, IMergedEnvironmentVariableCollection, IMergedEnvironmentVariableCollectionDiff } from "../../../../platform/terminal/common/environmentVariable.js";
-import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
-import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
-export declare class EnvironmentVariableInfoStale implements IEnvironmentVariableInfo {
-    private readonly _diff;
-    private readonly _terminalId;
-    private readonly _collection;
-    private readonly _terminalService;
-    private readonly _extensionService;
-    readonly requiresAction = true;
-    constructor(_diff: IMergedEnvironmentVariableCollectionDiff, _terminalId: number, _collection: IMergedEnvironmentVariableCollection, _terminalService: ITerminalService, _extensionService: IExtensionService);
-    private _getInfo;
-    private _getActions;
-    getStatus(scope: EnvironmentVariableScope | undefined): ITerminalStatus;
-}
-export declare class EnvironmentVariableInfoChangesActive implements IEnvironmentVariableInfo {
-    private readonly _collection;
-    private readonly _commandService;
-    private readonly _extensionService;
-    readonly requiresAction = false;
-    constructor(_collection: IMergedEnvironmentVariableCollection, _commandService: ICommandService, _extensionService: IExtensionService);
-    private _getInfo;
-    private _getActions;
-    getStatus(scope: EnvironmentVariableScope | undefined): ITerminalStatus;
-}