@codingame/monaco-vscode-extensions-service-override 15.0.3 → 16.0.0

package/vscode/src/vs/workbench/api/browser/mainThreadMcp.js

@@ -0,0 +1,166 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableMap, DisposableStore, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { LogLevel } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log';
+import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
+import { mcpEnabledSection } from '@codingame/monaco-vscode-ec21d4de-4d65-574c-8715-bb1a6bbad376-common/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
+import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
+import { McpServerTransportType, McpServerDefinition, McpConnectionState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { ExtensionHostKind, extensionHostKindToString } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensionHostKind';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
+
+let MainThreadMcp = class MainThreadMcp extends Disposable {
+    constructor(_extHostContext, _mcpRegistry, configurationService) {
+        super();
+        this._extHostContext = _extHostContext;
+        this._mcpRegistry = _mcpRegistry;
+        this._serverIdCounter = 0;
+        this._servers = ( new Map());
+        this._collectionDefinitions = this._register(( new DisposableMap()));
+        const proxy = ( _extHostContext.getProxy(ExtHostContext.ExtHostMcp));
+        this._mcpEnabled = observableConfigValue(mcpEnabledSection, true, configurationService);
+        this._register(this._mcpRegistry.registerDelegate({
+            priority: _extHostContext.extensionHostKind === ExtensionHostKind.LocalWebWorker ? 0 : 1,
+            waitForInitialProviderPromises() {
+                return proxy.$waitForInitialCollectionProviders();
+            },
+            canStart(collection, serverDefinition) {
+                if (collection.remoteAuthority !== _extHostContext.remoteAuthority) {
+                    return false;
+                }
+                if (serverDefinition.launch.type === McpServerTransportType.Stdio && _extHostContext.extensionHostKind === ExtensionHostKind.LocalWebWorker) {
+                    return false;
+                }
+                return true;
+            },
+            start: (collection, _serverDefiniton, resolveLaunch) => {
+                const id = ++this._serverIdCounter;
+                const launch = ( new ExtHostMcpServerLaunch(
+                    _extHostContext.extensionHostKind,
+                    () => proxy.$stopMcp(id),
+                    msg => proxy.$sendMessage(id, JSON.stringify(msg))
+                ));
+                this._servers.set(id, launch);
+                proxy.$startMcp(id, resolveLaunch);
+                return launch;
+            },
+        }));
+    }
+    $upsertMcpCollection(collection, serversDto) {
+        const servers = ( serversDto.map(McpServerDefinition.fromSerialized));
+        const existing = this._collectionDefinitions.get(collection.id);
+        if (existing) {
+            existing.servers.set(servers, undefined);
+        }
+        else {
+            const serverDefinitions = observableValue('mcpServers', servers);
+            const store = ( new DisposableStore());
+            const handle = store.add(( new MutableDisposable()));
+            store.add(autorun(reader => {
+                if (this._mcpEnabled.read(reader)) {
+                    handle.value = this._mcpRegistry.registerCollection({
+                        ...collection,
+                        remoteAuthority: this._extHostContext.remoteAuthority,
+                        serverDefinitions,
+                    });
+                }
+                else {
+                    handle.clear();
+                }
+            }));
+            this._collectionDefinitions.set(collection.id, {
+                fromExtHost: collection,
+                servers: serverDefinitions,
+                dispose: () => store.dispose(),
+            });
+        }
+    }
+    $deleteMcpCollection(collectionId) {
+        this._collectionDefinitions.deleteAndDispose(collectionId);
+    }
+    $onDidChangeState(id, update) {
+        const server = this._servers.get(id);
+        if (!server) {
+            return;
+        }
+        server.state.set(update, undefined);
+        if (!McpConnectionState.isRunning(update)) {
+            server.dispose();
+            this._servers.delete(id);
+        }
+    }
+    $onDidPublishLog(id, level, log) {
+        if (typeof level === 'string') {
+            level = LogLevel.Info;
+            log = level;
+        }
+        this._servers.get(id)?.pushLog(level, log);
+    }
+    $onDidReceiveMessage(id, message) {
+        this._servers.get(id)?.pushMessage(message);
+    }
+    dispose() {
+        for (const server of ( this._servers.values())) {
+            server.extHostDispose();
+        }
+        this._servers.clear();
+        super.dispose();
+    }
+};
+MainThreadMcp = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadMcp),
+    ( __param(1, IMcpRegistry)),
+    ( __param(2, IConfigurationService))
+], MainThreadMcp);
+class ExtHostMcpServerLaunch extends Disposable {
+    pushLog(level, message) {
+        this._onDidLog.fire({ message, level });
+    }
+    pushMessage(message) {
+        let parsed;
+        try {
+            parsed = JSON.parse(message);
+        }
+        catch (e) {
+            this.pushLog(LogLevel.Warning, `Failed to parse message: ${JSON.stringify(message)}`);
+        }
+        if (parsed) {
+            this._onDidReceiveMessage.fire(parsed);
+        }
+    }
+    constructor(extHostKind, stop, send) {
+        super();
+        this.stop = stop;
+        this.send = send;
+        this.state = observableValue('mcpServerState', { state: McpConnectionState.Kind.Starting });
+        this._onDidLog = this._register(( new Emitter()));
+        this.onDidLog = this._onDidLog.event;
+        this._onDidReceiveMessage = this._register(( new Emitter()));
+        this.onDidReceiveMessage = this._onDidReceiveMessage.event;
+        this._register(disposableTimeout(() => {
+            this.pushLog(LogLevel.Info, `Starting server from ${extensionHostKindToString(extHostKind)} extension host`);
+        }));
+    }
+    extHostDispose() {
+        if (McpConnectionState.isRunning(this.state.get())) {
+            this.pushLog(LogLevel.Warning, 'Extension host shut down, server will stop.');
+            this.state.set({ state: McpConnectionState.Kind.Stopped }, undefined);
+        }
+        this.dispose();
+    }
+    dispose() {
+        if (McpConnectionState.isRunning(this.state.get())) {
+            this.stop();
+        }
+        super.dispose();
+    }
+}
+
+export { MainThreadMcp };

