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

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

@@ -0,0 +1,103 @@
+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

@@ -0,0 +1,70 @@
+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 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 };

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

@@ -0,0 +1,207 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
+import { revive } from 'vscode/vscode/vs/base/common/marshalling';
+import { escapeRegExpCharacters } from 'vscode/vscode/vs/base/common/strings';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { getWordAtText } from 'vscode/vscode/vs/editor/common/core/wordHelper';
+import { ILanguageFeaturesService } from 'vscode/vscode/vs/editor/common/services/languageFeatures';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
+import { ChatInputPart } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatInputPart';
+import { AddDynamicVariableAction } from 'vscode/vscode/vs/workbench/contrib/chat/browser/contrib/chatDynamicVariables';
+import { IChatAgentService, ChatAgentLocation } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
+import { ChatRequestAgentPart } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+import { ChatRequestParser } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatRequestParser';
+import { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
+    constructor(extHostContext, _chatAgentService, _chatService, _languageFeaturesService, _chatWidgetService, _instantiationService) {
+        super();
+        this._chatAgentService = _chatAgentService;
+        this._chatService = _chatService;
+        this._languageFeaturesService = _languageFeaturesService;
+        this._chatWidgetService = _chatWidgetService;
+        this._instantiationService = _instantiationService;
+        this._agents = this._register(( new DisposableMap()));
+        this._agentCompletionProviders = this._register(( new DisposableMap()));
+        this._pendingProgress = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatAgents2));
+        this._register(this._chatService.onDidDisposeSession(e => {
+            this._proxy.$releaseSession(e.sessionId);
+        }));
+        this._register(this._chatService.onDidPerformUserAction(e => {
+            if (typeof e.agentId === 'string') {
+                for (const [handle, agent] of this._agents) {
+                    if (agent.id === e.agentId) {
+                        if (e.action.kind === 'vote') {
+                            this._proxy.$acceptFeedback(handle, e.result ?? {}, e.action.direction);
+                        }
+                        else {
+                            this._proxy.$acceptAction(handle, e.result || {}, e);
+                        }
+                        break;
+                    }
+                }
+            }
+        }));
+    }
+    $unregisterAgent(handle) {
+        this._agents.deleteAndDispose(handle);
+    }
+    $registerAgent(handle, extension, id, metadata, dynamicProps) {
+        const staticAgentRegistration = this._chatAgentService.getAgent(id);
+        if (!staticAgentRegistration && !dynamicProps) {
+            if (this._chatAgentService.getAgentsByName(id).length) {
+                throw new Error(`chatParticipant must be declared with an ID in package.json. The "id" property may be missing! "${id}"`);
+            }
+            throw new Error(`chatParticipant must be declared in package.json: ${id}`);
+        }
+        const impl = {
+            invoke: async (request, progress, history, token) => {
+                this._pendingProgress.set(request.requestId, progress);
+                try {
+                    return (await this._proxy.$invokeAgent(handle, request, { history }, token)) ?? {};
+                }
+                finally {
+                    this._pendingProgress.delete(request.requestId);
+                }
+            },
+            provideFollowups: async (request, result, history, token) => {
+                if (!this._agents.get(handle)?.hasFollowups) {
+                    return [];
+                }
+                return this._proxy.$provideFollowups(request, handle, result, { history }, token);
+            },
+            provideWelcomeMessage: (token) => {
+                return this._proxy.$provideWelcomeMessage(handle, token);
+            },
+            provideSampleQuestions: (token) => {
+                return this._proxy.$provideSampleQuestions(handle, token);
+            }
+        };
+        let disposable;
+        if (!staticAgentRegistration && dynamicProps) {
+            disposable = this._chatAgentService.registerDynamicAgent({
+                id,
+                name: dynamicProps.name,
+                description: dynamicProps.description,
+                extensionId: extension,
+                metadata: revive(metadata),
+                slashCommands: [],
+                locations: [ChatAgentLocation.Panel]
+            }, impl);
+        }
+        else {
+            disposable = this._chatAgentService.registerAgentImplementation(id, impl);
+        }
+        this._agents.set(handle, {
+            id: id,
+            extensionId: extension,
+            dispose: disposable.dispose,
+            hasFollowups: metadata.hasFollowups
+        });
+    }
+    $updateAgent(handle, metadataUpdate) {
+        const data = this._agents.get(handle);
+        if (!data) {
+            throw new Error(`No agent with handle ${handle} registered`);
+        }
+        data.hasFollowups = metadataUpdate.hasFollowups;
+        this._chatAgentService.updateAgent(data.id, revive(metadataUpdate));
+    }
+    async $handleProgressChunk(requestId, progress) {
+        const revivedProgress = revive(progress);
+        this._pendingProgress.get(requestId)?.(revivedProgress);
+    }
+    $registerAgentCompletionsProvider(handle, triggerCharacters) {
+        this._agentCompletionProviders.set(handle, this._languageFeaturesService.completionProvider.register({ scheme: ChatInputPart.INPUT_SCHEME, hasAccessToAllModels: true }, {
+            _debugDisplayName: 'chatAgentCompletions:' + handle,
+            triggerCharacters,
+            provideCompletionItems: async (model, position, _context, token) => {
+                const widget = this._chatWidgetService.getWidgetByInputUri(model.uri);
+                if (!widget || !widget.viewModel) {
+                    return;
+                }
+                const triggerCharsPart = ( triggerCharacters.map(c => escapeRegExpCharacters(c))).join('');
+                const wordRegex = ( new RegExp(`[${triggerCharsPart}]\\S*`, 'g'));
+                const query = getWordAtText(position.column, wordRegex, model.getLineContent(position.lineNumber), 0)?.word ?? '';
+                if (query && !( triggerCharacters.some(c => query.startsWith(c)))) {
+                    return;
+                }
+                const parsedRequest = this._instantiationService.createInstance(ChatRequestParser).parseChatRequest(widget.viewModel.sessionId, model.getValue()).parts;
+                const agentPart = parsedRequest.find((part) => part instanceof ChatRequestAgentPart);
+                const thisAgentId = this._agents.get(handle)?.id;
+                if (agentPart?.agent.id !== thisAgentId) {
+                    return;
+                }
+                const range = computeCompletionRanges(model, position, wordRegex);
+                if (!range) {
+                    return null;
+                }
+                const result = await this._proxy.$invokeCompletionProvider(handle, query, token);
+                const variableItems = ( result.map(v => {
+                    const insertText = v.insertText ?? (typeof v.label === 'string' ? v.label : v.label.label);
+                    const rangeAfterInsert = ( new Range(
+                        range.insert.startLineNumber,
+                        range.insert.startColumn,
+                        range.insert.endLineNumber,
+                        range.insert.startColumn + insertText.length
+                    ));
+                    return {
+                        label: v.label,
+                        range,
+                        insertText: insertText + ' ',
+                        kind: 18 ,
+                        detail: v.detail,
+                        documentation: v.documentation,
+                        command: { id: AddDynamicVariableAction.ID, title: '', arguments: [{ widget, range: rangeAfterInsert, variableData: revive(v.values) }] }
+                    };
+                }));
+                return {
+                    suggestions: variableItems
+                };
+            }
+        }));
+    }
+    $unregisterAgentCompletionsProvider(handle) {
+        this._agentCompletionProviders.deleteAndDispose(handle);
+    }
+};
+MainThreadChatAgents2 = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadChatAgents2),
+    ( __param(1, IChatAgentService)),
+    ( __param(2, IChatService)),
+    ( __param(3, ILanguageFeaturesService)),
+    ( __param(4, IChatWidgetService)),
+    ( __param(5, IInstantiationService))
+], MainThreadChatAgents2);
+function computeCompletionRanges(model, position, reg) {
+    const varWord = getWordAtText(position.column, reg, model.getLineContent(position.lineNumber), 0);
+    if (!varWord && model.getWordUntilPosition(position).word) {
+        return;
+    }
+    let insert;
+    let replace;
+    if (!varWord) {
+        insert = replace = Range.fromPositions(position);
+    }
+    else {
+        insert = ( new Range(
+            position.lineNumber,
+            varWord.startColumn,
+            position.lineNumber,
+            position.column
+        ));
+        replace = ( new Range(
+            position.lineNumber,
+            varWord.startColumn,
+            position.lineNumber,
+            varWord.endColumn
+        ));
+    }
+    return { insert, replace };
+}
+
+export { MainThreadChatAgents2 };

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

