@codingame/monaco-vscode-extensions-service-override 3.2.3 → 4.1.0

package/vscode/src/vs/workbench/services/extensions/common/remoteConsoleUtil.js

@@ -1,49 +0,0 @@
-import { parse } from '../../../../base/common/console.js';
-
-function logRemoteEntry(logService, entry, label = null) {
-    const args = parse(entry).args;
-    let firstArg = args.shift();
-    if (typeof firstArg !== 'string') {
-        return;
-    }
-    if (!entry.severity) {
-        entry.severity = 'info';
-    }
-    if (label) {
-        if (!/^\[/.test(label)) {
-            label = `[${label}]`;
-        }
-        if (!/ $/.test(label)) {
-            label = `${label} `;
-        }
-        firstArg = label + firstArg;
-    }
-    switch (entry.severity) {
-        case 'log':
-        case 'info':
-            logService.info(firstArg, ...args);
-            break;
-        case 'warn':
-            logService.warn(firstArg, ...args);
-            break;
-        case 'error':
-            logService.error(firstArg, ...args);
-            break;
-    }
-}
-function logRemoteEntryIfError(logService, entry, label) {
-    const args = parse(entry).args;
-    const firstArg = args.shift();
-    if (typeof firstArg !== 'string' || entry.severity !== 'error') {
-        return;
-    }
-    if (!/^\[/.test(label)) {
-        label = `[${label}]`;
-    }
-    if (!/ $/.test(label)) {
-        label = `${label} `;
-    }
-    logService.error(label + firstArg, ...args);
-}
-
-export { logRemoteEntry, logRemoteEntryIfError };

package/vscode/src/vs/workbench/services/extensions/common/remoteExtensionHost.js

@@ -1,222 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-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 { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { language, isWeb } from 'vscode/vscode/vs/base/common/platform';
-import { IExtensionHostDebugService } from 'vscode/vscode/vs/platform/debug/common/extensionHostDebug';
-import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
-import { ILogService, ILoggerService } from 'vscode/vscode/vs/platform/log/common/log';
-import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
-import { connectRemoteAgentExtensionHost } from 'vscode/vscode/vs/platform/remote/common/remoteAgentConnection';
-import { IRemoteAuthorityResolverService } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
-import { IRemoteSocketFactoryService } from 'vscode/vscode/vs/platform/remote/common/remoteSocketFactoryService';
-import { ISignService } from 'vscode/vscode/vs/platform/sign/common/sign';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-import { isLoggingOnly } from 'vscode/vscode/vs/platform/telemetry/common/telemetryUtils';
-import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
-import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
-import { parseExtensionDevOptions } from './extensionDevOptions.js';
-import { isMessageOfType, UIKind, createMessageOfType } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostProtocol';
-
-let RemoteExtensionHost = class RemoteExtensionHost extends Disposable {
-    constructor(runningLocation, _initDataProvider, remoteSocketFactoryService, _contextService, _environmentService, _telemetryService, _logService, _loggerService, _labelService, remoteAuthorityResolverService, _extensionHostDebugService, _productService, _signService) {
-        super();
-        this.runningLocation = runningLocation;
-        this._initDataProvider = _initDataProvider;
-        this.remoteSocketFactoryService = remoteSocketFactoryService;
-        this._contextService = _contextService;
-        this._environmentService = _environmentService;
-        this._telemetryService = _telemetryService;
-        this._logService = _logService;
-        this._loggerService = _loggerService;
-        this._labelService = _labelService;
-        this.remoteAuthorityResolverService = remoteAuthorityResolverService;
-        this._extensionHostDebugService = _extensionHostDebugService;
-        this._productService = _productService;
-        this._signService = _signService;
-        this.pid = null;
-        this.startup = 1 ;
-        this.extensions = null;
-        this._onExit = this._register(( new Emitter()));
-        this.onExit = this._onExit.event;
-        this.remoteAuthority = this._initDataProvider.remoteAuthority;
-        this._protocol = null;
-        this._hasLostConnection = false;
-        this._terminating = false;
-        const devOpts = parseExtensionDevOptions(this._environmentService);
-        this._isExtensionDevHost = devOpts.isExtensionDevHost;
-    }
-    start() {
-        const options = {
-            commit: this._productService.commit,
-            quality: this._productService.quality,
-            addressProvider: {
-                getAddress: async () => {
-                    const { authority } = await this.remoteAuthorityResolverService.resolveAuthority(this._initDataProvider.remoteAuthority);
-                    return { connectTo: authority.connectTo, connectionToken: authority.connectionToken };
-                }
-            },
-            remoteSocketFactoryService: this.remoteSocketFactoryService,
-            signService: this._signService,
-            logService: this._logService,
-            ipcLogger: null
-        };
-        return this.remoteAuthorityResolverService.resolveAuthority(this._initDataProvider.remoteAuthority).then((resolverResult) => {
-            const startParams = {
-                language: language,
-                debugId: this._environmentService.debugExtensionHost.debugId,
-                break: this._environmentService.debugExtensionHost.break,
-                port: this._environmentService.debugExtensionHost.port,
-                env: { ...this._environmentService.debugExtensionHost.env, ...resolverResult.options?.extensionHostEnv },
-            };
-            const extDevLocs = this._environmentService.extensionDevelopmentLocationURI;
-            let debugOk = true;
-            if (extDevLocs && extDevLocs.length > 0) {
-                if (extDevLocs[0].scheme === Schemas.file) {
-                    debugOk = false;
-                }
-            }
-            if (!debugOk) {
-                startParams.break = false;
-            }
-            return connectRemoteAgentExtensionHost(options, startParams).then(result => {
-                this._register(result);
-                const { protocol, debugPort, reconnectionToken } = result;
-                const isExtensionDevelopmentDebug = typeof debugPort === 'number';
-                if (debugOk && this._environmentService.isExtensionDevelopment && this._environmentService.debugExtensionHost.debugId && debugPort) {
-                    this._extensionHostDebugService.attachSession(this._environmentService.debugExtensionHost.debugId, debugPort, this._initDataProvider.remoteAuthority);
-                }
-                protocol.onDidDispose(() => {
-                    this._onExtHostConnectionLost(reconnectionToken);
-                });
-                protocol.onSocketClose(() => {
-                    if (this._isExtensionDevHost) {
-                        this._onExtHostConnectionLost(reconnectionToken);
-                    }
-                });
-                return ( new Promise((resolve, reject) => {
-                    const handle = setTimeout(() => {
-                        reject('The remote extension host took longer than 60s to send its ready message.');
-                    }, 60 * 1000);
-                    const disposable = protocol.onMessage(msg => {
-                        if (isMessageOfType(msg, 1 )) {
-                            this._createExtHostInitData(isExtensionDevelopmentDebug).then(data => {
-                                protocol.send(VSBuffer.fromString(JSON.stringify(data)));
-                            });
-                            return;
-                        }
-                        if (isMessageOfType(msg, 0 )) {
-                            clearTimeout(handle);
-                            disposable.dispose();
-                            this._protocol = protocol;
-                            resolve(protocol);
-                            return;
-                        }
-                        console.error(`received unexpected message during handshake phase from the extension host: `, msg);
-                    });
-                }));
-            });
-        });
-    }
-    _onExtHostConnectionLost(reconnectionToken) {
-        if (this._hasLostConnection) {
-            return;
-        }
-        this._hasLostConnection = true;
-        if (this._isExtensionDevHost && this._environmentService.debugExtensionHost.debugId) {
-            this._extensionHostDebugService.close(this._environmentService.debugExtensionHost.debugId);
-        }
-        if (this._terminating) {
-            return;
-        }
-        this._onExit.fire([0, reconnectionToken]);
-    }
-    async _createExtHostInitData(isExtensionDevelopmentDebug) {
-        const remoteInitData = await this._initDataProvider.getInitData();
-        this.extensions = remoteInitData.extensions;
-        const workspace = this._contextService.getWorkspace();
-        return {
-            commit: this._productService.commit,
-            version: this._productService.version,
-            quality: this._productService.quality,
-            parentPid: remoteInitData.pid,
-            environment: {
-                isExtensionDevelopmentDebug,
-                appRoot: remoteInitData.appRoot,
-                appName: this._productService.nameLong,
-                appHost: this._productService.embedderIdentifier || 'desktop',
-                appUriScheme: this._productService.urlProtocol,
-                extensionTelemetryLogResource: this._environmentService.extHostTelemetryLogFile,
-                isExtensionTelemetryLoggingOnly: isLoggingOnly(this._productService, this._environmentService),
-                appLanguage: language,
-                extensionDevelopmentLocationURI: this._environmentService.extensionDevelopmentLocationURI,
-                extensionTestsLocationURI: this._environmentService.extensionTestsLocationURI,
-                globalStorageHome: remoteInitData.globalStorageHome,
-                workspaceStorageHome: remoteInitData.workspaceStorageHome,
-                extensionLogLevel: this._environmentService.extensionLogLevel
-            },
-            workspace: this._contextService.getWorkbenchState() === 1  ? null : {
-                configuration: workspace.configuration,
-                id: workspace.id,
-                name: this._labelService.getWorkspaceLabel(workspace),
-                transient: workspace.transient
-            },
-            remote: {
-                isRemote: true,
-                authority: this._initDataProvider.remoteAuthority,
-                connectionData: remoteInitData.connectionData
-            },
-            consoleForward: {
-                includeStack: false,
-                logNative: Boolean(this._environmentService.debugExtensionHost.debugId)
-            },
-            extensions: this.extensions.toSnapshot(),
-            telemetryInfo: {
-                sessionId: this._telemetryService.sessionId,
-                machineId: this._telemetryService.machineId,
-                sqmId: this._telemetryService.sqmId,
-                firstSessionDate: this._telemetryService.firstSessionDate,
-                msftInternal: this._telemetryService.msftInternal
-            },
-            logLevel: this._logService.getLevel(),
-            loggers: [...this._loggerService.getRegisteredLoggers()],
-            logsLocation: remoteInitData.extensionHostLogsPath,
-            autoStart: ((this.startup === 1) ),
-            uiKind: isWeb ? UIKind.Web : UIKind.Desktop
-        };
-    }
-    getInspectPort() {
-        return undefined;
-    }
-    enableInspectPort() {
-        return Promise.resolve(false);
-    }
-    dispose() {
-        super.dispose();
-        this._terminating = true;
-        if (this._protocol) {
-            const socket = this._protocol.getSocket();
-            this._protocol.send(createMessageOfType(2 ));
-            this._protocol.sendDisconnect();
-            this._protocol.dispose();
-            socket.end();
-            this._protocol = null;
-        }
-    }
-};
-RemoteExtensionHost = ( __decorate([
-    ( __param(2, IRemoteSocketFactoryService)),
-    ( __param(3, IWorkspaceContextService)),
-    ( __param(4, IWorkbenchEnvironmentService)),
-    ( __param(5, ITelemetryService)),
-    ( __param(6, ILogService)),
-    ( __param(7, ILoggerService)),
-    ( __param(8, ILabelService)),
-    ( __param(9, IRemoteAuthorityResolverService)),
-    ( __param(10, IExtensionHostDebugService)),
-    ( __param(11, IProductService)),
-    ( __param(12, ISignService))
-], RemoteExtensionHost));
-
-export { RemoteExtensionHost };