@codingame/monaco-vscode-remote-agent-service-override 2.1.1 → 2.1.2

package/package.json

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

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

@@ -5,6 +5,7 @@ import { TunnelFactoryContribution } from './tunnelFactory.js';
 import { RemoteAgentConnectionStatusListener, RemoteMarkers } from './remote.js';
 import { RemoteStatusIndicator } from './remoteIndicator.js';
 import { ForwardedPortsView, PortRestore, AutomaticPortForwarding } from 'vscode/vscode/vs/workbench/contrib/remote/browser/remoteExplorer';
+import { InitialRemoteConnectionHealthContribution } from './remoteConnectionHealth.js';
 
 const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));
 workbenchContributionsRegistry.registerWorkbenchContribution(ShowCandidateContribution, 2 );
@@ -15,3 +16,4 @@ workbenchContributionsRegistry.registerWorkbenchContribution(ForwardedPortsView,
 workbenchContributionsRegistry.registerWorkbenchContribution(PortRestore, 4 );
 workbenchContributionsRegistry.registerWorkbenchContribution(AutomaticPortForwarding, 4 );
 workbenchContributionsRegistry.registerWorkbenchContribution(RemoteMarkers, 4 );
+workbenchContributionsRegistry.registerWorkbenchContribution(InitialRemoteConnectionHealthContribution, 3 );

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

@@ -0,0 +1,158 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { remoteConnectionLatencyMeasurer, IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { isWeb } from 'vscode/vscode/vs/base/common/platform';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { getRemoteName } from 'vscode/vscode/vs/platform/remote/common/remoteHosts';
+import { IBannerService } from 'vscode/vscode/vs/workbench/services/banner/browser/bannerService';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import Severity from 'vscode/vscode/vs/base/common/severity';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+const REMOTE_UNSUPPORTED_CONNECTION_CHOICE_KEY = 'remote.unsupportedConnectionChoice';
+let InitialRemoteConnectionHealthContribution = class InitialRemoteConnectionHealthContribution {
+    constructor(_remoteAgentService, _environmentService, _telemetryService, bannerService, dialogService, openerService, hostService, storageService, productService) {
+        this._remoteAgentService = _remoteAgentService;
+        this._environmentService = _environmentService;
+        this._telemetryService = _telemetryService;
+        this.bannerService = bannerService;
+        this.dialogService = dialogService;
+        this.openerService = openerService;
+        this.hostService = hostService;
+        this.storageService = storageService;
+        this.productService = productService;
+        if (this._environmentService.remoteAuthority) {
+            this._checkInitialRemoteConnectionHealth();
+        }
+    }
+    async _confirmConnection() {
+        const { result, checkboxChecked } = await this.dialogService.prompt({
+            type: Severity.Warning,
+            message: ( localizeWithPath(
+                'vs/workbench/contrib/remote/browser/remoteConnectionHealth',
+                'unsupportedGlibcWarning',
+                "You are about to connect to an OS version that is unsupported by {0}.",
+                this.productService.nameLong
+            )),
+            buttons: [
+                {
+                    label: ( localizeWithPath(
+                        'vs/workbench/contrib/remote/browser/remoteConnectionHealth',
+                        { key: 'allow', comment: ['&& denotes a mnemonic'] },
+                        "&&Allow"
+                    )),
+                    run: () => 1
+                },
+                {
+                    label: ( localizeWithPath(
+                        'vs/workbench/contrib/remote/browser/remoteConnectionHealth',
+                        { key: 'learnMore', comment: ['&& denotes a mnemonic'] },
+                        "&&Learn More"
+                    )),
+                    run: async () => { await this.openerService.open('https://aka.ms/vscode-remote/faq/old-linux'); return 2 ; }
+                }
+            ],
+            cancelButton: {
+                run: () => 0
+            },
+            checkbox: {
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/remote/browser/remoteConnectionHealth',
+                    'remember',
+                    "Do not show again"
+                )),
+            }
+        });
+        if (result === 2 ) {
+            return await this._confirmConnection();
+        }
+        const allowed = result === 1 ;
+        if (allowed && checkboxChecked) {
+            this.storageService.store(`${REMOTE_UNSUPPORTED_CONNECTION_CHOICE_KEY}.${this._environmentService.remoteAuthority}`, allowed, 0 , 1 );
+        }
+        return allowed;
+    }
+    async _checkInitialRemoteConnectionHealth() {
+        try {
+            const environment = await this._remoteAgentService.getRawEnvironment();
+            if (environment && environment.isUnsupportedGlibc) {
+                let allowed = this.storageService.getBoolean(`${REMOTE_UNSUPPORTED_CONNECTION_CHOICE_KEY}.${this._environmentService.remoteAuthority}`, 0 );
+                if (allowed === undefined) {
+                    allowed = await this._confirmConnection();
+                }
+                if (allowed) {
+                    const actions = [
+                        {
+                            label: ( localizeWithPath(
+                                'vs/workbench/contrib/remote/browser/remoteConnectionHealth',
+                                'unsupportedGlibcBannerLearnMore',
+                                "Learn More"
+                            )),
+                            href: 'https://aka.ms/vscode-remote/faq/old-linux'
+                        }
+                    ];
+                    this.bannerService.show({
+                        id: 'unsupportedGlibcWarning.banner',
+                        message: ( localizeWithPath(
+                            'vs/workbench/contrib/remote/browser/remoteConnectionHealth',
+                            'unsupportedGlibcWarning.banner',
+                            "You are connected to an OS version that is unsupported by {0}.",
+                            this.productService.nameLong
+                        )),
+                        actions,
+                        icon: Codicon.warning,
+                        disableCloseAction: true
+                    });
+                }
+                else {
+                    this.hostService.openWindow({ forceReuseWindow: true, remoteAuthority: null });
+                    return;
+                }
+            }
+            this._telemetryService.publicLog2('remoteConnectionSuccess', {
+                web: isWeb,
+                connectionTimeMs: await this._remoteAgentService.getConnection()?.getInitialConnectionTimeMs(),
+                remoteName: getRemoteName(this._environmentService.remoteAuthority)
+            });
+            await this._measureExtHostLatency();
+        }
+        catch (err) {
+            this._telemetryService.publicLog2('remoteConnectionFailure', {
+                web: isWeb,
+                connectionTimeMs: await this._remoteAgentService.getConnection()?.getInitialConnectionTimeMs(),
+                remoteName: getRemoteName(this._environmentService.remoteAuthority),
+                message: err ? err.message : ''
+            });
+        }
+    }
+    async _measureExtHostLatency() {
+        const measurement = await remoteConnectionLatencyMeasurer.measure(this._remoteAgentService);
+        if (measurement === undefined) {
+            return;
+        }
+        this._telemetryService.publicLog2('remoteConnectionLatency', {
+            web: isWeb,
+            remoteName: getRemoteName(this._environmentService.remoteAuthority),
+            latencyMs: measurement.current
+        });
+    }
+};
+InitialRemoteConnectionHealthContribution = ( __decorate([
+    ( __param(0, IRemoteAgentService)),
+    ( __param(1, IWorkbenchEnvironmentService)),
+    ( __param(2, ITelemetryService)),
+    ( __param(3, IBannerService)),
+    ( __param(4, IDialogService)),
+    ( __param(5, IOpenerService)),
+    ( __param(6, IHostService)),
+    ( __param(7, IStorageService)),
+    ( __param(8, IProductService))
+], InitialRemoteConnectionHealthContribution));
+
+export { InitialRemoteConnectionHealthContribution };

