@codingame/monaco-vscode-api 1.81.8-next.3 → 1.82.1

package/vscode/src/vs/workbench/api/common/extHostTerminalService.js

@@ -4,7 +4,7 @@ import { MainContext } from './extHost.protocol.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
-import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Disposable, MutableDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { Disposable as Disposable$1, EnvironmentVariableMutatorType } from './extHostTypes.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { NotSupportedError } from 'monaco-editor/esm/vs/base/common/errors.js';
@@ -13,10 +13,9 @@ import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancel
 import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
 import { TerminalDataBufferer } from '../../../platform/terminal/common/terminalDataBuffering.js';
 import { ThemeColor } from 'monaco-editor/esm/vs/base/common/themables.js';
-import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
 import { Promises } from 'monaco-editor/esm/vs/base/common/async.js';
-import { ViewColumn } from './extHostTypeConverters.js';
-import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
+import { TerminalQuickFix, ViewColumn } from './extHostTypeConverters.js';
+import { IExtHostCommands } from './extHostCommands.js';
 const IExtHostTerminalService = ( createDecorator('IExtHostTerminalService'));
 class ExtHostTerminal {
     constructor(_proxy, _id, _creationOptions, _name) {
@@ -84,20 +83,20 @@ class ExtHostTerminal {
         }
         await this._proxy.$createTerminal(this._id, {
             name: options.name,
-            shellPath: withNullAsUndefined(options.shellPath),
-            shellArgs: withNullAsUndefined(options.shellArgs),
-            cwd: withNullAsUndefined(options.cwd),
-            env: withNullAsUndefined(options.env),
-            icon: withNullAsUndefined(asTerminalIcon(options.iconPath)),
+            shellPath: options.shellPath ?? undefined,
+            shellArgs: options.shellArgs ?? undefined,
+            cwd: options.cwd ?? undefined,
+            env: options.env ?? undefined,
+            icon: asTerminalIcon(options.iconPath) ?? undefined,
             color: ThemeColor.isThemeColor(options.color) ? options.color.id : undefined,
-            initialText: withNullAsUndefined(options.message),
-            strictEnv: withNullAsUndefined(options.strictEnv),
-            hideFromUser: withNullAsUndefined(options.hideFromUser),
-            isFeatureTerminal: withNullAsUndefined(internalOptions?.isFeatureTerminal),
+            initialText: options.message ?? undefined,
+            strictEnv: options.strictEnv ?? undefined,
+            hideFromUser: options.hideFromUser ?? undefined,
+            isFeatureTerminal: internalOptions?.isFeatureTerminal ?? undefined,
             isExtensionOwnedTerminal: true,
-            useShellEnvironment: withNullAsUndefined(internalOptions?.useShellEnvironment),
+            useShellEnvironment: internalOptions?.useShellEnvironment ?? undefined,
             location: internalOptions?.location || this._serializeParentTerminal(options.location, internalOptions?.resolvedExtHostIdentifier),
-            isTransient: withNullAsUndefined(options.isTransient)
+            isTransient: options.isTransient ?? undefined,
         });
     }
     async createExtensionTerminal(location, parentTerminal, iconPath, color) {
@@ -245,15 +244,16 @@ let nextLinkId = 1;
 let BaseExtHostTerminalService = class BaseExtHostTerminalService extends Disposable {
     get activeTerminal() { return this._activeTerminal?.value; }
     get terminals() { return ( this._terminals.map(term => term.value)); }
-    get onDidWriteTerminalData() { return this._onDidWriteTerminalData.event; }
-    constructor(supportsProcesses, extHostRpc) {
+    constructor(supportsProcesses, _extHostCommands, extHostRpc) {
         super();
+        this._extHostCommands = _extHostCommands;
         this._terminals = [];
         this._terminalProcesses = ( new Map());
         this._terminalProcessDisposables = {};
         this._extensionTerminalAwaitingStart = {};
         this._getTerminalPromises = {};
         this._environmentVariableCollections = ( new Map());
+        this._lastQuickFixCommands = this._register(( new MutableDisposable()));
         this._linkProviders = ( new Set());
         this._profileProviders = ( new Map());
         this._quickFixProviders = ( new Map());
@@ -271,12 +271,18 @@ let BaseExtHostTerminalService = class BaseExtHostTerminalService extends Dispos
         this.onDidChangeTerminalState = this._onDidChangeTerminalState.event;
         this._onDidChangeShell = ( new Emitter());
         this.onDidChangeShell = this._onDidChangeShell.event;
-        this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadTerminalService));
-        this._bufferer = ( new TerminalDataBufferer(this._proxy.$sendProcessData));
         this._onDidWriteTerminalData = ( new Emitter({
             onWillAddFirstListener: () => this._proxy.$startSendingDataEvents(),
             onDidRemoveLastListener: () => this._proxy.$stopSendingDataEvents()
         }));
+        this.onDidWriteTerminalData = this._onDidWriteTerminalData.event;
+        this._onDidExecuteCommand = ( new Emitter({
+            onWillAddFirstListener: () => this._proxy.$startSendingCommandEvents(),
+            onDidRemoveLastListener: () => this._proxy.$stopSendingCommandEvents()
+        }));
+        this.onDidExecuteTerminalCommand = this._onDidExecuteCommand.event;
+        this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadTerminalService));
+        this._bufferer = ( new TerminalDataBufferer(this._proxy.$sendProcessData));
         this._proxy.$registerProcessSupport(supportsProcesses);
         this._register({
             dispose: () => {
@@ -366,6 +372,12 @@ let BaseExtHostTerminalService = class BaseExtHostTerminalService extends Dispos
             }
         }
     }
+    async $acceptDidExecuteCommand(id, command) {
+        const terminal = this._getTerminalById(id);
+        if (terminal) {
+            this._onDidExecuteCommand.fire({ terminal: terminal.value, ...command });
+        }
+    }
     async $acceptTerminalMaximumDimensions(id, cols, rows) {
         this._terminalProcesses.get(id)?.resize(cols, rows);
     }
@@ -533,12 +545,22 @@ let BaseExtHostTerminalService = class BaseExtHostTerminalService extends Dispos
             return;
         }
         const quickFixes = await provider.provideTerminalQuickFixes(matchResult, token);
