@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/terminal/common/history.js

@@ -0,0 +1,375 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { env } from '../../../../base/common/process.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { LRUCache } from '../../../../base/common/map.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IFileService, FileOperationError } from '../../../../platform/files/common/files.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { URI } from '../../../../base/common/uri.js';
+import { IRemoteAgentService } from '../../../services/remote/common/remoteAgentService.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { isWindows } from '../../../../base/common/platform.js';
+import { win32, posix } from '../../../../base/common/path.js';
+let commandHistory = undefined;
+function getCommandHistory(accessor) {
+    if (!commandHistory) {
+        commandHistory = accessor.get(IInstantiationService).createInstance(TerminalPersistedHistory, 'commands');
+    }
+    return commandHistory;
+}
+let directoryHistory = undefined;
+function getDirectoryHistory(accessor) {
+    if (!directoryHistory) {
+        directoryHistory = accessor.get(IInstantiationService).createInstance(TerminalPersistedHistory, 'dirs');
+    }
+    return directoryHistory;
+}
+const shellFileHistory = ( new Map());
+async function getShellFileHistory(accessor, shellType) {
+    const cached = shellFileHistory.get(shellType);
+    if (cached === null) {
+        return [];
+    }
+    if (cached !== undefined) {
+        return cached;
+    }
+    let result;
+    switch (shellType) {
+        case "bash" :
+            result = await fetchBashHistory(accessor);
+            break;
+        case "pwsh" :
+            result = await fetchPwshHistory(accessor);
+            break;
+        case "zsh" :
+            result = await fetchZshHistory(accessor);
+            break;
+        case "fish" :
+            result = await fetchFishHistory(accessor);
+            break;
+        case "python" :
+            result = await fetchPythonHistory(accessor);
+            break;
+        default: return [];
+    }
+    if (result === undefined) {
+        shellFileHistory.set(shellType, null);
+        return [];
+    }
+    const array = Array.from(result);
+    shellFileHistory.set(shellType, array);
+    return array;
+}
+function clearShellFileHistory() {
+    shellFileHistory.clear();
+}
+let TerminalPersistedHistory = class TerminalPersistedHistory extends Disposable {
+    get entries() {
+        this._ensureUpToDate();
+        return this._entries.entries();
+    }
+    constructor(_storageDataKey, _configurationService, _storageService) {
+        super();
+        this._storageDataKey = _storageDataKey;
+        this._configurationService = _configurationService;
+        this._storageService = _storageService;
+        this._timestamp = 0;
+        this._isReady = false;
+        this._isStale = true;
+        this._entries = ( new LRUCache(this._getHistoryLimit()));
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("terminal.integrated.shellIntegration.history" )) {
+                this._entries.limit = this._getHistoryLimit();
+            }
+        }));
+        this._register(this._storageService.onDidChangeValue(-1 , this._getTimestampStorageKey(), this._store)(() => {
+            if (!this._isStale) {
+                this._isStale = this._storageService.getNumber(this._getTimestampStorageKey(), -1 , 0) !== this._timestamp;
+            }
+        }));
+    }
+    add(key, value) {
+        this._ensureUpToDate();
+        this._entries.set(key, value);
+        this._saveState();
+    }
+    remove(key) {
+        this._ensureUpToDate();
+        this._entries.delete(key);
+        this._saveState();
+    }
+    clear() {
+        this._ensureUpToDate();
+        this._entries.clear();
+        this._saveState();
+    }
+    _ensureUpToDate() {
+        if (!this._isReady) {
+            this._loadState();
+            this._isReady = true;
+        }
+        if (this._isStale) {
+            this._entries.clear();
+            this._loadState();
+            this._isStale = false;
+        }
+    }
+    _loadState() {
+        this._timestamp = this._storageService.getNumber(this._getTimestampStorageKey(), -1 , 0);
+        const serialized = this._loadPersistedState();
+        if (serialized) {
+            for (const entry of serialized.entries) {
+                this._entries.set(entry.key, entry.value);
+            }
+        }
+    }
+    _loadPersistedState() {
+        const raw = this._storageService.get(this._getEntriesStorageKey(), -1 );
+        if (raw === undefined || raw.length === 0) {
+            return undefined;
+        }
+        let serialized = undefined;
+        try {
+            serialized = JSON.parse(raw);
+        }
+        catch {
+            return undefined;
+        }
+        return serialized;
+    }
+    _saveState() {
+        const serialized = { entries: [] };
+        this._entries.forEach((value, key) => serialized.entries.push({ key, value }));
+        this._storageService.store(this._getEntriesStorageKey(), JSON.stringify(serialized), -1 , 1 );
+        this._timestamp = Date.now();
+        this._storageService.store(this._getTimestampStorageKey(), this._timestamp, -1 , 1 );
+    }
+    _getHistoryLimit() {
+        const historyLimit = this._configurationService.getValue("terminal.integrated.shellIntegration.history" );
+        return typeof historyLimit === 'number' ? historyLimit : 100 ;
+    }
+    _getTimestampStorageKey() {
+        return `${"terminal.history.timestamp" }.${this._storageDataKey}`;
+    }
+    _getEntriesStorageKey() {
+        return `${"terminal.history.entries" }.${this._storageDataKey}`;
+    }
+};
+TerminalPersistedHistory = ( __decorate([
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IStorageService))
+], TerminalPersistedHistory));
+async function fetchBashHistory(accessor) {
+    const fileService = accessor.get(IFileService);
+    const remoteAgentService = accessor.get(IRemoteAgentService);
+    const remoteEnvironment = await remoteAgentService.getEnvironment();
+    if (remoteEnvironment?.os === 1  || !remoteEnvironment && isWindows) {
+        return undefined;
+    }
+    const content = await fetchFileContents(env['HOME'], '.bash_history', false, fileService, remoteAgentService);
+    if (content === undefined) {
+        return undefined;
+    }
+    const fileLines = content.split('\n');
+    const result = ( new Set());
+    let currentLine;
+    let currentCommand = undefined;
+    let wrapChar = undefined;
+    for (let i = 0; i < fileLines.length; i++) {
+        currentLine = fileLines[i];
+        if (currentCommand === undefined) {
+            currentCommand = currentLine;
+        }
+        else {
+            currentCommand += `\n${currentLine}`;
+        }
+        for (let c = 0; c < currentLine.length; c++) {
+            if (wrapChar) {
+                if (currentLine[c] === wrapChar) {
+                    wrapChar = undefined;
+                }
+            }
+            else {
+                if (currentLine[c].match(/['"]/)) {
+                    wrapChar = currentLine[c];
+                }
+            }
+        }
+        if (wrapChar === undefined) {
+            if (currentCommand.length > 0) {
+                result.add(currentCommand.trim());
+            }
+            currentCommand = undefined;
+        }
+    }
+    return ( result.values());
+}
+async function fetchZshHistory(accessor) {
+    const fileService = accessor.get(IFileService);
+    const remoteAgentService = accessor.get(IRemoteAgentService);
+    const remoteEnvironment = await remoteAgentService.getEnvironment();
+    if (remoteEnvironment?.os === 1  || !remoteEnvironment && isWindows) {
+        return undefined;
+    }
+    const content = await fetchFileContents(env['HOME'], '.zsh_history', false, fileService, remoteAgentService);
+    if (content === undefined) {
+        return undefined;
+    }
+    const fileLines = content.split(/\:\s\d+\:\d+;/);
+    const result = ( new Set());
+    for (let i = 0; i < fileLines.length; i++) {
+        const sanitized = fileLines[i].replace(/\\\n/g, '\n').trim();
+        if (sanitized.length > 0) {
+            result.add(sanitized);
+        }
+    }
+    return ( result.values());
+}
+async function fetchPythonHistory(accessor) {
+    const fileService = accessor.get(IFileService);
+    const remoteAgentService = accessor.get(IRemoteAgentService);
+    const content = await fetchFileContents(env['HOME'], '.python_history', false, fileService, remoteAgentService);
+    if (content === undefined) {
+        return undefined;
+    }
+    const fileLines = content.split('\n');
+    const result = ( new Set());
+    fileLines.forEach(line => {
+        if (line.trim().length > 0) {
+            result.add(line.trim());
+        }
+    });
+    return ( result.values());
+}
+async function fetchPwshHistory(accessor) {
+    const fileService = accessor.get(IFileService);
+    const remoteAgentService = accessor.get(IRemoteAgentService);
+    let folderPrefix;
+    let filePath;
+    const remoteEnvironment = await remoteAgentService.getEnvironment();
+    const isFileWindows = remoteEnvironment?.os === 1  || !remoteEnvironment && isWindows;
+    if (isFileWindows) {
+        folderPrefix = env['APPDATA'];
+        filePath = '\\Microsoft\\Windows\\PowerShell\\PSReadLine\\ConsoleHost_history.txt';
+    }
+    else {
+        folderPrefix = env['HOME'];
+        filePath = '.local/share/powershell/PSReadline/ConsoleHost_history.txt';
+    }
+    const content = await fetchFileContents(folderPrefix, filePath, isFileWindows, fileService, remoteAgentService);
+    if (content === undefined) {
+        return undefined;
+    }
+    const fileLines = content.split('\n');
+    const result = ( new Set());
+    let currentLine;
+    let currentCommand = undefined;
+    let wrapChar = undefined;
+    for (let i = 0; i < fileLines.length; i++) {
+        currentLine = fileLines[i];
+        if (currentCommand === undefined) {
+            currentCommand = currentLine;
+        }
+        else {
+            currentCommand += `\n${currentLine}`;
+        }
+        if (!currentLine.endsWith('`')) {
+            const sanitized = currentCommand.trim();
+            if (sanitized.length > 0) {
+                result.add(sanitized);
+            }
+            currentCommand = undefined;
+            continue;
+        }
+        for (let c = 0; c < currentLine.length; c++) {
+            if (wrapChar) {
+                if (currentLine[c] === wrapChar) {
+                    wrapChar = undefined;
+                }
+            }
+            else {
+                if (currentLine[c].match(/`/)) {
+                    wrapChar = currentLine[c];
+                }
+            }
+        }
+        if (!wrapChar) {
+            const sanitized = currentCommand.trim();
+            if (sanitized.length > 0) {
+                result.add(sanitized);
+            }
+            currentCommand = undefined;
+        }
+        else {
+            currentCommand = currentCommand.replace(/`$/, '');
+            wrapChar = undefined;
+        }
+    }
+    return ( result.values());
+}
+async function fetchFishHistory(accessor) {
+    const fileService = accessor.get(IFileService);
+    const remoteAgentService = accessor.get(IRemoteAgentService);
+    const remoteEnvironment = await remoteAgentService.getEnvironment();
+    if (remoteEnvironment?.os === 1  || !remoteEnvironment && isWindows) {
+        return undefined;
+    }
+    const overridenDataHome = env['XDG_DATA_HOME'];
+    const content = await (overridenDataHome
+        ? fetchFileContents(env['XDG_DATA_HOME'], 'fish/fish_history', false, fileService, remoteAgentService)
+        : fetchFileContents(env['HOME'], '.local/share/fish/fish_history', false, fileService, remoteAgentService));
+    if (content === undefined) {
+        return undefined;
+    }
+    const result = ( new Set());
+    const cmds = ( content.split('\n')
+        .filter(x => x.startsWith('- cmd:'))
+        .map(x => x.substring(6).trimStart()));
+    for (let i = 0; i < cmds.length; i++) {
+        const sanitized = sanitizeFishHistoryCmd(cmds[i]).trim();
+        if (sanitized.length > 0) {
+            result.add(sanitized);
+        }
+    }
+    return ( result.values());
+}
+function sanitizeFishHistoryCmd(cmd) {
+    return repeatedReplace(/(^|[^\\])((?:\\\\)*)(\\n)/g, cmd, '$1$2\n');
+}
+function repeatedReplace(pattern, value, replaceValue) {
+    let last;
+    let current = value;
+    while (true) {
+        last = current;
+        current = current.replace(pattern, replaceValue);
+        if (current === last) {
+            return current;
+        }
+    }
+}
+async function fetchFileContents(folderPrefix, filePath, isFileWindows, fileService, remoteAgentService) {
+    if (!folderPrefix) {
+        return undefined;
+    }
+    const isRemote = !!remoteAgentService.getConnection()?.remoteAuthority;
+    const historyFileUri = ( URI.from({
+        scheme: isRemote ? Schemas.vscodeRemote : Schemas.file,
+        path: (isFileWindows ? win32.join : posix.join)(folderPrefix, filePath)
+    }));
+    let content;
+    try {
+        content = await fileService.readFile(historyFileUri);
+    }
+    catch (e) {
+        if (e instanceof FileOperationError && e.fileOperationResult === 1 ) {
+            return undefined;
+        }
+        throw e;
+    }
+    if (content === undefined) {
+        return undefined;
+    }
+    return ( content.value.toString());
+}
+export { TerminalPersistedHistory, clearShellFileHistory, fetchBashHistory, fetchFishHistory, fetchPwshHistory, fetchPythonHistory, fetchZshHistory, getCommandHistory, getDirectoryHistory, getShellFileHistory, sanitizeFishHistoryCmd };

package/vscode/src/vs/workbench/contrib/terminal/common/remote/remoteTerminalChannel.js

@@ -0,0 +1,253 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { IWorkbenchConfigurationService } from '../../../../services/configuration/common/configuration.js';
+import { IRemoteAuthorityResolverService } from '../../../../../platform/remote/common/remoteAuthorityResolver.js';
+import { IWorkspaceContextService } from '../../../../../platform/workspace/common/workspace.js';
+import { serializeEnvironmentVariableCollection, serializeEnvironmentDescriptionMap } from '../../../../../platform/terminal/common/environmentVariableShared.js';
+import { IConfigurationResolverService } from '../../../../services/configurationResolver/common/configurationResolver.js';
+import { EditorResourceAccessor, SideBySideEditor } from '../../../../common/editor.js';
+import { IEditorService } from '../../../../services/editor/common/editorService.js';
+import { Schemas } from '../../../../../base/common/network.js';
+import { ILabelService } from '../../../../../platform/label/common/label.js';
+import { IEnvironmentVariableService } from '../environmentVariable.js';
+import { ITerminalLogService } from '../../../../../platform/terminal/common/terminal.js';
+const REMOTE_TERMINAL_CHANNEL_NAME = 'remoteterminal';
+let RemoteTerminalChannelClient = class RemoteTerminalChannelClient {
+    get onPtyHostExit() {
+        return this._channel.listen("$onPtyHostExitEvent" );
+    }
+    get onPtyHostStart() {
+        return this._channel.listen("$onPtyHostStartEvent" );
+    }
+    get onPtyHostUnresponsive() {
+        return this._channel.listen("$onPtyHostUnresponsiveEvent" );
+    }
+    get onPtyHostResponsive() {
+        return this._channel.listen("$onPtyHostResponsiveEvent" );
+    }
+    get onPtyHostRequestResolveVariables() {
+        return this._channel.listen("$onPtyHostRequestResolveVariablesEvent" );
+    }
+    get onProcessData() {
+        return this._channel.listen("$onProcessDataEvent" );
+    }
+    get onProcessExit() {
+        return this._channel.listen("$onProcessExitEvent" );
+    }
+    get onProcessReady() {
+        return this._channel.listen("$onProcessReadyEvent" );
+    }
+    get onProcessReplay() {
+        return this._channel.listen("$onProcessReplayEvent" );
+    }
+    get onProcessOrphanQuestion() {
+        return this._channel.listen("$onProcessOrphanQuestion" );
+    }
+    get onExecuteCommand() {
+        return this._channel.listen("$onExecuteCommand" );
+    }
+    get onDidRequestDetach() {
+        return this._channel.listen("$onDidRequestDetach" );
+    }
+    get onDidChangeProperty() {
+        return this._channel.listen("$onDidChangeProperty" );
+    }
+    constructor(_remoteAuthority, _channel, _configurationService, _workspaceContextService, _resolverService, _environmentVariableService, _remoteAuthorityResolverService, _logService, _editorService, _labelService) {
+        this._remoteAuthority = _remoteAuthority;
+        this._channel = _channel;
+        this._configurationService = _configurationService;
+        this._workspaceContextService = _workspaceContextService;
+        this._resolverService = _resolverService;
+        this._environmentVariableService = _environmentVariableService;
+        this._remoteAuthorityResolverService = _remoteAuthorityResolverService;
+        this._logService = _logService;
+        this._editorService = _editorService;
+        this._labelService = _labelService;
+    }
+    restartPtyHost() {
+        return this._channel.call("$restartPtyHost" , []);
+    }
+    async createProcess(shellLaunchConfig, configuration, activeWorkspaceRootUri, options, shouldPersistTerminal, cols, rows, unicodeVersion) {
+        await this._configurationService.whenRemoteConfigurationLoaded();
+        const resolvedVariables = Object.create(null);
+        const lastActiveWorkspace = activeWorkspaceRootUri ? this._workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri) ?? undefined : undefined;
+        let allResolvedVariables = undefined;
+        try {
+            allResolvedVariables = (await this._resolverService.resolveAnyMap(lastActiveWorkspace, {
+                shellLaunchConfig,
+                configuration
+            })).resolvedVariables;
+        }
+        catch (err) {
+            this._logService.error(err);
+        }
+        if (allResolvedVariables) {
+            for (const [name, value] of allResolvedVariables.entries()) {
+                if (/^config:/.test(name) || name === 'selectedText' || name === 'lineNumber') {
+                    resolvedVariables[name] = value;
+                }
+            }
+        }
+        const envVariableCollections = [];
+        for (const [k, v] of this._environmentVariableService.collections.entries()) {
+            envVariableCollections.push([k, serializeEnvironmentVariableCollection(v.map), serializeEnvironmentDescriptionMap(v.descriptionMap)]);
+        }
+        const resolverResult = await this._remoteAuthorityResolverService.resolveAuthority(this._remoteAuthority);
+        const resolverEnv = resolverResult.options && resolverResult.options.extensionHostEnv;
+        const workspace = this._workspaceContextService.getWorkspace();
+        const workspaceFolders = workspace.folders;
+        const activeWorkspaceFolder = activeWorkspaceRootUri ? this._workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri) : null;
+        const activeFileResource = EditorResourceAccessor.getOriginalUri(this._editorService.activeEditor, {
+            supportSideBySide: SideBySideEditor.PRIMARY,
+            filterByScheme: [Schemas.file, Schemas.vscodeUserData, Schemas.vscodeRemote]
+        });
+        const args = {
+            configuration,
+            resolvedVariables,
+            envVariableCollections,
+            shellLaunchConfig,
+            workspaceId: workspace.id,
+            workspaceName: this._labelService.getWorkspaceLabel(workspace),
+            workspaceFolders,
+            activeWorkspaceFolder,
+            activeFileResource,
+            shouldPersistTerminal,
+            options,
+            cols,
+            rows,
+            unicodeVersion,
+            resolverEnv
+        };
+        return await this._channel.call("$createProcess" , args);
+    }
+    requestDetachInstance(workspaceId, instanceId) {
+        return this._channel.call("$requestDetachInstance" , [workspaceId, instanceId]);
+    }
+    acceptDetachInstanceReply(requestId, persistentProcessId) {
+        return this._channel.call("$acceptDetachInstanceReply" , [requestId, persistentProcessId]);
+    }
+    attachToProcess(id) {
+        return this._channel.call("$attachToProcess" , [id]);
+    }
+    detachFromProcess(id, forcePersist) {
+        return this._channel.call("$detachFromProcess" , [id, forcePersist]);
+    }
+    listProcesses() {
+        return this._channel.call("$listProcesses" );
+    }
+    getLatency() {
+        return this._channel.call("$getLatency" );
+    }
+    getPerformanceMarks() {
+        return this._channel.call("$getPerformanceMarks" );
+    }
+    reduceConnectionGraceTime() {
+        return this._channel.call("$reduceConnectionGraceTime" );
+    }
+    processBinary(id, data) {
+        return this._channel.call("$processBinary" , [id, data]);
+    }
+    start(id) {
+        return this._channel.call("$start" , [id]);
+    }
+    input(id, data) {
+        return this._channel.call("$input" , [id, data]);
+    }
+    acknowledgeDataEvent(id, charCount) {
+        return this._channel.call("$acknowledgeDataEvent" , [id, charCount]);
+    }
+    setUnicodeVersion(id, version) {
+        return this._channel.call("$setUnicodeVersion" , [id, version]);
+    }
+    shutdown(id, immediate) {
+        return this._channel.call("$shutdown" , [id, immediate]);
+    }
+    resize(id, cols, rows) {
+        return this._channel.call("$resize" , [id, cols, rows]);
+    }
+    clearBuffer(id) {
+        return this._channel.call("$clearBuffer" , [id]);
+    }
+    getInitialCwd(id) {
+        return this._channel.call("$getInitialCwd" , [id]);
+    }
+    getCwd(id) {
+        return this._channel.call("$getCwd" , [id]);
+    }
+    orphanQuestionReply(id) {
+        return this._channel.call("$orphanQuestionReply" , [id]);
+    }
+    sendCommandResult(reqId, isError, payload) {
+        return this._channel.call("$sendCommandResult" , [reqId, isError, payload]);
+    }
+    freePortKillProcess(port) {
+        return this._channel.call("$freePortKillProcess" , [port]);
+    }
+    installAutoReply(match, reply) {
+        return this._channel.call("$installAutoReply" , [match, reply]);
+    }
+    uninstallAllAutoReplies() {
+        return this._channel.call("$uninstallAllAutoReplies" , []);
+    }
+    getDefaultSystemShell(osOverride) {
+        return this._channel.call("$getDefaultSystemShell" , [osOverride]);
+    }
+    getProfiles(profiles, defaultProfile, includeDetectedProfiles) {
+        return this._channel.call("$getProfiles" , [this._workspaceContextService.getWorkspace().id, profiles, defaultProfile, includeDetectedProfiles]);
+    }
+    acceptPtyHostResolvedVariables(requestId, resolved) {
+        return this._channel.call("$acceptPtyHostResolvedVariables" , [requestId, resolved]);
+    }
+    getEnvironment() {
+        return this._channel.call("$getEnvironment" );
+    }
+    getWslPath(original, direction) {
+        return this._channel.call("$getWslPath" , [original, direction]);
+    }
+    setTerminalLayoutInfo(layout) {
+        const workspace = this._workspaceContextService.getWorkspace();
+        const args = {
+            workspaceId: workspace.id,
+            tabs: layout ? layout.tabs : []
+        };
+        return this._channel.call("$setTerminalLayoutInfo" , args);
+    }
+    updateTitle(id, title, titleSource) {
+        return this._channel.call("$updateTitle" , [id, title, titleSource]);
+    }
+    updateIcon(id, userInitiated, icon, color) {
+        return this._channel.call("$updateIcon" , [id, userInitiated, icon, color]);
+    }
+    refreshProperty(id, property) {
+        return this._channel.call("$refreshProperty" , [id, property]);
+    }
+    updateProperty(id, property, value) {
+        return this._channel.call("$updateProperty" , [id, property, value]);
+    }
+    getTerminalLayoutInfo() {
+        const workspace = this._workspaceContextService.getWorkspace();
+        const args = {
+            workspaceId: workspace.id,
+        };
+        return this._channel.call("$getTerminalLayoutInfo" , args);
+    }
+    reviveTerminalProcesses(workspaceId, state, dateTimeFormatLocate) {
+        return this._channel.call("$reviveTerminalProcesses" , [workspaceId, state, dateTimeFormatLocate]);
+    }
+    getRevivedPtyNewId(id) {
+        return this._channel.call("$getRevivedPtyNewId" , [id]);
+    }
+    serializeTerminalState(ids) {
+        return this._channel.call("$serializeTerminalState" , [ids]);
+    }
+};
+RemoteTerminalChannelClient = ( __decorate([
+    ( __param(2, IWorkbenchConfigurationService)),
+    ( __param(3, IWorkspaceContextService)),
+    ( __param(4, IConfigurationResolverService)),
+    ( __param(5, IEnvironmentVariableService)),
+    ( __param(6, IRemoteAuthorityResolverService)),
+    ( __param(7, ITerminalLogService)),
+    ( __param(8, IEditorService)),
+    ( __param(9, ILabelService))
+], RemoteTerminalChannelClient));
+export { REMOTE_TERMINAL_CHANNEL_NAME, RemoteTerminalChannelClient };