@codingame/monaco-vscode-workbench-service-override 37.6.1 → 38.0.0

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

@@ -0,0 +1,595 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { addDisposableListener } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
+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 { isWeb } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { normalizeRemoteAgentHostAddress } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { ConnectionDiagnosticBuffer, formatConnectionDiagnosticError, getConnectionDiagnosticError } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/connectionDiagnostics';
+import { RemoteAgentHostsEnabledSettingId, RemoteAgentHostAutoConnectSettingId, getEntryAddress } 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 { TUNNEL_ADDRESS_PREFIX } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/tunnelAgentHost';
+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 { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { IAgentHostFilterService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/agentHostFilter/common/agentHostFilter.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { collectConnectionLogs } from './connectionDiagnosticsLogs.js';
+
+let ConnectionDiagnosticsService = class ConnectionDiagnosticsService extends Disposable {
+    get isWebPlatform() {
+        return isWeb;
+    }
+    constructor(
+        _remoteService,
+        _tunnelService,
+        _filterService,
+        _configurationService,
+        _productService,
+        _fileService,
+        _environmentService
+    ) {
+        super();
+        this._remoteService = _remoteService;
+        this._tunnelService = _tunnelService;
+        this._filterService = _filterService;
+        this._configurationService = _configurationService;
+        this._productService = _productService;
+        this._fileService = _fileService;
+        this._environmentService = _environmentService;
+        this._onDidChangeHostManagement = this._register(( new Emitter()));
+        this.onDidChangeHostManagement = this._onDidChangeHostManagement.event;
+        this._startedAt = Date.now();
+        this._activity = [];
+        this._discoveryDiagnostics = ( new ConnectionDiagnosticBuffer());
+        this._connectionStates = ( new Map());
+        this._nextDiscoveryId = 1;
+        this._lastSuccessfulDiscovery = 0;
+        this._discoveredTunnels = [];
+        this._captureConnections();
+        this._register(this._remoteService.onDidChangeConnections(() => {
+            this._captureConnections();
+            this._onDidChangeHostManagement.fire();
+        }));
+        if (this.isWebPlatform) {
+            this._register(
+                this._remoteService.onDidChangePendingConnections(() => this._onDidChangeHostManagement.fire())
+            );
+        }
+        this._register(
+            this._filterService.onDidChange(() => this._onDidChangeHostManagement.fire())
+        );
+        this._register(
+            this._filterService.onDidChangeDiscovering(() => this._onDidChangeHostManagement.fire())
+        );
+        this._register(
+            this._tunnelService.onDidChangeTunnels(() => this._onDidChangeHostManagement.fire())
+        );
+        this._register(this._configurationService.onDidChangeConfiguration(event => {
+            if (event.affectsConfiguration(RemoteAgentHostsEnabledSettingId) || event.affectsConfiguration(RemoteAgentHostAutoConnectSettingId)) {
+                this._record(( localize(5207, "Remote host connection settings changed.")));
+            }
+        }));
+        if (isWeb) {
+            for (const event of ["online", "offline"]) {
+                this._register(addDisposableListener(mainWindow, event, () => this._record(( localize(
+                    5208,
+                    "Browser network signal: {0}.",
+                    mainWindow.navigator.onLine ? "online" : "offline"
+                )))));
+            }
+            this._register(
+                addDisposableListener(mainWindow.document, "visibilitychange", () => this._record(( localize(5209, "Page visibility: {0}.", mainWindow.document.visibilityState))))
+            );
+        }
+    }
+    async trackDiscovery(trigger, discover) {
+        const attempt = {
+            id: this._nextDiscoveryId++,
+            trigger,
+            startedAt: Date.now(),
+            result: "pending"
+        };
+        this._lastDiscovery = attempt;
+        this._record(( localize(5210, "Discovery #{0} started ({1}).", attempt.id, trigger)));
+        try {
+            const tunnels = await discover(
+                event => this._discoveryDiagnostics.record(`discovery:${attempt.id}`, event)
+            );
+            attempt.finishedAt = Date.now();
+            attempt.result = "succeeded";
+            if (attempt.id > this._lastSuccessfulDiscovery) {
+                this._lastSuccessfulDiscovery = attempt.id;
+                this._lastSuccessfulDiscoveryAt = attempt.finishedAt;
+                this._discoveredTunnels = tunnels.map(tunnel => ({
+                    ...tunnel,
+                    tags: []
+                }));
+            }
+            const dismissed = tunnels.filter(tunnel => this._tunnelService.isTunnelDismissed(tunnel.tunnelId)).length;
+            this._record(( localize(
+                5211,
+                "Discovery #{0} succeeded in {1} ms: {2} found, {3} with an active host, {4} dismissed.",
+                attempt.id,
+                attempt.finishedAt - attempt.startedAt,
+                tunnels.length,
+                tunnels.filter(tunnel => tunnel.hostConnectionCount > 0).length,
+                dismissed
+            )));
+            return tunnels;
+        } catch (error) {
+            attempt.finishedAt = Date.now();
+            attempt.result = "failed";
+            attempt.error = formatConnectionDiagnosticError(getConnectionDiagnosticError(error));
+            this._record(( localize(
+                5212,
+                "Discovery #{0} failed after {1} ms. {2}",
+                attempt.id,
+                attempt.finishedAt - attempt.startedAt,
+                attempt.error
+            )));
+            throw error;
+        }
+    }
+    recordHostAction(address, action, userInitiated) {
+        this._record(action === "disconnect" ? ( localize(
+            5213,
+            "{0}: disconnect requested by the user; automatic reconnect suppressed.",
+            safeAddress(address)
+        )) : ( localize(
+            5214,
+            "{0}: connection requested ({1}).",
+            safeAddress(address),
+            userInitiated ? ( localize(5215, "user")) : ( localize(5216, "automatic"))
+        )));
+    }
+    getHostManagementState() {
+        const connections = ( new Map(this._remoteService.connections.map(
+            connection => [normalizeRemoteAgentHostAddress(connection.address), connection]
+        )));
+        const pending = ( new Set(
+            this.isWebPlatform ? this._remoteService.pendingConnections.map(attempt => attempt.address) : []
+        ));
+        const visibility = this._tunnelService.getTunnelVisibility();
+        const cached = ( new Map(
+            this._tunnelService.getCachedTunnels().map(tunnel => [tunnel.tunnelId, tunnel])
+        ));
+        const discovered = ( new Map(this._discoveredTunnels.map(tunnel => [tunnel.tunnelId, tunnel])));
+        const selectableAddresses = ( new Set());
+        const hosts = this._filterService.hosts.map(host => {
+            const address = host.address === undefined ? undefined : normalizeRemoteAgentHostAddress(host.address);
+            if (address) {
+                selectableAddresses.add(address);
+            }
+            const connectionStatus = address ? connections.get(address)?.status.kind : undefined;
+            const status = address && ( pending.has(address)) && (!connectionStatus || connectionStatus === "disconnected") ? "connecting" : connectionStatus ?? (host.status === "connected" ? "connected" : host.status === "connecting" ? "connecting" : "disconnected");
+            const tunnelId = address?.startsWith(TUNNEL_ADDRESS_PREFIX) ? address.slice(TUNNEL_ADDRESS_PREFIX.length) : undefined;
+            return {
+                id: host.id,
+                label: host.label,
+                address,
+                status,
+                selectable: true,
+                selected: this._filterService.selectedHostId === host.id,
+                hidden: false,
+                autoConnectSuppressed: tunnelId !== undefined && visibility.autoConnectSuppressed.includes(tunnelId),
+                connectable: host.connectable
+            };
+        });
+        for (const tunnelId of visibility.dismissed) {
+            const address = `${TUNNEL_ADDRESS_PREFIX}${tunnelId}`;
+            if (( selectableAddresses.has(address))) {
+                continue;
+            }
+            hosts.push({
+                id: address,
+                label: cached.get(tunnelId)?.name ?? discovered.get(tunnelId)?.name ?? tunnelId,
+                address,
+                status: connections.get(address)?.status.kind ?? "disconnected",
+                selectable: false,
+                selected: false,
+                hidden: true,
+                autoConnectSuppressed: visibility.autoConnectSuppressed.includes(tunnelId),
+                connectable: false
+            });
+        }
+        return {
+            hosts,
+            isDiscovering: this._filterService.isDiscovering
+        };
+    }
+    async runHostAction(hostId, action) {
+        const current = this.getHostManagementState().hosts.find(host => host.id === hostId);
+        if (!current) {
+            throw ( new Error(( localize(5217, "The host is no longer available."))));
+        }
+        if (action === "restore") {
+            if (!current.hidden || !current.address?.startsWith(TUNNEL_ADDRESS_PREFIX)) {
+                throw ( new Error(( localize(5218, "The host is not hidden."))));
+            }
+            this._tunnelService.clearTunnelDismissal(current.address.slice(TUNNEL_ADDRESS_PREFIX.length));
+            if (!(await this._filterService.rediscover())) {
+                throw ( new Error(( localize(
+                    5219,
+                    "Host is no longer hidden, but discovery failed. Use Refresh to try again."
+                ))));
+            }
+            return;
+        }
+        if (!current.selectable || !current.connectable) {
+            throw ( new Error(( localize(5220, "The host does not have manual connection controls."))));
+        }
+        if (action === "disconnect") {
+            await this._filterService.disconnect(current.id);
+            return;
+        }
+        await this._filterService.reconnect(current.id);
+    }
+    rediscover() {
+        return this._filterService.rediscover();
+    }
+    _record(detail) {
+        this._activity.push({
+            time: Date.now(),
+            detail
+        });
+        if (this._activity.length > 100) {
+            this._activity.shift();
+        }
+    }
+    _captureConnections() {
+        const present = ( new Set());
+        for (const connection of this._remoteService.connections) {
+            present.add(connection.address);
+            const state = connection.status;
+            const key = JSON.stringify(state);
+            if (this._connectionStates.get(connection.address) === key) {
+                continue;
+            }
+            this._connectionStates.set(connection.address, key);
+            const detail = state.kind === "reconnecting" && state.nextAttemptAt ? ( localize(
+                5221,
+                "reconnecting; next attempt at {0}",
+                ( new Date(state.nextAttemptAt)).toISOString()
+            )) : state.kind;
+            this._record(( localize(5222, "{0}: {1}.", safeAddress(connection.address), detail)));
+        }
+        for (const address of ( this._connectionStates.keys())) {
+            if (!( present.has(address))) {
+                this._connectionStates.delete(address);
+                this._record(( localize(5223, "{0}: connection entry removed.", safeAddress(address))));
+            }
+        }
+    }
+    async getSnapshot() {
+        const capturedAtMs = Date.now();
+        const capturedAt = ( new Date(capturedAtMs)).toISOString();
+        const sections = [];
+        const enabled = this._configurationService.getValue(RemoteAgentHostsEnabledSettingId);
+        const autoConnect = this._configurationService.getValue(RemoteAgentHostAutoConnectSettingId);
+        const yesNo = value => value ? ( localize(5224, "Yes")) : ( localize(5225, "No"));
+        const cached = this._tunnelService.getCachedTunnels();
+        const visibility = this._tunnelService.getTunnelVisibility();
+        const configured = ( new Map(
+            this._remoteService.configuredEntries.map(entry => [normalizeRemoteAgentHostAddress(getEntryAddress(entry)), entry])
+        ));
+        const connections = ( new Map(this._remoteService.connections.map(
+            connection => [normalizeRemoteAgentHostAddress(connection.address), connection]
+        )));
+        const connectionDiagnostics = this._remoteService.getConnectionDiagnostics();
+        const lastStages = ( new Map());
+        for (const event of connectionDiagnostics) {
+            lastStages.set(normalizeRemoteAgentHostAddress(event.address), event);
+        }
+        const pending = ( new Map(
+            (this.isWebPlatform ? this._remoteService.pendingConnections : []).map(attempt => [attempt.address, attempt])
+        ));
+        const discovered = ( new Map(
+            this._discoveredTunnels.map(tunnel => [`${TUNNEL_ADDRESS_PREFIX}${tunnel.tunnelId}`, tunnel])
+        ));
+        const cachedByAddress = ( new Map(
+            cached.map(tunnel => [`${TUNNEL_ADDRESS_PREFIX}${tunnel.tunnelId}`, tunnel])
+        ));
+        const addresses = ( new Set([...( discovered.keys()), ...( cachedByAddress.keys()), ...( configured.keys()), ...( connections.keys())]));
+        for (const id of [...visibility.dismissed, ...visibility.autoConnectSuppressed]) {
+            addresses.add(`${TUNNEL_ADDRESS_PREFIX}${id}`);
+        }
+        const visible = ( new Map(this._filterService.hosts.flatMap(
+            host => host.address === undefined ? [] : [[normalizeRemoteAgentHostAddress(host.address), host]]
+        )));
+        for (const address of ( visible.keys())) {
+            addresses.add(address);
+        }
+        const hostSections = [];
+        for (const address of addresses) {
+            const tunnel = discovered.get(address);
+            const cache = cachedByAddress.get(address);
+            const entry = configured.get(address);
+            const connection = connections.get(address);
+            const attempt = pending.get(address);
+            const connectionStatus = attempt && (!connection || connection.status.kind === "disconnected") ? "connecting" : connection?.status.kind;
+            const pickerHost = visible.get(address);
+            const tunnelId = address.startsWith(TUNNEL_ADDRESS_PREFIX) ? address.slice(TUNNEL_ADDRESS_PREFIX.length) : undefined;
+            const dismissed = tunnelId !== undefined && this._tunnelService.isTunnelDismissed(tunnelId);
+            const suppressed = tunnelId !== undefined && this._tunnelService.isAutoConnectSuppressed(tunnelId);
+            const name = safeAddress(
+                tunnel?.name ?? cache?.name ?? entry?.name ?? connection?.name ?? pickerHost?.label ?? address
+            );
+            const entries = [{
+                label: ( localize(5226, "Address")),
+                value: safeAddress(address)
+            }, {
+                label: ( localize(5227, "Connection type")),
+                value: entry?.connection.type ?? (tunnelId !== undefined ? "tunnel" : ( localize(5228, "Unknown")))
+            }, {
+                label: ( localize(5229, "Connection status")),
+                value: connectionStatus ?? ( localize(5230, "No connection entry"))
+            }, {
+                label: ( localize(5231, "Selectable")),
+                value: yesNo(!!pickerHost)
+            }, {
+                label: ( localize(5232, "Configured")),
+                value: yesNo(!!entry)
+            }, {
+                label: ( localize(5233, "Cached")),
+                value: yesNo(!!cache)
+            }, {
+                label: ( localize(5234, "In last successful discovery")),
+                value: yesNo(!!tunnel)
+            }];
+            if (attempt) {
+                entries.push({
+                    label: ( localize(5235, "Connection attempt")),
+                    value: ( localize(5236, "Pending"))
+                }, {
+                    label: ( localize(5237, "Attempt phase")),
+                    value: connection?.clientId ? ( localize(5238, "Protocol connection")) : ( localize(5239, "Connection setup (before protocol client)"))
+                }, {
+                    label: ( localize(5240, "Attempt started at")),
+                    value: ( new Date(attempt.startedAt)).toISOString()
+                }, {
+                    label: ( localize(5241, "Attempt elapsed at capture (ms)")),
+                    value: String(Math.max(0, capturedAtMs - attempt.startedAt))
+                }, {
+                    label: ( localize(5242, "Attempt trigger")),
+                    value: attempt.userInitiated ? ( localize(5215, "user")) : ( localize(5216, "automatic"))
+                }, {
+                    label: ( localize(5243, "Connection entry present")),
+                    value: yesNo(!!connection)
+                });
+            }
+            if (tunnelId !== undefined) {
+                entries.push({
+                    label: ( localize(5244, "Persistently dismissed")),
+                    value: yesNo(dismissed)
+                }, {
+                    label: ( localize(5245, "Auto-connect suppressed")),
+                    value: yesNo(suppressed)
+                });
+            }
+            if (tunnel) {
+                entries.push({
+                    label: ( localize(5246, "Tunnel cluster")),
+                    value: safeAddress(tunnel.clusterId)
+                }, {
+                    label: ( localize(5247, "Active tunnel hosts")),
+                    value: String(tunnel.hostConnectionCount)
+                }, {
+                    label: ( localize(5248, "Tunnel protocol version")),
+                    value: String(tunnel.protocolVersion)
+                });
+            }
+            if (connection?.clientId) {
+                entries.push({
+                    label: ( localize(5249, "Protocol client ID")),
+                    value: connection.clientId
+                });
+            }
+            const stage = lastStages.get(address);
+            if (stage) {
+                entries.push({
+                    label: ( localize(5250, "Last observed connection stage")),
+                    value: `${stage.phase}: ${stage.outcome}`
+                }, {
+                    label: ( localize(5251, "Stage observed at")),
+                    value: ( new Date(stage.timestamp)).toISOString()
+                });
+                if (stage.error) {
+                    entries.push({
+                        label: ( localize(5252, "Stage error")),
+                        value: formatConnectionDiagnosticError(stage.error)
+                    });
+                }
+            }
+            if (connection?.status.kind === "disconnected") {
+                entries.push({
+                    label: ( localize(5253, "Disconnect reason")),
+                    value: connection.status.reason
+                });
+            }
+            if (connection?.status.kind === "incompatible") {
+                entries.push({
+                    label: ( localize(5254, "Client protocol versions")),
+                    value: connection.status.supportedByClient.join(", ")
+                }, {
+                    label: ( localize(5255, "Server protocol versions")),
+                    value: connection.status.offeredByServer?.join(", ") ?? ( localize(5228, "Unknown"))
+                });
+            }
+            if (connection?.status.kind === "reconnecting" && connection.status.nextAttemptAt) {
+                entries.push({
+                    label: ( localize(5256, "Next reconnect attempt")),
+                    value: ( new Date(connection.status.nextAttemptAt)).toISOString()
+                });
+            }
+            const root = this._remoteService.getConnection(address)?.rootState.value;
+            if (root && !(root instanceof Error)) {
+                entries.push({
+                    label: ( localize(5257, "Advertised agents")),
+                    value: root.agents.map(agent => agent.provider).join(", ")
+                });
+            }
+            hostSections.push({
+                title: ( localize(
+                    5258,
+                    "{0} - {1}, {2}",
+                    name,
+                    connectionStatus ?? ( localize(5259, "no connection")),
+                    pickerHost ? ( localize(5260, "selectable")) : ( localize(5261, "not selectable"))
+                )),
+                hostAddress: address,
+                collapsed: true,
+                entries
+            });
+        }
+        const clientSection = {
+            title: ( localize(5262, "This client")),
+            collapsed: true,
+            entries: [{
+                label: ( localize(5263, "Captured at")),
+                value: capturedAt
+            }, {
+                label: ( localize(5264, "Version")),
+                value: this._productService.version
+            }, {
+                label: ( localize(5265, "Commit")),
+                value: this._productService.commit ?? ( localize(5228, "Unknown"))
+            }, {
+                label: ( localize(5266, "Client")),
+                value: isWeb ? ( localize(5267, "Web")) : ( localize(5268, "Desktop"))
+            }, {
+                label: ( localize(5269, "Browser online signal")),
+                value: yesNo(mainWindow.navigator.onLine)
+            }, {
+                label: ( localize(5270, "Page visibility")),
+                value: mainWindow.document.visibilityState
+            }, {
+                label: ( localize(5271, "Secure browser context")),
+                value: yesNo(mainWindow.isSecureContext)
+            }, {
+                label: ( localize(5272, "Standalone display mode")),
+                value: yesNo(mainWindow.matchMedia("(display-mode: standalone)").matches)
+            }, {
+                label: ( localize(5273, "Remote hosts enabled")),
+                value: yesNo(enabled)
+            }, {
+                label: ( localize(5274, "Automatic connections enabled")),
+                value: yesNo(autoConnect)
+            }, {
+                label: ( localize(5275, "Host picker entries")),
+                value: String(this._filterService.hosts.length)
+            }, {
+                label: ( localize(5276, "Selected host")),
+                value: safeAddress(this._filterService.selectedHost?.label ?? ( localize(5277, "None")))
+            }]
+        };
+        const attempt = this._lastDiscovery;
+        sections.push({
+            title: this.discoveryTitle(),
+            collapsed: true,
+            description: ( localize(
+                5278,
+                "Host details use the last successful discovery in this window; they may be stale. No network requests are made when viewing or copying diagnostics."
+            )),
+            entries: attempt ? [{
+                label: ( localize(5279, "Attempt")),
+                value: `#${attempt.id}`
+            }, {
+                label: ( localize(5280, "Trigger")),
+                value: attempt.trigger
+            }, {
+                label: ( localize(5281, "Result")),
+                value: attempt.result
+            }, ...(attempt.error ? [{
+                label: ( localize(5282, "Error")),
+                value: attempt.error
+            }] : []), {
+                label: ( localize(5283, "Started at")),
+                value: ( new Date(attempt.startedAt)).toISOString()
+            }, {
+                label: ( localize(5284, "Duration (ms)")),
+                value: String((attempt.finishedAt ?? Date.now()) - attempt.startedAt)
+            }, {
+                label: ( localize(5285, "Hosts in last successful discovery")),
+                value: String(discovered.size)
+            }, {
+                label: ( localize(5286, "Last successful discovery")),
+                value: this._lastSuccessfulDiscoveryAt === undefined ? ( localize(5277, "None")) : ( new Date(this._lastSuccessfulDiscoveryAt)).toISOString()
+            }, {
+                label: ( localize(5287, "Cached tunnels")),
+                value: String(cached.length)
+            }] : [{
+                label: ( localize(5281, "Result")),
+                value: ( localize(5288, "No discovery observed in this window."))
+            }]
+        });
+        sections.push(...hostSections, {
+            title: ( localize(5289, "Recent activity logs")),
+            collapsed: true,
+            description: ( localize(
+                5290,
+                "Up to 100 local events since {0}. Earlier history is not captured. Host names and addresses are included; review before sharing.",
+                ( new Date(this._startedAt)).toISOString()
+            )),
+            entries: this._activity.map(event => ({
+                label: ( new Date(event.time)).toISOString(),
+                value: event.detail
+            }))
+        }, {
+            title: ( localize(5291, "Connection and discovery stages")),
+            collapsed: true,
+            description: ( localize(
+                5292,
+                "Up to 200 connection and 200 discovery events from this window. A start without a completion may still be pending, or its completion may not have been captured. Error descriptions are redacted and bounded. These are client observations, not server logs."
+            )),
+            entries: [...connectionDiagnostics, ...this._discoveryDiagnostics.getEvents()].sort((a, b) => a.timestamp - b.timestamp).map(event => ({
+                label: `${( new Date(event.timestamp)).toISOString()} ${safeAddress(event.address)}`,
+                value: [
+                    `${event.phase}: ${event.outcome} (operation ${event.operationId})`,
+                    event.attemptId ? `attempt=${event.attemptId}` : undefined,
+                    event.durationMs === undefined ? undefined : `${event.durationMs} ms`,
+                    event.detail,
+                    event.error ? formatConnectionDiagnosticError(event.error) : undefined
+                ].filter(value => value !== undefined).join("; ")
+            }))
+        }, await collectConnectionLogs(this._fileService, this._environmentService.logFile), clientSection);
+        const text = [( localize(5293, "Connection diagnostics")), ...sections.flatMap(section => [
+            "",
+            section.title,
+            ...(section.description ? [section.description] : []),
+            ...section.entries.map(entry => `${entry.label}: ${entry.value}`)
+        ])].join("\n");
+        return {
+            capturedAt,
+            sections,
+            text
+        };
+    }
+    discoveryTitle() {
+        switch (this._lastDiscovery?.result) {
+        case "succeeded":
+            return this._discoveredTunnels.length === 1 ? ( localize(5294, "Tunnel discovery successful with 1 tunnel")) : ( localize(
+                5295,
+                "Tunnel discovery successful with {0} tunnels",
+                this._discoveredTunnels.length
+            ));
+        case "failed":
+            return localize(5296, "Tunnel discovery failed");
+        case "pending":
+            return localize(5297, "Tunnel discovery in progress");
+        default:
+            return localize(5298, "Tunnel discovery not yet observed");
+        }
+    }
+};
+ConnectionDiagnosticsService = ( __decorate([( __param(0, IRemoteAgentHostService)), ( __param(1, ITunnelAgentHostService)), ( __param(2, IAgentHostFilterService)), ( __param(3, IConfigurationService)), ( __param(4, IProductService)), ( __param(5, IFileService)), ( __param(6, IWorkbenchEnvironmentService))], ConnectionDiagnosticsService));
+function safeAddress(value) {
+    return value.replace(/[\r\n\t]/g, " ").split(/[?#]/, 1)[0].replace(/(^|\/\/)[^/]*@/, "$1").slice(0, 512);
+}
+
+export { ConnectionDiagnosticsService };

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

@@ -5,6 +5,7 @@ import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { IRemoteAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IWorkspaceTrustRequestService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service";
 import { IDevContainerAgentHostConnector, IDevContainerAgentHostTarget } from "@codingame/monaco-vscode-api/vscode/vs/sessions/common/devContainerAgentHostService";
 import { IDevContainerAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/common/devContainerAgentHostService.service";
 import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
@@ -15,24 +16,35 @@ export declare class DevContainerAgentHostService extends Disposable implements
     private readonly _remoteAgentHostService;
     private readonly _sessionsProvidersService;
     private readonly _storageService;
+    private readonly _workspaceTrustRequestService;
     readonly _serviceBrand: undefined;
     private readonly _providerStores;
     private readonly _providers;
     private readonly _activeConnections;
+    private readonly _knownSandboxSupport;
     private readonly _pendingConnections;
     private readonly _storedConnections;
     private readonly _connectionFactory;
+    private readonly _lifecycleOperations;
+    private readonly _lifecycleTokenSource;
     private readonly _onDidRegisterConnector;
     private readonly _onDidChangeAvailability;
     readonly onDidChangeAvailability: Event<void>;
     private _connector;
-    constructor(_instantiationService: IInstantiationService, _remoteAgentHostService: IRemoteAgentHostService, _sessionsProvidersService: ISessionsProvidersService, _storageService: IStorageService);
+    constructor(_instantiationService: IInstantiationService, _remoteAgentHostService: IRemoteAgentHostService, _sessionsProvidersService: ISessionsProvidersService, _storageService: IStorageService, _workspaceTrustRequestService: IWorkspaceTrustRequestService);
+    private _initializeProviders;
     registerConnector(connector: IDevContainerAgentHostConnector): IDisposable;
     isAvailable(workspaceUri: URI): Promise<boolean>;
-    connect(workspaceUri: URI, token: CancellationToken): Promise<IDevContainerAgentHostTarget>;
+    getSandboxSupported(workspaceUri: URI): boolean | undefined;
+    private _setSandboxSupported;
+    connect(workspaceUri: URI, token: CancellationToken, options?: {
+        readonly sandboxEnabled: boolean;
+    }): Promise<IDevContainerAgentHostTarget>;
+    showLog(workspaceUri: URI): Promise<void>;
     private _ensureConnection;
+    private _waitForReconnection;
     private _completePendingConnection;
-    private _replaceConnectionAndConnect;
+    private _connectWhenReady;
     private _waitForConnector;
     private _connect;
     private _acquireConnection;
@@ -41,6 +53,11 @@ export declare class DevContainerAgentHostService extends Disposable implements
     protected _waitForSessionTypes(provider: RemoteAgentHostSessionsProvider, token: CancellationToken): Promise<void>;
     disconnect(workspaceUri: URI): Promise<void>;
     private _disconnectActiveConnection;
+    private _stopContainer;
+    private _removeContainer;
+    private _ensureActiveConnection;
+    private _connectActive;
+    private _disconnectActiveTransport;
     private _isConnectedOrReconnecting;
     private _reconcileConnections;
     private _restoreProviders;