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

package/vscode/src/vs/sessions/contrib/layout/browser/singlePaneLayoutController.d.ts

@@ -0,0 +1,55 @@
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IEditorWorkingSet } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
+import { BaseLayoutController } from "./baseSessionLayoutController.js";
+export { TOGGLE_DETAILS_COMMAND_ID } from "./singlePane/singlePaneExistingSessionStrategy.js";
+/**
+ * Layout controller for the single-pane detail-panel layout. A sibling of the
+ * classic {@link import('./desktopSessionLayoutController.js').LayoutController}
+ * (both extend {@link BaseLayoutController}), it owns its behaviour through exactly
+ * two composed lifecycle strategies rather than desktop inheritance:
+ *  - {@link SinglePaneDraftSessionStrategy} — workspace-backed and workspace-less drafts;
+ *  - {@link SinglePaneExistingSessionStrategy} — a created, workspace-backed session
+ *    (also owns the Toggle Details command and the shared managed-tabs coordinator);
+ *
+ * Each owns the full vertical slice of behaviour for its stage: side-pane visibility, the
+ * detail-panel (Changes/Files) mapping, and — for the two workspace stages — a supplementary
+ * nuance on the shared managed-docked-tabs reconcile pipeline (`SinglePaneDockedTabsCoordinator`,
+ * which also performs the detail-only editor-area collapse). That coordinator, the detail
+ * panel's sync mechanics (`SinglePaneDetailPanelCoordinator`), and the shared New/Existing
+ * Editor-visibility-profile storage (`SinglePaneVisibilityProfileStore`) are non-strategy coordinator
+ * objects — see `singlePane/singlePaneLayoutStrategy.ts`'s doc comment for why.
+ *
+ * Strategies coordinate through this controller (the {@link ISinglePaneLayoutContext}):
+ * a session-switch restore is signalled by {@link _isRestoringSessionLayout}, so
+ * a restore-driven editor change is never mistaken for a user action.
+ */
+export declare class SinglePaneLayoutController extends BaseLayoutController {
+    private _context;
+    private _existingSession;
+    private _managedTabs;
+    protected get _layoutStateStorageKey(): string;
+    protected get _legacyWorkingSetsStorageKey(): string | undefined;
+    private get _ctx();
+    protected _registerViewStateManagement(): void;
+    protected _registerAuxiliaryControllers(): void;
+    /** Toggle the detail panel and return whether it is now visible. */
+    toggleDetails(): boolean;
+    /**
+     * A session-switch restore closes/opens the docked editors (empty working-set
+     * apply, managed-tab reconciliation), so suppress editor-part auto-visibility
+     * for the whole restore to avoid closing the side pane or mistaking a
+     * layout-driven close for a user dismissing a managed tab.
+     */
+    protected _suppressEditorVisibilityDuringRestore(): IDisposable | undefined;
+    protected get _isEditorPartVisibilityPerSession(): boolean;
+    protected get _isViewStatePerSession(): boolean;
+    /**
+     * Governs the panel at the workbench level (like the side pane). Flipping this
+     * single gate off makes the base remember the panel's *view* per session instead
+     * (defaulting to the Terminal).
+     */
+    protected get _isPanelVisibilityPerSession(): boolean;
+    protected _shouldRevealEditorPartOnApply(_editorPartHidden: boolean, _isModal: boolean): boolean;
+    protected _shouldHideEditorPartOnApply(_editorPartHidden: boolean): boolean;
+    protected _onWillApplyWorkingSet(workingSet: IEditorWorkingSet | "empty"): void;
+}

package/vscode/src/vs/sessions/contrib/layout/browser/singlePaneLayoutController.js