@@ -0,0 +1,41 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
+import { revive } from 'vscode/vscode/vs/base/common/marshalling';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IChatVariablesService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatVariables';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadChatVariables = class MainThreadChatVariables {
+    constructor(extHostContext, _chatVariablesService) {
+        this._chatVariablesService = _chatVariablesService;
+        this._variables = ( new DisposableMap());
+        this._pendingProgress = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatVariables));
+    }
+    dispose() {
+        this._variables.clearAndDisposeAll();
+    }
+    $registerVariable(handle, data) {
+        const registration = this._chatVariablesService.registerVariable(data, async (messageText, _arg, model, progress, token) => {
+            const varRequestId = `${model.sessionId}-${handle}`;
+            this._pendingProgress.set(varRequestId, progress);
+            const result = revive(await this._proxy.$resolveVariable(handle, varRequestId, messageText, token));
+            this._pendingProgress.delete(varRequestId);
+            return result;
+        });
+        this._variables.set(handle, registration);
+    }
+    async $handleProgressChunk(requestId, progress) {
+        const revivedProgress = revive(progress);
+        this._pendingProgress.get(requestId)?.(revivedProgress);
+    }
+    $unregisterVariable(handle) {
+        this._variables.deleteAndDispose(handle);
+    }
+};
+MainThreadChatVariables = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadChatVariables),
+    ( __param(1, IChatVariablesService))
+], MainThreadChatVariables);
+
+export { MainThreadChatVariables };

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

