@codingame/monaco-vscode-remote-agent-service-override 3.0.0 → 3.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-remote-agent-service-override",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,8 +18,8 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@3.0.0",
+    "vscode": "npm:@codingame/monaco-vscode-api@3.1.0",
     "vscode-marked": "npm:marked@=3.0.2",
-    "@codingame/monaco-vscode-environment-service-override": "3.0.0"
+    "@codingame/monaco-vscode-environment-service-override": "3.1.0"
   }
 }

package/remoteAgent.js

@@ -21,11 +21,14 @@ import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/service
 import { IRemoteUserDataProfilesService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/remoteUserDataProfiles';
 import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
 import { IActiveLanguagePackService } from 'vscode/vscode/vs/workbench/services/localization/common/locale';
+import { ITunnelService } from 'vscode/vscode/vs/platform/tunnel/common/tunnel';
+import { TunnelService } from './vscode/src/vs/workbench/services/tunnel/browser/tunnelService.js';
 import getServiceOverride$1 from '@codingame/monaco-vscode-environment-service-override';
 import { getWorkbenchConstructionOptions } from 'vscode/workbench';
 import { registerServiceInitializePreParticipant } from 'vscode/lifecycle';
 import './vscode/src/vs/workbench/contrib/remote/common/remote.contribution.js';
 import './vscode/src/vs/workbench/contrib/remote/browser/remote.contribution.js';
+import './vscode/src/vs/workbench/contrib/remote/browser/remoteStartEntry.contribution.js';
 
 let CustomRemoteSocketFactoryService = class CustomRemoteSocketFactoryService extends RemoteSocketFactoryService {
     constructor(browserWorkbenchEnvironmentService) {
@@ -82,7 +85,8 @@ function getServiceOverride({ scanRemoteExtensions = false } = {}) {
         [( IRemoteAuthorityResolverService.toString())]: new SyncDescriptor(InjectedRemoteAuthorityResolverService, []),
         [( IRemoteExplorerService.toString())]: new SyncDescriptor(RemoteExplorerService, [], true),
         [( IExternalUriOpenerService.toString())]: new SyncDescriptor(ExternalUriOpenerService, [], true),
-        [( IRemoteExtensionsScannerService.toString())]: new SyncDescriptor(CustomRemoteExtensionsScannerService, [scanRemoteExtensions], true)
+        [( IRemoteExtensionsScannerService.toString())]: new SyncDescriptor(CustomRemoteExtensionsScannerService, [scanRemoteExtensions], true),
+        [( ITunnelService.toString())]: new SyncDescriptor(TunnelService, [], true)
     };
 }
 

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;
+        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/services/tunnel/browser/tunnelService.js

@@ -0,0 +1,36 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { AbstractTunnelService, isTunnelProvider } from 'vscode/vscode/vs/platform/tunnel/common/tunnel';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+
+let TunnelService = class TunnelService extends AbstractTunnelService {
+    constructor(logService, environmentService, configurationService) {
+        super(logService, configurationService);
+        this.environmentService = environmentService;
+    }
+    isPortPrivileged(_port) {
+        return false;
+    }
+    retainOrCreateTunnel(tunnelProvider, remoteHost, remotePort, _localHost, localPort, elevateIfNeeded, privacy, protocol) {
+        const existing = this.getTunnelFromMap(remoteHost, remotePort);
+        if (existing) {
+            ++existing.refcount;
+            return existing.value;
+        }
+        if (isTunnelProvider(tunnelProvider)) {
+            return this.createWithProvider(tunnelProvider, remoteHost, remotePort, localPort, elevateIfNeeded, privacy, protocol);
+        }
+        return undefined;
+    }
+    canTunnel(uri) {
+        return super.canTunnel(uri) && !!this.environmentService.remoteAuthority;
+    }
+};
+TunnelService = ( __decorate([
+    ( __param(0, ILogService)),
+    ( __param(1, IWorkbenchEnvironmentService)),
+    ( __param(2, IConfigurationService))
+], TunnelService));
+
+export { TunnelService };