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

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

@@ -0,0 +1,8 @@
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ISessionsWindowUsageService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsWindowUsageService.service";
+export declare class SessionsWindowUsageService implements ISessionsWindowUsageService {
+    readonly _serviceBrand: undefined;
+    readonly hadPriorWindowOpen: boolean;
+    readonly windowOpenCount: number;
+    constructor(storageService: IStorageService);
+}

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

@@ -0,0 +1,24 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+
+const AGENTS_WINDOW_OPEN_COUNT_KEY = "agentSessions.telemetry.summary.appLaunchCount";
+let SessionsWindowUsageService = class SessionsWindowUsageService {
+    constructor(storageService) {
+        const previousWindowOpenCount = storageService.getNumber(AGENTS_WINDOW_OPEN_COUNT_KEY, StorageScope.APPLICATION, 0);
+        this.hadPriorWindowOpen = previousWindowOpenCount > 0;
+        this.windowOpenCount = previousWindowOpenCount + 1;
+        storageService.store(
+            AGENTS_WINDOW_OPEN_COUNT_KEY,
+            this.windowOpenCount,
+            StorageScope.APPLICATION,
+            StorageTarget.MACHINE
+        );
+    }
+};
+SessionsWindowUsageService = ( __decorate([( __param(0, IStorageService))], SessionsWindowUsageService));
+
+export { SessionsWindowUsageService };

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