@@ -0,0 +1,24 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IClipboardService } from 'vscode/vscode/vs/platform/clipboard/common/clipboardService';
+
+let MainThreadClipboard = class MainThreadClipboard {
+    constructor(_context, _clipboardService) {
+        this._clipboardService = _clipboardService;
+    }
+    dispose() {
+    }
+    $readText() {
+        return this._clipboardService.readText();
+    }
+    $writeText(value) {
+        return this._clipboardService.writeText(value);
+    }
+};
+MainThreadClipboard = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadClipboard),
+    ( __param(1, IClipboardService))
+], MainThreadClipboard);
+
+export { MainThreadClipboard };

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

@@ -0,0 +1,108 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { getWindow } from 'vscode/vscode/vs/base/browser/dom';
+import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { isEqual } from 'vscode/vscode/vs/base/common/resources';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
+import { reviveWebviewContentOptions } from './mainThreadWebviews.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IWebviewService } from 'vscode/vscode/vs/workbench/contrib/webview/browser/webview';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+class EditorWebviewZone {
+    constructor(editor, line, height, webview) {
+        this.editor = editor;
+        this.line = line;
+        this.height = height;
+        this.webview = webview;
+        this.domNode = document.createElement('div');
+        this.domNode.style.zIndex = '10';
+        this.afterLineNumber = line;
+        this.afterColumn = 1;
+        this.heightInLines = height;
+        editor.changeViewZones(accessor => this._id = accessor.addZone(this));
+        webview.mountTo(this.domNode, getWindow(editor.getDomNode()));
+    }
+    dispose() {
+        this.editor.changeViewZones(accessor => this._id && accessor.removeZone(this._id));
+    }
+}
+let MainThreadEditorInsets = class MainThreadEditorInsets {
+    constructor(context, _editorService, _webviewService) {
+        this._editorService = _editorService;
+        this._webviewService = _webviewService;
+        this._disposables = ( new DisposableStore());
+        this._insets = ( new Map());
+        this._proxy = ( context.getProxy(ExtHostContext.ExtHostEditorInsets));
+    }
+    dispose() {
+        this._disposables.dispose();
+    }
+    async $createEditorInset(handle, id, uri, line, height, options, extensionId, extensionLocation) {
+        let editor;
+        id = id.substr(0, id.indexOf(','));
+        for (const candidate of this._editorService.listCodeEditors()) {
+            if (candidate.getId() === id && candidate.hasModel() && isEqual(candidate.getModel().uri, URI.revive(uri))) {
+                editor = candidate;
+                break;
+            }
+        }
+        if (!editor) {
+            setTimeout(() => this._proxy.$onDidDispose(handle));
+            return;
+        }
+        const disposables = ( new DisposableStore());
+        const webview = this._webviewService.createWebviewElement({
+            title: undefined,
+            options: {
+                enableFindWidget: false,
+            },
+            contentOptions: reviveWebviewContentOptions(options),
+            extension: { id: extensionId, location: URI.revive(extensionLocation) }
+        });
+        const webviewZone = ( new EditorWebviewZone(editor, line, height, webview));
+        const remove = () => {
+            disposables.dispose();
+            this._proxy.$onDidDispose(handle);
+            this._insets.delete(handle);
+        };
+        disposables.add(editor.onDidChangeModel(remove));
+        disposables.add(editor.onDidDispose(remove));
+        disposables.add(webviewZone);
+        disposables.add(webview);
+        disposables.add(webview.onMessage(msg => this._proxy.$onDidReceiveMessage(handle, msg.message)));
+        this._insets.set(handle, webviewZone);
+    }
+    $disposeEditorInset(handle) {
+        const inset = this.getInset(handle);
+        this._insets.delete(handle);
+        inset.dispose();
+    }
+    $setHtml(handle, value) {
+        const inset = this.getInset(handle);
+        inset.webview.setHtml(value);
+    }
+    $setOptions(handle, options) {
+        const inset = this.getInset(handle);
+        inset.webview.contentOptions = reviveWebviewContentOptions(options);
+    }
+    async $postMessage(handle, value) {
+        const inset = this.getInset(handle);
+        inset.webview.postMessage(value);
+        return true;
+    }
+    getInset(handle) {
+        const inset = this._insets.get(handle);
+        if (!inset) {
+            throw new Error('Unknown inset');
+        }
+        return inset;
+    }
+};
+MainThreadEditorInsets = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadEditorInsets),
+    ( __param(1, ICodeEditorService)),
+    ( __param(2, IWebviewService))
+], MainThreadEditorInsets);
+
+export { MainThreadEditorInsets };

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

