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

package/external/rollup-plugin-styles/dist/runtime/inject-css.js

@@ -0,0 +1,3 @@
+var e=[],t=[];function n(n,r){if(n&&"undefined"!=typeof document){var a,s=!0===r.prepend?"prepend":"append",d=!0===r.singleTag,i="string"==typeof r.container?document.querySelector(r.container):document.getElementsByTagName("head")[0];if(d){var u=e.indexOf(i);-1===u&&(u=e.push(i)-1,t[u]={}),a=t[u]&&t[u][s]?t[u][s]:t[u][s]=c();}else a=c();65279===n.charCodeAt(0)&&(n=n.substring(1)),a.styleSheet?a.styleSheet.cssText+=n:a.appendChild(document.createTextNode(n));}function c(){var e=document.createElement("style");if(e.setAttribute("type","text/css"),r.attributes)for(var t=( Object.keys(r.attributes)),n=0;n<t.length;n++)e.setAttribute(t[n],r.attributes[t[n]]);var a="prepend"===s?"afterbegin":"beforeend";return i.insertAdjacentElement(a,e),e}}
+
+export { n as default };

package/override/vs/platform/dialogs/common/dialogs.js

@@ -0,0 +1,10 @@
+export { AbstractDialogHandler, IDialogService, IFileDialogService, getFileNamesMessage } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+var ConfirmResult;
+( (function(ConfirmResult) {
+    ConfirmResult[ConfirmResult["SAVE"] = 0] = "SAVE";
+    ConfirmResult[ConfirmResult["DONT_SAVE"] = 1] = "DONT_SAVE";
+    ConfirmResult[ConfirmResult["CANCEL"] = 2] = "CANCEL";
+})(ConfirmResult || (ConfirmResult = {})));
+
+export { ConfirmResult };

package/package.json

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

package/remoteAgent.js

@@ -1,10 +1,10 @@
 import { __decorate, __param } from './external/tslib/tslib.es6.js';
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
 import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
