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

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

@@ -1,98 +0,0 @@
-import { VSBuffer, encodeBase64 } from 'vscode/vscode/vs/base/common/buffer';
-import { PauseableEmitter, Emitter } from 'vscode/vscode/vs/base/common/event';
-import { DisposableStore, Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { SocketDiagnostics } from 'vscode/vscode/vs/base/parts/ipc/common/ipc.net';
-
-const makeRawSocketHeaders = (path, query, deubgLabel) => {
-    const buffer = ( new Uint8Array(16));
-    for (let i = 0; i < 16; i++) {
-        buffer[i] = Math.round(Math.random() * 256);
-    }
-    const nonce = encodeBase64(VSBuffer.wrap(buffer));
-    const headers = [
-        `GET ws://localhost${path}?${query}&skipWebSocketFrames=true HTTP/1.1`,
-        `Connection: Upgrade`,
-        `Upgrade: websocket`,
-        `Sec-WebSocket-Key: ${nonce}`
-    ];
-    return headers.join('\r\n') + '\r\n\r\n';
-};
-const socketRawEndHeaderSequence = VSBuffer.fromString('\r\n\r\n');
-async function connectManagedSocket(socket, path, query, debugLabel, half) {
-    socket.write(VSBuffer.fromString(makeRawSocketHeaders(path, query)));
-    const d = ( new DisposableStore());
-    try {
-        return await ( new Promise((resolve, reject) => {
-            let dataSoFar;
-            d.add(socket.onData(d_1 => {
-                if (!dataSoFar) {
-                    dataSoFar = d_1;
-                }
-                else {
-                    dataSoFar = VSBuffer.concat([dataSoFar, d_1], dataSoFar.byteLength + d_1.byteLength);
-                }
-                const index = dataSoFar.indexOf(socketRawEndHeaderSequence);
-                if (index === -1) {
-                    return;
-                }
-                resolve(socket);
-                socket.pauseData();
-                const rest = dataSoFar.slice(index + socketRawEndHeaderSequence.byteLength);
-                if (rest.byteLength) {
-                    half.onData.fire(rest);
-                }
-            }));
-            d.add(socket.onClose(err => reject(err ?? ( new Error('socket closed')))));
-            d.add(socket.onEnd(() => reject(( new Error('socket ended')))));
-        }));
-    }
-    catch (e) {
-        socket.dispose();
-        throw e;
-    }
-    finally {
-        d.dispose();
-    }
-}
-class ManagedSocket extends Disposable {
-    constructor(debugLabel, half) {
-        super();
-        this.debugLabel = debugLabel;
-        this.pausableDataEmitter = this._register(( new PauseableEmitter()));
-        this.onData = (...args) => {
-            if (this.pausableDataEmitter.isPaused) {
-                queueMicrotask(() => this.pausableDataEmitter.resume());
-            }
-            return this.pausableDataEmitter.event(...args);
-        };
-        this.didDisposeEmitter = this._register(( new Emitter()));
-        this.onDidDispose = this.didDisposeEmitter.event;
-        this.ended = false;
-        this._register(half.onData);
-        this._register(half.onData.event(data => this.pausableDataEmitter.fire(data)));
-        this.onClose = this._register(half.onClose).event;
-        this.onEnd = this._register(half.onEnd).event;
-    }
-    pauseData() {
-        this.pausableDataEmitter.pause();
-    }
-    drain() {
-        return Promise.resolve();
-    }
-    end() {
-        this.ended = true;
-        this.closeRemote();
-    }
-    traceSocketEvent(type, data) {
-        SocketDiagnostics.traceSocketEvent(this, this.debugLabel, type, data);
-    }
-    dispose() {
-        if (!this.ended) {
-            this.closeRemote();
-        }
-        this.didDisposeEmitter.fire();
-        super.dispose();
-    }
-}
-
-export { ManagedSocket, connectManagedSocket, makeRawSocketHeaders, socketRawEndHeaderSequence };

package/vscode/src/vs/workbench/api/browser/mainThreadAiEmbeddingVector.js

@@ -1,31 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Disposable, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
-import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { IAiEmbeddingVectorService } from 'vscode/vscode/vs/workbench/services/aiEmbeddingVector/common/aiEmbeddingVectorService';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-
-let MainThreadAiEmbeddingVector = class MainThreadAiEmbeddingVector extends Disposable {
-    constructor(context, _AiEmbeddingVectorService) {
-        super();
-        this._AiEmbeddingVectorService = _AiEmbeddingVectorService;
-        this._registrations = this._register(( new DisposableMap()));
-        this._proxy = ( context.getProxy(ExtHostContext.ExtHostAiEmbeddingVector));
-    }
-    $registerAiEmbeddingVectorProvider(model, handle) {
-        const provider = {
-            provideAiEmbeddingVector: (strings, token) => {
-                return this._proxy.$provideAiEmbeddingVector(handle, strings, token);
-            },
-        };
-        this._registrations.set(handle, this._AiEmbeddingVectorService.registerAiEmbeddingVectorProvider(model, provider));
-    }
-    $unregisterAiEmbeddingVectorProvider(handle) {
-        this._registrations.deleteAndDispose(handle);
-    }
-};
-MainThreadAiEmbeddingVector = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadAiEmbeddingVector),
-    ( __param(1, IAiEmbeddingVectorService))
-], MainThreadAiEmbeddingVector);
-
-export { MainThreadAiEmbeddingVector };