package/vscode/src/vs/workbench/api/browser/mainThreadMessageService.js

@@ -51,13 +51,13 @@ let MainThreadMessageService = class MainThreadMessageService {
                 };
             }
             if (!source) {
-                source = ( localize(2369, "Extension"));
+                source = ( localize(2408, "Extension"));
             }
             const secondaryActions = [];
             if (options.source) {
                 secondaryActions.push(toAction({
                     id: options.source.identifier.value,
-                    label: ( localize(2370, "Manage Extension")),
+                    label: ( localize(2409, "Manage Extension")),
                     run: () => {
                         return this._commandService.executeCommand('_extensions.manage', options.source.identifier.value);
                     }
@@ -92,13 +92,13 @@ let MainThreadMessageService = class MainThreadMessageService {
         if (!cancelButton) {
             if (buttons.length > 0) {
                 cancelButton = {
-                    label: ( localize(2371, "Cancel")),
+                    label: ( localize(2410, "Cancel")),
                     run: () => undefined
                 };
             }
             else {
                 cancelButton = {
-                    label: ( localize(2372, "&&OK")),
+                    label: ( localize(2411, "&&OK")),
                     run: () => undefined
                 };
             }

package/vscode/src/vs/workbench/api/browser/mainThreadNotebookDocuments.js

@@ -1,5 +1,6 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { DisposableStore, dispose } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
@@ -93,7 +94,7 @@ let MainThreadNotebookDocuments = class MainThreadNotebookDocuments {
     async $tryCreateNotebook(options) {
         if (options.content) {
             const ref = await this._notebookEditorModelResolverService.resolve({ untitledResource: undefined }, options.viewType);
-            ref.object.notebook.onWillDispose(() => {
+            Event.once(ref.object.notebook.onWillDispose)(() => {
                 ref.dispose();
             });
             this._proxy.$acceptDirtyStateChanged(ref.object.resource, true);

package/vscode/src/vs/workbench/api/browser/mainThreadNotebookSaveParticipant.js

@@ -6,7 +6,7 @@ import { extHostCustomer } from '../../services/extensions/common/extHostCustome
 import { ExtHostContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
 import { raceCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { IWorkingCopyFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service';
-import { NotebookFileWorkingCopyModel } from '@codingame/monaco-vscode-bba55be6-41a2-50cd-a3cc-8bafa35bfa89-common/vscode/vs/workbench/contrib/notebook/common/notebookEditorModel';
+import { NotebookFileWorkingCopyModel } from '@codingame/monaco-vscode-897bebad-39df-57cb-8a57-36a271d038be-common/vscode/vs/workbench/contrib/notebook/common/notebookEditorModel';
 
 class ExtHostNotebookDocumentSaveParticipant {
     constructor(extHostContext) {
@@ -18,7 +18,7 @@ class ExtHostNotebookDocumentSaveParticipant {
         }
         let _warningTimeout;
         const p = ( new Promise((resolve, reject) => {
-            _warningTimeout = setTimeout(() => reject(( new Error(( localize(2373, "Aborted onWillSaveNotebookDocument-event after 1750ms"))))), 1750);
+            _warningTimeout = setTimeout(() => reject(( new Error(( localize(2412, "Aborted onWillSaveNotebookDocument-event after 1750ms"))))), 1750);
             this._proxy.$participateInSave(workingCopy.resource, context.reason, token).then(_ => {
                 clearTimeout(_warningTimeout);
                 return undefined;

package/vscode/src/vs/workbench/api/browser/mainThreadOutputService.js

@@ -69,11 +69,11 @@ let MainThreadOutputService = class MainThreadOutputService extends Disposable {
     }
     _showChannelQuietly(channel) {
         const statusProperties = {
-            name: ( localize(2374, "Show Output")),
+            name: ( localize(2413, "Show Output")),
             text: '$(output)',
-            ariaLabel: ( localize(2375, "Show {0} Output Channel", channel.label)),
+            ariaLabel: ( localize(2414, "Show {0} Output Channel", channel.label)),
             command: `workbench.action.output.show.${channel.id}`,
-            tooltip: ( localize(2376, "Show {0} Output Channel", channel.label)),
+            tooltip: ( localize(2415, "Show {0} Output Channel", channel.label)),
             kind: 'prominent'
         };
         if (!this._outputStatusItem.value) {

package/vscode/src/vs/workbench/api/browser/mainThreadProgress.js

@@ -28,7 +28,7 @@ let MainThreadProgress = class MainThreadProgress {
                 location: ProgressLocation.Notification,
                 secondaryActions: [toAction({
                         id: extensionId,
-                        label: ( localize(2377, "Manage Extension")),
+                        label: ( localize(2416, "Manage Extension")),
                         run: () => this._commandService.executeCommand('_extensions.manage', extensionId)
                     })]
             };

package/vscode/src/vs/workbench/api/browser/mainThreadSaveParticipant.js

@@ -17,7 +17,7 @@ class ExtHostSaveParticipant {
             return undefined;
         }
         const p = ( new Promise((resolve, reject) => {
-            setTimeout(() => reject(( new Error(( localize(2378, "Aborted onWillSaveTextDocument-event after 1750ms"))))), 1750);
+            setTimeout(() => reject(( new Error(( localize(2417, "Aborted onWillSaveTextDocument-event after 1750ms"))))), 1750);
             this._proxy.$participateInSave(editorModel.resource, context.reason).then(values => {
                 if (!values.every(success => success)) {
                     return Promise.reject(( new Error('listener failed')));

package/vscode/src/vs/workbench/api/browser/mainThreadTask.d.ts

@@ -3,8 +3,21 @@ import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs
 import { ITaskService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/taskService.service";
 import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
 import { MainThreadTaskShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
-import { ITaskExecutionDTO, ITaskDTO, ITaskHandleDTO, ITaskFilterDTO, ITaskSystemInfoDTO } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/shared/tasks";
+import { ITaskExecutionDTO, ITaskDTO, ITaskHandleDTO, ITaskFilterDTO, ITaskSystemInfoDTO, ITaskProblemMatcherStarted, ITaskProblemMatcherEnded } from "../common/shared/tasks.js";
 import { IConfigurationResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolver.service";
+export interface ITaskProblemMatcherStartedDto {
+    execution: ITaskExecutionDTO;
+}
+export declare namespace TaskProblemMatcherStartedDto {
+    function from(value: ITaskProblemMatcherStarted): ITaskProblemMatcherStartedDto;
+}
+export interface ITaskProblemMatcherEndedDto {
+    execution: ITaskExecutionDTO;
+    hasErrors: boolean;
+}
+export declare namespace TaskProblemMatcherEndedDto {
+    function from(value: ITaskProblemMatcherEnded): ITaskProblemMatcherEndedDto;
+}
 export declare class MainThreadTask extends Disposable implements MainThreadTaskShape {
     private readonly _taskService;
     private readonly _workspaceContextServer;

package/vscode/src/vs/workbench/api/browser/mainThreadTask.js

@@ -7,12 +7,14 @@ import { isString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/typ
 import { platform, Platform } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
-import { TaskDefinition, PresentationOptions, RunOptions, CommandOptions, RuntimeType, TaskSourceKind, TaskScope, CustomTask, ContributedTask, ConfiguringTask, TaskEventKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/tasks';
+import { TaskDefinition, PresentationOptions, RunOptions, CommandOptions, RuntimeType, TaskSourceKind, TaskScope, CustomTask, ContributedTask, ConfiguringTask } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/tasks';
 import { ITaskService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/taskService.service';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+import { TaskEventKind } from '../common/shared/tasks.js';
 import { IConfigurationResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolver.service';
 import { ErrorNoTelemetry } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { ConfigurationResolverExpression } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolverExpression';
 
 var TaskExecutionDTO;
 (function (TaskExecutionDTO) {
@@ -24,6 +26,31 @@ var TaskExecutionDTO;
     }
     TaskExecutionDTO.from = from;
 })(TaskExecutionDTO || (TaskExecutionDTO = {}));
+var TaskProblemMatcherStartedDto;
+(function (TaskProblemMatcherStartedDto) {
+    function from(value) {
+        return {
+            execution: {
+                id: value.execution.id,
+                task: TaskDTO.from(value.execution.task)
+            },
+        };
+    }
+    TaskProblemMatcherStartedDto.from = from;
+})(TaskProblemMatcherStartedDto || (TaskProblemMatcherStartedDto = {}));
+var TaskProblemMatcherEndedDto;
+(function (TaskProblemMatcherEndedDto) {
+    function from(value) {
+        return {
+            execution: {
+                id: value.execution.id,
+                task: TaskDTO.from(value.execution.task)
+            },
+            hasErrors: value.hasErrors
+        };
+    }
+    TaskProblemMatcherEndedDto.from = from;
+})(TaskProblemMatcherEndedDto || (TaskProblemMatcherEndedDto = {}));
 var TaskProcessStartedDTO;
 (function (TaskProcessStartedDTO) {
     function from(value, processId) {
@@ -378,7 +405,7 @@ var TaskDTO;
         }
         command.presentation = TaskPresentationOptionsDTO.to(task.presentationOptions);
         const source = TaskSourceDTO.to(task.source, workspace);
-        const label = ( localize(2379, '{0}: {1}', source.label, task.name));
+        const label = ( localize(2418, '{0}: {1}', source.label, task.name));
         const definition = TaskDefinitionDTO.to(task.definition, executeOnly);
         const id = (CustomExecutionDTO.is(task.execution) && task._id) ? task._id : `${task.source.extensionId}.${definition._key}`;
         const result = ( new ContributedTask(
@@ -437,11 +464,14 @@ let MainThreadTask = class MainThreadTask extends Disposable {
                 const execution = TaskExecutionDTO.from(task.getTaskExecution());
                 let resolvedDefinition = execution.task.definition;
                 if (execution.task?.execution && CustomExecutionDTO.is(execution.task.execution) && event.resolvedVariables) {
-                    const dictionary = {};
-                    for (const [key, value] of event.resolvedVariables.entries()) {
-                        dictionary[key] = value;
+                    const expr = ConfigurationResolverExpression.parse(execution.task.definition);
+                    for (const replacement of expr.unresolved()) {
+                        const value = event.resolvedVariables.get(replacement.inner);
+                        if (value !== undefined) {
+                            expr.resolve(replacement, value);
+                        }
                     }
-                    resolvedDefinition = await this._configurationResolverService.resolveAnyAsync(task.getWorkspaceFolder(), execution.task.definition, dictionary);
+                    resolvedDefinition = await this._configurationResolverService.resolveAsync(task.getWorkspaceFolder(), expr);
                 }
                 this._proxy.$onDidStartTask(execution, event.terminalId, resolvedDefinition);
             }
@@ -454,6 +484,15 @@ let MainThreadTask = class MainThreadTask extends Disposable {
             else if (event.kind === TaskEventKind.End) {
                 this._proxy.$OnDidEndTask(TaskExecutionDTO.from(task.getTaskExecution()));
             }
+            else if (event.kind === TaskEventKind.ProblemMatcherStarted) {
+                this._proxy.$onDidStartTaskProblemMatchers(TaskProblemMatcherStartedDto.from({ execution: task.getTaskExecution() }));
+            }
+            else if (event.kind === TaskEventKind.ProblemMatcherEnded) {
+                this._proxy.$onDidEndTaskProblemMatchers(TaskProblemMatcherEndedDto.from({ execution: task.getTaskExecution(), hasErrors: false }));
+            }
+            else if (event.kind === TaskEventKind.ProblemMatcherFoundErrors) {
+                this._proxy.$onDidEndTaskProblemMatchers(TaskProblemMatcherEndedDto.from({ execution: task.getTaskExecution(), hasErrors: true }));
+            }
         }));
     }
     dispose() {
@@ -730,4 +769,4 @@ MainThreadTask = __decorate([
     ( __param(3, IConfigurationResolverService))
 ], MainThreadTask);
 
-export { MainThreadTask };
+export { MainThreadTask, TaskProblemMatcherEndedDto, TaskProblemMatcherStartedDto };

package/vscode/src/vs/workbench/api/browser/mainThreadTerminalShellIntegration.d.ts

@@ -9,4 +9,5 @@ export declare class MainThreadTerminalShellIntegration extends Disposable imple
     constructor(extHostContext: IExtHostContext, _terminalService: ITerminalService, workbenchEnvironmentService: IWorkbenchEnvironmentService);
     $executeCommand(terminalId: number, commandLine: string): void;
     private _convertCwdToUri;
+    private _enableShellIntegration;
 }

package/vscode/src/vs/workbench/api/browser/mainThreadTerminalShellIntegration.js

@@ -22,20 +22,18 @@ let MainThreadTerminalShellIntegration = class MainThreadTerminalShellIntegratio
             }
         }));
         for (const terminal of this._terminalService.instances) {
-            if (( terminal.capabilities.has(TerminalCapability.CommandDetection))) {
-                this._proxy.$shellIntegrationChange(terminal.instanceId);
-                const cwdDetection = terminal.capabilities.get(TerminalCapability.CwdDetection);
-                if (cwdDetection) {
-                    this._proxy.$cwdChange(terminal.instanceId, this._convertCwdToUri(cwdDetection.getCwd()));
-                }
+            const cmdDetection = terminal.capabilities.get(TerminalCapability.CommandDetection);
+            if (cmdDetection) {
+                this._enableShellIntegration(terminal);
             }
         }
         const onDidAddCommandDetection = this._store.add(this._terminalService.createOnInstanceEvent(instance => {
-            return ( Event.map(Event.filter(instance.capabilities.onDidAddCapabilityType, e => {
-                return e === TerminalCapability.CommandDetection || e === TerminalCapability.CwdDetection;
-            }), () => instance));
+            return ( Event.map(
+                Event.filter(instance.capabilities.onDidAddCapabilityType, e => e === TerminalCapability.CommandDetection),
+                () => instance
+            ));
         })).event;
-        this._store.add(onDidAddCommandDetection(e => this._proxy.$shellIntegrationChange(e.instanceId)));
+        this._store.add(onDidAddCommandDetection(e => this._enableShellIntegration(e)));
         const cwdChangeEvent = this._store.add(this._terminalService.createOnInstanceCapabilityEvent(TerminalCapability.CwdDetection, e => e.onDidChangeCwd));
         this._store.add(cwdChangeEvent.event(e => {
             this._proxy.$cwdChange(e.instance.instanceId, this._convertCwdToUri(e.data));
@@ -78,6 +76,13 @@ let MainThreadTerminalShellIntegration = class MainThreadTerminalShellIntegratio
     _convertCwdToUri(cwd) {
         return cwd ? URI.file(cwd) : undefined;
     }
+    _enableShellIntegration(instance) {
+        this._proxy.$shellIntegrationChange(instance.instanceId);
+        const cwdDetection = instance.capabilities.get(TerminalCapability.CwdDetection);
+        if (cwdDetection) {
+            this._proxy.$cwdChange(instance.instanceId, this._convertCwdToUri(cwdDetection.getCwd()));
+        }
+    }
 };
 MainThreadTerminalShellIntegration = __decorate([
     extHostNamedCustomer(MainContext.MainThreadTerminalShellIntegration),

package/vscode/src/vs/workbench/api/browser/mainThreadTunnelService.js

@@ -112,13 +112,13 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
     }
     async elevationPrompt(tunnelOptions, tunnel, source) {
         return this.notificationService.prompt(Severity.Info, ( localize(
-            2380,
+            2419,
             "The extension {0} has forwarded port {1}. You'll need to run as superuser to use port {2} locally.",
             source,
             tunnelOptions.remoteAddress.port,
             tunnelOptions.localAddressPort
         )), [{
-                label: ( localize(2381, "Use Port {0} as Sudo...", tunnel.tunnelRemotePort)),
+                label: ( localize(2420, "Use Port {0} as Sudo...", tunnel.tunnelRemotePort)),
                 run: async () => {
                     this.elevateionRetry = true;
                     await this.remoteExplorerService.close({ host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort }, TunnelCloseReason.Other);

package/vscode/src/vs/workbench/api/browser/mainThreadUriOpeners.js

@@ -10,7 +10,7 @@ import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/pla
 import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
 import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
-import { defaultExternalUriOpenerId } from '@codingame/monaco-vscode-bd6ad8b7-9db3-51a8-9895-0046508c029d-common/vscode/vs/workbench/contrib/externalUriOpener/common/configuration';
+import { defaultExternalUriOpenerId } from '@codingame/monaco-vscode-2a94c04a-b85b-5669-b06b-89c1bfa11cb9-common/vscode/vs/workbench/contrib/externalUriOpener/common/configuration';
 import { ContributedExternalUriOpenersStore } from '../../contrib/externalUriOpener/common/contributedOpeners.js';
 import { IExternalUriOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/externalUriOpener/common/externalUriOpenerService.service';
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
@@ -52,7 +52,7 @@ let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
                 }
                 catch (e) {
                     if (!isCancellationError(e)) {
-                        const openDefaultAction = ( new Action('default', ( localize(2382, "Open using default opener")), undefined, undefined, async () => {
+                        const openDefaultAction = ( new Action('default', ( localize(2421, "Open using default opener")), undefined, undefined, async () => {
                             await this.openerService.open(uri, {
                                 allowTunneling: false,
                                 allowContributedOpeners: defaultExternalUriOpenerId,
@@ -61,7 +61,7 @@ let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
                         openDefaultAction.tooltip = ( uri.toString());
                         this.notificationService.notify({
                             severity: Severity.Error,
-                            message: ( localize(2383, 'Could not open uri with \'{0}\': {1}', id, (e.toString()))),
+                            message: ( localize(2422, 'Could not open uri with \'{0}\': {1}', id, (e.toString()))),
                             actions: {
                                 primary: [
                                     openDefaultAction

package/vscode/src/vs/workbench/api/browser/mainThreadUrls.d.ts

@@ -2,14 +2,16 @@ import { MainThreadUrlsShape } from "@codingame/monaco-vscode-api/vscode/vs/work
 import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
 import { IURLService } from "@codingame/monaco-vscode-api/vscode/vs/platform/url/common/url.service";
 import { URI, UriComponents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { IExtensionUrlHandler } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/browser/extensionUrlHandler.service";
 import { ExtensionIdentifier } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions";
-export declare class MainThreadUrls implements MainThreadUrlsShape {
+import { ITrustedDomainService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/url/browser/trustedDomainService.service";
+export declare class MainThreadUrls extends Disposable implements MainThreadUrlsShape {
     private readonly urlService;
     private readonly extensionUrlHandler;
     private readonly proxy;
-    private handlers;
-    constructor(context: IExtHostContext, urlService: IURLService, extensionUrlHandler: IExtensionUrlHandler);
+    private readonly handlers;
+    constructor(context: IExtHostContext, trustedDomainService: ITrustedDomainService, urlService: IURLService, extensionUrlHandler: IExtensionUrlHandler);
     $registerUriHandler(handle: number, extensionId: ExtensionIdentifier, extensionDisplayName: string): Promise<void>;
     $unregisterUriHandler(handle: number): Promise<void>;
     $createAppUri(uri: UriComponents): Promise<URI>;

package/vscode/src/vs/workbench/api/browser/mainThreadUrls.js

@@ -3,8 +3,10 @@ import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib
 import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { IURLService } from '@codingame/monaco-vscode-api/vscode/vs/platform/url/common/url.service';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { IExtensionUrlHandler } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/browser/extensionUrlHandler.service';
 import { ExtensionIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions';
+import { ITrustedDomainService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/url/browser/trustedDomainService.service';
 
 class ExtensionUrlHandler {
     constructor(proxy, handle, extensionId, extensionDisplayName) {
@@ -13,50 +15,54 @@ class ExtensionUrlHandler {
         this.extensionId = extensionId;
         this.extensionDisplayName = extensionDisplayName;
     }
-    handleURL(uri, options) {
+    async handleURL(uri, options) {
         if (!ExtensionIdentifier.equals(this.extensionId, uri.authority)) {
-            return Promise.resolve(false);
+            return false;
         }
-        return Promise.resolve(this.proxy.$handleExternalUri(this.handle, uri)).then(() => true);
+        await this.proxy.$handleExternalUri(this.handle, uri);
+        return true;
     }
 }
-let MainThreadUrls = class MainThreadUrls {
-    constructor(context, urlService, extensionUrlHandler) {
+let MainThreadUrls = class MainThreadUrls extends Disposable {
+    constructor(context, trustedDomainService, urlService, extensionUrlHandler) {
+        super();
         this.urlService = urlService;
         this.extensionUrlHandler = extensionUrlHandler;
         this.handlers = ( new Map());
         this.proxy = ( context.getProxy(ExtHostContext.ExtHostUrls));
     }
-    $registerUriHandler(handle, extensionId, extensionDisplayName) {
+    async $registerUriHandler(handle, extensionId, extensionDisplayName) {
         const handler = ( new ExtensionUrlHandler(this.proxy, handle, extensionId, extensionDisplayName));
         const disposable = this.urlService.registerHandler(handler);
         this.handlers.set(handle, { extensionId, disposable });
         this.extensionUrlHandler.registerExtensionHandler(extensionId, handler);
-        return Promise.resolve(undefined);
+        return undefined;
     }
-    $unregisterUriHandler(handle) {
+    async $unregisterUriHandler(handle) {
         const tuple = this.handlers.get(handle);
         if (!tuple) {
-            return Promise.resolve(undefined);
+            return undefined;
         }
         const { extensionId, disposable } = tuple;
         this.extensionUrlHandler.unregisterExtensionHandler(extensionId);
         this.handlers.delete(handle);
         disposable.dispose();
-        return Promise.resolve(undefined);
+        return undefined;
     }
     async $createAppUri(uri) {
         return this.urlService.create(uri);
     }
     dispose() {
+        super.dispose();
         this.handlers.forEach(({ disposable }) => disposable.dispose());
         this.handlers.clear();
     }
 };
 MainThreadUrls = __decorate([
     extHostNamedCustomer(MainContext.MainThreadUrls),
-    ( __param(1, IURLService)),
-    ( __param(2, IExtensionUrlHandler))
+    ( __param(1, ITrustedDomainService)),
+    ( __param(2, IURLService)),
+    ( __param(3, IExtensionUrlHandler))
 ], MainThreadUrls);
 
 export { MainThreadUrls };

package/vscode/src/vs/workbench/api/browser/mainThreadWebviewPanels.js

@@ -96,7 +96,8 @@ let MainThreadWebviewPanels = class MainThreadWebviewPanels extends Disposable {
     addWebviewInput(handle, input, options) {
         this._webviewInputs.add(handle, input);
         this._mainThreadWebviews.addWebview(handle, input.webview, options);
-        input.webview.onDidDispose(() => {
+        const disposeSub = input.webview.onDidDispose(() => {
+            disposeSub.dispose();
             this._proxy.$onDidDisposeWebviewPanel(handle).finally(() => {
                 this._webviewInputs.delete(handle);
             });

package/vscode/src/vs/workbench/api/browser/mainThreadWebviews.js

@@ -104,7 +104,7 @@ let MainThreadWebviews = class MainThreadWebviews extends Disposable {
 				<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
 				<meta http-equiv="Content-Security-Policy" content="default-src 'none';">
 			</head>
-			<body>${( localize(2384, "An error occurred while loading view: {0}", escape(viewType)))}</body>
+			<body>${( localize(2423, "An error occurred while loading view: {0}", escape(viewType)))}</body>
 		</html>`;
     }
 };