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

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

@@ -0,0 +1,618 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, dispose, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { OS, isWindows, isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { formatMessageForTerminal } from '../../../../platform/terminal/common/terminalStrings.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.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 { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { getRemoteAuthority } from 'monaco-editor/esm/vs/platform/remote/common/remoteHosts.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { NaiveCwdDetectionCapability } from '../../../../platform/terminal/common/capabilities/naiveCwdDetectionCapability.js';
+import { TerminalCapabilityStore } from '../../../../platform/terminal/common/capabilities/terminalCapabilityStore.js';
+import { TerminalRecorder } from '../../../../platform/terminal/common/terminalRecorder.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { EnvironmentVariableInfoChangesActive, EnvironmentVariableInfoStale } from './environmentVariableInfo.js';
+import { ITerminalInstanceService } from './terminal.js';
+import { IEnvironmentVariableService } from '../common/environmentVariable.js';
+import { MergedEnvironmentVariableCollection } from '../../../../platform/terminal/common/environmentVariableCollection.js';
+import { serializeEnvironmentVariableCollections } from '../../../../platform/terminal/common/environmentVariableShared.js';
+import { ITerminalProfileResolverService } from '../common/terminal.js';
+import { getWorkspaceForTerminal, createVariableResolver, createTerminalEnvironment, getCwd } from '../common/terminalEnvironment.js';
+import { IConfigurationResolverService } from '../../../services/configurationResolver/common/configurationResolver.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+import { IHistoryService } from '../../../services/history/common/history.js';
+import { IPathService } from '../../../services/path/common/pathService.js';
+import { IRemoteAgentService } from '../../../services/remote/common/remoteAgentService.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+let TerminalProcessManager = class TerminalProcessManager extends Disposable {
+    get persistentProcessId() { return this._process?.id; }
+    get shouldPersist() { return !!this.reconnectionProperties || (this._process ? this._process.shouldPersist : false); }
+    get hasWrittenData() { return this._hasWrittenData; }
+    get hasChildProcesses() { return this._hasChildProcesses; }
+    get reconnectionProperties() { return this._shellLaunchConfig?.attachPersistentProcess?.reconnectionProperties || this._shellLaunchConfig?.reconnectionProperties || undefined; }
+    get extEnvironmentVariableCollection() { return this._extEnvironmentVariableCollection; }
+    constructor(_instanceId, _configHelper, cwd, environmentVariableCollections, shellIntegrationNonce, _historyService, _instantiationService, _logService, _workspaceContextService, _configurationResolverService, _workbenchEnvironmentService, _productService, _remoteAgentService, _pathService, _environmentVariableService, _terminalProfileResolverService, _configurationService, _terminalInstanceService, _telemetryService, _notificationService) {
+        super();
+        this._instanceId = _instanceId;
+        this._configHelper = _configHelper;
+        this._historyService = _historyService;
+        this._instantiationService = _instantiationService;
+        this._logService = _logService;
+        this._workspaceContextService = _workspaceContextService;
+        this._configurationResolverService = _configurationResolverService;
+        this._workbenchEnvironmentService = _workbenchEnvironmentService;
+        this._productService = _productService;
+        this._remoteAgentService = _remoteAgentService;
+        this._pathService = _pathService;
+        this._environmentVariableService = _environmentVariableService;
+        this._terminalProfileResolverService = _terminalProfileResolverService;
+        this._configurationService = _configurationService;
+        this._terminalInstanceService = _terminalInstanceService;
+        this._telemetryService = _telemetryService;
+        this._notificationService = _notificationService;
+        this.processState = 1 ;
+        this.capabilities = ( new TerminalCapabilityStore());
+        this._isDisposed = false;
+        this._process = null;
+        this._processType = 0 ;
+        this._preLaunchInputQueue = [];
+        this._latency = -1;
+        this._latencyLastMeasured = 0;
+        this._hasWrittenData = false;
+        this._hasChildProcesses = false;
+        this._ptyListenersAttached = false;
+        this._isDisconnected = false;
+        this._dimensions = { cols: 0, rows: 0 };
+        this._onPtyDisconnect = this._register(( new Emitter()));
+        this.onPtyDisconnect = this._onPtyDisconnect.event;
+        this._onPtyReconnect = this._register(( new Emitter()));
+        this.onPtyReconnect = this._onPtyReconnect.event;
+        this._onProcessReady = this._register(( new Emitter()));
+        this.onProcessReady = this._onProcessReady.event;
+        this._onProcessStateChange = this._register(( new Emitter()));
+        this.onProcessStateChange = this._onProcessStateChange.event;
+        this._onBeforeProcessData = this._register(( new Emitter()));
+        this.onBeforeProcessData = this._onBeforeProcessData.event;
+        this._onProcessData = this._register(( new Emitter()));
+        this.onProcessData = this._onProcessData.event;
+        this._onDidChangeProperty = this._register(( new Emitter()));
+        this.onDidChangeProperty = this._onDidChangeProperty.event;
+        this._onEnvironmentVariableInfoChange = this._register(( new Emitter()));
+        this.onEnvironmentVariableInfoChanged = this._onEnvironmentVariableInfoChange.event;
+        this._onProcessExit = this._register(( new Emitter()));
+        this.onProcessExit = this._onProcessExit.event;
+        this._onRestoreCommands = this._register(( new Emitter()));
+        this.onRestoreCommands = this._onRestoreCommands.event;
+        this._cwdWorkspaceFolder = getWorkspaceForTerminal(cwd, this._workspaceContextService, this._historyService);
+        this.ptyProcessReady = this._createPtyProcessReadyPromise();
+        this.getLatency();
+        this._ackDataBufferer = ( new AckDataBufferer(e => this._process?.acknowledgeDataEvent(e)));
+        this._dataFilter = this._instantiationService.createInstance(SeamlessRelaunchDataFilter);
+        this._dataFilter.onProcessData(ev => {
+            const data = (typeof ev === 'string' ? ev : ev.data);
+            const beforeProcessDataEvent = { data };
+            this._onBeforeProcessData.fire(beforeProcessDataEvent);
+            if (beforeProcessDataEvent.data && beforeProcessDataEvent.data.length > 0) {
+                if (typeof ev !== 'string') {
+                    ev.data = beforeProcessDataEvent.data;
+                }
+                this._onProcessData.fire(typeof ev !== 'string' ? ev : { data: beforeProcessDataEvent.data, trackCommit: false });
+            }
+        });
+        if (cwd && typeof cwd === 'object') {
+            this.remoteAuthority = getRemoteAuthority(cwd);
+        }
+        else {
+            this.remoteAuthority = this._workbenchEnvironmentService.remoteAuthority;
+        }
+        if (environmentVariableCollections) {
+            this._extEnvironmentVariableCollection = ( new MergedEnvironmentVariableCollection(environmentVariableCollections));
+            this._register(this._environmentVariableService.onDidChangeCollections(newCollection => this._onEnvironmentVariableCollectionChange(newCollection)));
+            this.environmentVariableInfo = this._instantiationService.createInstance(EnvironmentVariableInfoChangesActive, this._extEnvironmentVariableCollection);
+            this._onEnvironmentVariableInfoChange.fire(this.environmentVariableInfo);
+        }
+        this.shellIntegrationNonce = shellIntegrationNonce ?? generateUuid();
+    }
+    async freePortKillProcess(port) {
+        try {
+            if (this._process?.freePortKillProcess) {
+                await this._process?.freePortKillProcess(port);
+            }
+        }
+        catch (e) {
+            this._notificationService.notify({ message: ( localize(
+                'killportfailure',
+                'Could not kill process listening on port {0}, command exited with error {1}',
+                port,
+                e
+            )), severity: Severity.Warning });
+        }
+    }
+    dispose(immediate = false) {
+        this._isDisposed = true;
+        if (this._process) {
+            this._setProcessState(5 );
+            this._process.shutdown(immediate);
+            this._process = null;
+        }
+        super.dispose();
+    }
+    _createPtyProcessReadyPromise() {
+        return ( new Promise(c => {
+            const listener = this.onProcessReady(() => {
+                this._logService.debug(`Terminal process ready (shellProcessId: ${this.shellProcessId})`);
+                listener.dispose();
+                c(undefined);
+            });
+        }));
+    }
+    async detachFromProcess(forcePersist) {
+        await this._process?.detach?.(forcePersist);
+        this._process = null;
+    }
+    async createProcess(shellLaunchConfig, cols, rows, reset = true) {
+        this._shellLaunchConfig = shellLaunchConfig;
+        this._dimensions.cols = cols;
+        this._dimensions.rows = rows;
+        let newProcess;
+        if (shellLaunchConfig.customPtyImplementation) {
+            this._processType = 1 ;
+            newProcess = shellLaunchConfig.customPtyImplementation(this._instanceId, cols, rows);
+        }
+        else {
+            const backend = await this._terminalInstanceService.getBackend(this.remoteAuthority);
+            if (!backend) {
+                throw new Error(`No terminal backend registered for remote authority '${this.remoteAuthority}'`);
+            }
+            this.backend = backend;
+            const variableResolver = createVariableResolver(this._cwdWorkspaceFolder, await this._terminalProfileResolverService.getEnvironment(this.remoteAuthority), this._configurationResolverService);
+            this.userHome = this._pathService.resolvedUserHome?.fsPath;
+            this.os = OS;
+            if (!!this.remoteAuthority) {
+                const userHomeUri = await this._pathService.userHome();
+                this.userHome = userHomeUri.path;
+                const remoteEnv = await this._remoteAgentService.getEnvironment();
+                if (!remoteEnv) {
+                    throw new Error(`Failed to get remote environment for remote authority "${this.remoteAuthority}"`);
+                }
+                this.userHome = remoteEnv.userHome.path;
+                this.os = remoteEnv.os;
+                const env = await this._resolveEnvironment(backend, variableResolver, shellLaunchConfig);
+                const shouldPersist = ((this._configurationService.getValue("task.reconnection" ) && shellLaunchConfig.reconnectionProperties) || !shellLaunchConfig.isFeatureTerminal) && this._configHelper.config.enablePersistentSessions && !shellLaunchConfig.isTransient;
+                if (shellLaunchConfig.attachPersistentProcess) {
+                    const result = await backend.attachToProcess(shellLaunchConfig.attachPersistentProcess.id);
+                    if (result) {
+                        newProcess = result;
+                    }
+                    else {
+                        this._logService.warn(`Attach to process failed for terminal`, shellLaunchConfig.attachPersistentProcess);
+                        shellLaunchConfig.attachPersistentProcess = undefined;
+                    }
+                }
+                if (!newProcess) {
+                    await this._terminalProfileResolverService.resolveShellLaunchConfig(shellLaunchConfig, {
+                        remoteAuthority: this.remoteAuthority,
+                        os: this.os
+                    });
+                    const options = {
+                        shellIntegration: {
+                            enabled: this._configurationService.getValue("terminal.integrated.shellIntegration.enabled" ),
+                            suggestEnabled: this._configurationService.getValue("terminal.integrated.shellIntegration.suggestEnabled" ),
+                            nonce: this.shellIntegrationNonce
+                        },
+                        windowsEnableConpty: this._configHelper.config.windowsEnableConpty,
+                        environmentVariableCollections: this._extEnvironmentVariableCollection?.collections ? serializeEnvironmentVariableCollections(this._extEnvironmentVariableCollection.collections) : undefined,
+                        workspaceFolder: this._cwdWorkspaceFolder,
+                    };
+                    try {
+                        newProcess = await backend.createProcess(shellLaunchConfig, '',
+                        cols, rows, this._configHelper.config.unicodeVersion, env,
+                        options, shouldPersist);
+                    }
+                    catch (e) {
+                        if (e?.message === 'Could not fetch remote environment') {
+                            this._logService.trace(`Could not fetch remote environment, silently failing`);
+                            return undefined;
+                        }
+                        throw e;
+                    }
+                }
+                if (!this._isDisposed) {
+                    this._setupPtyHostListeners(backend);
+                }
+            }
+            else {
+                if (shellLaunchConfig.attachPersistentProcess) {
+                    const result = shellLaunchConfig.attachPersistentProcess.findRevivedId ? await backend.attachToRevivedProcess(shellLaunchConfig.attachPersistentProcess.id) : await backend.attachToProcess(shellLaunchConfig.attachPersistentProcess.id);
+                    if (result) {
+                        newProcess = result;
+                    }
+                    else {
+                        this._logService.warn(`Attach to process failed for terminal`, shellLaunchConfig.attachPersistentProcess);
+                        shellLaunchConfig.attachPersistentProcess = undefined;
+                    }
+                }
+                if (!newProcess) {
+                    newProcess = await this._launchLocalProcess(backend, shellLaunchConfig, cols, rows, this.userHome, variableResolver);
+                }
+                if (!this._isDisposed) {
+                    this._setupPtyHostListeners(backend);
+                }
+            }
+        }
+        if (this._isDisposed) {
+            newProcess.shutdown(false);
+            return undefined;
+        }
+        this._process = newProcess;
+        this._setProcessState(2 );
+        if (this.os === 3  || this.os === 2 ) {
+            this.capabilities.add(1 , ( new NaiveCwdDetectionCapability(this._process)));
+        }
+        this._dataFilter.newProcess(this._process, reset);
+        if (this._processListeners) {
+            dispose(this._processListeners);
+        }
+        this._processListeners = [
+            newProcess.onProcessReady((e) => {
+                this.shellProcessId = e.pid;
+                this._initialCwd = e.cwd;
+                this._onDidChangeProperty.fire({ type: "initialCwd" , value: this._initialCwd });
+                this._onProcessReady.fire(e);
+                if (this._preLaunchInputQueue.length > 0 && this._process) {
+                    newProcess.input(this._preLaunchInputQueue.join(''));
+                    this._preLaunchInputQueue.length = 0;
+                }
+            }),
+            newProcess.onProcessExit(exitCode => this._onExit(exitCode)),
+            newProcess.onDidChangeProperty(({ type, value }) => {
+                switch (type) {
+                    case "hasChildProcesses" :
+                        this._hasChildProcesses = value;
+                        break;
+                    case "failedShellIntegrationActivation" :
+                        this._telemetryService?.publicLog2('terminal/shellIntegrationActivationFailureCustomArgs');
+                        break;
+                }
+                this._onDidChangeProperty.fire({ type, value });
+            })
+        ];
+        if (newProcess.onRestoreCommands) {
+            this._processListeners.push(newProcess.onRestoreCommands(e => {
+                this._onRestoreCommands.fire(e);
+            }));
+        }
+        setTimeout(() => {
+            if (this.processState === 2 ) {
+                this._setProcessState(3 );
+            }
+        }, 500 );
+        const result = await newProcess.start();
+        if (result) {
+            return result;
+        }
+        return undefined;
+    }
+    async relaunch(shellLaunchConfig, cols, rows, reset) {
+        this.ptyProcessReady = this._createPtyProcessReadyPromise();
+        this._logService.trace(`Relaunching terminal instance ${this._instanceId}`);
+        if (this._isDisconnected) {
+            this._isDisconnected = false;
+            this._onPtyReconnect.fire();
+        }
+        this._hasWrittenData = false;
+        return this.createProcess(shellLaunchConfig, cols, rows, reset);
+    }
+    async _resolveEnvironment(backend, variableResolver, shellLaunchConfig) {
+        const workspaceFolder = getWorkspaceForTerminal(shellLaunchConfig.cwd, this._workspaceContextService, this._historyService);
+        const platformKey = isWindows ? 'windows' : (isMacintosh ? 'osx' : 'linux');
+        const envFromConfigValue = this._configurationService.getValue(`terminal.integrated.env.${platformKey}`);
+        this._configHelper.showRecommendations(shellLaunchConfig);
+        let baseEnv;
+        if (shellLaunchConfig.useShellEnvironment) {
+            baseEnv = await backend.getShellEnvironment();
+        }
+        else {
+            baseEnv = await this._terminalProfileResolverService.getEnvironment(this.remoteAuthority);
+        }
+        const env = await createTerminalEnvironment(shellLaunchConfig, envFromConfigValue, variableResolver, this._productService.version, this._configHelper.config.detectLocale, baseEnv);
+        if (!this._isDisposed && !shellLaunchConfig.strictEnv && !shellLaunchConfig.hideFromUser) {
+            this._extEnvironmentVariableCollection = this._environmentVariableService.mergedCollection;
+            this._register(this._environmentVariableService.onDidChangeCollections(newCollection => this._onEnvironmentVariableCollectionChange(newCollection)));
+            await this._extEnvironmentVariableCollection.applyToProcessEnvironment(env, { workspaceFolder }, variableResolver);
+            if (this._extEnvironmentVariableCollection.getVariableMap({ workspaceFolder }).size) {
+                this.environmentVariableInfo = this._instantiationService.createInstance(EnvironmentVariableInfoChangesActive, this._extEnvironmentVariableCollection);
+                this._onEnvironmentVariableInfoChange.fire(this.environmentVariableInfo);
+            }
+        }
+        return env;
+    }
+    async _launchLocalProcess(backend, shellLaunchConfig, cols, rows, userHome, variableResolver) {
+        await this._terminalProfileResolverService.resolveShellLaunchConfig(shellLaunchConfig, {
+            remoteAuthority: undefined,
+            os: OS
+        });
+        const activeWorkspaceRootUri = this._historyService.getLastActiveWorkspaceRoot(Schemas.file);
+        const initialCwd = await getCwd(shellLaunchConfig, userHome, variableResolver, activeWorkspaceRootUri, this._configHelper.config.cwd, this._logService);
+        const env = await this._resolveEnvironment(backend, variableResolver, shellLaunchConfig);
+        const options = {
+            shellIntegration: {
+                enabled: this._configurationService.getValue("terminal.integrated.shellIntegration.enabled" ),
+                suggestEnabled: this._configurationService.getValue("terminal.integrated.shellIntegration.suggestEnabled" ),
+                nonce: this.shellIntegrationNonce
+            },
+            windowsEnableConpty: this._configHelper.config.windowsEnableConpty,
+            environmentVariableCollections: this._extEnvironmentVariableCollection ? serializeEnvironmentVariableCollections(this._extEnvironmentVariableCollection.collections) : undefined,
+            workspaceFolder: this._cwdWorkspaceFolder,
+        };
+        const shouldPersist = ((this._configurationService.getValue("task.reconnection" ) && shellLaunchConfig.reconnectionProperties) || !shellLaunchConfig.isFeatureTerminal) && this._configHelper.config.enablePersistentSessions && !shellLaunchConfig.isTransient;
+        return await backend.createProcess(shellLaunchConfig, initialCwd, cols, rows, this._configHelper.config.unicodeVersion, env, options, shouldPersist);
+    }
+    _setupPtyHostListeners(backend) {
+        if (this._ptyListenersAttached) {
+            return;
+        }
+        this._ptyListenersAttached = true;
+        this._register(backend.onPtyHostUnresponsive(() => {
+            this._isDisconnected = true;
+            this._onPtyDisconnect.fire();
+        }));
+        this._ptyResponsiveListener = backend.onPtyHostResponsive(() => {
+            this._isDisconnected = false;
+            this._onPtyReconnect.fire();
+        });
+        this._register(toDisposable(() => this._ptyResponsiveListener?.dispose()));
+        this._register(backend.onPtyHostRestart(async () => {
+            if (!this._isDisconnected) {
+                this._isDisconnected = true;
+                this._onPtyDisconnect.fire();
+            }
+            this._ptyResponsiveListener?.dispose();
+            this._ptyResponsiveListener = undefined;
+            if (this._shellLaunchConfig) {
+                if (this._shellLaunchConfig.isFeatureTerminal && !this.reconnectionProperties) {
+                    this._onExit(-1);
+                }
+                else {
+                    const message = ( localize(
+                        'ptyHostRelaunch',
+                        "Restarting the terminal because the connection to the shell process was lost..."
+                    ));
+                    this._onProcessData.fire({ data: formatMessageForTerminal(message, { loudFormatting: true }), trackCommit: false });
+                    await this.relaunch(this._shellLaunchConfig, this._dimensions.cols, this._dimensions.rows, false);
+                }
+            }
+        }));
+    }
+    async getBackendOS() {
+        let os = OS;
+        if (!!this.remoteAuthority) {
+            const remoteEnv = await this._remoteAgentService.getEnvironment();
+            if (!remoteEnv) {
+                throw new Error(`Failed to get remote environment for remote authority "${this.remoteAuthority}"`);
+            }
+            os = remoteEnv.os;
+        }
+        return os;
+    }
+    setDimensions(cols, rows, sync) {
+        if (sync) {
+            this._resize(cols, rows);
+            return;
+        }
+        return this.ptyProcessReady.then(() => this._resize(cols, rows));
+    }
+    async setUnicodeVersion(version) {
+        return this._process?.setUnicodeVersion(version);
+    }
+    _resize(cols, rows) {
+        if (!this._process) {
+            return;
+        }
+        try {
+            this._process.resize(cols, rows);
+        }
+        catch (error) {
+            if (error.code !== 'EPIPE' && error.code !== 'ERR_IPC_CHANNEL_CLOSED') {
+                throw (error);
+            }
+        }
+        this._dimensions.cols = cols;
+        this._dimensions.rows = rows;
+    }
+    async write(data) {
+        await this.ptyProcessReady;
+        this._dataFilter.disableSeamlessRelaunch();
+        this._hasWrittenData = true;
+        if (this.shellProcessId || this._processType === 1 ) {
+            if (this._process) {
+                this._process.input(data);
+            }
+        }
+        else {
+            this._preLaunchInputQueue.push(data);
+        }
+    }
+    async processBinary(data) {
+        await this.ptyProcessReady;
+        this._dataFilter.disableSeamlessRelaunch();
+        this._hasWrittenData = true;
+        this._process?.processBinary(data);
+    }
+    get initialCwd() {
+        return this._initialCwd ?? '';
+    }
+    async getLatency() {
+        await this.ptyProcessReady;
+        if (!this._process) {
+            return Promise.resolve(0);
+        }
+        if (this._latencyLastMeasured === 0 || this._latencyLastMeasured + 1000  < Date.now()) {
+            const latencyRequest = this._process.getLatency();
+            this._latency = await latencyRequest;
+            this._latencyLastMeasured = Date.now();
+        }
+        return Promise.resolve(this._latency);
+    }
+    async refreshProperty(type) {
+        if (!this._process) {
+            throw new Error('Cannot refresh property when process is not set');
+        }
+        return this._process.refreshProperty(type);
+    }
+    async updateProperty(type, value) {
+        return this._process?.updateProperty(type, value);
+    }
+    acknowledgeDataEvent(charCount) {
+        this._ackDataBufferer.ack(charCount);
+    }
+    _onExit(exitCode) {
+        this._process = null;
+        if (this.processState === 2 ) {
+            this._setProcessState(4 );
+        }
+        if (this.processState === 3 ) {
+            this._setProcessState(6 );
+        }
+        this._onProcessExit.fire(exitCode);
+    }
+    _setProcessState(state) {
+        this.processState = state;
+        this._onProcessStateChange.fire();
+    }
+    _onEnvironmentVariableCollectionChange(newCollection) {
+        const diff = this._extEnvironmentVariableCollection.diff(newCollection, { workspaceFolder: this._cwdWorkspaceFolder });
+        if (diff === undefined) {
+            if (this.environmentVariableInfo instanceof EnvironmentVariableInfoStale) {
+                this.environmentVariableInfo = this._instantiationService.createInstance(EnvironmentVariableInfoChangesActive, this._extEnvironmentVariableCollection);
+                this._onEnvironmentVariableInfoChange.fire(this.environmentVariableInfo);
+            }
+            return;
+        }
+        this.environmentVariableInfo = this._instantiationService.createInstance(EnvironmentVariableInfoStale, diff, this._instanceId, newCollection);
+        this._onEnvironmentVariableInfoChange.fire(this.environmentVariableInfo);
+    }
+};
+TerminalProcessManager = ( __decorate([
+    ( __param(5, IHistoryService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, ILogService)),
+    ( __param(8, IWorkspaceContextService)),
+    ( __param(9, IConfigurationResolverService)),
+    ( __param(10, IWorkbenchEnvironmentService)),
+    ( __param(11, IProductService)),
+    ( __param(12, IRemoteAgentService)),
+    ( __param(13, IPathService)),
+    ( __param(14, IEnvironmentVariableService)),
+    ( __param(15, ITerminalProfileResolverService)),
+    ( __param(16, IConfigurationService)),
+    ( __param(17, ITerminalInstanceService)),
+    ( __param(18, ITelemetryService)),
+    ( __param(19, INotificationService))
+], TerminalProcessManager));
+class AckDataBufferer {
+    constructor(_callback) {
+        this._callback = _callback;
+        this._unsentCharCount = 0;
+    }
+    ack(charCount) {
+        this._unsentCharCount += charCount;
+        while (this._unsentCharCount > 5000 ) {
+            this._unsentCharCount -= 5000 ;
+            this._callback(5000 );
+        }
+    }
+}
+let SeamlessRelaunchDataFilter = class SeamlessRelaunchDataFilter extends Disposable {
+    get onProcessData() { return this._onProcessData.event; }
+    constructor(_logService) {
+        super();
+        this._logService = _logService;
+        this._disableSeamlessRelaunch = false;
+        this._onProcessData = this._register(( new Emitter()));
+    }
+    newProcess(process, reset) {
+        this._dataListener?.dispose();
+        this._activeProcess?.shutdown(false);
+        this._activeProcess = process;
+        if (!this._firstRecorder || !reset || this._disableSeamlessRelaunch) {
+            this._firstDisposable?.dispose();
+            [this._firstRecorder, this._firstDisposable] = this._createRecorder(process);
+            if (this._disableSeamlessRelaunch && reset) {
+                this._onProcessData.fire('\x1bc');
+            }
+            this._dataListener = process.onProcessData(e => this._onProcessData.fire(e));
+            this._disableSeamlessRelaunch = false;
+            return;
+        }
+        if (this._secondRecorder) {
+            this.triggerSwap();
+        }
+        this._swapTimeout = window.setTimeout(() => this.triggerSwap(), 3000 );
+        this._dataListener?.dispose();
+        this._firstDisposable?.dispose();
+        const recorder = this._createRecorder(process);
+        [this._secondRecorder, this._secondDisposable] = recorder;
+    }
+    disableSeamlessRelaunch() {
+        this._disableSeamlessRelaunch = true;
+        this._stopRecording();
+        this.triggerSwap();
+    }
+    triggerSwap() {
+        if (this._swapTimeout) {
+            window.clearTimeout(this._swapTimeout);
+            this._swapTimeout = undefined;
+        }
+        if (!this._firstRecorder) {
+            return;
+        }
+        if (!this._secondRecorder) {
+            this._firstRecorder = undefined;
+            this._firstDisposable?.dispose();
+            return;
+        }
+        const firstData = this._getDataFromRecorder(this._firstRecorder);
+        const secondData = this._getDataFromRecorder(this._secondRecorder);
+        if (firstData === secondData) {
+            this._logService.trace(`Seamless terminal relaunch - identical content`);
+        }
+        else {
+            this._logService.trace(`Seamless terminal relaunch - resetting content`);
+            this._onProcessData.fire({ data: `\x1bc${secondData}`, trackCommit: false });
+        }
+        this._dataListener?.dispose();
+        this._dataListener = this._activeProcess.onProcessData(e => this._onProcessData.fire(e));
+        this._firstRecorder = this._secondRecorder;
+        this._firstDisposable?.dispose();
+        this._firstDisposable = this._secondDisposable;
+        this._secondRecorder = undefined;
+    }
+    _stopRecording() {
+        if (this._swapTimeout) {
+            return;
+        }
+        this._firstRecorder = undefined;
+        this._firstDisposable?.dispose();
+        this._secondRecorder = undefined;
+        this._secondDisposable?.dispose();
+    }
+    _createRecorder(process) {
+        const recorder = ( new TerminalRecorder(0, 0));
+        const disposable = process.onProcessData(e => recorder.handleData(typeof e === 'string' ? e : e.data));
+        return [recorder, disposable];
+    }
+    _getDataFromRecorder(recorder) {
+        return ( recorder.generateReplayEventSync().events.filter(e => !!e.data).map(e => e.data)).join('');
+    }
+};
+SeamlessRelaunchDataFilter = ( __decorate([
+    ( __param(0, ILogService))
+], SeamlessRelaunchDataFilter));
+export { TerminalProcessManager };