@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.0

package/dist/vscode/vs/workbench/contrib/terminal/browser/terminalService.js

@@ -0,0 +1,1063 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { debounce } from 'monaco-editor/esm/vs/base/common/decorators.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { dispose, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { isWeb, isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { TerminalLocation, TerminalExitReason, TitleEventSource } from '../../../../platform/terminal/common/terminal.js';
+import { formatMessageForTerminal } from '../../../../platform/terminal/common/terminalStrings.js';
+import { iconForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { getIconRegistry } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { ColorScheme } from 'monaco-editor/esm/vs/platform/theme/common/theme.js';
+import { Themable, IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { VirtualWorkspaceContext } from '../../../common/contextkeys.js';
+import { IViewsService } from '../../../common/views.js';
+import { ITerminalEditorService, ITerminalGroupService, ITerminalInstanceService, ITerminalService } from './terminal.js';
+import { getCwdForSplit } from './terminalActions.js';
+import { TerminalConfigHelper } from './terminalConfigHelper.js';
+import { TerminalEditorInput } from './terminalEditorInput.js';
+import { getUriClasses, getColorStyleContent } from './terminalIcon.js';
+import { TerminalProfileQuickpick } from './terminalProfileQuickpick.js';
+import { getTerminalUri, getInstanceFromResource, parseTerminalUri } from './terminalUri.js';
+import { TERMINAL_VIEW_ID, ITerminalProfileService } from '../common/terminal.js';
+import { TerminalContextKeys } from '../common/terminalContextKey.js';
+import { columnToEditorGroup } from '../../../services/editor/common/editorGroupColumn.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { IEditorService, SIDE_GROUP } from '../../../services/editor/common/editorService.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
+import { IRemoteAgentService } from '../../../services/remote/common/remoteAgentService.js';
+let TerminalService = class TerminalService {
+    get isProcessSupportRegistered() { return !!this._processSupportContextKey.get(); }
+    get connectionState() { return this._connectionState; }
+    get configHelper() { return this._configHelper; }
+    get instances() {
+        return this._terminalGroupService.instances.concat(this._terminalEditorService.instances);
+    }
+    getReconnectedTerminals(reconnectionOwner) {
+        return this._reconnectedTerminals.get(reconnectionOwner);
+    }
+    get defaultLocation() { return this.configHelper.config.defaultLocation === "editor"  ? TerminalLocation.Editor : TerminalLocation.Panel; }
+    get activeInstance() {
+        for (const activeHostTerminal of ( this._hostActiveTerminals.values())) {
+            if (activeHostTerminal?.hasFocus) {
+                return activeHostTerminal;
+            }
+        }
+        return this._activeInstance;
+    }
+    get onDidChangeActiveGroup() { return this._onDidChangeActiveGroup.event; }
+    get onDidCreateInstance() { return this._onDidCreateInstance.event; }
+    get onDidDisposeInstance() { return this._onDidDisposeInstance.event; }
+    get onDidFocusInstance() { return this._onDidFocusInstance.event; }
+    get onDidReceiveProcessId() { return this._onDidReceiveProcessId.event; }
+    get onDidRequestStartExtensionTerminal() { return this._onDidRequestStartExtensionTerminal.event; }
+    get onDidChangeInstanceDimensions() { return this._onDidChangeInstanceDimensions.event; }
+    get onDidMaximumDimensionsChange() { return this._onDidMaxiumumDimensionsChange.event; }
+    get onDidChangeInstanceCapability() { return this._onDidChangeInstanceCapability.event; }
+    get onDidChangeInstances() { return this._onDidChangeInstances.event; }
+    get onDidChangeInstanceTitle() { return this._onDidChangeInstanceTitle.event; }
+    get onDidChangeInstanceIcon() { return this._onDidChangeInstanceIcon.event; }
+    get onDidChangeInstanceColor() { return this._onDidChangeInstanceColor.event; }
+    get onDidChangeActiveInstance() { return this._onDidChangeActiveInstance.event; }
+    get onDidChangeInstancePrimaryStatus() { return this._onDidChangeInstancePrimaryStatus.event; }
+    get onDidInputInstanceData() { return this._onDidInputInstanceData.event; }
+    get onDidDisposeGroup() { return this._onDidDisposeGroup.event; }
+    get onDidChangeGroups() { return this._onDidChangeGroups.event; }
+    get onDidRegisterProcessSupport() { return this._onDidRegisterProcessSupport.event; }
+    get onDidChangeConnectionState() { return this._onDidChangeConnectionState.event; }
+    constructor(_contextKeyService, _lifecycleService, _logService, _dialogService, _instantiationService, _remoteAgentService, _viewsService, _configurationService, _environmentService, _terminalEditorService, _terminalGroupService, _terminalInstanceService, _editorGroupsService, _terminalProfileService, _extensionService, _notificationService, _workspaceContextService, _commandService) {
+        this._contextKeyService = _contextKeyService;
+        this._lifecycleService = _lifecycleService;
+        this._logService = _logService;
+        this._dialogService = _dialogService;
+        this._instantiationService = _instantiationService;
+        this._remoteAgentService = _remoteAgentService;
+        this._viewsService = _viewsService;
+        this._configurationService = _configurationService;
+        this._environmentService = _environmentService;
+        this._terminalEditorService = _terminalEditorService;
+        this._terminalGroupService = _terminalGroupService;
+        this._terminalInstanceService = _terminalInstanceService;
+        this._editorGroupsService = _editorGroupsService;
+        this._terminalProfileService = _terminalProfileService;
+        this._extensionService = _extensionService;
+        this._notificationService = _notificationService;
+        this._workspaceContextService = _workspaceContextService;
+        this._commandService = _commandService;
+        this._hostActiveTerminals = ( new Map());
+        this._escapeSequenceLoggingEnabled = false;
+        this._isShuttingDown = false;
+        this._backgroundedTerminalInstances = [];
+        this._backgroundedTerminalDisposables = ( new Map());
+        this._connectionState = 0 ;
+        this._reconnectedTerminals = ( new Map());
+        this._onDidChangeActiveGroup = ( new Emitter());
+        this._onDidCreateInstance = ( new Emitter());
+        this._onDidDisposeInstance = ( new Emitter());
+        this._onDidFocusInstance = ( new Emitter());
+        this._onDidReceiveProcessId = ( new Emitter());
+        this._onDidRequestStartExtensionTerminal = ( new Emitter());
+        this._onDidChangeInstanceDimensions = ( new Emitter());
+        this._onDidMaxiumumDimensionsChange = ( new Emitter());
+        this._onDidChangeInstanceCapability = ( new Emitter());
+        this._onDidChangeInstances = ( new Emitter());
+        this._onDidChangeInstanceTitle = ( new Emitter());
+        this._onDidChangeInstanceIcon = ( new Emitter());
+        this._onDidChangeInstanceColor = ( new Emitter());
+        this._onDidChangeActiveInstance = ( new Emitter());
+        this._onDidChangeInstancePrimaryStatus = ( new Emitter());
+        this._onDidInputInstanceData = ( new Emitter());
+        this._onDidDisposeGroup = ( new Emitter());
+        this._onDidChangeGroups = ( new Emitter());
+        this._onDidRegisterProcessSupport = ( new Emitter());
+        this._onDidChangeConnectionState = ( new Emitter());
+        this._configHelper = this._instantiationService.createInstance(TerminalConfigHelper);
+        this.onDidCreateInstance(() => this._terminalProfileService.refreshAvailableProfiles());
+        this._forwardInstanceHostEvents(this._terminalGroupService);
+        this._forwardInstanceHostEvents(this._terminalEditorService);
+        this._terminalGroupService.onDidChangeActiveGroup(this._onDidChangeActiveGroup.fire, this._onDidChangeActiveGroup);
+        this._terminalInstanceService.onDidCreateInstance(instance => {
+            instance.setEscapeSequenceLogging(this._escapeSequenceLoggingEnabled);
+            this._initInstanceListeners(instance);
+            this._onDidCreateInstance.fire(instance);
+        });
+        this._terminalGroupService.onDidChangeActiveInstance(instance => {
+            if (!instance && !this._isShuttingDown) {
+                this._terminalGroupService.hidePanel();
+            }
+            if (instance?.shellType) {
+                this._terminalShellTypeContextKey.set(( instance.shellType.toString()));
+            }
+            else if (!instance) {
+                this._terminalShellTypeContextKey.reset();
+            }
+        });
+        this._handleInstanceContextKeys();
+        this._terminalShellTypeContextKey = TerminalContextKeys.shellType.bindTo(this._contextKeyService);
+        this._processSupportContextKey = TerminalContextKeys.processSupported.bindTo(this._contextKeyService);
+        this._processSupportContextKey.set(!isWeb || this._remoteAgentService.getConnection() !== null);
+        this._terminalHasBeenCreated = TerminalContextKeys.terminalHasBeenCreated.bindTo(this._contextKeyService);
+        this._terminalCountContextKey = TerminalContextKeys.count.bindTo(this._contextKeyService);
+        this._terminalEditorActive = TerminalContextKeys.terminalEditorActive.bindTo(this._contextKeyService);
+        this.onDidChangeActiveInstance(instance => {
+            this._terminalEditorActive.set(!!instance?.target && instance.target === TerminalLocation.Editor);
+        });
+        _lifecycleService.onBeforeShutdown(async (e) => e.veto(this._onBeforeShutdown(e.reason), 'veto.terminal'));
+        _lifecycleService.onWillShutdown(e => this._onWillShutdown(e));
+        this.initializePrimaryBackend();
+        timeout(0).then(() => this._instantiationService.createInstance(TerminalEditorStyle, document.head));
+    }
+    async showProfileQuickPick(type, cwd) {
+        const quickPick = this._instantiationService.createInstance(TerminalProfileQuickpick);
+        const result = await quickPick.showAndGetResult(type);
+        if (!result) {
+            return;
+        }
+        if (typeof result === 'string') {
+            return;
+        }
+        const keyMods = result.keyMods;
+        if (type === 'createInstance') {
+            const activeInstance = this.getDefaultInstanceHost().activeInstance;
+            let instance;
+            if (result.config && 'id' in result?.config) {
+                await this.createContributedTerminalProfile(result.config.extensionIdentifier, result.config.id, {
+                    icon: result.config.options?.icon,
+                    color: result.config.options?.color,
+                    location: !!(keyMods?.alt && activeInstance) ? { splitActiveTerminal: true } : this.defaultLocation
+                });
+                return;
+            }
+            else if (result.config && 'profileName' in result.config) {
+                if (keyMods?.alt && activeInstance) {
+                    instance = await this.createTerminal({ location: { parentTerminal: activeInstance }, config: result.config, cwd });
+                }
+                else {
+                    instance = await this.createTerminal({ location: this.defaultLocation, config: result.config, cwd });
+                }
+            }
+            if (instance && this.defaultLocation !== TerminalLocation.Editor) {
+                this._terminalGroupService.showPanel(true);
+                this.setActiveInstance(instance);
+                return instance;
+            }
+        }
+        return undefined;
+    }
+    async initializePrimaryBackend() {
+        this._primaryBackend = await this._terminalInstanceService.getBackend(this._environmentService.remoteAuthority);
+        const enableTerminalReconnection = this.configHelper.config.enablePersistentSessions;
+        this._connectionState = 0 ;
+        const isPersistentRemote = !!this._environmentService.remoteAuthority && enableTerminalReconnection;
+        if (isPersistentRemote) {
+            this._reconnectToRemoteTerminals().then(() => this._setConnected());
+        }
+        else if (enableTerminalReconnection) {
+            this._reconnectToLocalTerminals().then(() => this._setConnected());
+        }
+        else {
+            Promise.resolve().then(() => this._setConnected());
+        }
+        this._primaryBackend?.onDidRequestDetach(async (e) => {
+            const instanceToDetach = this.getInstanceFromResource(getTerminalUri(e.workspaceId, e.instanceId));
+            if (instanceToDetach) {
+                const persistentProcessId = instanceToDetach?.persistentProcessId;
+                if (persistentProcessId && !instanceToDetach.shellLaunchConfig.isFeatureTerminal && !instanceToDetach.shellLaunchConfig.customPtyImplementation) {
+                    if (instanceToDetach.target === TerminalLocation.Editor) {
+                        this._terminalEditorService.detachInstance(instanceToDetach);
+                    }
+                    else {
+                        this._terminalGroupService.getGroupForInstance(instanceToDetach)?.removeInstance(instanceToDetach);
+                    }
+                    await instanceToDetach.detachProcessAndDispose(TerminalExitReason.User);
+                    await this._primaryBackend?.acceptDetachInstanceReply(e.requestId, persistentProcessId);
+                }
+                else {
+                    await this._primaryBackend?.acceptDetachInstanceReply(e.requestId, undefined);
+                }
+            }
+        });
+    }
+    getPrimaryBackend() {
+        return this._primaryBackend;
+    }
+    _forwardInstanceHostEvents(host) {
+        host.onDidChangeInstances(this._onDidChangeInstances.fire, this._onDidChangeInstances);
+        host.onDidDisposeInstance(this._onDidDisposeInstance.fire, this._onDidDisposeInstance);
+        host.onDidChangeActiveInstance(instance => this._evaluateActiveInstance(host, instance));
+        host.onDidFocusInstance(instance => {
+            this._onDidFocusInstance.fire(instance);
+            this._evaluateActiveInstance(host, instance);
+        });
+        host.onDidChangeInstanceCapability((instance) => {
+            this._onDidChangeInstanceCapability.fire(instance);
+        });
+        this._hostActiveTerminals.set(host, undefined);
+    }
+    _evaluateActiveInstance(host, instance) {
+        this._hostActiveTerminals.set(host, instance);
+        if (instance === undefined) {
+            for (const active of ( this._hostActiveTerminals.values())) {
+                if (active) {
+                    instance = active;
+                }
+            }
+        }
+        this._activeInstance = instance;
+        this._onDidChangeActiveInstance.fire(instance);
+    }
+    setActiveInstance(value) {
+        if (value.shellLaunchConfig.hideFromUser) {
+            this._showBackgroundTerminal(value);
+        }
+        if (value.target === TerminalLocation.Editor) {
+            this._terminalEditorService.setActiveInstance(value);
+        }
+        else {
+            this._terminalGroupService.setActiveInstance(value);
+        }
+    }
+    async focusActiveInstance() {
+        if (!this._activeInstance) {
+            return;
+        }
+        if (this._activeInstance.target === TerminalLocation.Editor) {
+            return this._terminalEditorService.focusActiveInstance();
+        }
+        return this._terminalGroupService.focusActiveInstance();
+    }
+    async createContributedTerminalProfile(extensionIdentifier, id, options) {
+        await this._extensionService.activateByEvent(`onTerminalProfile:${id}`);
+        const profileProvider = this._terminalProfileService.getContributedProfileProvider(extensionIdentifier, id);
+        if (!profileProvider) {
+            this._notificationService.error(`No terminal profile provider registered for id "${id}"`);
+            return;
+        }
+        try {
+            await profileProvider.createContributedTerminalProfile(options);
+            this._terminalGroupService.setActiveInstanceByIndex(this._terminalGroupService.instances.length - 1);
+            await this._terminalGroupService.activeInstance?.focusWhenReady();
+        }
+        catch (e) {
+            this._notificationService.error(e.message);
+        }
+    }
+    async safeDisposeTerminal(instance) {
+        if (instance.target !== TerminalLocation.Editor &&
+            instance.hasChildProcesses &&
+            (this.configHelper.config.confirmOnKill === 'panel' || this.configHelper.config.confirmOnKill === 'always')) {
+            const veto = await this._showTerminalCloseConfirmation(true);
+            if (veto) {
+                return;
+            }
+        }
+        return ( new Promise(r => {
+            instance.onExit(() => r());
+            instance.dispose(TerminalExitReason.User);
+        }));
+    }
+    _setConnected() {
+        this._connectionState = 1 ;
+        this._onDidChangeConnectionState.fire();
+        this._logService.trace('Reconnected to terminals');
+    }
+    async _reconnectToRemoteTerminals() {
+        const remoteAuthority = this._environmentService.remoteAuthority;
+        if (!remoteAuthority) {
+            return;
+        }
+        const backend = await this._terminalInstanceService.getBackend(remoteAuthority);
+        if (!backend) {
+            return;
+        }
+        const layoutInfo = await backend.getTerminalLayoutInfo();
+        backend.reduceConnectionGraceTime();
+        await this._recreateTerminalGroups(layoutInfo);
+        this._attachProcessLayoutListeners();
+    }
+    async _reconnectToLocalTerminals() {
+        const localBackend = await this._terminalInstanceService.getBackend();
+        if (!localBackend) {
+            return;
+        }
+        const layoutInfo = await localBackend.getTerminalLayoutInfo();
+        if (layoutInfo && layoutInfo.tabs.length > 0) {
+            await this._recreateTerminalGroups(layoutInfo);
+        }
+        this._attachProcessLayoutListeners();
+    }
+    async _recreateTerminalGroups(layoutInfo) {
+        let reconnectCounter = 0;
+        let activeGroup;
+        if (layoutInfo) {
+            for (const groupLayout of layoutInfo.tabs) {
+                const terminalLayouts = groupLayout.terminals.filter(t => t.terminal && t.terminal.isOrphan);
+                if (terminalLayouts.length) {
+                    reconnectCounter += terminalLayouts.length;
+                    let terminalInstance;
+                    let group;
+                    for (const terminalLayout of terminalLayouts) {
+                        if (this._lifecycleService.startupKind !== 3  && terminalLayout.terminal?.type === 'Task') {
+                            continue;
+                        }
+                        if (!terminalInstance) {
+                            terminalInstance = await this.createTerminal({
+                                config: { attachPersistentProcess: terminalLayout.terminal },
+                                location: TerminalLocation.Panel
+                            });
+                            group = this._terminalGroupService.getGroupForInstance(terminalInstance);
+                            if (groupLayout.isActive) {
+                                activeGroup = group;
+                            }
+                        }
+                        else {
+                            terminalInstance = await this.createTerminal({
+                                config: { attachPersistentProcess: terminalLayout.terminal },
+                                location: { parentTerminal: terminalInstance }
+                            });
+                        }
+                    }
+                    const activeInstance = this.instances.find(t => {
+                        return t.shellLaunchConfig.attachPersistentProcess?.id === groupLayout.activePersistentProcessId;
+                    });
+                    if (activeInstance) {
+                        this.setActiveInstance(activeInstance);
+                    }
+                    group?.resizePanes(( groupLayout.terminals.map(terminal => terminal.relativeSize)));
+                }
+            }
+            if (layoutInfo.tabs.length) {
+                this._terminalGroupService.activeGroup = activeGroup;
+            }
+        }
+        return reconnectCounter;
+    }
+    async toggleEscapeSequenceLogging() {
+        if (this.instances.length === 0) {
+            return;
+        }
+        this._escapeSequenceLoggingEnabled = await this.instances[0].toggleEscapeSequenceLogging();
+        for (let i = 1; i < this.instances.length; i++) {
+            this.instances[i].setEscapeSequenceLogging(this._escapeSequenceLoggingEnabled);
+        }
+        await this._toggleDevTools(this._escapeSequenceLoggingEnabled);
+    }
+    _attachProcessLayoutListeners() {
+        this.onDidChangeActiveGroup(() => this._saveState());
+        this.onDidChangeActiveInstance(() => this._saveState());
+        this.onDidChangeInstances(() => this._saveState());
+        this.onDidReceiveProcessId(() => this._saveState());
+        this.onDidChangeInstanceTitle(instance => this._updateTitle(instance));
+        this.onDidChangeInstanceIcon(e => this._updateIcon(e.instance, e.userInitiated));
+    }
+    _handleInstanceContextKeys() {
+        const terminalIsOpenContext = TerminalContextKeys.isOpen.bindTo(this._contextKeyService);
+        const updateTerminalContextKeys = () => {
+            terminalIsOpenContext.set(this.instances.length > 0);
+            this._terminalCountContextKey.set(this.instances.length);
+        };
+        this.onDidChangeInstances(() => updateTerminalContextKeys());
+    }
+    async getActiveOrCreateInstance(options) {
+        const activeInstance = this.activeInstance;
+        if (!activeInstance) {
+            return this.createTerminal();
+        }
+        if (!options?.acceptsInput || activeInstance.xterm?.isStdinDisabled !== true) {
+            return activeInstance;
+        }
+        const instance = await this.createTerminal();
+        this.setActiveInstance(instance);
+        await this.revealActiveTerminal();
+        return instance;
+    }
+    async revealActiveTerminal() {
+        const instance = this.activeInstance;
+        if (!instance) {
+            return;
+        }
+        if (instance.target === TerminalLocation.Editor) {
+            await this._terminalEditorService.revealActiveEditor();
+        }
+        else {
+            await this._terminalGroupService.showPanel();
+        }
+    }
+    setEditable(instance, data) {
+        if (!data) {
+            this._editable = undefined;
+        }
+        else {
+            this._editable = { instance: instance, data };
+        }
+        const pane = this._viewsService.getActiveViewWithId(TERMINAL_VIEW_ID);
+        const isEditing = this.isEditable(instance);
+        pane?.terminalTabbedView?.setEditable(isEditing);
+    }
+    isEditable(instance) {
+        return !!this._editable && (this._editable.instance === instance || !instance);
+    }
+    getEditableData(instance) {
+        return this._editable && this._editable.instance === instance ? this._editable.data : undefined;
+    }
+    requestStartExtensionTerminal(proxy, cols, rows) {
+        return ( new Promise(callback => {
+            this._onDidRequestStartExtensionTerminal.fire({ proxy, cols, rows, callback });
+        }));
+    }
+    _onBeforeShutdown(reason) {
+        if (isWeb) {
+            this._isShuttingDown = true;
+            return false;
+        }
+        return this._onBeforeShutdownAsync(reason);
+    }
+    async _onBeforeShutdownAsync(reason) {
+        if (this.instances.length === 0) {
+            return false;
+        }
+        try {
+            this._shutdownWindowCount = await this._nativeDelegate?.getWindowCount();
+            const shouldReviveProcesses = this._shouldReviveProcesses(reason);
+            if (shouldReviveProcesses) {
+                await Promise.race([
+                    this._primaryBackend?.persistTerminalState(),
+                    timeout(2000)
+                ]);
+            }
+            const shouldPersistProcesses = this._configHelper.config.enablePersistentSessions && reason === 3 ;
+            if (!shouldPersistProcesses) {
+                const hasDirtyInstances = ((this.configHelper.config.confirmOnExit === 'always' && this.instances.length > 0) ||
+                    (this.configHelper.config.confirmOnExit === 'hasChildProcesses' && ( this.instances.some(e => e.hasChildProcesses))));
+                if (hasDirtyInstances) {
+                    return this._onBeforeShutdownConfirmation(reason);
+                }
+            }
+        }
+        catch (err) {
+            this._logService.warn('Exception occurred during terminal shutdown', err);
+        }
+        this._isShuttingDown = true;
+        return false;
+    }
+    setNativeDelegate(nativeDelegate) {
+        this._nativeDelegate = nativeDelegate;
+    }
+    async _toggleDevTools(open) {
+        if (open) {
+            this._nativeDelegate?.openDevTools();
+        }
+        else {
+            this._nativeDelegate?.toggleDevTools();
+        }
+    }
+    _shouldReviveProcesses(reason) {
+        if (!this._configHelper.config.enablePersistentSessions) {
+            return false;
+        }
+        switch (this.configHelper.config.persistentSessionReviveProcess) {
+            case 'onExit': {
+                if (reason === 1  && (this._shutdownWindowCount === 1 && !isMacintosh)) {
+                    return true;
+                }
+                return reason === 4  || reason === 2 ;
+            }
+            case 'onExitAndWindowClose': return reason !== 3 ;
+            default: return false;
+        }
+    }
+    async _onBeforeShutdownConfirmation(reason) {
+        const veto = await this._showTerminalCloseConfirmation();
+        if (!veto) {
+            this._isShuttingDown = true;
+        }
+        return veto;
+    }
+    _onWillShutdown(e) {
+        const shouldPersistTerminals = this._configHelper.config.enablePersistentSessions && e.reason === 3 ;
+        for (const instance of [...this._terminalGroupService.instances, ...this._backgroundedTerminalInstances]) {
+            if (shouldPersistTerminals && instance.shouldPersist) {
+                instance.detachProcessAndDispose(TerminalExitReason.Shutdown);
+            }
+            else {
+                instance.dispose(TerminalExitReason.Shutdown);
+            }
+        }
+        if (!shouldPersistTerminals && !this._shouldReviveProcesses(e.reason)) {
+            this._primaryBackend?.setTerminalLayoutInfo(undefined);
+        }
+    }
+    _saveState() {
+        if (this._isShuttingDown) {
+            return;
+        }
+        if (!this.configHelper.config.enablePersistentSessions) {
+            return;
+        }
+        const tabs = ( this._terminalGroupService.groups.map(g => g.getLayoutInfo(g === this._terminalGroupService.activeGroup)));
+        const state = { tabs };
+        this._primaryBackend?.setTerminalLayoutInfo(state);
+    }
+    _updateTitle(instance) {
+        if (!this.configHelper.config.enablePersistentSessions || !instance || !instance.persistentProcessId || !instance.title || instance.isDisposed) {
+            return;
+        }
+        if (instance.staticTitle) {
+            this._primaryBackend?.updateTitle(instance.persistentProcessId, instance.staticTitle, TitleEventSource.Api);
+        }
+        else {
+            this._primaryBackend?.updateTitle(instance.persistentProcessId, instance.title, instance.titleSource);
+        }
+    }
+    _updateIcon(instance, userInitiated) {
+        if (!this.configHelper.config.enablePersistentSessions || !instance || !instance.persistentProcessId || !instance.icon || instance.isDisposed) {
+            return;
+        }
+        this._primaryBackend?.updateIcon(instance.persistentProcessId, userInitiated, instance.icon, instance.color);
+    }
+    refreshActiveGroup() {
+        this._onDidChangeActiveGroup.fire(this._terminalGroupService.activeGroup);
+    }
+    getInstanceFromId(terminalId) {
+        let bgIndex = -1;
+        this._backgroundedTerminalInstances.forEach((terminalInstance, i) => {
+            if (terminalInstance.instanceId === terminalId) {
+                bgIndex = i;
+            }
+        });
+        if (bgIndex !== -1) {
+            return this._backgroundedTerminalInstances[bgIndex];
+        }
+        try {
+            return this.instances[this._getIndexFromId(terminalId)];
+        }
+        catch {
+            return undefined;
+        }
+    }
+    getInstanceFromIndex(terminalIndex) {
+        return this.instances[terminalIndex];
+    }
+    getInstanceFromResource(resource) {
+        return getInstanceFromResource(this.instances, resource);
+    }
+    isAttachedToTerminal(remoteTerm) {
+        return ( this.instances.some(term => term.processId === remoteTerm.pid));
+    }
+    moveToEditor(source) {
+        if (source.target === TerminalLocation.Editor) {
+            return;
+        }
+        const sourceGroup = this._terminalGroupService.getGroupForInstance(source);
+        if (!sourceGroup) {
+            return;
+        }
+        sourceGroup.removeInstance(source);
+        this._terminalEditorService.openEditor(source);
+    }
+    async moveToTerminalView(source, target, side) {
+        if (URI.isUri(source)) {
+            source = this.getInstanceFromResource(source);
+        }
+        if (!source) {
+            return;
+        }
+        this._terminalEditorService.detachInstance(source);
+        if (source.target !== TerminalLocation.Editor) {
+            await this._terminalGroupService.showPanel(true);
+            return;
+        }
+        source.target = TerminalLocation.Panel;
+        let group;
+        if (target) {
+            group = this._terminalGroupService.getGroupForInstance(target);
+        }
+        if (!group) {
+            group = this._terminalGroupService.createGroup();
+        }
+        group.addInstance(source);
+        this.setActiveInstance(source);
+        await this._terminalGroupService.showPanel(true);
+        if (target && side) {
+            const index = group.terminalInstances.indexOf(target) + (side === 'after' ? 1 : 0);
+            group.moveInstance(source, index);
+        }
+        this._onDidChangeInstances.fire();
+        this._onDidChangeActiveGroup.fire(this._terminalGroupService.activeGroup);
+    }
+    _initInstanceListeners(instance) {
+        const instanceDisposables = [
+            instance.onTitleChanged(this._onDidChangeInstanceTitle.fire, this._onDidChangeInstanceTitle),
+            instance.onIconChanged(this._onDidChangeInstanceIcon.fire, this._onDidChangeInstanceIcon),
+            instance.onIconChanged(this._onDidChangeInstanceColor.fire, this._onDidChangeInstanceColor),
+            instance.onProcessIdReady(this._onDidReceiveProcessId.fire, this._onDidReceiveProcessId),
+            instance.statusList.onDidChangePrimaryStatus(() => this._onDidChangeInstancePrimaryStatus.fire(instance)),
+            instance.onDimensionsChanged(() => {
+                this._onDidChangeInstanceDimensions.fire(instance);
+                if (this.configHelper.config.enablePersistentSessions && this.isProcessSupportRegistered) {
+                    this._saveState();
+                }
+            }),
+            instance.onMaximumDimensionsChanged(() => this._onDidMaxiumumDimensionsChange.fire(instance)),
+            instance.onDidInputData(this._onDidInputInstanceData.fire, this._onDidInputInstanceData),
+            instance.onDidFocus(this._onDidChangeActiveInstance.fire, this._onDidChangeActiveInstance),
+            instance.onRequestAddInstanceToGroup(async (e) => await this._addInstanceToGroup(instance, e))
+        ];
+        instance.onDisposed(() => dispose(instanceDisposables));
+    }
+    async _addInstanceToGroup(instance, e) {
+        const terminalIdentifier = parseTerminalUri(e.uri);
+        if (terminalIdentifier.instanceId === undefined) {
+            return;
+        }
+        let sourceInstance = this.getInstanceFromResource(e.uri);
+        if (!sourceInstance) {
+            const attachPersistentProcess = await this._primaryBackend?.requestDetachInstance(terminalIdentifier.workspaceId, terminalIdentifier.instanceId);
+            if (attachPersistentProcess) {
+                sourceInstance = await this.createTerminal({ config: { attachPersistentProcess }, resource: e.uri });
+                this._terminalGroupService.moveInstance(sourceInstance, instance, e.side);
+                return;
+            }
+        }
+        sourceInstance = this._terminalGroupService.getInstanceFromResource(e.uri);
+        if (sourceInstance) {
+            this._terminalGroupService.moveInstance(sourceInstance, instance, e.side);
+            return;
+        }
+        sourceInstance = this._terminalEditorService.getInstanceFromResource(e.uri);
+        if (sourceInstance) {
+            this.moveToTerminalView(sourceInstance, instance, e.side);
+            return;
+        }
+        return;
+    }
+    registerProcessSupport(isSupported) {
+        if (!isSupported) {
+            return;
+        }
+        this._processSupportContextKey.set(isSupported);
+        this._onDidRegisterProcessSupport.fire();
+    }
+    _getIndexFromId(terminalId) {
+        let terminalIndex = -1;
+        this.instances.forEach((terminalInstance, i) => {
+            if (terminalInstance.instanceId === terminalId) {
+                terminalIndex = i;
+            }
+        });
+        if (terminalIndex === -1) {
+            throw new Error(`Terminal with ID ${terminalId} does not exist (has it already been disposed?)`);
+        }
+        return terminalIndex;
+    }
+    async _showTerminalCloseConfirmation(singleTerminal) {
+        let message;
+        if (this.instances.length === 1 || singleTerminal) {
+            message = ( nls.localize(
+                'terminalService.terminalCloseConfirmationSingular',
+                "Do you want to terminate the active terminal session?"
+            ));
+        }
+        else {
+            message = ( nls.localize(
+                'terminalService.terminalCloseConfirmationPlural',
+                "Do you want to terminate the {0} active terminal sessions?",
+                this.instances.length
+            ));
+        }
+        const { confirmed } = await this._dialogService.confirm({
+            type: 'warning',
+            message,
+            primaryButton: ( nls.localize({ key: 'terminate', comment: ['&& denotes a mnemonic'] }, "&&Terminate"))
+        });
+        return !confirmed;
+    }
+    getDefaultInstanceHost() {
+        if (this.defaultLocation === TerminalLocation.Editor) {
+            return this._terminalEditorService;
+        }
+        return this._terminalGroupService;
+    }
+    getInstanceHost(location) {
+        if (location) {
+            if (location === TerminalLocation.Editor) {
+                return this._terminalEditorService;
+            }
+            else if (typeof location === 'object') {
+                if ('viewColumn' in location) {
+                    return this._terminalEditorService;
+                }
+                else if ('parentTerminal' in location) {
+                    return location.parentTerminal.target === TerminalLocation.Editor ? this._terminalEditorService : this._terminalGroupService;
+                }
+            }
+            else {
+                return this._terminalGroupService;
+            }
+        }
+        return this;
+    }
+    async createTerminal(options) {
+        if (this._terminalProfileService.availableProfiles.length === 0) {
+            const isPtyTerminal = options?.config && 'customPtyImplementation' in options.config;
+            const isLocalInRemoteTerminal = this._remoteAgentService.getConnection() && URI.isUri(options?.cwd) && options?.cwd.scheme === Schemas.vscodeFileResource;
+            if (!isPtyTerminal && !isLocalInRemoteTerminal) {
+                await this._terminalProfileService.profilesReady;
+            }
+        }
+        const config = options?.config || this._terminalProfileService.getDefaultProfile();
+        const shellLaunchConfig = config && 'extensionIdentifier' in config ? {} : this._terminalInstanceService.convertProfileToShellLaunchConfig(config || {});
+        let contributedProfile = config && 'extensionIdentifier' in config ? config : undefined;
+        if (!contributedProfile && (!options || !options.config)) {
+            contributedProfile = await this._terminalProfileService.getContributedDefaultProfile(shellLaunchConfig);
+        }
+        const splitActiveTerminal = typeof options?.location === 'object' && 'splitActiveTerminal' in options.location ? options.location.splitActiveTerminal : typeof options?.location === 'object' ? 'parentTerminal' in options.location : false;
+        await this._resolveCwd(shellLaunchConfig, splitActiveTerminal, options);
+        if (contributedProfile) {
+            const resolvedLocation = this.resolveLocation(options?.location);
+            let location;
+            if (splitActiveTerminal) {
+                location = resolvedLocation === TerminalLocation.Editor ? { viewColumn: SIDE_GROUP } : { splitActiveTerminal: true };
+            }
+            else {
+                location = typeof options?.location === 'object' && 'viewColumn' in options.location ? options.location : resolvedLocation;
+            }
+            await this.createContributedTerminalProfile(contributedProfile.extensionIdentifier, contributedProfile.id, {
+                icon: contributedProfile.icon,
+                color: contributedProfile.color,
+                location
+            });
+            const instanceHost = resolvedLocation === TerminalLocation.Editor ? this._terminalEditorService : this._terminalGroupService;
+            const instance = instanceHost.instances[instanceHost.instances.length - 1];
+            await instance.focusWhenReady();
+            this._terminalHasBeenCreated.set(true);
+            return instance;
+        }
+        if (!shellLaunchConfig.customPtyImplementation && !this.isProcessSupportRegistered) {
+            throw new Error('Could not create terminal when process support is not registered');
+        }
+        if (shellLaunchConfig.hideFromUser) {
+            const instance = this._terminalInstanceService.createInstance(shellLaunchConfig, TerminalLocation.Panel);
+            this._backgroundedTerminalInstances.push(instance);
+            this._backgroundedTerminalDisposables.set(instance.instanceId, [
+                instance.onDisposed(this._onDidDisposeInstance.fire, this._onDidDisposeInstance)
+            ]);
+            this._terminalHasBeenCreated.set(true);
+            return instance;
+        }
+        this._evaluateLocalCwd(shellLaunchConfig);
+        const location = this.resolveLocation(options?.location) || this.defaultLocation;
+        const parent = this._getSplitParent(options?.location);
+        this._terminalHasBeenCreated.set(true);
+        if (parent) {
+            return this._splitTerminal(shellLaunchConfig, location, parent);
+        }
+        return this._createTerminal(shellLaunchConfig, location, options);
+    }
+    async _resolveCwd(shellLaunchConfig, splitActiveTerminal, options) {
+        const cwd = shellLaunchConfig.cwd;
+        if (!cwd) {
+            if (options?.cwd) {
+                shellLaunchConfig.cwd = options.cwd;
+            }
+            else if (splitActiveTerminal && options?.location) {
+                let parent = this.activeInstance;
+                if (typeof options.location === 'object' && 'parentTerminal' in options.location) {
+                    parent = options.location.parentTerminal;
+                }
+                if (!parent) {
+                    throw new Error('Cannot split without an active instance');
+                }
+                shellLaunchConfig.cwd = await getCwdForSplit(this.configHelper, parent, this._workspaceContextService.getWorkspace().folders, this._commandService);
+            }
+        }
+    }
+    _splitTerminal(shellLaunchConfig, location, parent) {
+        let instance;
+        if (typeof shellLaunchConfig.cwd !== 'object' && typeof parent.shellLaunchConfig.cwd === 'object') {
+            shellLaunchConfig.cwd = ( URI.from({
+                scheme: parent.shellLaunchConfig.cwd.scheme,
+                authority: parent.shellLaunchConfig.cwd.authority,
+                path: shellLaunchConfig.cwd || parent.shellLaunchConfig.cwd.path
+            }));
+        }
+        if (location === TerminalLocation.Editor || parent.target === TerminalLocation.Editor) {
+            instance = this._terminalEditorService.splitInstance(parent, shellLaunchConfig);
+        }
+        else {
+            const group = this._terminalGroupService.getGroupForInstance(parent);
+            if (!group) {
+                throw new Error(`Cannot split a terminal without a group ${parent}`);
+            }
+            shellLaunchConfig.parentTerminalId = parent.instanceId;
+            instance = group.split(shellLaunchConfig);
+        }
+        this._addToReconnected(instance);
+        return instance;
+    }
+    _addToReconnected(instance) {
+        if (!instance.reconnectionProperties?.ownerId) {
+            return;
+        }
+        const reconnectedTerminals = this._reconnectedTerminals.get(instance.reconnectionProperties.ownerId);
+        if (reconnectedTerminals) {
+            reconnectedTerminals.push(instance);
+        }
+        else {
+            this._reconnectedTerminals.set(instance.reconnectionProperties.ownerId, [instance]);
+        }
+    }
+    _createTerminal(shellLaunchConfig, location, options) {
+        let instance;
+        const editorOptions = this._getEditorOptions(options?.location);
+        if (location === TerminalLocation.Editor) {
+            instance = this._terminalInstanceService.createInstance(shellLaunchConfig, TerminalLocation.Editor);
+            this._terminalEditorService.openEditor(instance, editorOptions);
+        }
+        else {
+            const group = this._terminalGroupService.createGroup(shellLaunchConfig);
+            instance = group.terminalInstances[0];
+        }
+        this._addToReconnected(instance);
+        return instance;
+    }
+    resolveLocation(location) {
+        if (location && typeof location === 'object') {
+            if ('parentTerminal' in location) {
+                return !location.parentTerminal.target ? TerminalLocation.Panel : location.parentTerminal.target;
+            }
+            else if ('viewColumn' in location) {
+                return TerminalLocation.Editor;
+            }
+            else if ('splitActiveTerminal' in location) {
+                return !this._activeInstance?.target ? TerminalLocation.Panel : this._activeInstance?.target;
+            }
+        }
+        return location;
+    }
+    _getSplitParent(location) {
+        if (location && typeof location === 'object' && 'parentTerminal' in location) {
+            return location.parentTerminal;
+        }
+        else if (location && typeof location === 'object' && 'splitActiveTerminal' in location) {
+            return this.activeInstance;
+        }
+        return undefined;
+    }
+    _getEditorOptions(location) {
+        if (location && typeof location === 'object' && 'viewColumn' in location) {
+            location.viewColumn = columnToEditorGroup(this._editorGroupsService, this._configurationService, location.viewColumn);
+            return location;
+        }
+        return undefined;
+    }
+    _evaluateLocalCwd(shellLaunchConfig) {
+        if (typeof shellLaunchConfig.cwd !== 'string' && shellLaunchConfig.cwd?.scheme === Schemas.file) {
+            if (VirtualWorkspaceContext.getValue(this._contextKeyService)) {
+                shellLaunchConfig.initialText = formatMessageForTerminal(( nls.localize(
+                    'localTerminalVirtualWorkspace',
+                    "This shell is open to a {0}local{1} folder, NOT to the virtual folder",
+                    '\x1b[3m',
+                    '\x1b[23m'
+                )), { excludeLeadingNewLine: true, loudFormatting: true });
+                shellLaunchConfig.type = 'Local';
+            }
+            else if (this._remoteAgentService.getConnection()) {
+                shellLaunchConfig.initialText = formatMessageForTerminal(( nls.localize(
+                    'localTerminalRemote',
+                    "This shell is running on your {0}local{1} machine, NOT on the connected remote machine",
+                    '\x1b[3m',
+                    '\x1b[23m'
+                )), { excludeLeadingNewLine: true, loudFormatting: true });
+                shellLaunchConfig.type = 'Local';
+            }
+        }
+    }
+    _showBackgroundTerminal(instance) {
+        this._backgroundedTerminalInstances.splice(this._backgroundedTerminalInstances.indexOf(instance), 1);
+        const disposables = this._backgroundedTerminalDisposables.get(instance.instanceId);
+        if (disposables) {
+            dispose(disposables);
+        }
+        this._backgroundedTerminalDisposables.delete(instance.instanceId);
+        instance.shellLaunchConfig.hideFromUser = false;
+        this._terminalGroupService.createGroup(instance);
+        if (this.instances.length === 1) {
+            this._terminalGroupService.setActiveInstanceByIndex(0);
+        }
+        this._onDidChangeInstances.fire();
+        this._onDidChangeGroups.fire();
+    }
+    async setContainers(panelContainer, terminalContainer) {
+        this._configHelper.panelContainer = panelContainer;
+        this._terminalGroupService.setContainer(terminalContainer);
+    }
+    getEditingTerminal() {
+        return this._editingTerminal;
+    }
+    setEditingTerminal(instance) {
+        this._editingTerminal = instance;
+    }
+};
+TerminalService.__decorator = ( __decorate([
+    debounce(500)
+], TerminalService.prototype, "_saveState", null));
+TerminalService.__decorator = ( __decorate([
+    debounce(500)
+], TerminalService.prototype, "_updateTitle", null));
+TerminalService.__decorator = ( __decorate([
+    debounce(500)
+], TerminalService.prototype, "_updateIcon", null));
+TerminalService = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, ILifecycleService)),
+    ( __param(2, ILogService)),
+    ( __param(3, IDialogService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IRemoteAgentService)),
+    ( __param(6, IViewsService)),
+    ( __param(7, IConfigurationService)),
+    ( __param(8, IWorkbenchEnvironmentService)),
+    ( __param(9, ITerminalEditorService)),
+    ( __param(10, ITerminalGroupService)),
+    ( __param(11, ITerminalInstanceService)),
+    ( __param(12, IEditorGroupsService)),
+    ( __param(13, ITerminalProfileService)),
+    ( __param(14, IExtensionService)),
+    ( __param(15, INotificationService)),
+    ( __param(16, IWorkspaceContextService)),
+    ( __param(17, ICommandService))
+], TerminalService));
+let TerminalEditorStyle = class TerminalEditorStyle extends Themable {
+    constructor(container, _terminalService, _themeService, _terminalProfileService, _editorService) {
+        super(_themeService);
+        this._terminalService = _terminalService;
+        this._themeService = _themeService;
+        this._terminalProfileService = _terminalProfileService;
+        this._editorService = _editorService;
+        this._registerListeners();
+        this._styleElement = document.createElement('style');
+        container.appendChild(this._styleElement);
+        this._register(toDisposable(() => container.removeChild(this._styleElement)));
+        this.updateStyles();
+    }
+    _registerListeners() {
+        this._register(this._terminalService.onDidChangeInstanceIcon(() => this.updateStyles()));
+        this._register(this._terminalService.onDidChangeInstanceColor(() => this.updateStyles()));
+        this._register(this._terminalService.onDidCreateInstance(() => this.updateStyles()));
+        this._register(this._editorService.onDidActiveEditorChange(() => {
+            if (this._editorService.activeEditor instanceof TerminalEditorInput) {
+                this.updateStyles();
+            }
+        }));
+        this._register(this._editorService.onDidCloseEditor(() => {
+            if (this._editorService.activeEditor instanceof TerminalEditorInput) {
+                this.updateStyles();
+            }
+        }));
+        this._register(this._terminalProfileService.onDidChangeAvailableProfiles(() => this.updateStyles()));
+    }
+    updateStyles() {
+        super.updateStyles();
+        const colorTheme = this._themeService.getColorTheme();
+        let css = '';
+        const productIconTheme = this._themeService.getProductIconTheme();
+        for (const instance of this._terminalService.instances) {
+            const icon = instance.icon;
+            if (!icon) {
+                continue;
+            }
+            let uri = undefined;
+            if (icon instanceof URI) {
+                uri = icon;
+            }
+            else if (icon instanceof Object && 'light' in icon && 'dark' in icon) {
+                uri = colorTheme.type === ColorScheme.LIGHT ? icon.light : icon.dark;
+            }
+            const iconClasses = getUriClasses(instance, colorTheme.type);
+            if (uri instanceof URI && iconClasses && iconClasses.length > 1) {
+                css += (`.monaco-workbench .terminal-tab.${iconClasses[0]}::before` +
+                    `{background-image: ${dom.asCSSUrl(uri)};}`);
+            }
+            if (ThemeIcon.isThemeIcon(icon)) {
+                const iconRegistry = getIconRegistry();
+                const iconContribution = iconRegistry.getIcon(icon.id);
+                if (iconContribution) {
+                    const def = productIconTheme.getIcon(iconContribution);
+                    if (def) {
+                        css += (`.monaco-workbench .terminal-tab.codicon-${icon.id}::before` +
+                            `{content: '${def.fontCharacter}' !important; font-family: ${dom.asCSSPropertyValue(def.font?.id ?? 'codicon')} !important;}`);
+                    }
+                }
+            }
+        }
+        const iconForegroundColor = colorTheme.getColor(iconForeground);
+        if (iconForegroundColor) {
+            css += `.monaco-workbench .show-file-icons .file-icon.terminal-tab::before { color: ${iconForegroundColor}; }`;
+        }
+        css += getColorStyleContent(colorTheme, true);
+        this._styleElement.textContent = css;
+    }
+};
+TerminalEditorStyle = ( __decorate([
+    ( __param(1, ITerminalService)),
+    ( __param(2, IThemeService)),
+    ( __param(3, ITerminalProfileService)),
+    ( __param(4, IEditorService))
+], TerminalEditorStyle));
+export { TerminalService };