@codingame/monaco-vscode-walkthrough-service-override 25.1.2 → 26.0.1

package/vscode/src/vs/workbench/contrib/welcomeAgentSessions/browser/agentSessionsWelcome.js

@@ -0,0 +1,748 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as agentSessionsWelcome from './media/agentSessionsWelcome.css';
+import { $, clearNode, append, getWindow, scheduleAtNextAnimationFrame, addDisposableListener } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { renderIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { DomScrollableElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/scrollbar/scrollableElement';
+import { Toggle } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/toggle/toggle';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { ScrollbarVisibility } from '@codingame/monaco-vscode-api/vscode/vs/base/common/scrollable';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+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 { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ServiceCollection } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/serviceCollection';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.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 { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/baseColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/chartsColors';
+import { editorBackground } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/editorColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/inputColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/listColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/menuColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/minimapColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/miscColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
+import { getListStyles, getToggleStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { EditorPane } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editorPane';
+import { SIDE_BAR_FOREGROUND } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/theme';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { ChatAgentLocation, ChatModeKind, ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { ChatWidget } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/chatWidget';
+import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
+import { AgentSessionProviders } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
+import './agentSessionsWelcomeInput.js';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { ChatViewPaneTarget, ChatViewId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { getResourceForNewChatSession, ChatSessionPosition } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/chatSessions/chatSessions.contribution';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+import { AgentSessionsControl } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsControl';
+import { HoverPosition } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverWidget';
+import { IWalkthroughsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/welcomeGettingStarted/browser/gettingStartedService.service';
+import { GettingStartedInput } from '../../welcomeGettingStarted/browser/gettingStartedInput.js';
+import { IMarkdownRendererService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer.service';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { WorkbenchState } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { isRecentWorkspace, isRecentFolder } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspaces/common/workspaces';
+import { IWorkspacesService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspaces/common/workspaces.service';
+import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service';
+import { IWorkspaceTrustManagementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
+import { ViewContainerLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views';
+import { IViewDescriptorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service';
+import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+
+var AgentSessionsWelcomePage_1;
+registerCss(agentSessionsWelcome);
+const configurationKey = "workbench.startupEditor";
+const MAX_SESSIONS = 6;
+const MAX_REPO_PICKS = 10;
+const MAX_WALKTHROUGHS = 10;
+let AgentSessionsWelcomePage = class AgentSessionsWelcomePage extends EditorPane {
+    static {
+        AgentSessionsWelcomePage_1 = this;
+    }
+    static {
+        this.ID = "agentSessionsWelcomePage";
+    }
+    static {
+        this.COMMAND_ID = "workbench.action.openAgentSessionsWelcome";
+    }
+    constructor(
+        group,
+        telemetryService,
+        themeService,
+        storageService,
+        instantiationService,
+        contextKeyService,
+        layoutService,
+        commandService,
+        editorService,
+        agentSessionsService,
+        configurationService,
+        productService,
+        walkthroughsService,
+        chatService,
+        chatEntitlementService,
+        markdownRendererService,
+        workspaceContextService,
+        workspacesService,
+        hostService,
+        workspaceTrustManagementService,
+        viewDescriptorService,
+        chatWidgetService,
+        logService
+    ) {
+        super(
+            AgentSessionsWelcomePage_1.ID,
+            group,
+            telemetryService,
+            themeService,
+            storageService
+        );
+        this.storageService = storageService;
+        this.instantiationService = instantiationService;
+        this.layoutService = layoutService;
+        this.commandService = commandService;
+        this.editorService = editorService;
+        this.agentSessionsService = agentSessionsService;
+        this.configurationService = configurationService;
+        this.productService = productService;
+        this.walkthroughsService = walkthroughsService;
+        this.chatService = chatService;
+        this.chatEntitlementService = chatEntitlementService;
+        this.markdownRendererService = markdownRendererService;
+        this.workspaceContextService = workspaceContextService;
+        this.workspacesService = workspacesService;
+        this.hostService = hostService;
+        this.workspaceTrustManagementService = workspaceTrustManagementService;
+        this.viewDescriptorService = viewDescriptorService;
+        this.chatWidgetService = chatWidgetService;
+        this.logService = logService;
+        this.sessionsControlDisposables = this._register(( new DisposableStore()));
+        this.contentDisposables = this._register(( new DisposableStore()));
+        this.walkthroughs = [];
+        this._selectedSessionProvider = AgentSessionProviders.Local;
+        this._recentWorkspaces = [];
+        this._isEmptyWorkspace = false;
+        this._workspaceKind = "empty";
+        this._openedAt = 0;
+        this._closedBy = "unknown";
+        this.container = $(".agentSessionsWelcome", {
+            role: "document",
+            tabindex: 0,
+            "aria-label": ( localize(13528, "Overview of agent sessions and how to get started."))
+        });
+        this.contextService = this._register(contextKeyService.createScoped(this.container));
+        ChatContextKeys.inAgentSessionsWelcome.bindTo(this.contextService).set(true);
+        this._register(this.chatEntitlementService.onDidChangeSentiment(() => {
+            const input = this.input || this._storedInput;
+            if (this.chatEntitlementService.sentiment.hidden && input) {
+                this._closedBy = "chatHidden";
+                this.group.closeEditor(input);
+            }
+        }));
+    }
+    createEditor(parent) {
+        parent.appendChild(this.container);
+        this.contentContainer = $(".agentSessionsWelcome-content");
+        this.scrollableElement = this._register(( new DomScrollableElement(this.contentContainer, {
+            className: "agentSessionsWelcome-scrollable",
+            vertical: ScrollbarVisibility.Auto
+        })));
+        this.container.appendChild(this.scrollableElement.getDomNode());
+    }
+    async setInput(input, options, context, token) {
+        this._storedInput = input;
+        await super.setInput(input, options, context, token);
+        this._workspaceKind = input.workspaceKind ?? "empty";
+        await this.buildContent();
+    }
+    async buildContent() {
+        this.contentDisposables.clear();
+        this.sessionsControlDisposables.clear();
+        this.sessionsControl = undefined;
+        clearNode(this.contentContainer);
+        this._isEmptyWorkspace = this.workspaceContextService.getWorkbenchState() === WorkbenchState.EMPTY;
+        if (this._isEmptyWorkspace) {
+            const recentlyOpened = await this.workspacesService.getRecentlyOpened();
+            const trustInfoPromises = ( recentlyOpened.workspaces.map(async ws => {
+                const uri = isRecentWorkspace(ws) ? ws.workspace.configPath : ws.folderUri;
+                const trustInfo = await this.workspaceTrustManagementService.getUriTrustInfo(uri);
+                return {
+                    workspace: ws,
+                    trusted: trustInfo.trusted
+                };
+            }));
+            const trustInfoResults = await Promise.all(trustInfoPromises);
+            const filteredWorkspaces = ( trustInfoResults.filter(result => result.trusted).map(result => result.workspace));
+            this._recentWorkspaces = filteredWorkspaces.slice(0, MAX_REPO_PICKS);
+        }
+        this.walkthroughs = this.walkthroughsService.getWalkthroughs();
+        const header = append(this.contentContainer, $(".agentSessionsWelcome-header"));
+        append(header, $("h1.product-name", {}, this.productService.nameLong));
+        const startEntries = append(header, $(".agentSessionsWelcome-startEntries"));
+        this.buildStartEntries(startEntries);
+        const chatSection = append(this.contentContainer, $(".agentSessionsWelcome-chatSection"));
+        this.buildChatWidget(chatSection);
+        const sessionsSection = append(this.contentContainer, $(".agentSessionsWelcome-sessionsSection"));
+        this.buildSessionsOrPrompts(sessionsSection);
+        const footer = append(this.contentContainer, $(".agentSessionsWelcome-footer"));
+        this.buildFooter(footer);
+        let originalSessions = this.agentSessionsService.model.sessions.length > 0;
+        this.contentDisposables.add(this.agentSessionsService.model.onDidChangeSessions(() => {
+            const hasSessions = this.agentSessionsService.model.sessions.length > 0;
+            if (hasSessions !== originalSessions) {
+                originalSessions = hasSessions;
+                clearNode(sessionsSection);
+                this.buildSessionsOrPrompts(sessionsSection);
+            }
+            this.layoutSessionsControl();
+        }));
+        this.scrollableElement?.scanDomNode();
+    }
+    buildStartEntries(container) {
+        const entries = [{
+            icon: Codicon.folderOpened,
+            label: ( localize(13529, "Open Recent...")),
+            command: "workbench.action.openRecent"
+        }, {
+            icon: Codicon.newFile,
+            label: ( localize(13530, "New file...")),
+            command: "workbench.action.files.newUntitledFile"
+        }, {
+            icon: Codicon.repoClone,
+            label: ( localize(13531, "Clone Git Repository...")),
+            command: "git.clone"
+        }];
+        for (const entry of entries) {
+            const button = append(container, $("button.agentSessionsWelcome-startEntry"));
+            button.appendChild(renderIcon(entry.icon));
+            button.appendChild(document.createTextNode(entry.label));
+            button.onclick = () => {
+                this.telemetryService.publicLog2("gettingStarted.ActionExecuted", {
+                    welcomeKind: "agentSessionsWelcomePage",
+                    action: "executeCommand",
+                    actionId: entry.command
+                });
+                this.commandService.executeCommand(entry.command);
+            };
+        }
+    }
+    buildChatWidget(container) {
+        const chatWidgetContainer = append(container, $(".agentSessionsWelcome-chatWidget"));
+        const editorOverflowWidgetsDomNode = this.layoutService.getContainer(getWindow(chatWidgetContainer)).appendChild($(".chat-editor-overflow.monaco-editor"));
+        this.contentDisposables.add(toDisposable(() => editorOverflowWidgetsDomNode.remove()));
+        const scopedContextKeyService = this.contentDisposables.add(this.contextService.createScoped(chatWidgetContainer));
+        const scopedInstantiationService = this.contentDisposables.add(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, scopedContextKeyService]))));
+        const onDidChangeActiveSessionProvider = this.contentDisposables.add(( new Emitter()));
+        const recreateSessionForProvider = async provider => {
+            if (this.chatWidget && this.chatModelRef) {
+                this.chatWidget.setModel(undefined);
+                this.chatModelRef.dispose();
+                const newResource = getResourceForNewChatSession({
+                    type: provider,
+                    position: ChatSessionPosition.Sidebar});
+                const ref = await this.chatService.loadSessionForResource(newResource, ChatAgentLocation.Chat, CancellationToken.None);
+                this.chatModelRef = ref ?? this.chatService.startSession(ChatAgentLocation.Chat);
+                this.contentDisposables.add(this.chatModelRef);
+                if (this.chatModelRef.object) {
+                    this.chatWidget.setModel(this.chatModelRef.object);
+                }
+            }
+        };
+        const sessionTypePickerDelegate = {
+            getActiveSessionProvider: () => this._selectedSessionProvider,
+            setActiveSessionProvider: provider => {
+                this._selectedSessionProvider = provider;
+                onDidChangeActiveSessionProvider.fire(provider);
+                try {
+                    recreateSessionForProvider(provider);
+                } catch {}
+            },
+            onDidChangeActiveSessionProvider: onDidChangeActiveSessionProvider.event
+        };
+        const onDidChangeSelectedWorkspace = this.contentDisposables.add(( new Emitter()));
+        const onDidChangeWorkspaces = this.contentDisposables.add(( new Emitter()));
+        const workspacePickerDelegate = this._isEmptyWorkspace ? {
+            getWorkspaces: () => ( this._recentWorkspaces.map(w => ({
+                uri: this.getWorkspaceUri(w),
+                label: this.getWorkspaceLabel(w),
+                isFolder: isRecentFolder(w)
+            }))),
+            getSelectedWorkspace: () => this._selectedWorkspace,
+            setSelectedWorkspace: workspace => {
+                this._selectedWorkspace = workspace;
+                onDidChangeSelectedWorkspace.fire(workspace);
+            },
+            onDidChangeSelectedWorkspace: onDidChangeSelectedWorkspace.event,
+            onDidChangeWorkspaces: onDidChangeWorkspaces.event,
+            openFolderCommand: "workbench.action.files.openFolder"
+        } : undefined;
+        this.chatWidget = this.contentDisposables.add(scopedInstantiationService.createInstance(
+            ChatWidget,
+            ChatAgentLocation.Chat,
+            {},
+            {
+                autoScroll: mode => mode !== ChatModeKind.Ask,
+                renderFollowups: false,
+                supportsFileReferences: true,
+                renderInputOnTop: true,
+                rendererOptions: {
+                    renderTextEditsAsSummary: () => true,
+                    referencesExpandedWhenEmptyResponse: false,
+                    progressMessageAtBottomOfResponse: mode => mode !== ChatModeKind.Ask
+                },
+                editorOverflowWidgetsDomNode,
+                enableImplicitContext: true,
+                enableWorkingSet: "explicit",
+                supportsChangingModes: true,
+                sessionTypePickerDelegate,
+                workspacePickerDelegate,
+                submitHandler: this._isEmptyWorkspace ? (query, mode) => this.handleWorkspaceSubmission(query, mode) : undefined
+            },
+            {
+                listForeground: SIDE_BAR_FOREGROUND,
+                listBackground: editorBackground,
+                overlayBackground: editorBackground,
+                inputEditorBackground: editorBackground,
+                resultEditorBackground: editorBackground
+            }
+        ));
+        this.chatWidget.render(chatWidgetContainer);
+        this.chatWidget.setVisible(true);
+        this.contentDisposables.add(scheduleAtNextAnimationFrame(getWindow(chatWidgetContainer), () => {
+            this.layoutChatWidget();
+        }));
+        this.chatModelRef = this.chatService.startSession(ChatAgentLocation.Chat);
+        this.contentDisposables.add(this.chatModelRef);
+        if (this.chatModelRef.object) {
+            this.chatWidget.setModel(this.chatModelRef.object);
+        }
+        this.contentDisposables.add(addDisposableListener(chatWidgetContainer, "mousedown", () => {
+            this.chatWidget?.focusInput();
+        }));
+        this.contentDisposables.add(this.chatService.onDidSubmitRequest((
+            {
+                chatSessionResource
+            }
+        ) => {
+            if (this.chatModelRef?.object?.sessionResource.toString() === ( chatSessionResource.toString())) {
+                const mode = this.chatWidget?.input.currentModeObs.get().name.get() || "unknown";
+                this.telemetryService.publicLog2("agentSessionsWelcome.chatSubmitted", {
+                    mode,
+                    provider: this._selectedSessionProvider,
+                    workspaceKind: this._workspaceKind,
+                    selectedRecentWorkspace: this._selectedWorkspace !== undefined
+                });
+                this._closedBy = "chatSubmission";
+                this.openSessionInChat(chatSessionResource);
+            }
+        }));
+        this.applyPrefillData();
+    }
+    getWorkspaceLabel(workspace) {
+        if (isRecentFolder(workspace)) {
+            return workspace.label || basename(workspace.folderUri);
+        } else if (isRecentWorkspace(workspace)) {
+            return workspace.label || basename(workspace.workspace.configPath);
+        }
+        return "";
+    }
+    getWorkspaceUri(workspace) {
+        if (isRecentFolder(workspace)) {
+            return workspace.folderUri;
+        } else if (isRecentWorkspace(workspace)) {
+            return workspace.workspace.configPath;
+        }
+        throw ( new Error("Invalid workspace type"));
+    }
+    async handleWorkspaceSubmission(query, mode) {
+        if (!this._selectedWorkspace) {
+            return false;
+        }
+        if (!query.trim()) {
+            return false;
+        }
+        const prefillData = {
+            query,
+            mode,
+            timestamp: Date.now()
+        };
+        this.storageService.store(
+            "chat.welcomeViewPrefill",
+            JSON.stringify(prefillData),
+            StorageScope.APPLICATION,
+            StorageTarget.MACHINE
+        );
+        const workspace = this._recentWorkspaces.find(w => ( this.getWorkspaceUri(w).toString()) === this._selectedWorkspace?.uri.toString());
+        if (workspace) {
+            try {
+                if (isRecentFolder(workspace)) {
+                    await this.hostService.openWindow([{
+                        folderUri: workspace.folderUri
+                    }]);
+                } else if (isRecentWorkspace(workspace)) {
+                    await this.hostService.openWindow([{
+                        workspaceUri: workspace.workspace.configPath
+                    }]);
+                }
+                return true;
+            } catch (e) {}
+        }
+        this.storageService.remove("chat.welcomeViewPrefill", StorageScope.APPLICATION);
+        return false;
+    }
+    applyPrefillData() {
+        const prefillData = this.storageService.get("chat.welcomeViewPrefill", StorageScope.APPLICATION);
+        if (prefillData) {
+            this.storageService.remove("chat.welcomeViewPrefill", StorageScope.APPLICATION);
+            try {
+                const {
+                    query,
+                    mode,
+                    timestamp
+                } = JSON.parse(prefillData);
+                if (timestamp && Date.now() - timestamp > 60 * 1000) {
+                    return;
+                }
+                if (query && this.chatWidget) {
+                    this.chatWidget.setInput(query);
+                }
+                if (mode !== undefined && this.chatWidget) {
+                    this.chatWidget.input.setChatMode(mode, false);
+                }
+                this.chatWidget?.focusInput();
+            } catch {}
+        }
+    }
+    buildSessionsOrPrompts(container) {
+        this.sessionsControlDisposables.clear();
+        this.sessionsControl = undefined;
+        this.sessionsLoadingContainer = undefined;
+        const sessions = this.agentSessionsService.model.sessions.filter(s => !s.isArchived());
+        if (sessions.length > 0) {
+            this.buildSessionsGrid(container, sessions);
+        } else {
+            this.buildWalkthroughs(container);
+        }
+    }
+    buildLoadingSkeleton(container) {
+        const loadingContainer = append(container, $(".agentSessionsWelcome-sessionsLoading", {
+            "role": "status",
+            "aria-busy": "true",
+            "aria-label": ( localize(13532, "Loading sessions..."))
+        }));
+        for (let i = 0; i < MAX_SESSIONS; i++) {
+            const skeleton = append(loadingContainer, $(".agentSessionsWelcome-sessionSkeleton", {
+                "aria-hidden": "true"
+            }));
+            append(skeleton, $(".agentSessionsWelcome-sessionSkeleton-icon"));
+            const content = append(skeleton, $(".agentSessionsWelcome-sessionSkeleton-content"));
+            append(content, $(".agentSessionsWelcome-sessionSkeleton-title"));
+            append(content, $(".agentSessionsWelcome-sessionSkeleton-description"));
+        }
+        return loadingContainer;
+    }
+    hideLoadingSkeleton() {
+        if (this.sessionsLoadingContainer) {
+            this.sessionsLoadingContainer.style.display = "none";
+        }
+        if (this.sessionsControlContainer) {
+            this.sessionsControlContainer.style.display = "";
+            this.layoutSessionsControl();
+        }
+    }
+    buildSessionsGrid(container, _sessions) {
+        this.sessionsLoadingContainer = this.buildLoadingSkeleton(container);
+        this.sessionsControlContainer = append(container, $(".agentSessionsWelcome-sessionsGrid"));
+        this.sessionsControlContainer.style.display = "none";
+        const onDidChangeEmitter = this.sessionsControlDisposables.add(( new Emitter()));
+        const filter = {
+            onDidChange: onDidChangeEmitter.event,
+            limitResults: () => MAX_SESSIONS,
+            exclude: session => session.isArchived(),
+            getExcludes: () => ({
+                providers: [],
+                states: [],
+                archived: true,
+                read: false
+            })
+        };
+        const options = {
+            overrideStyles: getListStyles({
+                listBackground: editorBackground
+            }),
+            filter,
+            getHoverPosition: () => HoverPosition.BELOW,
+            trackActiveEditorSession: () => false,
+            source: "welcomeView",
+            notifySessionOpened: () => {
+                this._closedBy = "sessionClicked";
+                const isProjectionEnabled = this.configurationService.getValue(ChatConfiguration.AgentSessionProjectionEnabled);
+                if (!isProjectionEnabled) {
+                    this.revealMaximizedChat();
+                }
+            }
+        };
+        this.sessionsControl = this.sessionsControlDisposables.add(
+            this.instantiationService.createInstance(AgentSessionsControl, this.sessionsControlContainer, options)
+        );
+        this.sessionsControlDisposables.add(this.agentSessionsService.model.onDidResolve(() => {
+            this.hideLoadingSkeleton();
+        }));
+        if (this.agentSessionsService.model.resolved) {
+            this.hideLoadingSkeleton();
+        }
+        this.sessionsControlDisposables.add(
+            scheduleAtNextAnimationFrame(getWindow(this.sessionsControlContainer), () => {
+                this.layoutSessionsControl();
+            })
+        );
+        const openButton = append(container, $("button.agentSessionsWelcome-openSessionsButton"));
+        openButton.textContent = ( localize(13533, "View All Sessions"));
+        openButton.onclick = () => {
+            this._closedBy = "viewAllSessions";
+            this.revealMaximizedChat();
+        };
+    }
+    buildWalkthroughs(container) {
+        const activeWalkthroughs = this.walkthroughs.filter(w => !w.when || this.contextService.contextMatchesRules(w.when)).slice(0, MAX_WALKTHROUGHS);
+        if (activeWalkthroughs.length === 0) {
+            return;
+        }
+        let currentIndex = 0;
+        const card = append(container, $(".agentSessionsWelcome-walkthroughCard"));
+        const iconContainer = append(card, $(".agentSessionsWelcome-walkthroughCard-icon"));
+        const content = append(card, $(".agentSessionsWelcome-walkthroughCard-content"));
+        const title = append(content, $(".agentSessionsWelcome-walkthroughCard-title"));
+        const desc = append(content, $(".agentSessionsWelcome-walkthroughCard-description"));
+        const navContainer = append(card, $(".agentSessionsWelcome-walkthroughCard-nav"));
+        const prevButton = append(navContainer, $("button.nav-button"));
+        prevButton.appendChild(renderIcon(Codicon.chevronLeft));
+        prevButton.title = ( localize(13534, "Previous"));
+        const nextButton = append(navContainer, $("button.nav-button"));
+        nextButton.appendChild(renderIcon(Codicon.chevronRight));
+        nextButton.title = ( localize(13535, "Next"));
+        const updateContent = () => {
+            const walkthrough = activeWalkthroughs[currentIndex];
+            clearNode(iconContainer);
+            if (walkthrough.icon.type === "icon") {
+                iconContainer.appendChild(renderIcon(walkthrough.icon.icon));
+            }
+            title.textContent = walkthrough.title;
+            desc.textContent = walkthrough.description || "";
+            prevButton.disabled = currentIndex === 0;
+            nextButton.disabled = currentIndex === activeWalkthroughs.length - 1;
+        };
+        updateContent();
+        card.onclick = () => {
+            const walkthrough = activeWalkthroughs[currentIndex];
+            this.telemetryService.publicLog2("gettingStarted.ActionExecuted", {
+                welcomeKind: "agentSessionsWelcomePage",
+                action: "openWalkthrough",
+                actionId: walkthrough.id
+            });
+            const options = {
+                selectedCategory: walkthrough.id,
+                returnToCommand: AgentSessionsWelcomePage_1.COMMAND_ID
+            };
+            this.editorService.openEditor({
+                resource: GettingStartedInput.RESOURCE,
+                options
+            });
+        };
+        prevButton.onclick = e => {
+            e.stopPropagation();
+            if (currentIndex > 0) {
+                currentIndex--;
+                updateContent();
+            }
+        };
+        nextButton.onclick = e => {
+            e.stopPropagation();
+            if (currentIndex < activeWalkthroughs.length - 1) {
+                currentIndex++;
+                updateContent();
+            }
+        };
+    }
+    static {
+        this.PRIVACY_NOTICE_DISMISSED_KEY = "agentSessionsWelcome.privacyNoticeDismissed";
+    }
+    buildPrivacyNotice(container) {
+        if (!this.chatEntitlementService.anonymous) {
+            return;
+        }
+        if (this.storageService.getBoolean(
+            AgentSessionsWelcomePage_1.PRIVACY_NOTICE_DISMISSED_KEY,
+            StorageScope.APPLICATION,
+            false
+        )) {
+            return;
+        }
+        const providers = this.productService.defaultChatAgent?.provider;
+        if (!providers || !providers.default || !this.productService.defaultChatAgent?.termsStatementUrl || !this.productService.defaultChatAgent?.privacyStatementUrl) {
+            return;
+        }
+        const tosCard = append(
+            container,
+            $(".agentSessionsWelcome-walkthroughCard.agentSessionsWelcome-tosCard")
+        );
+        const dismissNotice = () => {
+            this.storageService.store(
+                AgentSessionsWelcomePage_1.PRIVACY_NOTICE_DISMISSED_KEY,
+                true,
+                StorageScope.APPLICATION,
+                StorageTarget.USER
+            );
+            tosCard.remove();
+        };
+        this.contentDisposables.add(this.chatService.onDidSubmitRequest(() => dismissNotice()));
+        const iconContainer = append(tosCard, $(".agentSessionsWelcome-walkthroughCard-icon"));
+        iconContainer.appendChild(renderIcon(Codicon.chatSparkle));
+        const content = append(tosCard, $(".agentSessionsWelcome-walkthroughCard-content"));
+        const title = append(content, $(".agentSessionsWelcome-walkthroughCard-title"));
+        title.textContent = ( localize(13536, "Your GitHub Copilot trial is active"));
+        const desc = append(content, $(".agentSessionsWelcome-walkthroughCard-description"));
+        const descriptionMarkdown = ( new MarkdownString(( localize(
+            13537,
+            "By continuing, you agree to {0}'s [Terms]({1}) and [Privacy Statement]({2}).",
+            providers.default.name,
+            this.productService.defaultChatAgent.termsStatementUrl,
+            this.productService.defaultChatAgent.privacyStatementUrl
+        )), {
+            isTrusted: true
+        }));
+        const renderedMarkdown = this.markdownRendererService.render(descriptionMarkdown);
+        desc.appendChild(renderedMarkdown.element);
+        const dismissButton = append(tosCard, $("button.agentSessionsWelcome-tosCard-dismiss"));
+        dismissButton.appendChild(renderIcon(Codicon.close));
+        dismissButton.title = ( localize(13538, "Dismiss"));
+        dismissButton.onclick = e => {
+            e.stopPropagation();
+            dismissNotice();
+        };
+    }
+    buildFooter(container) {
+        this.buildPrivacyNotice(container);
+        const showOnStartupContainer = append(container, $(".agentSessionsWelcome-showOnStartup"));
+        const showOnStartupCheckbox = this.contentDisposables.add(( new Toggle({
+            icon: Codicon.check,
+            actionClassName: "agentSessionsWelcome-checkbox",
+            isChecked: this.configurationService.getValue(configurationKey) === "agentSessionsWelcomePage",
+            title: ( localize(13539, "When checked, this page will be shown on startup.")),
+            ...getToggleStyles({
+                inputActiveOptionBackground: "var(--vscode-descriptionForeground)",
+                inputActiveOptionForeground: "var(--vscode-editor-background)",
+                inputActiveOptionBorder: "var(--vscode-descriptionForeground)"
+            })
+        })));
+        showOnStartupCheckbox.domNode.id = "showOnStartup";
+        const showOnStartupLabel = $("label.caption", {
+            for: "showOnStartup"
+        }, ( localize(13540, "Show welcome page on startup")));
+        const onShowOnStartupChanged = () => {
+            if (showOnStartupCheckbox.checked) {
+                this.configurationService.updateValue(configurationKey, "agentSessionsWelcomePage");
+            } else {
+                this.configurationService.updateValue(configurationKey, "none");
+            }
+        };
+        this.contentDisposables.add(showOnStartupCheckbox.onChange(() => onShowOnStartupChanged()));
+        this.contentDisposables.add(addDisposableListener(showOnStartupLabel, "click", () => {
+            showOnStartupCheckbox.checked = !showOnStartupCheckbox.checked;
+            onShowOnStartupChanged();
+        }));
+        showOnStartupContainer.appendChild(showOnStartupCheckbox.domNode);
+        showOnStartupContainer.appendChild(showOnStartupLabel);
+    }
+    layout(dimension) {
+        this.lastDimension = dimension;
+        this.container.style.height = `${dimension.height}px`;
+        this.container.style.width = `${dimension.width}px`;
+        this.layoutChatWidget();
+        this.layoutSessionsControl();
+        this.scrollableElement?.scanDomNode();
+    }
+    layoutChatWidget() {
+        if (!this.chatWidget || !this.lastDimension) {
+            return;
+        }
+        const chatWidth = Math.min(800, this.lastDimension.width - 80);
+        const inputHeight = 150;
+        this.chatWidget.layout(inputHeight, chatWidth);
+    }
+    layoutSessionsControl() {
+        if (!this.sessionsControl || !this.sessionsControlContainer || !this.lastDimension) {
+            return;
+        }
+        const sessionsWidth = Math.min(800, this.lastDimension.width - 80);
+        const visibleSessions = Math.min(
+            this.agentSessionsService.model.sessions.filter(s => !s.isArchived()).length,
+            MAX_SESSIONS
+        );
+        const sessionsHeight = visibleSessions * 52;
+        this.sessionsControl.layout(sessionsHeight, sessionsWidth);
+        const marginOffset = Math.floor(visibleSessions / 2) * 52;
+        this.sessionsControl.element.style.marginBottom = `-${marginOffset}px`;
+    }
+    focus() {
+        super.focus();
+        this.chatWidget?.focusInput();
+    }
+    async revealMaximizedChat() {
+        try {
+            await this.closeEditorAndMaximizeAuxiliaryBar();
+        } catch (error) {
+            this.logService.error("Failed to open maximized chat: {0}", toErrorMessage(error));
+        }
+    }
+    async openSessionInChat(sessionResource) {
+        try {
+            await this.closeEditorAndMaximizeAuxiliaryBar(sessionResource);
+        } catch (error) {
+            this.logService.error("Failed to open agent session: {0}", toErrorMessage(error));
+        }
+    }
+    async closeEditorAndMaximizeAuxiliaryBar(sessionResource) {
+        await this.commandService.executeCommand("workbench.action.closeActiveEditor");
+        if (sessionResource) {
+            await this.chatWidgetService.openSession(sessionResource, ChatViewPaneTarget);
+        } else {
+            await this.commandService.executeCommand("workbench.action.chat.open");
+        }
+        const chatViewLocation = this.viewDescriptorService.getViewLocationById(ChatViewId);
+        if (chatViewLocation === ViewContainerLocation.AuxiliaryBar) {
+            this.layoutService.setAuxiliaryBarMaximized(true);
+        }
+    }
+    dispose() {
+        if (this._openedAt > 0) {
+            const visibleDurationMs = Date.now() - this._openedAt;
+            this.telemetryService.publicLog2("agentSessionsWelcome.closed", {
+                visibleDurationMs,
+                closedBy: this._closedBy
+            });
+        }
+        super.dispose();
+    }
+};
+AgentSessionsWelcomePage = AgentSessionsWelcomePage_1 = ( __decorate([( __param(1, ITelemetryService)), ( __param(2, IThemeService)), ( __param(3, IStorageService)), ( __param(4, IInstantiationService)), ( __param(5, IContextKeyService)), ( __param(6, IWorkbenchLayoutService)), ( __param(7, ICommandService)), ( __param(8, IEditorService)), ( __param(9, IAgentSessionsService)), ( __param(10, IConfigurationService)), ( __param(11, IProductService)), ( __param(12, IWalkthroughsService)), ( __param(13, IChatService)), ( __param(14, IChatEntitlementService)), ( __param(15, IMarkdownRendererService)), ( __param(16, IWorkspaceContextService)), ( __param(17, IWorkspacesService)), ( __param(18, IHostService)), ( __param(19, IWorkspaceTrustManagementService)), ( __param(20, IViewDescriptorService)), ( __param(21, IChatWidgetService)), ( __param(22, ILogService))], AgentSessionsWelcomePage));
+
+export { AgentSessionsWelcomePage };