@codingame/monaco-vscode-workbench-service-override 37.1.0 → 37.3.0

package/vscode/src/vs/sessions/services/sessions/browser/sessionsProvidersService.d.ts

@@ -0,0 +1,22 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ISessionsProvider } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsProvider";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+export interface ISessionsProvidersChangeEvent {
+    readonly added: readonly ISessionsProvider[];
+    readonly removed: readonly ISessionsProvider[];
+}
+export declare class SessionsProvidersService extends Disposable implements ISessionsProvidersService {
+    readonly _serviceBrand: undefined;
+    private readonly _providers;
+    private readonly _onDidChangeProviders;
+    readonly onDidChangeProviders: Event<ISessionsProvidersChangeEvent>;
+    registerProvider(provider: ISessionsProvider): IDisposable;
+    /**
+     * Returns all registered providers sorted by each provider's
+     * {@link ISessionsProvider.order} (lower first). The sort is stable, so
+     * providers with equal order keep their registration order.
+     */
+    getProviders(): ISessionsProvider[];
+    getProvider<T extends ISessionsProvider>(providerId: string): T | undefined;
+}

package/vscode/src/vs/sessions/services/sessions/browser/sessionsProvidersService.js

@@ -0,0 +1,42 @@
+
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+
+class SessionsProvidersService extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._providers = ( new Map());
+        this._onDidChangeProviders = this._register(( new Emitter()));
+        this.onDidChangeProviders = this._onDidChangeProviders.event;
+    }
+    registerProvider(provider) {
+        if (( this._providers.has(provider.id))) {
+            throw ( new Error(`Sessions provider '${provider.id}' is already registered.`));
+        }
+        this._providers.set(provider.id, provider);
+        this._onDidChangeProviders.fire({
+            added: [provider],
+            removed: []
+        });
+        return toDisposable(() => {
+            const entry = this._providers.get(provider.id);
+            if (entry) {
+                this._providers.delete(provider.id);
+                this._onDidChangeProviders.fire({
+                    added: [],
+                    removed: [provider]
+                });
+            }
+        });
+    }
+    getProviders() {
+        return Array.from(( this._providers.values())).sort((a, b) => a.order - b.order);
+    }
+    getProvider(providerId) {
+        return this._providers.get(providerId);
+    }
+}
+
+export { SessionsProvidersService };

package/vscode/src/vs/sessions/services/sessions/browser/sessionsRecencyHistory.d.ts

@@ -0,0 +1,43 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+/** A single recently-opened entry: a chat within a session, or a session when no specific chat applies. */
+export interface IRecencyEntry {
+    readonly sessionResource: URI;
+    readonly chatResource: URI | undefined;
+}
+/**
+ * The single source of truth for "recently opened" ordering across the sessions
+ * UI. Maintains an MRU-ordered list of `(session, chat)` entries (index 0 is the
+ * most recently opened), deduplicated by the `(session, chat)` pair and capped at
+ * {@link MAX_RECENCY_ENTRIES}. The list is persisted so recency survives reloads.
+ *
+ * Both the sessions picker (via
+ * {@link ISessionsManagementService.getRecentlyOpenedSessions}) and the
+ * Back/Forward navigation ({@link SessionsNavigation}) build on top of this.
+ */
+export declare class SessionsRecencyHistory extends Disposable {
+    private readonly _storageService;
+    private readonly _logService;
+    private static readonly STORAGE_KEY;
+    private static readonly MAX_RECENCY_ENTRIES;
+    private _entries;
+    private readonly _version;
+    /** Bumped whenever {@link entries} changes, so observers can react. */
+    get version(): IObservable<number>;
+    /** The recency entries in MRU order (index 0 is the most recently opened). */
+    get entries(): readonly IRecencyEntry[];
+    constructor(_storageService: IStorageService, _logService: ILogService);
+    /**
+     * Record that the given session (optionally a specific chat within it) was
+     * explicitly opened, promoting it to the front of the MRU list.
+     */
+    markOpened(sessionResource: URI, chatResource: URI | undefined): void;
+    /** Remove every entry matching the given predicate. */
+    remove(predicate: (entry: IRecencyEntry) => boolean): void;
+    private _bumpVersion;
+    private _load;
+    private _save;
+}

package/vscode/src/vs/sessions/services/sessions/browser/sessionsRecencyHistory.js

