@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/api/browser/extensionHost.contribution.js

@@ -0,0 +1,103 @@
+import '../../common/contributions.js';
+import '../../../platform/instantiation/common/instantiation.js';
+import { JSONValidationExtensionPoint } from '../common/jsonValidationExtensionPoint.js';
+import { ColorExtensionPoint } from '../../services/themes/common/colorExtensionPoint.js';
+import { IconExtensionPoint } from '../../services/themes/common/iconExtensionPoint.js';
+import { TokenClassificationExtensionPoints } from '../../services/themes/common/tokenClassificationExtensionPoint.js';
+import { LanguageConfigurationFileHandler } from '../../contrib/codeEditor/common/languageConfigurationExtensionPoint.js';
+import { StatusBarItemsExtensionPoint } from './statusBarExtensionPoint.js';
+import './mainThreadLocalization.js';
+import './mainThreadBulkEdits.js';
+import './mainThreadLanguageModels.js';
+import './mainThreadChatAgents2.js';
+import './mainThreadChatVariables.js';
+import './mainThreadCodeInsets.js';
+import './mainThreadCLICommands.js';
+import './mainThreadClipboard.js';
+import './mainThreadCommands.js';
+import './mainThreadConfiguration.js';
+import './mainThreadConsole.js';
+import './mainThreadDebugService.js';
+import './mainThreadDecorations.js';
+import './mainThreadDiagnostics.js';
+import './mainThreadDialogs.js';
+import './mainThreadDocumentContentProviders.js';
+import './mainThreadDocuments.js';
+import './mainThreadDocumentsAndEditors.js';
+import '../../../base/common/event.js';
+import '../../../base/common/lifecycle.js';
+import '../../../editor/common/config/editorOptions.js';
+import '../../../editor/contrib/snippet/browser/snippetController2.js';
+import '../common/extHost.protocol.js';
+import '../../../base/common/arrays.js';
+import '../../../base/common/strings.js';
+import '../../../base/common/cancellation.js';
+import '../../../editor/contrib/editorState/browser/keybindingCancellation.js';
+import '../../../editor/contrib/snippet/browser/snippetParser.js';
+import './mainThreadEditors.js';
+import './mainThreadEditorTabs.js';
+import './mainThreadErrors.js';
+import './mainThreadExtensionService.js';
+import './mainThreadFileSystem.js';
+import './mainThreadFileSystemEventService.js';
+import './mainThreadLanguageFeatures.js';
+import './mainThreadLanguages.js';
+import './mainThreadLogService.js';
+import './mainThreadMessageService.js';
+import './mainThreadManagedSockets.js';
+import './mainThreadOutputService.js';
+import './mainThreadProgress.js';
+import './mainThreadQuickDiff.js';
+import './mainThreadQuickOpen.js';
+import './mainThreadRemoteConnectionData.js';
+import './mainThreadSaveParticipant.js';
+import './mainThreadSpeech.js';
+import './mainThreadEditSessionIdentityParticipant.js';
+import './mainThreadSCM.js';
+import './mainThreadSearch.js';
+import './mainThreadStatusBar.js';
+import './mainThreadStorage.js';
+import './mainThreadTelemetry.js';
+import './mainThreadTerminalService.js';
+import './mainThreadTerminalShellIntegration.js';
+import './mainThreadTheming.js';
+import './mainThreadTreeViews.js';
+import './mainThreadDownloadService.js';
+import './mainThreadUrls.js';
+import './mainThreadUriOpeners.js';
+import './mainThreadWindow.js';
+import './mainThreadWebviewManager.js';
+import './mainThreadWorkspace.js';
+import './mainThreadComments.js';
+import './mainThreadNotebook.js';
+import './mainThreadNotebookKernels.js';
+import './mainThreadNotebookDocumentsAndEditors.js';
+import './mainThreadNotebookRenderers.js';
+import './mainThreadNotebookSaveParticipant.js';
+import './mainThreadInteractive.js';
+import './mainThreadInlineChat.js';
+import './mainThreadChat.js';
+import './mainThreadTask.js';
+import './mainThreadLabelService.js';
+import './mainThreadTunnelService.js';
+import './mainThreadAuthentication.js';
+import './mainThreadTimeline.js';
+import './mainThreadTesting.js';
+import './mainThreadSecretState.js';
+import './mainThreadShare.js';
+import './mainThreadProfileContentHandlers.js';
+import './mainThreadAiRelatedInformation.js';
+import './mainThreadAiEmbeddingVector.js';
+import './mainThreadIssueReporter.js';
+(class ExtensionPoints {
+    static { this.ID = 'workbench.contrib.extensionPoints'; }
+    constructor(instantiationService) {
+        this.instantiationService = instantiationService;
+        this.instantiationService.createInstance(JSONValidationExtensionPoint);
+        this.instantiationService.createInstance(ColorExtensionPoint);
+        this.instantiationService.createInstance(IconExtensionPoint);
+        this.instantiationService.createInstance(TokenClassificationExtensionPoints);
+        this.instantiationService.createInstance(LanguageConfigurationFileHandler);
+        this.instantiationService.createInstance(StatusBarItemsExtensionPoint);
+    }
+});

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

