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

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

@@ -0,0 +1,250 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { getActiveElement, getWindow, isHTMLElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Disposable, toDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
+import { isWeb } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { AccessibleContentProvider, AccessibleViewProviderId, AccessibleViewType } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleView';
+import { AccessibleViewRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleViewRegistry';
+import { IAccessibilityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service';
+import { registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { RawContextKey, ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { registerWorkbenchContribution2, WorkbenchPhase, getWorkbenchContribution } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IsSessionsWindowContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { AccessibilityVerbositySettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+import { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
+import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { isPhoneLayout } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/mobile/mobileLayout';
+import { ShowConnectionDiagnosticsCommandId } 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';
+import './connectionDiagnosticsService.js';
+import { showConnectionDiagnosticsSheet } from './connectionDiagnosticsReport.js';
+
+const connectionDiagnosticsFocused = new RawContextKey("connectionDiagnosticsFocused", false);
+let ConnectionDiagnosticsContribution = class ConnectionDiagnosticsContribution extends Disposable {
+    static {
+        this.ID = "sessions.connectionDiagnostics";
+    }
+    get isWebPlatform() {
+        return isWeb;
+    }
+    constructor(
+        diagnosticsService,
+        instantiationService,
+        layoutService,
+        contextKeyService,
+        entitlementService,
+        accessibilityService,
+        configurationService,
+        keybindingService,
+        notificationService
+    ) {
+        super();
+        this.diagnosticsService = diagnosticsService;
+        this.instantiationService = instantiationService;
+        this.layoutService = layoutService;
+        this.contextKeyService = contextKeyService;
+        this.entitlementService = entitlementService;
+        this.accessibilityService = accessibilityService;
+        this.configurationService = configurationService;
+        this.keybindingService = keybindingService;
+        this.notificationService = notificationService;
+        this._register(toDisposable(() => this.active?.close()));
+        this._register(toDisposable(() => this.accessibleView?.dispose()));
+        this._register(this.entitlementService.onDidChangeSentiment(() => {
+            if (this.entitlementService.sentiment.hidden) {
+                this.active?.close();
+            }
+        }));
+    }
+    async show(snapshot, returnFocus) {
+        if (this._store.isDisposed || this.entitlementService.sentiment.hidden) {
+            return;
+        }
+        if (this.focusActiveReport()) {
+            return;
+        }
+        const container = this.layoutService.activeContainer;
+        const previouslyFocused = returnFocus ?? getActiveElement();
+        const returnPart = this.isWebPlatform ? [Parts.TITLEBAR_PART, Parts.SIDEBAR_PART].find(part => this.layoutService.hasFocus(part)) : undefined;
+        try {
+            snapshot ??= await this.diagnosticsService.getSnapshot();
+        } catch (error) {
+            this.notificationService.warn(( localize(
+                5152,
+                "Could not capture connection information. {0}",
+                toErrorMessage(error)
+            )));
+            return;
+        }
+        if (this._store.isDisposed || this.entitlementService.sentiment.hidden || getWindow(container).closed) {
+            return;
+        }
+        if (this.focusActiveReport()) {
+            return;
+        }
+        let active;
+        await showConnectionDiagnosticsSheet(container, snapshot, this.instantiationService, {
+            autoFocus: false,
+            enableHostManagement: this.isWebPlatform,
+            rediscoverOnRefresh: this.isWebPlatform,
+            onDidCreate: (report, api) => {
+                active = this.active = {
+                    report,
+                    overlay: api.overlay,
+                    close: () => api.close(),
+                    restoreFocus: true,
+                    returnFocus: isHTMLElement(previouslyFocused) ? previouslyFocused : undefined
+                };
+                return this.attachModal(container, report, api);
+            }
+        });
+        if (active?.restoreFocus && !this.active) {
+            if (isHTMLElement(previouslyFocused) && previouslyFocused.isConnected) {
+                previouslyFocused.focus();
+            } else if (returnPart !== undefined) {
+                this.layoutService.focusPart(returnPart, getWindow(container));
+            }
+        }
+    }
+    focusActiveReport() {
+        if (!this.active) {
+            return false;
+        }
+        this.active.report.focus();
+        return true;
+    }
+    attachModal(container, report, api) {
+        const store = ( new DisposableStore());
+        const updateLayoutClass = () => {
+            const phoneLayout = isPhoneLayout(this.layoutService);
+            api.overlay.classList.toggle("phone-layout", phoneLayout);
+            api.overlay.classList.toggle("desktop-layout", !phoneLayout);
+        };
+        updateLayoutClass();
+        store.add(this.layoutService.onDidLayoutMainContainer(updateLayoutClass));
+        const context = store.add(this.contextKeyService.createScoped(api.sheet));
+        connectionDiagnosticsFocused.bindTo(context).set(true);
+        for (const sibling of Array.from(container.children).filter(isHTMLElement)) {
+            if (sibling === api.overlay) {
+                continue;
+            }
+            const wasInert = sibling.inert;
+            sibling.inert = true;
+            store.add(toDisposable(() => sibling.inert = wasInert));
+        }
+        store.add(toDisposable(() => {
+            api.overlay.inert = true;
+            api.overlay.setAttribute("aria-hidden", "true");
+            if (this.active?.report === report) {
+                this.active = undefined;
+            }
+        }));
+        report.focus();
+        if (this.accessibilityService.isScreenReaderOptimized() && this.configurationService.getValue(AccessibilityVerbositySettingId.ConnectionDiagnostics)) {
+            const keybinding = this.keybindingService.lookupKeybinding("editor.action.accessibilityHelp")?.getAriaLabel();
+            if (keybinding) {
+                report.announce(( localize(5153, "Use {0} for connection diagnostics accessibility help.", keybinding)));
+            }
+        }
+        return store;
+    }
+    getAccessibleProvider(type) {
+        const active = this.active;
+        if (!active) {
+            return undefined;
+        }
+        const snapshot = active.report.getSnapshot();
+        const returnFocus = active.returnFocus;
+        active.restoreFocus = false;
+        active.overlay.remove();
+        active.close();
+        const help = [...(this.isWebPlatform ? [( localize(
+            5154,
+            "On phones, Open Connection Information beside the Hosts sheet title closes the picker and opens this report. Closing the report returns focus to the host picker control, or its toolbar if that control was replaced."
+        ))] : []), this.isWebPlatform ? ( localize(
+            5155,
+            "Connection information shows live host summaries with Connect and Disconnect beside each host. Expand a host to read its captured diagnostic details. Actions use current host state. An intentional disconnect keeps the host in the picker and pauses automatic connection. The separate Hidden hosts section has Restore actions that return hosts to discovery; restoration does not guarantee a connection."
+        )) : ( localize(
+            5156,
+            "Connection diagnostics shows a read-only snapshot of local connection state."
+        )), this.isWebPlatform ? ( localize(
+            5157,
+            "Use Tab and Shift+Tab to move between host actions, header actions, the report, and collapsed sections. Use arrow keys to scroll the focused report. Use Enter or Space to expand client details."
+        )) : ( localize(
+            5158,
+            "Use Tab and Shift+Tab to move between the header actions, report, and collapsed sections. Use arrow keys to scroll the focused report. Use Enter or Space to expand client details."
+        )), this.isWebPlatform ? ( localize(
+            5159,
+            "Copy Diagnostics and Download Diagnostics include the entire displayed snapshot, including collapsed sections. Review host names and addresses before sharing. Refresh re-runs host discovery and then captures current local state."
+        )) : ( localize(
+            5160,
+            "Copy Diagnostics and Download Diagnostics include the entire displayed snapshot, including collapsed sections. Review host names and addresses before sharing. Refresh reads current local state without discovery, authentication, or connection changes."
+        )), ( localize(
+            5161,
+            "Open the report as plain text with {0}.",
+            "<keybinding:editor.action.accessibleView>"
+        )), ( localize(
+            5162,
+            "Snapshots include recorded connection stages and a bounded excerpt of the local Window log. Copy and Download use the captured text without collecting new logs. Known credentials are redacted; review messages before sharing."
+        )), ( localize(
+            5163,
+            "Escape or Close dismisses diagnostics. Closing this accessible view returns to the diagnostics snapshot."
+        ))].join("\n\n");
+        const provider = ( new AccessibleContentProvider(AccessibleViewProviderId.ConnectionDiagnostics, {
+            type,
+            language: "plaintext"
+        }, () => type === AccessibleViewType.Help ? help : snapshot.text, () => {
+            if (this.accessibleView === provider) {
+                this.accessibleView = undefined;
+            }
+            void this.show(snapshot, isHTMLElement(returnFocus) ? returnFocus : undefined);
+        }, AccessibilityVerbositySettingId.ConnectionDiagnostics));
+        this.accessibleView = provider;
+        provider.onDispose = () => {
+            if (this.accessibleView === provider) {
+                this.accessibleView = undefined;
+            }
+        };
+        return provider;
+    }
+};
+ConnectionDiagnosticsContribution = ( __decorate([( __param(0, IConnectionDiagnosticsService)), ( __param(1, IInstantiationService)), ( __param(2, IWorkbenchLayoutService)), ( __param(3, IContextKeyService)), ( __param(4, IChatEntitlementService)), ( __param(5, IAccessibilityService)), ( __param(6, IConfigurationService)), ( __param(7, IKeybindingService)), ( __param(8, INotificationService))], ConnectionDiagnosticsContribution));
+registerWorkbenchContribution2(
+    ConnectionDiagnosticsContribution.ID,
+    ConnectionDiagnosticsContribution,
+    WorkbenchPhase.Eventually
+);
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: ShowConnectionDiagnosticsCommandId,
+            title: ( localize2(5164, "Show Connection Information")),
+            category: ( localize2(5165, "Remote Agent Hosts")),
+            f1: true,
+            precondition: ( ContextKeyExpr.and(IsSessionsWindowContext, ChatContextKeys.enabled))
+        });
+    }
+    run(_accessor) {
+        void getWorkbenchContribution(ConnectionDiagnosticsContribution.ID).show();
+    }
+});
+for (const type of [AccessibleViewType.Help, AccessibleViewType.View]) {
+    AccessibleViewRegistry.register({
+        type,
+        priority: 125,
+        name: "connectionDiagnostics",
+        when: connectionDiagnosticsFocused,
+        getProvider: () => getWorkbenchContribution(ConnectionDiagnosticsContribution.ID).getAccessibleProvider(type)
+    });
+}
+
+export { ConnectionDiagnosticsContribution };

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

@@ -0,0 +1,6 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IConnectionDiagnosticsSection } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/connectionDiagnostics";
+/** Only lifecycle messages are exported; protocol payloads, auth dumps and multiline continuations are excluded. */
+export declare function selectConnectionLogLines(text: string): readonly string[];
+export declare function collectConnectionLogs(fileService: IFileService, logFile: URI): Promise<IConnectionDiagnosticsSection>;

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

@@ -0,0 +1,52 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { sanitizeConnectionDiagnosticText, formatConnectionDiagnosticError, getConnectionDiagnosticError } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/connectionDiagnostics';
+
+const MAX_LOG_BYTES = 128 * 1024;
+function selectConnectionLogLines(text) {
+    const lifecycle = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3} \[(?:trace|debug|info|warning|error|critical)\] \[(?:RemoteAgentHost|RemoteAgentHostProtocol|BrowserTunnelAgentHost|WebTunnelAgentHost|TunnelAgentHost)\] (?:Connecting|Connected|Reconnecting|Reconnected|Re-establishing|Re-established|Connection closed|Transport lost|Reconnect attempt failed|Automatic reconnect|Scheduling reconnect|Stopped reconnecting|Not reconnecting|Liveness:|Failed to (?:list|enumerate|create a connection|connect|get)|Discovery (?:complete|failed)|Silent status check|Tunnel transport closed|Found \d+ tunnel)/;
+    return text.split(/\r?\n/).filter(line => lifecycle.test(line)).slice(-200).map(line => sanitizeConnectionDiagnosticText(line));
+}
+async function collectConnectionLogs(fileService, logFile) {
+    const entries = [{
+        label: ( localize(5166, "Collection started at")),
+        value: ( new Date()).toISOString()
+    }];
+    try {
+        const stat = await fileService.stat(logFile);
+        const position = Math.max(0, stat.size - MAX_LOG_BYTES);
+        const result = await fileService.readFile(logFile, {
+            position,
+            length: MAX_LOG_BYTES
+        });
+        let text = ( result.value.toString());
+        if (position > 0) {
+            const newline = text.indexOf("\n");
+            text = newline === -1 ? "" : text.slice(newline + 1);
+        }
+        const lines = selectConnectionLogLines(text);
+        entries.push({
+            label: ( localize(5167, "Messages")),
+            value: lines.length ? lines.join("\n") : ( localize(
+                5168,
+                "No matching connection lifecycle lines were found in this bounded excerpt."
+            ))
+        });
+    } catch (error) {
+        entries.push({
+            label: ( localize(5169, "Log collection failed")),
+            value: formatConnectionDiagnosticError(getConnectionDiagnosticError(error))
+        });
+    }
+    return {
+        title: ( localize(5170, "Connection-related Window log excerpt")),
+        collapsed: true,
+        description: ( localize(
+            5171,
+            "Up to 200 lifecycle lines from the last 128 KiB of the current Window log; no rotated or remote logs. Messages may be unavailable at the current log level. Known credentials are redacted; review before sharing."
+        )),
+        entries
+    };
+}
+
+export { collectConnectionLogs, selectConnectionLogLines };

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

