@codingame/monaco-vscode-remote-agent-service-override 4.1.0 → 4.1.2

package/vscode/src/vs/workbench/contrib/remote/browser/remoteStartEntry.contribution.js

@@ -0,0 +1,6 @@
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { RemoteStartEntry } from './remoteStartEntry.js';
+
+( Registry.as(Extensions.Workbench))
+    .registerWorkbenchContribution(RemoteStartEntry, 3 );

package/vscode/src/vs/workbench/contrib/remote/browser/remoteStartEntry.js

@@ -0,0 +1,97 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localize2WithPath } from 'vscode/vscode/vs/nls';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
+import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IExtensionManagementService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { IWorkbenchExtensionEnablementService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
+import { RawContextKey, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+
+var RemoteStartEntry_1;
+const showStartEntryInWeb = ( new RawContextKey('showRemoteStartEntryInWeb', false));
+let RemoteStartEntry = class RemoteStartEntry extends Disposable {
+    static { RemoteStartEntry_1 = this; }
+    static { this.REMOTE_WEB_START_ENTRY_ACTIONS_COMMAND_ID = 'workbench.action.remote.showWebStartEntryActions'; }
+    constructor(commandService, productService, extensionManagementService, extensionEnablementService, telemetryService, contextKeyService) {
+        super();
+        this.commandService = commandService;
+        this.productService = productService;
+        this.extensionManagementService = extensionManagementService;
+        this.extensionEnablementService = extensionEnablementService;
+        this.telemetryService = telemetryService;
+        this.contextKeyService = contextKeyService;
+        const remoteExtensionTips = this.productService.remoteExtensionTips?.['tunnel'];
+        this.startCommand = remoteExtensionTips?.startEntry?.startCommand ?? '';
+        this.remoteExtensionId = remoteExtensionTips?.extensionId ?? '';
+        this._init();
+        this.registerActions();
+        this.registerListeners();
+    }
+    registerActions() {
+        const category = ( localize2WithPath(
+            'vs/workbench/contrib/remote/browser/remoteStartEntry',
+            'remote.category',
+            "Remote"
+        ));
+        const startEntry = this;
+        this._register(registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: RemoteStartEntry_1.REMOTE_WEB_START_ENTRY_ACTIONS_COMMAND_ID,
+                    category,
+                    title: ( localize2WithPath(
+                        'vs/workbench/contrib/remote/browser/remoteStartEntry',
+                        'remote.showWebStartEntryActions',
+                        "Show Remote Start Entry for web"
+                    )),
+                    f1: false
+                });
+            }
+            async run() {
+                await startEntry.showWebRemoteStartActions();
+            }
+        }));
+    }
+    registerListeners() {
+        this._register(this.extensionEnablementService.onEnablementChanged(async (result) => {
+            for (const ext of result) {
+                if (ExtensionIdentifier.equals(this.remoteExtensionId, ext.identifier.id)) {
+                    if (this.extensionEnablementService.isEnabled(ext)) {
+                        showStartEntryInWeb.bindTo(this.contextKeyService).set(true);
+                    }
+                    else {
+                        showStartEntryInWeb.bindTo(this.contextKeyService).set(false);
+                    }
+                }
+            }
+        }));
+    }
+    async _init() {
+        const installed = (await this.extensionManagementService.getInstalled()).find(value => ExtensionIdentifier.equals(value.identifier.id, this.remoteExtensionId));
+        if (installed) {
+            if (this.extensionEnablementService.isEnabled(installed)) {
+                showStartEntryInWeb.bindTo(this.contextKeyService).set(true);
+            }
+        }
+    }
+    async showWebRemoteStartActions() {
+        this.commandService.executeCommand(this.startCommand);
+        this.telemetryService.publicLog2('workbenchActionExecuted', {
+            id: this.startCommand,
+            from: 'remote start entry'
+        });
+    }
+};
+RemoteStartEntry = RemoteStartEntry_1 = ( __decorate([
+    ( __param(0, ICommandService)),
+    ( __param(1, IProductService)),
+    ( __param(2, IExtensionManagementService)),
+    ( __param(3, IWorkbenchExtensionEnablementService)),
+    ( __param(4, ITelemetryService)),
+    ( __param(5, IContextKeyService))
+], RemoteStartEntry));
+
+export { RemoteStartEntry, showStartEntryInWeb };

package/vscode/src/vs/workbench/contrib/remote/browser/showCandidate.js