@@ -0,0 +1,29 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, DisposableMap } from '../../../base/common/lifecycle.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { IAiEmbeddingVectorService } from '../../services/aiEmbeddingVector/common/aiEmbeddingVectorService.js';
+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

@@ -0,0 +1,33 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from '../../../base/common/cancellation.js';
+import { Disposable, DisposableMap } from '../../../base/common/lifecycle.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { IAiRelatedInformationService } from '../../services/aiRelatedInformation/common/aiRelatedInformation.js';
+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

@@ -0,0 +1,252 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, DisposableMap } from '../../../base/common/lifecycle.js';
+import { localizeWithPath } from '../../../nls.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { IAuthenticationService, IAuthenticationExtensionsService } from '../../services/authentication/common/authentication.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import Severity$1 from '../../../base/common/severity.js';
+import { INotificationService } from '../../../platform/notification/common/notification.js';
+import { IExtensionService } from '../../services/extensions/common/extensions.js';
+import { ITelemetryService } from '../../../platform/telemetry/common/telemetry.js';
+import { Emitter } from '../../../base/common/event.js';
+import { IAuthenticationAccessService } from '../../services/authentication/browser/authenticationAccessService.js';
+import { IAuthenticationUsageService } from '../../services/authentication/browser/authenticationUsageService.js';
+import { getAuthenticationProviderActivationEvent } from '../../services/authentication/browser/authenticationService.js';
+import { URI } from '../../../base/common/uri.js';
+import { IOpenerService } from '../../../platform/opener/common/opener.js';
+import { IDialogService } from '../../../platform/dialogs/common/dialogs.js';
+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, authenticationExtensionsService, authenticationAccessService, authenticationUsageService, dialogService, notificationService, extensionService, telemetryService, openerService) {
+        super();
+        this.authenticationService = authenticationService;
+        this.authenticationExtensionsService = authenticationExtensionsService;
+        this.authenticationAccessService = authenticationAccessService;
+        this.authenticationUsageService = authenticationUsageService;
+        this.dialogService = dialogService;
+        this.notificationService = notificationService;
+        this.extensionService = extensionService;
+        this.telemetryService = telemetryService;
+        this.openerService = openerService;
+        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, options) {
+        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 buttons = [
+            {
+                label: ( localizeWithPath(
+                    'vs/workbench/api/browser/mainThreadAuthentication',
+                    { key: 'allow', comment: ['&& denotes a mnemonic'] },
+                    "&&Allow"
+                )),
+                run() {
+                    return true;
+                },
+            }
+        ];
+        if (options?.learnMore) {
+            buttons.push({
+                label: ( localizeWithPath(
+                    'vs/workbench/api/browser/mainThreadAuthentication',
+                    'learnMore',
+                    "Learn more"
+                )),
+                run: async () => {
+                    const result = this.loginPrompt(providerName, extensionName, recreatingSession, options);
+                    await this.openerService.open(URI.revive(options.learnMore), { allowCommands: true });
+                    return await result;
+                }
+            });
+        }
+        const { result } = await this.dialogService.prompt({
+            type: Severity$1.Info,
+            message,
+            buttons,
+            detail: options?.detail,
+            cancelButton: true,
+        });
+        return result ?? false;
+    }
+    async doGetSession(providerId, scopes, extensionId, extensionName, options) {
+        const sessions = await this.authenticationService.getSessions(providerId, scopes, true);
+        const provider = this.authenticationService.getProvider(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 (provider.supportsMultipleAccounts) {
+                if (options.clearSessionPreference) {
+                    this.authenticationExtensionsService.removeSessionPreference(providerId, extensionId, scopes);
+                }
+                else {
+                    const existingSessionPreference = this.authenticationExtensionsService.getSessionPreference(providerId, extensionId, scopes);
+                    if (existingSessionPreference) {
+                        const matchingSession = sessions.find(session => session.id === existingSessionPreference);
+                        if (matchingSession && this.authenticationAccessService.isAccessAllowed(providerId, matchingSession.account.label, extensionId)) {
+                            return matchingSession;
+                        }
+                    }
+                }
+            }
+            else if (this.authenticationAccessService.isAccessAllowed(providerId, sessions[0].account.label, extensionId)) {
+                return sessions[0];
+            }
+        }
+        if (options.createIfNone || options.forceNewSession) {
+            let uiOptions;
+            if (typeof options.forceNewSession === 'object') {
+                uiOptions = options.forceNewSession;
+            }
+            const recreatingSession = !!(options.forceNewSession && sessions.length);
+            const isAllowed = await this.loginPrompt(provider.label, extensionName, recreatingSession, uiOptions);
+            if (!isAllowed) {
+                throw new Error('User did not consent to login.');
+            }
+            let session;
+            if (sessions?.length && !options.forceNewSession) {
+                session = provider.supportsMultipleAccounts
+                    ? await this.authenticationExtensionsService.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.authenticationExtensionsService.getSessionPreference(providerId, extensionId, scopes);
+                    sessionToRecreate = sessionIdToRecreate ? sessions.find(session => session.id === sessionIdToRecreate) : undefined;
+                }
+                session = await this.authenticationService.createSession(providerId, scopes, { activateImmediate: true, sessionToRecreate });
+            }
+            this.authenticationAccessService.updateAllowedExtensions(providerId, session.account.label, [{ id: extensionId, name: extensionName, allowed: true }]);
+            this.authenticationExtensionsService.updateSessionPreference(providerId, extensionId, session);
+            return session;
+        }
+        const validSession = sessions.find(session => this.authenticationAccessService.isAccessAllowed(providerId, session.account.label, extensionId));
+        if (validSession) {
+            return validSession;
+        }
+        if (!options.silent) {
+            sessions.length
+                ? this.authenticationExtensionsService.requestSessionAccess(providerId, extensionId, extensionName, scopes, sessions)
+                : await this.authenticationExtensionsService.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);
+            this.authenticationUsageService.addAccountUsage(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.authenticationAccessService.isAccessAllowed(providerId, s.account.label, extensionId));
+        if (accessibleSessions.length) {
+            this.sendProviderUsageTelemetry(extensionId, providerId);
+            for (const session of accessibleSessions) {
+                this.authenticationUsageService.addAccountUsage(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, IAuthenticationExtensionsService)),
+    ( __param(3, IAuthenticationAccessService)),
+    ( __param(4, IAuthenticationUsageService)),
+    ( __param(5, IDialogService)),
+    ( __param(6, INotificationService)),
+    ( __param(7, IExtensionService)),
+    ( __param(8, ITelemetryService)),
+    ( __param(9, IOpenerService))
+], MainThreadAuthentication);
+export { MainThreadAuthentication, MainThreadAuthenticationProvider };

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

