@codingame/monaco-vscode-api 4.0.0 → 4.1.0

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

@@ -0,0 +1,312 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { DeferredPromise } from '../../../../base/common/async.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { revive } from '../../../../base/common/marshalling.js';
+import { mark } from '../../../../base/common/performance.js';
+import { StopWatch } from '../../../../base/common/stopwatch.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { IRemoteAuthorityResolverService } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { TerminalExtensions, ITerminalLogService } from '../../../../platform/terminal/common/terminal.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { BaseTerminalBackend } from './baseTerminalBackend.js';
+import { RemotePty } from './remotePty.js';
+import { ITerminalInstanceService } from './terminal.js';
+import { RemoteTerminalChannelClient, REMOTE_TERMINAL_CHANNEL_NAME } from '../common/remote/remoteTerminalChannel.js';
+import { TERMINAL_CONFIG_SECTION } from '../common/terminal.js';
+import { IConfigurationResolverService } from '../../../services/configurationResolver/common/configurationResolver.js';
+import { IHistoryService } from '../../../services/history/common/history.js';
+import { IRemoteAgentService } from '../../../services/remote/common/remoteAgentService.js';
+import { IStatusbarService } from '../../../services/statusbar/browser/statusbar.js';
+let RemoteTerminalBackendContribution = class RemoteTerminalBackendContribution {
+    static { this.ID = 'remoteTerminalBackend'; }
+    constructor(instantiationService, remoteAgentService, terminalInstanceService) {
+        const connection = remoteAgentService.getConnection();
+        if (connection?.remoteAuthority) {
+            const channel = instantiationService.createInstance(RemoteTerminalChannelClient, connection.remoteAuthority, connection.getChannel(REMOTE_TERMINAL_CHANNEL_NAME));
+            const backend = instantiationService.createInstance(RemoteTerminalBackend, connection.remoteAuthority, channel);
+            ( Registry.as(TerminalExtensions.Backend)).registerTerminalBackend(backend);
+            terminalInstanceService.didRegisterBackend(backend.remoteAuthority);
+        }
+    }
+};
+RemoteTerminalBackendContribution = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IRemoteAgentService)),
+    ( __param(2, ITerminalInstanceService))
+], RemoteTerminalBackendContribution));
+let RemoteTerminalBackend = class RemoteTerminalBackend extends BaseTerminalBackend {
+    get whenReady() { return this._whenConnected.p; }
+    setReady() { this._whenConnected.complete(); }
+    constructor(remoteAuthority, _remoteTerminalChannel, _remoteAgentService, _instantiationService, logService, _commandService, _storageService, _remoteAuthorityResolverService, workspaceContextService, configurationResolverService, _historyService, _configurationService, statusBarService) {
+        super(_remoteTerminalChannel, logService, _historyService, configurationResolverService, statusBarService, workspaceContextService);
+        this.remoteAuthority = remoteAuthority;
+        this._remoteTerminalChannel = _remoteTerminalChannel;
+        this._remoteAgentService = _remoteAgentService;
+        this._instantiationService = _instantiationService;
+        this._commandService = _commandService;
+        this._storageService = _storageService;
+        this._remoteAuthorityResolverService = _remoteAuthorityResolverService;
+        this._historyService = _historyService;
+        this._configurationService = _configurationService;
+        this._ptys = ( new Map());
+        this._whenConnected = ( new DeferredPromise());
+        this._onDidRequestDetach = this._register(( new Emitter()));
+        this.onDidRequestDetach = this._onDidRequestDetach.event;
+        this._onRestoreCommands = this._register(( new Emitter()));
+        this.onRestoreCommands = this._onRestoreCommands.event;
+        this._remoteTerminalChannel.onProcessData(e => this._ptys.get(e.id)?.handleData(e.event));
+        this._remoteTerminalChannel.onProcessReplay(e => {
+            this._ptys.get(e.id)?.handleReplay(e.event);
+            if (e.event.commands.commands.length > 0) {
+                this._onRestoreCommands.fire({ id: e.id, commands: e.event.commands.commands });
+            }
+        });
+        this._remoteTerminalChannel.onProcessOrphanQuestion(e => this._ptys.get(e.id)?.handleOrphanQuestion());
+        this._remoteTerminalChannel.onDidRequestDetach(e => this._onDidRequestDetach.fire(e));
+        this._remoteTerminalChannel.onProcessReady(e => this._ptys.get(e.id)?.handleReady(e.event));
+        this._remoteTerminalChannel.onDidChangeProperty(e => this._ptys.get(e.id)?.handleDidChangeProperty(e.property));
+        this._remoteTerminalChannel.onProcessExit(e => {
+            const pty = this._ptys.get(e.id);
+            if (pty) {
+                pty.handleExit(e.event);
+                this._ptys.delete(e.id);
+            }
+        });
+        const allowedCommands = ['_remoteCLI.openExternal', '_remoteCLI.windowOpen', '_remoteCLI.getSystemStatus', '_remoteCLI.manageExtensions'];
+        this._remoteTerminalChannel.onExecuteCommand(async (e) => {
+            const pty = this._ptys.get(e.persistentProcessId);
+            if (!pty) {
+                return;
+            }
+            const reqId = e.reqId;
+            const commandId = e.commandId;
+            if (!allowedCommands.includes(commandId)) {
+                this._remoteTerminalChannel.sendCommandResult(reqId, true, 'Invalid remote cli command: ' + commandId);
+                return;
+            }
+            const commandArgs = ( e.commandArgs.map(arg => revive(arg)));
+            try {
+                const result = await this._commandService.executeCommand(e.commandId, ...commandArgs);
+                this._remoteTerminalChannel.sendCommandResult(reqId, false, result);
+            }
+            catch (err) {
+                this._remoteTerminalChannel.sendCommandResult(reqId, true, err);
+            }
+        });
+        const initialConfig = this._configurationService.getValue(TERMINAL_CONFIG_SECTION);
+        for (const match of ( Object.keys(initialConfig.autoReplies))) {
+            const reply = initialConfig.autoReplies[match];
+            if (reply) {
+                this._remoteTerminalChannel.installAutoReply(match, reply);
+            }
+        }
+        this._register(this._configurationService.onDidChangeConfiguration(async (e) => {
+            if (e.affectsConfiguration("terminal.integrated.autoReplies" )) {
+                this._remoteTerminalChannel.uninstallAllAutoReplies();
+                const config = this._configurationService.getValue(TERMINAL_CONFIG_SECTION);
+                for (const match of ( Object.keys(config.autoReplies))) {
+                    const reply = config.autoReplies[match];
+                    if (reply) {
+                        await this._remoteTerminalChannel.installAutoReply(match, reply);
+                    }
+                }
+            }
+        }));
+        this._onPtyHostConnected.fire();
+    }
+    async requestDetachInstance(workspaceId, instanceId) {
+        if (!this._remoteTerminalChannel) {
+            throw new Error(`Cannot request detach instance when there is no remote!`);
+        }
+        return this._remoteTerminalChannel.requestDetachInstance(workspaceId, instanceId);
+    }
+    async acceptDetachInstanceReply(requestId, persistentProcessId) {
+        if (!this._remoteTerminalChannel) {
+            throw new Error(`Cannot accept detached instance when there is no remote!`);
+        }
+        else if (!persistentProcessId) {
+            this._logService.warn('Cannot attach to feature terminals, custom pty terminals, or those without a persistentProcessId');
+            return;
+        }
+        return this._remoteTerminalChannel.acceptDetachInstanceReply(requestId, persistentProcessId);
+    }
+    async persistTerminalState() {
+        if (!this._remoteTerminalChannel) {
+            throw new Error(`Cannot persist terminal state when there is no remote!`);
+        }
+        const ids = Array.from(( this._ptys.keys()));
+        const serialized = await this._remoteTerminalChannel.serializeTerminalState(ids);
+        this._storageService.store("terminal.integrated.bufferState" , serialized, 1 , 1 );
+    }
+    async createProcess(shellLaunchConfig, cwd,
+    cols, rows, unicodeVersion, env,
+    options, shouldPersist) {
+        if (!this._remoteTerminalChannel) {
+            throw new Error(`Cannot create remote terminal when there is no remote!`);
+        }
+        const remoteEnv = await this._remoteAgentService.getEnvironment();
+        if (!remoteEnv) {
+            throw new Error('Could not fetch remote environment');
+        }
+        const terminalConfig = this._configurationService.getValue(TERMINAL_CONFIG_SECTION);
+        const configuration = {
+            'terminal.integrated.env.windows': this._configurationService.getValue("terminal.integrated.env.windows" ),
+            'terminal.integrated.env.osx': this._configurationService.getValue("terminal.integrated.env.osx" ),
+            'terminal.integrated.env.linux': this._configurationService.getValue("terminal.integrated.env.linux" ),
+            'terminal.integrated.cwd': this._configurationService.getValue("terminal.integrated.cwd" ),
+            'terminal.integrated.detectLocale': terminalConfig.detectLocale
+        };
+        const shellLaunchConfigDto = {
+            name: shellLaunchConfig.name,
+            executable: shellLaunchConfig.executable,
+            args: shellLaunchConfig.args,
+            cwd: shellLaunchConfig.cwd,
+            env: shellLaunchConfig.env,
+            useShellEnvironment: shellLaunchConfig.useShellEnvironment,
+            reconnectionProperties: shellLaunchConfig.reconnectionProperties,
+            type: shellLaunchConfig.type,
+            isFeatureTerminal: shellLaunchConfig.isFeatureTerminal
+        };
+        const activeWorkspaceRootUri = this._historyService.getLastActiveWorkspaceRoot();
+        const result = await this._remoteTerminalChannel.createProcess(shellLaunchConfigDto, configuration, activeWorkspaceRootUri, options, shouldPersist, cols, rows, unicodeVersion);
+        const pty = this._instantiationService.createInstance(RemotePty, result.persistentTerminalId, shouldPersist, this._remoteTerminalChannel);
+        this._ptys.set(result.persistentTerminalId, pty);
+        return pty;
+    }
+    async attachToProcess(id) {
+        if (!this._remoteTerminalChannel) {
+            throw new Error(`Cannot create remote terminal when there is no remote!`);
+        }
+        try {
+            await this._remoteTerminalChannel.attachToProcess(id);
+            const pty = this._instantiationService.createInstance(RemotePty, id, true, this._remoteTerminalChannel);
+            this._ptys.set(id, pty);
+            return pty;
+        }
+        catch (e) {
+            this._logService.trace(`Couldn't attach to process ${e.message}`);
+        }
+        return undefined;
+    }
+    async attachToRevivedProcess(id) {
+        if (!this._remoteTerminalChannel) {
+            throw new Error(`Cannot create remote terminal when there is no remote!`);
+        }
+        try {
+            const newId = (await this._remoteTerminalChannel.getRevivedPtyNewId(id)) ?? id;
+            return await this.attachToProcess(newId);
+        }
+        catch (e) {
+            this._logService.trace(`Couldn't attach to process ${e.message}`);
+        }
+        return undefined;
+    }
+    async listProcesses() {
+        return this._remoteTerminalChannel.listProcesses();
+    }
+    async getLatency() {
+        const sw = ( new StopWatch());
+        const results = await this._remoteTerminalChannel.getLatency();
+        sw.stop();
+        return [
+            {
+                label: 'window<->ptyhostservice<->ptyhost',
+                latency: sw.elapsed()
+            },
+            ...results
+        ];
+    }
+    async updateProperty(id, property, value) {
+        await this._remoteTerminalChannel.updateProperty(id, property, value);
+    }
+    async updateTitle(id, title, titleSource) {
+        await this._remoteTerminalChannel.updateTitle(id, title, titleSource);
+    }
+    async updateIcon(id, userInitiated, icon, color) {
+        await this._remoteTerminalChannel.updateIcon(id, userInitiated, icon, color);
+    }
+    async getDefaultSystemShell(osOverride) {
+        return this._remoteTerminalChannel.getDefaultSystemShell(osOverride) || '';
+    }
+    async getProfiles(profiles, defaultProfile, includeDetectedProfiles) {
+        return this._remoteTerminalChannel.getProfiles(profiles, defaultProfile, includeDetectedProfiles) || [];
+    }
+    async getEnvironment() {
+        return this._remoteTerminalChannel.getEnvironment() || {};
+    }
+    async getShellEnvironment() {
+        const connection = this._remoteAgentService.getConnection();
+        if (!connection) {
+            return undefined;
+        }
+        const resolverResult = await this._remoteAuthorityResolverService.resolveAuthority(connection.remoteAuthority);
+        return resolverResult.options?.extensionHostEnv;
+    }
+    async getWslPath(original, direction) {
+        const env = await this._remoteAgentService.getEnvironment();
+        if (env?.os !== 1 ) {
+            return original;
+        }
+        return this._remoteTerminalChannel.getWslPath(original, direction) || original;
+    }
+    async setTerminalLayoutInfo(layout) {
+        if (!this._remoteTerminalChannel) {
+            throw new Error(`Cannot call setActiveInstanceId when there is no remote`);
+        }
+        return this._remoteTerminalChannel.setTerminalLayoutInfo(layout);
+    }
+    async reduceConnectionGraceTime() {
+        if (!this._remoteTerminalChannel) {
+            throw new Error('Cannot reduce grace time when there is no remote');
+        }
+        return this._remoteTerminalChannel.reduceConnectionGraceTime();
+    }
+    async getTerminalLayoutInfo() {
+        if (!this._remoteTerminalChannel) {
+            throw new Error(`Cannot call getActiveInstanceId when there is no remote`);
+        }
+        const workspaceId = this._getWorkspaceId();
+        const serializedState = this._storageService.get("terminal.integrated.bufferState" , 1 );
+        const reviveBufferState = this._deserializeTerminalState(serializedState);
+        if (reviveBufferState && reviveBufferState.length > 0) {
+            try {
+                mark('code/terminal/willReviveTerminalProcessesRemote');
+                await this._remoteTerminalChannel.reviveTerminalProcesses(workspaceId, reviveBufferState, Intl.DateTimeFormat().resolvedOptions().locale);
+                mark('code/terminal/didReviveTerminalProcessesRemote');
+                this._storageService.remove("terminal.integrated.bufferState" , 1 );
+                const layoutInfo = this._storageService.get("terminal.integrated.layoutInfo" , 1 );
+                if (layoutInfo) {
+                    mark('code/terminal/willSetTerminalLayoutInfoRemote');
+                    await this._remoteTerminalChannel.setTerminalLayoutInfo(JSON.parse(layoutInfo));
+                    mark('code/terminal/didSetTerminalLayoutInfoRemote');
+                    this._storageService.remove("terminal.integrated.layoutInfo" , 1 );
+                }
+            }
+            catch (e) {
+                this._logService.warn('RemoteTerminalBackend#getTerminalLayoutInfo Error', e && typeof e === 'object' && 'message' in e ? e.message : e);
+            }
+        }
+        return this._remoteTerminalChannel.getTerminalLayoutInfo();
+    }
+    async getPerformanceMarks() {
+        return this._remoteTerminalChannel.getPerformanceMarks();
+    }
+};
+RemoteTerminalBackend = ( __decorate([
+    ( __param(2, IRemoteAgentService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, ITerminalLogService)),
+    ( __param(5, ICommandService)),
+    ( __param(6, IStorageService)),
+    ( __param(7, IRemoteAuthorityResolverService)),
+    ( __param(8, IWorkspaceContextService)),
+    ( __param(9, IConfigurationResolverService)),
+    ( __param(10, IHistoryService)),
+    ( __param(11, IConfigurationService)),
+    ( __param(12, IStatusbarService))
+], RemoteTerminalBackend));
+export { RemoteTerminalBackendContribution };

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

