@codingame/monaco-vscode-api 1.82.4-next.1 → 1.82.5-next.0

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

@@ -1,617 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/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 { 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 { ITerminalLogService } from '../../../../platform/terminal/common/terminal.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';
-import { runWhenIdle } from 'monaco-editor/esm/vs/base/common/async.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._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._onProcessReplayComplete = this._register(( (new Emitter())));
-        this.onProcessReplayComplete = this._onProcessReplayComplete.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._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.onProcessReplayComplete) {
-            this._processListeners.push(newProcess.onProcessReplayComplete(() => this._onProcessReplayComplete.fire()));
-        }
-        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;
-        }
-        runWhenIdle(() => {
-            this.backend?.getLatency().then(measurements => {
-                this._logService.info(`Latency measurements for ${this.remoteAuthority ?? 'local'} backend\n${( ( measurements.map(e => `${e.label}: ${e.latency.toFixed(2)}ms`))).join('\n')}`);
-            });
-        });
-        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 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);
-    }
-    async clearBuffer() {
-        this._process?.clearBuffer?.();
-    }
-};
-TerminalProcessManager = ( (__decorate([
-    ( (__param(5, IHistoryService))),
-    ( (__param(6, IInstantiationService))),
-    ( (__param(7, ITerminalLogService))),
-    ( (__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, ITerminalLogService)))
-], SeamlessRelaunchDataFilter)));
-export { TerminalProcessManager };