-import { RemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/browser/remoteAgentService';
+import { RemoteAgentService } from './vscode/src/vs/workbench/services/remote/browser/remoteAgentService.js';
 import { IRemoteSocketFactoryService, RemoteSocketFactoryService } from 'vscode/vscode/vs/platform/remote/common/remoteSocketFactoryService';
 import { IRemoteAuthorityResolverService } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
-import { RemoteAuthorityResolverService } from 'vscode/vscode/vs/platform/remote/browser/remoteAuthorityResolverService';
+import { RemoteAuthorityResolverService } from './vscode/src/vs/platform/remote/browser/remoteAuthorityResolverService.js';
 import { BrowserSocketFactory } from './vscode/src/vs/platform/remote/browser/browserSocketFactory.js';
 import { RemoteFileSystemProviderClient } from './vscode/src/vs/workbench/services/remote/common/remoteFileSystemProviderClient.js';
 import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService';
@@ -12,23 +12,23 @@ import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
 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/vscode/vs/workbench/services/remote/common/remoteExtensionsScanner';
+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 'vscode/vscode/vs/platform/product/common/productService';
 import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment';
-import { BrowserRemoteResourceLoader } from 'vscode/vscode/vs/workbench/services/remote/browser/browserRemoteResourceHandler';
+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 { ITunnelService } from 'vscode/vscode/vs/platform/tunnel/common/tunnel';
-import { TunnelService } from 'vscode/vscode/vs/workbench/services/tunnel/browser/tunnelService';
+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/vscode/vs/workbench/contrib/remote/common/remote.contribution';
-import 'vscode/vscode/vs/workbench/contrib/remote/browser/remote.contribution';
-import 'vscode/vscode/vs/workbench/contrib/remote/browser/remoteStartEntry.contribution';
+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) {

package/vscode/src/vs/platform/download/common/downloadIpc.js

@@ -0,0 +1,18 @@
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+
+class DownloadServiceChannel {
+    constructor(service) {
+        this.service = service;
+    }
+    listen(_, event, arg) {
+        throw new Error('Invalid listen');
+    }
+    call(context, command, args) {
+        switch (command) {
+            case 'download': return this.service.download(URI.revive(args[0]), URI.revive(args[1]));
+        }
+        throw new Error('Invalid call');
+    }
+}
+
+export { DownloadServiceChannel };

package/vscode/src/vs/platform/log/common/logIpc.js

@@ -0,0 +1,28 @@
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import 'vscode/vscode/vs/base/common/event';
+import 'vscode/vscode/vs/platform/log/common/log';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+
+class RemoteLoggerChannelClient extends Disposable {
+    constructor(loggerService, channel) {
+        super();
+        channel.call('setLogLevel', [loggerService.getLogLevel()]);
+        this._register(loggerService.onDidChangeLogLevel(arg => channel.call('setLogLevel', [arg])));
+        channel.call('getRegisteredLoggers').then(loggers => {
+            for (const loggerResource of loggers) {
+                loggerService.registerLogger({ ...loggerResource, resource: URI.revive(loggerResource.resource) });
+            }
+        });
+        this._register(channel.listen('onDidChangeVisibility')(([resource, visibility]) => loggerService.setVisibility(URI.revive(resource), visibility)));
+        this._register(channel.listen('onDidChangeLoggers')(({ added, removed }) => {
+            for (const loggerResource of added) {
+                loggerService.registerLogger({ ...loggerResource, resource: URI.revive(loggerResource.resource) });
+            }
+            for (const loggerResource of removed) {
+                loggerService.deregisterLogger(loggerResource.resource);
+            }
+        }));
+    }
+}
+
+export { RemoteLoggerChannelClient };

package/vscode/src/vs/platform/remote/browser/remoteAuthorityResolverService.js

@@ -0,0 +1,110 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
+import { DeferredPromise } from 'vscode/vscode/vs/base/common/async';
+import { ErrorNoTelemetry } from 'vscode/vscode/vs/base/common/errors';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { RemoteAuthorities } from 'vscode/vscode/vs/base/common/network';
+import { mark } from 'vscode/vscode/vs/base/common/performance';
+import { StopWatch } from 'vscode/vscode/vs/base/common/stopwatch';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
+import { getRemoteAuthorityPrefix, WebSocketRemoteConnection } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
+import { parseAuthorityWithOptionalPort } from 'vscode/vscode/vs/platform/remote/common/remoteHosts';
+
+let RemoteAuthorityResolverService = class RemoteAuthorityResolverService extends Disposable {
+    constructor(isWorkbenchOptionsBasedResolution, connectionToken, resourceUriProvider, serverBasePath, productService, _logService) {
+        super();
+        this._logService = _logService;
+        this._onDidChangeConnectionData = this._register(( new Emitter()));
+        this.onDidChangeConnectionData = this._onDidChangeConnectionData.event;
+        this._resolveAuthorityRequests = ( new Map());
+        this._cache = ( new Map());
+        this._connectionToken = connectionToken;
+        this._connectionTokens = ( new Map());
+        this._isWorkbenchOptionsBasedResolution = isWorkbenchOptionsBasedResolution;
+        if (resourceUriProvider) {
+            RemoteAuthorities.setDelegate(resourceUriProvider);
+        }
+        RemoteAuthorities.setServerRootPath(productService, serverBasePath);
+    }
+    async resolveAuthority(authority) {
+        let result = this._resolveAuthorityRequests.get(authority);
+        if (!result) {
+            result = ( new DeferredPromise());
+            this._resolveAuthorityRequests.set(authority, result);
+            if (this._isWorkbenchOptionsBasedResolution) {
+                this._doResolveAuthority(authority).then(v => result.complete(v), (err) => result.error(err));
+            }
+        }
+        return result.p;
+    }
+    async getCanonicalURI(uri) {
+        return uri;
+    }
+    getConnectionData(authority) {
+        if (!( this._cache.has(authority))) {
+            return null;
+        }
+        const resolverResult = this._cache.get(authority);
+        const connectionToken = this._connectionTokens.get(authority) || resolverResult.authority.connectionToken;
+        return {
+            connectTo: resolverResult.authority.connectTo,
+            connectionToken: connectionToken
+        };
+    }
+    async _doResolveAuthority(authority) {
+        const authorityPrefix = getRemoteAuthorityPrefix(authority);
+        const sw = StopWatch.create(false);
+        this._logService.info(`Resolving connection token (${authorityPrefix})...`);
+        mark(`code/willResolveConnectionToken/${authorityPrefix}`);
+        const connectionToken = await Promise.resolve(this._connectionTokens.get(authority) || this._connectionToken);
+        mark(`code/didResolveConnectionToken/${authorityPrefix}`);
+        this._logService.info(`Resolved connection token (${authorityPrefix}) after ${sw.elapsed()} ms`);
+        const defaultPort = (/^https:/.test(mainWindow.location.href) ? 443 : 80);
+        const { host, port } = parseAuthorityWithOptionalPort(authority, defaultPort);
+        const result = { authority: { authority, connectTo: ( new WebSocketRemoteConnection(host, port)), connectionToken } };
+        RemoteAuthorities.set(authority, host, port);
+        this._cache.set(authority, result);
+        this._onDidChangeConnectionData.fire();
+        return result;
+    }
+    _clearResolvedAuthority(authority) {
+        if (( this._resolveAuthorityRequests.has(authority))) {
+            this._resolveAuthorityRequests.get(authority).cancel();
+            this._resolveAuthorityRequests.delete(authority);
+        }
+    }
+    _setResolvedAuthority(resolvedAuthority, options) {
+        if (( this._resolveAuthorityRequests.has(resolvedAuthority.authority))) {
+            const request = this._resolveAuthorityRequests.get(resolvedAuthority.authority);
+            if (resolvedAuthority.connectTo.type === 0 ) {
+                RemoteAuthorities.set(resolvedAuthority.authority, resolvedAuthority.connectTo.host, resolvedAuthority.connectTo.port);
+            }
+            if (resolvedAuthority.connectionToken) {
+                RemoteAuthorities.setConnectionToken(resolvedAuthority.authority, resolvedAuthority.connectionToken);
+            }
+            request.complete({ authority: resolvedAuthority, options });
+            this._onDidChangeConnectionData.fire();
+        }
+    }
+    _setResolvedAuthorityError(authority, err) {
+        if (( this._resolveAuthorityRequests.has(authority))) {
+            const request = this._resolveAuthorityRequests.get(authority);
+            request.error(ErrorNoTelemetry.fromError(err));
+        }
+    }
+    _setAuthorityConnectionToken(authority, connectionToken) {
+        this._connectionTokens.set(authority, connectionToken);
+        RemoteAuthorities.setConnectionToken(authority, connectionToken);
+        this._onDidChangeConnectionData.fire();
+    }
+    _setCanonicalURIProvider(provider) {
+    }
+};
+RemoteAuthorityResolverService = ( __decorate([
+    ( __param(4, IProductService)),
+    ( __param(5, ILogService))
+], RemoteAuthorityResolverService));
+
+export { RemoteAuthorityResolverService };

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

@@ -0,0 +1,135 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { REMOTE_EXPLORER_TYPE_KEY, IRemoteExplorerService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteExplorerService';
+import { isStringArray } from 'vscode/vscode/vs/base/common/types';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { RawContextKey, ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { MenuId, MenuRegistry, registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { VIEWLET_ID } from 'vscode/vscode/vs/workbench/contrib/remote/browser/remoteExplorer';
+import { getVirtualWorkspaceLocation } from 'vscode/vscode/vs/platform/workspace/common/virtualWorkspace';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { Disposable, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
+
+const SELECTED_REMOTE_IN_EXPLORER = ( new RawContextKey('selectedRemoteInExplorer', ''));
+let SwitchRemoteViewItem = class SwitchRemoteViewItem extends Disposable {
+    constructor(contextKeyService, remoteExplorerService, environmentService, storageService, workspaceContextService) {
+        super();
+        this.contextKeyService = contextKeyService;
+        this.remoteExplorerService = remoteExplorerService;
+        this.environmentService = environmentService;
+        this.storageService = storageService;
+        this.workspaceContextService = workspaceContextService;
+        this.completedRemotes = this._register(( new DisposableMap()));
+        this.selectedRemoteContext = SELECTED_REMOTE_IN_EXPLORER.bindTo(contextKeyService);
+        this.switchRemoteMenu = MenuId.for('workbench.remote.menu.switchRemoteMenu');
+        this._register(MenuRegistry.appendMenuItem(MenuId.ViewContainerTitle, {
+            submenu: this.switchRemoteMenu,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/remote/browser/explorerViewItems',
+                'switchRemote.label',
+                "Switch Remote"
+            )),
+            group: 'navigation',
+            when: ( ContextKeyExpr.equals('viewContainer', VIEWLET_ID)),
+            order: 1,
+            isSelection: true
+        }));
+        this._register(remoteExplorerService.onDidChangeTargetType(e => {
+            this.select(e);
+        }));
+    }
+    setSelectionForConnection() {
+        let isSetForConnection = false;
+        if (this.completedRemotes.size > 0) {
+            let authority;
+            const remoteAuthority = this.environmentService.remoteAuthority;
+            let virtualWorkspace;
+            if (!remoteAuthority) {
+                virtualWorkspace = getVirtualWorkspaceLocation(this.workspaceContextService.getWorkspace())?.scheme;
+            }
+            isSetForConnection = true;
+            const explorerType = remoteAuthority ? [remoteAuthority.split('+')[0]]
+                : (virtualWorkspace ? [virtualWorkspace]
+                    : (this.storageService.get(REMOTE_EXPLORER_TYPE_KEY, 1 )?.split(',') ?? this.storageService.get(REMOTE_EXPLORER_TYPE_KEY, 0 )?.split(',')));
+            if (explorerType !== undefined) {
+                authority = this.getAuthorityForExplorerType(explorerType);
+            }
+            if (authority) {
+                this.select(authority);
+            }
+        }
+        return isSetForConnection;
+    }
+    select(authority) {
+        this.selectedRemoteContext.set(authority[0]);
+        this.remoteExplorerService.targetType = authority;
+    }
+    getAuthorityForExplorerType(explorerType) {
+        let authority;
+        for (const option of this.completedRemotes) {
+            for (const authorityOption of option[1].authority) {
+                for (const explorerOption of explorerType) {
+                    if (authorityOption === explorerOption) {
+                        authority = option[1].authority;
+                        break;
+                    }
+                    else if (option[1].virtualWorkspace === explorerOption) {
+                        authority = option[1].authority;
+                        break;
+                    }
+                }
+            }
+        }
+        return authority;
+    }
+    removeOptionItems(views) {
+        for (const view of views) {
+            if (view.group && view.group.startsWith('targets') && view.remoteAuthority && (!view.when || this.contextKeyService.contextMatchesRules(view.when))) {
+                const authority = isStringArray(view.remoteAuthority) ? view.remoteAuthority : [view.remoteAuthority];
+                this.completedRemotes.deleteAndDispose(authority[0]);
+            }
+        }
+    }
+    createOptionItems(views) {
+        const startingCount = this.completedRemotes.size;
+        for (const view of views) {
+            if (view.group && view.group.startsWith('targets') && view.remoteAuthority && (!view.when || this.contextKeyService.contextMatchesRules(view.when))) {
+                const text = view.name;
+                const authority = isStringArray(view.remoteAuthority) ? view.remoteAuthority : [view.remoteAuthority];
+                if (( this.completedRemotes.has(authority[0]))) {
+                    continue;
+                }
+                const thisCapture = this;
+                const action = registerAction2(class extends Action2 {
+                    constructor() {
+                        super({
+                            id: `workbench.action.remoteExplorer.show.${authority[0]}`,
+                            title: text,
+                            toggled: ( SELECTED_REMOTE_IN_EXPLORER.isEqualTo(authority[0])),
+                            menu: {
+                                id: thisCapture.switchRemoteMenu
+                            }
+                        });
+                    }
+                    async run() {
+                        thisCapture.select(authority);
+                    }
+                });
+                this.completedRemotes.set(authority[0], { text: text.value, authority, virtualWorkspace: view.virtualWorkspace, dispose: () => action.dispose() });
+            }
+        }
+        if (this.completedRemotes.size > startingCount) {
+            this.setSelectionForConnection();
+        }
+    }
+};
+SwitchRemoteViewItem = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, IRemoteExplorerService)),
+    ( __param(2, IWorkbenchEnvironmentService)),
+    ( __param(3, IStorageService)),
+    ( __param(4, IWorkspaceContextService))
+], SwitchRemoteViewItem));
+
+export { SELECTED_REMOTE_IN_EXPLORER, SwitchRemoteViewItem };

