@codingame/monaco-vscode-api 1.81.8-next.2 → 1.82.0-next.0

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

@@ -3,7 +3,7 @@ import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { sanitizeProcessEnvironment } from '../../../../base/common/processes.js';
 import { isWindows, language } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { escapeNonWindowsPath, sanitizeCwd } from '../../../../platform/terminal/common/terminalEnvironment.js';
-import { isString, withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { isString } from 'monaco-editor/esm/vs/base/common/types.js';
 function mergeEnvironments(parent, other) {
     if (!other) {
         return;
@@ -262,10 +262,10 @@ async function preparePathForShell(resource, executable, title, shellType, backe
 }
 function getWorkspaceForTerminal(cwd, workspaceContextService, historyService) {
     const cwdUri = typeof cwd === 'string' ? ( URI.parse(cwd)) : cwd;
-    let workspaceFolder = cwdUri ? withNullAsUndefined(workspaceContextService.getWorkspaceFolder(cwdUri)) : undefined;
+    let workspaceFolder = cwdUri ? workspaceContextService.getWorkspaceFolder(cwdUri) ?? undefined : undefined;
     if (!workspaceFolder) {
         const activeWorkspaceRootUri = historyService.getLastActiveWorkspaceRoot();
-        workspaceFolder = activeWorkspaceRootUri ? withNullAsUndefined(workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri)) : undefined;
+        workspaceFolder = activeWorkspaceRootUri ? workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri) ?? undefined : undefined;
     }
     return workspaceFolder;
 }

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

@@ -13,6 +13,13 @@ const terminalStrings = {
         value: ( localize('workbench.action.terminal.focus', "Focus Terminal")),
         original: 'Focus Terminal'
     },
+    focusAndHideAccessibleBuffer: {
+        value: ( localize(
+            'workbench.action.terminal.focusAndHideAccessibleBuffer',
+            "Focus Terminal and Hide Accessible Buffer"
+        )),
+        original: 'Focus Terminal and Hide Accessible Buffer'
+    },
     kill: {
         value: ( localize('killTerminal', "Kill Terminal")),
         original: 'Kill Terminal',

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

@@ -2,26 +2,60 @@ import { __decorate, __param } from '../../../../../../../../external/tslib/tsli
 import { DisposableStore, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { CONTEXT_ACCESSIBILITY_MODE_ENABLED } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { terminalTabFocusModeContextKey } from '../../../../../platform/terminal/common/terminal.js';
-import { AccessibilityHelpAction } from '../../../accessibility/browser/accessibilityContribution.js';
 import { IAccessibleViewService } from '../../../accessibility/browser/accessibleView.js';
+import { AccessibilityHelpAction } from '../../../accessibility/browser/accessibleViewActions.js';
 import { ITerminalService } from '../../../terminal/browser/terminal.js';
 import { registerTerminalAction } from '../../../terminal/browser/terminalActions.js';
 import { registerTerminalContribution } from '../../../terminal/browser/terminalExtensions.js';
 import { TerminalContextKeys } from '../../../terminal/common/terminalContextKey.js';
 import { TerminalAccessibleContentProvider } from './terminalAccessibilityHelp.js';
 import { AccessibleBufferWidget } from './terminalAccessibleBuffer.js';
+import { TextAreaSyncAddon } from './textAreaSyncAddon.js';
+var TextAreaSyncContribution_1, AccessibleBufferContribution_1;
+let TextAreaSyncContribution = class TextAreaSyncContribution extends DisposableStore {
+    static { TextAreaSyncContribution_1 = this; }
+    static { this.ID = 'terminal.textAreaSync'; }
+    static get(instance) {
+        return instance.getContribution(TextAreaSyncContribution_1.ID);
+    }
+    constructor(_instance, processManager, widgetManager, _instantiationService) {
+        super();
+        this._instance = _instance;
+        this._instantiationService = _instantiationService;
+    }
+    xtermReady(xterm) {
+        const addon = this._instantiationService.createInstance(TextAreaSyncAddon, this._instance.capabilities);
+        xterm.raw.loadAddon(addon);
+        addon.activate(xterm.raw);
+    }
+};
+TextAreaSyncContribution = TextAreaSyncContribution_1 = ( __decorate([
+    ( __param(3, IInstantiationService))
+], TextAreaSyncContribution));
+registerTerminalContribution(TextAreaSyncContribution.ID, TextAreaSyncContribution);
 let AccessibleBufferContribution = class AccessibleBufferContribution extends DisposableStore {
+    static { AccessibleBufferContribution_1 = this; }
     static { this.ID = 'terminal.accessible-buffer'; }
     static get(instance) {
-        return instance.getContribution(AccessibleBufferContribution.ID);
+        return instance.getContribution(AccessibleBufferContribution_1.ID);
     }
-    constructor(_instance, processManager, widgetManager, _instantiationService) {
+    constructor(_instance, processManager, widgetManager, _instantiationService, configurationService) {
         super();
         this._instance = _instance;
         this._instantiationService = _instantiationService;
+        this.add(_instance.onDidRunText(() => {
+            const focusAfterRun = configurationService.getValue("terminal.integrated.focusAfterRun" );
+            if (focusAfterRun === 'terminal') {
+                _instance.focus(true);
+            }
+            else if (focusAfterRun === 'accessible-buffer') {
+                this.show();
+            }
+        }));
     }
     layout(xterm) {
         this._xterm = xterm;
@@ -41,9 +75,13 @@ let AccessibleBufferContribution = class AccessibleBufferContribution extends Di
     navigateToCommand(type) {
         return this._accessibleBufferWidget?.navigateToCommand(type);
     }
+    hide() {
+        this._accessibleBufferWidget?.hide();
+    }
 };
-AccessibleBufferContribution = ( __decorate([
-    ( __param(3, IInstantiationService))
+AccessibleBufferContribution = AccessibleBufferContribution_1 = ( __decorate([
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IConfigurationService))
 ], AccessibleBufferContribution));
 registerTerminalContribution(AccessibleBufferContribution.ID, AccessibleBufferContribution);
 class TerminalAccessibilityHelpContribution extends Disposable {
@@ -60,7 +98,7 @@ class TerminalAccessibilityHelpContribution extends Disposable {
                 return;
             }
             accessibleViewService.show(instantiationService.createInstance(TerminalAccessibleContentProvider, instance, terminal));
-        }, TerminalContextKeys.focus));
+        }, ( ContextKeyExpr.or(TerminalContextKeys.focus, TerminalContextKeys.accessibleBufferFocus))));
     }
 }
 registerTerminalContribution(TerminalAccessibilityHelpContribution.ID, TerminalAccessibilityHelpContribution);