@@ -0,0 +1,98 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
+import { revive } from 'vscode/vscode/vs/base/common/marshalling';
+import { ICommandService, CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { SerializableObjectWithBuffers } from 'vscode/vscode/vs/workbench/services/extensions/common/proxyIdentifier';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { isString } from 'vscode/vscode/vs/base/common/types';
+
+let MainThreadCommands = class MainThreadCommands {
+    constructor(extHostContext, _commandService, _extensionService) {
+        this._commandService = _commandService;
+        this._extensionService = _extensionService;
+        this._commandRegistrations = ( new DisposableMap());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostCommands));
+        this._generateCommandsDocumentationRegistration = CommandsRegistry.registerCommand('_generateCommandsDocumentation', () => this._generateCommandsDocumentation());
+    }
+    dispose() {
+        this._commandRegistrations.dispose();
+        this._generateCommandsDocumentationRegistration.dispose();
+    }
+    async _generateCommandsDocumentation() {
+        const result = await this._proxy.$getContributedCommandMetadata();
+        const commands = CommandsRegistry.getCommands();
+        for (const [id, command] of commands) {
+            if (command.metadata) {
+                result[id] = command.metadata;
+            }
+        }
+        const all = [];
+        for (const id in result) {
+            all.push('`' + id + '` - ' + _generateMarkdown(result[id]));
+        }
+        console.log(all.join('\n'));
+    }
+    $registerCommand(id) {
+        this._commandRegistrations.set(id, CommandsRegistry.registerCommand(id, (accessor, ...args) => {
+            return this._proxy.$executeContributedCommand(id, ...args).then(result => {
+                return revive(result);
+            });
+        }));
+    }
+    $unregisterCommand(id) {
+        this._commandRegistrations.deleteAndDispose(id);
+    }
+    $fireCommandActivationEvent(id) {
+        const activationEvent = `onCommand:${id}`;
+        if (!this._extensionService.activationEventIsDone(activationEvent)) {
+            this._extensionService.activateByEvent(activationEvent);
+        }
+    }
+    async $executeCommand(id, args, retry) {
+        if (args instanceof SerializableObjectWithBuffers) {
+            args = args.value;
+        }
+        for (let i = 0; i < args.length; i++) {
+            args[i] = revive(args[i]);
+        }
+        if (retry && args.length > 0 && !CommandsRegistry.getCommand(id)) {
+            await this._extensionService.activateByEvent(`onCommand:${id}`);
+            throw new Error('$executeCommand:retry');
+        }
+        return this._commandService.executeCommand(id, ...args);
+    }
+    $getCommands() {
+        return Promise.resolve([...( CommandsRegistry.getCommands().keys())]);
+    }
+};
+MainThreadCommands = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadCommands),
+    ( __param(1, ICommandService)),
+    ( __param(2, IExtensionService))
+], MainThreadCommands);
+function _generateMarkdown(description) {
+    if (typeof description === 'string') {
+        return description;
+    }
+    else {
+        const descriptionString = isString(description.description)
+            ? description.description
+            : description.description.original;
+        const parts = [descriptionString];
+        parts.push('\n\n');
+        if (description.args) {
+            for (const arg of description.args) {
+                parts.push(`* _${arg.name}_ - ${arg.description || ''}\n`);
+            }
+        }
+        if (description.returns) {
+            parts.push(`* _(returns)_ - ${description.returns}`);
+        }
+        parts.push('\n\n');
+        return parts.join('');
+    }
+}
+
+export { MainThreadCommands };