package/vscode/src/vs/workbench/api/browser/mainThreadAiRelatedInformation.js

@@ -1,35 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
-import { Disposable, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
-import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { IAiRelatedInformationService } from 'vscode/vscode/vs/workbench/services/aiRelatedInformation/common/aiRelatedInformation';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-
-let MainThreadAiRelatedInformation = class MainThreadAiRelatedInformation extends Disposable {
-    constructor(context, _aiRelatedInformationService) {
-        super();
-        this._aiRelatedInformationService = _aiRelatedInformationService;
-        this._registrations = this._register(( new DisposableMap()));
-        this._proxy = ( context.getProxy(ExtHostContext.ExtHostAiRelatedInformation));
-    }
-    $getAiRelatedInformation(query, types) {
-        return this._aiRelatedInformationService.getRelatedInformation(query, types, CancellationToken.None);
-    }
-    $registerAiRelatedInformationProvider(handle, type) {
-        const provider = {
-            provideAiRelatedInformation: (query, token) => {
-                return this._proxy.$provideAiRelatedInformation(handle, query, token);
-            },
-        };
-        this._registrations.set(handle, this._aiRelatedInformationService.registerAiRelatedInformationProvider(type, provider));
-    }
-    $unregisterAiRelatedInformationProvider(handle) {
-        this._registrations.deleteAndDispose(handle);
-    }
-};
-MainThreadAiRelatedInformation = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadAiRelatedInformation),
-    ( __param(1, IAiRelatedInformationService))
-], MainThreadAiRelatedInformation);
-
-export { MainThreadAiRelatedInformation };

package/vscode/src/vs/workbench/api/browser/mainThreadAuthentication.js

