@codingame/monaco-vscode-chat-service-override 11.1.2 → 12.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatSetup.js

@@ -0,0 +1,941 @@
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
+import './media/chatViewSetup.css.js';
+import { getActiveElement, $, setVisibility } from 'vscode/vscode/vs/base/browser/dom';
+import { Button, ButtonWithDropdown } from 'vscode/vscode/vs/base/browser/ui/button/button';
+import { renderIcon } from 'vscode/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { toAction } from 'vscode/vscode/vs/base/common/actions';
+import { timeout, Barrier } from 'vscode/vscode/vs/base/common/async';
+import { CancellationTokenSource, CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { isCancellationError } from 'vscode/vscode/vs/base/common/errors';
+import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
+import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
+import { Lazy } from 'vscode/vscode/vs/base/common/lazy';
+import { Disposable, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { MarkdownRenderer } from 'vscode/vscode/vs/editor/browser/widget/markdownRenderer/browser/markdownRenderer';
+import { localize2, localize } from 'vscode/vscode/vs/nls';
+import { Action2, MenuId, registerAction2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
+import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView.service';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs.service';
+import { ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import product from 'vscode/vscode/vs/platform/product/common/product';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
+import { ProgressLocation } from 'vscode/vscode/vs/platform/progress/common/progress';
+import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/progress.service';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { asText } from 'vscode/vscode/vs/platform/request/common/request';
+import { IRequestService } from 'vscode/vscode/vs/platform/request/common/request.service';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { TelemetryLevel } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
+import { defaultButtonStyles } from 'vscode/vscode/vs/platform/theme/browser/defaultStyles';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
+import { ViewContainerLocation } from 'vscode/vscode/vs/workbench/common/views';
+import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views.service';
+import { ProgressBadge } from '@codingame/monaco-vscode-a7c9ae3c-16d2-5d17-86b2-981be7094566-common/vscode/vs/workbench/services/activity/common/activity';
+import { IActivityService } from 'vscode/vscode/vs/workbench/services/activity/common/activity.service';
+import { IAuthenticationService } from 'vscode/vscode/vs/workbench/services/authentication/common/authentication.service';
+import { IWorkbenchExtensionEnablementService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement.service';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { Parts } from '@codingame/monaco-vscode-e571cbbb-526b-5d8b-92c5-a0437d2dabb3-common/vscode/vs/workbench/services/layout/browser/layoutService';
+import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService.service';
+import { IExtensionsWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/extensions/common/extensions.service';
+import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
+import { ChatContextKeys } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { CHAT_CATEGORY } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { ensureSideBarChatViewSize, ChatViewId, EditsViewId, showEditsView, showChatView } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/browser/chat';
+import { CHAT_EDITING_SIDEBAR_PANEL_ID, CHAT_SIDEBAR_PANEL_ID } from './chatViewPane.js';
+import { ChatViewsWelcomeExtensions } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/browser/viewsWelcome/chatViewsWelcome';
+import { IChatQuotasService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatQuotasService.service';
+import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener.service';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host.service';
+import Severity from 'vscode/vscode/vs/base/common/severity';
+
+var ChatSetupContext_1;
+const defaultChat = {
+    extensionId: product.defaultChatAgent?.extensionId ?? '',
+    chatExtensionId: product.defaultChatAgent?.chatExtensionId ?? '',
+    documentationUrl: product.defaultChatAgent?.documentationUrl ?? '',
+    termsStatementUrl: product.defaultChatAgent?.termsStatementUrl ?? '',
+    privacyStatementUrl: product.defaultChatAgent?.privacyStatementUrl ?? '',
+    skusDocumentationUrl: product.defaultChatAgent?.skusDocumentationUrl ?? '',
+    publicCodeMatchesUrl: product.defaultChatAgent?.publicCodeMatchesUrl ?? '',
+    upgradePlanUrl: product.defaultChatAgent?.upgradePlanUrl ?? '',
+    providerId: product.defaultChatAgent?.providerId ?? '',
+    providerName: product.defaultChatAgent?.providerName ?? '',
+    providerScopes: product.defaultChatAgent?.providerScopes ?? [[]],
+    entitlementUrl: product.defaultChatAgent?.entitlementUrl ?? '',
+    entitlementSignupLimitedUrl: product.defaultChatAgent?.entitlementSignupLimitedUrl ?? '',
+    manageSettingsUrl: product.defaultChatAgent?.manageSettingsUrl ?? '',
+};
+var ChatEntitlement;
+(function (ChatEntitlement) {
+    ChatEntitlement[ChatEntitlement["Unknown"] = 1] = "Unknown";
+    ChatEntitlement[ChatEntitlement["Unresolved"] = 2] = "Unresolved";
+    ChatEntitlement[ChatEntitlement["Available"] = 3] = "Available";
+    ChatEntitlement[ChatEntitlement["Unavailable"] = 4] = "Unavailable";
+    ChatEntitlement[ChatEntitlement["Limited"] = 5] = "Limited";
+    ChatEntitlement[ChatEntitlement["Pro"] = 6] = "Pro";
+})(ChatEntitlement || (ChatEntitlement = {}));
+const TRIGGER_SETUP_COMMAND_ID = 'workbench.action.chat.triggerSetup';
+const TRIGGER_SETUP_COMMAND_LABEL = ( localize2(4520, "Use AI Features with Copilot for Free..."));
+const SetupWelcomeViewKeys = ( new Set(
+    [ChatContextKeys.Setup.triggered.key, ChatContextKeys.Setup.installed.key, ChatContextKeys.Setup.signedOut.key, ChatContextKeys.Setup.canSignUp.key]
+));
+const SetupWelcomeViewCondition = ( ContextKeyExpr.and(( ContextKeyExpr.has('config.chat.experimental.offerSetup')), ( ContextKeyExpr.or(( ContextKeyExpr.and(ChatContextKeys.Setup.triggered, ( ChatContextKeys.Setup.installed.negate()))), ( ContextKeyExpr.and(ChatContextKeys.Setup.canSignUp, ChatContextKeys.Setup.installed)), ( ContextKeyExpr.and(ChatContextKeys.Setup.signedOut, ChatContextKeys.Setup.installed))))));
+(class ChatSetupContribution extends Disposable {
+    static { this.ID = 'workbench.chat.setup'; }
+    constructor(productService, instantiationService) {
+        super();
+        this.productService = productService;
+        this.instantiationService = instantiationService;
+        this.context = this._register(this.instantiationService.createInstance(ChatSetupContext));
+        this.requests = this._register(this.instantiationService.createInstance(ChatSetupRequests, this.context));
+        this.controller = ( new Lazy(
+            () => this._register(this.instantiationService.createInstance(ChatSetupController, this.context, this.requests))
+        ));
+        if (!this.productService.defaultChatAgent) {
+            return;
+        }
+        this.registerChatWelcome();
+        this.registerActions();
+    }
+    registerChatWelcome() {
+        ( Registry.as(ChatViewsWelcomeExtensions.ChatViewsWelcomeRegistry)).register({
+            title: ( localize(4521, "Welcome to Copilot")),
+            when: SetupWelcomeViewCondition,
+            icon: Codicon.copilotLarge,
+            content: disposables => disposables.add(this.instantiationService.createInstance(ChatSetupWelcomeContent, this.controller.value, this.context)).element,
+        });
+    }
+    registerActions() {
+        const that = this;
+        class ChatSetupTriggerAction extends Action2 {
+            constructor() {
+                super({
+                    id: TRIGGER_SETUP_COMMAND_ID,
+                    title: TRIGGER_SETUP_COMMAND_LABEL,
+                    category: CHAT_CATEGORY,
+                    f1: true,
+                    precondition: ( ContextKeyExpr.and(( ChatContextKeys.Setup.installed.negate()), ( ContextKeyExpr.has('config.chat.experimental.offerSetup')))),
+                    menu: {
+                        id: MenuId.ChatCommandCenter,
+                        group: 'a_last',
+                        order: 1,
+                        when: ( ChatContextKeys.Setup.installed.negate())
+                    }
+                });
+            }
+            async run(accessor, startSetup) {
+                const viewsService = accessor.get(IViewsService);
+                const viewDescriptorService = accessor.get(IViewDescriptorService);
+                const configurationService = accessor.get(IConfigurationService);
+                const layoutService = accessor.get(IWorkbenchLayoutService);
+                await that.context.update({ triggered: true });
+                showCopilotView(viewsService, layoutService);
+                ensureSideBarChatViewSize(400, viewDescriptorService, layoutService);
+                if (startSetup === true) {
+                    const controller = that.controller.value;
+                    controller.setup();
+                }
+                configurationService.updateValue('chat.commandCenter.enabled', true);
+            }
+        }
+        class ChatSetupHideAction extends Action2 {
+            static { this.ID = 'workbench.action.chat.hideSetup'; }
+            static { this.TITLE = ( localize2(4522, "Hide Copilot")); }
+            constructor() {
+                super({
+                    id: ChatSetupHideAction.ID,
+                    title: ChatSetupHideAction.TITLE,
+                    f1: true,
+                    category: CHAT_CATEGORY,
+                    precondition: ( ContextKeyExpr.and(( ChatContextKeys.Setup.installed.negate()), ( ContextKeyExpr.has('config.chat.experimental.offerSetup')))),
+                    menu: {
+                        id: MenuId.ChatCommandCenter,
+                        group: 'z_hide',
+                        order: 1,
+                        when: ( ChatContextKeys.Setup.installed.negate())
+                    }
+                });
+            }
+            async run(accessor) {
+                const viewsDescriptorService = accessor.get(IViewDescriptorService);
+                const layoutService = accessor.get(IWorkbenchLayoutService);
+                const configurationService = accessor.get(IConfigurationService);
+                const dialogService = accessor.get(IDialogService);
+                const { confirmed } = await dialogService.confirm({
+                    message: ( localize(4523, "Are you sure you want to hide Copilot?")),
+                    detail: ( localize(
+                        4524,
+                        "You can restore Copilot by running the '{0}' command.",
+                        TRIGGER_SETUP_COMMAND_LABEL.value
+                    )),
+                    primaryButton: ( localize(4525, "Hide Copilot"))
+                });
+                if (!confirmed) {
+                    return;
+                }
+                await hideSetupView(viewsDescriptorService, layoutService);
+                configurationService.updateValue('chat.commandCenter.enabled', false);
+            }
+        }
+        const windowFocusListener = this._register(( new MutableDisposable()));
+        class UpgradePlanAction extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.action.chat.upgradePlan',
+                    title: ( localize2(4526, "Upgrade to Copilot Pro")),
+                    category: ( localize2(4527, 'Chat')),
+                    f1: true,
+                    precondition: ChatContextKeys.enabled,
+                    menu: {
+                        id: MenuId.ChatCommandCenter,
+                        group: 'a_first',
+                        order: 1,
+                        when: ( ContextKeyExpr.and(ChatContextKeys.Setup.installed, ( ContextKeyExpr.or(
+                            ChatContextKeys.chatQuotaExceeded,
+                            ChatContextKeys.completionsQuotaExceeded
+                        ))))
+                    }
+                });
+            }
+            async run(accessor) {
+                const openerService = accessor.get(IOpenerService);
+                const telemetryService = accessor.get(ITelemetryService);
+                const hostService = accessor.get(IHostService);
+                const commandService = accessor.get(ICommandService);
+                telemetryService.publicLog2('workbenchActionExecuted', { id: this.desc.id, from: 'chat' });
+                openerService.open(( URI.parse(defaultChat.upgradePlanUrl)));
+                const entitlement = that.context.state.entitlement;
+                if (entitlement !== ChatEntitlement.Pro) {
+                    windowFocusListener.value = hostService.onDidChangeFocus(focus => this.onWindowFocus(focus, commandService));
+                }
+            }
+            async onWindowFocus(focus, commandService) {
+                if (focus) {
+                    windowFocusListener.clear();
+                    const entitlement = await that.requests.forceResolveEntitlement(undefined);
+                    if (entitlement === ChatEntitlement.Pro) {
+                        commandService.executeCommand('github.copilot.refreshToken');
+                    }
+                }
+            }
+        }
+        async function hideSetupView(viewsDescriptorService, layoutService) {
+            const location = viewsDescriptorService.getViewLocationById(ChatViewId);
+            await that.context.update({ triggered: false });
+            if (location === ViewContainerLocation.AuxiliaryBar) {
+                const activeContainers = viewsDescriptorService.getViewContainersByLocation(location).filter(container => viewsDescriptorService.getViewContainerModel(container).activeViewDescriptors.length > 0);
+                if (activeContainers.length === 0) {
+                    layoutService.setPartHidden(true, Parts.AUXILIARYBAR_PART);
+                }
+            }
+        }
+        registerAction2(ChatSetupTriggerAction);
+        registerAction2(ChatSetupHideAction);
+        registerAction2(UpgradePlanAction);
+    }
+});
+let ChatSetupRequests = class ChatSetupRequests extends Disposable {
+    constructor(context, telemetryService, authenticationService, logService, requestService, chatQuotasService, dialogService, openerService) {
+        super();
+        this.context = context;
+        this.telemetryService = telemetryService;
+        this.authenticationService = authenticationService;
+        this.logService = logService;
+        this.requestService = requestService;
+        this.chatQuotasService = chatQuotasService;
+        this.dialogService = dialogService;
+        this.openerService = openerService;
+        this.state = { entitlement: this.context.state.entitlement };
+        this.pendingResolveCts = ( new CancellationTokenSource());
+        this.didResolveEntitlements = false;
+        this.registerListeners();
+        this.resolve();
+    }
+    registerListeners() {
+        this._register(this.authenticationService.onDidChangeDeclaredProviders(() => this.resolve()));
+        this._register(this.authenticationService.onDidChangeSessions(e => {
+            if (e.providerId === defaultChat.providerId) {
+                this.resolve();
+            }
+        }));
+        this._register(this.authenticationService.onDidRegisterAuthenticationProvider(e => {
+            if (e.id === defaultChat.providerId) {
+                this.resolve();
+            }
+        }));
+        this._register(this.authenticationService.onDidUnregisterAuthenticationProvider(e => {
+            if (e.id === defaultChat.providerId) {
+                this.resolve();
+            }
+        }));
+        this._register(this.context.onDidChange(() => {
+            if (!this.context.state.installed || this.context.state.entitlement === ChatEntitlement.Unknown) {
+                this.state = { entitlement: this.state.entitlement, quotas: undefined };
+                this.chatQuotasService.clearQuotas();
+            }
+        }));
+    }
+    async resolve() {
+        this.pendingResolveCts.dispose(true);
+        const cts = this.pendingResolveCts = ( new CancellationTokenSource());
+        const session = await this.findMatchingProviderSession(cts.token);
+        if (cts.token.isCancellationRequested) {
+            return;
+        }
+        let state = undefined;
+        if (session) {
+            if (this.state.entitlement === ChatEntitlement.Unknown) {
+                state = { entitlement: ChatEntitlement.Unresolved };
+            }
+        }
+        else {
+            this.didResolveEntitlements = false;
+            state = { entitlement: ChatEntitlement.Unknown };
+        }
+        if (state) {
+            this.update(state);
+        }
+        if (session && !this.didResolveEntitlements) {
+            await this.resolveEntitlement(session, cts.token);
+        }
+    }
+    async findMatchingProviderSession(token) {
+        const sessions = await this.authenticationService.getSessions(defaultChat.providerId);
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        for (const session of sessions) {
+            for (const scopes of defaultChat.providerScopes) {
+                if (this.scopesMatch(session.scopes, scopes)) {
+                    return session;
+                }
+            }
+        }
+        return undefined;
+    }
+    scopesMatch(scopes, expectedScopes) {
+        return scopes.length === expectedScopes.length && expectedScopes.every(scope => scopes.includes(scope));
+    }
+    async resolveEntitlement(session, token) {
+        const entitlements = await this.doResolveEntitlement(session, token);
+        if (typeof entitlements?.entitlement === 'number' && !token.isCancellationRequested) {
+            this.didResolveEntitlements = true;
+            this.update(entitlements);
+        }
+        return entitlements?.entitlement;
+    }
+    async doResolveEntitlement(session, token) {
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        const response = await this.request(defaultChat.entitlementUrl, 'GET', undefined, session, token);
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        if (!response) {
+            this.logService.trace('[chat setup] entitlement: no response');
+            return { entitlement: ChatEntitlement.Unresolved };
+        }
+        if (response.res.statusCode && response.res.statusCode !== 200) {
+            this.logService.trace(`[chat setup] entitlement: unexpected status code ${response.res.statusCode}`);
+            return { entitlement: ChatEntitlement.Unresolved };
+        }
+        let responseText = null;
+        try {
+            responseText = await asText(response);
+        }
+        catch (error) {
+        }
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        if (!responseText) {
+            this.logService.trace('[chat setup] entitlement: response has no content');
+            return { entitlement: ChatEntitlement.Unresolved };
+        }
+        let entitlementsResponse;
+        try {
+            entitlementsResponse = JSON.parse(responseText);
+            this.logService.trace(`[chat setup] entitlement: parsed result is ${JSON.stringify(entitlementsResponse)}`);
+        }
+        catch (err) {
+            this.logService.trace(`[chat setup] entitlement: error parsing response (${err})`);
+            return { entitlement: ChatEntitlement.Unresolved };
+        }
+        let entitlement;
+        if (entitlementsResponse.access_type_sku === 'free_limited_copilot') {
+            entitlement = ChatEntitlement.Limited;
+        }
+        else if (entitlementsResponse.can_signup_for_limited) {
+            entitlement = ChatEntitlement.Available;
+        }
+        else if (entitlementsResponse.chat_enabled) {
+            entitlement = ChatEntitlement.Pro;
+        }
+        else {
+            entitlement = ChatEntitlement.Unavailable;
+        }
+        const entitlements = {
+            entitlement,
+            quotas: {
+                chat: entitlementsResponse.limited_user_quotas?.chat,
+                completions: entitlementsResponse.limited_user_quotas?.completions,
+                resetDate: entitlementsResponse.limited_user_reset_date
+            }
+        };
+        this.logService.trace(`[chat setup] entitlement: resolved to ${entitlements.entitlement}, quotas: ${JSON.stringify(entitlements.quotas)}`);
+        this.telemetryService.publicLog2('chatInstallEntitlement', {
+            entitlement: entitlements.entitlement,
+            quotaChat: entitlementsResponse.limited_user_quotas?.chat,
+            quotaCompletions: entitlementsResponse.limited_user_quotas?.completions
+        });
+        return entitlements;
+    }
+    async request(url, type, body, session, token) {
+        try {
+            return await this.requestService.request({
+                type,
+                url,
+                data: type === 'POST' ? JSON.stringify(body) : undefined,
+                disableCache: true,
+                headers: {
+                    'Authorization': `Bearer ${session.accessToken}`
+                }
+            }, token);
+        }
+        catch (error) {
+            this.logService.error(`[chat setup] request: error ${error}`);
+            return undefined;
+        }
+    }
+    update(state) {
+        this.state = state;
+        this.context.update({ entitlement: this.state.entitlement });
+        if (state.quotas) {
+            this.chatQuotasService.acceptQuotas({
+                chatQuotaExceeded: typeof state.quotas.chat === 'number' ? state.quotas.chat <= 0 : false,
+                completionsQuotaExceeded: typeof state.quotas.completions === 'number' ? state.quotas.completions <= 0 : false,
+                quotaResetDate: state.quotas.resetDate ? ( new Date(state.quotas.resetDate)) : undefined
+            });
+        }
+    }
+    async forceResolveEntitlement(session) {
+        if (!session) {
+            session = await this.findMatchingProviderSession(CancellationToken.None);
+        }
+        if (!session) {
+            return undefined;
+        }
+        return this.resolveEntitlement(session, CancellationToken.None);
+    }
+    async signUpLimited(session) {
+        const body = {
+            restricted_telemetry: this.telemetryService.telemetryLevel === TelemetryLevel.NONE ? 'disabled' : 'enabled',
+            public_code_suggestions: 'enabled'
+        };
+        const response = await this.request(defaultChat.entitlementSignupLimitedUrl, 'POST', body, session, CancellationToken.None);
+        if (!response) {
+            this.onUnknownSignUpError('[chat setup] sign-up: no response');
+            return false;
+        }
+        if (response.res.statusCode && response.res.statusCode !== 200) {
+            if (response.res.statusCode === 422) {
+                try {
+                    const responseText = await asText(response);
+                    if (responseText) {
+                        const responseError = JSON.parse(responseText);
+                        if (typeof responseError.message === 'string' && responseError.message) {
+                            this.onUnprocessableSignUpError(`[chat setup] sign-up: unprocessable entity (${responseError.message})`, responseError.message);
+                            return false;
+                        }
+                    }
+                }
+                catch (error) {
+                }
+            }
+            this.onUnknownSignUpError(`[chat setup] sign-up: unexpected status code ${response.res.statusCode}`);
+            return false;
+        }
+        let responseText = null;
+        try {
+            responseText = await asText(response);
+        }
+        catch (error) {
+        }
+        if (!responseText) {
+            this.onUnknownSignUpError('[chat setup] sign-up: response has no content');
+            return false;
+        }
+        let parsedResult = undefined;
+        try {
+            parsedResult = JSON.parse(responseText);
+            this.logService.trace(`[chat setup] sign-up: response is ${responseText}`);
+        }
+        catch (err) {
+            this.onUnknownSignUpError(`[chat setup] sign-up: error parsing response (${err})`);
+        }
+        const subscribed = Boolean(parsedResult?.subscribed);
+        if (subscribed) {
+            this.logService.trace('[chat setup] sign-up: successfully subscribed');
+        }
+        else {
+            this.logService.error('[chat setup] sign-up: not subscribed');
+        }
+        if (subscribed) {
+            this.update({ entitlement: ChatEntitlement.Limited });
+        }
+        return subscribed;
+    }
+    onUnknownSignUpError(logMessage) {
+        this.dialogService.error(( localize(4528, "An error occurred while signing up for Copilot Free.")), ( localize(4529, "Please try again.")));
+        this.logService.error(logMessage);
+    }
+    onUnprocessableSignUpError(logMessage, logDetails) {
+        this.dialogService.prompt({
+            type: Severity.Error,
+            message: ( localize(4530, "An error occurred while signing up for Copilot Free.")),
+            detail: logDetails,
+            buttons: [
+                {
+                    label: ( localize(4531, "OK")),
+                    run: () => { }
+                },
+                {
+                    label: ( localize(4532, "Learn More")),
+                    run: () => this.openerService.open(( URI.parse(defaultChat.upgradePlanUrl)))
+                }
+            ],
+        });
+        this.logService.error(logMessage);
+    }
+    dispose() {
+        this.pendingResolveCts.dispose(true);
+        super.dispose();
+    }
+};
+ChatSetupRequests = ( __decorate([
+    ( __param(1, ITelemetryService)),
+    ( __param(2, IAuthenticationService)),
+    ( __param(3, ILogService)),
+    ( __param(4, IRequestService)),
+    ( __param(5, IChatQuotasService)),
+    ( __param(6, IDialogService)),
+    ( __param(7, IOpenerService))
+], ChatSetupRequests));
+var ChatSetupStep;
+(function (ChatSetupStep) {
+    ChatSetupStep[ChatSetupStep["Initial"] = 1] = "Initial";
+    ChatSetupStep[ChatSetupStep["SigningIn"] = 2] = "SigningIn";
+    ChatSetupStep[ChatSetupStep["Installing"] = 3] = "Installing";
+})(ChatSetupStep || (ChatSetupStep = {}));
+let ChatSetupController = class ChatSetupController extends Disposable {
+    get step() {
+        return this._step;
+    }
+    constructor(context, requests, telemetryService, authenticationService, viewsService, extensionsWorkbenchService, productService, logService, progressService, chatAgentService, activityService, commandService, layoutService) {
+        super();
+        this.context = context;
+        this.requests = requests;
+        this.telemetryService = telemetryService;
+        this.authenticationService = authenticationService;
+        this.viewsService = viewsService;
+        this.extensionsWorkbenchService = extensionsWorkbenchService;
+        this.productService = productService;
+        this.logService = logService;
+        this.progressService = progressService;
+        this.chatAgentService = chatAgentService;
+        this.activityService = activityService;
+        this.commandService = commandService;
+        this.layoutService = layoutService;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._step = ChatSetupStep.Initial;
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.context.onDidChange(() => this._onDidChange.fire()));
+    }
+    setStep(step) {
+        if (this._step === step) {
+            return;
+        }
+        this._step = step;
+        this._onDidChange.fire();
+    }
+    async setup() {
+        const title = ( localize(4533, "Getting Copilot ready..."));
+        const badge = this.activityService.showViewContainerActivity(isCopilotEditsViewActive(this.viewsService) ? CHAT_EDITING_SIDEBAR_PANEL_ID : CHAT_SIDEBAR_PANEL_ID, {
+            badge: ( new ProgressBadge(() => title)),
+            priority: 100
+        });
+        try {
+            await this.progressService.withProgress({
+                location: ProgressLocation.Window,
+                command: TRIGGER_SETUP_COMMAND_ID,
+                title,
+            }, () => this.doSetup());
+        }
+        finally {
+            badge.dispose();
+        }
+    }
+    async doSetup() {
+        this.context.suspend();
+        let focusChatInput = false;
+        try {
+            let session;
+            let entitlement;
+            if (this.context.state.entitlement === ChatEntitlement.Unknown) {
+                this.setStep(ChatSetupStep.SigningIn);
+                const result = await this.signIn();
+                if (!result.session) {
+                    return;
+                }
+                session = result.session;
+                entitlement = result.entitlement;
+            }
+            if (!session) {
+                session = (await this.authenticationService.getSessions(defaultChat.providerId)).at(0);
+                if (!session) {
+                    return;
+                }
+            }
+            const activeElement = getActiveElement();
+            this.setStep(ChatSetupStep.Installing);
+            await this.install(session, entitlement ?? this.context.state.entitlement);
+            const currentActiveElement = getActiveElement();
+            focusChatInput = activeElement === currentActiveElement || currentActiveElement === mainWindow.document.body;
+        }
+        finally {
+            this.setStep(ChatSetupStep.Initial);
+            this.context.resume();
+        }
+        if (focusChatInput) {
+            (await showCopilotView(this.viewsService, this.layoutService))?.focusInput();
+        }
+    }
+    async signIn() {
+        let session;
+        let entitlement;
+        try {
+            showCopilotView(this.viewsService, this.layoutService);
+            session = await this.authenticationService.createSession(defaultChat.providerId, defaultChat.providerScopes[0]);
+            entitlement = await this.requests.forceResolveEntitlement(session);
+        }
+        catch (error) {
+        }
+        if (!session) {
+            this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedNotSignedIn', signedIn: false });
+        }
+        return { session, entitlement };
+    }
+    async install(session, entitlement) {
+        const signedIn = !!session;
+        let installResult = undefined;
+        const wasInstalled = this.context.state.installed;
+        let didSignUp = false;
+        try {
+            showCopilotView(this.viewsService, this.layoutService);
+            if (entitlement !== ChatEntitlement.Limited && entitlement !== ChatEntitlement.Pro && entitlement !== ChatEntitlement.Unavailable) {
+                didSignUp = await this.requests.signUpLimited(session);
+                if (!didSignUp) {
+                    this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedSignUp', signedIn });
+                }
+            }
+            await this.extensionsWorkbenchService.install(defaultChat.extensionId, {
+                enable: true,
+                isMachineScoped: false,
+                installEverywhere: true,
+                installPreReleaseVersion: this.productService.quality !== 'stable'
+            }, isCopilotEditsViewActive(this.viewsService) ? EditsViewId : ChatViewId);
+            installResult = 'installed';
+        }
+        catch (error) {
+            this.logService.error(`[chat setup] install: error ${error}`);
+            installResult = isCancellationError(error) ? 'cancelled' : 'failedInstall';
+        }
+        finally {
+            if (wasInstalled && didSignUp) {
+                this.commandService.executeCommand('github.copilot.refreshToken');
+            }
+            if (installResult === 'installed') {
+                await Promise.race([
+                    timeout(5000),
+                    Event.toPromise(this.chatAgentService.onDidChangeAgents)
+                ]);
+            }
+        }
+        this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult, signedIn });
+    }
+};
+ChatSetupController = ( __decorate([
+    ( __param(2, ITelemetryService)),
+    ( __param(3, IAuthenticationService)),
+    ( __param(4, IViewsService)),
+    ( __param(5, IExtensionsWorkbenchService)),
+    ( __param(6, IProductService)),
+    ( __param(7, ILogService)),
+    ( __param(8, IProgressService)),
+    ( __param(9, IChatAgentService)),
+    ( __param(10, IActivityService)),
+    ( __param(11, ICommandService)),
+    ( __param(12, IWorkbenchLayoutService))
+], ChatSetupController));
+let ChatSetupWelcomeContent = class ChatSetupWelcomeContent extends Disposable {
+    constructor(controller, context, instantiationService, contextMenuService, commandService, telemetryService) {
+        super();
+        this.controller = controller;
+        this.context = context;
+        this.instantiationService = instantiationService;
+        this.contextMenuService = contextMenuService;
+        this.commandService = commandService;
+        this.telemetryService = telemetryService;
+        this.element = $('.chat-setup-view');
+        this.create();
+    }
+    create() {
+        const markdown = this._register(this.instantiationService.createInstance(MarkdownRenderer, {}));
+        {
+            const header = ( localize(
+                4534,
+                "[Copilot]({0}) is your AI pair programmer.",
+                this.context.state.installed ? 'command:github.copilot.open.walkthrough' : defaultChat.documentationUrl
+            ));
+            this.element.appendChild($('p')).appendChild(this._register(markdown.render(( new MarkdownString(header, { isTrusted: true })))).element);
+            const features = this.element.appendChild($('div.chat-features-container'));
+            this.element.appendChild(features);
+            const featureChatContainer = features.appendChild($('div.chat-feature-container'));
+            featureChatContainer.appendChild(renderIcon(Codicon.code));
+            const featureChatLabel = featureChatContainer.appendChild($('span'));
+            featureChatLabel.textContent = ( localize(4535, "Code faster with completions and Inline Chat"));
+            const featureEditsContainer = features.appendChild($('div.chat-feature-container'));
+            featureEditsContainer.appendChild(renderIcon(Codicon.editSession));
+            const featureEditsLabel = featureEditsContainer.appendChild($('span'));
+            featureEditsLabel.textContent = ( localize(4536, "Build features and resolve bugs with Copilot Edits"));
+            const featureExploreContainer = features.appendChild($('div.chat-feature-container'));
+            featureExploreContainer.appendChild(renderIcon(Codicon.commentDiscussion));
+            const featureExploreLabel = featureExploreContainer.appendChild($('span'));
+            featureExploreLabel.textContent = ( localize(4537, "Explore your codebase with chat"));
+        }
+        const free = ( localize(
+            4538,
+            "$(sparkle-filled) We now offer [Copilot for free]({0}).",
+            defaultChat.skusDocumentationUrl
+        ));
+        const freeContainer = this.element.appendChild($('p'));
+        freeContainer.appendChild(this._register(markdown.render(( new MarkdownString(free, { isTrusted: true, supportThemeIcons: true })))).element);
+        const actions = [];
+        if (this.context.state.installed) {
+            actions.push(toAction({ id: 'chatSetup.signInGh', label: ( localize(4539, "Sign in with a GitHub.com Account")), run: () => this.commandService.executeCommand('github.copilotChat.signIn') }));
+            actions.push(toAction({ id: 'chatSetup.signInGhe', label: ( localize(4540, "Sign in with a GHE.com Account")), run: () => this.commandService.executeCommand('github.copilotChat.signInGHE') }));
+        }
+        const buttonContainer = this.element.appendChild($('p'));
+        buttonContainer.classList.add('button-container');
+        const button = this._register(actions.length === 0 ? ( new Button(buttonContainer, {
+            supportIcons: true,
+            ...defaultButtonStyles
+        })) : ( new ButtonWithDropdown(buttonContainer, {
+            actions,
+            addPrimaryActionToDropdown: false,
+            contextMenuProvider: this.contextMenuService,
+            supportIcons: true,
+            ...defaultButtonStyles
+        })));
+        this._register(button.onDidClick(() => this.controller.setup()));
+        const terms = ( localize(
+            4541,
+            "By continuing, you agree to the [Terms]({0}) and [Privacy Policy]({1}).",
+            defaultChat.termsStatementUrl,
+            defaultChat.privacyStatementUrl
+        ));
+        this.element.appendChild($('p')).appendChild(this._register(markdown.render(( new MarkdownString(terms, { isTrusted: true })))).element);
+        const settings = ( localize(
+            4542,
+            "Copilot Free and Pro may show [public code]({0}) suggestions and we may use your data for product improvement. You can change these [settings]({1}) at any time.",
+            defaultChat.publicCodeMatchesUrl,
+            defaultChat.manageSettingsUrl
+        ));
+        const settingsContainer = this.element.appendChild($('p'));
+        settingsContainer.appendChild(this._register(markdown.render(( new MarkdownString(settings, { isTrusted: true })))).element);
+        this._register(Event.runAndSubscribe(this.controller.onDidChange, () => this.update(freeContainer, settingsContainer, button)));
+    }
+    update(freeContainer, settingsContainer, button) {
+        const showSettings = this.telemetryService.telemetryLevel !== TelemetryLevel.NONE;
+        let showFree;
+        let buttonLabel;
+        switch (this.context.state.entitlement) {
+            case ChatEntitlement.Unknown:
+                showFree = true;
+                buttonLabel = this.context.state.registered ? ( localize(4543, "Sign in to Use Copilot")) : ( localize(4544, "Sign in to Use Copilot for Free"));
+                break;
+            case ChatEntitlement.Unresolved:
+                showFree = true;
+                buttonLabel = this.context.state.registered ? ( localize(4545, "Use Copilot")) : ( localize(4546, "Use Copilot for Free"));
+                break;
+            case ChatEntitlement.Available:
+            case ChatEntitlement.Limited:
+                showFree = true;
+                buttonLabel = ( localize(4546, "Use Copilot for Free"));
+                break;
+            case ChatEntitlement.Pro:
+            case ChatEntitlement.Unavailable:
+                showFree = false;
+                buttonLabel = ( localize(4545, "Use Copilot"));
+                break;
+        }
+        switch (this.controller.step) {
+            case ChatSetupStep.SigningIn:
+                buttonLabel = ( localize(4547, "$(loading~spin) Signing in to {0}...", defaultChat.providerName));
+                break;
+            case ChatSetupStep.Installing:
+                buttonLabel = ( localize(4548, "$(loading~spin) Getting Copilot Ready..."));
+                break;
+        }
+        setVisibility(showFree, freeContainer);
+        setVisibility(showSettings, settingsContainer);
+        button.label = buttonLabel;
+        button.enabled = this.controller.step === ChatSetupStep.Initial;
+    }
+};
+ChatSetupWelcomeContent = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IContextMenuService)),
+    ( __param(4, ICommandService)),
+    ( __param(5, ITelemetryService))
+], ChatSetupWelcomeContent));
+let ChatSetupContext = class ChatSetupContext extends Disposable {
+    static { ChatSetupContext_1 = this; }
+    static { this.CHAT_SETUP_CONTEXT_STORAGE_KEY = 'chat.setupContext'; }
+    get state() {
+        return this.suspendedState ?? this._state;
+    }
+    constructor(contextKeyService, storageService, workspaceContextService, extensionService, extensionEnablementService, logService, extensionsWorkbenchService) {
+        super();
+        this.contextKeyService = contextKeyService;
+        this.storageService = storageService;
+        this.workspaceContextService = workspaceContextService;
+        this.extensionService = extensionService;
+        this.extensionEnablementService = extensionEnablementService;
+        this.logService = logService;
+        this.extensionsWorkbenchService = extensionsWorkbenchService;
+        this.canSignUpContextKey = ChatContextKeys.Setup.canSignUp.bindTo(this.contextKeyService);
+        this.signedOutContextKey = ChatContextKeys.Setup.signedOut.bindTo(this.contextKeyService);
+        this.limitedContextKey = ChatContextKeys.Setup.limited.bindTo(this.contextKeyService);
+        this.triggeredContext = ChatContextKeys.Setup.triggered.bindTo(this.contextKeyService);
+        this.installedContext = ChatContextKeys.Setup.installed.bindTo(this.contextKeyService);
+        this._state = this.storageService.getObject(ChatSetupContext_1.CHAT_SETUP_CONTEXT_STORAGE_KEY, StorageScope.PROFILE) ?? { entitlement: ChatEntitlement.Unknown };
+        this.suspendedState = undefined;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this.updateBarrier = undefined;
+        this.checkExtensionInstallation();
+        this.updateContextSync();
+    }
+    async checkExtensionInstallation() {
+        this._register(this.extensionService.onDidChangeExtensions(result => {
+            for (const extension of result.removed) {
+                if (ExtensionIdentifier.equals(defaultChat.extensionId, extension.identifier)) {
+                    this.update({ installed: false });
+                    break;
+                }
+            }
+            for (const extension of result.added) {
+                if (ExtensionIdentifier.equals(defaultChat.extensionId, extension.identifier)) {
+                    this.update({ installed: true });
+                    break;
+                }
+            }
+        }));
+        const extensions = await this.extensionsWorkbenchService.queryLocal();
+        const defaultChatExtension = extensions.find(value => ExtensionIdentifier.equals(value.identifier.id, defaultChat.extensionId));
+        this.update({ installed: !!defaultChatExtension?.local && this.extensionEnablementService.isEnabled(defaultChatExtension.local) });
+    }
+    update(context) {
+        this.logService.trace(`[chat setup] update(): ${JSON.stringify(context)}`);
+        if (typeof context.installed === 'boolean') {
+            this._state.installed = context.installed;
+            if (context.installed) {
+                context.triggered = true;
+            }
+        }
+        if (typeof context.triggered === 'boolean') {
+            this._state.triggered = context.triggered;
+        }
+        if (typeof context.entitlement === 'number') {
+            this._state.entitlement = context.entitlement;
+            if (this._state.entitlement === ChatEntitlement.Limited || this._state.entitlement === ChatEntitlement.Pro) {
+                this._state.registered = true;
+            }
+            else if (this._state.entitlement === ChatEntitlement.Available) {
+                this._state.registered = false;
+            }
+        }
+        this.storageService.store(ChatSetupContext_1.CHAT_SETUP_CONTEXT_STORAGE_KEY, this._state, StorageScope.PROFILE, StorageTarget.MACHINE);
+        return this.updateContext();
+    }
+    async updateContext() {
+        await this.updateBarrier?.wait();
+        this.updateContextSync();
+    }
+    updateContextSync() {
+        this.logService.trace(`[chat setup] updateContext(): ${JSON.stringify(this._state)}`);
+        if (this._state.triggered && !this._state.installed) {
+            this.storageService.remove('chat.welcomeMessageContent.panel', StorageScope.APPLICATION);
+            this.storageService.remove('interactive.sessions', this.workspaceContextService.getWorkspace().folders.length ? StorageScope.WORKSPACE : StorageScope.APPLICATION);
+        }
+        this.signedOutContextKey.set(this._state.entitlement === ChatEntitlement.Unknown);
+        this.canSignUpContextKey.set(this._state.entitlement === ChatEntitlement.Available);
+        this.limitedContextKey.set(this._state.entitlement === ChatEntitlement.Limited);
+        this.triggeredContext.set(!!this._state.triggered);
+        this.installedContext.set(!!this._state.installed);
+        this._onDidChange.fire();
+    }
+    suspend() {
+        this.suspendedState = { ...this._state };
+        this.updateBarrier = ( new Barrier());
+    }
+    resume() {
+        this.suspendedState = undefined;
+        this.updateBarrier?.open();
+        this.updateBarrier = undefined;
+    }
+};
+ChatSetupContext = ChatSetupContext_1 = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, IStorageService)),
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, IExtensionService)),
+    ( __param(4, IWorkbenchExtensionEnablementService)),
+    ( __param(5, ILogService)),
+    ( __param(6, IExtensionsWorkbenchService))
+], ChatSetupContext));
+function isCopilotEditsViewActive(viewsService) {
+    return viewsService.getFocusedView()?.id === EditsViewId;
+}
+function showCopilotView(viewsService, layoutService) {
+    if (layoutService.activeContainer !== layoutService.mainContainer) {
+        layoutService.mainContainer.focus();
+    }
+    if (isCopilotEditsViewActive(viewsService)) {
+        return showEditsView(viewsService);
+    }
+    else {
+        return showChatView(viewsService);
+    }
+}
+
+export { SetupWelcomeViewCondition, SetupWelcomeViewKeys };