@@ -0,0 +1,321 @@
+import { Disposable, IDisposable } 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 { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IActiveSession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement";
+import { IChat, ISession, SessionStatus } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+/**
+ * Wraps an {@link ISession} with an active chat observable to form an
+ * {@link IActiveSession}. Delegates all {@link ISession} property accesses
+ * to the wrapped session so the active session always reflects the latest
+ * session state without a stale shallow copy.
+ *
+ * One instance exists per session currently in the visibility model
+ * (active, transient, or sticky). Each instance owns its own active-chat
+ * observable so visible-but-not-active sessions retain their per-session
+ * chat selection.
+ */
+export declare class VisibleSession extends Disposable implements IActiveSession {
+    private readonly _session;
+    private readonly _isCreated;
+    readonly isCreated: IObservable<boolean>;
+    private readonly _sticky;
+    readonly sticky: IObservable<boolean>;
+    private readonly _activeChat;
+    readonly activeChat: IObservable<IChat>;
+    /**
+     * Model and mode are scoped to the active chat so the Agents window pickers
+     * read and write the selection of the currently focused chat, not the
+     * session/default chat. Sessions with multiple peer chats keep an
+     * independent model/agent per chat.
+     */
+    private readonly _activeChatModelId;
+    private readonly _activeChatMode;
+    /** Resource strings of chats that have been closed (hidden from the tab strip). */
+    private readonly _closedChatUris;
+    /**
+     * Resource strings of subagent (tool-origin) chats the user explicitly opened,
+     * so they surface as tabs. Subagents are hidden from the tab strip by default.
+     */
+    private readonly _shownRelatedChatUris;
+    /** Append-only list tracking close order; last element is the most recently closed. */
+    private readonly _closedChatOrder;
+    readonly openChats: IObservable<readonly IChat[]>;
+    readonly closedChats: IObservable<readonly IChat[]>;
+    readonly visibleChatTabs: IObservable<readonly IChat[]>;
+    readonly shouldShowChatTabs: IObservable<boolean>;
+    constructor(_session: ISession, initialChat: IChat, initialClosedChatUris?: Iterable<string>, initialShownRelatedChatUris?: Iterable<string>);
+    setActiveChat(chat: IChat): void;
+    closeChat(chat: IChat): void;
+    openChat(chat: IChat): void;
+    /**
+     * Pick the active chat to fall back to when the current one is closed: the
+     * last chat that would appear as a visible tab given the closed and shown-
+     * subagent sets, or the main chat.
+     */
+    private _defaultActiveChat;
+    get lastClosedChat(): IChat | undefined;
+    setSticky(value: boolean): void;
+    /** Register a disposable that lives as long as this wrapper. */
+    addDisposable(disposable: IDisposable): IDisposable;
+    get sessionId(): string;
+    get resource(): URI;
+    get providerId(): string;
+    get sessionType(): string;
+    get icon(): import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+    get createdAt(): Date;
+    get workspace(): IObservable<import("@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session").ISessionWorkspace | undefined>;
+    get hasGitRepository(): IObservable<boolean> | undefined;
+    get worktreePending(): IObservable<boolean> | undefined;
+    get isQuickChat(): IObservable<boolean> | undefined;
+    get isAutomation(): IObservable<boolean> | undefined;
+    get isExternal(): IObservable<boolean> | undefined;
+    get remoteConnectionStatus(): IObservable<import("@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session").SessionRemoteConnectionStatus> | undefined;
+    get createdBySession(): IObservable<import("@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session").ISessionCreationReference | undefined> | undefined;
+    get title(): IObservable<string>;
+    get updatedAt(): IObservable<Date>;
+    get status(): IObservable<SessionStatus>;
+    get completedStateIcon(): IObservable<import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon | undefined> | undefined;
+    get changesSummary(): IObservable<import("@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session").ISessionChangesSummary | undefined> | undefined;
+    get changesets(): IObservable<readonly import("@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session").ISessionChangeset[] | undefined>;
+    get changes(): IObservable<readonly import("@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session").ISessionFileChange[]>;
+    get artifacts(): IObservable<readonly import("@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session").ISessionArtifact[]> | undefined;
+    get modelId(): IObservable<string | undefined>;
+    get mode(): IObservable<{
+        readonly id: string;
+        readonly kind: string;
+    } | undefined>;
+    get loading(): IObservable<boolean>;
+    get isNewSessionRequestInProgress(): IObservable<boolean> | undefined;
+    get isArchived(): IObservable<boolean>;
+    get isRead(): IObservable<boolean>;
+    get description(): IObservable<import("@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent").IMarkdownString | undefined>;
+    get lastTurnEnd(): IObservable<Date | undefined>;
+    get chats(): IObservable<readonly IChat[]>;
+    get mainChat(): IObservable<IChat>;
+    get capabilities(): IObservable<import("@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session").ISessionCapabilities>;
+    /** The wrapped session, which outlives this wrapper. */
+    get session(): ISession;
+}
+/**
+ * Encapsulates the visibility model used by the
+ * {@link SessionsManagementService}.
+ *
+ * The model tracks:
+ * - The currently active session.
+ * - An ordered list of slots to display in the sessions part's grid. A slot
+ *   is either a session id (string) or `undefined` (the "empty" / new-session
+ *   placeholder). At most one slot may be `undefined` at a time.
+ * - A "sticky" set: sessions the user has explicitly pinned. Non-sticky
+ *   sessions also live in the grid but get replaced when new sessions open.
+ *   The empty slot is always non-sticky.
+ *
+ * Each tracked session has a single {@link VisibleSession} wrapper owned by
+ * this class. Wrappers are disposed automatically when their session leaves
+ * the visibility model.
+ */
+export declare class VisibleSessions extends Disposable {
+    private readonly _resolveInitialChat;
+    private readonly _resolveInitialClosedChats;
+    private readonly _resolveInitialShownRelatedChats;
+    private readonly _onSlotReplaced;
+    private readonly _uriIdentityService;
+    private readonly _activeSession;
+    readonly activeSession: IObservable<IActiveSession | undefined>;
+    /**
+     * Whether the most recent active-session change asked to preserve keyboard
+     * focus (i.e. show the session without moving focus into it). Always set in
+     * the **same transaction** as {@link _activeSession} via
+     * {@link _setActiveSession} so the pair can never go stale, and read
+     * reactively by the consumer that drives focus.
+     */
+    private readonly _activePreserveFocus;
+    readonly activePreserveFocus: IObservable<boolean>;
+    private readonly _visibleSessions;
+    readonly visibleSessions: IObservable<readonly (IActiveSession | undefined)[]>;
+    private readonly _wrappers;
+    /**
+     * Ordered slot ids in the grid (left-to-right). Each entry is either a
+     * session id or `undefined` (the empty slot). The invariant is that at
+     * most one entry is `undefined` at any time.
+     */
+    private _visibleList;
+    /** Subset of {@link _visibleList} the user has marked sticky. */
+    private readonly _stickyIds;
+    /**
+     * Slot id of the most recently opened (or toggled-to-non-sticky) entry in
+     * the grid. Used to choose which non-sticky slot to replace when opening a
+     * new session while the active one is sticky.
+     * - `NO_RECENT` means none is tracked.
+     * - `undefined` refers to the empty slot.
+     * - A string refers to that session id.
+     */
+    private _mostRecentNonStickySlot;
+    /**
+     * @param _onSlotReplaced Reports a session that left the grid because a
+     * newly opened slot took its place, with the slot state it lost. Explicit
+     * removals ({@link removeMany}) and grid restores are not reported.
+     */
+    constructor(_resolveInitialChat: (session: ISession) => IChat, _resolveInitialClosedChats: (session: ISession) => Iterable<string>, _resolveInitialShownRelatedChats: (session: ISession) => Iterable<string>, _onSlotReplaced: (replaced: ISession, index: number, sticky: boolean, replacedBySessionId: string | undefined) => void, _uriIdentityService: IUriIdentityService);
+    /**
+     * Set the active session together with its preserve-focus intent in a
+     * single transaction. Routing every active-session change through here
+     * guarantees the two observables are always consistent and that the intent
+     * never goes stale (callers that do not preserve focus pass `false`).
+     */
+    private _setActiveSession;
+    /**
+     * Set the active session, updating the visibility model accordingly.
+     *
+     * - Passing `undefined` places (or keeps) the single empty slot in the
+     *   grid and makes it active. The empty slot is always non-sticky.
+     * - If the session is already in the grid, its slot is preserved and only
+     *   the active observable is updated.
+     * - Otherwise the session is placed as non-sticky:
+     *   - If the active slot is non-sticky, the new one replaces it in
+     *     place.
+     *   - Else if a non-sticky slot exists, the most-recently opened
+     *     non-sticky is replaced.
+     *   - Else the session is appended at the end of the grid.
+     *
+     * Returns the wrapper for the active session, or `undefined` when the
+     * active slot is the empty slot.
+     */
+    setActive(session: ISession | undefined, preserveFocus?: boolean): VisibleSession | undefined;
+    /**
+     * Insert (or move) a slot into the grid positioned next to a target
+     * session that is already visible. Used by drag-and-drop and by
+     * "open at position" entry points.
+     *
+     * - If the slot is not yet visible, a new non-sticky entry is created
+     *   at the computed position.
+     * - If the slot is already visible, it is moved to the computed
+     *   position; its sticky / non-sticky state is preserved. This also
+     *   moves the single empty slot when `session` is `undefined`.
+     *
+     * When `activate` is `true` (default), the inserted slot also becomes
+     * the active session. When `false`, the active session is left
+     * unchanged.
+     *
+     * `targetSessionId` may be `undefined` to position relative to the empty
+     * (new-session) slot. No-op if the target slot is not currently visible.
+     */
+    insertAt(session: ISession | undefined, targetSessionId: string | undefined, side: "left" | "right", activate?: boolean): void;
+    /**
+     * Atomically (re)build the entire grid from a persisted snapshot.
+     *
+     * Slots are given left-to-right; a `session` of `undefined` denotes the
+     * empty new-session slot. The whole model — slot order, stickiness and the
+     * active slot — is published in a single transaction so restoring multiple
+     * sessions does not produce intermediate layouts (which would otherwise
+     * cause the grid to visibly flicker as sessions are restored one by one).
+     *
+     * Any wrappers for sessions no longer present in the snapshot are disposed.
+     *
+     * @param slots Ordered grid slots to restore.
+     * @param activeIndex Index into `slots` of the slot that should be active,
+     * or `-1` for none.
+     */
+    restoreGrid(slots: ReadonlyArray<{
+        readonly session: ISession | undefined;
+        readonly sticky: boolean;
+    }>, activeIndex: number): void;
+    /**
+     * The grid slot state of a currently visible session (or of the empty slot
+     * when `sessionId` is `undefined`), or `undefined` when it is not visible.
+     */
+    getSlot(sessionId: string | undefined): {
+        readonly index: number;
+        readonly sticky: boolean;
+    } | undefined;
+    /** The session behind a visible slot, or `undefined` for the empty slot / an unknown id. */
+    getSession(sessionId: string | undefined): ISession | undefined;
+    /**
+     * Put a session (back) into the grid at `index`, shifting the slots at and
+     * after it to the right, and make it active. The index is clamped to the
+     * current grid size, so a stale index appends instead of failing. No-op
+     * when the session is already visible.
+     */
+    insertAtIndex(session: ISession, index: number, sticky: boolean): VisibleSession | undefined;
+    /**
+     * Replace the slot currently held by `slotId` (`undefined` for the empty
+     * slot) with `session`, and make it active. Used to undo a grid
+     * replacement, so the restored session lands exactly where it was and the
+     * session that took its place leaves the grid. No-op when the slot is not
+     * visible or the session is already visible elsewhere.
+     */
+    replaceSlot(slotId: string | undefined, session: ISession, sticky: boolean): VisibleSession | undefined;
+    /**
+     * Toggle a session's stickiness in the grid. The session keeps its grid
+     * slot when toggled.
+     * - If the session is not currently visible, it is appended at the end as
+     *   sticky.
+     *
+     * Returns the session's stickiness state after the toggle.
+     */
+    toggleStickiness(session: ISession): boolean;
+    /**
+     * Remove the given session ids from the visibility model and dispose their
+     * wrappers. Passing `undefined` removes the empty (new-session) slot if
+     * present. If the active slot is among the removed entries, the active
+     * observable falls back to the slot at the active's original position
+     * (or the slot to its left if it was at the end of the grid); when no
+     * visible slot remains, the active observable is cleared. Observables
+     * are refreshed once if anything changed.
+     */
+    removeMany(sessionIds: Iterable<string | undefined>): void;
+    /**
+     * Set the active chat for the given session's wrapper. No-op if the
+     * session is not currently tracked in the visibility model.
+     */
+    setActiveChat(session: ISession, chat: IChat): void;
+    /**
+     * Close (hide from the tab strip) the given chat in the session's wrapper.
+     * No-op if the session is not currently tracked in the visibility model.
+     */
+    closeChat(session: ISession, chat: IChat): void;
+    /**
+     * Open (un-hide from the tab strip) a previously closed chat in the session's
+     * wrapper. No-op if the session is not currently tracked in the visibility model.
+     */
+    openChat(session: ISession, chat: IChat): void;
+    /**
+     * Replace the given session in the visibility model with `updatedSession`,
+     * preserving the grid slot, sticky state, and active state. The wrapper
+     * for the old session is disposed; a fresh wrapper is created for the
+     * updated session. No-op if `session` is not currently in the grid.
+     */
+    updateSession(session: ISession, updatedSession: ISession): void;
+    /**
+     * Create a transient {@link ISession} that mirrors the given session but
+     * exposes a different {@link ISession.resource}. The visibility model's
+     * wrapper for the same session id is rebuilt against this transient
+     * session so consumers observe the new resource. Returns the transient
+     * session so callers can pass it to a subsequent {@link updateSession}
+     * once the provider produces the final session.
+     *
+     * No-op (but still returns the transient session) if the session is not
+     * currently in the grid.
+     */
+    updateResourceOfSession(session: ISession, resource: URI): ISession;
+    /**
+     * Rename a session id in the visibility model so the same grid slot is
+     * reused for the replacement. The old wrapper is disposed; a fresh one is
+     * created lazily on next access. Does not auto-refresh — callers should
+     * call {@link refresh} or {@link setActive} as appropriate.
+     */
+    replaceId(fromId: string, toId: string): void;
+    /** Re-publish the visible sessions and sticky ids observables. */
+    refresh(): void;
+    private _findLastNonSticky;
+    /** True if the given slot id refers to a sticky session. The empty slot is never sticky. */
+    private _isStickySlot;
+    /**
+     * Returns the slot id of the currently active entry in the grid, or
+     * {@link NO_RECENT} if no entry in the grid is active.
+     */
+    private _currentActiveSlot;
+    private _removeFromModel;
+    private _refresh;
+    private _getOrCreateVisibleSession;
+}