@@ -1,227 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Disposable, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { getAuthenticationProviderActivationEvent, addAccountUsage } from 'vscode/vscode/vs/workbench/services/authentication/browser/authenticationService';
-import { IAuthenticationService } from 'vscode/vscode/vs/workbench/services/authentication/common/authentication';
-import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import Severity from 'vscode/vscode/vs/base/common/severity';
-import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
-import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
-
-class MainThreadAuthenticationProvider extends Disposable {
-    constructor(_proxy, id, label, supportsMultipleAccounts, notificationService, onDidChangeSessionsEmitter) {
-        super();
-        this._proxy = _proxy;
-        this.id = id;
-        this.label = label;
-        this.supportsMultipleAccounts = supportsMultipleAccounts;
-        this.notificationService = notificationService;
-        this.onDidChangeSessions = onDidChangeSessionsEmitter.event;
-    }
-    async getSessions(scopes) {
-        return this._proxy.$getSessions(this.id, scopes);
-    }
-    createSession(scopes, options) {
-        return this._proxy.$createSession(this.id, scopes, options);
-    }
-    async removeSession(sessionId) {
-        await this._proxy.$removeSession(this.id, sessionId);
-        this.notificationService.info(( localizeWithPath(
-            'vs/workbench/api/browser/mainThreadAuthentication',
-            'signedOut',
-            "Successfully signed out."
-        )));
-    }
-}
-let MainThreadAuthentication = class MainThreadAuthentication extends Disposable {
-    constructor(extHostContext, authenticationService, dialogService, storageService, notificationService, extensionService, telemetryService) {
-        super();
-        this.authenticationService = authenticationService;
-        this.dialogService = dialogService;
-        this.storageService = storageService;
-        this.notificationService = notificationService;
-        this.extensionService = extensionService;
-        this.telemetryService = telemetryService;
-        this._registrations = this._register(( new DisposableMap()));
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostAuthentication));
-        this._register(this.authenticationService.onDidChangeSessions(e => {
-            this._proxy.$onDidChangeAuthenticationSessions(e.providerId, e.label);
-        }));
-    }
-    async $registerAuthenticationProvider(id, label, supportsMultipleAccounts) {
-        const emitter = ( new Emitter());
-        this._registrations.set(id, emitter);
-        const provider = ( new MainThreadAuthenticationProvider(
-            this._proxy,
-            id,
-            label,
-            supportsMultipleAccounts,
-            this.notificationService,
-            emitter
-        ));
-        this.authenticationService.registerAuthenticationProvider(id, provider);
-    }
-    $unregisterAuthenticationProvider(id) {
-        this._registrations.deleteAndDispose(id);
-        this.authenticationService.unregisterAuthenticationProvider(id);
-    }
-    async $ensureProvider(id) {
-        if (!this.authenticationService.isAuthenticationProviderRegistered(id)) {
-            return await this.extensionService.activateByEvent(getAuthenticationProviderActivationEvent(id), 1 );
-        }
-    }
-    $sendDidChangeSessions(providerId, event) {
-        const obj = this._registrations.get(providerId);
-        if (obj instanceof Emitter) {
-            obj.fire(event);
-        }
-    }
-    $removeSession(providerId, sessionId) {
-        return this.authenticationService.removeSession(providerId, sessionId);
-    }
-    async loginPrompt(providerName, extensionName, recreatingSession, detail) {
-        const message = recreatingSession
-            ? ( localizeWithPath(
-            'vs/workbench/api/browser/mainThreadAuthentication',
-            'confirmRelogin',
-            "The extension '{0}' wants you to sign in again using {1}.",
-            extensionName,
-            providerName
-        ))
-            : ( localizeWithPath(
-            'vs/workbench/api/browser/mainThreadAuthentication',
-            'confirmLogin',
-            "The extension '{0}' wants to sign in using {1}.",
-            extensionName,
-            providerName
-        ));
-        const { confirmed } = await this.dialogService.confirm({
-            type: Severity.Info,
-            message,
-            detail,
-            primaryButton: ( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadAuthentication',
-                { key: 'allow', comment: ['&& denotes a mnemonic'] },
-                "&&Allow"
-            ))
-        });
-        return confirmed;
-    }
-    async doGetSession(providerId, scopes, extensionId, extensionName, options) {
-        const sessions = await this.authenticationService.getSessions(providerId, scopes, true);
-        const supportsMultipleAccounts = this.authenticationService.supportsMultipleAccounts(providerId);
-        if (options.forceNewSession && options.createIfNone) {
-            throw new Error('Invalid combination of options. Please remove one of the following: forceNewSession, createIfNone');
-        }
-        if (options.forceNewSession && options.silent) {
-            throw new Error('Invalid combination of options. Please remove one of the following: forceNewSession, silent');
-        }
-        if (options.createIfNone && options.silent) {
-            throw new Error('Invalid combination of options. Please remove one of the following: createIfNone, silent');
-        }
-        if (!options.forceNewSession && sessions.length) {
-            if (supportsMultipleAccounts) {
-                if (options.clearSessionPreference) {
-                    this.authenticationService.removeSessionPreference(providerId, extensionId, scopes);
-                }
-                else {
-                    const existingSessionPreference = this.authenticationService.getSessionPreference(providerId, extensionId, scopes);
-                    if (existingSessionPreference) {
-                        const matchingSession = sessions.find(session => session.id === existingSessionPreference);
-                        if (matchingSession && this.authenticationService.isAccessAllowed(providerId, matchingSession.account.label, extensionId)) {
-                            return matchingSession;
-                        }
-                    }
-                }
-            }
-            else if (this.authenticationService.isAccessAllowed(providerId, sessions[0].account.label, extensionId)) {
-                return sessions[0];
-            }
-        }
-        if (options.createIfNone || options.forceNewSession) {
-            const providerName = this.authenticationService.getLabel(providerId);
-            const detail = (typeof options.forceNewSession === 'object') ? options.forceNewSession.detail : undefined;
-            const recreatingSession = !!(options.forceNewSession && sessions.length);
-            const isAllowed = await this.loginPrompt(providerName, extensionName, recreatingSession, detail);
-            if (!isAllowed) {
-                throw new Error('User did not consent to login.');
-            }
-            let session;
-            if (sessions?.length && !options.forceNewSession) {
-                session = supportsMultipleAccounts
-                    ? await this.authenticationService.selectSession(providerId, extensionId, extensionName, scopes, sessions)
-                    : sessions[0];
-            }
-            else {
-                let sessionToRecreate;
-                if (typeof options.forceNewSession === 'object' && options.forceNewSession.sessionToRecreate) {
-                    sessionToRecreate = options.forceNewSession.sessionToRecreate;
-                }
-                else {
-                    const sessionIdToRecreate = this.authenticationService.getSessionPreference(providerId, extensionId, scopes);
-                    sessionToRecreate = sessionIdToRecreate ? sessions.find(session => session.id === sessionIdToRecreate) : undefined;
-                }
-                session = await this.authenticationService.createSession(providerId, scopes, { activateImmediate: true, sessionToRecreate });
-            }
-            this.authenticationService.updateAllowedExtension(providerId, session.account.label, extensionId, extensionName, true);
-            this.authenticationService.updateSessionPreference(providerId, extensionId, session);
-            return session;
-        }
-        const validSession = sessions.find(session => this.authenticationService.isAccessAllowed(providerId, session.account.label, extensionId));
-        if (validSession) {
-            if (!this.authenticationService.getSessionPreference(providerId, extensionId, scopes)) {
-                if (this.storageService.get(`${extensionName}-${providerId}`, -1 )) {
-                    this.storageService.remove(`${extensionName}-${providerId}`, -1 );
-                }
-                this.authenticationService.updateAllowedExtension(providerId, validSession.account.label, extensionId, extensionName, true);
-                this.authenticationService.updateSessionPreference(providerId, extensionId, validSession);
-            }
-            return validSession;
-        }
-        if (!options.silent) {
-            sessions.length
-                ? this.authenticationService.requestSessionAccess(providerId, extensionId, extensionName, scopes, sessions)
-                : await this.authenticationService.requestNewSession(providerId, scopes, extensionId, extensionName);
-        }
-        return undefined;
-    }
-    async $getSession(providerId, scopes, extensionId, extensionName, options) {
-        const session = await this.doGetSession(providerId, scopes, extensionId, extensionName, options);
-        if (session) {
-            this.sendProviderUsageTelemetry(extensionId, providerId);
-            addAccountUsage(this.storageService, providerId, session.account.label, extensionId, extensionName);
-        }
-        return session;
-    }
-    async $getSessions(providerId, scopes, extensionId, extensionName) {
-        const sessions = await this.authenticationService.getSessions(providerId, [...scopes], true);
-        const accessibleSessions = sessions.filter(s => this.authenticationService.isAccessAllowed(providerId, s.account.label, extensionId));
-        if (accessibleSessions.length) {
-            this.sendProviderUsageTelemetry(extensionId, providerId);
-            for (const session of accessibleSessions) {
-                addAccountUsage(this.storageService, providerId, session.account.label, extensionId, extensionName);
-            }
-        }
-        return accessibleSessions;
-    }
-    sendProviderUsageTelemetry(extensionId, providerId) {
-        this.telemetryService.publicLog2('authentication.providerUsage', { providerId, extensionId });
-    }
-};
-MainThreadAuthentication = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadAuthentication),
-    ( __param(1, IAuthenticationService)),
-    ( __param(2, IDialogService)),
-    ( __param(3, IStorageService)),
-    ( __param(4, INotificationService)),
-    ( __param(5, IExtensionService)),
-    ( __param(6, ITelemetryService))
-], MainThreadAuthentication);
-
-export { MainThreadAuthentication, MainThreadAuthenticationProvider };