@@ -0,0 +1,103 @@
+
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+
+function entryKey(sessionResource, chatResource) {
+    return `${( sessionResource.toString())}::${chatResource?.toString() ?? ""}`;
+}
+class SessionsRecencyHistory extends Disposable {
+    static {
+        this.STORAGE_KEY = "agentSessions.recencyHistory";
+    }
+    static {
+        this.MAX_RECENCY_ENTRIES = 50;
+    }
+    get version() {
+        return this._version;
+    }
+    get entries() {
+        return this._entries;
+    }
+    constructor(_storageService, _logService) {
+        super();
+        this._storageService = _storageService;
+        this._logService = _logService;
+        this._entries = [];
+        this._version = observableValue(this, 0);
+        this._entries = this._load();
+    }
+    markOpened(sessionResource, chatResource) {
+        const key = entryKey(sessionResource, chatResource);
+        const existingIndex = this._entries.findIndex(e => entryKey(e.sessionResource, e.chatResource) === key);
+        if (existingIndex === 0) {
+            return;
+        }
+        if (existingIndex > 0) {
+            this._entries.splice(existingIndex, 1);
+        }
+        this._entries.unshift({
+            sessionResource,
+            chatResource
+        });
+        if (this._entries.length > SessionsRecencyHistory.MAX_RECENCY_ENTRIES) {
+            this._entries.length = SessionsRecencyHistory.MAX_RECENCY_ENTRIES;
+        }
+        this._save();
+        this._bumpVersion();
+    }
+    remove(predicate) {
+        const next = this._entries.filter(e => !predicate(e));
+        if (next.length === this._entries.length) {
+            return;
+        }
+        this._entries = next;
+        this._save();
+        this._bumpVersion();
+    }
+    _bumpVersion() {
+        this._version.set(this._version.get() + 1, undefined);
+    }
+    _load() {
+        const raw = this._storageService.get(SessionsRecencyHistory.STORAGE_KEY, StorageScope.WORKSPACE);
+        if (!raw) {
+            return [];
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed)) {
+                return [];
+            }
+            return parsed.filter(e => e && typeof e.session === "string").map(e => ({
+                sessionResource: ( URI.parse(e.session)),
+                chatResource: e.chat ? ( URI.parse(e.chat)) : undefined
+            }));
+        } catch (error) {
+            this._logService.warn(
+                "[SessionsRecencyHistory] failed to parse persisted recency history",
+                error
+            );
+            return [];
+        }
+    }
+    _save() {
+        if (this._entries.length === 0) {
+            this._storageService.remove(SessionsRecencyHistory.STORAGE_KEY, StorageScope.WORKSPACE);
+            return;
+        }
+        const serialized = this._entries.map(e => ({
+            session: ( e.sessionResource.toString()),
+            chat: e.chatResource?.toString()
+        }));
+        this._storageService.store(
+            SessionsRecencyHistory.STORAGE_KEY,
+            JSON.stringify(serialized),
+            StorageScope.WORKSPACE,
+            StorageTarget.MACHINE
+        );
+    }
+}
+
+export { SessionsRecencyHistory };

package/vscode/src/vs/sessions/services/sessions/browser/sessionsService.d.ts