package/vscode/src/vs/workbench/contrib/remote/common/remote.contribution.js

@@ -4,7 +4,7 @@ import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
 import { OS, isWeb } from 'vscode/vscode/vs/base/common/platform';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { remoteConnectionLatencyMeasurer, IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
+import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
 import { ILoggerService } from 'vscode/vscode/vs/platform/log/common/log';
 import { localizeWithPath, localize2WithPath } from 'vscode/vscode/vs/nls';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
@@ -17,8 +17,6 @@ import { firstOrDefault } from 'vscode/vscode/vs/base/common/arrays';
 import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
 import { PersistentConnection } from 'vscode/vscode/vs/platform/remote/common/remoteAgentConnection';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-import { getRemoteName } from 'vscode/vscode/vs/platform/remote/common/remoteHosts';
 import { IDownloadService } from 'vscode/vscode/vs/platform/download/common/download';
 import { DownloadServiceChannel } from '../../../../platform/download/common/downloadIpc.js';
 import { RemoteLoggerChannelClient } from '../../../../platform/log/common/logIpc.js';
@@ -132,56 +130,10 @@ RemoteInvalidWorkspaceDetector = ( __decorate([
     ( __param(4, IFileDialogService)),
     ( __param(5, IRemoteAgentService))
 ], RemoteInvalidWorkspaceDetector));
-let InitialRemoteConnectionHealthContribution = class InitialRemoteConnectionHealthContribution {
-    constructor(_remoteAgentService, _environmentService, _telemetryService) {
-        this._remoteAgentService = _remoteAgentService;
-        this._environmentService = _environmentService;
-        this._telemetryService = _telemetryService;
-        if (this._environmentService.remoteAuthority) {
-            this._checkInitialRemoteConnectionHealth();
-        }
-    }
-    async _checkInitialRemoteConnectionHealth() {
-        try {
-            await this._remoteAgentService.getRawEnvironment();
-            this._telemetryService.publicLog2('remoteConnectionSuccess', {
-                web: isWeb,
-                connectionTimeMs: await this._remoteAgentService.getConnection()?.getInitialConnectionTimeMs(),
-                remoteName: getRemoteName(this._environmentService.remoteAuthority)
-            });
-            await this._measureExtHostLatency();
-        }
-        catch (err) {
-            this._telemetryService.publicLog2('remoteConnectionFailure', {
-                web: isWeb,
-                connectionTimeMs: await this._remoteAgentService.getConnection()?.getInitialConnectionTimeMs(),
-                remoteName: getRemoteName(this._environmentService.remoteAuthority),
-                message: err ? err.message : ''
-            });
-        }
-    }
-    async _measureExtHostLatency() {
-        const measurement = await remoteConnectionLatencyMeasurer.measure(this._remoteAgentService);
-        if (measurement === undefined) {
-            return;
-        }
-        this._telemetryService.publicLog2('remoteConnectionLatency', {
-            web: isWeb,
-            remoteName: getRemoteName(this._environmentService.remoteAuthority),
-            latencyMs: measurement.current
-        });
-    }
-};
-InitialRemoteConnectionHealthContribution = ( __decorate([
-    ( __param(0, IRemoteAgentService)),
-    ( __param(1, IWorkbenchEnvironmentService)),
-    ( __param(2, ITelemetryService))
-], InitialRemoteConnectionHealthContribution));
 const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));
 workbenchContributionsRegistry.registerWorkbenchContribution(LabelContribution, 1 );
 workbenchContributionsRegistry.registerWorkbenchContribution(RemoteChannelsContribution, 3 );
 workbenchContributionsRegistry.registerWorkbenchContribution(RemoteInvalidWorkspaceDetector, 1 );
-workbenchContributionsRegistry.registerWorkbenchContribution(InitialRemoteConnectionHealthContribution, 3 );
 {
     class TriggerReconnectAction extends Action2 {
         constructor() {

package/vscode/src/vs/workbench/services/remote/common/remoteAgentEnvironmentChannel.js

@@ -23,7 +23,8 @@ class RemoteExtensionEnvironmentChannelClient {
             arch: data.arch,
             marks: data.marks,
             useHostProxy: data.useHostProxy,
-            profiles: revive(data.profiles)
+            profiles: revive(data.profiles),
+            isUnsupportedGlibc: data.isUnsupportedGlibc
         };
     }
     static async getExtensionHostExitInfo(channel, remoteAuthority, reconnectionToken) {