package/vscode/src/vs/workbench/api/browser/mainThreadBulkEdits.js

@@ -1,68 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { decodeBase64 } from 'vscode/vscode/vs/base/common/buffer';
-import { revive } from 'vscode/vscode/vs/base/common/marshalling';
-import { IBulkEditService, ResourceTextEdit, ResourceFileEdit } from 'vscode/vscode/vs/editor/browser/services/bulkEditService';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
-import { MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { ResourceNotebookCellEdit } from 'vscode/vscode/vs/workbench/contrib/bulkEdit/browser/bulkCellEdits';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-
-let MainThreadBulkEdits = class MainThreadBulkEdits {
-    constructor(_extHostContext, _bulkEditService, _logService, _uriIdentService) {
-        this._bulkEditService = _bulkEditService;
-        this._logService = _logService;
-        this._uriIdentService = _uriIdentService;
-    }
-    dispose() { }
-    $tryApplyWorkspaceEdit(dto, undoRedoGroupId, isRefactoring) {
-        const edits = reviveWorkspaceEditDto(dto, this._uriIdentService);
-        return this._bulkEditService.apply(edits, { undoRedoGroupId, respectAutoSaveConfig: isRefactoring }).then((res) => res.isApplied, err => {
-            this._logService.warn(`IGNORING workspace edit: ${err}`);
-            return false;
-        });
-    }
-};
-MainThreadBulkEdits = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadBulkEdits),
-    ( __param(1, IBulkEditService)),
-    ( __param(2, ILogService)),
-    ( __param(3, IUriIdentityService))
-], MainThreadBulkEdits);
-function reviveWorkspaceEditDto(data, uriIdentityService, resolveDataTransferFile) {
-    if (!data || !data.edits) {
-        return data;
-    }
-    const result = revive(data);
-    for (const edit of result.edits) {
-        if (ResourceTextEdit.is(edit)) {
-            edit.resource = uriIdentityService.asCanonicalUri(edit.resource);
-        }
-        if (ResourceFileEdit.is(edit)) {
-            if (edit.options) {
-                const inContents = edit.options?.contents;
-                if (inContents) {
-                    if (inContents.type === 'base64') {
-                        edit.options.contents = Promise.resolve(decodeBase64(inContents.value));
-                    }
-                    else {
-                        if (resolveDataTransferFile) {
-                            edit.options.contents = resolveDataTransferFile(inContents.id);
-                        }
-                        else {
-                            throw new Error('Could not revive data transfer file');
-                        }
-                    }
-                }
-            }
-            edit.newResource = edit.newResource && uriIdentityService.asCanonicalUri(edit.newResource);
-            edit.oldResource = edit.oldResource && uriIdentityService.asCanonicalUri(edit.oldResource);
-        }
-        if (ResourceNotebookCellEdit.is(edit)) {
-            edit.resource = uriIdentityService.asCanonicalUri(edit.resource);
-        }
-    }
-    return data;
-}
-
-export { MainThreadBulkEdits, reviveWorkspaceEditDto };

