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

package/vscode/src/vs/sessions/browser/sessionsSetUpService.js

@@ -0,0 +1,598 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, MutableDisposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { disposableTimeout, DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+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 { 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 { IUserDataProfileStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataProfile/common/userDataProfileStorageService.service';
+import { IUserDataProfilesService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
+import { ServiceCollection } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/serviceCollection';
+import { ChatEntitlementContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+import { isWeb } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { GitHubPaths } from '@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount';
+import { IDefaultAccountService } from '@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { IAuthenticationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service';
+import { IMarkdownRendererService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer.service';
+import { WELCOME_COMPLETE_KEY } from '../common/welcome.js';
+import { SessionsWelcomeVisibleContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { observeAllowSignedOutWhenUsable, conditionalAuthState, ConditionalAuthState, resolveSignedOutWindowGate, SignedOutWindowGate } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/sessionsAuthGate';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { append, $ } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Dialog, DialogContentsAlignment } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/dialog/dialog';
+import { createWorkbenchDialogOptions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/dialogs/dialog';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { SessionsSigningInDialog, createSessionsSignInDialogOptions } from './sessionsSignInDialog.js';
+import { SHOULD_SHOW_RETURN_TO_VSCODE_EDITOR_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionCommands';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { runOnChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/runOnChange';
+
+const AIDisabledConfig = "chat.disableAIFeatures";
+function shouldSkipSessionsWelcome(environmentService) {
+    if (environmentService.enableSmokeTestDriver) {
+        return true;
+    }
+    const envArgs = environmentService.args;
+    if (envArgs?.["skip-sessions-welcome"]) {
+        return true;
+    }
+    return typeof globalThis.location !== "undefined" && ( ( new URLSearchParams(globalThis.location.search)).has("skip-sessions-welcome"));
+}
+let SessionsSetUpWidget = class SessionsSetUpWidget extends Disposable {
+    constructor(
+        onCompleted,
+        serviceWhenSetupDone,
+        serviceMarkDone,
+        onInitialSignInDialogShown,
+        defaultAccountService,
+        productService,
+        storageService,
+        contextKeyService,
+        environmentService,
+        authenticationService,
+        logService,
+        commandService,
+        configurationService,
+        layoutService,
+        keybindingService,
+        hostService,
+        markdownRendererService,
+        instantiationService,
+        sessionsManagementService
+    ) {
+        super();
+        this.onCompleted = onCompleted;
+        this.serviceWhenSetupDone = serviceWhenSetupDone;
+        this.serviceMarkDone = serviceMarkDone;
+        this.onInitialSignInDialogShown = onInitialSignInDialogShown;
+        this.defaultAccountService = defaultAccountService;
+        this.productService = productService;
+        this.storageService = storageService;
+        this.contextKeyService = contextKeyService;
+        this.environmentService = environmentService;
+        this.authenticationService = authenticationService;
+        this.logService = logService;
+        this.commandService = commandService;
+        this.configurationService = configurationService;
+        this.layoutService = layoutService;
+        this.keybindingService = keybindingService;
+        this.hostService = hostService;
+        this.markdownRendererService = markdownRendererService;
+        this.instantiationService = instantiationService;
+        this.sessionsManagementService = sessionsManagementService;
+        this.dialogRef = this._register(( new MutableDisposable()));
+        this.watcherRef = this._register(( new MutableDisposable()));
+        this.signInSetupCancellation = this._register(( new MutableDisposable()));
+        this._initialSetupFlow = true;
+        this._proceedingSignedOut = false;
+        this._accountResolved = false;
+        this._waitingForSessionTypes = false;
+        this._allowSignedOutWhenUsable = observeAllowSignedOutWhenUsable(this.configurationService);
+        this._register(runOnChange(
+            this._allowSignedOutWhenUsable,
+            () => this._onAllowSignedOutWhenUsableChanged()
+        ));
+        this._register(
+            this.sessionsManagementService.onDidChangeSessionTypes(() => this._onSessionTypesChanged())
+        );
+        this._start();
+    }
+    _onSessionTypesChanged() {
+        const signedIn = this.defaultAccountService.currentDefaultAccount !== null;
+        if (conditionalAuthState(this._accountResolved, signedIn) === ConditionalAuthState.SignedOut) {
+            this._reevaluateSignedOut();
+        }
+    }
+    _onAllowSignedOutWhenUsableChanged() {
+        const signedIn = this.defaultAccountService.currentDefaultAccount !== null;
+        if (conditionalAuthState(this._accountResolved, signedIn) !== ConditionalAuthState.SignedOut) {
+            return;
+        }
+        this._reevaluateSignedOut();
+    }
+    _start() {
+        if (!this.productService.defaultChatAgent?.chatExtensionId) {
+            this.onCompleted();
+            return;
+        }
+        if (shouldSkipSessionsWelcome(this.environmentService)) {
+            this.onCompleted();
+            return;
+        }
+        this.defaultAccountService.getDefaultAccount().then(() => {
+            if (this._store.isDisposed) {
+                return;
+            }
+            this._accountResolved = true;
+            if (!this._initialSetupFlow && this._allowSignedOutWhenUsable.get()) {
+                this._onAllowSignedOutWhenUsableChanged();
+            }
+        });
+        if (isWeb) {
+            void this._checkWebAuth().finally(() => this._initialSetupFlow = false);
+            this._watchWebAuth();
+            return;
+        }
+        const isFirstLaunch = !this.storageService.getBoolean(WELCOME_COMPLETE_KEY, StorageScope.APPLICATION, false);
+        if (isFirstLaunch) {
+            void this._showWelcome(true).finally(() => this._initialSetupFlow = false);
+        } else {
+            void this._watchSignInState().finally(() => this._initialSetupFlow = false);
+        }
+    }
+    async _checkWebAuth() {
+        try {
+            const sessions = await this.authenticationService.getSessions("github");
+            if (sessions.length > 0) {
+                this.logService.info("[sessions welcome] GitHub session found on web, skipping welcome");
+                this.storageService.store(
+                    WELCOME_COMPLETE_KEY,
+                    true,
+                    StorageScope.APPLICATION,
+                    StorageTarget.MACHINE
+                );
+                this.onCompleted();
+                return;
+            }
+        } catch {}
+        this._showWelcome(false);
+    }
+    _watchWebAuth() {
+        this._register(this.authenticationService.onDidChangeSessions(async e => {
+            if (e.providerId !== "github" || !e.event.removed?.length) {
+                return;
+            }
+            try {
+                const remaining = await this.authenticationService.getSessions("github");
+                if (remaining.length > 0) {
+                    return;
+                }
+            } catch {}
+            this.logService.info("[sessions welcome] GitHub session removed on web, re-showing welcome");
+            this.storageService.remove(WELCOME_COMPLETE_KEY, StorageScope.APPLICATION);
+            this._showWelcome(false);
+        }));
+    }
+    async _watchSignInState() {
+        const initialAccount = await this.defaultAccountService.getDefaultAccount();
+        if (this.dialogRef.value) {
+            return;
+        }
+        if (!initialAccount) {
+            const welcomeComplete = this.storageService.getBoolean(WELCOME_COMPLETE_KEY, StorageScope.APPLICATION, false);
+            if (welcomeComplete && this._allowSignedOutWhenUsable.get()) {
+                await this._proceedWithoutGitHub();
+            } else {
+                this._showWelcome(false);
+            }
+            return;
+        }
+        await this._ensureAIFeaturesEnabled();
+        this.onCompleted();
+        this.watcherRef.value = this._watchActiveState(true);
+    }
+    _watchActiveState(signedIn) {
+        const disposables = ( new DisposableStore());
+        disposables.add(this.defaultAccountService.onDidChangeDefaultAccount(account => {
+            const nowSignedIn = account !== null;
+            if (signedIn && !nowSignedIn) {
+                this.storageService.remove(WELCOME_COMPLETE_KEY, StorageScope.APPLICATION);
+                this._reevaluateSignedOut();
+            } else if (!signedIn && nowSignedIn) {
+                this._proceedingSignedOut = false;
+            }
+            signedIn = nowSignedIn;
+        }));
+        disposables.add(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(AIDisabledConfig)) {
+                if (this.configurationService.getValue(AIDisabledConfig)) {
+                    this._showAIDisabledDialog();
+                } else {
+                    this.dialogRef.clear();
+                }
+            }
+        }));
+        return disposables;
+    }
+    _signedOutWindowGate() {
+        return resolveSignedOutWindowGate(
+            this._allowSignedOutWhenUsable.get(),
+            this.sessionsManagementService.getAllProviderSessionTypes().map((
+                {
+                    sessionType
+                }
+            ) => sessionType.authRequirement)
+        );
+    }
+    _reevaluateSignedOut() {
+        if (this._initialSetupFlow) {
+            return;
+        }
+        if (this._proceedingSignedOut && this._allowSignedOutWhenUsable.get()) {
+            return;
+        }
+        const gate = this._signedOutWindowGate();
+        if (gate === SignedOutWindowGate.Unresolved) {
+            this._waitingForSessionTypes = true;
+            return;
+        }
+        if (this._waitingForSessionTypes) {
+            this._waitingForSessionTypes = false;
+            this.dialogRef.clear();
+        }
+        if (gate === SignedOutWindowGate.ForceGitHubSignIn) {
+            if (this.dialogRef.value) {
+                return;
+            }
+            this._proceedingSignedOut = false;
+            void this._showWelcome(false);
+        } else {
+            this.signInSetupCancellation.value?.cancel();
+            this.dialogRef.clear();
+            void this._proceedWithoutGitHub();
+        }
+    }
+    async _proceedWithoutGitHub() {
+        if (this._proceedingSignedOut) {
+            return;
+        }
+        this._proceedingSignedOut = true;
+        this.logService.info(
+            "[sessions welcome] Proceeding without GitHub sign-in; signed-out operation is enabled"
+        );
+        await this._ensureAIFeaturesEnabled();
+        if (this._store.isDisposed) {
+            return;
+        }
+        this.onCompleted();
+        this.watcherRef.value = this._watchActiveState(false);
+    }
+    async _ensureAIFeaturesEnabled() {
+        if (this.configurationService.getValue(AIDisabledConfig)) {
+            this.logService.info("[sessions welcome] AI features disabled, enabling");
+            await this.configurationService.updateValue(AIDisabledConfig, false);
+        }
+    }
+    async _showAIDisabledDialog() {
+        if (this.dialogRef.value) {
+            return;
+        }
+        this.logService.info("[sessions welcome] AI features disabled, showing enable dialog");
+        const disposables = ( new DisposableStore());
+        this.dialogRef.value = disposables;
+        const welcomeVisibleKey = SessionsWelcomeVisibleContext.bindTo(this.contextKeyService);
+        welcomeVisibleKey.set(true);
+        disposables.add(toDisposable(() => welcomeVisibleKey.reset()));
+        const dialog = disposables.add(( new Dialog(this.layoutService.activeContainer, "", [( localize(3044, "Enable AI Features"))], createWorkbenchDialogOptions({
+            type: "none",
+            extraClasses: ["chat-setup-dialog", "sessions-welcome-dialog"],
+            detail: ( localize(3045, "Enable AI features to continue using Agents.")),
+            icon: Codicon.agent,
+            alignment: DialogContentsAlignment.Vertical,
+            cancelId: 1,
+            disableCloseButton: true,
+            disableCloseAction: true
+        }, this.keybindingService, this.layoutService, this.hostService))));
+        const {
+            button
+        } = await dialog.show();
+        disposables.dispose();
+        this.dialogRef.clear();
+        if (button === 0) {
+            this.logService.info("[sessions welcome] User chose to enable AI features");
+            await this.configurationService.updateValue(AIDisabledConfig, false);
+        }
+    }
+    async _showWelcome(isFirstLaunch) {
+        if (this.dialogRef.value) {
+            return;
+        }
+        if (!isFirstLaunch) {
+            const gate = this._signedOutWindowGate();
+            if (gate === SignedOutWindowGate.Unresolved) {
+                this._waitingForSessionTypes = true;
+                return;
+            }
+            if (gate === SignedOutWindowGate.Proceed) {
+                await this._proceedWithoutGitHub();
+                return;
+            }
+        }
+        this.watcherRef.clear();
+        this.dialogRef.value = ( new DisposableStore());
+        const welcomeVisibleKey = SessionsWelcomeVisibleContext.bindTo(this.contextKeyService);
+        welcomeVisibleKey.set(true);
+        this.dialogRef.value.add(toDisposable(() => welcomeVisibleKey.reset()));
+        if (isFirstLaunch) {
+            const overlay = this._showLoadingOverlay();
+            this.dialogRef.value.add(overlay);
+            const account = await this.defaultAccountService.getDefaultAccount();
+            if (this._store.isDisposed) {
+                return;
+            }
+            overlay.element.classList.add("sessions-loading-dismissed");
+            this.dialogRef.value.add(disposableTimeout(() => overlay.element.remove(), 200));
+            if (account) {
+                const setupDone = await this.serviceWhenSetupDone();
+                if (this._store.isDisposed) {
+                    return;
+                }
+                if (setupDone) {
+                    this.storageService.store(
+                        WELCOME_COMPLETE_KEY,
+                        true,
+                        StorageScope.APPLICATION,
+                        StorageTarget.MACHINE
+                    );
+                    this.dialogRef.clear();
+                    this._watchSignInState();
+                    return;
+                }
+                await this._showWelcomeDialog();
+            } else {
+                const allowContinueWithoutSignIn = this._allowSignedOutWhenUsable.get();
+                const continueWithoutSignIn = await this._showSignInDialog(allowContinueWithoutSignIn);
+                if (continueWithoutSignIn) {
+                    this.storageService.store(
+                        WELCOME_COMPLETE_KEY,
+                        true,
+                        StorageScope.APPLICATION,
+                        StorageTarget.MACHINE
+                    );
+                    this.serviceMarkDone();
+                    this.dialogRef.clear();
+                    await this._proceedWithoutGitHub();
+                    return;
+                }
+            }
+        } else {
+            await this._showSignInDialog();
+        }
+        this.dialogRef.clear();
+        await this._ensureAIFeaturesEnabled();
+        this._watchSignInState();
+    }
+    _showLoadingOverlay() {
+        const overlay = append(this.layoutService.mainContainer, $("div.sessions-loading-overlay"));
+        overlay.setAttribute("role", "status");
+        overlay.setAttribute("aria-busy", "true");
+        overlay.setAttribute("aria-label", ( localize(3046, "Loading")));
+        append(overlay, $("div.sessions-loading-icon.codicon.codicon-agent"));
+        return {
+            element: overlay,
+            dispose: () => overlay.remove()
+        };
+    }
+    async _showSignInDialog(allowContinueWithoutSignIn = false) {
+        if (this._initialSetupFlow) {
+            this.onInitialSignInDialogShown();
+        }
+        this.logService.info("[sessions welcome] Showing sign-in dialog");
+        const setupCancellation = ( new CancellationTokenSource());
+        this.signInSetupCancellation.value = setupCancellation;
+        while (true) {
+            const attemptDisposables = ( new DisposableStore());
+            const signingInDialogRef = attemptDisposables.add(( new MutableDisposable()));
+            let canceled = false;
+            let continueWithoutSignIn = false;
+            const showReturnToVSCodeEditor = !isWeb && (await this.commandService.executeCommand(SHOULD_SHOW_RETURN_TO_VSCODE_EDITOR_COMMAND_ID)) === true;
+            const onContinueWithoutSignIn = () => {
+                if (!this._allowSignedOutWhenUsable.get()) {
+                    return;
+                }
+                continueWithoutSignIn = true;
+                setupCancellation.cancel();
+            };
+            let success;
+            try {
+                success = await this.commandService.executeCommand("workbench.action.chat.triggerSetup", undefined, {
+                    ...createSessionsSignInDialogOptions(
+                        this.commandService,
+                        showReturnToVSCodeEditor,
+                        allowContinueWithoutSignIn,
+                        onContinueWithoutSignIn
+                    ),
+                    cancellationToken: setupCancellation.token,
+                    onSignInStarted: cancel => {
+                        signingInDialogRef.value = this.instantiationService.createInstance(SessionsSigningInDialog, () => {
+                            canceled = true;
+                            cancel();
+                        });
+                    }
+                });
+            } finally {
+                attemptDisposables.dispose();
+            }
+            if (continueWithoutSignIn) {
+                this.logService.info("[sessions welcome] User chose to continue without GitHub sign-in");
+                this.signInSetupCancellation.clear();
+                return true;
+            }
+            if (setupCancellation.token.isCancellationRequested) {
+                this.logService.info(
+                    "[sessions welcome] Sign-in dialog retired because another agent became usable"
+                );
+                this.signInSetupCancellation.clear();
+                return false;
+            }
+            if (canceled) {
+                this.logService.info("[sessions welcome] Sign-in canceled; returning to sign-in dialog");
+                continue;
+            }
+            if (success) {
+                this.logService.info("[sessions welcome] Sign-in completed successfully");
+                this.storageService.store(
+                    WELCOME_COMPLETE_KEY,
+                    true,
+                    StorageScope.APPLICATION,
+                    StorageTarget.MACHINE
+                );
+                this.serviceMarkDone();
+            } else {
+                this.logService.info("[sessions welcome] Sign-in was canceled or failed");
+            }
+            this.signInSetupCancellation.clear();
+            return false;
+        }
+    }
+    async _showWelcomeDialog() {
+        this.logService.info("[sessions welcome] Showing welcome dialog");
+        const disposables = ( new DisposableStore());
+        const productName = ( localize(3047, "{0} - Agents", this.productService.nameLong));
+        const dialog = disposables.add(( new Dialog(this.layoutService.activeContainer, ( localize(3048, "Welcome to {0}", productName)), [( localize(3049, "Get Started"))], createWorkbenchDialogOptions({
+            type: "none",
+            extraClasses: [
+                "chat-setup-dialog",
+                "sessions-welcome-dialog",
+                "sessions-main-welcome-dialog"
+            ],
+            detail: ( localize(
+                3050,
+                "Your AI-powered coding experience where agents explore, build, and iterate with you."
+            )),
+            icon: Codicon.agent,
+            alignment: DialogContentsAlignment.Vertical,
+            cancelId: 1,
+            disableCloseButton: true,
+            renderFooter: footer => footer.appendChild(this._createWelcomeFooter(disposables))
+        }, this.keybindingService, this.layoutService, this.hostService))));
+        await dialog.show();
+        disposables.dispose();
+        this.storageService.store(
+            WELCOME_COMPLETE_KEY,
+            true,
+            StorageScope.APPLICATION,
+            StorageTarget.MACHINE
+        );
+        this.serviceMarkDone();
+    }
+    _createWelcomeFooter(disposables) {
+        const element = $(".chat-setup-dialog-footer");
+        const defaultChatAgent = this.productService.defaultChatAgent;
+        const providerName = defaultChatAgent?.provider?.default?.name ?? "GitHub";
+        const termsUrl = defaultChatAgent?.termsStatementUrl ?? "";
+        const privacyUrl = defaultChatAgent?.privacyStatementUrl ?? "";
+        const publicCodeUrl = defaultChatAgent?.publicCodeMatchesUrl ?? "";
+        const settingsUrl = this.defaultAccountService.resolveGitHubUrl(GitHubPaths.copilotSettings);
+        const footer = ( localize(
+            3051,
+            "By continuing, you agree to {0}'s [Terms]({1}) and [Privacy Statement]({2}). {3} Copilot may show [public code]({4}) suggestions and use your data to improve the product. You can change these [settings]({5}) anytime.",
+            providerName,
+            termsUrl,
+            privacyUrl,
+            providerName,
+            publicCodeUrl,
+            settingsUrl
+        ));
+        element.appendChild($(
+            "p",
+            undefined,
+            disposables.add(this.markdownRendererService.render(( new MarkdownString(footer, {
+                isTrusted: true
+            })))).element
+        ));
+        return element;
+    }
+};
+SessionsSetUpWidget = ( __decorate([( __param(4, IDefaultAccountService)), ( __param(5, IProductService)), ( __param(6, IStorageService)), ( __param(7, IContextKeyService)), ( __param(8, IWorkbenchEnvironmentService)), ( __param(9, IAuthenticationService)), ( __param(10, ILogService)), ( __param(11, ICommandService)), ( __param(12, IConfigurationService)), ( __param(13, IWorkbenchLayoutService)), ( __param(14, IKeybindingService)), ( __param(15, IHostService)), ( __param(16, IMarkdownRendererService)), ( __param(17, IInstantiationService)), ( __param(18, ISessionsManagementService))], SessionsSetUpWidget));
+let SessionsSetUpService = class SessionsSetUpService extends Disposable {
+    get initialSignInDialogShown() {
+        return this._initialSignInDialogShown;
+    }
+    constructor(
+        instantiationService,
+        userDataProfileStorageService,
+        userDataProfilesService,
+        chatEntitlementService,
+        logService
+    ) {
+        super();
+        this.instantiationService = instantiationService;
+        this.userDataProfileStorageService = userDataProfileStorageService;
+        this.userDataProfilesService = userDataProfilesService;
+        this.chatEntitlementService = chatEntitlementService;
+        this.logService = logService;
+        this._welcomeDoneDeferred = ( new DeferredPromise());
+        this._initialSignInDialogShown = false;
+        this._initPromise = this.initialize();
+        this._register(this.instantiationService.createInstance(
+            SessionsSetUpWidget,
+            () => this._welcomeDoneDeferred.complete(),
+            () => this.whenSetupDone(),
+            () => this.markDone(),
+            () => this._initialSignInDialogShown = true
+        ));
+    }
+    async whenSetupDone() {
+        await this._initPromise;
+        return this.chatEntitlementService.sentiment.completed === true;
+    }
+    markDone() {
+        this.chatEntitlementService.markSetupCompleted();
+    }
+    whenWelcomeDone() {
+        return this._welcomeDoneDeferred.p;
+    }
+    async initialize() {
+        if (this.chatEntitlementService.sentiment.completed) {
+            return;
+        }
+        try {
+            const defaultProfile = this.userDataProfilesService.defaultProfile;
+            await this.userDataProfileStorageService.withProfileScopedStorageService(defaultProfile, async storageService => {
+                const defaultContext = this.instantiationService.createChild(( new ServiceCollection([IStorageService, storageService]))).createInstance(ChatEntitlementContext);
+                try {
+                    if (defaultContext.state.completed) {
+                        this.logService.info(
+                            "[sessions welcome] Setup already completed in default profile, marking done locally"
+                        );
+                        this.markDone();
+                    }
+                } finally {
+                    defaultContext.dispose();
+                }
+            });
+        } catch (error) {
+            this.logService.error(
+                "[sessions welcome] Failed to read setup state from default profile:",
+                error
+            );
+        }
+    }
+};
+SessionsSetUpService = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IUserDataProfileStorageService)), ( __param(2, IUserDataProfilesService)), ( __param(3, IChatEntitlementService)), ( __param(4, ILogService))], SessionsSetUpService));
+
+export { SessionsSetUpService };

package/vscode/src/vs/sessions/browser/sessionsSignInDialog.d.ts

@@ -0,0 +1,25 @@
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { IHostService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service";
+import { IWorkbenchLayoutService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service";
+export declare function createSessionsSignInDialogOptions(commandService: ICommandService, showReturnToVSCodeEditor: boolean, allowContinueWithoutSignIn?: boolean, onContinueWithoutSignIn?: () => void): {
+    forceSignInDialog: boolean;
+    dialogIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+    dialogTitle: string;
+    disableCloseButton: boolean;
+    dialogExtraClasses: string[];
+    allowContinueWithoutSignIn: boolean;
+    renderDialogFooter: ((footer: HTMLElement) => IDisposable) | undefined;
+    onDidDismissDialog: (() => void) | undefined;
+};
+export declare class SessionsSigningInDialog extends Disposable {
+    private readonly onCancel;
+    private readonly dialog;
+    private isDisposed;
+    private didCancel;
+    constructor(onCancel: () => void, keybindingService: IKeybindingService, layoutService: IWorkbenchLayoutService, hostService: IHostService);
+    private show;
+    private cancel;
+    dispose(): void;
+}