@@ -0,0 +1,91 @@
+
+import { LifecyclePhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { BaseLayoutController } from './baseSessionLayoutController.js';
+import { SinglePaneDetailPanelCoordinator } from './singlePane/singlePaneDetailPanelCoordinator.js';
+import { SinglePaneDockedTabsCoordinator } from './singlePane/singlePaneDockedTabsCoordinator.js';
+import { SinglePaneDraftSessionStrategy } from './singlePane/singlePaneDraftSessionStrategy.js';
+import { SinglePaneExistingSessionStrategy } from './singlePane/singlePaneExistingSessionStrategy.js';
+export { TOGGLE_DETAILS_COMMAND_ID } from './singlePane/singlePaneExistingSessionStrategy.js';
+import { SinglePaneVisibilityProfileStore } from './singlePane/singlePaneVisibilityProfileStore.js';
+
+const SINGLE_PANE_LAYOUT_STATE_KEY = "sessions.singlePane.layoutState";
+class SinglePaneLayoutController extends BaseLayoutController {
+    get _layoutStateStorageKey() {
+        return SINGLE_PANE_LAYOUT_STATE_KEY;
+    }
+    get _legacyWorkingSetsStorageKey() {
+        return undefined;
+    }
+    get _ctx() {
+        if (!this._context) {
+            const that = this;
+            this._context = {
+                get isRestoringSessionLayout() {
+                    return that._isRestoringSessionLayout;
+                },
+                withSessionLayoutRestore: work => that._withSessionLayoutRestore(work),
+                onDidEndSessionLayoutRestore: that.onDidEndSessionLayoutRestore,
+                get togglingSidePane() {
+                    return that._togglingSidePane;
+                },
+                get multipleSessionsVisibleObs() {
+                    return that.multipleSessionsVisibleObs;
+                },
+                get activeSessionResourceObs() {
+                    return that.activeSessionResourceObs;
+                },
+                hasSavedWorkingSet: sessionResource => ( that._workingSets.has(sessionResource))
+            };
+        }
+        return this._context;
+    }
+    _registerViewStateManagement() {
+        const visibilityStore = this._instantiationService.createInstance(SinglePaneVisibilityProfileStore);
+        const detailPanel = this._register(
+            this._instantiationService.createInstance(SinglePaneDetailPanelCoordinator)
+        );
+        this._existingSession = this._register(
+            this._instantiationService.createInstance(SinglePaneExistingSessionStrategy, this._ctx, visibilityStore, detailPanel)
+        );
+        this._register(
+            this._instantiationService.createInstance(SinglePaneDraftSessionStrategy, this._ctx, detailPanel, visibilityStore)
+        );
+    }
+    _registerAuxiliaryControllers() {
+        this._lifecycleService.when(LifecyclePhase.Restored).then(() => {
+            if (this._store.isDisposed) {
+                return;
+            }
+            this._managedTabs = this._register(
+                this._instantiationService.createInstance(SinglePaneDockedTabsCoordinator, this._ctx)
+            );
+            this._existingSession?.registerManagedTabs(this._managedTabs);
+        });
+    }
+    toggleDetails() {
+        return this._existingSession?.toggleDetails() ?? false;
+    }
+    _suppressEditorVisibilityDuringRestore() {
+        return this._layoutService.suppressEditorPartAutoVisibility();
+    }
+    get _isEditorPartVisibilityPerSession() {
+        return false;
+    }
+    get _isViewStatePerSession() {
+        return false;
+    }
+    get _isPanelVisibilityPerSession() {
+        return false;
+    }
+    _shouldRevealEditorPartOnApply(_editorPartHidden, _isModal) {
+        return false;
+    }
+    _shouldHideEditorPartOnApply(_editorPartHidden) {
+        return false;
+    }
+    _onWillApplyWorkingSet(workingSet) {
+        this._managedTabs?.prepareWorkingSetRestore(workingSet !== "empty");
+    }
+}
+
+export { SinglePaneLayoutController };

package/vscode/src/vs/sessions/contrib/onboardingTours/browser/agentHostReadinessContext.d.ts

@@ -0,0 +1,11 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+export declare class AgentHostReadinessContextContribution extends Disposable implements IWorkbenchContribution {
+    private readonly _sessionsManagementService;
+    static readonly ID = "sessions.contrib.onboardingTours.agentHostReadinessContext";
+    private readonly _agentHostSessionTypesAvailable;
+    constructor(_sessionsManagementService: ISessionsManagementService, contextKeyService: IContextKeyService);
+    private _update;
+}

package/vscode/src/vs/sessions/contrib/onboardingTours/browser/agentHostReadinessContext.js

@@ -0,0 +1,39 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { isAgentHostProviderId } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { AgentHostSessionTypesAvailableContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+
+let AgentHostReadinessContextContribution = class AgentHostReadinessContextContribution extends Disposable {
+    static {
+        this.ID = "sessions.contrib.onboardingTours.agentHostReadinessContext";
+    }
+    constructor(_sessionsManagementService, contextKeyService) {
+        super();
+        this._sessionsManagementService = _sessionsManagementService;
+        this._agentHostSessionTypesAvailable = AgentHostSessionTypesAvailableContext.bindTo(contextKeyService);
+        this._register(toDisposable(() => this._agentHostSessionTypesAvailable.reset()));
+        this._register(
+            this._sessionsManagementService.onDidChangeSessionTypes(() => this._update())
+        );
+        this._update();
+    }
+    _update() {
+        this._agentHostSessionTypesAvailable.set(( this._sessionsManagementService.getAllProviderSessionTypes().some((
+            {
+                providerId
+            }
+        ) => isAgentHostProviderId(providerId))));
+    }
+};
+AgentHostReadinessContextContribution = ( __decorate([( __param(0, ISessionsManagementService)), ( __param(1, IContextKeyService))], AgentHostReadinessContextContribution));
+registerWorkbenchContribution2(
+    AgentHostReadinessContextContribution.ID,
+    AgentHostReadinessContextContribution,
+    WorkbenchPhase.BlockRestore
+);
+
+export { AgentHostReadinessContextContribution };

package/vscode/src/vs/sessions/contrib/onboardingTours/browser/newSessionTourContribution.d.ts

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/sessions/contrib/onboardingTours/browser/newSessionTourContribution.js

@@ -0,0 +1,109 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { addDisposableListener, EventType } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { StorageScope } 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 { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { onboardingScenarioRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/onboarding/common/onboardingRegistry';
+import { isOnboardingDeveloperModeEnabled } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/onboarding/common/onboardingScenarioService';
+import { IOnboardingScenarioService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/onboarding/common/onboardingScenarioService.service';
+import { findOnboardingTarget, pulseOnboardingTarget } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/onboarding/browser/spotlight/onboardingTarget';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { TOTAL_SESSIONS_KEY } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/sessionsLifecycleTracker';
+import { createNewSessionTour, NEW_SESSION_TOUR_ID } from './tours/newSessionTour.js';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+
+var NewSessionTourContribution_1;
+const NEW_SESSION_BUTTON_TARGET = "sessions.newSession.button";
+let NewSessionTourContribution = class NewSessionTourContribution extends Disposable {
+    static {
+        NewSessionTourContribution_1 = this;
+    }
+    static {
+        this.ID = "sessions.contrib.onboardingTours.newSessionTour";
+    }
+    static {
+        this.MAX_SESSIONS_FOR_TOUR = 3;
+    }
+    static {
+        this.VISIBILITY_DELAY_MS = 5_000;
+    }
+    constructor(
+        sessionsManagementService,
+        onboardingScenarioService,
+        sessionsService,
+        storageService,
+        configurationService
+    ) {
+        super();
+        this.onboardingScenarioService = onboardingScenarioService;
+        this.sessionsService = sessionsService;
+        this.storageService = storageService;
+        this.configurationService = configurationService;
+        this._trigger = observableValue(this, false);
+        this._pendingCheck = this._register(( new MutableDisposable()));
+        this._pulse = this._register(( new MutableDisposable()));
+        this._register(onboardingScenarioRegistry.register(createNewSessionTour(this._trigger)));
+        this._register(
+            sessionsManagementService.onWillSendRequest(session => this._onWillSendRequest(session))
+        );
+    }
+    _onWillSendRequest(session) {
+        if (this._trigger.get() || this.onboardingScenarioService.hasBeenShown(NEW_SESSION_TOUR_ID)) {
+            this._pendingCheck.clear();
+            this._pulse.clear();
+            return;
+        }
+        const developerMode = isOnboardingDeveloperModeEnabled(this.configurationService, NEW_SESSION_TOUR_ID);
+        if (!developerMode) {
+            const sessionsStarted = this.storageService.getNumber(TOTAL_SESSIONS_KEY, StorageScope.APPLICATION, 0);
+            if (sessionsStarted > NewSessionTourContribution_1.MAX_SESSIONS_FOR_TOUR) {
+                return;
+            }
+        }
+        this._pendingCheck.value = disposableTimeout(() => {
+            const stillVisible = ( this.sessionsService.visibleSessions.get().some(s => s?.sessionId === session.sessionId));
+            if (stillVisible) {
+                this._startNewSessionButtonPulse();
+            }
+        }, NewSessionTourContribution_1.VISIBILITY_DELAY_MS);
+    }
+    _startNewSessionButtonPulse() {
+        if (this._pulse.value || this._trigger.get() || this.onboardingScenarioService.hasBeenShown(NEW_SESSION_TOUR_ID)) {
+            return;
+        }
+        const target = findOnboardingTarget(mainWindow, NEW_SESSION_BUTTON_TARGET);
+        if (!target) {
+            return;
+        }
+        const pulse = ( new DisposableStore());
+        pulse.add(pulseOnboardingTarget(target));
+        pulse.add(addDisposableListener(target, EventType.CLICK, () => {
+            if (this._trigger.get()) {
+                return;
+            }
+            this._pulse.clear();
+            this._trigger.set(true, undefined);
+        }));
+        pulse.add(addDisposableListener(target, "tap", () => {
+            if (this._trigger.get()) {
+                return;
+            }
+            this._pulse.clear();
+            this._trigger.set(true, undefined);
+        }));
+        this._pulse.value = pulse;
+    }
+};
+NewSessionTourContribution = NewSessionTourContribution_1 = ( __decorate([( __param(0, ISessionsManagementService)), ( __param(1, IOnboardingScenarioService)), ( __param(2, ISessionsService)), ( __param(3, IStorageService)), ( __param(4, IConfigurationService))], NewSessionTourContribution));
+registerWorkbenchContribution2(
+    NewSessionTourContribution.ID,
+    NewSessionTourContribution,
+    WorkbenchPhase.AfterRestored
+);

package/vscode/src/vs/sessions/contrib/onboardingTours/browser/newSessionViewTourContribution.d.ts

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/sessions/contrib/onboardingTours/browser/newSessionViewTourContribution.js

@@ -0,0 +1,123 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { StorageScope } 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 { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { onboardingScenarioRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/onboarding/common/onboardingRegistry';
+import { isOnboardingDeveloperModeEnabled } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/onboarding/common/onboardingScenarioService';
+import { IOnboardingScenarioService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/onboarding/common/onboardingScenarioService.service';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { SessionWorkspacePickerVisibleContext, SessionHarnessPickerVisibleContext, SessionIsolationPickerVisibleContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { TOTAL_SESSIONS_KEY } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/sessionsLifecycleTracker';
+import { createNewSessionViewTour, NEW_SESSION_VIEW_TOUR_ID } from './tours/newSessionViewTour.js';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+var NewSessionViewTourContribution_1;
+const NEW_SESSION_PICKER_VISIBLE_KEYS = [
+    SessionWorkspacePickerVisibleContext.key,
+    SessionHarnessPickerVisibleContext.key,
+    SessionIsolationPickerVisibleContext.key
+];
+let NewSessionViewTourContribution = class NewSessionViewTourContribution extends Disposable {
+    static {
+        NewSessionViewTourContribution_1 = this;
+    }
+    static {
+        this.ID = "sessions.contrib.onboardingTours.newSessionViewTour";
+    }
+    static {
+        this.MAX_REQUESTS_FOR_TOUR = 3;
+    }
+    static {
+        this.SETTLE_DELAY_MS = 1_000;
+    }
+    constructor(
+        onboardingScenarioService,
+        sessionsService,
+        storageService,
+        configurationService,
+        contextKeyService
+    ) {
+        super();
+        this.onboardingScenarioService = onboardingScenarioService;
+        this.sessionsService = sessionsService;
+        this.storageService = storageService;
+        this.configurationService = configurationService;
+        this.contextKeyService = contextKeyService;
+        this._trigger = observableValue(this, false);
+        this._pendingCheck = this._register(( new MutableDisposable()));
+        this._register(
+            onboardingScenarioRegistry.register(createNewSessionViewTour(this._trigger))
+        );
+        if (!this._isEligibleUser()) {
+            return;
+        }
+        this._register(autorun(reader => {
+            if (this._isTriggeredOrShown()) {
+                this._pendingCheck.clear();
+                return;
+            }
+            const activeSession = this.sessionsService.activeSession.read(reader);
+            const newSessionViewOpen = !activeSession || !activeSession.isCreated.read(reader);
+            if (!newSessionViewOpen) {
+                this._pendingCheck.clear();
+                return;
+            }
+            if (!this._pendingCheck.value) {
+                this._armReadyCheck();
+            }
+        }));
+    }
+    _isEligibleUser() {
+        if (isOnboardingDeveloperModeEnabled(this.configurationService, NEW_SESSION_VIEW_TOUR_ID)) {
+            return true;
+        }
+        const requestsSent = this.storageService.getNumber(TOTAL_SESSIONS_KEY, StorageScope.APPLICATION, 0);
+        return requestsSent <= NewSessionViewTourContribution_1.MAX_REQUESTS_FOR_TOUR;
+    }
+    _isTriggeredOrShown() {
+        return this._trigger.get() || this.onboardingScenarioService.hasBeenShown(NEW_SESSION_VIEW_TOUR_ID);
+    }
+    _armReadyCheck() {
+        const store = ( new DisposableStore());
+        const check = () => {
+            if (this._isTriggeredOrShown()) {
+                this._pendingCheck.clear();
+                return;
+            }
+            const activeSession = this.sessionsService.activeSession.get();
+            const newSessionViewOpen = !activeSession || !activeSession.isCreated.get();
+            if (!newSessionViewOpen) {
+                this._pendingCheck.clear();
+                return;
+            }
+            if (this._allPickersVisible()) {
+                this._trigger.set(true, undefined);
+                this._pendingCheck.clear();
+            }
+        };
+        const watchedKeys = ( new Set(NEW_SESSION_PICKER_VISIBLE_KEYS));
+        store.add(this.contextKeyService.onDidChangeContext(e => {
+            if (e.affectsSome(watchedKeys)) {
+                check();
+            }
+        }));
+        store.add(disposableTimeout(check, NewSessionViewTourContribution_1.SETTLE_DELAY_MS));
+        this._pendingCheck.value = store;
+    }
+    _allPickersVisible() {
+        return NEW_SESSION_PICKER_VISIBLE_KEYS.every(key => this.contextKeyService.getContextKeyValue(key) === true);
+    }
+};
+NewSessionViewTourContribution = NewSessionViewTourContribution_1 = ( __decorate([( __param(0, IOnboardingScenarioService)), ( __param(1, ISessionsService)), ( __param(2, IStorageService)), ( __param(3, IConfigurationService)), ( __param(4, IContextKeyService))], NewSessionViewTourContribution));
+registerWorkbenchContribution2(
+    NewSessionViewTourContribution.ID,
+    NewSessionViewTourContribution,
+    WorkbenchPhase.AfterRestored
+);

package/vscode/src/vs/sessions/contrib/onboardingTours/browser/newSessionViewTourTrigger.d.ts

@@ -0,0 +1,24 @@
+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 { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IOnboardingScenarioService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/onboarding/common/onboardingScenarioService.service";
+import { IChatEntitlementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service";
+import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service";
+/** Drives a new-session view tour using the V2 eligibility and readiness criteria. */
+export declare class NewSessionViewTourTrigger extends Disposable {
+    private readonly _tourId;
+    private readonly _onboardingScenarioService;
+    private readonly _sessionsService;
+    private readonly _storageService;
+    private readonly _configurationService;
+    private readonly _contextKeyService;
+    private readonly _chatEntitlementService;
+    private readonly _trigger;
+    readonly signal: IObservable<boolean>;
+    constructor(_tourId: string, _onboardingScenarioService: IOnboardingScenarioService, _sessionsService: ISessionsService, _storageService: IStorageService, _configurationService: IConfigurationService, _contextKeyService: IContextKeyService, _chatEntitlementService: IChatEntitlementService);
+    private _isEligibleUser;
+    private _isTriggeredOrShown;
+    private _isReady;
+}

package/vscode/src/vs/sessions/contrib/onboardingTours/browser/newSessionViewTourTrigger.js

@@ -0,0 +1,67 @@
+
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { StorageScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { isOnboardingDeveloperModeEnabled } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/onboarding/common/onboardingScenarioService';
+import { ChatEntitlement } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService';
+import { SessionWorkspacePickerVisibleContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { TOTAL_SESSIONS_KEY } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/sessionsLifecycleTracker';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+const MAX_REQUESTS_FOR_TOUR = 1;
+class NewSessionViewTourTrigger extends Disposable {
+    constructor(_tourId, _onboardingScenarioService, _sessionsService, _storageService, _configurationService, _contextKeyService, _chatEntitlementService) {
+        super();
+        this._tourId = _tourId;
+        this._onboardingScenarioService = _onboardingScenarioService;
+        this._sessionsService = _sessionsService;
+        this._storageService = _storageService;
+        this._configurationService = _configurationService;
+        this._contextKeyService = _contextKeyService;
+        this._chatEntitlementService = _chatEntitlementService;
+        this._trigger = observableValue(this, false);
+        this.signal = this._trigger;
+        if (!this._isEligibleUser()) {
+            return;
+        }
+        const contextChanged = observableSignalFromEvent(this, this._contextKeyService.onDidChangeContext);
+        this._register(autorun(reader => {
+            contextChanged.read(reader);
+            this._sessionsService.initialRestoreComplete.read(reader);
+            if (this._isTriggeredOrShown()) {
+                return;
+            }
+            const activeSession = this._sessionsService.activeSession.read(reader);
+            const newSessionViewOpen = !activeSession || !activeSession.isCreated.read(reader);
+            const loggedIn = this._chatEntitlementService.entitlementObs.read(reader) !== ChatEntitlement.Unknown;
+            if (!newSessionViewOpen || !loggedIn) {
+                return;
+            }
+            if (this._isReady()) {
+                this._trigger.set(true, undefined);
+            }
+        }));
+    }
+    _isEligibleUser() {
+        if (isOnboardingDeveloperModeEnabled(this._configurationService, this._tourId)) {
+            return true;
+        }
+        const requestsSent = this._storageService.getNumber(TOTAL_SESSIONS_KEY, StorageScope.APPLICATION, 0);
+        return requestsSent <= MAX_REQUESTS_FOR_TOUR;
+    }
+    _isTriggeredOrShown() {
+        return this._trigger.get() || this._onboardingScenarioService.hasBeenShown(this._tourId);
+    }
+    _isReady() {
+        const activeSession = this._sessionsService.activeSession.get();
+        const newSessionViewOpen = !activeSession || !activeSession.isCreated.get();
+        return this._sessionsService.initialRestoreComplete.get()
+            && newSessionViewOpen
+            && this._chatEntitlementService.entitlement !== ChatEntitlement.Unknown
+            && this._contextKeyService.getContextKeyValue(SessionWorkspacePickerVisibleContext.key) === true;
+    }
+}
+
+export { NewSessionViewTourTrigger };

package/vscode/src/vs/sessions/contrib/onboardingTours/browser/newSessionViewV2TourContribution.d.ts

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/sessions/contrib/onboardingTours/browser/newSessionViewV2TourContribution.js

@@ -0,0 +1,47 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { onboardingScenarioRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/onboarding/common/onboardingRegistry';
+import { IOnboardingScenarioService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/onboarding/common/onboardingScenarioService.service';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { NewSessionViewTourTrigger } from './newSessionViewTourTrigger.js';
+import { NEW_SESSION_VIEW_V2_TOUR_ID, createNewSessionViewV2Tour } from './tours/newSessionViewV2Tour.js';
+
+let NewSessionViewV2TourContribution = class NewSessionViewV2TourContribution extends Disposable {
+    static {
+        this.ID = "sessions.contrib.onboardingTours.newSessionViewV2Tour";
+    }
+    constructor(
+        onboardingScenarioService,
+        sessionsService,
+        storageService,
+        configurationService,
+        contextKeyService,
+        chatEntitlementService
+    ) {
+        super();
+        const trigger = this._register(( new NewSessionViewTourTrigger(
+            NEW_SESSION_VIEW_V2_TOUR_ID,
+            onboardingScenarioService,
+            sessionsService,
+            storageService,
+            configurationService,
+            contextKeyService,
+            chatEntitlementService
+        )));
+        this._register(
+            onboardingScenarioRegistry.register(createNewSessionViewV2Tour(trigger.signal))
+        );
+    }
+};
+NewSessionViewV2TourContribution = ( __decorate([( __param(0, IOnboardingScenarioService)), ( __param(1, ISessionsService)), ( __param(2, IStorageService)), ( __param(3, IConfigurationService)), ( __param(4, IContextKeyService)), ( __param(5, IChatEntitlementService))], NewSessionViewV2TourContribution));
+registerWorkbenchContribution2(
+    NewSessionViewV2TourContribution.ID,
+    NewSessionViewV2TourContribution,
+    WorkbenchPhase.AfterRestored
+);