@@ -76,7 +114,8 @@ registerTerminalAction({
     )),
     keybinding: [
         {
-            primary: 1024  | 2 ,
+            primary: 512  | 60 ,
+            secondary: [2048  | 16 ],
             weight: 200 ,
             when: ( ContextKeyExpr.and(
                 CONTEXT_ACCESSIBILITY_MODE_ENABLED,
@@ -139,8 +178,7 @@ registerTerminalAction({
             weight: 200  + 2
         },
         {
-            primary: 2048  | 18 ,
-            mac: { primary: 512  | 18  },
+            primary: 512  | 18 ,
             when: ( ContextKeyExpr.and(
                 TerminalContextKeys.accessibleBufferFocus,
                 CONTEXT_ACCESSIBILITY_MODE_ENABLED
@@ -174,8 +212,7 @@ registerTerminalAction({
             weight: 200  + 2
         },
         {
-            primary: 2048  | 16 ,
-            mac: { primary: 512  | 16  },
+            primary: 512  | 16 ,
             when: ( ContextKeyExpr.and(
                 TerminalContextKeys.accessibleBufferFocus,
                 CONTEXT_ACCESSIBILITY_MODE_ENABLED

package/vscode/src/vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp.js

@@ -3,36 +3,52 @@ import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { format } from 'monaco-editor/esm/vs/base/common/strings.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { TerminalContextKeys } from '../../../terminal/common/terminalContextKey.js';
 let TerminalAccessibleContentProvider = class TerminalAccessibleContentProvider extends Disposable {
     onClose() {
-        this._instance.focus();
+        if (this._contextKeyService.getContextKeyValue(TerminalContextKeys.accessibleBufferFocus.key) === true) {
+            this._commandService.executeCommand("workbench.action.terminal.focusAccessibleBuffer" );
+        }
+        else {
+            this._instance.focus();
+        }
         this.dispose();
     }
-    constructor(_instance, _xterm, _instantiationService, _keybindingService, _accessibilityService) {
+    constructor(_instance, _xterm, _instantiationService, _keybindingService, _contextKeyService, _commandService, _accessibilityService) {
         super();
         this._instance = _instance;
         this._keybindingService = _keybindingService;
+        this._contextKeyService = _contextKeyService;
+        this._commandService = _commandService;
         this._accessibilityService = _accessibilityService;
         this._hasShellIntegration = false;
         this.options = {
             type: "help" ,
-            ariaLabel: ( localize('terminal-help-label', "terminal accessibility help")),
             readMoreUrl: 'https://code.visualstudio.com/docs/editor/accessibility#_terminal-accessibility'
         };
         this.verbositySettingKey = "accessibility.verbosity.terminal" ;
         this._hasShellIntegration = _xterm.shellIntegration.status === 2 ;
     }
     _descriptionForCommand(commandId, msg, noKbMsg) {
-        const kb = this._keybindingService.lookupKeybindings(commandId);
-        switch (kb.length) {
-            case 0:
+        if (commandId === "workbench.action.terminal.runRecentCommand" ) {
+            const kb = this._keybindingService.lookupKeybindings(commandId);
+            const isScreenReaderOptimized = this._accessibilityService.isScreenReaderOptimized();
+            if (isScreenReaderOptimized && kb[1]) {
+                format(msg, kb[1].getAriaLabel());
+            }
+            else if (kb[0]) {
+                format(msg, kb[0].getAriaLabel());
+            }
+            else {
                 return format(noKbMsg, commandId);
-            case 1:
-                return format(msg, kb[0].getAriaLabel());
+            }
         }
-        return this._accessibilityService.isScreenReaderOptimized() ? format(msg, kb[1].getAriaLabel()) : format(msg, kb[0].getAriaLabel());
+        const kb = this._keybindingService.lookupKeybinding(commandId, this._contextKeyService)?.getAriaLabel();
+        return !kb ? format(noKbMsg, commandId) : format(msg, kb);
     }
     provideContent() {
         const content = [];
@@ -50,30 +66,32 @@ let TerminalAccessibleContentProvider = class TerminalAccessibleContentProvider
             )));
         }
         if (this._hasShellIntegration) {
-            content.push(( localize(
+            const shellIntegrationCommandList = [];
+            shellIntegrationCommandList.push(( localize(
                 'shellIntegration',
                 "The terminal has a feature called shell integration that offers an enhanced experience and provides useful commands for screen readers such as:"
             )));
-            content.push('- ' + this._descriptionForCommand("workbench.action.terminal.accessibleBufferGoToNextCommand" , ( localize('goToNextCommand', 'Go to Next Command ({0})')), ( localize(
+            shellIntegrationCommandList.push('- ' + this._descriptionForCommand("workbench.action.terminal.accessibleBufferGoToNextCommand" , ( localize('goToNextCommand', 'Go to Next Command ({0})')), ( localize(
                 'goToNextCommandNoKb',
                 'Go to Next Command is currently not triggerable by a keybinding.'
             ))));
-            content.push('- ' + this._descriptionForCommand("workbench.action.terminal.accessibleBufferGoToPreviousCommand" , ( localize('goToPreviousCommand', 'Go to Previous Command ({0})')), ( localize(
+            shellIntegrationCommandList.push('- ' + this._descriptionForCommand("workbench.action.terminal.accessibleBufferGoToPreviousCommand" , ( localize('goToPreviousCommand', 'Go to Previous Command ({0})')), ( localize(
                 'goToPreviousCommandNoKb',
                 'Go to Previous Command is currently not triggerable by a keybinding.'
             ))));
-            content.push('- ' + this._descriptionForCommand("workbench.action.terminal.navigateAccessibleBuffer" , ( localize('navigateAccessibleBuffer', 'Navigate Accessible Buffer ({0})')), ( localize(
+            shellIntegrationCommandList.push('- ' + this._descriptionForCommand("workbench.action.terminal.navigateAccessibleBuffer" , ( localize('navigateAccessibleBuffer', 'Navigate Accessible Buffer ({0})')), ( localize(
                 'navigateAccessibleBufferNoKb',
                 'Navigate Accessible Buffer is currently not triggerable by a keybinding.'
             ))));
-            content.push('- ' + this._descriptionForCommand("workbench.action.terminal.runRecentCommand" , ( localize('runRecentCommand', 'Run Recent Command ({0})')), ( localize(
+            shellIntegrationCommandList.push('- ' + this._descriptionForCommand("workbench.action.terminal.runRecentCommand" , ( localize('runRecentCommand', 'Run Recent Command ({0})')), ( localize(
                 'runRecentCommandNoKb',
                 'Run Recent Command is currently not triggerable by a keybinding.'
             ))));
-            content.push('- ' + this._descriptionForCommand("workbench.action.terminal.goToRecentDirectory" , ( localize('goToRecentDirectory', 'Go to Recent Directory ({0})')), ( localize(
+            shellIntegrationCommandList.push('- ' + this._descriptionForCommand("workbench.action.terminal.goToRecentDirectory" , ( localize('goToRecentDirectory', 'Go to Recent Directory ({0})')), ( localize(
                 'goToRecentDirectoryNoKb',
                 'Go to Recent Directory is currently not triggerable by a keybinding.'
             ))));
+            content.push(shellIntegrationCommandList.join('\n'));
         }
         else {
             content.push(this._descriptionForCommand("workbench.action.terminal.runRecentCommand" , ( localize(
@@ -98,16 +116,23 @@ let TerminalAccessibleContentProvider = class TerminalAccessibleContentProvider
             'newWithProfileNoKb',
             'The Create New Terminal (With Profile) command allows for easy terminal creation using a specific profile and is currently not triggerable by a keybinding.'
         ))));
+        content.push(( localize(
+            'focusAfterRun',
+            'Configure what gets focused after running selected text in the terminal with `{0}`.',
+            "terminal.integrated.focusAfterRun"
+        )));
         content.push(( localize(
             'accessibilitySettings',
             'Access accessibility settings such as `terminal.integrated.tabFocusMode` via the Preferences: Open Accessibility Settings command.'
         )));
-        return content.join('\n');
+        return content.join('\n\n');
     }
 };
 TerminalAccessibleContentProvider = ( __decorate([
     ( __param(2, IInstantiationService)),
     ( __param(3, IKeybindingService)),
-    ( __param(4, IAccessibilityService))
+    ( __param(4, IContextKeyService)),
+    ( __param(5, ICommandService)),
+    ( __param(6, IAccessibilityService))
 ], TerminalAccessibleContentProvider));
 export { TerminalAccessibleContentProvider };

package/vscode/src/vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibleBuffer.js

@@ -1,6 +1,5 @@
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
 import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
 import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { AudioCue, IAudioCueService } from 'monaco-editor/esm/vs/platform/audioCues/browser/audioCueService.js';
@@ -15,7 +14,7 @@ import { BufferContentTracker } from './bufferContentTracker.js';
 import { TerminalAccessibleWidget } from './terminalAccessibleWidget.js';
 let AccessibleBufferWidget = class AccessibleBufferWidget extends TerminalAccessibleWidget {
     constructor(_instance, _xterm, _instantiationService, _modelService, _configurationService, _quickInputService, _audioCueService, _contextKeyService, _logService, _terminalService) {
-        super("accessible-buffer" , _instance, _xterm, TerminalContextKeys.accessibleBufferFocus, _instantiationService, _modelService, _configurationService, _contextKeyService, _terminalService);
+        super("accessible-buffer" , _instance, _xterm, TerminalContextKeys.accessibleBufferFocus, TerminalContextKeys.accessibleBufferOnLastLine, _instantiationService, _modelService, _configurationService, _contextKeyService, _terminalService);
         this._quickInputService = _quickInputService;
         this._audioCueService = _audioCueService;
         this._logService = _logService;
@@ -23,15 +22,8 @@ let AccessibleBufferWidget = class AccessibleBufferWidget extends TerminalAccess
         this._pendingUpdates = 0;
         this._bufferTracker = _instantiationService.createInstance(BufferContentTracker, _xterm);
         this.element.ariaRoleDescription = ( localize('terminal.integrated.accessibleBuffer', 'Terminal buffer'));
+        _instance.onDidRequestFocus(() => this.hide(true));
         this.updateEditor();
-        this.add(this.editorWidget.onDidFocusEditorText(async () => {
-            if (this.element.classList.contains("active" )) {
-                return;
-            }
-            this.registerListeners();
-            await this.updateEditor();
-            this.element.classList.add("active" );
-        }));
         this.layout();
     }
     navigateToCommand(type) {
@@ -48,8 +40,14 @@ let AccessibleBufferWidget = class AccessibleBufferWidget extends TerminalAccess
         this._resetPosition();
     }
     _getEditorLineForCommand(command) {
-        let line = command.marker?.line;
-        if (line === undefined || !command.command.length || line < 0) {
+        let line;
+        if ('marker' in command) {
+            line = command.marker?.line;
+        }
+        else if ('commandStartMarker' in command) {
+            line = command.commandStartMarker?.line;
+        }
+        if (line === undefined || line < 0) {
             return;
         }
         line = this._bufferTracker.bufferToEditorLineMapping.get(line);
@@ -59,7 +57,9 @@ let AccessibleBufferWidget = class AccessibleBufferWidget extends TerminalAccess
         return line + 1;
     }
     _getCommandsWithEditorLine() {
-        const commands = this._instance.capabilities.get(2 )?.commands;
+        const capability = this._instance.capabilities.get(2 );
+        const commands = capability?.commands;
+        const currentCommand = capability?.currentCommand;
         if (!commands?.length) {
             return;
         }
@@ -71,10 +71,16 @@ let AccessibleBufferWidget = class AccessibleBufferWidget extends TerminalAccess
             }
             result.push({ command, lineNumber });
         }
+        if (currentCommand) {
+            const lineNumber = this._getEditorLineForCommand(currentCommand);
+            if (!!lineNumber) {
+                result.push({ command: currentCommand, lineNumber });
+            }
+        }
         return result;
     }
     async createQuickPick() {
-        this._cursorPosition = withNullAsUndefined(this.editorWidget.getPosition());
+        this._cursorPosition = this.editorWidget.getPosition() ?? undefined;
         const commands = this._getCommandsWithEditorLine();
         if (!commands) {
             return;
@@ -92,7 +98,7 @@ let AccessibleBufferWidget = class AccessibleBufferWidget extends TerminalAccess
                     command.command
                 )),
                 lineNumber,
-                exitCode: command.exitCode
+                exitCode: 'exitCode' in command ? command.exitCode : undefined
             });
         }
         const quickPick = this._quickInputService.createQuickPick();
@@ -103,7 +109,7 @@ let AccessibleBufferWidget = class AccessibleBufferWidget extends TerminalAccess
                 return;
             }
             if (activeItem.exitCode) {
-                this._audioCueService.playAudioCue(AudioCue.error, true);
+                this._audioCueService.playAudioCue(AudioCue.error, { allowManyInParallel: true, source: 'accessibleBufferWidget' });
             }
             this.editorWidget.revealLine(activeItem.lineNumber, 0);
         });
@@ -182,7 +188,7 @@ let AccessibleBufferWidget = class AccessibleBufferWidget extends TerminalAccess
         const modelChanged = linesBefore !== linesAfter;
         let savedViewState;
         if (dataChanged) {
-            savedViewState = withNullAsUndefined(this.editorWidget.saveViewState());
+            savedViewState = this.editorWidget.saveViewState() ?? undefined;
         }
         let model = this.editorWidget.getModel();
         const text = this._bufferTracker.lines.join('\n');

package/vscode/src/vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibleWidget.js

@@ -11,15 +11,15 @@ import { getSimpleEditorOptions } from '../../../codeEditor/browser/simpleEditor
 import { ITerminalService } from '../../../terminal/browser/terminal.js';
 import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { CodeActionController } from 'monaco-editor/esm/vs/editor/contrib/codeAction/browser/codeActionController.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
 let TerminalAccessibleWidget = class TerminalAccessibleWidget extends DisposableStore {
     get element() { return this._element; }
     get editorWidget() { return this._editorWidget; }
-    constructor(_className, _instance, _xterm, _focusContextKey, _instantiationService, _modelService, _configurationService, _contextKeyService, _terminalService) {
+    constructor(_className, _instance, _xterm, rawFocusContextKey, rawFocusLastLineContextKey, _instantiationService, _modelService, _configurationService, _contextKeyService, _terminalService) {
         super();
         this._className = _className;
         this._instance = _instance;
         this._xterm = _xterm;
-        this._focusContextKey = _focusContextKey;
         this._instantiationService = _instantiationService;
         this._modelService = _modelService;
         this._configurationService = _configurationService;
@@ -51,17 +51,27 @@ let TerminalAccessibleWidget = class TerminalAccessibleWidget extends Disposable
             quickSuggestions: false,
             renderWhitespace: 'none',
             dropIntoEditor: { enabled: true },
-            readOnly: true
+            readOnly: true,
+            ariaLabel: ( localize('terminalAccessibleBuffer', "Terminal Buffer"))
         };
         this._editorWidget = this.add(this._instantiationService.createInstance(CodeEditorWidget, this._editorContainer, editorOptions, codeEditorWidgetOptions));
         this._element.replaceChildren(this._editorContainer);
         this._xtermElement.insertAdjacentElement('beforebegin', this._element);
-        if (this._focusContextKey) {
-            this._focusTracker = this.add(dom.trackFocus(this._editorContainer));
-            this._focusedContextKey = this._focusContextKey.bindTo(this._contextKeyService);
-            this.add(this._focusTracker.onDidFocus(() => this._focusedContextKey?.set(true)));
-            this.add(this._focusTracker.onDidBlur(() => this._focusedContextKey?.reset()));
-        }
+        this._focusTracker = this.add(dom.trackFocus(this._editorContainer));
+        this._focusedContextKey = rawFocusContextKey.bindTo(this._contextKeyService);
+        this._focusedLastLineContextKey = rawFocusLastLineContextKey.bindTo(this._contextKeyService);
+        this.add(this._focusTracker.onDidFocus(() => {
+            this._focusedContextKey?.set(true);
+            this._focusedLastLineContextKey?.set(this._editorWidget.getSelection()?.positionLineNumber === this._editorWidget.getModel()?.getLineCount());
+        }));
+        this.add(this._focusTracker.onDidBlur(() => {
+            this._focusedContextKey?.reset();
+            this._focusedLastLineContextKey?.reset();
+        }));
+        this._editorWidget.onDidChangeCursorPosition(() => {
+            console.log(this._editorWidget.getSelection()?.positionLineNumber === this._editorWidget.getModel()?.getLineCount());
+            this._focusedLastLineContextKey?.set(this._editorWidget.getSelection()?.positionLineNumber === this._editorWidget.getModel()?.getLineCount());
+        });
         this.add(Event.runAndSubscribe(this._xterm.raw.onResize, () => this.layout()));
         this.add(this._configurationService.onDidChangeConfiguration(e => {
             if (( e.affectedKeys.has("terminal.integrated.fontFamily" )) || ( e.affectedKeys.has("terminal.integrated.fontSize" )) || ( e.affectedKeys.has("terminal.integrated.lineHeight" )) || ( e.affectedKeys.has("terminal.integrated.letterSpacing" ))) {
@@ -72,11 +82,7 @@ let TerminalAccessibleWidget = class TerminalAccessibleWidget extends Disposable
         this.add(this._editorWidget.onKeyDown((e) => {
             switch (e.keyCode) {
                 case 9 :
-                    this.hide();
-                    this._xterm.raw.focus();
-                    break;
-                case 2 :
-                    this.hide();
+                    this.hide(true);
                     break;
             }
         }));
@@ -84,6 +90,7 @@ let TerminalAccessibleWidget = class TerminalAccessibleWidget extends Disposable
             this._terminalService.setActiveInstance(this._instance);
             this._xtermElement.classList.add("hide" );
         }));
+        this.add(this._editorWidget.onDidBlurEditorText(async () => this.hide()));
     }
     registerListeners() {
         this._listeners.push(this._instance.onDidRequestFocus(() => this.editorWidget.focus()));
@@ -109,10 +116,13 @@ let TerminalAccessibleWidget = class TerminalAccessibleWidget extends Disposable
             listener.dispose();
         }
     }
-    hide() {
+    hide(focusXterm) {
         this._disposeListeners();
         this.element.classList.remove("active" );
         this._xtermElement.classList.remove("hide" );
+        if (focusXterm) {
+            this._xterm.raw.focus();
+        }
     }
     async getTextModel(resource) {
         const existing = this._modelService.getModel(resource);
@@ -123,10 +133,10 @@ let TerminalAccessibleWidget = class TerminalAccessibleWidget extends Disposable
     }
 };
 TerminalAccessibleWidget = ( __decorate([
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IModelService)),
-    ( __param(6, IConfigurationService)),
-    ( __param(7, IContextKeyService)),
-    ( __param(8, ITerminalService))
+    ( __param(5, IInstantiationService)),
+    ( __param(6, IModelService)),
+    ( __param(7, IConfigurationService)),
+    ( __param(8, IContextKeyService)),
+    ( __param(9, ITerminalService))
 ], TerminalAccessibleWidget));
 export { TerminalAccessibleWidget };

package/vscode/src/vs/workbench/contrib/terminalContrib/accessibility/browser/textAreaSyncAddon.js

@@ -0,0 +1,98 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, MutableDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
+import { ITerminalLogService } from '../../../../../platform/terminal/common/terminal.js';
+import { debounce } from 'monaco-editor/esm/vs/base/common/decorators.js';
+import { addDisposableListener } from 'monaco-editor/esm/vs/base/browser/dom.js';
+let TextAreaSyncAddon = class TextAreaSyncAddon extends Disposable {
+    activate(terminal) {
+        this._terminal = terminal;
+        if (this._accessibilityService.isScreenReaderOptimized()) {
+            this._registerSyncListeners();
+        }
+    }
+    constructor(_capabilities, _accessibilityService, _logService) {
+        super();
+        this._capabilities = _capabilities;
+        this._accessibilityService = _accessibilityService;
+        this._logService = _logService;
+        this._listeners = this._register(( new MutableDisposable()));
+        this._register(this._accessibilityService.onDidChangeScreenReaderOptimized(() => {
+            if (this._accessibilityService.isScreenReaderOptimized()) {
+                this._syncTextArea();
+                this._registerSyncListeners();
+            }
+            else {
+                this._listeners.clear();
+            }
+        }));
+    }
+    _registerSyncListeners() {
+        if (this._accessibilityService.isScreenReaderOptimized() && this._terminal?.textarea) {
+            this._listeners.value = ( new DisposableStore());
+            this._listeners.value.add(this._terminal.onCursorMove(() => this._syncTextArea()));
+            this._listeners.value.add(this._terminal.onData(() => this._syncTextArea()));
+            this._listeners.value.add(addDisposableListener(this._terminal.textarea, 'focus', () => this._syncTextArea()));
+        }
+    }
+    _syncTextArea() {
+        this._logService.debug('TextAreaSyncAddon#syncTextArea');
+        const textArea = this._terminal?.textarea;
+        if (!textArea) {
+            this._logService.debug(`TextAreaSyncAddon#syncTextArea: no textarea`);
+            return;
+        }
+        this._updateCommandAndCursor();
+        if (this._currentCommand !== textArea.value) {
+            textArea.value = this._currentCommand || '';
+            this._logService.debug(`TextAreaSyncAddon#syncTextArea: text changed to "${this._currentCommand}"`);
+        }
+        else if (!this._currentCommand) {
+            textArea.value = '';
+            this._logService.debug(`TextAreaSyncAddon#syncTextArea: text cleared`);
+        }
+        if (this._cursorX !== textArea.selectionStart) {
+            textArea.selectionStart = this._cursorX ?? 0;
+            textArea.selectionEnd = this._cursorX ?? 0;
+            this._logService.debug(`TextAreaSyncAddon#syncTextArea: selection start/end changed to ${this._cursorX}`);
+        }
+    }
+    _updateCommandAndCursor() {
+        if (!this._terminal) {
+            return;
+        }
+        const commandCapability = this._capabilities.get(2 );
+        const currentCommand = commandCapability?.currentCommand;
+        if (!currentCommand) {
+            this._logService.debug(`TextAreaSyncAddon#updateCommandAndCursor: no current command`);
+            return;
+        }
+        const buffer = this._terminal.buffer.active;
+        const lineNumber = currentCommand.commandStartMarker?.line;
+        if (!lineNumber) {
+            return;
+        }
+        const commandLine = buffer.getLine(lineNumber)?.translateToString(true);
+        if (!commandLine) {
+            this._logService.debug(`TextAreaSyncAddon#updateCommandAndCursor: no line`);
+            return;
+        }
+        if (currentCommand.commandStartX !== undefined) {
+            this._currentCommand = commandLine.substring(currentCommand.commandStartX);
+            this._cursorX = buffer.cursorX - currentCommand.commandStartX;
+        }
+        else {
+            this._currentCommand = undefined;
+            this._cursorX = undefined;
+            this._logService.debug(`TextAreaSyncAddon#updateCommandAndCursor: no commandStartX`);
+        }
+    }
+};
+TextAreaSyncAddon.__decorator = ( __decorate([
+    debounce(50)
+], TextAreaSyncAddon.prototype, "_syncTextArea", null));
+TextAreaSyncAddon = ( __decorate([
+    ( __param(1, IAccessibilityService)),
+    ( __param(2, ITerminalLogService))
+], TextAreaSyncAddon));
+export { TextAreaSyncAddon };

package/vscode/src/vs/workbench/contrib/terminalContrib/quickFix/browser/quickFix.js

@@ -1,3 +1,10 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 const ITerminalQuickFixService = ( createDecorator('terminalQuickFixService'));
-export { ITerminalQuickFixService };
+var TerminalQuickFixType;
+( (function(TerminalQuickFixType) {
+    TerminalQuickFixType[TerminalQuickFixType["TerminalCommand"] = 0] = "TerminalCommand";
+    TerminalQuickFixType[TerminalQuickFixType["Opener"] = 1] = "Opener";
+    TerminalQuickFixType[TerminalQuickFixType["Port"] = 2] = "Port";
+    TerminalQuickFixType[TerminalQuickFixType["VscodeCommand"] = 3] = "VscodeCommand";
+})(TerminalQuickFixType || (TerminalQuickFixType = {})));
+export { ITerminalQuickFixService, TerminalQuickFixType };

package/vscode/src/vs/workbench/contrib/terminalContrib/quickFix/browser/terminalQuickFixService.js

@@ -135,6 +135,18 @@ const quickFixExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
                         'The command exited with an exit code of zero.',
                         'The command exited with a non-zero exit code.'
                     ]
+                },
+                kind: {
+                    description: ( localize(
+                        'vscode.extension.contributes.terminalQuickFixes.kind',
+                        "The kind of the resulting quick fix. This changes how the quick fix is presented. Defaults to {0}.",
+                        '`"fix"`'
+                    )),
+                    enum: ['default', 'explain'],
+                    enumDescriptions: [
+                        'A high confidence quick fix.',
+                        'An explanation of the problem.'
+                    ]
                 }
             },
         }