@codingame/monaco-vscode-chat-service-override 37.2.0 → 37.3.1

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostCustomizationHarness.d.ts

@@ -0,0 +1,31 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import type { IAgentConnection } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService";
+import { type Customization } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+import { IFileDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service";
+import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
+import { IAICustomizationWorkspaceService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService.service";
+import { ICustomizationSyncProvider, type IHarnessDescriptor, type ICustomizationItemAction } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/customizationHarnessService";
+import { AgentCustomizationItemProvider } from "../../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentCustomizationItemProvider.js";
+/**
+ * Owns the client-side UI commands for configuring plugins on a remote
+ * agent host. The actual source of truth lives in the host's root config.
+ */
+export declare class RemoteAgentPluginController extends Disposable {
+    private readonly _hostLabel;
+    private readonly _connectionAuthority;
+    private readonly _connection;
+    private readonly _fileDialogService;
+    private readonly _notificationService;
+    readonly pluginActions: readonly ICustomizationItemAction[];
+    constructor(_hostLabel: string, _connectionAuthority: string, _connection: IAgentConnection, _fileDialogService: IFileDialogService, _notificationService: INotificationService, _workspaceService: IAICustomizationWorkspaceService);
+    removeConfiguredPlugin(customizationToRemove: Customization): Promise<void>;
+    private getConfiguredCustomizations;
+    private dispatchCustomizations;
+    private pickRemotePluginFolder;
+    private addConfiguredPlugin;
+}
+/**
+ * Creates a {@link IHarnessDescriptor} for a remote agent discovered via
+ * the agent host protocol.
+ */
+export declare function createRemoteAgentHarnessDescriptor(harnessId: string, displayName: string, controller: RemoteAgentPluginController, itemProvider: AgentCustomizationItemProvider, syncProvider: ICustomizationSyncProvider): IHarnessDescriptor;

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostCustomizationHarness.js

@@ -0,0 +1,136 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { getAgentHostConfiguredCustomizations, AgentHostConfigKey } from '../../../../../platform/agentHost/common/agentHostCustomizationConfig.js';
+import { agentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostFileSystemProvider';
+import { AGENT_HOST_SCHEME, fromAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/notifications';
+import { ROOT_STATE_URI, customizationId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { IFileDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { AICustomizationManagementSection } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService';
+import { IAICustomizationWorkspaceService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-root/state';
+import { CustomizationType } from '@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 '@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';
+
+function customizationKey(customization) {
+    return customization.uri;
+}
+let RemoteAgentPluginController = class RemoteAgentPluginController extends Disposable {
+    constructor(
+        _hostLabel,
+        _connectionAuthority,
+        _connection,
+        _fileDialogService,
+        _notificationService,
+        _workspaceService
+    ) {
+        super();
+        this._hostLabel = _hostLabel;
+        this._connectionAuthority = _connectionAuthority;
+        this._connection = _connection;
+        this._fileDialogService = _fileDialogService;
+        this._notificationService = _notificationService;
+        this.pluginActions = [{
+            id: "remoteAgentHost.addPlugin",
+            label: ( localize(4410, "Add Remote Plugin")),
+            tooltip: ( localize(4411, "Add a plugin folder that already exists on this remote agent host.")),
+            icon: Codicon.remote,
+            run: () => this.addConfiguredPlugin()
+        }];
+    }
+    async removeConfiguredPlugin(customizationToRemove) {
+        const updated = this.getConfiguredCustomizations().filter(
+            customization => customizationKey(customization) !== customizationKey(customizationToRemove)
+        );
+        this.dispatchCustomizations(updated);
+    }
+    getConfiguredCustomizations() {
+        const rootState = this._connection.rootState.value;
+        if (!rootState || rootState instanceof Error) {
+            return [];
+        }
+        return getAgentHostConfiguredCustomizations(rootState.config?.values);
+    }
+    dispatchCustomizations(customizations) {
+        this._connection.dispatch(ROOT_STATE_URI, {
+            type: ActionType.RootConfigChanged,
+            config: {
+                [AgentHostConfigKey.Customizations]: customizations.map(c => ({
+                    uri: c.uri,
+                    displayName: c.name
+                }))
+            }
+        });
+    }
+    async pickRemotePluginFolder(title) {
+        try {
+            const selected = await this._fileDialogService.showOpenDialog({
+                canSelectFiles: false,
+                canSelectFolders: true,
+                canSelectMany: false,
+                title,
+                availableFileSystems: [AGENT_HOST_SCHEME],
+                defaultUri: agentHostUri(this._connectionAuthority, "/")
+            });
+            return selected?.[0];
+        } catch {
+            return undefined;
+        }
+    }
+    async addConfiguredPlugin() {
+        const selected = await this.pickRemotePluginFolder(( localize(4412, "Select Plugin Folder on {0}", this._hostLabel)));
+        if (!selected) {
+            return;
+        }
+        const original = fromAgentHostUri(selected);
+        const uriString = ( original.toString());
+        const newCustomization = {
+            type: CustomizationType.Plugin,
+            id: customizationId(uriString),
+            uri: uriString,
+            name: basename(original) || original.path
+        };
+        const current = this.getConfiguredCustomizations();
+        const nextKey = customizationKey(newCustomization);
+        if (( current.some(customization => customizationKey(customization) === nextKey))) {
+            this._notificationService.info(( localize(
+                4413,
+                "'{0}' is already configured on {1}.",
+                newCustomization.name,
+                this._hostLabel
+            )));
+            return;
+        }
+        this.dispatchCustomizations([...current, newCustomization]);
+    }
+};
+RemoteAgentPluginController = ( __decorate([( __param(3, IFileDialogService)), ( __param(4, INotificationService)), ( __param(5, IAICustomizationWorkspaceService))], RemoteAgentPluginController));
+function createRemoteAgentHarnessDescriptor(harnessId, displayName, controller, itemProvider, syncProvider) {
+    return {
+        id: harnessId,
+        label: displayName,
+        icon: ThemeIcon.fromId(Codicon.remote.id),
+        hiddenSections: [
+            AICustomizationManagementSection.Models,
+            AICustomizationManagementSection.McpServers
+        ],
+        hideGenerateButton: true,
+        itemProvider,
+        syncProvider,
+        pluginActions: controller.pluginActions
+    };
+}
+
+export { RemoteAgentPluginController, createRemoteAgentHarnessDescriptor };

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostLogForwarder.d.ts

@@ -0,0 +1,103 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { type AgentHostProtocolClient } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/browser/agentHostProtocolClient";
+import { IOutputService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/output/common/output.service";
+/**
+ * Forwarder that bridges a connected {@link AgentHostProtocolClient}'s
+ * OTLP logs channel into the workbench's Output panel.
+ *
+ * For each {@link AgentHostClientState.Connected} transition (initial
+ * handshake or post-reconnect) where the host advertised
+ * `telemetry.logs`, the forwarder:
+ *
+ * - Lazily registers an Output channel via
+ *   {@link IOutputChannelRegistry.registerChannel} keyed by the host's
+ *   stable address so subsequent connects reuse the same channel and the
+ *   user keeps any logs from previous sessions visible in the picker.
+ * - Subscribes to the host's logs channel at the level matching the
+ *   workbench's current {@link ILogService} level and re-subscribes when
+ *   that level changes.
+ * - Decodes incoming `otlp/exportLogs` notifications and appends each
+ *   record to the Output channel.
+ *
+ * Output channels are deliberately NOT removed when the host disconnects —
+ * the user expects to still be able to inspect prior log output, and the
+ * count of remote hosts is small so leaking them is fine.
+ *
+ * The local agent host has its own out-of-band IPC log forwarder
+ * (`AgentHostProcessManager` + `LoggerChannel`) and does NOT route through
+ * this class.
+ */
+export declare class RemoteAgentHostLogForwarder extends Disposable {
+    private readonly _client;
+    private readonly _outputService;
+    private readonly _logService;
+    private readonly _channelId;
+    private readonly _channelLabel;
+    private _outputChannel;
+    private _channelRegistered;
+    /** Whether the one-time host build-info header has been written. */
+    private _buildInfoHeaderWritten;
+    /** Tracks whatever needs to be torn down for a single subscribe cycle. */
+    private readonly _subscriptionStore;
+    private _currentLevel;
+    constructor(_client: AgentHostProtocolClient, address: string, displayName: string, _outputService: IOutputService, _logService: ILogService);
+    /**
+     * (Re-)subscribe to the host's logs channel at the level matching the
+     * workbench's current log level. Replaces any prior subscription.
+     * Silent no-op when the host did not advertise a logs channel —
+     * there is nothing to subscribe to.
+     */
+    private _attach;
+    /**
+     * Register the per-host Output channel on first attach. Subsequent
+     * calls are no-ops — registering the same id twice replaces the
+     * existing channel.
+     *
+     * The channel is intentionally never deregistered: the host count is
+     * small, and the user typically wants to inspect logs after a host
+     * has disconnected (e.g. when diagnosing why it dropped).
+     */
+    private _ensureChannelRegistered;
+    /**
+     * Drop the current subscription (if any). Idempotent. The Output
+     * channel registration is preserved — only the in-flight subscribe
+     * is undone.
+     */
+    private _detach;
+    /**
+     * Resolve the level we want to subscribe at from the workbench's
+     * global log level. `Off` yields `undefined` so the caller can drop
+     * any existing subscription.
+     */
+    private _levelFromLogService;
+    /**
+     * Expand the host's RFC 6570 URI template to a concrete subscribable
+     * channel URI. Hosts that hard-code a literal channel (no template
+     * variables) round-trip verbatim — `UriTemplate.resolve` substitutes
+     * any `{level}` variable and otherwise emits the literal sequence.
+     *
+     * Using `UriTemplate.parse` (rather than a hand-rolled `.replace`)
+     * keeps the implementation spec-conformant: the host can theoretically
+     * advertise variants like `{?level}` or pin additional unknown
+     * variables the protocol may later define.
+     */
+    private _expandLogsChannel;
+    /**
+     * Decode an OTLP/JSON `ExportLogsServiceRequest` payload and append
+     * each contained record to the registered Output channel. Records
+     * whose severity is below the workbench's current log level are
+     * filtered defensively (the host *should* have honoured `{level}`
+     * but the spec says we MUST still filter).
+     */
+    private _handleBatch;
+    /**
+     * Write a one-time header line with the host's build info (version,
+     * commit, date, quality) read from the connected client's root state.
+     * Lets the user see which build is hosting the agent host in the
+     * forwarded Output channel. No-op when the root state has not arrived
+     * or carries no build info, and only ever writes once.
+     */
+    private _writeHostBuildInfoHeader;
+    private _appendLine;
+}

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostLogForwarder.js

@@ -0,0 +1,173 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, MutableDisposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { UriTemplate } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uriTemplate';
+import { LogLevel } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { logLevelToOtlpLevelName, iterateOtlpLogRecords, severityNumberToLogLevel } from '../../../../../platform/agentHost/common/otlp/otlpLogEmitter.js';
+import { AgentHostClientState } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/browser/agentHostProtocolClient';
+import { remoteAgentHostLogOutputChannelId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService';
+import { readHostBuildInfo, formatHostBuildInfo } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/output/common/output';
+import { IOutputService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/output/common/output.service';
+
+let RemoteAgentHostLogForwarder = class RemoteAgentHostLogForwarder extends Disposable {
+    constructor(_client, address, displayName, _outputService, _logService) {
+        super();
+        this._client = _client;
+        this._outputService = _outputService;
+        this._logService = _logService;
+        this._channelRegistered = false;
+        this._buildInfoHeaderWritten = false;
+        this._subscriptionStore = this._register(( new MutableDisposable()));
+        this._channelId = remoteAgentHostLogOutputChannelId(address);
+        this._channelLabel = `Agent Host (${displayName})`;
+        this._register(_client.onDidChangeConnectionState(state => {
+            switch (state) {
+            case AgentHostClientState.Connected:
+                this._attach();
+                break;
+            case AgentHostClientState.Reconnecting:
+            case AgentHostClientState.Incompatible:
+            case AgentHostClientState.Closed:
+                this._detach();
+                break;
+            }
+        }));
+        this._register(_logService.onDidChangeLogLevel(() => this._attach()));
+        this._register(_client.onDidReceiveOtlpLogs(params => {
+            this._handleBatch(params.payload);
+        }));
+        if (_client.connectionState === AgentHostClientState.Connected) {
+            this._attach();
+        }
+    }
+    _attach() {
+        if (this._client.connectionState !== AgentHostClientState.Connected) {
+            return;
+        }
+        const template = this._client.initializeResult.get()?.telemetry?.logs;
+        if (!template) {
+            return;
+        }
+        const desiredLevel = this._levelFromLogService();
+        if (!desiredLevel) {
+            this._detach();
+            return;
+        }
+        if (this._subscriptionStore.value && this._currentLevel === desiredLevel) {
+            return;
+        }
+        this._ensureChannelRegistered();
+        this._writeHostBuildInfoHeader();
+        const store = ( new DisposableStore());
+        this._subscriptionStore.value = store;
+        this._currentLevel = desiredLevel;
+        const channelUri = this._expandLogsChannel(template, desiredLevel);
+        this._client.subscribeStateless(( URI.parse(channelUri))).catch(err => {
+            this._appendLine(
+                `Failed to subscribe to OTLP logs channel ${channelUri}: ${formatError(err)}`
+            );
+        });
+        store.add(toDisposable(() => {
+            try {
+                this._client.unsubscribe(( URI.parse(channelUri)));
+            } catch {}
+        }));
+    }
+    _ensureChannelRegistered() {
+        if (this._channelRegistered) {
+            return;
+        }
+        this._channelRegistered = true;
+        const registry = ( Registry.as(Extensions.OutputChannels));
+        if (!registry.getChannel(this._channelId)) {
+            registry.registerChannel({
+                id: this._channelId,
+                label: this._channelLabel,
+                log: false,
+                languageId: "log"
+            });
+        }
+    }
+    _detach() {
+        this._subscriptionStore.clear();
+        this._currentLevel = undefined;
+    }
+    _levelFromLogService() {
+        const level = this._logService.getLevel();
+        if (level === LogLevel.Off) {
+            return undefined;
+        }
+        return logLevelToOtlpLevelName(level) ?? "info";
+    }
+    _expandLogsChannel(template, level) {
+        return UriTemplate.parse(template).resolve({
+            level
+        });
+    }
+    _handleBatch(payload) {
+        if (!this._channelRegistered) {
+            return;
+        }
+        const loggerLevel = this._logService.getLevel();
+        if (loggerLevel === LogLevel.Off) {
+            return;
+        }
+        for (const record of iterateOtlpLogRecords(payload)) {
+            const level = severityNumberToLogLevel(record.severityNumber);
+            if (level < loggerLevel) {
+                continue;
+            }
+            this._appendLine(formatRecord(record));
+        }
+    }
+    _writeHostBuildInfoHeader() {
+        if (this._buildInfoHeaderWritten) {
+            return;
+        }
+        const rootState = this._client.rootState.value;
+        if (!rootState || rootState instanceof Error) {
+            return;
+        }
+        const buildInfo = readHostBuildInfo(rootState);
+        if (!buildInfo) {
+            return;
+        }
+        this._buildInfoHeaderWritten = true;
+        this._appendLine(`Agent host version ${formatHostBuildInfo(buildInfo)}`);
+    }
+    _appendLine(text) {
+        if (!this._outputChannel) {
+            this._outputChannel = this._outputService.getChannel(this._channelId);
+            if (!this._outputChannel) {
+                return;
+            }
+        }
+        this._outputChannel.append(text.endsWith("\n") ? text : `${text}\n`);
+    }
+};
+RemoteAgentHostLogForwarder = ( __decorate([( __param(3, IOutputService)), ( __param(4, ILogService))], RemoteAgentHostLogForwarder));
+function formatRecord(record) {
+    const timestamp = formatTimestamp(record.timeUnixNano);
+    const severity = record.severityText.toUpperCase().padEnd(5);
+    const attributes = record.attributes && ( Object.keys(record.attributes)).length > 0 ? ` ${JSON.stringify(record.attributes)}` : "";
+    return `[${timestamp}] [${severity}] ${record.body}${attributes}`;
+}
+function formatTimestamp(timeUnixNano) {
+    const ms = timeUnixNano.length > 6 ? Number(timeUnixNano.slice(0, -6)) : 0;
+    if (!Number.isFinite(ms)) {
+        return ( new Date()).toISOString();
+    }
+    return ( new Date(ms)).toISOString();
+}
+function formatError(err) {
+    if (err instanceof Error) {
+        return err.message;
+    }
+    return String(err);
+}
+
+export { RemoteAgentHostLogForwarder };

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostTerminal.contribution.d.ts

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostTerminal.contribution.js

@@ -0,0 +1,51 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { RemoteAgentHostConnectionStatus } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService';
+import { IRemoteAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IAgentHostTerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/agentHostTerminalService.service';
+
+let RemoteAgentHostTerminalContribution = class RemoteAgentHostTerminalContribution extends Disposable {
+    constructor(_remoteAgentHostService, _agentHostTerminalService) {
+        super();
+        this._remoteAgentHostService = _remoteAgentHostService;
+        this._agentHostTerminalService = _agentHostTerminalService;
+        this._remoteEntries = this._register(( new DisposableMap()));
+        this._register(
+            this._remoteAgentHostService.onDidChangeConnections(() => this._reconcileRemote())
+        );
+        this._reconcileRemote();
+    }
+    _reconcileRemote() {
+        const connectedAddresses = ( new Set());
+        for (const info of this._remoteAgentHostService.connections) {
+            if (!RemoteAgentHostConnectionStatus.isConnected(info.status)) {
+                continue;
+            }
+            const connection = this._remoteAgentHostService.getConnection(info.address);
+            if (!connection) {
+                continue;
+            }
+            connectedAddresses.add(info.address);
+            if (!( this._remoteEntries.has(info.address))) {
+                this._remoteEntries.set(info.address, this._agentHostTerminalService.registerEntry({
+                    name: info.name || info.address,
+                    address: info.address,
+                    getConnection: () => connection
+                }));
+            }
+        }
+        for (const address of ( this._remoteEntries.keys())) {
+            if (!( connectedAddresses.has(address))) {
+                this._remoteEntries.deleteAndDispose(address);
+            }
+        }
+    }
+};
+RemoteAgentHostTerminalContribution = ( __decorate([( __param(0, IRemoteAgentHostService)), ( __param(1, IAgentHostTerminalService))], RemoteAgentHostTerminalContribution));
+registerWorkbenchContribution2(
+    "workbench.contrib.remoteAgentHostTerminal",
+    RemoteAgentHostTerminalContribution,
+    WorkbenchPhase.AfterRestored
+);

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/tunnelAgentHost.contribution.d.ts

@@ -0,0 +1,74 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IRemoteAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service";
+import { ITunnelAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/tunnelAgentHost.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
+import { IRemoteTunnelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/remoteTunnel/common/remoteTunnel.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IAuthenticationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service";
+import { IHostService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { IAgentHostFilterService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/agentHostFilter/common/agentHostFilter.service";
+import { RemoteAgentHostSessionsProvider } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostSessionsProvider";
+export declare class TunnelAgentHostContribution extends Disposable implements IWorkbenchContribution {
+    private readonly _tunnelService;
+    private readonly _remoteAgentHostService;
+    private readonly _sessionsProvidersService;
+    private readonly _configurationService;
+    private readonly _instantiationService;
+    private readonly _notificationService;
+    private readonly _logService;
+    private readonly _authenticationService;
+    private readonly _telemetryService;
+    private readonly _hostService;
+    private readonly _remoteTunnelService;
+    static readonly ID = "sessions.contrib.tunnelAgentHostContribution";
+    private readonly _providerStores;
+    private readonly _providerInstances;
+    private readonly _pendingConnects;
+    private _lastStatusCheck;
+    private readonly _hostedTunnelSuppressions;
+    private _remoteTunnelStatus;
+    private _hasReceivedRemoteTunnelStatus;
+    /**
+     * `false` until the first {@link _silentStatusCheck} resolves. Until then
+     * we keep newly-created providers in the `Connecting` state so the picker
+     * doesn't briefly show every cached tunnel as "Offline" on startup.
+     */
+    private _initialStatusChecked;
+    private readonly _wiredAddresses;
+    constructor(_tunnelService: ITunnelAgentHostService, _remoteAgentHostService: IRemoteAgentHostService, _sessionsProvidersService: ISessionsProvidersService, _configurationService: IConfigurationService, _instantiationService: IInstantiationService, _notificationService: INotificationService, _logService: ILogService, _authenticationService: IAuthenticationService, _telemetryService: ITelemetryService, _hostService: IHostService, _remoteTunnelService: IRemoteTunnelService, agentHostFilterService: IAgentHostFilterService);
+    /**
+     * Called by the workspace picker when it opens. Silently re-checks
+     * tunnel statuses if more than 5 minutes have elapsed since the last check.
+     */
+    checkTunnelStatuses(): Promise<void>;
+    private _reconcileProviders;
+    private _getProviderTunnels;
+    private _isHostedTunnel;
+    private _loadRemoteTunnelStatus;
+    private _syncHostedTunnelSuppression;
+    private _createProvider;
+    protected _instantiateProvider(address: string, name: string): RemoteAgentHostSessionsProvider;
+    private _updateConnectionStatuses;
+    /**
+     * Wire live connections to their providers so session operations work, and
+     * drop a provider's connection once its transport is gone.
+     */
+    private _wireConnections;
+    /**
+     * Establish a relay connection to a cached tunnel. Called on demand
+     * when the user invokes the browse action on an online-but-not-connected tunnel.
+     */
+    private _connectTunnel;
+    /**
+     * Dismiss a tunnel from the remote-host picker and tear down its active relay.
+     */
+    private _disconnectTunnel;
+    private _requestServiceReconnects;
+    private _handleSessionsChange;
+    private _silentStatusCheck;
+}