@@ -0,0 +1,267 @@
+import { Schemas } from '../../../../base/common/network.js';
+import { isWindows, isIOS } from '../../../../base/common/platform.js';
+import { URI } from '../../../../base/common/uri.js';
+import './media/scrollbar.css.js';
+import './media/terminal.css.js';
+import './media/terminalVoice.css.js';
+import './media/widgets.css.js';
+import './media/xterm.css.js';
+import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
+import { CONTEXT_ACCESSIBILITY_MODE_ENABLED } from '../../../../platform/accessibility/common/accessibility.js';
+import { CommandsRegistry } from '../../../../platform/commands/common/commands.js';
+import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { Extensions } from '../../../../platform/dnd/browser/dnd.js';
+import { SyncDescriptor } from '../../../../platform/instantiation/common/descriptors.js';
+import { KeybindingsRegistry } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
+import { Extensions as Extensions$2 } from '../../../../platform/quickinput/common/quickAccess.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import '../../../../platform/terminal/common/terminal.js';
+import '../../../../platform/terminal/common/terminalLogService.js';
+import { registerTerminalPlatformConfiguration } from '../../../../platform/terminal/common/terminalPlatformConfiguration.js';
+import { EditorPaneDescriptor } from '../../../browser/editor.js';
+import { ViewPaneContainer } from '../../../browser/parts/views/viewPaneContainer.js';
+import { getQuickNavigateHandler } from '../../../browser/quickaccess.js';
+import { registerWorkbenchContribution2 } from '../../../common/contributions.js';
+import { EditorExtensions } from '../../../common/editor.js';
+import { Extensions as Extensions$1 } from '../../../common/views.js';
+import { RemoteTerminalBackendContribution } from './remoteTerminalBackend.js';
+import { terminalEditorId } from './terminal.js';
+import { registerTerminalActions, terminalSendSequenceCommand } from './terminalActions.js';
+import { setupTerminalCommands } from './terminalCommands.js';
+import { TerminalEditor } from './terminalEditor.js';
+import { TerminalEditorInput } from './terminalEditorInput.js';
+import { TerminalInputSerializer } from './terminalEditorSerializer.js';
+import './terminalEditorService.js';
+import './terminalGroupService.js';
+import { terminalViewIcon } from './terminalIcons.js';
+import './terminalInstanceService.js';
+import { TerminalMainContribution } from './terminalMainContribution.js';
+import { setupTerminalMenus } from './terminalMenus.js';
+import './terminalProfileService.js';
+import { TerminalQuickAccessProvider } from './terminalQuickAccess.js';
+import './terminalService.js';
+import { TerminalViewPane } from './terminalView.js';
+import { TERMINAL_VIEW_ID } from '../common/terminal.js';
+import { registerColors } from '../common/terminalColorRegistry.js';
+import { registerTerminalConfiguration } from '../common/terminalConfiguration.js';
+import { TerminalContextKeys } from '../common/terminalContextKey.js';
+import { terminalStrings } from '../common/terminalStrings.js';
+const quickAccessRegistry = (( Registry.as(Extensions$2.Quickaccess)));
+const inTerminalsPicker = 'inTerminalPicker';
+quickAccessRegistry.registerQuickAccessProvider({
+    ctor: TerminalQuickAccessProvider,
+    prefix: TerminalQuickAccessProvider.PREFIX,
+    contextKey: inTerminalsPicker,
+    placeholder: ( localizeWithPath(
+        'vs/workbench/contrib/terminal/browser/terminal.contribution',
+        'tasksQuickAccessPlaceholder',
+        "Type the name of a terminal to open."
+    )),
+    helpEntries: [{ description: ( localizeWithPath(
+        'vs/workbench/contrib/terminal/browser/terminal.contribution',
+        'tasksQuickAccessHelp',
+        "Show All Opened Terminals"
+    )), commandId: "workbench.action.quickOpenTerm"  }]
+});
+const quickAccessNavigateNextInTerminalPickerId = 'workbench.action.quickOpenNavigateNextInTerminalPicker';
+CommandsRegistry.registerCommand({ id: quickAccessNavigateNextInTerminalPickerId, handler: getQuickNavigateHandler(quickAccessNavigateNextInTerminalPickerId, true) });
+const quickAccessNavigatePreviousInTerminalPickerId = 'workbench.action.quickOpenNavigatePreviousInTerminalPicker';
+CommandsRegistry.registerCommand({ id: quickAccessNavigatePreviousInTerminalPickerId, handler: getQuickNavigateHandler(quickAccessNavigatePreviousInTerminalPickerId, false) });
+registerWorkbenchContribution2(TerminalMainContribution.ID, TerminalMainContribution, 1 );
+registerWorkbenchContribution2(RemoteTerminalBackendContribution.ID, RemoteTerminalBackendContribution, 3 );
+registerTerminalPlatformConfiguration();
+registerTerminalConfiguration();
+( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(TerminalEditorInput.ID, TerminalInputSerializer);
+( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(EditorPaneDescriptor.create(TerminalEditor, terminalEditorId, terminalStrings.terminal), [
+    ( new SyncDescriptor(TerminalEditorInput))
+]);
+( Registry.as(Extensions.DragAndDropContribution)).register({
+    dataFormatKey: "Terminals" ,
+    getEditorInputs(data) {
+        const editors = [];
+        try {
+            const terminalEditors = JSON.parse(data);
+            for (const terminalEditor of terminalEditors) {
+                editors.push({ resource: ( URI.parse(terminalEditor)) });
+            }
+        }
+        catch (error) {
+        }
+        return editors;
+    },
+    setData(resources, event) {
+        const terminalResources = resources.filter(({ resource }) => resource.scheme === Schemas.vscodeTerminal);
+        if (terminalResources.length) {
+            event.dataTransfer?.setData("Terminals" , JSON.stringify(( terminalResources.map(({ resource }) => ( resource.toString())))));
+        }
+    }
+});
+const VIEW_CONTAINER = ( Registry.as(Extensions$1.ViewContainersRegistry)).registerViewContainer({
+    id: TERMINAL_VIEW_ID,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/terminal/browser/terminal.contribution',
+        'terminal',
+        "Terminal"
+    )),
+    icon: terminalViewIcon,
+    ctorDescriptor: ( new SyncDescriptor(
+        ViewPaneContainer,
+        [TERMINAL_VIEW_ID, { mergeViewWithContainerWhenSingleView: true }]
+    )),
+    storageId: TERMINAL_VIEW_ID,
+    hideIfEmpty: true,
+    order: 3,
+}, 1 , { doNotRegisterOpenCommand: true, isDefault: true });
+( Registry.as(Extensions$1.ViewsRegistry)).registerViews([{
+        id: TERMINAL_VIEW_ID,
+        name: ( localize2WithPath(
+            'vs/workbench/contrib/terminal/browser/terminal.contribution',
+            'terminal',
+            "Terminal"
+        )),
+        containerIcon: terminalViewIcon,
+        canToggleVisibility: false,
+        canMoveView: true,
+        ctorDescriptor: ( new SyncDescriptor(TerminalViewPane)),
+        when: TerminalContextKeys.processSupported,
+        openCommandActionDescriptor: {
+            id: "workbench.action.terminal.toggleTerminal" ,
+            mnemonicTitle: ( localizeWithPath(
+                'vs/workbench/contrib/terminal/browser/terminal.contribution',
+                { key: 'miToggleIntegratedTerminal', comment: ['&& denotes a mnemonic'] },
+                "&&Terminal"
+            )),
+            keybindings: {
+                primary: 2048  | 91 ,
+                mac: { primary: 256  | 91  }
+            },
+            order: 3
+        }
+    }], VIEW_CONTAINER);
+registerTerminalActions();
+function registerSendSequenceKeybinding(text, rule) {
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: "workbench.action.terminal.sendSequence" ,
+        weight: 200 ,
+        when: rule.when || TerminalContextKeys.focus,
+        primary: rule.primary,
+        mac: rule.mac,
+        linux: rule.linux,
+        win: rule.win,
+        handler: terminalSendSequenceCommand,
+        args: { text }
+    });
+}
+if (isWindows) {
+    registerSendSequenceKeybinding(String.fromCharCode('V'.charCodeAt(0) - 64 ), {
+        when: ( ContextKeyExpr.and(TerminalContextKeys.focus, ( ContextKeyExpr.equals(
+            "terminalShellType",
+            "pwsh"
+        )), ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()))),
+        primary: 2048  | 52
+    });
+}
+registerSendSequenceKeybinding('\x1b[24~a', {
+    when: ( ContextKeyExpr.and(TerminalContextKeys.focus, ( ContextKeyExpr.equals(
+        "terminalShellType",
+        "pwsh"
+    )), TerminalContextKeys.terminalShellIntegrationEnabled, ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()))),
+    primary: 2048  | 10 ,
+    mac: { primary: 256  | 10  }
+});
+registerSendSequenceKeybinding('\x1b[24~b', {
+    when: ( ContextKeyExpr.and(TerminalContextKeys.focus, ( ContextKeyExpr.equals(
+        "terminalShellType",
+        "pwsh"
+    )), TerminalContextKeys.terminalShellIntegrationEnabled, ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()))),
+    primary: 512  | 10
+});
+registerSendSequenceKeybinding('\x1b[24~c', {
+    when: ( ContextKeyExpr.and(TerminalContextKeys.focus, ( ContextKeyExpr.equals(
+        "terminalShellType",
+        "pwsh"
+    )), TerminalContextKeys.terminalShellIntegrationEnabled, ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()))),
+    primary: 1024  | 3
+});
+registerSendSequenceKeybinding('\x1b[24~d', {
+    when: ( ContextKeyExpr.and(TerminalContextKeys.focus, ( ContextKeyExpr.equals(
+        "terminalShellType",
+        "pwsh"
+    )), TerminalContextKeys.terminalShellIntegrationEnabled, ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()))),
+    mac: { primary: 1024  | 2048  | 17  }
+});
+registerSendSequenceKeybinding('\x1b[24~e', {
+    when: ( ContextKeyExpr.and(TerminalContextKeys.focus, ( ContextKeyExpr.equals(
+        "terminalShellType",
+        "pwsh"
+    )), TerminalContextKeys.terminalShellIntegrationEnabled, ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()), ( ContextKeyExpr.equals(
+        `config.${"terminal.integrated.shellIntegration.suggestEnabled" }`,
+        true
+    )))),
+    primary: 2048  | 10 ,
+    mac: { primary: 256  | 10  }
+});
+registerSendSequenceKeybinding('\x1b[1;2H', {
+    when: ( ContextKeyExpr.and(TerminalContextKeys.focus, ( ContextKeyExpr.equals(
+        "terminalShellType",
+        "pwsh"
+    )))),
+    mac: { primary: 1024  | 2048  | 15  }
+});
+registerSendSequenceKeybinding('\x12', {
+    when: ( ContextKeyExpr.and(TerminalContextKeys.focus, CONTEXT_ACCESSIBILITY_MODE_ENABLED)),
+    primary: 2048  | 512  | 48 ,
+    mac: { primary: 256  | 512  | 48  }
+});
+registerSendSequenceKeybinding('\x07', {
+    when: TerminalContextKeys.focus,
+    primary: 2048  | 512  | 37 ,
+    mac: { primary: 256  | 512  | 37  }
+});
+if (isIOS) {
+    registerSendSequenceKeybinding(String.fromCharCode('C'.charCodeAt(0) - 64 ), {
+        when: ( ContextKeyExpr.and(TerminalContextKeys.focus)),
+        primary: 256  | 33
+    });
+}
+registerSendSequenceKeybinding(String.fromCharCode('W'.charCodeAt(0) - 64 ), {
+    primary: 2048  | 1 ,
+    mac: { primary: 512  | 1  }
+});
+if (isWindows) {
+    registerSendSequenceKeybinding(String.fromCharCode('H'.charCodeAt(0) - 64 ), {
+        when: ( ContextKeyExpr.and(TerminalContextKeys.focus, ( ContextKeyExpr.equals(
+            "terminalShellType",
+            "cmd"
+        )))),
+        primary: 2048  | 1 ,
+    });
+}
+registerSendSequenceKeybinding('\u001bd', {
+    primary: 2048  | 20 ,
+    mac: { primary: 512  | 20  }
+});
+registerSendSequenceKeybinding('\u0015', {
+    mac: { primary: 2048  | 1  }
+});
+registerSendSequenceKeybinding(String.fromCharCode('A'.charCodeAt(0) - 64), {
+    mac: { primary: 2048  | 15  }
+});
+registerSendSequenceKeybinding(String.fromCharCode('E'.charCodeAt(0) - 64), {
+    mac: { primary: 2048  | 17  }
+});
+registerSendSequenceKeybinding('\u0000', {
+    primary: 2048  | 1024  | 23 ,
+    mac: { primary: 256  | 1024  | 23  }
+});
+registerSendSequenceKeybinding('\u001e', {
+    primary: 2048  | 1024  | 27 ,
+    mac: { primary: 256  | 1024  | 27  }
+});
+registerSendSequenceKeybinding('\u001f', {
+    primary: 2048  | 90 ,
+    mac: { primary: 256  | 90  }
+});
+setupTerminalCommands();
+setupTerminalMenus();
+registerColors();

package/vscode/src/vs/workbench/contrib/terminal/browser/terminal.web.contribution.js

@@ -0,0 +1,11 @@
+import { KeybindingsRegistry } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
+import '../../../../nls.js';
+import '../../../../platform/instantiation/common/instantiation.js';
+import './terminalProfileResolverService.js';
+import { TerminalContextKeys } from '../common/terminalContextKey.js';
+KeybindingsRegistry.registerKeybindingRule({
+    id: "workbench.action.terminal.new" ,
+    weight: 200 ,
+    when: TerminalContextKeys.notFocus,
+    primary: 2048  | 1024  | 33
+});