@@ -0,0 +1,51 @@
+import * as dom from "@codingame/monaco-vscode-api/vscode/vs/base/browser/dom";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IClipboardService } from "@codingame/monaco-vscode-api/vscode/vs/platform/clipboard/common/clipboardService.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IMobileContentSheetApi } from "@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/mobile/mobilePickerSheet";
+import { IConnectionDiagnosticsSnapshot } 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";
+export declare class ConnectionDiagnosticsReport extends Disposable {
+    private readonly triggerDownload;
+    private readonly options;
+    private readonly diagnosticsService;
+    private readonly clipboardService;
+    private readonly _onDidChangeFocusTargets;
+    readonly onDidChangeFocusTargets: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    private readonly managementStore;
+    private readonly renderScheduler;
+    private readonly content;
+    private readonly scrollable;
+    private readonly message;
+    private readonly bodyFocusTargets;
+    private readonly hostFocusTargets;
+    private snapshot;
+    private snapshotRequest;
+    private pendingHostId;
+    private actionError;
+    constructor(container: HTMLElement, snapshot: IConnectionDiagnosticsSnapshot, triggerDownload: typeof dom.triggerDownload | undefined, options: {
+        readonly enableHostManagement: boolean;
+        readonly rediscoverOnRefresh: boolean;
+    }, diagnosticsService: IConnectionDiagnosticsService, clipboardService: IClipboardService);
+    getSnapshot(): IConnectionDiagnosticsSnapshot;
+    focus(): void;
+    getFocusTargets(): readonly HTMLElement[];
+    refresh(): Promise<void>;
+    copy(): Promise<void>;
+    download(): void;
+    announce(message: string): void;
+    private render;
+    private renderHiddenHosts;
+    private getHostStatusLabel;
+    private renderHostManagementAction;
+    private restoreManagementFocus;
+    private scheduleRender;
+    private runHostAction;
+}
+export declare function showConnectionDiagnosticsSheet(container: HTMLElement, snapshot: IConnectionDiagnosticsSnapshot, instantiationService: IInstantiationService, options?: {
+    readonly onDidCreate?: (report: ConnectionDiagnosticsReport, api: IMobileContentSheetApi) => IDisposable;
+    readonly triggerDownload?: typeof dom.triggerDownload;
+    readonly autoFocus?: boolean;
+    readonly enableHostManagement?: boolean;
+    readonly rediscoverOnRefresh?: boolean;
+}): Promise<void>;