@codingame/monaco-vscode-xterm-addons-common 24.1.0

package/vscode/src/vs/workbench/contrib/terminal/browser/xterm/decorationAddon.js

@@ -0,0 +1,583 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { addDisposableListener, EventType } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Separator } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableMap, toDisposable, DisposableStore, dispose } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { AccessibilitySignal } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService';
+import { IAccessibilitySignalService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService.service';
+import { IClipboardService } from '@codingame/monaco-vscode-api/vscode/vs/platform/clipboard/common/clipboardService.service';
+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 { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { TerminalCapability, CommandInvalidationReason } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities';
+import { TerminalSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { terminalDecorationMark } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminalIcons';
+import { DecorationSelector, updateLayout, getTerminalDecorationHoverContent, getTerminalCommandDecorationState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/xterm/decorationStyles';
+import { TERMINAL_COMMAND_DECORATION_DEFAULT_BACKGROUND_COLOR, TERMINAL_COMMAND_DECORATION_ERROR_BACKGROUND_COLOR, TERMINAL_COMMAND_DECORATION_SUCCESS_BACKGROUND_COLOR } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminalColorRegistry';
+import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { IChatContextPickService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContextPickService.service';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { TerminalContext } from '../../../chat/browser/actions/chatContext.js';
+import { parseTerminalUri, getTerminalUri } from '../terminalUri.js';
+import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { isString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
+
+let DecorationAddon = class DecorationAddon extends Disposable {
+    constructor(_resource, _capabilities, _clipboardService, _contextMenuService, _configurationService, _themeService, _openerService, _quickInputService, lifecycleService, _commandService, _accessibilitySignalService, _notificationService, _hoverService, _contextPickService, _chatWidgetService, _instantiationService) {
+        super();
+        this._resource = _resource;
+        this._capabilities = _capabilities;
+        this._clipboardService = _clipboardService;
+        this._contextMenuService = _contextMenuService;
+        this._configurationService = _configurationService;
+        this._themeService = _themeService;
+        this._openerService = _openerService;
+        this._quickInputService = _quickInputService;
+        this._commandService = _commandService;
+        this._accessibilitySignalService = _accessibilitySignalService;
+        this._notificationService = _notificationService;
+        this._hoverService = _hoverService;
+        this._contextPickService = _contextPickService;
+        this._chatWidgetService = _chatWidgetService;
+        this._instantiationService = _instantiationService;
+        this._capabilityDisposables = this._register(( new DisposableMap()));
+        this._decorations = ( new Map());
+        this._registeredMenuItems = ( new Map());
+        this._onDidRequestRunCommand = this._register(( new Emitter()));
+        this.onDidRequestRunCommand = this._onDidRequestRunCommand.event;
+        this._onDidRequestCopyAsHtml = this._register(( new Emitter()));
+        this.onDidRequestCopyAsHtml = this._onDidRequestCopyAsHtml.event;
+        this._register(toDisposable(() => this._dispose()));
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(TerminalSettingId.FontSize) || e.affectsConfiguration(TerminalSettingId.LineHeight)) {
+                this.refreshLayouts();
+            }
+            else if (e.affectsConfiguration('workbench.colorCustomizations')) {
+                this._refreshStyles(true);
+            }
+            else if (e.affectsConfiguration(TerminalSettingId.ShellIntegrationDecorationsEnabled)) {
+                this._removeCapabilityDisposables(TerminalCapability.CommandDetection);
+                this._updateDecorationVisibility();
+            }
+        }));
+        this._register(this._themeService.onDidColorThemeChange(() => this._refreshStyles(true)));
+        this._updateDecorationVisibility();
+        this._register(this._capabilities.onDidAddCapability(c => this._createCapabilityDisposables(c.id)));
+        this._register(this._capabilities.onDidRemoveCapability(c => this._removeCapabilityDisposables(c.id)));
+        this._register(lifecycleService.onWillShutdown(() => this._disposeAllDecorations()));
+    }
+    _createCapabilityDisposables(c) {
+        const capability = this._capabilities.get(c);
+        if (!capability || ( this._capabilityDisposables.has(c))) {
+            return;
+        }
+        const store = ( new DisposableStore());
+        switch (capability.type) {
+            case TerminalCapability.BufferMarkDetection:
+                store.add(capability.onMarkAdded(mark => this.registerMarkDecoration(mark)));
+                break;
+            case TerminalCapability.CommandDetection: {
+                const disposables = this._getCommandDetectionListeners(capability);
+                for (const d of disposables) {
+                    store.add(d);
+                }
+                break;
+            }
+        }
+        this._capabilityDisposables.set(c, store);
+    }
+    _removeCapabilityDisposables(c) {
+        this._capabilityDisposables.deleteAndDispose(c);
+    }
+    registerMarkDecoration(mark) {
+        if (!this._terminal || (!this._showGutterDecorations && !this._showOverviewRulerDecorations)) {
+            return undefined;
+        }
+        if (mark.hidden) {
+            return undefined;
+        }
+        return this.registerCommandDecoration(undefined, undefined, mark);
+    }
+    _updateDecorationVisibility() {
+        const showDecorations = this._configurationService.getValue(TerminalSettingId.ShellIntegrationDecorationsEnabled);
+        this._showGutterDecorations = (showDecorations === 'both' || showDecorations === 'gutter');
+        this._showOverviewRulerDecorations = (showDecorations === 'both' || showDecorations === 'overviewRuler');
+        this._disposeAllDecorations();
+        if (this._showGutterDecorations || this._showOverviewRulerDecorations) {
+            this._attachToCommandCapability();
+            this._updateGutterDecorationVisibility();
+        }
+        const currentCommand = this._capabilities.get(TerminalCapability.CommandDetection)?.executingCommandObject;
+        if (currentCommand) {
+            this.registerCommandDecoration(currentCommand, true);
+        }
+    }
+    _disposeAllDecorations() {
+        this._placeholderDecoration?.dispose();
+        for (const value of ( this._decorations.values())) {
+            value.decoration.dispose();
+            dispose(value.disposables);
+        }
+    }
+    _updateGutterDecorationVisibility() {
+        const commandDecorationElements = this._terminal?.element?.querySelectorAll(DecorationSelector.CommandDecoration);
+        if (commandDecorationElements) {
+            for (const commandDecorationElement of commandDecorationElements) {
+                this._updateCommandDecorationVisibility(commandDecorationElement);
+            }
+        }
+    }
+    _updateCommandDecorationVisibility(commandDecorationElement) {
+        if (this._showGutterDecorations) {
+            commandDecorationElement.classList.remove(DecorationSelector.Hide);
+        }
+        else {
+            commandDecorationElement.classList.add(DecorationSelector.Hide);
+        }
+    }
+    refreshLayouts() {
+        updateLayout(this._configurationService, this._placeholderDecoration?.element);
+        for (const decoration of this._decorations) {
+            updateLayout(this._configurationService, decoration[1].decoration.element);
+        }
+    }
+    _refreshStyles(refreshOverviewRulerColors) {
+        if (refreshOverviewRulerColors) {
+            for (const decoration of ( this._decorations.values())) {
+                const color = this._getDecorationCssColor(decoration.command)?.toString() ?? '';
+                if (decoration.decoration.options?.overviewRulerOptions) {
+                    decoration.decoration.options.overviewRulerOptions.color = color;
+                }
+                else if (decoration.decoration.options) {
+                    decoration.decoration.options.overviewRulerOptions = { color };
+                }
+            }
+        }
+        this._updateClasses(this._placeholderDecoration?.element);
+        for (const decoration of ( this._decorations.values())) {
+            this._updateClasses(decoration.decoration.element, decoration.command, decoration.markProperties);
+        }
+    }
+    _dispose() {
+        for (const disposable of ( this._capabilityDisposables.values())) {
+            dispose(disposable);
+        }
+        this.clearDecorations();
+    }
+    _clearPlaceholder() {
+        this._placeholderDecoration?.dispose();
+        this._placeholderDecoration = undefined;
+    }
+    clearDecorations() {
+        this._placeholderDecoration?.marker.dispose();
+        this._clearPlaceholder();
+        this._disposeAllDecorations();
+        this._decorations.clear();
+    }
+    _attachToCommandCapability() {
+        if (( this._capabilities.has(TerminalCapability.CommandDetection))) {
+            const capability = this._capabilities.get(TerminalCapability.CommandDetection);
+            const disposables = this._getCommandDetectionListeners(capability);
+            const store = ( new DisposableStore());
+            for (const d of disposables) {
+                store.add(d);
+            }
+            this._capabilityDisposables.set(TerminalCapability.CommandDetection, store);
+        }
+    }
+    _getCommandDetectionListeners(capability) {
+        this._removeCapabilityDisposables(TerminalCapability.CommandDetection);
+        const commandDetectionListeners = [];
+        if (capability.executingCommandObject?.marker) {
+            this.registerCommandDecoration(capability.executingCommandObject, true);
+        }
+        commandDetectionListeners.push(capability.onCommandStarted(command => this.registerCommandDecoration(command, true)));
+        for (const command of capability.commands) {
+            this.registerCommandDecoration(command);
+        }
+        commandDetectionListeners.push(capability.onCommandFinished(command => {
+            const buffer = this._terminal?.buffer?.active;
+            const marker = command.promptStartMarker;
+            const shouldRegisterDecoration = (command.exitCode === undefined ||
+                (buffer && marker && buffer.baseY + buffer.cursorY >= marker.line));
+            if (shouldRegisterDecoration) {
+                this.registerCommandDecoration(command);
+            }
+            if (command.exitCode) {
+                this._accessibilitySignalService.playSignal(AccessibilitySignal.terminalCommandFailed);
+            }
+            else {
+                this._accessibilitySignalService.playSignal(AccessibilitySignal.terminalCommandSucceeded);
+            }
+        }));
+        commandDetectionListeners.push(capability.onCommandInvalidated(commands => {
+            for (const command of commands) {
+                const id = command.marker?.id;
+                if (id) {
+                    const match = this._decorations.get(id);
+                    if (match) {
+                        match.decoration.dispose();
+                        dispose(match.disposables);
+                    }
+                }
+            }
+        }));
+        commandDetectionListeners.push(capability.onCurrentCommandInvalidated((request) => {
+            if (request.reason === CommandInvalidationReason.NoProblemsReported) {
+                const lastDecoration = Array.from(this._decorations.entries())[this._decorations.size - 1];
+                lastDecoration?.[1].decoration.dispose();
+            }
+            else if (request.reason === CommandInvalidationReason.Windows) {
+                this._clearPlaceholder();
+            }
+        }));
+        return commandDetectionListeners;
+    }
+    activate(terminal) {
+        this._terminal = terminal;
+        this._attachToCommandCapability();
+    }
+    registerCommandDecoration(command, beforeCommandExecution, markProperties) {
+        if (!this._terminal || (beforeCommandExecution && !command) || (!this._showGutterDecorations && !this._showOverviewRulerDecorations)) {
+            return undefined;
+        }
+        const marker = command?.marker || markProperties?.marker;
+        if (!marker) {
+            throw ( new Error(
+                `cannot add a decoration for a command ${JSON.stringify(command)} with no marker`
+            ));
+        }
+        this._clearPlaceholder();
+        const color = this._getDecorationCssColor(command)?.toString() ?? '';
+        const decoration = this._terminal.registerDecoration({
+            marker,
+            overviewRulerOptions: this._showOverviewRulerDecorations ? (beforeCommandExecution
+                ? { color, position: 'left' }
+                : { color, position: command?.exitCode ? 'right' : 'left' }) : undefined
+        });
+        if (!decoration) {
+            return undefined;
+        }
+        if (beforeCommandExecution) {
+            this._placeholderDecoration = decoration;
+        }
+        decoration.onRender(element => {
+            if (element.classList.contains(DecorationSelector.OverviewRuler)) {
+                return;
+            }
+            if (!this._decorations.get(decoration.marker.id)) {
+                decoration.onDispose(() => this._decorations.delete(decoration.marker.id));
+                this._decorations.set(decoration.marker.id, {
+                    decoration,
+                    disposables: this._createDisposables(element, command, markProperties),
+                    command,
+                    markProperties: command?.markProperties || markProperties
+                });
+            }
+            if (!element.classList.contains(DecorationSelector.Codicon) || command?.marker?.line === 0) {
+                updateLayout(this._configurationService, element);
+                this._updateClasses(element, command, command?.markProperties || markProperties);
+            }
+        });
+        return decoration;
+    }
+    registerMenuItems(command, items) {
+        const existingItems = this._registeredMenuItems.get(command);
+        if (existingItems) {
+            existingItems.push(...items);
+        }
+        else {
+            this._registeredMenuItems.set(command, [...items]);
+        }
+        return toDisposable(() => {
+            const commandItems = this._registeredMenuItems.get(command);
+            if (commandItems) {
+                for (const item of ( items.values())) {
+                    const index = commandItems.indexOf(item);
+                    if (index !== -1) {
+                        commandItems.splice(index, 1);
+                    }
+                }
+            }
+        });
+    }
+    _createDisposables(element, command, markProperties) {
+        if (command?.exitCode === undefined && !command?.markProperties) {
+            return [];
+        }
+        else if (command?.markProperties || markProperties) {
+            return [this._createHover(element, command || markProperties, markProperties?.hoverMessage)];
+        }
+        return [...this._createContextMenu(element, command), this._createHover(element, command)];
+    }
+    _createHover(element, command, hoverMessage) {
+        return this._hoverService.setupDelayedHover(element, () => ({
+            content: ( new MarkdownString(getTerminalDecorationHoverContent(command, hoverMessage, true)))
+        }));
+    }
+    _updateClasses(element, command, markProperties) {
+        if (!element) {
+            return;
+        }
+        for (const classes of element.classList) {
+            element.classList.remove(classes);
+        }
+        element.classList.add(DecorationSelector.CommandDecoration, DecorationSelector.Codicon, DecorationSelector.XtermDecoration);
+        if (markProperties) {
+            element.classList.add(DecorationSelector.DefaultColor, ...ThemeIcon.asClassNameArray(terminalDecorationMark));
+            if (!markProperties.hoverMessage) {
+                element.classList.add(DecorationSelector.Default);
+            }
+        }
+        else {
+            const state = getTerminalCommandDecorationState(command);
+            this._updateCommandDecorationVisibility(element);
+            for (const className of state.classNames) {
+                element.classList.add(className);
+            }
+            element.classList.add(...ThemeIcon.asClassNameArray(state.icon));
+        }
+        element.removeAttribute('title');
+        element.removeAttribute('aria-label');
+    }
+    _createContextMenu(element, command) {
+        return [
+            addDisposableListener(element, EventType.MOUSE_DOWN, async (e) => {
+                e.stopImmediatePropagation();
+            }),
+            addDisposableListener(element, EventType.CLICK, async (e) => {
+                e.stopImmediatePropagation();
+                const actions = await this._getCommandActions(command);
+                this._contextMenuService.showContextMenu({ getAnchor: () => element, getActions: () => actions });
+            }),
+            addDisposableListener(element, EventType.CONTEXT_MENU, async (e) => {
+                e.stopImmediatePropagation();
+                const chatActions = await this._getCommandActions(command);
+                const actions = this._getContextMenuActions();
+                this._contextMenuService.showContextMenu({ getAnchor: () => element, getActions: () => [...actions, ...chatActions] });
+            }),
+        ];
+    }
+    _getContextMenuActions() {
+        const label = ( localize(11647, "Toggle Visibility"));
+        return [
+            {
+                class: undefined, tooltip: label, id: 'terminal.toggleVisibility', label, enabled: true,
+                run: async () => {
+                    this._showToggleVisibilityQuickPick();
+                }
+            }
+        ];
+    }
+    async _getCommandActions(command) {
+        const actions = [];
+        const registeredMenuItems = this._registeredMenuItems.get(command);
+        if (registeredMenuItems?.length) {
+            actions.push(...registeredMenuItems, ( new Separator()));
+        }
+        const attachToChatAction = this._createAttachToChatAction(command);
+        if (attachToChatAction) {
+            actions.push(attachToChatAction, ( new Separator()));
+        }
+        if (command.command !== '') {
+            const labelRun = ( localize(11648, 'Rerun Command'));
+            actions.push({
+                class: undefined, tooltip: labelRun, id: 'terminal.rerunCommand', label: labelRun, enabled: true,
+                run: async () => {
+                    if (command.command === '') {
+                        return;
+                    }
+                    if (!command.isTrusted) {
+                        const shouldRun = await ( new Promise(r => {
+                            this._notificationService.prompt(Severity.Info, ( localize(11649, 'Do you want to run the command: {0}', command.command)), [{
+                                    label: ( localize(11650, 'Yes')),
+                                    run: () => r(true)
+                                }, {
+                                    label: ( localize(11651, 'No')),
+                                    run: () => r(false)
+                                }]);
+                        }));
+                        if (!shouldRun) {
+                            return;
+                        }
+                    }
+                    this._onDidRequestRunCommand.fire({ command });
+                }
+            });
+            actions.push(( new Separator()));
+            const labelCopy = ( localize(11652, 'Copy Command'));
+            actions.push({
+                class: undefined, tooltip: labelCopy, id: 'terminal.copyCommand', label: labelCopy, enabled: true,
+                run: () => this._clipboardService.writeText(command.command)
+            });
+        }
+        if (command.hasOutput()) {
+            const labelCopyCommandAndOutput = ( localize(11653, 'Copy Command and Output'));
+            actions.push({
+                class: undefined, tooltip: labelCopyCommandAndOutput, id: 'terminal.copyCommandAndOutput', label: labelCopyCommandAndOutput, enabled: true,
+                run: () => {
+                    const output = command.getOutput();
+                    if (isString(output)) {
+                        this._clipboardService.writeText(`${command.command !== '' ? command.command + '\n' : ''}${output}`);
+                    }
+                }
+            });
+            const labelText = ( localize(11654, 'Copy Output'));
+            actions.push({
+                class: undefined, tooltip: labelText, id: 'terminal.copyOutput', label: labelText, enabled: true,
+                run: () => {
+                    const text = command.getOutput();
+                    if (isString(text)) {
+                        this._clipboardService.writeText(text);
+                    }
+                }
+            });
+            const labelHtml = ( localize(11655, 'Copy Output as HTML'));
+            actions.push({
+                class: undefined, tooltip: labelHtml, id: 'terminal.copyOutputAsHtml', label: labelHtml, enabled: true,
+                run: () => this._onDidRequestCopyAsHtml.fire({ command })
+            });
+        }
+        if (actions.length > 0) {
+            actions.push(( new Separator()));
+        }
+        const labelRunRecent = ( localize(11656, "Run Recent Command"));
+        actions.push({
+            class: undefined, tooltip: labelRunRecent, id: 'workbench.action.terminal.runRecentCommand', label: labelRunRecent, enabled: true,
+            run: () => this._commandService.executeCommand('workbench.action.terminal.runRecentCommand')
+        });
+        const labelGoToRecent = ( localize(11657, "Go To Recent Directory"));
+        actions.push({
+            class: undefined, tooltip: labelRunRecent, id: 'workbench.action.terminal.goToRecentDirectory', label: labelGoToRecent, enabled: true,
+            run: () => this._commandService.executeCommand('workbench.action.terminal.goToRecentDirectory')
+        });
+        actions.push(( new Separator()));
+        const labelAbout = ( localize(11658, 'Learn About Shell Integration'));
+        actions.push({
+            class: undefined, tooltip: labelAbout, id: 'terminal.learnShellIntegration', label: labelAbout, enabled: true,
+            run: () => this._openerService.open('https://code.visualstudio.com/docs/terminal/shell-integration')
+        });
+        return actions;
+    }
+    _createAttachToChatAction(command) {
+        const chatIsEnabled = ( this._chatWidgetService.getWidgetsByLocations(ChatAgentLocation.Chat).some(w => w.attachmentCapabilities.supportsTerminalAttachments));
+        if (!chatIsEnabled) {
+            return undefined;
+        }
+        const labelAttachToChat = ( localize(11659, 'Attach To Chat'));
+        return {
+            class: undefined, tooltip: labelAttachToChat, id: 'terminal.attachToChat', label: labelAttachToChat, enabled: true,
+            run: async () => {
+                let widget = this._chatWidgetService.lastFocusedWidget ?? this._chatWidgetService.getWidgetsByLocations(ChatAgentLocation.Chat)?.find(w => w.attachmentCapabilities.supportsTerminalAttachments);
+                if (!widget) {
+                    widget = await this._chatWidgetService.revealWidget();
+                }
+                if (!widget) {
+                    return;
+                }
+                let terminalContext;
+                if (this._resource) {
+                    const parsedUri = parseTerminalUri(this._resource);
+                    terminalContext = this._instantiationService.createInstance(TerminalContext, getTerminalUri(parsedUri.workspaceId, parsedUri.instanceId, undefined, command.id));
+                }
+                if (terminalContext && widget.attachmentCapabilities.supportsTerminalAttachments) {
+                    try {
+                        const attachment = await terminalContext.asAttachment(widget);
+                        if (attachment) {
+                            widget.attachmentModel.addContext(attachment);
+                            widget.focusInput();
+                            return;
+                        }
+                    }
+                    catch (err) {
+                    }
+                    this._store.add(this._contextPickService.registerChatContextItem(terminalContext));
+                }
+            }
+        };
+    }
+    _showToggleVisibilityQuickPick() {
+        const quickPick = this._register(this._quickInputService.createQuickPick());
+        quickPick.hideInput = true;
+        quickPick.hideCheckAll = true;
+        quickPick.canSelectMany = true;
+        quickPick.title = ( localize(11660, 'Toggle visibility'));
+        const configValue = this._configurationService.getValue(TerminalSettingId.ShellIntegrationDecorationsEnabled);
+        const gutterIcon = {
+            label: ( localize(11661, 'Gutter command decorations')),
+            picked: configValue !== 'never' && configValue !== 'overviewRuler'
+        };
+        const overviewRulerIcon = {
+            label: ( localize(11662, 'Overview ruler command decorations')),
+            picked: configValue !== 'never' && configValue !== 'gutter'
+        };
+        quickPick.items = [gutterIcon, overviewRulerIcon];
+        const selectedItems = [];
+        if (configValue !== 'never') {
+            if (configValue !== 'gutter') {
+                selectedItems.push(gutterIcon);
+            }
+            if (configValue !== 'overviewRuler') {
+                selectedItems.push(overviewRulerIcon);
+            }
+        }
+        quickPick.selectedItems = selectedItems;
+        this._register(quickPick.onDidChangeSelection(async (e) => {
+            let newValue = 'never';
+            if (e.includes(gutterIcon)) {
+                if (e.includes(overviewRulerIcon)) {
+                    newValue = 'both';
+                }
+                else {
+                    newValue = 'gutter';
+                }
+            }
+            else if (e.includes(overviewRulerIcon)) {
+                newValue = 'overviewRuler';
+            }
+            await this._configurationService.updateValue(TerminalSettingId.ShellIntegrationDecorationsEnabled, newValue);
+        }));
+        quickPick.ok = false;
+        quickPick.show();
+    }
+    _getDecorationCssColor(command) {
+        let colorId;
+        if (command?.exitCode === undefined) {
+            colorId = TERMINAL_COMMAND_DECORATION_DEFAULT_BACKGROUND_COLOR;
+        }
+        else {
+            colorId = command.exitCode ? TERMINAL_COMMAND_DECORATION_ERROR_BACKGROUND_COLOR : TERMINAL_COMMAND_DECORATION_SUCCESS_BACKGROUND_COLOR;
+        }
+        return this._themeService.getColorTheme().getColor(colorId)?.toString();
+    }
+};
+DecorationAddon = ( __decorate([
+    ( __param(2, IClipboardService)),
+    ( __param(3, IContextMenuService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IThemeService)),
+    ( __param(6, IOpenerService)),
+    ( __param(7, IQuickInputService)),
+    ( __param(8, ILifecycleService)),
+    ( __param(9, ICommandService)),
+    ( __param(10, IAccessibilitySignalService)),
+    ( __param(11, INotificationService)),
+    ( __param(12, IHoverService)),
+    ( __param(13, IChatContextPickService)),
+    ( __param(14, IChatWidgetService)),
+    ( __param(15, IInstantiationService))
+], DecorationAddon));
+
+export { DecorationAddon };

package/vscode/src/vs/workbench/contrib/terminal/browser/xterm/markNavigationAddon.d.ts

@@ -0,0 +1,64 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IMarkTracker } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import { ITerminalCapabilityStore, ITerminalCommand } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities";
+import type { Terminal, IMarker, ITerminalAddon, IBufferRange } from "@xterm/xterm";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { ICurrentPartialCommand } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/commandDetection/terminalCommand";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+declare enum Boundary {
+    Top = 0,
+    Bottom = 1
+}
+export declare enum ScrollPosition {
+    Top = 0,
+    Middle = 1
+}
+export declare class MarkNavigationAddon extends Disposable implements IMarkTracker, ITerminalAddon {
+    private readonly _capabilities;
+    private readonly _configurationService;
+    private readonly _themeService;
+    private _currentMarker;
+    private _selectionStart;
+    private _isDisposable;
+    protected _terminal: Terminal | undefined;
+    private _navigationDecorations;
+    private _activeCommandGuide?;
+    private readonly _commandGuideDecorations;
+    activate(terminal: Terminal): void;
+    constructor(_capabilities: ITerminalCapabilityStore, _configurationService: IConfigurationService, _themeService: IThemeService);
+    private _getMarkers;
+    private _findCommand;
+    clear(): void;
+    private _resetNavigationDecorations;
+    private _isEmptyCommand;
+    scrollToPreviousMark(scrollPosition?: ScrollPosition, retainSelection?: boolean, skipEmptyCommands?: boolean): void;
+    scrollToNextMark(scrollPosition?: ScrollPosition, retainSelection?: boolean, skipEmptyCommands?: boolean): void;
+    private _scrollToCommand;
+    private _scrollToMarker;
+    private _createMarkerForOffset;
+    revealCommand(command: ITerminalCommand | ICurrentPartialCommand, position?: ScrollPosition): void;
+    revealRange(range: IBufferRange): void;
+    showCommandGuide(command: ITerminalCommand | undefined): void;
+    private _scrollState;
+    saveScrollState(): void;
+    restoreScrollState(): void;
+    private _highlightBufferRange;
+    registerTemporaryDecoration(marker: IMarker | number, endMarker: IMarker | number | undefined, showOutline: boolean): void;
+    scrollToLine(line: number, position: ScrollPosition): void;
+    getTargetScrollLine(line: number, position: ScrollPosition): number;
+    private _isMarkerInViewport;
+    scrollToClosestMarker(startMarkerId: string, endMarkerId?: string, highlight?: boolean | undefined): void;
+    selectToPreviousMark(): void;
+    selectToNextMark(): void;
+    selectToPreviousLine(): void;
+    selectToNextLine(): void;
+    scrollToPreviousLine(xterm: Terminal, scrollPosition?: ScrollPosition, retainSelection?: boolean): void;
+    scrollToNextLine(xterm: Terminal, scrollPosition?: ScrollPosition, retainSelection?: boolean): void;
+    private _registerMarkerOrThrow;
+    private _getOffset;
+    private _findPreviousMarker;
+    private _findNextMarker;
+}
+export declare function getLine(xterm: Terminal, marker: IMarker | Boundary): number;
+export declare function selectLines(xterm: Terminal, start: IMarker | Boundary, end: IMarker | Boundary | null): void;
+export {};