@@ -0,0 +1,35 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService';
+import { IRemoteExplorerService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteExplorerService';
+
+let ShowCandidateContribution = class ShowCandidateContribution extends Disposable {
+    static { this.ID = 'workbench.contrib.showPortCandidate'; }
+    constructor(remoteExplorerService, environmentService) {
+        super();
+        const showPortCandidate = environmentService.options?.tunnelProvider?.showPortCandidate;
+        if (showPortCandidate) {
+            this._register(remoteExplorerService.setCandidateFilter(async (candidates) => {
+                const filters = await Promise.all(( candidates.map(
+                    candidate => showPortCandidate(candidate.host, candidate.port, candidate.detail ?? '')
+                )));
+                const filteredCandidates = [];
+                if (filters.length !== candidates.length) {
+                    return candidates;
+                }
+                for (let i = 0; i < candidates.length; i++) {
+                    if (filters[i]) {
+                        filteredCandidates.push(candidates[i]);
+                    }
+                }
+                return filteredCandidates;
+            }));
+        }
+    }
+};
+ShowCandidateContribution = ( __decorate([
+    ( __param(0, IRemoteExplorerService)),
+    ( __param(1, IBrowserWorkbenchEnvironmentService))
+], ShowCandidateContribution));
+
+export { ShowCandidateContribution };

package/vscode/src/vs/workbench/contrib/remote/browser/tunnelFactory.js

@@ -0,0 +1,110 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { TunnelPrivacyId, TunnelProtocol, ITunnelService } from 'vscode/vscode/vs/platform/tunnel/common/tunnel';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { IRemoteExplorerService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteExplorerService';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { forwardedPortsViewEnabled } from 'vscode/vscode/vs/workbench/services/remote/common/tunnelModel';
+
+let TunnelFactoryContribution = class TunnelFactoryContribution extends Disposable {
+    static { this.ID = 'workbench.contrib.tunnelFactory'; }
+    constructor(tunnelService, environmentService, openerService, remoteExplorerService, logService, contextKeyService) {
+        super();
+        this.openerService = openerService;
+        const tunnelFactory = environmentService.options?.tunnelProvider?.tunnelFactory;
+        if (tunnelFactory) {
+            contextKeyService.createKey(forwardedPortsViewEnabled.key, true);
+            let privacyOptions = environmentService.options?.tunnelProvider?.features?.privacyOptions ?? [];
+            if (environmentService.options?.tunnelProvider?.features?.public
+                && (privacyOptions.length === 0)) {
+                privacyOptions = [
+                    {
+                        id: 'private',
+                        label: ( localizeWithPath(
+                            'vs/workbench/contrib/remote/browser/tunnelFactory',
+                            'tunnelPrivacy.private',
+                            "Private"
+                        )),
+                        themeIcon: 'lock'
+                    },
+                    {
+                        id: 'public',
+                        label: ( localizeWithPath(
+                            'vs/workbench/contrib/remote/browser/tunnelFactory',
+                            'tunnelPrivacy.public',
+                            "Public"
+                        )),
+                        themeIcon: 'eye'
+                    }
+                ];
+            }
+            this._register(tunnelService.setTunnelProvider({
+                forwardPort: async (tunnelOptions, tunnelCreationOptions) => {
+                    let tunnelPromise;
+                    try {
+                        tunnelPromise = tunnelFactory(tunnelOptions, tunnelCreationOptions);
+                    }
+                    catch (e) {
+                        logService.trace('tunnelFactory: tunnel provider error');
+                    }
+                    if (!tunnelPromise) {
+                        return undefined;
+                    }
+                    let tunnel;
+                    try {
+                        tunnel = await tunnelPromise;
+                    }
+                    catch (e) {
+                        logService.trace('tunnelFactory: tunnel provider promise error');
+                        if (e instanceof Error) {
+                            return e.message;
+                        }
+                        return undefined;
+                    }
+                    const localAddress = tunnel.localAddress.startsWith('http') ? tunnel.localAddress : `http://${tunnel.localAddress}`;
+                    const remoteTunnel = {
+                        tunnelRemotePort: tunnel.remoteAddress.port,
+                        tunnelRemoteHost: tunnel.remoteAddress.host,
+                        localAddress: await this.resolveExternalUri(localAddress),
+                        privacy: tunnel.privacy ?? (tunnel.public ? TunnelPrivacyId.Public : TunnelPrivacyId.Private),
+                        protocol: tunnel.protocol ?? TunnelProtocol.Http,
+                        dispose: async () => { await tunnel.dispose(); }
+                    };
+                    return remoteTunnel;
+                }
+            }));
+            const tunnelInformation = environmentService.options?.tunnelProvider?.features ?
+                {
+                    features: {
+                        elevation: !!environmentService.options?.tunnelProvider?.features?.elevation,
+                        public: !!environmentService.options?.tunnelProvider?.features?.public,
+                        privacyOptions,
+                        protocol: environmentService.options?.tunnelProvider?.features?.protocol === undefined ? true : !!environmentService.options?.tunnelProvider?.features?.protocol
+                    }
+                } : undefined;
+            remoteExplorerService.setTunnelInformation(tunnelInformation);
+        }
+    }
+    async resolveExternalUri(uri) {
+        try {
+            return ( (await this.openerService.resolveExternalUri(( URI.parse(uri)))).resolved.toString());
+        }
+        catch {
+            return uri;
+        }
+    }
+};
+TunnelFactoryContribution = ( __decorate([
+    ( __param(0, ITunnelService)),
+    ( __param(1, IBrowserWorkbenchEnvironmentService)),
+    ( __param(2, IOpenerService)),
+    ( __param(3, IRemoteExplorerService)),
+    ( __param(4, ILogService)),
+    ( __param(5, IContextKeyService))
+], TunnelFactoryContribution));
+
+export { TunnelFactoryContribution };