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

package/vscode/src/vs/sessions/browser/parts/sessionRemoteConnection.js

@@ -0,0 +1,363 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { TimeoutTimer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Disposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { isAgentHostProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { SessionRemoteConnectionFailureReason } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { observableSignal } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignal';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { derivedObservableWithCache } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/utils';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+
+const RECONNECTING_BANNER_DELAY = 5_000;
+function isSameRemoteConnectionStatus(a, b) {
+    if (!a || !b) {
+        return a === b;
+    }
+    if (a.kind === "disconnected" && b.kind === "disconnected") {
+        return a.reason === b.reason;
+    }
+    return a.kind === b.kind;
+}
+let SessionRemoteConnection = class SessionRemoteConnection extends Disposable {
+    constructor(_sessionsProvidersService, _logService) {
+        super();
+        this._sessionsProvidersService = _sessionsProvidersService;
+        this._logService = _logService;
+        this._session = observableValue(this, undefined);
+        this._attempt = observableValue(this, undefined);
+        this._progressListener = this._register(( new MutableDisposable()));
+        this._deadlineSignal = observableSignal(this);
+        this._reconnectCountdownSignal = observableSignal(this);
+        this._autoConnected = observableValue(this, undefined);
+        this._connectAttempted = observableValue(this, undefined);
+        this._autoConnectPending = derived(this, reader => {
+            const session = this._session.read(reader);
+            const provider = session && this._sessionsProvidersService.getProvider(session.providerId);
+            const status = this._getEffectiveStatus(reader);
+            if (!session || !provider || !isAgentHostProvider(provider) || !provider.connect || !provider.autoConnect) {
+                return false;
+            }
+            return provider.autoConnect.enabled.read(reader) && status?.kind === "disconnected" && status.reason === SessionRemoteConnectionFailureReason.HostNotRunning && this._autoConnected.read(reader) !== session && this._attempt.read(reader) === undefined;
+        });
+        this._reconnectingSince = derivedObservableWithCache(this, (reader, last) => {
+            const session = this._session.read(reader);
+            const status = this._getEffectiveStatus(reader);
+            const attempt = this._attempt.read(reader);
+            if (!session || status?.kind !== "reconnecting" || attempt?.kind === "active") {
+                return undefined;
+            }
+            return last?.session === session ? last : {
+                session,
+                since: Date.now()
+            };
+        }).recomputeInitiallyAndOnChange(this._store);
+        this._reconnectingBannerVisible = derived(this, reader => {
+            const reconnecting = this._reconnectingSince.read(reader);
+            if (reconnecting === undefined) {
+                return false;
+            }
+            const remaining = reconnecting.since + RECONNECTING_BANNER_DELAY - Date.now();
+            if (remaining <= 0) {
+                return true;
+            }
+            this._deadlineSignal.read(reader);
+            reader.store.add(new TimeoutTimer(() => this._deadlineSignal.trigger(undefined), remaining));
+            return false;
+        });
+        this._reconnectCountdownSeconds = derived(this, reader => {
+            const status = this._getEffectiveStatus(reader);
+            if (status?.kind !== "reconnecting" || status.nextAttemptAt === undefined) {
+                return undefined;
+            }
+            this._reconnectCountdownSignal.read(reader);
+            const now = Date.now();
+            const remaining = status.nextAttemptAt - now;
+            if (remaining <= 0) {
+                return undefined;
+            }
+            reader.store.add(new TimeoutTimer(
+                () => this._reconnectCountdownSignal.trigger(undefined),
+                1_000 - now % 1_000
+            ));
+            return Math.ceil(remaining / 1_000);
+        });
+        this.bannerContent = derived(this, reader => this._getRemoteConnectionBannerContent(reader));
+        this.recoveryContent = derived(this, reader => this._getRemoteHostUnavailableContent(reader));
+        this._register(autorun(reader => {
+            if (this._getEffectiveStatus(reader)?.kind === "connected" && this._autoConnected.read(reader) !== undefined) {
+                this._autoConnected.set(undefined, undefined);
+            }
+            if (!this._autoConnectPending.read(reader)) {
+                return;
+            }
+            const session = this._session.read(reader);
+            this._logService.info(
+                `[SessionRemoteConnection] auto-connect triggered for ${session?.providerId}`
+            );
+            this._autoConnected.set(session, undefined);
+            this.connect();
+        }));
+    }
+    setSession(session) {
+        this._progressListener.clear();
+        transaction(tx => {
+            this._session.set(session, tx);
+            this._attempt.set(undefined, tx);
+            this._autoConnected.set(undefined, tx);
+            this._connectAttempted.set(undefined, tx);
+        });
+    }
+    connect() {
+        const session = this._session.get();
+        if (!session) {
+            this._logService.info("[SessionRemoteConnection] connect: no session");
+            return;
+        }
+        const attempt = this._attempt.get();
+        if (attempt?.kind === "active" && attempt.session === session) {
+            this._logService.info("[SessionRemoteConnection] connect: attempt already active");
+            return;
+        }
+        if (attempt?.kind === "failed") {
+            this._attempt.set(undefined, undefined);
+        }
+        const provider = this._sessionsProvidersService.getProvider(session.providerId);
+        if (!provider || !isAgentHostProvider(provider) || !provider.connect) {
+            this._logService.info(
+                `[SessionRemoteConnection] connect: ${session.providerId} cannot connect on demand`
+            );
+            return;
+        }
+        const statusBefore = session.remoteConnectionStatus?.get();
+        this._logService.info(
+            `[SessionRemoteConnection] connect: starting ${provider.remoteAddress ?? provider.id}, statusBefore=${statusBefore?.kind}`
+        );
+        transaction(tx => {
+            this._attempt.set({
+                kind: "active",
+                session,
+                message: undefined,
+                statusBefore
+            }, tx);
+            this._connectAttempted.set(session, tx);
+        });
+        const remoteAddress = provider.remoteAddress;
+        if (remoteAddress && provider.onDidReportConnectProgress) {
+            this._progressListener.value = provider.onDidReportConnectProgress(progress => {
+                if (progress.connectionKey !== remoteAddress) {
+                    return;
+                }
+                const currentAttempt = this._attempt.get();
+                if (currentAttempt?.kind === "active" && currentAttempt.session === session) {
+                    this._attempt.set({
+                        ...currentAttempt,
+                        message: progress.message
+                    }, undefined);
+                }
+            });
+        }
+        void this._runConnect(session, statusBefore, () => provider.connect());
+    }
+    async _runConnect(session, statusBefore, connect) {
+        try {
+            await connect();
+            this._logService.info(
+                `[SessionRemoteConnection] connect resolved, status=${session.remoteConnectionStatus?.get()?.kind}`
+            );
+            this._finishAttempt(session);
+        } catch (error) {
+            this._logService.info(`[SessionRemoteConnection] connect rejected: ${error}`);
+            this._failAttempt(session, statusBefore);
+            onUnexpectedError(error);
+        }
+    }
+    _finishAttempt(session) {
+        const attempt = this._attempt.get();
+        if (attempt?.kind !== "active" || attempt.session !== session) {
+            return;
+        }
+        this._progressListener.clear();
+        this._attempt.set(undefined, undefined);
+    }
+    _failAttempt(session, statusBefore) {
+        const attempt = this._attempt.get();
+        if (attempt?.kind !== "active" || attempt.session !== session) {
+            return;
+        }
+        this._progressListener.clear();
+        this._attempt.set({
+            kind: "failed",
+            session,
+            statusBefore
+        }, undefined);
+    }
+    _getEffectiveStatus(reader) {
+        const session = this._session.read(reader);
+        const status = session?.remoteConnectionStatus?.read(reader);
+        const attempt = this._attempt.read(reader);
+        return attempt?.kind === "failed" && attempt.session === session && status?.kind === "connecting" ? attempt.statusBefore : status;
+    }
+    _getConnectionLabels(provider) {
+        if (provider && isAgentHostProvider(provider) && provider.connectionLabels) {
+            return provider.connectionLabels;
+        }
+        const hostLabel = provider?.label ?? ( localize(3022, "The remote host"));
+        return {
+            unavailableTitle: ( localize(3023, "Cannot Connect to {0}", hostLabel)),
+            unavailableDescription: ( localize(3024, "Cannot reach {0}.", hostLabel)),
+            unavailable: ( localize(3024, "Cannot reach {0}.", hostLabel)),
+            connectingTitle: ( localize(3025, "Connecting to {0}", hostLabel)),
+            connectingDescription: ( localize(3026, "Starting {0}.", hostLabel)),
+            connecting: ( localize(3027, "Waiting for agent host connection...")),
+            reconnecting: ( localize(3028, "Reconnecting to {0}...", hostLabel)),
+            reconnectingIn: seconds => ( localize(3029, "Reconnecting to {0} in {1}s", hostLabel, seconds)),
+            incompatibleTitle: ( localize(3030, "Cannot Connect to {0}", hostLabel)),
+            incompatible: ( localize(
+                3031,
+                "{0} is incompatible with this version of Visual Studio Code.",
+                hostLabel
+            ))
+        };
+    }
+    _getRemoteHostConnectProgress(session, status, labels, reader) {
+        const attempt = this._attempt.read(reader);
+        if (attempt?.kind !== "active" || attempt.session !== session || status?.kind === "connected") {
+            return undefined;
+        }
+        if (attempt.message !== undefined) {
+            return attempt.message;
+        }
+        const settling = status?.kind === "connecting" || status?.kind === "reconnecting" || isSameRemoteConnectionStatus(status, attempt.statusBefore);
+        return settling ? labels.connecting : undefined;
+    }
+    _getRemoteHostUnavailableContent(reader) {
+        const session = this._session.read(reader);
+        if (!session) {
+            return undefined;
+        }
+        const status = this._getEffectiveStatus(reader);
+        const provider = this._sessionsProvidersService.getProvider(session.providerId);
+        const hostLabel = provider?.label ?? ( localize(3022, "The remote host"));
+        const labels = this._getConnectionLabels(provider);
+        if (status?.kind === "connected") {
+            return undefined;
+        }
+        if (status?.kind === "incompatible") {
+            return {
+                title: labels.incompatibleTitle,
+                description: labels.incompatible
+            };
+        }
+        const progressMessage = this._getRemoteHostConnectProgress(session, status, labels, reader);
+        const autoConnectPending = this._autoConnectPending.read(reader);
+        const canStartHost = !!provider && isAgentHostProvider(provider) && !!provider.connect;
+        const autoConnect = canStartHost && provider.autoConnect ? {
+            label: provider.autoConnect.label,
+            checked: provider.autoConnect.enabled.read(reader),
+            onChange: checked => provider.autoConnect.setEnabled(checked)
+        } : undefined;
+        const attempt = this._attempt.read(reader);
+        const startedFromStoppedHost = autoConnectPending || (attempt?.kind === "active" && attempt.session === session && attempt.statusBefore?.kind === "disconnected" && attempt.statusBefore.reason === SessionRemoteConnectionFailureReason.HostNotRunning);
+        if (progressMessage || autoConnectPending || status?.kind === "connecting") {
+            return {
+                title: labels.connectingTitle,
+                description: labels.connectingDescription,
+                progress: progressMessage ?? labels.connecting,
+                autoConnect: startedFromStoppedHost ? autoConnect : undefined
+            };
+        }
+        if (!status || status.kind !== "disconnected") {
+            return undefined;
+        }
+        if (status.reason === SessionRemoteConnectionFailureReason.HostNotRunning) {
+            return {
+                title: ( localize(3032, "Unable to Connect to {0}", hostLabel)),
+                description: ( localize(3033, "{0} is not running.", hostLabel)),
+                action: provider && isAgentHostProvider(provider) && provider.connect ? {
+                    label: ( localize(3034, "Start {0}", hostLabel)),
+                    run: () => this.connect()
+                } : undefined,
+                autoConnect
+            };
+        }
+        return {
+            title: labels.unavailableTitle,
+            description: labels.unavailableDescription,
+            action: canStartHost ? {
+                label: this._connectActionLabel(session, reader),
+                run: () => this.connect()
+            } : undefined
+        };
+    }
+    _getRemoteConnectionBannerContent(reader) {
+        const session = this._session.read(reader);
+        if (!session) {
+            return undefined;
+        }
+        const status = this._getEffectiveStatus(reader);
+        const provider = this._sessionsProvidersService.getProvider(session.providerId);
+        const hostLabel = provider?.label ?? ( localize(3022, "The remote host"));
+        const labels = this._getConnectionLabels(provider);
+        const progressMessage = this._getRemoteHostConnectProgress(session, status, labels, reader);
+        if (progressMessage || this._autoConnectPending.read(reader) || status?.kind === "connecting") {
+            return {
+                icon: Codicon.sync,
+                message: progressMessage ?? labels.connecting
+            };
+        }
+        if (!status || status.kind === "connected") {
+            return undefined;
+        }
+        if (status.kind === "incompatible") {
+            return {
+                icon: Codicon.debugDisconnect,
+                message: labels.incompatible
+            };
+        }
+        if (status.kind === "reconnecting") {
+            const seconds = this._reconnectCountdownSeconds.read(reader);
+            return this._reconnectingBannerVisible.read(reader) ? {
+                icon: Codicon.sync,
+                message: seconds === undefined ? labels.reconnecting : labels.reconnectingIn(seconds),
+                ariaLabel: labels.reconnecting,
+                action: seconds !== undefined && provider && isAgentHostProvider(provider) && provider.reconnectNow ? {
+                    label: ( localize(3035, "Try Now")),
+                    run: () => provider.reconnectNow?.()
+                } : undefined
+            } : undefined;
+        }
+        if (status.reason === SessionRemoteConnectionFailureReason.HostNotRunning) {
+            return {
+                icon: Codicon.debugDisconnect,
+                message: ( localize(3033, "{0} is not running.", hostLabel)),
+                action: provider && isAgentHostProvider(provider) && provider.connect ? {
+                    label: ( localize(3034, "Start {0}", hostLabel)),
+                    run: () => this.connect()
+                } : undefined
+            };
+        }
+        return {
+            icon: Codicon.debugDisconnect,
+            message: labels.unavailable,
+            action: provider && isAgentHostProvider(provider) && provider.connect ? {
+                label: this._connectActionLabel(session, reader),
+                run: () => this.connect()
+            } : undefined
+        };
+    }
+    _connectActionLabel(session, reader) {
+        return this._connectAttempted.read(reader) === session ? ( localize(3036, "Retry")) : ( localize(3037, "Connect"));
+    }
+};
+SessionRemoteConnection = ( __decorate([( __param(0, ISessionsProvidersService)), ( __param(1, ILogService))], SessionRemoteConnection));
+
+export { SessionRemoteConnection };

package/vscode/src/vs/sessions/browser/parts/sessionView.d.ts

@@ -0,0 +1,125 @@
+import { ISerializableView, IViewSize } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/grid/grid";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { IActiveSession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement";
+import { IChat } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+import { IChatViewOptions, ISelectWorkspaceOptions, WorkspaceSelectionResult } from "@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/chatView";
+import { ISessionChangesStatsCache } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionChangesStatsCache.service";
+import { IChatViewFactory } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/chatView/browser/chatViewFactory.service";
+/**
+ * Options passed to {@link SessionView.openSession}. Extends the chat view
+ * options so they can be forwarded to the new-chat views the host creates.
+ */
+export interface ISessionViewOptions extends IChatViewOptions {
+}
+/**
+ * A stable single-slot grid leaf for the Sessions Part. `SessionsPart`
+ * delegates `openSession(...)` to this host so it no longer needs to remove/add
+ * grid views as the bound session changes.
+ *
+ * Hosts the full-width {@link SessionHeader} above a {@link ChatGroupsView} that
+ * renders the session's chats as a grid of groups. The header content shares the
+ * chat's centered, width-capped content band.
+ */
+export declare class SessionView extends Disposable implements ISerializableView {
+    private readonly _chatViewFactory;
+    private readonly themeService;
+    private readonly _changesStatsCache;
+    static readonly TYPE = "sessions.sessionView";
+    private static readonly CENTERED_CONTENT_MAX_WIDTH;
+    readonly element: HTMLElement;
+    readonly minimumWidth = 200;
+    readonly maximumWidth: number;
+    readonly minimumHeight = 200;
+    readonly maximumHeight: number;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<IViewSize | undefined>;
+    private readonly _header;
+    private readonly _groupsView;
+    private readonly _standaloneView;
+    private readonly _floatingToolbar;
+    private readonly _centeredContentContainer;
+    private readonly _contentContainer;
+    private _lastLayout;
+    private _openSessionDisposables;
+    private _currentSession;
+    private _hasOpenedSession;
+    private readonly _sessionIsMaximizedKey;
+    private readonly _scopedContextKeyService;
+    private readonly _scopedInstantiationService;
+    /** Whether the hosted groups view currently shows a grid (more than one group). */
+    private _isGridLayout;
+    /** Whether this view currently hosts the active session in the grid. */
+    private _isActive;
+    /** Whether the owning {@link SessionsPart} is visible in the workbench grid. */
+    private _isPartVisible;
+    /** Whether this leaf is visible within the part's internal grid. */
+    private _isLeafVisible;
+    private readonly _sessionObs;
+    constructor(_chatViewFactory: IChatViewFactory, instantiationService: IInstantiationService, contextKeyService: IContextKeyService, themeService: IThemeService, _changesStatsCache: ISessionChangesStatsCache);
+    openSession(session: IActiveSession | undefined, options: ISessionViewOptions): void;
+    private _showSessionGroups;
+    private _handleContextKeys;
+    layout(width: number, height: number, top: number, left: number): void;
+    private _layoutChildren;
+    toJSON(): object;
+    focus(): void;
+    /**
+     * Starts an inline rename of the session title in the header. Returns
+     * `false` when the header cannot host it (e.g. this view is hidden or the
+     * chat tabs row replaces the header) so callers can fall back to another
+     * rename affordance.
+     */
+    startTitleEditing(): boolean;
+    getFocusedChat(): IChat | undefined;
+    getSession(): IActiveSession | undefined;
+    selectWorkspace(folderUri: URI, options?: ISelectWorkspaceOptions): WorkspaceSelectionResult;
+    selectNoWorkspace(): void;
+    /** Opens the given chat in a group beside the active one ("open to the side"). */
+    openChatToSide(resource: URI): Promise<void>;
+    /** Places a freshly created chat (e.g. a side chat) into its own group beside the current one. */
+    splitChatToSide(resource: URI): void;
+    focusAdjacentChatGroup(direction: "previous" | "next"): void;
+    splitActiveChat(direction: "right" | "bottom"): void;
+    moveActiveChatToAdjacentGroup(direction: "previous" | "next"): void;
+    prefillInput(text: string): void;
+    sendQuery(text: string): void;
+    submitInput(): Promise<boolean>;
+    /**
+     * Attaches the given resources as context to the active chat group's input.
+     */
+    attach(uris: URI[]): void;
+    /**
+     * Updates the view's maximized context key so toolbars hosted within can react.
+     * Called by the owning {@link SessionsPart} when the grid's maximized view changes.
+     */
+    setMaximized(maximized: boolean): void;
+    /**
+     * Updates whether this view currently hosts the active session in the grid.
+     * Forwarded to the inner chat view so it can adjust its visual styling
+     * (e.g. dim the list background for inactive sessions).
+     */
+    setActive(active: boolean): void;
+    /**
+     * Grid hook invoked by the part's internal split view when this leaf is
+     * hidden or shown (e.g. when a sibling session is maximized).
+     */
+    setVisible(visible: boolean): void;
+    /**
+     * Called by the owning {@link SessionsPart} when the part itself is hidden or
+     * shown in the workbench grid. Combined with this leaf's own visibility to
+     * form the view's effective visibility.
+     */
+    setPartVisible(visible: boolean): void;
+    /**
+     * Whether this view is actually shown. Unrelated to {@link setActive}:
+     * inactive sessions shown side by side are still visible.
+     */
+    private get _isVisible();
+    private _updateVisibility;
+    private _applyActiveSessionStyles;
+}