package/vscode/src/vs/workbench/api/browser/mainThreadCLICommands.js

@@ -1,103 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { isWeb } from 'vscode/vscode/vs/base/common/platform';
-import { isString } from 'vscode/vscode/vs/base/common/types';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { CommandsRegistry, ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { IExtensionManagementService, IExtensionGalleryService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
-import { ExtensionManagementCLI } from '../../../platform/extensionManagement/common/extensionManagementCLI.js';
-import { getExtensionId } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { ServiceCollection } from 'vscode/vscode/vs/platform/instantiation/common/serviceCollection';
-import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
-import { AbstractMessageLogger } from 'vscode/vscode/vs/platform/log/common/log';
-import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
-import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
-import { IExtensionManagementServerService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
-import { IExtensionManifestPropertiesService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService';
-
-CommandsRegistry.registerCommand('_remoteCLI.openExternal', function (accessor, uri) {
-    const openerService = accessor.get(IOpenerService);
-    return openerService.open(isString(uri) ? uri : URI.revive(uri), { openExternal: true, allowTunneling: true });
-});
-CommandsRegistry.registerCommand('_remoteCLI.windowOpen', function (accessor, toOpen, options) {
-    const commandService = accessor.get(ICommandService);
-    if (!toOpen.length) {
-        return commandService.executeCommand('_files.newWindow', options);
-    }
-    return commandService.executeCommand('_files.windowOpen', toOpen, options);
-});
-CommandsRegistry.registerCommand('_remoteCLI.getSystemStatus', function (accessor) {
-    const commandService = accessor.get(ICommandService);
-    return commandService.executeCommand('_issues.getSystemStatus');
-});
-CommandsRegistry.registerCommand('_remoteCLI.manageExtensions', async function (accessor, args) {
-    const instantiationService = accessor.get(IInstantiationService);
-    const extensionManagementServerService = accessor.get(IExtensionManagementServerService);
-    const remoteExtensionManagementService = extensionManagementServerService.remoteExtensionManagementServer?.extensionManagementService;
-    if (!remoteExtensionManagementService) {
-        return;
-    }
-    const lines = [];
-    const logger = new (class extends AbstractMessageLogger {
-        log(level, message) {
-            lines.push(message);
-        }
-    })();
-    const cliService = instantiationService.createChild(( new ServiceCollection([IExtensionManagementService, remoteExtensionManagementService]))).createInstance(RemoteExtensionManagementCLI, logger);
-    if (args.list) {
-        await cliService.listExtensions(!!args.list.showVersions, args.list.category, undefined);
-    }
-    else {
-        const revive = (inputs) => ( inputs.map(input => isString(input) ? input : URI.revive(input)));
-        if (Array.isArray(args.install) && args.install.length) {
-            try {
-                await cliService.installExtensions(revive(args.install), [], { isMachineScoped: true }, !!args.force);
-            }
-            catch (e) {
-                lines.push(e.message);
-            }
-        }
-        if (Array.isArray(args.uninstall) && args.uninstall.length) {
-            try {
-                await cliService.uninstallExtensions(revive(args.uninstall), !!args.force, undefined);
-            }
-            catch (e) {
-                lines.push(e.message);
-            }
-        }
-    }
-    return lines.join('\n');
-});
-let RemoteExtensionManagementCLI = class RemoteExtensionManagementCLI extends ExtensionManagementCLI {
-    constructor(logger, extensionManagementService, extensionGalleryService, labelService, envService, _extensionManifestPropertiesService) {
-        super(logger, extensionManagementService, extensionGalleryService);
-        this._extensionManifestPropertiesService = _extensionManifestPropertiesService;
-        const remoteAuthority = envService.remoteAuthority;
-        this._location = remoteAuthority ? labelService.getHostLabel(Schemas.vscodeRemote, remoteAuthority) : undefined;
-    }
-    get location() {
-        return this._location;
-    }
-    validateExtensionKind(manifest) {
-        if (!this._extensionManifestPropertiesService.canExecuteOnWorkspace(manifest)
-            && !(isWeb && this._extensionManifestPropertiesService.canExecuteOnWeb(manifest))) {
-            this.logger.info(( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadCLICommands',
-                'cannot be installed',
-                "Cannot install the '{0}' extension because it is declared to not run in this setup.",
-                getExtensionId(manifest.publisher, manifest.name)
-            )));
-            return false;
-        }
-        return true;
-    }
-};
-RemoteExtensionManagementCLI = ( __decorate([
-    ( __param(1, IExtensionManagementService)),
-    ( __param(2, IExtensionGalleryService)),
-    ( __param(3, ILabelService)),
-    ( __param(4, IWorkbenchEnvironmentService)),
-    ( __param(5, IExtensionManifestPropertiesService))
-], RemoteExtensionManagementCLI));

package/vscode/src/vs/workbench/api/browser/mainThreadChat.js

@@ -1,83 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { Disposable, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
-import { IChatContributionService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContributionService';
-import { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-
-let MainThreadChat = class MainThreadChat extends Disposable {
-    constructor(extHostContext, _chatService, _chatWidgetService, chatContribService) {
-        super();
-        this._chatService = _chatService;
-        this._chatWidgetService = _chatWidgetService;
-        this.chatContribService = chatContribService;
-        this._providerRegistrations = this._register(( new DisposableMap()));
-        this._stateEmitters = ( new Map());
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChat));
-    }
-    $transferChatSession(sessionId, toWorkspace) {
-        const sessionIdStr = this._chatService.getSessionId(sessionId);
-        if (!sessionIdStr) {
-            throw new Error(`Failed to transfer session. Unknown session provider ID: ${sessionId}`);
-        }
-        const widget = this._chatWidgetService.getWidgetBySessionId(sessionIdStr);
-        const inputValue = widget?.inputEditor.getValue() ?? '';
-        this._chatService.transferChatSession({ sessionId: sessionIdStr, inputValue: inputValue }, URI.revive(toWorkspace));
-    }
-    async $registerChatProvider(handle, id) {
-        const registration = this.chatContribService.registeredProviders.find(staticProvider => staticProvider.id === id);
-        if (!registration) {
-            throw new Error(`Provider ${id} must be declared in the package.json.`);
-        }
-        const unreg = this._chatService.registerProvider({
-            id,
-            prepareSession: async (token) => {
-                const session = await this._proxy.$prepareChat(handle, token);
-                if (!session) {
-                    return undefined;
-                }
-                const responderAvatarIconUri = session.responderAvatarIconUri &&
-                    URI.revive(session.responderAvatarIconUri);
-                const emitter = ( new Emitter());
-                this._stateEmitters.set(session.id, emitter);
-                return {
-                    id: session.id,
-                    requesterUsername: session.requesterUsername,
-                    requesterAvatarIconUri: URI.revive(session.requesterAvatarIconUri),
-                    responderUsername: session.responderUsername,
-                    responderAvatarIconUri,
-                    inputPlaceholder: session.inputPlaceholder,
-                    dispose: () => {
-                        emitter.dispose();
-                        this._stateEmitters.delete(session.id);
-                        this._proxy.$releaseSession(session.id);
-                    }
-                };
-            },
-        });
-        this._providerRegistrations.set(handle, unreg);
-    }
-    async $acceptChatState(sessionId, state) {
-        this._stateEmitters.get(sessionId)?.fire(state);
-    }
-    async $sendRequestToProvider(providerId, message) {
-        const widget = await this._chatWidgetService.revealViewForProvider(providerId);
-        if (widget && widget.viewModel) {
-            this._chatService.sendRequestToProvider(widget.viewModel.sessionId, message);
-        }
-    }
-    async $unregisterChatProvider(handle) {
-        this._providerRegistrations.deleteAndDispose(handle);
-    }
-};
-MainThreadChat = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadChat),
-    ( __param(1, IChatService)),
-    ( __param(2, IChatWidgetService)),
-    ( __param(3, IChatContributionService))
-], MainThreadChat);
-
-export { MainThreadChat };