@codingame/monaco-vscode-remote-agent-service-override 1.85.2 → 1.85.4

package/index.d.ts

@@ -1 +1 @@
-export { default } from './remoteAgent.js';
+export { RemoteAgentServiceOverrideParams, default } from './remoteAgent.js';

package/package.json

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

package/remoteAgent.d.ts

@@ -1,6 +1,12 @@
 import { IEditorOverrideServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
 
-declare function getServiceOverride(connectionToken?: Promise<string> | string, resourceUriProvider?: ((uri: URI) => URI)): IEditorOverrideServices;
+interface RemoteAgentServiceOverrideParams {
+    /**
+     * if true, the default extensions on the remote agent will be scanned and added
+     * @default false
+     */
+    scanRemoteExtensions?: boolean;
+}
+declare function getServiceOverride({ scanRemoteExtensions }?: RemoteAgentServiceOverrideParams): IEditorOverrideServices;
 
-export { getServiceOverride as default };
+export { type RemoteAgentServiceOverrideParams, getServiceOverride as default };

package/remoteAgent.js

@@ -12,7 +12,17 @@ import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.j
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { IRemoteExplorerService, RemoteExplorerService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteExplorerService';
 import { IExternalUriOpenerService, ExternalUriOpenerService } from 'vscode/vscode/vs/workbench/contrib/externalUriOpener/common/externalUriOpenerService';
+import { RemoteExtensionsScannerService } from './vscode/src/vs/workbench/services/remote/common/remoteExtensionsScanner.js';
+import { IRemoteExtensionsScannerService } from 'vscode/vscode/vs/platform/remote/common/remoteExtensionsScanner';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { BrowserRemoteResourceLoader } from './vscode/src/vs/workbench/services/remote/browser/browserRemoteResourceHandler.js';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+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 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';
@@ -26,17 +36,53 @@ let CustomRemoteSocketFactoryService = class CustomRemoteSocketFactoryService ex
 CustomRemoteSocketFactoryService = __decorate([
     ( __param(0, IBrowserWorkbenchEnvironmentService))
 ], CustomRemoteSocketFactoryService);
+let InjectedRemoteAuthorityResolverService = class InjectedRemoteAuthorityResolverService extends RemoteAuthorityResolverService {
+    constructor(environmentService, productService, logService, fileService) {
+        const configuration = getWorkbenchConstructionOptions();
+        const connectionToken = environmentService.options.connectionToken;
+        const remoteResourceLoader = configuration.remoteResourceProvider != null ? new BrowserRemoteResourceLoader(fileService, configuration.remoteResourceProvider) : undefined;
+        const resourceUriProvider = configuration.resourceUriProvider ?? remoteResourceLoader?.getResourceUriProvider();
+        super(!environmentService.expectsResolverExtension, connectionToken, resourceUriProvider, productService, logService);
+    }
+};
+InjectedRemoteAuthorityResolverService = __decorate([
+    ( __param(0, IEnvironmentService)),
+    ( __param(1, IProductService)),
+    ( __param(2, ILogService)),
+    ( __param(3, IFileService))
+], InjectedRemoteAuthorityResolverService);
+let CustomRemoteExtensionsScannerService = class CustomRemoteExtensionsScannerService extends RemoteExtensionsScannerService {
+    constructor(scanRemoteExtensions, remoteAgentService, environmentService, userDataProfileService, remoteUserDataProfilesService, logService, activeLanguagePackService) {
+        super(remoteAgentService, environmentService, userDataProfileService, remoteUserDataProfilesService, logService, activeLanguagePackService);
+        this.scanRemoteExtensions = scanRemoteExtensions;
+    }
+    async scanExtensions() {
+        if (!this.scanRemoteExtensions) {
+            return [];
+        }
+        return super.scanExtensions();
+    }
+};
+CustomRemoteExtensionsScannerService = __decorate([
+    ( __param(1, IRemoteAgentService)),
+    ( __param(2, IWorkbenchEnvironmentService)),
+    ( __param(3, IUserDataProfileService)),
+    ( __param(4, IRemoteUserDataProfilesService)),
+    ( __param(5, ILogService)),
+    ( __param(6, IActiveLanguagePackService))
+], CustomRemoteExtensionsScannerService);
 registerServiceInitializePreParticipant(async (serviceAccessor) => {
     RemoteFileSystemProviderClient.register(serviceAccessor.get(IRemoteAgentService), serviceAccessor.get(IFileService), serviceAccessor.get(ILogService));
 });
-function getServiceOverride(connectionToken, resourceUriProvider) {
+function getServiceOverride({ scanRemoteExtensions = false } = {}) {
     return {
         ...getServiceOverride$1(),
         [( IRemoteAgentService.toString())]: new SyncDescriptor(RemoteAgentService, [], true),
         [( IRemoteSocketFactoryService.toString())]: new SyncDescriptor(CustomRemoteSocketFactoryService, [], true),
-        [( IRemoteAuthorityResolverService.toString())]: new SyncDescriptor(RemoteAuthorityResolverService, [true, connectionToken, resourceUriProvider]),
+        [( IRemoteAuthorityResolverService.toString())]: new SyncDescriptor(InjectedRemoteAuthorityResolverService, []),
         [( IRemoteExplorerService.toString())]: new SyncDescriptor(RemoteExplorerService, [], true),
-        [( IExternalUriOpenerService.toString())]: new SyncDescriptor(ExternalUriOpenerService, [], true)
+        [( IExternalUriOpenerService.toString())]: new SyncDescriptor(ExternalUriOpenerService, [], true),
+        [( IRemoteExtensionsScannerService.toString())]: new SyncDescriptor(CustomRemoteExtensionsScannerService, [scanRemoteExtensions], true)
     };
 }
 

package/vscode/src/vs/workbench/services/remote/browser/browserRemoteResourceHandler.js

@@ -0,0 +1,49 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { getMediaOrTextMime } from 'monaco-editor/esm/vs/base/common/mime.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { FileOperationError, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+
+let BrowserRemoteResourceLoader = class BrowserRemoteResourceLoader extends Disposable {
+    constructor(fileService, provider) {
+        super();
+        this.provider = provider;
+        this._register(provider.onDidReceiveRequest(async (request) => {
+            let uri;
+            try {
+                uri = JSON.parse(decodeURIComponent(request.uri.query));
+            }
+            catch {
+                return request.respondWith(404, ( new Uint8Array()), {});
+            }
+            let content;
+            try {
+                content = await fileService.readFile(( URI.from(uri, true)));
+            }
+            catch (e) {
+                const str = VSBuffer.fromString(e.message).buffer;
+                if (e instanceof FileOperationError && e.fileOperationResult === 1 ) {
+                    return request.respondWith(404, str, {});
+                }
+                else {
+                    return request.respondWith(500, str, {});
+                }
+            }
+            const mime = uri.path && getMediaOrTextMime(uri.path);
+            request.respondWith(200, content.value.buffer, mime ? { 'content-type': mime } : {});
+        }));
+    }
+    getResourceUriProvider() {
+        const baseUri = ( URI.parse(document.location.href));
+        return uri => baseUri.with({
+            path: this.provider.path,
+            query: JSON.stringify(uri),
+        });
+    }
+};
+BrowserRemoteResourceLoader = ( __decorate([
+    ( __param(0, IFileService))
+], BrowserRemoteResourceLoader));
+
+export { BrowserRemoteResourceLoader };

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

@@ -0,0 +1,73 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
+import { RemoteExtensionsScannerChannelName } from 'vscode/vscode/vs/platform/remote/common/remoteExtensionsScanner';
+import * as platform from 'monaco-editor/esm/vs/base/common/platform.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { IRemoteUserDataProfilesService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/remoteUserDataProfiles';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IActiveLanguagePackService } from 'vscode/vscode/vs/workbench/services/localization/common/locale';
+
+let RemoteExtensionsScannerService = class RemoteExtensionsScannerService {
+    constructor(remoteAgentService, environmentService, userDataProfileService, remoteUserDataProfilesService, logService, activeLanguagePackService) {
+        this.remoteAgentService = remoteAgentService;
+        this.environmentService = environmentService;
+        this.userDataProfileService = userDataProfileService;
+        this.remoteUserDataProfilesService = remoteUserDataProfilesService;
+        this.logService = logService;
+        this.activeLanguagePackService = activeLanguagePackService;
+    }
+    whenExtensionsReady() {
+        return this.withChannel(channel => channel.call('whenExtensionsReady'), undefined);
+    }
+    async scanExtensions() {
+        try {
+            const languagePack = await this.activeLanguagePackService.getExtensionIdProvidingCurrentLocale();
+            return await this.withChannel(async (channel) => {
+                const profileLocation = this.userDataProfileService.currentProfile.isDefault ? undefined : (await this.remoteUserDataProfilesService.getRemoteProfile(this.userDataProfileService.currentProfile)).extensionsResource;
+                const scannedExtensions = await channel.call('scanExtensions', [platform.language, profileLocation, this.environmentService.extensionDevelopmentLocationURI, languagePack]);
+                scannedExtensions.forEach((extension) => {
+                    extension.extensionLocation = URI.revive(extension.extensionLocation);
+                });
+                return scannedExtensions;
+            }, []);
+        }
+        catch (error) {
+            this.logService.error(error);
+            return [];
+        }
+    }
+    async scanSingleExtension(extensionLocation, isBuiltin) {
+        try {
+            return await this.withChannel(async (channel) => {
+                const extension = await channel.call('scanSingleExtension', [extensionLocation, isBuiltin, platform.language]);
+                if (extension !== null) {
+                    extension.extensionLocation = URI.revive(extension.extensionLocation);
+                }
+                return extension;
+            }, null);
+        }
+        catch (error) {
+            this.logService.error(error);
+            return null;
+        }
+    }
+    withChannel(callback, fallback) {
+        const connection = this.remoteAgentService.getConnection();
+        if (!connection) {
+            return Promise.resolve(fallback);
+        }
+        return connection.withChannel(RemoteExtensionsScannerChannelName, (channel) => callback(channel));
+    }
+};
+RemoteExtensionsScannerService = ( __decorate([
+    ( __param(0, IRemoteAgentService)),
+    ( __param(1, IWorkbenchEnvironmentService)),
+    ( __param(2, IUserDataProfileService)),
+    ( __param(3, IRemoteUserDataProfilesService)),
+    ( __param(4, ILogService)),
+    ( __param(5, IActiveLanguagePackService))
+], RemoteExtensionsScannerService));
+
+export { RemoteExtensionsScannerService };