@codingame/monaco-vscode-remote-agent-service-override 11.1.2 → 12.0.1

package/index.d.ts

@@ -1,2 +1,9 @@
-export * from 'vscode/service-override/remoteAgent';
-export { default } from 'vscode/service-override/remoteAgent';
+import type { IEditorOverrideServices } from "vscode/vscode/vs/editor/standalone/browser/standaloneServices";
+export interface RemoteAgentServiceOverrideParams {
+    /**
+     * if true, the default extensions on the remote agent will be scanned and added
+     * @default false
+     */
+    scanRemoteExtensions?: boolean;
+}
+export default function getServiceOverride({ scanRemoteExtensions }?: RemoteAgentServiceOverrideParams): IEditorOverrideServices;

package/index.js

@@ -1 +1,103 @@
-export { default } from './remoteAgent.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
+import { RemoteAgentService } from './vscode/src/vs/workbench/services/remote/browser/remoteAgentService.js';
+import { RemoteSocketFactoryService } from './vscode/src/vs/platform/remote/common/remoteSocketFactoryService.js';
+import { IRemoteSocketFactoryService } from 'vscode/vscode/vs/platform/remote/common/remoteSocketFactoryService.service';
+import { RemoteConnectionType } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
+import { IRemoteAuthorityResolverService } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver.service';
+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 '@codingame/monaco-vscode-abed5a84-8a82-5f84-9412-88a736235bae-common/vscode/vs/workbench/services/environment/browser/environmentService';
+import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService.service';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { RemoteExplorerService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteExplorerService';
+import { IRemoteExplorerService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteExplorerService.service';
+import { ExternalUriOpenerService } from '@codingame/monaco-vscode-1b4486de-4fe4-59c4-9e6d-34f265ff6625-common/vscode/vs/workbench/contrib/externalUriOpener/common/externalUriOpenerService';
+import { IExternalUriOpenerService } from 'vscode/vscode/vs/workbench/contrib/externalUriOpener/common/externalUriOpenerService.service';
+import { RemoteExtensionsScannerService } from './vscode/src/vs/workbench/services/remote/common/remoteExtensionsScanner.js';
+import { IRemoteExtensionsScannerService } from 'vscode/vscode/vs/platform/remote/common/remoteExtensionsScanner.service';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
+import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment.service';
+import { BrowserRemoteResourceLoader } from './vscode/src/vs/workbench/services/remote/browser/browserRemoteResourceHandler.js';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { IRemoteUserDataProfilesService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/remoteUserDataProfiles.service';
+import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
+import { IActiveLanguagePackService } from 'vscode/vscode/vs/workbench/services/localization/common/locale.service';
+import { ITunnelService } from 'vscode/vscode/vs/platform/tunnel/common/tunnel.service';
+import { TunnelService } from './vscode/src/vs/workbench/services/tunnel/browser/tunnelService.js';
+import { IWorkbenchExtensionManagementService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement.service';
+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) {
+        super();
+        this.register(RemoteConnectionType.WebSocket, new BrowserSocketFactory(browserWorkbenchEnvironmentService.options?.webSocketFactory));
+    }
+};
+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, configuration.serverBasePath, 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, activeLanguagePackService, extensionManagementService, logService) {
+        super(remoteAgentService, environmentService, userDataProfileService, remoteUserDataProfilesService, activeLanguagePackService, extensionManagementService, logService);
+        this.scanRemoteExtensions = scanRemoteExtensions;
+    }
+    async scanExtensions() {
+        if (!this.scanRemoteExtensions) {
+            return [];
+        }
+        return await super.scanExtensions();
+    }
+};
+CustomRemoteExtensionsScannerService = __decorate([
+    __param(1, IRemoteAgentService),
+    __param(2, IWorkbenchEnvironmentService),
+    __param(3, IUserDataProfileService),
+    __param(4, IRemoteUserDataProfilesService),
+    __param(5, IActiveLanguagePackService),
+    __param(6, IWorkbenchExtensionManagementService),
+    __param(7, ILogService)
+], CustomRemoteExtensionsScannerService);
+registerServiceInitializePreParticipant(async (serviceAccessor) => {
+    RemoteFileSystemProviderClient.register(serviceAccessor.get(IRemoteAgentService), serviceAccessor.get(IFileService), serviceAccessor.get(ILogService));
+});
+function getServiceOverride({ scanRemoteExtensions = false } = {}) {
+    return {
+        ...getServiceOverride$1(),
+        [IRemoteAgentService.toString()]: new SyncDescriptor(RemoteAgentService, [], true),
+        [IRemoteSocketFactoryService.toString()]: new SyncDescriptor(CustomRemoteSocketFactoryService, [], true),
+        [IRemoteAuthorityResolverService.toString()]: new SyncDescriptor(InjectedRemoteAuthorityResolverService, []),
+        [IRemoteExplorerService.toString()]: new SyncDescriptor(RemoteExplorerService, [], true),
+        [IExternalUriOpenerService.toString()]: new SyncDescriptor(ExternalUriOpenerService, [], true),
+        [IRemoteExtensionsScannerService.toString()]: new SyncDescriptor(CustomRemoteExtensionsScannerService, [scanRemoteExtensions], true),
+        [ITunnelService.toString()]: new SyncDescriptor(TunnelService, [], true)
+    };
+}
+
+export { getServiceOverride as default };