package/vscode/src/vs/workbench/contrib/remote/browser/media/remoteViewlet.css.js

@@ -0,0 +1,6 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".remote-help-content .monaco-list .monaco-list-row .remote-help-tree-node-item{display:flex;flex:1;flex-wrap:nowrap;height:22px;line-height:22px;overflow:hidden;text-overflow:ellipsis}.remote-help-content .monaco-list .monaco-list-row .remote-help-tree-node-item>.remote-help-tree-node-item-icon{-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;background-position:0;background-repeat:no-repeat;background-size:16px;height:22px;padding-right:6px;padding-top:3px;width:16px}.remote-help-tree-node-item-icon .monaco-icon-label-container>.monaco-icon-name-container{padding-left:22px}.remote-help-content .monaco-list .monaco-list-row .monaco-tl-twistie{width:0!important}";
+n(css,{});
+
+export { css, css as default };

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

@@ -0,0 +1,19 @@
+import { Extensions, registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { ShowCandidateContribution } from './showCandidate.js';
+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));
+registerWorkbenchContribution2(ShowCandidateContribution.ID, ShowCandidateContribution, 2 );
+registerWorkbenchContribution2(TunnelFactoryContribution.ID, TunnelFactoryContribution, 2 );
+workbenchContributionsRegistry.registerWorkbenchContribution(RemoteAgentConnectionStatusListener, 4 );
+registerWorkbenchContribution2(RemoteStatusIndicator.ID, RemoteStatusIndicator, 1 );
+workbenchContributionsRegistry.registerWorkbenchContribution(ForwardedPortsView, 3 );
+workbenchContributionsRegistry.registerWorkbenchContribution(PortRestore, 4 );
+workbenchContributionsRegistry.registerWorkbenchContribution(AutomaticPortForwarding, 4 );
+workbenchContributionsRegistry.registerWorkbenchContribution(RemoteMarkers, 4 );
+workbenchContributionsRegistry.registerWorkbenchContribution(InitialRemoteConnectionHealthContribution, 3 );