@@ -0,0 +1,243 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+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 { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+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 { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IWorkspaceTrustRequestService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service";
+import { IWorkspaceTrustManagementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service";
+import { IChat, ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+import { IActiveSession, ICreateNewChatInSessionOptions, ICreateNewSessionOptions, IRecentlyOpenedSessions, IToggleSessionStickinessEvent } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { ISessionsPartService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsPartService.service";
+import { ICustomViewService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/customView/browser/customViewService.service";
+import { ISessionChangesStatsCache } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionChangesStatsCache.service";
+import { SessionOpenSource } from "./sessionOpenTelemetryService.js";
+import { ISessionOpenTelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionOpenTelemetryService.service";
+import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service";
+export interface ISessionNavigationRequest {
+    /** The caller's token, so deferred handoffs can recognize their own navigation. */
+    readonly token: CancellationToken;
+}
+/**
+ * Options for {@link ISessionsService.openNewSession}.
+ */
+export interface IOpenNewSessionOptions extends ICreateNewSessionOptions {
+    /**
+     * Folder to create a concrete draft session for. When set, a new draft is
+     * created and shown; when omitted, the new-session composer is shown
+     * (restoring any pending draft).
+     */
+    readonly folderUri?: URI;
+    /** Cancel startup session restoration so this new-session navigation wins. */
+    readonly cancelRestore?: boolean;
+    /** Keep the current navigation intent when the composer creates or updates its own draft. */
+    readonly preserveNavigation?: boolean;
+    /**
+     * When `true`, opens the new session (or empty composer slot) to the side
+     * of the active session in the grid instead of replacing it in place.
+     */
+    readonly toSide?: boolean;
+}
+/**
+ * Result of {@link ISessionsService.openNewSession}. `session` holds the
+ * created/restored draft on success. `trustDeclined` is `true` only when a
+ * `folderUri` was supplied, the folder required workspace trust, and the
+ * user explicitly declined it — distinct from any other resolution/creation
+ * failure (where `session` is also `undefined` but `trustDeclined` is
+ * `false`, since that may still succeed later once a provider registers).
+ */
+export interface IOpenNewSessionResult {
+    readonly session: ISession | undefined;
+    readonly trustDeclined: boolean;
+}
+/** Options for {@link ISessionsService.closeChat}. */
+export interface ICloseChatOptions {
+    /**
+     * Do not remember the chat as the most recently closed item. Used by batch
+     * closes (e.g. "Close All Chats"), where remembering just the final chat of
+     * the batch would make one arbitrary member of it reopenable.
+     */
+    readonly skipHistory?: boolean;
+}
+export interface IOpenSessionOptions {
+    readonly preserveFocus?: boolean;
+    readonly source?: SessionOpenSource;
+    readonly restoreOnlySideOrToolChat?: boolean;
+}
+export declare class SessionsService extends Disposable implements ISessionsService {
+    private readonly storageService;
+    private readonly logService;
+    private readonly uriIdentityService;
+    private readonly contextKeyService;
+    private readonly sessionsManagementService;
+    private readonly sessionsProvidersService;
+    private readonly sessionsPartService;
+    private readonly customViewService;
+    private readonly instantiationService;
+    private readonly workspaceTrustRequestService;
+    private readonly workspaceTrustManagementService;
+    private readonly changesStatsCache;
+    private readonly sessionOpenTelemetryService;
+    readonly _serviceBrand: undefined;
+    private readonly _onDidToggleSessionStickiness;
+    readonly onDidToggleSessionStickiness: Event<IToggleSessionStickinessEvent>;
+    /** Owns the active/sticky/transient visibility model and the {@link IActiveSession} wrappers. */
+    private readonly _visibility;
+    readonly visibleSessions: IObservable<readonly (IActiveSession | undefined)[]>;
+    /** Remembers the single most recently closed chat or session for {@link reopenLastClosedItem}. */
+    private readonly _closedItems;
+    /** The canonical active session — the visible active slot. */
+    readonly activeSession: IObservable<IActiveSession | undefined>;
+    private readonly _initialRestoreComplete;
+    readonly initialRestoreComplete: IObservable<boolean>;
+    private readonly _navigationRequest;
+    readonly navigationRequest: IObservable<ISessionNavigationRequest | undefined>;
+    private readonly _isNewChatSessionContext;
+    /** Cancelled on every navigation action so in-flight async opens bail out. */
+    private readonly _openSessionCts;
+    /**
+     * Cancellation for the in-flight {@link restoreVisibleSessions}. Kept
+     * separate from {@link _openSessionCts} so that additive new-session
+     * operations (the new-chat composer eagerly creating a draft on startup)
+     * do not abort restoring the previously visible grid. Explicit navigation
+     * to a session, or a new-session handoff with `cancelRestore`, cancels it.
+     */
+    private readonly _restoreCts;
+    private readonly _sessionStates;
+    private readonly _pendingRestoredChatResources;
+    private readonly _navigation;
+    /**
+     * The single source of truth for session recency (most-recently-opened
+     * first), persisted across restarts. Both the recent-sessions picker (via
+     * {@link getRecentlyOpenedSessions}) and {@link SessionsNavigation} build on
+     * top of it.
+     */
+    private readonly _recencyHistory;
+    /**
+     * Session id (or `undefined` for the new-session slot) that focus was last
+     * moved into in response to an active-session change. Tracks the active id
+     * so unrelated visibility updates don't re-focus and steal focus.
+     */
+    private _focusedActiveSessionId;
+    /** The in-flight foreground send's "keep newest chat active" follow. */
+    private readonly _sendFollow;
+    constructor(storageService: IStorageService, logService: ILogService, uriIdentityService: IUriIdentityService, contextKeyService: IContextKeyService, sessionsManagementService: ISessionsManagementService, sessionsProvidersService: ISessionsProvidersService, sessionsPartService: ISessionsPartService, customViewService: ICustomViewService, instantiationService: IInstantiationService, workspaceTrustRequestService: IWorkspaceTrustRequestService, workspaceTrustManagementService: IWorkspaceTrustManagementService, changesStatsCache: ISessionChangesStatsCache, sessionOpenTelemetryService: ISessionOpenTelemetryService);
+    private _onDidReplaceSession;
+    private _activeSessionViewListeners;
+    private _onDidChangeSessions;
+    private _startSendFollow;
+    getRecentlyOpenedSessions(): IRecentlyOpenedSessions;
+    /**
+     * Cancel any in-flight open-session/restore and return a fresh cancellation token.
+     */
+    private _startOpenSession;
+    private _beginNavigation;
+    private _recordNavigation;
+    /**
+     * Cancel an in-flight {@link restoreVisibleSessions}. Called when the user
+     * explicitly navigates to a session, including a new-session handoff that
+     * sets `cancelRestore`, so restore stops fighting the user's choice.
+     */
+    private _cancelRestore;
+    /**
+     * Make the given session active in the visibility model, optionally without
+     * moving focus into it. The preserve-focus intent is published atomically
+     * with the active session by the visibility model, and the model's
+     * canonical active session is updated reactively by the mirror autorun.
+     */
+    private _activate;
+    openChat(session: ISession, chatUri: URI, options?: IOpenSessionOptions): Promise<void>;
+    private _openChatSession;
+    private _openChat;
+    closeChat(session: IActiveSession, chat: IChat, options?: ICloseChatOptions): Promise<void>;
+    reopenLastClosedItem(): Promise<void>;
+    /**
+     * Persist a chat's closed/open state into the session's stored view state so
+     * it survives switching the session out of the grid (which disposes its
+     * wrapper) and reloads. Done synchronously on the close/open action rather
+     * than reactively from `closedChats`, which would depend on the session's
+     * chats being loaded. The main chat can never be closed and is ignored.
+     */
+    private _setChatVisibilityState;
+    private _applyActiveChatSelection;
+    openSession(sessionResource: URI, options?: IOpenSessionOptions): Promise<void>;
+    private _openSession;
+    showSession(sessionResource: URI, options?: {
+        preserveFocus?: boolean;
+    }): void;
+    canOpenSession(session: ISession): Promise<boolean>;
+    openSessionToSide(session: ISession, options?: IOpenSessionOptions & {
+        chatResource?: URI;
+    }): Promise<void>;
+    /**
+     * Opens a chat to the side of its session view, redirecting a superseded
+     * resource first so a migrating session opens its adopted twin to the side
+     * rather than the old facade. Provider-neutral: the redirect is the
+     * `resolveSessionResource` hook, not a scheme check.
+     */
+    openChatToSide(session: ISession, chatResource: URI, options?: {
+        preserveFocus?: boolean;
+    }): Promise<void>;
+    /**
+     * Redirects a superseded session to its authoritative facade before it is
+     * shown (mirrors `openSession`'s URI resolution). Provider-neutral: it asks
+     * `resolveSessionResource`, which declines unfamiliar resources, rather than
+     * inspecting the provider's URI scheme. Returns the redirected session (and
+     * its main chat) when it changes, otherwise the inputs unchanged.
+     */
+    private _resolveSessionForOpen;
+    private _getSession;
+    private _showSession;
+    private _waitForOpenSessionToLoad;
+    unsetNewSession(): void;
+    openNewSession(options?: IOpenNewSessionOptions, token?: CancellationToken): Promise<IOpenNewSessionResult>;
+    private _openNewSession;
+    /** Open or move beside the active session when requested, keeping a single empty slot. */
+    private _activateOrInsert;
+    openQuickChat(options?: ICreateNewSessionOptions): IActiveSession | undefined;
+    private _openQuickChat;
+    openNewChatInSession(session: ISession, options?: ICreateNewChatInSessionOptions): Promise<void>;
+    setActive(session: IActiveSession | undefined): void;
+    submitNewSessionInput(): Promise<boolean>;
+    toggleSessionStickiness(session: ISession): void;
+    insertAt(session: ISession | undefined, targetSessionId: string, side: "left" | "right", activate?: boolean): void;
+    closeSession(session: ISession | undefined): void;
+    closeAllSessions(): void;
+    private _restoreInitialChat;
+    /**
+     * The resource strings of chats that were closed (hidden from the tab strip)
+     * when the session was last saved, so they stay hidden across reloads. Stale
+     * URIs that no longer match a chat are harmless: the visible session
+     * intersects them with the live chat list.
+     */
+    private _restoreClosedChats;
+    private _restoreShownRelatedChats;
+    private _waitForSessionToLoad;
+    private _loadSessionStates;
+    private _saveSessionStates;
+    private _snapshotVisibleSessionStates;
+    /**
+     * The persisted visible sessions, ordered left-to-right by their stored
+     * grid position.
+     */
+    private _getVisibleSessionStates;
+    /**
+     * Wait for the session with the given resource to become available via its
+     * provider, resolving with the session or `undefined` if the token is
+     * cancelled before it appears. When `timeout` is given, resolves with
+     * `undefined` after that many milliseconds so a persisted session that never
+     * resurfaces (e.g. deleted while the window was closed) cannot keep restore
+     * pending — and its provider listeners alive — indefinitely.
+     */
+    private _waitForSession;
+    restoreVisibleSessions(): Promise<void>;
+    private _restoreVisibleSessions;
+    openPreviousSession(): Promise<void>;
+    openNextSession(): Promise<void>;
+}