package/package.json

@@ -1,6 +1,8 @@
 {
   "name": "@codingame/monaco-vscode-remote-agent-service-override",
-  "version": "11.1.2",
+  "version": "12.0.1",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - remote-agent service-override",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -12,8 +14,25 @@
     "url": "git+ssh://git@github.com/CodinGame/monaco-vscode-api.git"
   },
   "type": "module",
-  "private": false,
-  "description": "VSCode public API plugged on the monaco editor - remote-agent service-override",
+  "dependencies": {
+    "@codingame/monaco-vscode-1b4486de-4fe4-59c4-9e6d-34f265ff6625-common": "12.0.1",
+    "@codingame/monaco-vscode-22790577-4553-50b6-978d-0acc75c394cc-common": "12.0.1",
+    "@codingame/monaco-vscode-2a94c04a-b85b-5669-b06b-89c1bfa11cb9-common": "12.0.1",
+    "@codingame/monaco-vscode-56402b83-4a60-5b15-86f9-71fe99c32744-common": "12.0.1",
+    "@codingame/monaco-vscode-65619f8f-0eab-5d8b-855a-43b6353fe527-common": "12.0.1",
+    "@codingame/monaco-vscode-abed5a84-8a82-5f84-9412-88a736235bae-common": "12.0.1",
+    "@codingame/monaco-vscode-d6e33d82-c101-549d-a885-0807ab3e0cfb-common": "12.0.1",
+    "@codingame/monaco-vscode-environment-service-override": "12.0.1",
+    "vscode": "npm:@codingame/monaco-vscode-api@12.0.1"
+  },
+  "peerDependencies": {
+    "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common": "12.0.1"
+  },
+  "peerDependenciesMeta": {
+    "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common": {
+      "optional": true
+    }
+  },
   "main": "index.js",
   "module": "index.js",
   "types": "index.d.ts",
@@ -22,11 +41,12 @@
       "default": "./index.js"
     },
     "./vscode/*": {
-      "default": "./vscode/src/*.js"
+      "default": "./vscode/src/*.js",
+      "types": "./vscode/src/*.d.ts"
+    },
+    "./*": {
+      "default": "./*.js",
+      "types": "./*.d.ts"
     }
-  },
-  "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@11.1.2",
-    "@codingame/monaco-vscode-environment-service-override": "11.1.2"
   }
 }

package/vscode/src/vs/platform/download/common/downloadIpc.d.ts