-        if (quickFixes === null) {
+        if (quickFixes === null || (Array.isArray(quickFixes) && quickFixes.length === 0)) {
             return undefined;
         }
-        else {
-            return quickFixes;
+        const store = ( new DisposableStore());
+        this._lastQuickFixCommands.value = store;
+        if (!Array.isArray(quickFixes)) {
+            return quickFixes ? TerminalQuickFix.from(quickFixes, this._extHostCommands.converter, store) : undefined;
         }
+        const result = [];
+        for (const fix of quickFixes) {
+            const converted = TerminalQuickFix.from(fix, this._extHostCommands.converter, store);
+            if (converted) {
+                result.push(converted);
+            }
+        }
+        return result;
     }
     async $createContributedProfileTerminal(id, options) {
         const token = ( new CancellationTokenSource()).token;
@@ -642,7 +664,7 @@ let BaseExtHostTerminalService = class BaseExtHostTerminalService extends Dispos
     getEnvironmentVariableCollection(extension) {
         let collection = this._environmentVariableCollections.get(extension.identifier.value);
         if (!collection) {
-            collection = ( new UnifiedEnvironmentVariableCollection(extension));
+            collection = ( new UnifiedEnvironmentVariableCollection());
             this._setEnvironmentVariableCollection(extension.identifier.value, collection);
         }
         return collection.getScopedEnvironmentVariableCollection(undefined);
@@ -655,7 +677,7 @@ let BaseExtHostTerminalService = class BaseExtHostTerminalService extends Dispos
     $initEnvironmentVariableCollections(collections) {
         collections.forEach(entry => {
             const extensionIdentifier = entry[0];
-            const collection = ( new UnifiedEnvironmentVariableCollection(undefined, entry[1]));
+            const collection = ( new UnifiedEnvironmentVariableCollection(entry[1]));
             this._setEnvironmentVariableCollection(extensionIdentifier, collection);
         });
     }
@@ -675,7 +697,8 @@ let BaseExtHostTerminalService = class BaseExtHostTerminalService extends Dispos
     }
 };
 BaseExtHostTerminalService = ( __decorate([
-    ( __param(1, IExtHostRpcService))
+    ( __param(1, IExtHostCommands)),
+    ( __param(2, IExtHostRpcService))
 ], BaseExtHostTerminalService));
 class UnifiedEnvironmentVariableCollection {
     get persistent() { return this._persistent; }
@@ -684,9 +707,7 @@ class UnifiedEnvironmentVariableCollection {
         this._onDidChangeCollection.fire();
     }
     get onDidChangeCollection() { return this._onDidChangeCollection && this._onDidChangeCollection.event; }
-    constructor(
-    _extension, serialized) {
-        this._extension = _extension;
+    constructor(serialized) {
         this.map = ( new Map());
         this.scopedCollections = ( new Map());
         this.descriptionMap = ( new Map());
@@ -695,9 +716,6 @@ class UnifiedEnvironmentVariableCollection {
         this.map = ( new Map(serialized));
     }
     getScopedEnvironmentVariableCollection(scope) {
-        if (this._extension && scope) {
-            checkProposedApiEnabled(this._extension, 'envCollectionWorkspace');
-        }
         const scopedCollectionKey = this.getScopeKey(scope);
         let scopedCollection = this.scopedCollections.get(scopedCollectionKey);
         if (!scopedCollection) {
@@ -708,22 +726,13 @@ class UnifiedEnvironmentVariableCollection {
         return scopedCollection;
     }
     replace(variable, value, options, scope) {
-        if (this._extension && options) {
-            checkProposedApiEnabled(this._extension, 'envCollectionOptions');
-        }
-        this._setIfDiffers(variable, { value, type: EnvironmentVariableMutatorType.Replace, options: options ?? {}, scope });
+        this._setIfDiffers(variable, { value, type: EnvironmentVariableMutatorType.Replace, options: options ?? { applyAtProcessCreation: true }, scope });
     }
     append(variable, value, options, scope) {
-        if (this._extension && options) {
-            checkProposedApiEnabled(this._extension, 'envCollectionOptions');
-        }
-        this._setIfDiffers(variable, { value, type: EnvironmentVariableMutatorType.Append, options: options ?? {}, scope });
+        this._setIfDiffers(variable, { value, type: EnvironmentVariableMutatorType.Append, options: options ?? { applyAtProcessCreation: true }, scope });
     }
     prepend(variable, value, options, scope) {
-        if (this._extension && options) {
-            checkProposedApiEnabled(this._extension, 'envCollectionOptions');
-        }
-        this._setIfDiffers(variable, { value, type: EnvironmentVariableMutatorType.Prepend, options: options ?? {}, scope });
+        this._setIfDiffers(variable, { value, type: EnvironmentVariableMutatorType.Prepend, options: options ?? { applyAtProcessCreation: true }, scope });
     }
     _setIfDiffers(variable, mutator) {
         if (mutator.options && mutator.options.applyAtProcessCreation === false && !mutator.options.applyAtShellIntegration) {
@@ -731,20 +740,23 @@ class UnifiedEnvironmentVariableCollection {
         }
         const key = this.getKey(variable, mutator.scope);
         const current = this.map.get(key);
+        const newOptions = mutator.options ? {
+            applyAtProcessCreation: mutator.options.applyAtProcessCreation ?? false,
+            applyAtShellIntegration: mutator.options.applyAtShellIntegration ?? false,
+        } : {
+            applyAtProcessCreation: true
+        };
         if (!current ||
             current.value !== mutator.value ||
             current.type !== mutator.type ||
-            current.options?.applyAtProcessCreation !== (mutator.options.applyAtProcessCreation ?? true) ||
-            current.options?.applyAtShellIntegration !== (mutator.options.applyAtShellIntegration ?? false) ||
+            current.options?.applyAtProcessCreation !== newOptions.applyAtProcessCreation ||
+            current.options?.applyAtShellIntegration !== newOptions.applyAtShellIntegration ||
             current.scope?.workspaceFolder?.index !== mutator.scope?.workspaceFolder?.index) {
             const key = this.getKey(variable, mutator.scope);
             const value = {
                 variable,
                 ...mutator,
-                options: {
-                    applyAtProcessCreation: mutator.options.applyAtProcessCreation ?? true,
-                    applyAtShellIntegration: mutator.options.applyAtShellIntegration ?? false,
-                }
+                options: newOptions
             };
             this.map.set(key, value);
             this._onDidChangeCollection.fire();
@@ -830,7 +842,7 @@ class ScopedEnvironmentVariableCollection {
         this.scope = scope;
         this._onDidChangeCollection = ( new Emitter());
     }
-    getScopedEnvironmentVariableCollection(scope) {
+    getScoped(scope) {
         return this.collection.getScopedEnvironmentVariableCollection(scope);
     }
     replace(variable, value, options) {
@@ -866,8 +878,8 @@ class ScopedEnvironmentVariableCollection {
     }
 }
 let WorkerExtHostTerminalService = class WorkerExtHostTerminalService extends BaseExtHostTerminalService {
-    constructor(extHostRpc) {
-        super(false, extHostRpc);
+    constructor(extHostCommands, extHostRpc) {
+        super(false, extHostCommands, extHostRpc);
     }
     createTerminal(name, shellPath, shellArgs) {
         throw new NotSupportedError();
@@ -877,7 +889,8 @@ let WorkerExtHostTerminalService = class WorkerExtHostTerminalService extends Ba
     }
 };
 WorkerExtHostTerminalService = ( __decorate([
-    ( __param(0, IExtHostRpcService))
+    ( __param(0, IExtHostCommands)),
+    ( __param(1, IExtHostRpcService))
 ], WorkerExtHostTerminalService));
 function asTerminalIcon(iconPath) {
     if (!iconPath || typeof iconPath === 'string') {

package/vscode/src/vs/workbench/api/common/extHostTesting.js

@@ -13,11 +13,12 @@ import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
 import { MainContext } from './extHost.protocol.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
 import { toItemFromContext, ExtHostTestItemCollection, TestItemImpl, TestItemRootImpl } from './extHostTestItem.js';
-import { TestResults, TestTag, location, TestItem, TestCoverage, TestMessage, Range } from './extHostTypeConverters.js';
+import { TestMessage, TestResults, TestTag, location, TestItem, TestCoverage, Range } from './extHostTypeConverters.js';
 import { TestRunProfileKind, TestRunRequest } from './extHostTypes.js';
 import { TestId } from '../../contrib/testing/common/testId.js';
 import { InvalidTestItemError } from '../../contrib/testing/common/testItemCollection.js';
 import { TestsDiffOp, isStartControllerTests, AbstractIncrementalTestCollection } from '../../contrib/testing/common/testTypes.js';
+import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
 let ExtHostTesting = class ExtHostTesting {
     constructor(rpc, commands, editors) {
         this.editors = editors;
@@ -30,13 +31,22 @@ let ExtHostTesting = class ExtHostTesting {
         this.runTracker = ( new TestRunCoordinator(this.proxy));
         commands.registerArgumentProcessor({
             processArgument: arg => {
-                if (arg?.$mid !== 15 ) {
-                    return arg;
+                switch (arg?.$mid) {
+                    case 15 : {
+                        const cast = arg;
+                        const targetTest = cast.tests[cast.tests.length - 1].item.extId;
+                        const controller = this.controllers.get(TestId.root(targetTest));
+                        return controller?.collection.tree.get(targetTest)?.actual ?? toItemFromContext(arg);
+                    }
+                    case 17 : {
+                        const { extId, message } = arg;
+                        return {
+                            test: this.controllers.get(TestId.root(extId))?.collection.tree.get(extId)?.actual,
+                            message: TestMessage.to(message),
+                        };
+                    }
+                    default: return arg;
                 }
-                const cast = arg;
-                const targetTest = cast.tests[cast.tests.length - 1].item.extId;
-                const controller = this.controllers.get(TestId.root(targetTest));
-                return controller?.collection.tree.get(targetTest)?.actual ?? toItemFromContext(arg);
             }
         });
         commands.registerCommand(false, 'testing.getExplorerSelection', async () => {
@@ -105,7 +115,7 @@ let ExtHostTesting = class ExtHostTesting {
                 return ( new TestItemImpl(controllerId, id, label, uri));
             },
             createTestRun: (request, name, persist = true) => {
-                return this.runTracker.createTestRun(controllerId, collection, request, name, persist);
+                return this.runTracker.createTestRun(extension, controllerId, collection, request, name, persist);
             },
             invalidateTestResults: items => {
                 if (items === undefined) {
@@ -128,7 +138,7 @@ let ExtHostTesting = class ExtHostTesting {
         };
         proxy.$registerTestController(controllerId, label, !!refreshHandler);
         disposable.add(toDisposable(() => proxy.$unregisterTestController(controllerId)));
-        const info = { controller, collection, profiles: profiles };
+        const info = { controller, collection, profiles: profiles, extension };
         this.controllers.set(controllerId, info);
         disposable.add(toDisposable(() => this.controllers.delete(controllerId)));
         disposable.add(collection.onDidGenerateDiff(diff => proxy.$publishDiff(controllerId, ( diff.map(TestsDiffOp.serialize)))));
@@ -212,7 +222,7 @@ let ExtHostTesting = class ExtHostTesting {
         if (!lookup) {
             return {};
         }
-        const { collection, profiles } = lookup;
+        const { collection, profiles, extension } = lookup;
         const profile = profiles.get(req.profileId);
         if (!profile) {
             return {};
@@ -230,7 +240,7 @@ let ExtHostTesting = class ExtHostTesting {
             return {};
         }
         const publicReq = ( new TestRunRequest(( includeTests.some(i => i.actual instanceof TestItemRootImpl)) ? undefined : ( includeTests.map(t => t.actual)), ( excludeTests.map(t => t.actual)), profile, isContinuous));
-        const tracker = isStartControllerTests(req) && this.runTracker.prepareForMainThreadTestRun(publicReq, TestRunDto.fromInternal(req, lookup.collection), token);
+        const tracker = isStartControllerTests(req) && this.runTracker.prepareForMainThreadTestRun(publicReq, TestRunDto.fromInternal(req, lookup.collection), extension, token);
         try {
             await profile.runHandler(publicReq, token);
             return {};
@@ -267,10 +277,11 @@ class TestRunTracker extends Disposable {
     get id() {
         return this.dto.id;
     }
-    constructor(dto, proxy, parentToken) {
+    constructor(dto, proxy, extension, parentToken) {
         super();
         this.dto = dto;
         this.proxy = proxy;
+        this.extension = extension;
         this.state = 0 ;
         this.tasks = ( new Map());
         this.sharedTestIds = ( new Set());
@@ -312,6 +323,9 @@ class TestRunTracker extends Disposable {
             const converted = messages instanceof Array
                 ? ( messages.map(TestMessage.from))
                 : [TestMessage.from(messages)];
+            if (( converted.some(c => c.contextValue !== undefined))) {
+                checkProposedApiEnabled(this.extension, 'testMessageContextValue');
+            }
             if (test.uri && test.range) {
                 const defaultLocation = { range: Range.from(test.range), uri: test.uri };
                 for (const message of converted) {
@@ -424,8 +438,8 @@ class TestRunCoordinator {
         this.proxy = proxy;
         this.tracked = ( new Map());
     }
-    prepareForMainThreadTestRun(req, dto, token) {
-        return this.getTracker(req, dto, token);
+    prepareForMainThreadTestRun(req, dto, extension, token) {
+        return this.getTracker(req, dto, extension, token);
     }
     cancelRunById(runId) {
         for (const tracker of ( this.tracked.values())) {
@@ -440,7 +454,7 @@ class TestRunCoordinator {
             tracker.cancel();
         }
     }
-    createTestRun(controllerId, collection, request, name, persist) {
+    createTestRun(extension, controllerId, collection, request, name, persist) {
         const existing = this.tracked.get(request);
         if (existing) {
             return existing.createRun(name);
@@ -456,15 +470,15 @@ class TestRunCoordinator {
             include: request.include?.map(t => ( TestId.fromExtHostTestItem(t, collection.root.id).toString())) ?? [collection.root.id],
             persist
         });
-        const tracker = this.getTracker(request, dto);
+        const tracker = this.getTracker(request, dto, extension);
         tracker.onEnd(() => {
             this.proxy.$finishedExtensionTestRun(dto.id);
             tracker.dispose();
         });
         return tracker.createRun(name);
     }
-    getTracker(req, dto, token) {
-        const tracker = ( new TestRunTracker(dto, this.proxy, token));
+    getTracker(req, dto, extension, token) {
+        const tracker = ( new TestRunTracker(dto, this.proxy, extension, token));
         this.tracked.set(req, tracker);
         tracker.onEnd(() => this.tracked.delete(req));
         return tracker;

package/vscode/src/vs/workbench/api/common/extHostTreeViews.js

@@ -211,6 +211,9 @@ class ExtHostTreeViews {
     $setVisible(treeViewId, isVisible) {
         const treeView = this.treeViews.get(treeViewId);
         if (!treeView) {
+            if (!isVisible) {
+                return;
+            }
             throw new NoTreeViewError(treeViewId);
         }
         treeView.setVisible(isVisible);

package/vscode/src/vs/workbench/api/common/extHostTunnelService.d.ts

@@ -10,7 +10,7 @@ interface IExtHostTunnelService extends ExtHostTunnelServiceShape {
     openTunnel(extension: IExtensionDescription, forward: TunnelOptions): Promise<vscode.Tunnel | undefined>;
     getTunnels(): Promise<vscode.TunnelDescription[]>;
     onDidChangeTunnels: vscode.Event<void>;
-    setTunnelFactory(provider: vscode.RemoteAuthorityResolver | undefined): Promise<IDisposable>;
+    setTunnelFactory(provider: vscode.RemoteAuthorityResolver | undefined, managedRemoteAuthority: vscode.ManagedResolvedAuthority | undefined): Promise<IDisposable>;
     registerPortsAttributesProvider(portSelector: PortAttributesSelector, provider: vscode.PortAttributesProvider): IDisposable;
     registerTunnelProvider(provider: vscode.TunnelProvider, information: vscode.TunnelInformation): Promise<IDisposable>;
 }

package/vscode/src/vs/workbench/api/common/extHostTunnelService.js

@@ -78,7 +78,7 @@ let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
             this._proxy.$unregisterPortsAttributesProvider(providerHandle);
         });
     }
-    async $providePortAttributes(handles, ports, pid, commandline, cancellationToken) {
+    async $providePortAttributes(handles, ports, pid, commandLine, cancellationToken) {
         const providedAttributes = [];
         for (const handle of handles) {
             const provider = this._portAttributesProviders.get(handle);
@@ -86,7 +86,14 @@ let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
                 return [];
             }
             providedAttributes.push(...(await Promise.all(( (ports.map(async (port) => {
-                return { providedAttributes: (await provider.provider.providePortAttributes(port, pid, commandline, cancellationToken)), port };
+                let providedAttributes;
+                try {
+                    providedAttributes = await provider.provider.providePortAttributes({ port, pid, commandLine }, cancellationToken);
+                }
+                catch (e) {
+                    providedAttributes = await provider.provider.providePortAttributes(port, pid, commandLine, cancellationToken);
+                }
+                return { providedAttributes, port };
             }))))));
         }
         const allAttributes = providedAttributes.filter(attribute => !!attribute.providedAttributes);
@@ -116,7 +123,7 @@ let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
             this._proxy.$setTunnelProvider(undefined);
         }));
     }
-    async setTunnelFactory(provider) {
+    async setTunnelFactory(provider, managedRemoteAuthority) {
         if (provider) {
             if (provider.candidatePortSource !== undefined) {
                 this._proxy.$setCandidatePortSource(provider.candidatePortSource);
@@ -125,8 +132,9 @@ let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
                 this._showCandidatePort = provider.showCandidatePort;
                 this._proxy.$setCandidateFilter();
             }
-            if (provider.tunnelFactory) {
-                this._forwardPortProvider = provider.tunnelFactory;
+            const tunnelFactory = provider.tunnelFactory ?? (managedRemoteAuthority ? this.makeManagedTunnelFactory(managedRemoteAuthority) : undefined);
+            if (tunnelFactory) {
+                this._forwardPortProvider = tunnelFactory;
                 let privacyOptions = provider.tunnelFeatures?.privacyOptions ?? [];
                 if (provider.tunnelFeatures?.public && (privacyOptions.length === 0)) {
                     privacyOptions = [
@@ -157,6 +165,9 @@ let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
             this._forwardPortProvider = undefined;
         });
     }
+    makeManagedTunnelFactory(_authority) {
+        return undefined;
+    }
     async $closeTunnel(remote, silent) {
         if (( (this._extensionTunnels.has(remote.host)))) {
             const hostMap = this._extensionTunnels.get(remote.host);
@@ -201,6 +212,9 @@ let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
             }
             catch (e) {
                 this.logService.trace('ForwardedPorts: (ExtHostTunnelService) tunnel provider error');
+                if (e instanceof Error) {
+                    return e.message;
+                }
             }
         }
         return undefined;