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

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

@@ -0,0 +1,439 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as connectionDiagnostics from './media/connectionDiagnostics.css';
+import { triggerDownload, append, $, addDisposableListener, EventType, DisposableResizeObserver, getActiveElement, isHTMLElement, clearNode, scheduleAtNextAnimationFrame, getWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Gesture } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/touch';
+import { Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { DomScrollableElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/scrollbar/scrollableElement';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableStore, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ScrollbarVisibility } from '@codingame/monaco-vscode-api/vscode/vs/base/common/scrollable';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IClipboardService } from '@codingame/monaco-vscode-api/vscode/vs/platform/clipboard/common/clipboardService.service';
+import { defaultButtonStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { showMobileContentSheet } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/mobile/mobilePickerSheet';
+import { IConnectionDiagnosticsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/connectionDiagnostics.service';
+
+registerCss(connectionDiagnostics, 1);
+let ConnectionDiagnosticsReport = class ConnectionDiagnosticsReport extends Disposable {
+    constructor(
+        container,
+        snapshot,
+        triggerDownload$1 = triggerDownload,
+        options,
+        diagnosticsService,
+        clipboardService
+    ) {
+        super();
+        this.triggerDownload = triggerDownload$1;
+        this.options = options;
+        this.diagnosticsService = diagnosticsService;
+        this.clipboardService = clipboardService;
+        this._onDidChangeFocusTargets = this._register(( new Emitter()));
+        this.onDidChangeFocusTargets = this._onDidChangeFocusTargets.event;
+        this.managementStore = this._register(( new DisposableStore()));
+        this.renderScheduler = this._register(( new MutableDisposable()));
+        this.bodyFocusTargets = [];
+        this.hostFocusTargets = ( new Map());
+        this.snapshotRequest = 0;
+        this.snapshot = snapshot;
+        container.classList.add("connection-diagnostics");
+        this.message = append(container, $("div.connection-diagnostics-message", {
+            role: "status",
+            "aria-live": "polite",
+            "aria-atomic": "true"
+        }));
+        this.message.hidden = true;
+        this.content = $("div.connection-diagnostics-content");
+        this.content.tabIndex = 0;
+        this.content.setAttribute("role", "region");
+        this.content.setAttribute("aria-label", ( localize(5172, "Connection diagnostics report")));
+        this.scrollable = this._register(( new DomScrollableElement(this.content, {
+            className: "connection-diagnostics-scrollable",
+            horizontal: ScrollbarVisibility.Hidden,
+            vertical: ScrollbarVisibility.Auto,
+            consumeMouseWheelIfScrollbarIsNeeded: true
+        })));
+        this.content.style.overflow = "";
+        this._register(Gesture.ignoreTarget(this.content));
+        this._register(addDisposableListener(
+            this.content,
+            EventType.SCROLL,
+            () => this.scrollable.setScrollPosition({
+                scrollTop: this.content.scrollTop,
+                scrollLeft: this.content.scrollLeft
+            })
+        ));
+        append(container, this.scrollable.getDomNode());
+        const resizeObserver = this._register(new DisposableResizeObserver(
+            "ConnectionDiagnosticsReport.scrollable",
+            () => this.scrollable.scanDomNode()
+        ));
+        this._register(resizeObserver.observe(this.scrollable.getDomNode()));
+        this.render();
+        if (this.options.enableHostManagement) {
+            this._register(
+                this.diagnosticsService.onDidChangeHostManagement(() => this.scheduleRender())
+            );
+        }
+    }
+    getSnapshot() {
+        return this.snapshot;
+    }
+    focus() {
+        this.content.focus();
+    }
+    getFocusTargets() {
+        return [this.content, ...this.bodyFocusTargets];
+    }
+    async refresh() {
+        const request = ++this.snapshotRequest;
+        try {
+            const discoverySucceeded = !this.options.rediscoverOnRefresh || (await this.diagnosticsService.rediscover());
+            const snapshot = await this.diagnosticsService.getSnapshot();
+            if (this._store.isDisposed || request !== this.snapshotRequest) {
+                return;
+            }
+            this.snapshot = snapshot;
+            this.render();
+            this.announce(this.options.rediscoverOnRefresh ? discoverySucceeded ? ( localize(5173, "Hosts rediscovered and snapshot refreshed.")) : ( localize(
+                5174,
+                "Snapshot refreshed, but one or more host discovery operations failed."
+            )) : ( localize(5175, "Snapshot refreshed.")));
+        } catch (error) {
+            if (request === this.snapshotRequest) {
+                this.announce(( localize(
+                    5176,
+                    "Could not refresh connection information. {0}",
+                    toErrorMessage(error)
+                )));
+            }
+        }
+    }
+    async copy() {
+        try {
+            await this.clipboardService.writeText(this.snapshot.text);
+            this.announce(( localize(5177, "Diagnostics copied.")));
+        } catch {
+            this.announce(( localize(5178, "Could not copy. Try downloading diagnostics.")));
+        }
+    }
+    download() {
+        try {
+            const timestamp = ( new Date(this.snapshot.capturedAt)).toISOString().replace(/[:.]/g, "-");
+            this.triggerDownload(
+                VSBuffer.fromString(this.snapshot.text).buffer,
+                `connection-diagnostics-${timestamp}.txt`
+            );
+            this.announce(( localize(5179, "Download requested.")));
+        } catch {
+            this.announce(( localize(5180, "Could not download. Try copying diagnostics.")));
+        }
+    }
+    announce(message) {
+        if (!this._store.isDisposed) {
+            this.message.hidden = false;
+            this.message.textContent = message;
+        }
+    }
+    render() {
+        const openSections = ( new Set(Array.from(this.content.children).flatMap(element => {
+            if (element.tagName !== "DETAILS" || !element.open) {
+                return [];
+            }
+            return [
+                element.dataset.hostAddress ?? element.firstElementChild?.textContent ?? ""
+            ];
+        })));
+        const activeElement = getActiveElement();
+        const focusedHostId = isHTMLElement(activeElement) ? activeElement.dataset.hostId : undefined;
+        const focusedAction = isHTMLElement(activeElement) ? activeElement.dataset.hostAction : undefined;
+        const focusedSection = isHTMLElement(activeElement) ? activeElement.closest(".connection-diagnostics-host-section") : undefined;
+        const focusedHostAddress = isHTMLElement(activeElement) ? activeElement.dataset.hostAddress ?? focusedSection?.dataset.hostAddress : undefined;
+        const focusedSummary = activeElement?.tagName === "SUMMARY";
+        this.managementStore.clear();
+        clearNode(this.content);
+        this.bodyFocusTargets.length = 0;
+        this.hostFocusTargets.clear();
+        const hosts = this.options.enableHostManagement ? this.diagnosticsService.getHostManagementState().hosts : [];
+        const hostsByAddress = ( new Map(hosts.flatMap(host => host.address ? [[host.address, host]] : [])));
+        if (this.options.enableHostManagement) {
+            this.renderHiddenHosts(hosts.filter(host => host.hidden));
+            append(this.content, $("p.connection-diagnostics-caption")).textContent = ( localize(
+                5181,
+                "Host summaries and controls are live. Details and exports use the captured snapshot."
+            ));
+        }
+        append(this.content, $("p.connection-diagnostics-caption")).textContent = ( localize(
+            5182,
+            "Local snapshot, including connection-related Window logs. Known credentials are redacted, but host names, addresses, and messages can contain personal information. Review before sharing."
+        ));
+        append(this.content, $("p.connection-diagnostics-caption")).textContent = ( localize(5183, "Captured: {0}", this.snapshot.capturedAt));
+        const snapshotAddresses = ( new Set(this.snapshot.sections.map(section => section.hostAddress)));
+        const newHostSections = hosts.filter(host => !host.hidden && host.address && !( snapshotAddresses.has(host.address))).map(host => ({
+            title: host.label,
+            hostAddress: host.address,
+            collapsed: false,
+            description: ( localize(5184, "Not included in the captured snapshot. Refresh to capture details.")),
+            entries: []
+        }));
+        for (const section of [
+            ...this.snapshot.sections.filter(section => !section.collapsed),
+            ...newHostSections,
+            ...this.snapshot.sections.filter(section => section.collapsed)
+        ]) {
+            const element = append(this.content, $(
+                section.collapsed ? "details.connection-diagnostics-section" : "section.connection-diagnostics-section"
+            ));
+            if (section.hostAddress) {
+                element.classList.add("connection-diagnostics-host-section");
+                element.dataset.hostAddress = section.hostAddress;
+            }
+            const heading = append(element, $(section.collapsed ? "summary" : "h2"));
+            heading.textContent = section.title;
+            if (section.hostAddress) {
+                heading.dataset.hostAddress = section.hostAddress;
+            }
+            if (section.collapsed) {
+                this.bodyFocusTargets.push(heading);
+                element.open = ( openSections.has(section.hostAddress ?? section.title));
+                this.managementStore.add(
+                    addDisposableListener(element, "toggle", () => this.scrollable.scanDomNode())
+                );
+            }
+            const host = section.hostAddress ? hostsByAddress.get(section.hostAddress) : undefined;
+            if (host && !host.hidden) {
+                heading.textContent = "";
+                const row = append(heading, $("span.connection-diagnostics-host-heading"));
+                const label = append(row, $("span.connection-diagnostics-host-label"));
+                append(label, $("span.connection-diagnostics-host-name")).textContent = host.label;
+                append(label, $("span.connection-diagnostics-host-status")).textContent = !host.connectable ? ( localize(5185, "Connections managed on demand")) : host.status === "disconnected" && host.autoConnectSuppressed ? ( localize(5186, "Disconnected. Automatic connection paused.")) : this.getHostStatusLabel(host.status);
+                const actions = append(row, $("span.connection-diagnostics-host-actions"));
+                if (host.address) {
+                    this.hostFocusTargets.set(host.address, heading);
+                }
+                this.renderHostManagementAction(actions, host);
+                this.managementStore.add(
+                    addDisposableListener(actions, EventType.CLICK, event => event.stopPropagation())
+                );
+            }
+            if (section.description) {
+                append(element, $("p")).textContent = section.description;
+            }
+            const entries = append(element, $("dl"));
+            for (const entry of section.entries) {
+                append(entries, $("dt")).textContent = entry.label;
+                append(entries, $("dd")).textContent = entry.value;
+            }
+        }
+        this.scrollable.scanDomNode();
+        this._onDidChangeFocusTargets.fire();
+        this.restoreManagementFocus(focusedHostId, focusedHostAddress, focusedAction, focusedSummary);
+    }
+    renderHiddenHosts(hosts) {
+        if (!hosts.length) {
+            return;
+        }
+        const section = append(
+            this.content,
+            $("section.connection-diagnostics-hosts.connection-diagnostics-hidden-hosts")
+        );
+        append(section, $("h2")).textContent = ( localize(5187, "Hidden hosts"));
+        for (const host of hosts) {
+            const row = append(section, $("div.connection-diagnostics-host-row"));
+            row.tabIndex = -1;
+            if (host.address) {
+                row.dataset.hostAddress = host.address;
+                this.hostFocusTargets.set(host.address, row);
+            }
+            const details = append(row, $("div.connection-diagnostics-host-label"));
+            append(details, $("div")).textContent = host.label;
+            append(details, $("div.connection-diagnostics-host-status")).textContent = ( localize(5188, "Hidden from host picker"));
+            const actions = append(row, $("div.connection-diagnostics-host-actions"));
+            this.renderHostManagementAction(actions, host);
+        }
+    }
+    getHostStatusLabel(status) {
+        switch (status) {
+        case "connected":
+            return localize(5189, "Connected");
+        case "connecting":
+            return localize(5190, "Connecting");
+        case "reconnecting":
+            return localize(5191, "Reconnecting");
+        case "disconnected":
+            return localize(5192, "Disconnected");
+        case "incompatible":
+            return localize(5193, "Incompatible");
+        }
+    }
+    renderHostManagementAction(container, host) {
+        const actions = [];
+        if (host.hidden) {
+            actions.push({
+                action: "restore",
+                label: ( localize(5194, "Restore")),
+                ariaLabel: ( localize(5195, "Restore {0}", host.label)),
+                icon: Codicon.refresh
+            });
+        } else if (host.connectable && (host.status === "connected" || host.status === "connecting" || host.status === "reconnecting")) {
+            actions.push({
+                action: "disconnect",
+                label: ( localize(5196, "Disconnect")),
+                ariaLabel: ( localize(5197, "Disconnect {0}", host.label)),
+                icon: Codicon.circleSlash
+            });
+        } else if (host.connectable && host.status === "disconnected") {
+            actions.push({
+                action: "reconnect",
+                label: ( localize(5198, "Connect")),
+                ariaLabel: ( localize(5199, "Connect {0}", host.label)),
+                icon: Codicon.plug
+            });
+        }
+        for (const {
+            action,
+            label,
+            icon,
+            ariaLabel
+        } of actions) {
+            const button = this.managementStore.add(( new Button(container, {
+                ...defaultButtonStyles,
+                secondary: true,
+                supportIcons: true,
+                title: ariaLabel,
+                ariaLabel
+            })));
+            button.label = `$(${icon.id}) ${label}`;
+            button.element.dataset.hostId = host.id;
+            button.element.dataset.hostAction = action;
+            if (host.address) {
+                button.element.dataset.hostAddress = host.address;
+                this.hostFocusTargets.set(host.address, button.element);
+            }
+            button.enabled = this.pendingHostId === undefined;
+            this.bodyFocusTargets.push(button.element);
+            this.managementStore.add(button.onDidClick(() => void this.runHostAction(host.id, action)));
+        }
+        if (this.pendingHostId === host.id) {
+            append(container, $("span.connection-diagnostics-host-status")).textContent = ( localize(5200, "Working..."));
+        }
+        if (this.actionError?.hostId === host.id) {
+            const error = append(container, $("span.connection-diagnostics-host-error", {
+                role: "alert"
+            }));
+            error.textContent = this.actionError.message;
+        }
+    }
+    restoreManagementFocus(hostId, hostAddress, action, summary) {
+        if (action) {
+            const exactTarget = this.bodyFocusTargets.find(
+                target => target.dataset.hostId === hostId && target.dataset.hostAction === action
+            );
+            if (exactTarget) {
+                exactTarget.focus();
+                return;
+            }
+        }
+        if (hostAddress && (action || summary)) {
+            const target = action ? this.hostFocusTargets.get(hostAddress) : this.bodyFocusTargets.find(
+                target => target.dataset.hostAddress === hostAddress && target.tagName === "SUMMARY"
+            );
+            (target ?? this.content).focus();
+        }
+    }
+    scheduleRender() {
+        if (!this.renderScheduler.value) {
+            this.renderScheduler.value = scheduleAtNextAnimationFrame(getWindow(this.content), () => {
+                this.renderScheduler.clear();
+                this.render();
+            });
+        }
+    }
+    async runHostAction(hostId, action) {
+        if (this.pendingHostId) {
+            return;
+        }
+        this.pendingHostId = hostId;
+        this.actionError = undefined;
+        this.render();
+        try {
+            const host = this.diagnosticsService.getHostManagementState().hosts.find(host => host.id === hostId);
+            await this.diagnosticsService.runHostAction(hostId, action);
+            if (action === "restore") {
+                const restored = ( this.diagnosticsService.getHostManagementState().hosts.some(current => current.address === host?.address && current.selectable));
+                this.announce(restored ? ( localize(5201, "Host restored to the picker.")) : ( localize(5202, "Host restored, but not found in the latest discovery.")));
+            }
+        } catch (error) {
+            this.actionError = {
+                hostId,
+                message: toErrorMessage(error)
+            };
+            this.announce(this.actionError.message);
+        } finally {
+            this.pendingHostId = undefined;
+            this.render();
+        }
+    }
+};
+ConnectionDiagnosticsReport = ( __decorate([( __param(4, IConnectionDiagnosticsService)), ( __param(5, IClipboardService))], ConnectionDiagnosticsReport));
+function showConnectionDiagnosticsSheet(container, snapshot, instantiationService, options = {}) {
+    let report;
+    let api;
+    return showMobileContentSheet(container, ( localize(5203, "Connection information")), (body, sheetApi) => {
+        const store = ( new DisposableStore());
+        api = sheetApi;
+        api.overlay.classList.add("connection-diagnostics-overlay");
+        report = store.add(
+            instantiationService.createInstance(ConnectionDiagnosticsReport, body, snapshot, options.triggerDownload, {
+                enableHostManagement: options.enableHostManagement === true,
+                rediscoverOnRefresh: options.rediscoverOnRefresh === true
+            })
+        );
+        api.setBodyFocusTargets(report.getFocusTargets());
+        store.add(
+            report.onDidChangeFocusTargets(() => api.setBodyFocusTargets(report.getFocusTargets()))
+        );
+        if (options.onDidCreate) {
+            store.add(options.onDidCreate(report, api));
+        }
+        if (options.autoFocus !== false) {
+            report.focus();
+        }
+        return store;
+    }, {
+        iconClose: true,
+        trapFocus: true,
+        headerActions: [{
+            id: "copy",
+            label: ( localize(5204, "Copy Diagnostics")),
+            icon: Codicon.copy
+        }, {
+            id: "download",
+            label: ( localize(5205, "Download Diagnostics")),
+            icon: Codicon.cloudDownload
+        }, {
+            id: "refresh",
+            label: ( localize(5206, "Refresh")),
+            icon: Codicon.refresh
+        }],
+        onHeaderAction: id => {
+            switch (id) {
+            case "copy":
+                return report.copy();
+            case "download":
+                return report.download();
+            case "refresh":
+                return report.refresh().then(() => {
+                    api.setBodyFocusTargets(report.getFocusTargets());
+                });
+            }
+        }
+    });
+}
+
+export { ConnectionDiagnosticsReport, showConnectionDiagnosticsSheet };

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

@@ -0,0 +1,45 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { type ConnectionDiagnosticObserver } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/connectionDiagnostics";
+import { IRemoteAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service";
+import { ITunnelInfo } 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 { 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 { ConnectionHostManagementAction, IConnectionDiagnosticsSnapshot, IConnectionHostManagementState } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/connectionDiagnostics";
+import { IConnectionDiagnosticsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/connectionDiagnostics.service";
+/** Captures local evidence, not remote probes or raw protocol/log payloads. */
+export declare class ConnectionDiagnosticsService extends Disposable implements IConnectionDiagnosticsService {
+    private readonly _remoteService;
+    private readonly _tunnelService;
+    private readonly _filterService;
+    private readonly _configurationService;
+    private readonly _productService;
+    private readonly _fileService;
+    private readonly _environmentService;
+    readonly _serviceBrand: undefined;
+    protected get isWebPlatform(): boolean;
+    private readonly _onDidChangeHostManagement;
+    readonly onDidChangeHostManagement: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    private readonly _startedAt;
+    private readonly _activity;
+    private readonly _discoveryDiagnostics;
+    private readonly _connectionStates;
+    private _nextDiscoveryId;
+    private _lastDiscovery;
+    private _lastSuccessfulDiscovery;
+    private _lastSuccessfulDiscoveryAt;
+    private _discoveredTunnels;
+    constructor(_remoteService: IRemoteAgentHostService, _tunnelService: ITunnelAgentHostService, _filterService: IAgentHostFilterService, _configurationService: IConfigurationService, _productService: IProductService, _fileService: IFileService, _environmentService: IWorkbenchEnvironmentService);
+    trackDiscovery(trigger: string, discover: (onDiagnostic: ConnectionDiagnosticObserver) => Promise<ITunnelInfo[]>): Promise<ITunnelInfo[]>;
+    recordHostAction(address: string, action: "connect" | "disconnect", userInitiated: boolean): void;
+    getHostManagementState(): IConnectionHostManagementState;
+    runHostAction(hostId: string, action: ConnectionHostManagementAction): Promise<void>;
+    rediscover(): Promise<boolean>;
+    private _record;
+    private _captureConnections;
+    getSnapshot(): Promise<IConnectionDiagnosticsSnapshot>;
+    private discoveryTitle;
+}