@codingame/monaco-vscode-katex-common 24.1.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatContentParts/toolInvocationParts/chatTerminalToolProgressPart.js

@@ -0,0 +1,1085 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { h, addDisposableListener, EventType, clearNode, getActiveWindow, getComputedStyle } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { ActionBar } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { MarkdownString, isMarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { migrateLegacyTerminalToolSpecificData } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chat';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ChatQueryTitlePart } from '../chatConfirmationWidget.js';
+import { ChatMarkdownContentPart } from '../chatMarkdownContentPart.js';
+import { ChatProgressSubPart } from '../chatProgressContentPart.js';
+import { BaseChatToolInvocationSubPart } from './chatToolInvocationSubPart.js';
+import * as chatTerminalToolProgressPart from '../media/chatTerminalToolProgressPart.css';
+import { Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { ITerminalChatService, ITerminalService, ITerminalConfigurationService, ITerminalEditorService, ITerminalGroupService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
+import { Disposable, MutableDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { getTerminalCommandDecorationTooltip, getTerminalCommandDecorationState, DecorationSelector } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/xterm/decorationStyles';
+import { DomScrollableElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/scrollbar/scrollableElement';
+import { ScrollbarVisibility } from '@codingame/monaco-vscode-api/vscode/vs/base/common/scrollable';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { stripIcons } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iconLabels';
+import { IAccessibleViewService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleView.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { AccessibilityVerbositySettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { DetachedTerminalCommandMirror } from '../../../../terminal/browser/chatTerminalCommandMirror.js';
+import { DetachedProcessInfo } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/detachedTerminal';
+import { TerminalLocation } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { TerminalContribCommandId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/terminalContribExports';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { isNumber } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { removeAnsiEscapeCodes } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { Color } from '@codingame/monaco-vscode-api/vscode/vs/base/common/color';
+import { TERMINAL_BACKGROUND_COLOR } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminalColorRegistry';
+import { PANEL_BACKGROUND } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/theme';
+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 { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+
+registerCss(chatTerminalToolProgressPart);
+const MIN_OUTPUT_ROWS = 1;
+const MAX_OUTPUT_ROWS = 10;
+const expandedStateByInvocation = ( new WeakMap());
+let TerminalCommandDecoration = class TerminalCommandDecoration extends Disposable {
+    constructor(_options, _hoverService) {
+        super();
+        this._options = _options;
+        this._hoverService = _hoverService;
+        const decorationElements = h('span.chat-terminal-command-decoration@decoration', { role: 'img', tabIndex: 0 });
+        this._element = decorationElements.decoration;
+        this._attachElementToContainer();
+    }
+    _attachElementToContainer() {
+        const container = this._options.getCommandBlock();
+        if (!container) {
+            return;
+        }
+        const decoration = this._element;
+        if (!decoration.isConnected || decoration.parentElement !== container) {
+            const icon = this._options.getIconElement();
+            if (icon && icon.parentElement === container) {
+                icon.insertAdjacentElement('afterend', decoration);
+            }
+            else {
+                container.insertBefore(decoration, container.firstElementChild ?? null);
+            }
+        }
+        this._register(this._hoverService.setupDelayedHover(decoration, () => ({
+            content: this._getHoverText()
+        })));
+        this._attachInteractionHandlers(decoration);
+    }
+    _getHoverText() {
+        const command = this._options.getResolvedCommand();
+        const storedState = this._options.terminalData.terminalCommandState;
+        return getTerminalCommandDecorationTooltip(command, storedState) || '';
+    }
+    update(command) {
+        this._attachElementToContainer();
+        const decoration = this._element;
+        const resolvedCommand = command ?? this._options.getResolvedCommand();
+        this._apply(decoration, resolvedCommand);
+    }
+    _apply(decoration, command) {
+        const terminalData = this._options.terminalData;
+        let storedState = terminalData.terminalCommandState;
+        if (command) {
+            const existingState = terminalData.terminalCommandState ?? {};
+            terminalData.terminalCommandState = {
+                ...existingState,
+                exitCode: command.exitCode,
+                timestamp: command.timestamp ?? existingState.timestamp,
+                duration: command.duration ?? existingState.duration
+            };
+            storedState = terminalData.terminalCommandState;
+        }
+        else if (!storedState) {
+            const now = Date.now();
+            terminalData.terminalCommandState = { exitCode: undefined, timestamp: now };
+            storedState = terminalData.terminalCommandState;
+        }
+        const decorationState = getTerminalCommandDecorationState(command, storedState);
+        const tooltip = getTerminalCommandDecorationTooltip(command, storedState);
+        decoration.className = `chat-terminal-command-decoration ${DecorationSelector.CommandDecoration}`;
+        decoration.classList.add(DecorationSelector.Codicon);
+        for (const className of decorationState.classNames) {
+            decoration.classList.add(className);
+        }
+        decoration.classList.add(...ThemeIcon.asClassNameArray(decorationState.icon));
+        const isInteractive = !decoration.classList.contains(DecorationSelector.Default);
+        decoration.tabIndex = isInteractive ? 0 : -1;
+        if (isInteractive) {
+            decoration.removeAttribute('aria-disabled');
+        }
+        else {
+            decoration.setAttribute('aria-disabled', 'true');
+        }
+        const hoverText = tooltip || decorationState.hoverMessage;
+        if (hoverText) {
+            decoration.setAttribute('aria-label', hoverText);
+        }
+        else {
+            decoration.removeAttribute('aria-label');
+        }
+    }
+    _attachInteractionHandlers(decoration) {
+        if (this._interactionElement === decoration) {
+            return;
+        }
+        this._interactionElement = decoration;
+    }
+};
+TerminalCommandDecoration = ( __decorate([
+    ( __param(1, IHoverService))
+], TerminalCommandDecoration));
+let ChatTerminalToolProgressPart = class ChatTerminalToolProgressPart extends BaseChatToolInvocationSubPart {
+    get codeblocks() {
+        return this.markdownPart?.codeblocks ?? [];
+    }
+    get elementIndex() {
+        return this._elementIndex;
+    }
+    get contentIndex() {
+        return this._contentIndex;
+    }
+    constructor(toolInvocation, terminalData, context, renderer, editorPool, currentWidthDelegate, codeBlockStartIndex, codeBlockModelCollection, _instantiationService, _terminalChatService, _terminalService, _contextKeyService, _chatWidgetService, _keybindingService) {
+        super(toolInvocation);
+        this._instantiationService = _instantiationService;
+        this._terminalChatService = _terminalChatService;
+        this._terminalService = _terminalService;
+        this._contextKeyService = _contextKeyService;
+        this._chatWidgetService = _chatWidgetService;
+        this._keybindingService = _keybindingService;
+        this._showOutputAction = this._register(( new MutableDisposable()));
+        this._showOutputActionAdded = false;
+        this._focusAction = this._register(( new MutableDisposable()));
+        this._elementIndex = context.elementIndex;
+        this._contentIndex = context.contentIndex;
+        this._sessionResource = context.element.sessionResource;
+        terminalData = migrateLegacyTerminalToolSpecificData(terminalData);
+        this._terminalData = terminalData;
+        this._terminalCommandUri = terminalData.terminalCommandUri ? URI.revive(terminalData.terminalCommandUri) : undefined;
+        this._storedCommandId = this._terminalCommandUri ? ( new URLSearchParams(this._terminalCommandUri.query ?? '')).get('command') ?? undefined : undefined;
+        this._isSerializedInvocation = (toolInvocation.kind === 'toolInvocationSerialized');
+        const elements = h('.chat-terminal-content-part@container', [
+            h('.chat-terminal-content-title@title', [
+                h('.chat-terminal-command-block@commandBlock')
+            ]),
+            h('.chat-terminal-content-message@message')
+        ]);
+        this._titleElement = elements.title;
+        const command = terminalData.commandLine.userEdited ?? terminalData.commandLine.toolEdited ?? terminalData.commandLine.original;
+        this._commandText = command;
+        this._terminalOutputContextKey = ChatContextKeys.inChatTerminalToolOutput.bindTo(this._contextKeyService);
+        this._decoration = this._register(this._instantiationService.createInstance(TerminalCommandDecoration, {
+            terminalData: this._terminalData,
+            getCommandBlock: () => elements.commandBlock,
+            getIconElement: () => undefined,
+            getResolvedCommand: () => this._getResolvedCommand()
+        }));
+        const titlePart = this._register(_instantiationService.createInstance(ChatQueryTitlePart, elements.commandBlock, ( new MarkdownString([
+            `\`\`\`${terminalData.language}`,
+            `${command.replaceAll('```', '\\`\\`\\`')}`,
+            `\`\`\``
+        ].join('\n'), { supportThemeIcons: true })), undefined));
+        this._register(titlePart.onDidChangeHeight(() => {
+            this._decoration.update();
+            this._onDidChangeHeight.fire();
+        }));
+        this._outputView = this._register(this._instantiationService.createInstance(ChatTerminalToolOutputSection, () => this._onDidChangeHeight.fire(), () => this._ensureTerminalInstance(), () => this._getResolvedCommand(), () => this._terminalData.terminalCommandOutput, () => this._commandText, () => this._terminalData.terminalTheme));
+        elements.container.append(this._outputView.domNode);
+        this._register(this._outputView.onDidFocus(() => this._handleOutputFocus()));
+        this._register(this._outputView.onDidBlur(e => this._handleOutputBlur(e)));
+        this._register(toDisposable(() => this._handleDispose()));
+        this._register(this._keybindingService.onDidUpdateKeybindings(() => {
+            this._focusAction.value?.refreshKeybindingTooltip();
+            this._showOutputAction.value?.refreshKeybindingTooltip();
+        }));
+        const actionBarEl = h('.chat-terminal-action-bar@actionBar');
+        elements.title.append(actionBarEl.root);
+        this._actionBar = this._register(( new ActionBar(actionBarEl.actionBar, {})));
+        this._initializeTerminalActions();
+        this._terminalService.whenConnected.then(() => this._initializeTerminalActions());
+        let pastTenseMessage;
+        if (toolInvocation.pastTenseMessage) {
+            pastTenseMessage = `${typeof toolInvocation.pastTenseMessage === 'string' ? toolInvocation.pastTenseMessage : toolInvocation.pastTenseMessage.value}`;
+        }
+        const markdownContent = ( new MarkdownString(pastTenseMessage, {
+            supportThemeIcons: true,
+            isTrusted: isMarkdownString(toolInvocation.pastTenseMessage) ? toolInvocation.pastTenseMessage.isTrusted : false,
+        }));
+        const chatMarkdownContent = {
+            kind: 'markdownContent',
+            content: markdownContent,
+        };
+        const codeBlockRenderOptions = {
+            hideToolbar: true,
+            reserveWidth: 19,
+            verticalPadding: 5,
+            editorOptions: {
+                wordWrap: 'on'
+            }
+        };
+        const markdownOptions = {
+            codeBlockRenderOptions,
+            accessibilityOptions: pastTenseMessage ? {
+                statusMessage: ( localize(5150, '{0}', stripIcons(pastTenseMessage)))
+            } : undefined
+        };
+        this.markdownPart = this._register(_instantiationService.createInstance(ChatMarkdownContentPart, chatMarkdownContent, context, editorPool, false, codeBlockStartIndex, renderer, {}, currentWidthDelegate(), codeBlockModelCollection, markdownOptions));
+        this._register(this.markdownPart.onDidChangeHeight(() => this._onDidChangeHeight.fire()));
+        elements.message.append(this.markdownPart.domNode);
+        const progressPart = this._register(_instantiationService.createInstance(ChatProgressSubPart, elements.container, this.getIcon(), terminalData.autoApproveInfo));
+        this.domNode = progressPart.domNode;
+        this._decoration.update();
+        if (expandedStateByInvocation.get(toolInvocation)) {
+            void this._toggleOutput(true);
+        }
+        this._register(this._terminalChatService.registerProgressPart(this));
+    }
+    async _initializeTerminalActions() {
+        if (this._store.isDisposed) {
+            return;
+        }
+        const terminalToolSessionId = this._terminalData.terminalToolSessionId;
+        if (!terminalToolSessionId) {
+            this._addActions();
+            return;
+        }
+        const attachInstance = async (instance) => {
+            if (this._store.isDisposed) {
+                return;
+            }
+            if (!instance) {
+                if (this._isSerializedInvocation) {
+                    this._clearCommandAssociation();
+                }
+                this._addActions(undefined, terminalToolSessionId);
+                return;
+            }
+            const isNewInstance = this._terminalInstance !== instance;
+            if (isNewInstance) {
+                this._terminalInstance = instance;
+                this._registerInstanceListener(instance);
+            }
+            this._addActions(instance, terminalToolSessionId);
+        };
+        const initialInstance = await this._terminalChatService.getTerminalInstanceByToolSessionId(terminalToolSessionId);
+        await attachInstance(initialInstance);
+        if (!initialInstance) {
+            this._addActions(undefined, terminalToolSessionId);
+        }
+        if (this._store.isDisposed) {
+            return;
+        }
+        if (!this._terminalSessionRegistration) {
+            const listener = this._terminalChatService.onDidRegisterTerminalInstanceWithToolSession(async (instance) => {
+                const registeredInstance = await this._terminalChatService.getTerminalInstanceByToolSessionId(terminalToolSessionId);
+                if (instance !== registeredInstance) {
+                    return;
+                }
+                this._terminalSessionRegistration?.dispose();
+                this._terminalSessionRegistration = undefined;
+                await attachInstance(instance);
+            });
+            this._terminalSessionRegistration = this._store.add(listener);
+        }
+    }
+    _addActions(terminalInstance, terminalToolSessionId) {
+        if (this._store.isDisposed) {
+            return;
+        }
+        const actionBar = this._actionBar;
+        this._removeFocusAction();
+        const resolvedCommand = this._getResolvedCommand(terminalInstance);
+        if (terminalInstance) {
+            const isTerminalHidden = terminalInstance && terminalToolSessionId ? this._terminalChatService.isBackgroundTerminal(terminalToolSessionId) : false;
+            const focusAction = this._instantiationService.createInstance(FocusChatInstanceAction, terminalInstance, resolvedCommand, this._terminalCommandUri, this._storedCommandId, isTerminalHidden);
+            this._focusAction.value = focusAction;
+            actionBar.push(focusAction, { icon: true, label: false, index: 0 });
+        }
+        this._ensureShowOutputAction(resolvedCommand);
+        this._decoration.update(resolvedCommand);
+    }
+    _getResolvedCommand(instance) {
+        const target = instance ?? this._terminalInstance;
+        if (!target) {
+            return undefined;
+        }
+        return this._resolveCommand(target);
+    }
+    _ensureShowOutputAction(command) {
+        if (this._store.isDisposed) {
+            return;
+        }
+        const resolvedCommand = command ?? this._getResolvedCommand();
+        const hasSnapshot = !!this._terminalData.terminalCommandOutput;
+        if (!resolvedCommand && !hasSnapshot) {
+            return;
+        }
+        let showOutputAction = this._showOutputAction.value;
+        if (!showOutputAction) {
+            showOutputAction = this._instantiationService.createInstance(ToggleChatTerminalOutputAction, () => this._toggleOutputFromAction());
+            this._showOutputAction.value = showOutputAction;
+            const exitCode = resolvedCommand?.exitCode ?? this._terminalData.terminalCommandState?.exitCode;
+            if (exitCode) {
+                this._toggleOutput(true);
+            }
+        }
+        showOutputAction.syncPresentation(this._outputView.isExpanded);
+        const actionBar = this._actionBar;
+        if (this._showOutputActionAdded) {
+            const existingIndex = actionBar.viewItems.findIndex(item => item.action === showOutputAction);
+            if (existingIndex >= 0 && existingIndex !== actionBar.length() - 1) {
+                actionBar.pull(existingIndex);
+                this._showOutputActionAdded = false;
+            }
+            else if (existingIndex >= 0) {
+                return;
+            }
+        }
+        if (this._showOutputActionAdded) {
+            return;
+        }
+        actionBar.push([showOutputAction], { icon: true, label: false });
+        this._showOutputActionAdded = true;
+    }
+    _clearCommandAssociation(options) {
+        this._terminalCommandUri = undefined;
+        this._storedCommandId = undefined;
+        if (options?.clearPersistentData) {
+            if (this._terminalData.terminalCommandUri) {
+                delete this._terminalData.terminalCommandUri;
+            }
+            if (this._terminalData.terminalToolSessionId) {
+                delete this._terminalData.terminalToolSessionId;
+            }
+        }
+        this._decoration.update();
+    }
+    _registerInstanceListener(terminalInstance) {
+        const commandDetectionListener = this._register(( new MutableDisposable()));
+        const tryResolveCommand = async () => {
+            const resolvedCommand = this._resolveCommand(terminalInstance);
+            this._addActions(terminalInstance, this._terminalData.terminalToolSessionId);
+            return resolvedCommand;
+        };
+        const attachCommandDetection = async (commandDetection) => {
+            commandDetectionListener.clear();
+            if (!commandDetection) {
+                await tryResolveCommand();
+                return;
+            }
+            commandDetectionListener.value = commandDetection.onCommandFinished(() => {
+                this._addActions(terminalInstance, this._terminalData.terminalToolSessionId);
+                const resolvedCommand = this._getResolvedCommand(terminalInstance);
+                if (resolvedCommand?.endMarker) {
+                    commandDetectionListener.clear();
+                }
+            });
+            const resolvedImmediately = await tryResolveCommand();
+            if (resolvedImmediately?.endMarker) {
+                commandDetectionListener.clear();
+                return;
+            }
+        };
+        attachCommandDetection(terminalInstance.capabilities.get(TerminalCapability.CommandDetection));
+        this._register(terminalInstance.capabilities.onDidAddCommandDetectionCapability(cd => attachCommandDetection(cd)));
+        const instanceListener = this._register(terminalInstance.onDisposed(() => {
+            if (this._terminalInstance === terminalInstance) {
+                this._terminalInstance = undefined;
+            }
+            this._clearCommandAssociation({ clearPersistentData: true });
+            commandDetectionListener.clear();
+            if (!this._store.isDisposed) {
+                this._actionBar.clear();
+            }
+            this._removeFocusAction();
+            this._showOutputActionAdded = false;
+            this._showOutputAction.clear();
+            this._addActions(undefined, this._terminalData.terminalToolSessionId);
+            instanceListener.dispose();
+        }));
+    }
+    _removeFocusAction() {
+        if (this._store.isDisposed) {
+            return;
+        }
+        const actionBar = this._actionBar;
+        const focusAction = this._focusAction.value;
+        if (actionBar && focusAction) {
+            const existingIndex = actionBar.viewItems.findIndex(item => item.action === focusAction);
+            if (existingIndex >= 0) {
+                actionBar.pull(existingIndex);
+            }
+        }
+        this._focusAction.clear();
+    }
+    async _toggleOutput(expanded) {
+        const didChange = await this._outputView.toggle(expanded);
+        const isExpanded = this._outputView.isExpanded;
+        this._titleElement.classList.toggle('chat-terminal-content-title-no-bottom-radius', isExpanded);
+        this._showOutputAction.value?.syncPresentation(isExpanded);
+        if (didChange) {
+            expandedStateByInvocation.set(this.toolInvocation, isExpanded);
+        }
+        return didChange;
+    }
+    async _ensureTerminalInstance() {
+        if (this._terminalInstance?.isDisposed) {
+            this._terminalInstance = undefined;
+        }
+        if (!this._terminalInstance && this._terminalData.terminalToolSessionId) {
+            this._terminalInstance = await this._terminalChatService.getTerminalInstanceByToolSessionId(this._terminalData.terminalToolSessionId);
+            if (this._terminalInstance?.isDisposed) {
+                this._terminalInstance = undefined;
+            }
+        }
+        return this._terminalInstance;
+    }
+    _handleOutputFocus() {
+        this._terminalOutputContextKey.set(true);
+        this._terminalChatService.setFocusedProgressPart(this);
+        this._outputView.updateAriaLabel();
+    }
+    _handleOutputBlur(event) {
+        const nextTarget = event.relatedTarget;
+        if (this._outputView.containsElement(nextTarget)) {
+            return;
+        }
+        this._terminalOutputContextKey.reset();
+        this._terminalChatService.clearFocusedProgressPart(this);
+    }
+    _handleDispose() {
+        this._terminalOutputContextKey.reset();
+        this._terminalChatService.clearFocusedProgressPart(this);
+    }
+    getCommandAndOutputAsText() {
+        return this._outputView.getCommandAndOutputAsText();
+    }
+    focusOutput() {
+        this._outputView.focus();
+    }
+    _focusChatInput() {
+        const widget = this._chatWidgetService.getWidgetBySessionResource(this._sessionResource);
+        widget?.focusInput();
+    }
+    async focusTerminal() {
+        if (this._focusAction.value) {
+            await this._focusAction.value.run();
+            return;
+        }
+        if (this._terminalCommandUri) {
+            this._terminalService.openResource(this._terminalCommandUri);
+        }
+    }
+    async toggleOutputFromKeyboard() {
+        if (!this._outputView.isExpanded) {
+            await this._toggleOutput(true);
+            this.focusOutput();
+            return;
+        }
+        await this._collapseOutputAndFocusInput();
+    }
+    async _toggleOutputFromAction() {
+        if (!this._outputView.isExpanded) {
+            await this._toggleOutput(true);
+            return;
+        }
+        await this._toggleOutput(false);
+    }
+    async _collapseOutputAndFocusInput() {
+        if (this._outputView.isExpanded) {
+            await this._toggleOutput(false);
+        }
+        this._focusChatInput();
+    }
+    _resolveCommand(instance) {
+        if (instance.isDisposed) {
+            return undefined;
+        }
+        const commandDetection = instance.capabilities.get(TerminalCapability.CommandDetection);
+        const commands = commandDetection?.commands;
+        if (!commands || commands.length === 0) {
+            return undefined;
+        }
+        return commands.find(c => c.id === this._terminalData.terminalCommandId);
+    }
+};
+ChatTerminalToolProgressPart = ( __decorate([
+    ( __param(8, IInstantiationService)),
+    ( __param(9, ITerminalChatService)),
+    ( __param(10, ITerminalService)),
+    ( __param(11, IContextKeyService)),
+    ( __param(12, IChatWidgetService)),
+    ( __param(13, IKeybindingService))
+], ChatTerminalToolProgressPart));
+let ChatTerminalToolOutputSection = class ChatTerminalToolOutputSection extends Disposable {
+    get isExpanded() {
+        return this.domNode.classList.contains('expanded');
+    }
+    get onDidFocus() { return this._onDidFocusEmitter.event; }
+    get onDidBlur() { return this._onDidBlurEmitter.event; }
+    constructor(_onDidChangeHeight, _ensureTerminalInstance, _resolveCommand, _getTerminalCommandOutput, _getCommandText, _getStoredTheme, _accessibleViewService, _instantiationService, _terminalConfigurationService, _themeService, _contextKeyService) {
+        super();
+        this._onDidChangeHeight = _onDidChangeHeight;
+        this._ensureTerminalInstance = _ensureTerminalInstance;
+        this._resolveCommand = _resolveCommand;
+        this._getTerminalCommandOutput = _getTerminalCommandOutput;
+        this._getCommandText = _getCommandText;
+        this._getStoredTheme = _getStoredTheme;
+        this._accessibleViewService = _accessibleViewService;
+        this._instantiationService = _instantiationService;
+        this._terminalConfigurationService = _terminalConfigurationService;
+        this._themeService = _themeService;
+        this._contextKeyService = _contextKeyService;
+        this._onDidFocusEmitter = this._register(( new Emitter()));
+        this._onDidBlurEmitter = this._register(( new Emitter()));
+        const containerElements = h('.chat-terminal-output-container@container', [
+            h('.chat-terminal-output-body@body', [
+                h('.chat-terminal-output-content@content', [
+                    h('.chat-terminal-output-terminal@terminal'),
+                    h('.chat-terminal-output-empty@empty')
+                ])
+            ])
+        ]);
+        this.domNode = containerElements.container;
+        this.domNode.classList.add('collapsed');
+        this._outputBody = containerElements.body;
+        this._contentContainer = containerElements.content;
+        this._terminalContainer = containerElements.terminal;
+        this._emptyElement = containerElements.empty;
+        this._contentContainer.appendChild(this._emptyElement);
+        this._register(addDisposableListener(this.domNode, EventType.FOCUS_IN, () => this._onDidFocusEmitter.fire()));
+        this._register(addDisposableListener(this.domNode, EventType.FOCUS_OUT, event => this._onDidBlurEmitter.fire(event)));
+        const resizeObserver = ( new ResizeObserver(() => this._handleResize()));
+        resizeObserver.observe(this.domNode);
+        this._register(toDisposable(() => resizeObserver.disconnect()));
+        this._applyBackgroundColor();
+        this._register(this._themeService.onDidColorThemeChange(() => this._applyBackgroundColor()));
+    }
+    async toggle(expanded) {
+        const currentlyExpanded = this.isExpanded;
+        if (expanded === currentlyExpanded) {
+            if (expanded) {
+                await this._updateTerminalContent();
+            }
+            return false;
+        }
+        this._setExpanded(expanded);
+        if (!expanded) {
+            this._renderedOutputHeight = undefined;
+            this._onDidChangeHeight();
+            return true;
+        }
+        if (!this._scrollableContainer) {
+            await this._createScrollableContainer();
+        }
+        await this._updateTerminalContent();
+        this._layoutOutput();
+        this._scrollOutputToBottom();
+        this._scheduleOutputRelayout();
+        return true;
+    }
+    focus() {
+        this._scrollableContainer?.getDomNode().focus();
+    }
+    containsElement(element) {
+        return !!element && this.domNode.contains(element);
+    }
+    updateAriaLabel() {
+        if (!this._scrollableContainer) {
+            return;
+        }
+        const command = this._resolveCommand();
+        const commandText = command?.command ?? this._getCommandText();
+        if (!commandText) {
+            return;
+        }
+        const ariaLabel = ( localize(5151, 'Terminal output for {0}', commandText));
+        const scrollableDomNode = this._scrollableContainer.getDomNode();
+        scrollableDomNode.setAttribute('role', 'region');
+        const accessibleViewHint = this._accessibleViewService.getOpenAriaHint(AccessibilityVerbositySettingId.TerminalChatOutput);
+        const label = accessibleViewHint
+            ? ariaLabel + ', ' + accessibleViewHint
+            : ariaLabel;
+        scrollableDomNode.setAttribute('aria-label', label);
+    }
+    getCommandAndOutputAsText() {
+        const command = this._resolveCommand();
+        const commandText = command?.command ?? this._getCommandText();
+        if (!commandText) {
+            return undefined;
+        }
+        const commandHeader = ( localize(5152, 'Command: {0}', commandText));
+        if (command) {
+            const rawOutput = command.getOutput();
+            if (!rawOutput || rawOutput.trim().length === 0) {
+                return `${commandHeader}\n${( localize(5153, 'No output was produced by the command.'))}`;
+            }
+            const lines = rawOutput.split('\n');
+            return `${commandHeader}\n${lines.join('\n').trimEnd()}`;
+        }
+        const snapshot = this._getTerminalCommandOutput();
+        if (!snapshot) {
+            return `${commandHeader}\n${( localize(5154, 'Command output is no longer available.'))}`;
+        }
+        const plain = removeAnsiEscapeCodes((snapshot.text ?? ''));
+        if (!plain.trim().length) {
+            return `${commandHeader}\n${( localize(5153, 'No output was produced by the command.'))}`;
+        }
+        let outputText = plain.trimEnd();
+        if (snapshot.truncated) {
+            outputText += `\n${( localize(5155, 'Output truncated.'))}`;
+        }
+        return `${commandHeader}\n${outputText}`;
+    }
+    _setExpanded(expanded) {
+        this.domNode.classList.toggle('expanded', expanded);
+        this.domNode.classList.toggle('collapsed', !expanded);
+    }
+    async _createScrollableContainer() {
+        this._scrollableContainer = this._register(( new DomScrollableElement(this._outputBody, {
+            vertical: ScrollbarVisibility.Hidden,
+            horizontal: ScrollbarVisibility.Auto,
+            handleMouseWheel: true
+        })));
+        const scrollableDomNode = this._scrollableContainer.getDomNode();
+        scrollableDomNode.tabIndex = 0;
+        this.domNode.appendChild(scrollableDomNode);
+        this.updateAriaLabel();
+    }
+    async _updateTerminalContent() {
+        const liveTerminalInstance = await this._resolveLiveTerminal();
+        const command = liveTerminalInstance ? this._resolveCommand() : undefined;
+        const snapshot = this._getTerminalCommandOutput();
+        if (liveTerminalInstance && command) {
+            const handled = await this._renderLiveOutput(liveTerminalInstance, command);
+            if (handled) {
+                return;
+            }
+        }
+        this._disposeLiveMirror();
+        if (snapshot) {
+            await this._renderSnapshotOutput(snapshot);
+            return;
+        }
+        this._renderUnavailableMessage(liveTerminalInstance);
+    }
+    async _renderLiveOutput(liveTerminalInstance, command) {
+        if (this._mirror) {
+            return true;
+        }
+        await liveTerminalInstance.xtermReadyPromise;
+        if (liveTerminalInstance.isDisposed || !liveTerminalInstance.xterm) {
+            this._disposeLiveMirror();
+            return false;
+        }
+        this._mirror = this._register(this._instantiationService.createInstance(DetachedTerminalCommandMirror, liveTerminalInstance.xterm, command));
+        await this._mirror.attach(this._terminalContainer);
+        const result = await this._mirror.renderCommand();
+        if (!result || result.lineCount === 0) {
+            this._showEmptyMessage(( localize(5153, 'No output was produced by the command.')));
+        }
+        else {
+            this._hideEmptyMessage();
+        }
+        this._layoutOutput(result?.lineCount ?? 0);
+        return true;
+    }
+    async _renderSnapshotOutput(snapshot) {
+        if (this._snapshotMirror) {
+            this._layoutOutput(snapshot.lineCount ?? 0);
+            return;
+        }
+        clearNode(this._terminalContainer);
+        this._snapshotMirror = this._register(this._instantiationService.createInstance(DetachedTerminalSnapshotMirror, snapshot, this._getStoredTheme));
+        await this._snapshotMirror.attach(this._terminalContainer);
+        this._snapshotMirror.setOutput(snapshot);
+        const result = await this._snapshotMirror.render();
+        const hasText = !!snapshot.text && snapshot.text.length > 0;
+        if (hasText) {
+            this._hideEmptyMessage();
+        }
+        else {
+            this._showEmptyMessage(( localize(5153, 'No output was produced by the command.')));
+        }
+        const lineCount = result?.lineCount ?? snapshot.lineCount ?? 0;
+        this._layoutOutput(lineCount);
+    }
+    _renderUnavailableMessage(liveTerminalInstance) {
+        clearNode(this._terminalContainer);
+        this._lastRenderedLineCount = undefined;
+        if (!liveTerminalInstance) {
+            this._showEmptyMessage(( localize(5156, 'Terminal is no longer available.')));
+        }
+        else {
+            this._showEmptyMessage(( localize(5157, 'Command information is not available.')));
+        }
+    }
+    async _resolveLiveTerminal() {
+        const instance = await this._ensureTerminalInstance();
+        return instance && !instance.isDisposed ? instance : undefined;
+    }
+    _showEmptyMessage(message) {
+        this._emptyElement.textContent = message;
+        this._terminalContainer.classList.add('chat-terminal-output-terminal-no-output');
+        this.domNode.classList.add('chat-terminal-output-container-no-output');
+    }
+    _hideEmptyMessage() {
+        this._emptyElement.textContent = '';
+        this._terminalContainer.classList.remove('chat-terminal-output-terminal-no-output');
+        this.domNode.classList.remove('chat-terminal-output-container-no-output');
+    }
+    _disposeLiveMirror() {
+        if (this._mirror) {
+            this._mirror.dispose();
+            this._mirror = undefined;
+        }
+    }
+    _scheduleOutputRelayout() {
+        getActiveWindow().requestAnimationFrame(() => {
+            this._layoutOutput();
+            this._scrollOutputToBottom();
+        });
+    }
+    _handleResize() {
+        if (!this._scrollableContainer) {
+            return;
+        }
+        if (this.isExpanded) {
+            this._layoutOutput();
+            this._scrollOutputToBottom();
+        }
+        else {
+            this._scrollableContainer.scanDomNode();
+        }
+    }
+    _layoutOutput(lineCount) {
+        if (!this._scrollableContainer) {
+            return;
+        }
+        if (lineCount !== undefined) {
+            this._lastRenderedLineCount = lineCount;
+        }
+        else {
+            lineCount = this._lastRenderedLineCount;
+        }
+        this._scrollableContainer.scanDomNode();
+        if (!this.isExpanded || lineCount === undefined) {
+            return;
+        }
+        const scrollableDomNode = this._scrollableContainer.getDomNode();
+        const rowHeight = this._computeRowHeightPx();
+        const padding = this._getOutputPadding();
+        const minHeight = rowHeight * MIN_OUTPUT_ROWS + padding;
+        const maxHeight = rowHeight * MAX_OUTPUT_ROWS + padding;
+        const contentHeight = this._getOutputContentHeight(lineCount, rowHeight, padding);
+        const clampedHeight = Math.min(contentHeight, maxHeight);
+        const measuredBodyHeight = Math.max(this._outputBody.clientHeight, minHeight);
+        const appliedHeight = Math.min(clampedHeight, measuredBodyHeight);
+        scrollableDomNode.style.height = appliedHeight < maxHeight ? `${appliedHeight}px` : '';
+        this._scrollableContainer.scanDomNode();
+        if (this._renderedOutputHeight !== appliedHeight) {
+            this._renderedOutputHeight = appliedHeight;
+            this._onDidChangeHeight();
+        }
+    }
+    _scrollOutputToBottom() {
+        if (!this._scrollableContainer) {
+            return;
+        }
+        const dimensions = this._scrollableContainer.getScrollDimensions();
+        this._scrollableContainer.setScrollPosition({ scrollTop: dimensions.scrollHeight });
+    }
+    _getOutputContentHeight(lineCount, rowHeight, padding) {
+        const contentRows = Math.max(lineCount, MIN_OUTPUT_ROWS);
+        const adjustedRows = contentRows + (lineCount > MAX_OUTPUT_ROWS ? 1 : 0);
+        return (adjustedRows * rowHeight) + padding;
+    }
+    _getOutputPadding() {
+        const style = getComputedStyle(this._outputBody);
+        const paddingTop = Number.parseFloat(style.paddingTop || '0');
+        const paddingBottom = Number.parseFloat(style.paddingBottom || '0');
+        return paddingTop + paddingBottom;
+    }
+    _computeRowHeightPx() {
+        const window = getActiveWindow();
+        const font = this._terminalConfigurationService.getFont(window);
+        const hasCharHeight = isNumber(font.charHeight) && font.charHeight > 0;
+        const hasFontSize = isNumber(font.fontSize) && font.fontSize > 0;
+        const hasLineHeight = isNumber(font.lineHeight) && font.lineHeight > 0;
+        const charHeight = (hasCharHeight ? font.charHeight : (hasFontSize ? font.fontSize : 1)) ?? 1;
+        const lineHeight = hasLineHeight ? font.lineHeight : 1;
+        const rowHeight = Math.ceil(charHeight * lineHeight);
+        return Math.max(rowHeight, 1);
+    }
+    _applyBackgroundColor() {
+        const theme = this._themeService.getColorTheme();
+        const isInEditor = ChatContextKeys.inChatEditor.getValue(this._contextKeyService);
+        const backgroundColor = theme.getColor(isInEditor ? editorBackground : PANEL_BACKGROUND);
+        if (backgroundColor) {
+            this.domNode.style.backgroundColor = ( backgroundColor.toString());
+        }
+    }
+};
+ChatTerminalToolOutputSection = ( __decorate([
+    ( __param(6, IAccessibleViewService)),
+    ( __param(7, IInstantiationService)),
+    ( __param(8, ITerminalConfigurationService)),
+    ( __param(9, IThemeService)),
+    ( __param(10, IContextKeyService))
+], ChatTerminalToolOutputSection));
+let DetachedTerminalSnapshotMirror = class DetachedTerminalSnapshotMirror extends Disposable {
+    constructor(output, _getTheme, _terminalService, _contextKeyService) {
+        super();
+        this._getTheme = _getTheme;
+        this._terminalService = _terminalService;
+        this._contextKeyService = _contextKeyService;
+        this._dirty = true;
+        this._output = output;
+    }
+    setOutput(output) {
+        this._output = output;
+        this._dirty = true;
+    }
+    async attach(container) {
+        const terminal = await this._getTerminal();
+        container.classList.add('chat-terminal-output-terminal');
+        if (this._attachedContainer !== container || container.firstChild === null) {
+            terminal.attachToElement(container);
+            this._attachedContainer = container;
+        }
+        this._container = container;
+        this._applyTheme(container);
+    }
+    async render() {
+        const output = this._output;
+        if (!output) {
+            return undefined;
+        }
+        if (!this._dirty) {
+            return { lineCount: this._lastRenderedLineCount ?? output.lineCount };
+        }
+        const terminal = await this._getTerminal();
+        terminal.xterm.clearBuffer();
+        terminal.xterm.clearSearchDecorations?.();
+        if (this._container) {
+            this._applyTheme(this._container);
+        }
+        const text = output.text ?? '';
+        const lineCount = output.lineCount ?? this._estimateLineCount(text);
+        if (!text) {
+            this._dirty = false;
+            this._lastRenderedLineCount = lineCount;
+            return { lineCount: 0 };
+        }
+        await ( new Promise(resolve => terminal.xterm.write(text, resolve)));
+        this._dirty = false;
+        this._lastRenderedLineCount = lineCount;
+        return { lineCount };
+    }
+    _estimateLineCount(text) {
+        if (!text) {
+            return 0;
+        }
+        const sanitized = text.replace(/\r/g, '');
+        const segments = sanitized.split('\n');
+        const count = sanitized.endsWith('\n') ? segments.length - 1 : segments.length;
+        return Math.max(count, 1);
+    }
+    _applyTheme(container) {
+        const theme = this._getTheme();
+        if (!theme) {
+            container.style.removeProperty('background-color');
+            container.style.removeProperty('color');
+            return;
+        }
+        if (theme.background) {
+            container.style.backgroundColor = theme.background;
+        }
+        if (theme.foreground) {
+            container.style.color = theme.foreground;
+        }
+    }
+    async _getTerminal() {
+        if (!this._detachedTerminal) {
+            this._detachedTerminal = this._createTerminal();
+        }
+        return this._detachedTerminal;
+    }
+    async _createTerminal() {
+        const terminal = await this._terminalService.createDetachedTerminal({
+            cols: 80,
+            rows: 10,
+            readonly: true,
+            processInfo: ( new DetachedProcessInfo({ initialCwd: '' })),
+            disableOverviewRuler: true,
+            colorProvider: {
+                getBackgroundColor: theme => {
+                    const storedBackground = this._getTheme()?.background;
+                    if (storedBackground) {
+                        const color = ( Color.fromHex(storedBackground));
+                        if (color) {
+                            return color;
+                        }
+                    }
+                    const terminalBackground = theme.getColor(TERMINAL_BACKGROUND_COLOR);
+                    if (terminalBackground) {
+                        return terminalBackground;
+                    }
+                    const isInEditor = ChatContextKeys.inChatEditor.getValue(this._contextKeyService);
+                    return theme.getColor(isInEditor ? editorBackground : PANEL_BACKGROUND);
+                }
+            }
+        });
+        return this._register(terminal);
+    }
+};
+DetachedTerminalSnapshotMirror = ( __decorate([
+    ( __param(2, ITerminalService)),
+    ( __param(3, IContextKeyService))
+], DetachedTerminalSnapshotMirror));
+let ToggleChatTerminalOutputAction = class ToggleChatTerminalOutputAction extends Action {
+    constructor(_toggle, _keybindingService, _telemetryService) {
+        super(TerminalContribCommandId.ToggleChatTerminalOutput, ( localize(5158, 'Show Output')), ThemeIcon.asClassName(Codicon.chevronRight), true);
+        this._toggle = _toggle;
+        this._keybindingService = _keybindingService;
+        this._telemetryService = _telemetryService;
+        this._expanded = false;
+        this._updateTooltip();
+    }
+    async run() {
+        this._telemetryService.publicLog2('terminal/chatToggleOutput', {
+            previousExpanded: this._expanded
+        });
+        await this._toggle();
+    }
+    syncPresentation(expanded) {
+        this._expanded = expanded;
+        this._updatePresentation();
+        this._updateTooltip();
+    }
+    refreshKeybindingTooltip() {
+        this._updateTooltip();
+    }
+    _updatePresentation() {
+        if (this._expanded) {
+            this.label = ( localize(5159, 'Hide Output'));
+            this.class = ThemeIcon.asClassName(Codicon.chevronDown);
+        }
+        else {
+            this.label = ( localize(5158, 'Show Output'));
+            this.class = ThemeIcon.asClassName(Codicon.chevronRight);
+        }
+    }
+    _updateTooltip() {
+        const keybinding = this._keybindingService.lookupKeybinding(TerminalContribCommandId.FocusMostRecentChatTerminalOutput);
+        const label = keybinding?.getLabel();
+        this.tooltip = label ? `${this.label} (${label})` : this.label;
+    }
+};
+ToggleChatTerminalOutputAction = ( __decorate([
+    ( __param(1, IKeybindingService)),
+    ( __param(2, ITelemetryService))
+], ToggleChatTerminalOutputAction));
+let FocusChatInstanceAction = class FocusChatInstanceAction extends Action {
+    constructor(_instance, _command, _commandUri, _commandId, isTerminalHidden, _terminalService, _terminalEditorService, _terminalGroupService, _keybindingService, _telemetryService) {
+        super(TerminalContribCommandId.FocusChatInstanceAction, isTerminalHidden ? ( localize(5160, 'Show and Focus Terminal')) : ( localize(5161, 'Focus Terminal')), ThemeIcon.asClassName(Codicon.openInProduct), true);
+        this._instance = _instance;
+        this._command = _command;
+        this._commandUri = _commandUri;
+        this._commandId = _commandId;
+        this._terminalService = _terminalService;
+        this._terminalEditorService = _terminalEditorService;
+        this._terminalGroupService = _terminalGroupService;
+        this._keybindingService = _keybindingService;
+        this._telemetryService = _telemetryService;
+        this._updateTooltip();
+    }
+    async run() {
+        this.label = ( localize(5161, 'Focus Terminal'));
+        this._updateTooltip();
+        let target = 'none';
+        let location = 'panel';
+        if (this._instance) {
+            target = 'instance';
+            location = this._instance.target === TerminalLocation.Editor ? 'editor' : 'panel';
+        }
+        else if (this._commandUri) {
+            target = 'commandUri';
+        }
+        this._telemetryService.publicLog2('terminal/chatFocusInstance', {
+            target,
+            location
+        });
+        if (this._instance) {
+            this._terminalService.setActiveInstance(this._instance);
+            if (this._instance.target === TerminalLocation.Editor) {
+                this._terminalEditorService.openEditor(this._instance);
+            }
+            else {
+                await this._terminalGroupService.showPanel(true);
+            }
+            this._terminalService.setActiveInstance(this._instance);
+            await this._instance.focusWhenReady(true);
+            const command = this._resolveCommand();
+            if (command) {
+                this._instance.xterm?.markTracker.revealCommand(command);
+            }
+            return;
+        }
+        if (this._commandUri) {
+            this._terminalService.openResource(this._commandUri);
+        }
+    }
+    refreshKeybindingTooltip() {
+        this._updateTooltip();
+    }
+    _resolveCommand() {
+        if (this._command && !this._command.endMarker?.isDisposed) {
+            return this._command;
+        }
+        if (!this._instance || !this._commandId) {
+            return this._command;
+        }
+        const commandDetection = this._instance.capabilities.get(TerminalCapability.CommandDetection);
+        const resolved = commandDetection?.commands.find(c => c.id === this._commandId);
+        if (resolved) {
+            this._command = resolved;
+        }
+        return this._command;
+    }
+    _updateTooltip() {
+        const keybinding = this._keybindingService.lookupKeybinding(TerminalContribCommandId.FocusMostRecentChatTerminal);
+        const label = keybinding?.getLabel();
+        this.tooltip = label ? `${this.label} (${label})` : this.label;
+    }
+};
+FocusChatInstanceAction = ( __decorate([
+    ( __param(5, ITerminalService)),
+    ( __param(6, ITerminalEditorService)),
+    ( __param(7, ITerminalGroupService)),
+    ( __param(8, IKeybindingService)),
+    ( __param(9, ITelemetryService))
+], FocusChatInstanceAction));
+
+export { ChatTerminalToolProgressPart, FocusChatInstanceAction, ToggleChatTerminalOutputAction };