@@ -0,0 +1,66 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { decodeBase64 } from '../../../base/common/buffer.js';
+import { revive } from '../../../base/common/marshalling.js';
+import { IBulkEditService, ResourceTextEdit, ResourceFileEdit } from '../../../editor/browser/services/bulkEditService.js';
+import { ILogService } from '../../../platform/log/common/log.js';
+import { IUriIdentityService } from '../../../platform/uriIdentity/common/uriIdentity.js';
+import { MainContext } from '../common/extHost.protocol.js';
+import { ResourceNotebookCellEdit } from '../../contrib/bulkEdit/browser/bulkCellEdits.js';
+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

@@ -0,0 +1,102 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Schemas } from '../../../base/common/network.js';
+import { isWeb } from '../../../base/common/platform.js';
+import { isString } from '../../../base/common/types.js';
+import { URI } from '../../../base/common/uri.js';
+import { localizeWithPath } from '../../../nls.js';
+import { CommandsRegistry, ICommandService } from '../../../platform/commands/common/commands.js';
+import { IExtensionManagementService, IExtensionGalleryService } from '../../../platform/extensionManagement/common/extensionManagement.js';
+import { ExtensionManagementCLI } from '../../../platform/extensionManagement/common/extensionManagementCLI.js';
+import { getExtensionId } from '../../../platform/extensionManagement/common/extensionManagementUtil.js';
+import { IInstantiationService } from '../../../platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from '../../../platform/instantiation/common/serviceCollection.js';
+import { ILabelService } from '../../../platform/label/common/label.js';
+import { AbstractMessageLogger } from '../../../platform/log/common/log.js';
+import { IOpenerService } from '../../../platform/opener/common/opener.js';
+import { IWorkbenchEnvironmentService } from '../../services/environment/common/environmentService.js';
+import { IExtensionManagementServerService } from '../../services/extensionManagement/common/extensionManagement.js';
+import { IExtensionManifestPropertiesService } from '../../services/extensions/common/extensionManifestPropertiesService.js';
+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

@@ -0,0 +1,68 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable, DisposableMap } from '../../../base/common/lifecycle.js';
+import { URI } from '../../../base/common/uri.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { IChatWidgetService } from '../../contrib/chat/browser/chat.js';
+import { IChatContributionService } from '../../contrib/chat/common/chatContributionService.js';
+import { IChatService } from '../../contrib/chat/common/chatService.js';
+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 emitter = ( new Emitter());
+                this._stateEmitters.set(session.id, emitter);
+                return {
+                    id: session.id,
+                    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 $unregisterChatProvider(handle) {
+        this._providerRegistrations.deleteAndDispose(handle);
+    }
+};
+MainThreadChat = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadChat),
+    ( __param(1, IChatService)),
+    ( __param(2, IChatWidgetService)),
+    ( __param(3, IChatContributionService))
+], MainThreadChat);
+export { MainThreadChat };