@@ -0,0 +1,18 @@
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { IURITransformer } from "vscode/vscode/vs/base/common/uriIpc";
+import { IChannel, IServerChannel } from "vscode/vscode/vs/base/parts/ipc/common/ipc";
+import { IDownloadService } from "vscode/vscode/vs/platform/download/common/download.service";
+export declare class DownloadServiceChannel implements IServerChannel {
+    private readonly service;
+    constructor(service: IDownloadService);
+    listen(_: unknown, event: string, arg?: any): Event<any>;
+    call(context: any, command: string, args?: any): Promise<any>;
+}
+export declare class DownloadServiceChannelClient implements IDownloadService {
+    private channel;
+    private getUriTransformer;
+    readonly _serviceBrand: undefined;
+    constructor(channel: IChannel, getUriTransformer: () => IURITransformer | null);
+    download(from: URI, to: URI): Promise<void>;
+}

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

@@ -1,3 +1,4 @@
+
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 
 class DownloadServiceChannel {

package/vscode/src/vs/platform/files/common/diskFileSystemProviderClient.d.ts

@@ -0,0 +1,43 @@
+import { CancellationToken } from "vscode/vscode/vs/base/common/cancellation";
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { ReadableStreamEvents } from "vscode/vscode/vs/base/common/stream";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { IChannel } from "vscode/vscode/vs/base/parts/ipc/common/ipc";
+import { IFileAtomicReadOptions, IFileDeleteOptions, IFileOpenOptions, IFileOverwriteOptions, IFileReadStreamOptions, FileSystemProviderCapabilities, FileType, IFileWriteOptions, IFileChange, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileCloneCapability, IFileSystemProviderWithFileFolderCopyCapability, IFileSystemProviderWithFileReadStreamCapability, IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithOpenReadWriteCloseCapability, IStat, IWatchOptions } from "vscode/vscode/vs/platform/files/common/files";
+export declare const LOCAL_FILE_SYSTEM_CHANNEL_NAME = "localFilesystem";
+export declare class DiskFileSystemProviderClient extends Disposable implements IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithOpenReadWriteCloseCapability, IFileSystemProviderWithFileReadStreamCapability, IFileSystemProviderWithFileFolderCopyCapability, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileCloneCapability {
+    private readonly channel;
+    private readonly extraCapabilities;
+    constructor(channel: IChannel, extraCapabilities: {
+        trash?: boolean;
+        pathCaseSensitive?: boolean;
+    });
+    readonly onDidChangeCapabilities: Event<void>;
+    private _capabilities;
+    get capabilities(): FileSystemProviderCapabilities;
+    stat(resource: URI): Promise<IStat>;
+    readdir(resource: URI): Promise<[
+        string,
+        FileType
+    ][]>;
+    readFile(resource: URI, opts?: IFileAtomicReadOptions): Promise<Uint8Array>;
+    readFileStream(resource: URI, opts: IFileReadStreamOptions, token: CancellationToken): ReadableStreamEvents<Uint8Array>;
+    writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
+    open(resource: URI, opts: IFileOpenOptions): Promise<number>;
+    close(fd: number): Promise<void>;
+    read(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
+    write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
+    mkdir(resource: URI): Promise<void>;
+    delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;
+    rename(resource: URI, target: URI, opts: IFileOverwriteOptions): Promise<void>;
+    copy(resource: URI, target: URI, opts: IFileOverwriteOptions): Promise<void>;
+    cloneFile(resource: URI, target: URI): Promise<void>;
+    private readonly _onDidChange;
+    readonly onDidChangeFile: Event<readonly IFileChange[]>;
+    private readonly _onDidWatchError;
+    readonly onDidWatchError: Event<string>;
+    private readonly sessionId;
+    private registerFileChangeListeners;
+    watch(resource: URI, opts: IWatchOptions): IDisposable;
+}

package/vscode/src/vs/platform/files/common/diskFileSystemProviderClient.js

@@ -1,3 +1,4 @@
+
 import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
 import { toErrorMessage } from 'vscode/vscode/vs/base/common/errorMessage';
 import { canceled } from 'vscode/vscode/vs/base/common/errors';
@@ -5,7 +6,7 @@ import { Event, Emitter } from 'vscode/vscode/vs/base/common/event';
 import { Disposable, DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { newWriteableStream } from 'vscode/vscode/vs/base/common/stream';
 import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
-import { createFileSystemProviderError, FileSystemProviderErrorCode } from 'vscode/vscode/vs/platform/files/common/files';
+import { FileSystemProviderCapabilities, createFileSystemProviderError, FileSystemProviderErrorCode } from 'vscode/vscode/vs/platform/files/common/files';
 import { reviveFileChanges } from 'vscode/vscode/vs/platform/files/common/watcher';
 
 class DiskFileSystemProviderClient extends Disposable {
@@ -24,20 +25,20 @@ class DiskFileSystemProviderClient extends Disposable {
     get capabilities() {
         if (!this._capabilities) {
             this._capabilities =
-                2  |
-                    4  |
-                    16  |
-                    8  |
-                    8192  |
-                    16384  |
-                    32768  |
-                    65536  |
-                    131072 ;
+                FileSystemProviderCapabilities.FileReadWrite |
+                    FileSystemProviderCapabilities.FileOpenReadWriteClose |
+                    FileSystemProviderCapabilities.FileReadStream |
+                    FileSystemProviderCapabilities.FileFolderCopy |
+                    FileSystemProviderCapabilities.FileWriteUnlock |
+                    FileSystemProviderCapabilities.FileAtomicRead |
+                    FileSystemProviderCapabilities.FileAtomicWrite |
+                    FileSystemProviderCapabilities.FileAtomicDelete |
+                    FileSystemProviderCapabilities.FileClone;
             if (this.extraCapabilities.pathCaseSensitive) {
-                this._capabilities |= 1024 ;
+                this._capabilities |= FileSystemProviderCapabilities.PathCaseSensitive;
             }
             if (this.extraCapabilities.trash) {
-                this._capabilities |= 4096 ;
+                this._capabilities |= FileSystemProviderCapabilities.Trash;
             }
         }
         return this._capabilities;

package/vscode/src/vs/platform/log/common/logIpc.d.ts

@@ -0,0 +1,32 @@
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { IChannel, IServerChannel } from "vscode/vscode/vs/base/parts/ipc/common/ipc";
+import { AbstractLoggerService, ILogger, ILoggerOptions, ILoggerResource, LogLevel } from "vscode/vscode/vs/platform/log/common/log";
+import { ILoggerService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IURITransformer } from "vscode/vscode/vs/base/common/uriIpc";
+export declare class LoggerChannelClient extends AbstractLoggerService implements ILoggerService {
+    private readonly windowId;
+    private readonly channel;
+    constructor(windowId: number | undefined, logLevel: LogLevel, logsHome: URI, loggers: ILoggerResource[], channel: IChannel);
+    createConsoleMainLogger(): ILogger;
+    registerLogger(logger: ILoggerResource): void;
+    deregisterLogger(resource: URI): void;
+    setLogLevel(logLevel: LogLevel): void;
+    setLogLevel(resource: URI, logLevel: LogLevel): void;
+    setVisibility(resourceOrId: URI | string, visibility: boolean): void;
+    protected doCreateLogger(file: URI, logLevel: LogLevel, options?: ILoggerOptions): ILogger;
+    static setLogLevel(channel: IChannel, level: LogLevel): Promise<void>;
+    static setLogLevel(channel: IChannel, resource: URI, level: LogLevel): Promise<void>;
+}
+export declare class LoggerChannel implements IServerChannel {
+    private readonly loggerService;
+    private getUriTransformer;
+    constructor(loggerService: ILoggerService, getUriTransformer: (requestContext: any) => IURITransformer);
+    listen(context: any, event: string): Event<any>;
+    call(context: any, command: string, arg?: any): Promise<any>;
+    private transformLogger;
+}
+export declare class RemoteLoggerChannelClient extends Disposable {
+    constructor(loggerService: ILoggerService, channel: IChannel);
+}

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

@@ -1,3 +1,4 @@
+
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import 'vscode/vscode/vs/base/common/event';
 import 'vscode/vscode/vs/platform/log/common/log';

package/vscode/src/vs/platform/remote/browser/browserSocketFactory.d.ts

@@ -0,0 +1,29 @@
+import { VSBuffer } from "vscode/vscode/vs/base/common/buffer";
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { ISocket, SocketDiagnosticsEventType } from "vscode/vscode/vs/base/parts/ipc/common/ipc.net";
+import { ISocketFactory } from "../common/remoteSocketFactoryService.js";
+import { RemoteConnectionType, WebSocketRemoteConnection } from "vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver";
+export interface IWebSocketFactory {
+    create(url: string, debugLabel: string): IWebSocket;
+}
+export interface IWebSocketCloseEvent {
+    readonly code: number;
+    readonly reason: string;
+    readonly wasClean: boolean;
+    readonly event: any | undefined;
+}
+export interface IWebSocket {
+    readonly onData: Event<ArrayBuffer>;
+    readonly onOpen: Event<void>;
+    readonly onClose: Event<IWebSocketCloseEvent | void>;
+    readonly onError: Event<any>;
+    traceSocketEvent?(type: SocketDiagnosticsEventType, data?: VSBuffer | Uint8Array | ArrayBuffer | ArrayBufferView | any): void;
+    send(data: ArrayBuffer | ArrayBufferView): void;
+    close(): void;
+}
+export declare class BrowserSocketFactory implements ISocketFactory<RemoteConnectionType.WebSocket> {
+    private readonly _webSocketFactory;
+    constructor(webSocketFactory: IWebSocketFactory | null | undefined);
+    supports(connectTo: WebSocketRemoteConnection): boolean;
+    connect({ host, port }: WebSocketRemoteConnection, path: string, query: string, debugLabel: string): Promise<ISocket>;
+}

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

@@ -1,9 +1,10 @@
+
 import { addDisposableListener } from 'vscode/vscode/vs/base/browser/dom';
 import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
 import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { SocketDiagnostics } from 'vscode/vscode/vs/base/parts/ipc/common/ipc.net';
+import { SocketDiagnostics, SocketDiagnosticsEventType, SocketCloseEventType } from 'vscode/vscode/vs/base/parts/ipc/common/ipc.net';
 import { RemoteAuthorityResolverError, RemoteAuthorityResolverErrorCode } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
 import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
 
@@ -23,7 +24,7 @@ class BrowserWebSocket extends Disposable {
         this.onError = this._onError.event;
         this._debugLabel = debugLabel;
         this._socket = ( new WebSocket(url));
-        this.traceSocketEvent("created" , { type: 'BrowserWebSocket', url });
+        this.traceSocketEvent(SocketDiagnosticsEventType.Created, { type: 'BrowserWebSocket', url });
         this._fileReader = ( new FileReader());
         this._queue = [];
         this._isReading = false;
@@ -31,7 +32,7 @@ class BrowserWebSocket extends Disposable {
         this._fileReader.onload = (event) => {
             this._isReading = false;
             const buff = event.target.result;
-            this.traceSocketEvent("read" , buff);
+            this.traceSocketEvent(SocketDiagnosticsEventType.Read, buff);
             this._onData.fire(buff);
             if (this._queue.length > 0) {
                 enqueue(this._queue.shift());
@@ -47,12 +48,12 @@ class BrowserWebSocket extends Disposable {
         };
         this._socketMessageListener = (ev) => {
             const blob = ev.data;
-            this.traceSocketEvent("browserWebSocketBlobReceived" , { type: blob.type, size: blob.size });
+            this.traceSocketEvent(SocketDiagnosticsEventType.BrowserWebSocketBlobReceived, { type: blob.type, size: blob.size });
             enqueue(blob);
         };
         this._socket.addEventListener('message', this._socketMessageListener);
         this._register(addDisposableListener(this._socket, 'open', (e) => {
-            this.traceSocketEvent("open" );
+            this.traceSocketEvent(SocketDiagnosticsEventType.Open);
             this._onOpen.fire();
         }));
         let pendingErrorEvent = null;
@@ -73,7 +74,7 @@ class BrowserWebSocket extends Disposable {
             sendPendingErrorNow();
         };
         this._register(addDisposableListener(this._socket, 'close', (e) => {
-            this.traceSocketEvent("close" , { code: e.code, reason: e.reason, wasClean: e.wasClean });
+            this.traceSocketEvent(SocketDiagnosticsEventType.Close, { code: e.code, reason: e.reason, wasClean: e.wasClean });
             this._isClosed = true;
             if (pendingErrorEvent) {
                 if (!navigator.onLine) {
@@ -100,7 +101,7 @@ class BrowserWebSocket extends Disposable {
             this._onClose.fire({ code: e.code, reason: e.reason, wasClean: e.wasClean, event: e });
         }));
         this._register(addDisposableListener(this._socket, 'error', (err) => {
-            this.traceSocketEvent("error" , { message: err?.message });
+            this.traceSocketEvent(SocketDiagnosticsEventType.Error, { message: err?.message });
             sendErrorSoon(err);
         }));
     }
@@ -108,12 +109,12 @@ class BrowserWebSocket extends Disposable {
         if (this._isClosed) {
             return;
         }
-        this.traceSocketEvent("write" , data);
+        this.traceSocketEvent(SocketDiagnosticsEventType.Write, data);
         this._socket.send(data);
     }
     close() {
         this._isClosed = true;
-        this.traceSocketEvent("close" );
+        this.traceSocketEvent(SocketDiagnosticsEventType.Close);
         this._socket.close();
         this._socket.removeEventListener('message', this._socketMessageListener);
         this.dispose();
@@ -150,7 +151,7 @@ class BrowserSocket {
             }
             else {
                 listener({
-                    type: 1 ,
+                    type: SocketCloseEventType.WebSocketCloseEvent,
                     code: e.code,
                     reason: e.reason,
                     wasClean: e.wasClean,

package/vscode/src/vs/platform/remote/browser/remoteAuthorityResolverService.d.ts

@@ -0,0 +1,27 @@
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { IProductService } from "vscode/vscode/vs/platform/product/common/productService.service";
+import { IRemoteConnectionData, ResolvedAuthority, ResolvedOptions, ResolverResult } from "vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver";
+import { IRemoteAuthorityResolverService } from "vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver.service";
+export declare class RemoteAuthorityResolverService extends Disposable implements IRemoteAuthorityResolverService {
+    private readonly _logService;
+    readonly _serviceBrand: undefined;
+    private readonly _onDidChangeConnectionData;
+    readonly onDidChangeConnectionData: import("vscode/vscode/vs/base/common/event").Event<void>;
+    private readonly _resolveAuthorityRequests;
+    private readonly _cache;
+    private readonly _connectionToken;
+    private readonly _connectionTokens;
+    private readonly _isWorkbenchOptionsBasedResolution;
+    constructor(isWorkbenchOptionsBasedResolution: boolean, connectionToken: Promise<string> | string | undefined, resourceUriProvider: ((uri: URI) => URI) | undefined, serverBasePath: string | undefined, productService: IProductService, _logService: ILogService);
+    resolveAuthority(authority: string): Promise<ResolverResult>;
+    getCanonicalURI(uri: URI): Promise<URI>;
+    getConnectionData(authority: string): IRemoteConnectionData | null;
+    private _doResolveAuthority;
+    _clearResolvedAuthority(authority: string): void;
+    _setResolvedAuthority(resolvedAuthority: ResolvedAuthority, options?: ResolvedOptions): void;
+    _setResolvedAuthorityError(authority: string, err: any): void;
+    _setAuthorityConnectionToken(authority: string, connectionToken: string): void;
+    _setCanonicalURIProvider(provider: (uri: URI) => Promise<URI>): void;
+}

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

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 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';
@@ -9,7 +10,7 @@ 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.service';
 import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
-import { getRemoteAuthorityPrefix, WebSocketRemoteConnection } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
+import { getRemoteAuthorityPrefix, WebSocketRemoteConnection, RemoteConnectionType } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
 import { parseAuthorityWithOptionalPort } from 'vscode/vscode/vs/platform/remote/common/remoteHosts';
 
 let RemoteAuthorityResolverService = class RemoteAuthorityResolverService extends Disposable {
@@ -78,7 +79,7 @@ let RemoteAuthorityResolverService = class RemoteAuthorityResolverService extend
     _setResolvedAuthority(resolvedAuthority, options) {
         if (( this._resolveAuthorityRequests.has(resolvedAuthority.authority))) {
             const request = this._resolveAuthorityRequests.get(resolvedAuthority.authority);
-            if (resolvedAuthority.connectTo.type === 0 ) {
+            if (resolvedAuthority.connectTo.type === RemoteConnectionType.WebSocket) {
                 RemoteAuthorities.set(resolvedAuthority.authority, resolvedAuthority.connectTo.host, resolvedAuthority.connectTo.port);
             }
             if (resolvedAuthority.connectionToken) {

package/vscode/src/vs/platform/remote/common/remoteExtensionsScanner.d.ts

@@ -0,0 +1 @@
+export declare const RemoteExtensionsScannerChannelName = "remoteExtensionsScanner";

package/vscode/src/vs/platform/remote/common/remoteExtensionsScanner.js

@@ -1,3 +1,5 @@
+
+
 const RemoteExtensionsScannerChannelName = 'remoteExtensionsScanner';
 
 export { RemoteExtensionsScannerChannelName };

package/vscode/src/vs/platform/remote/common/remoteSocketFactoryService.d.ts

@@ -0,0 +1,15 @@
+import { IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { ISocket } from "vscode/vscode/vs/base/parts/ipc/common/ipc.net";
+import { RemoteConnectionOfType, RemoteConnectionType, RemoteConnection } from "vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver";
+import { IRemoteSocketFactoryService } from "vscode/vscode/vs/platform/remote/common/remoteSocketFactoryService.service";
+export interface ISocketFactory<T extends RemoteConnectionType> {
+    supports(connectTo: RemoteConnectionOfType<T>): boolean;
+    connect(connectTo: RemoteConnectionOfType<T>, path: string, query: string, debugLabel: string): Promise<ISocket>;
+}
+export declare class RemoteSocketFactoryService implements IRemoteSocketFactoryService {
+    readonly _serviceBrand: undefined;
+    private readonly factories;
+    register<T extends RemoteConnectionType>(type: T, factory: ISocketFactory<T>): IDisposable;
+    private getSocketFactory;
+    connect(connectTo: RemoteConnection, path: string, query: string, debugLabel: string): Promise<ISocket>;
+}

package/vscode/src/vs/platform/remote/common/remoteSocketFactoryService.js

@@ -1,3 +1,4 @@
+
 import { toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 
 class RemoteSocketFactoryService {

package/vscode/src/vs/workbench/contrib/remote/browser/explorerViewItems.d.ts

@@ -0,0 +1,25 @@
+import { IRemoteExplorerService } from "vscode/vscode/vs/workbench/services/remote/common/remoteExplorerService.service";
+import { IViewDescriptor } from "vscode/vscode/vs/workbench/common/views";
+import { IWorkbenchEnvironmentService } from "vscode/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IStorageService } from "vscode/vscode/vs/platform/storage/common/storage.service";
+import { RawContextKey } from "vscode/vscode/vs/platform/contextkey/common/contextkey";
+import { IContextKeyService } from "vscode/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IWorkspaceContextService } from "vscode/vscode/vs/platform/workspace/common/workspace.service";
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+export declare const SELECTED_REMOTE_IN_EXPLORER: RawContextKey<string>;
+export declare class SwitchRemoteViewItem extends Disposable {
+    private readonly contextKeyService;
+    private remoteExplorerService;
+    private environmentService;
+    private readonly storageService;
+    private readonly workspaceContextService;
+    private switchRemoteMenu;
+    private completedRemotes;
+    private readonly selectedRemoteContext;
+    constructor(contextKeyService: IContextKeyService, remoteExplorerService: IRemoteExplorerService, environmentService: IWorkbenchEnvironmentService, storageService: IStorageService, workspaceContextService: IWorkspaceContextService);
+    setSelectionForConnection(): boolean;
+    private select;
+    private getAuthorityForExplorerType;
+    removeOptionItems(views: IViewDescriptor[]): void;
+    createOptionItems(views: IViewDescriptor[]): void;
+}