@codingame/monaco-vscode-mcp-service-override 17.2.0 → 18.0.0

package/vscode/src/vs/workbench/contrib/mcp/browser/mcpServerActions.js

@@ -0,0 +1,423 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { ActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { Action, Separator } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { disposeIfDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { manageExtensionIcon } from '@codingame/monaco-vscode-93784a59-b4cf-520c-8339-f8104d3a4f3e-common/vscode/vs/workbench/contrib/extensions/browser/extensionsIcons';
+import { getDomNodePagePosition } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { McpConnectionState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { IMcpWorkbenchService, IMcpService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
+import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+
+var InstallAction_1, UninstallAction_1, ManageMcpServerAction_1, StartServerAction_1, StopServerAction_1, RestartServerAction_1, ShowServerOutputAction_1, ShowServerConfigurationAction_1;
+class McpServerAction extends Action {
+    constructor() {
+        super(...arguments);
+        this._mcpServer = null;
+    }
+    static { this.EXTENSION_ACTION_CLASS = 'extension-action'; }
+    static { this.TEXT_ACTION_CLASS = `${McpServerAction.EXTENSION_ACTION_CLASS} text`; }
+    static { this.LABEL_ACTION_CLASS = `${McpServerAction.EXTENSION_ACTION_CLASS} label`; }
+    static { this.PROMINENT_LABEL_ACTION_CLASS = `${McpServerAction.LABEL_ACTION_CLASS} prominent`; }
+    static { this.ICON_ACTION_CLASS = `${McpServerAction.EXTENSION_ACTION_CLASS} icon`; }
+    get mcpServer() { return this._mcpServer; }
+    set mcpServer(mcpServer) { this._mcpServer = mcpServer; this.update(); }
+}
+let DropDownAction = class DropDownAction extends McpServerAction {
+    constructor(id, label, cssClass, enabled, instantiationService) {
+        super(id, label, cssClass, enabled);
+        this.instantiationService = instantiationService;
+        this._actionViewItem = null;
+    }
+    createActionViewItem(options) {
+        this._actionViewItem = this.instantiationService.createInstance(DropDownExtensionActionViewItem, this, options);
+        return this._actionViewItem;
+    }
+    run(actionGroups) {
+        this._actionViewItem?.showMenu(actionGroups);
+        return Promise.resolve();
+    }
+};
+DropDownAction = ( __decorate([
+    ( __param(4, IInstantiationService))
+], DropDownAction));
+let DropDownExtensionActionViewItem = class DropDownExtensionActionViewItem extends ActionViewItem {
+    constructor(action, options, contextMenuService) {
+        super(null, action, { ...options, icon: true, label: true });
+        this.contextMenuService = contextMenuService;
+    }
+    showMenu(menuActionGroups) {
+        if (this.element) {
+            const actions = this.getActions(menuActionGroups);
+            const elementPosition = getDomNodePagePosition(this.element);
+            const anchor = { x: elementPosition.left, y: elementPosition.top + elementPosition.height + 10 };
+            this.contextMenuService.showContextMenu({
+                getAnchor: () => anchor,
+                getActions: () => actions,
+                actionRunner: this.actionRunner,
+                onHide: () => disposeIfDisposable(actions)
+            });
+        }
+    }
+    getActions(menuActionGroups) {
+        let actions = [];
+        for (const menuActions of menuActionGroups) {
+            actions = [...actions, ...menuActions, ( new Separator())];
+        }
+        return actions.length ? actions.slice(0, actions.length - 1) : actions;
+    }
+};
+DropDownExtensionActionViewItem = ( __decorate([
+    ( __param(2, IContextMenuService))
+], DropDownExtensionActionViewItem));
+let InstallAction = class InstallAction extends McpServerAction {
+    static { InstallAction_1 = this; }
+    static { this.CLASS = `${this.LABEL_ACTION_CLASS} prominent install`; }
+    static { this.HIDE = `${this.CLASS} hide`; }
+    constructor(mcpWorkbenchService) {
+        super('extensions.install', ( localize(7891, "Install")), InstallAction_1.CLASS, false);
+        this.mcpWorkbenchService = mcpWorkbenchService;
+        this.update();
+    }
+    update() {
+        this.enabled = false;
+        this.class = InstallAction_1.HIDE;
+        if (!this.mcpServer?.gallery) {
+            return;
+        }
+        if (this.mcpServer.local) {
+            return;
+        }
+        this.class = InstallAction_1.CLASS;
+        this.enabled = true;
+        this.label = ( localize(7891, "Install"));
+    }
+    async run() {
+        if (!this.mcpServer) {
+            return;
+        }
+        await this.mcpWorkbenchService.install(this.mcpServer);
+    }
+};
+InstallAction = InstallAction_1 = ( __decorate([
+    ( __param(0, IMcpWorkbenchService))
+], InstallAction));
+let UninstallAction = class UninstallAction extends McpServerAction {
+    static { UninstallAction_1 = this; }
+    static { this.CLASS = `${this.LABEL_ACTION_CLASS} prominent uninstall`; }
+    static { this.HIDE = `${this.CLASS} hide`; }
+    constructor(mcpWorkbenchService) {
+        super('extensions.uninstall', ( localize(7892, "Uninstall")), UninstallAction_1.CLASS, false);
+        this.mcpWorkbenchService = mcpWorkbenchService;
+        this.update();
+    }
+    update() {
+        this.enabled = false;
+        this.class = UninstallAction_1.HIDE;
+        if (!this.mcpServer) {
+            return;
+        }
+        if (!this.mcpServer.local) {
+            return;
+        }
+        this.class = UninstallAction_1.CLASS;
+        this.enabled = true;
+        this.label = ( localize(7892, "Uninstall"));
+    }
+    async run() {
+        if (!this.mcpServer) {
+            return;
+        }
+        await this.mcpWorkbenchService.uninstall(this.mcpServer);
+    }
+};
+UninstallAction = UninstallAction_1 = ( __decorate([
+    ( __param(0, IMcpWorkbenchService))
+], UninstallAction));
+let ManageMcpServerAction = class ManageMcpServerAction extends DropDownAction {
+    static { ManageMcpServerAction_1 = this; }
+    static { this.ID = 'mcpServer.manage'; }
+    static { this.Class = `${McpServerAction.ICON_ACTION_CLASS} manage ` + ThemeIcon.asClassName(manageExtensionIcon); }
+    static { this.HideManageExtensionClass = `${this.Class} hide`; }
+    constructor(isEditorAction, instantiationService) {
+        super(ManageMcpServerAction_1.ID, '', '', true, instantiationService);
+        this.isEditorAction = isEditorAction;
+        this.tooltip = ( localize(7893, "Manage"));
+        this.update();
+    }
+    async getActionGroups() {
+        const groups = [];
+        groups.push([
+            this.instantiationService.createInstance(StartServerAction),
+        ]);
+        groups.push([
+            this.instantiationService.createInstance(StopServerAction),
+            this.instantiationService.createInstance(RestartServerAction),
+        ]);
+        groups.push([
+            this.instantiationService.createInstance(ShowServerOutputAction),
+            this.instantiationService.createInstance(ShowServerConfigurationAction),
+        ]);
+        if (!this.isEditorAction) {
+            groups.push([
+                this.instantiationService.createInstance(UninstallAction),
+            ]);
+        }
+        groups.forEach(group => group.forEach(extensionAction => {
+            if (extensionAction instanceof McpServerAction) {
+                extensionAction.mcpServer = this.mcpServer;
+            }
+        }));
+        return groups;
+    }
+    async run() {
+        return super.run(await this.getActionGroups());
+    }
+    update() {
+        this.class = ManageMcpServerAction_1.HideManageExtensionClass;
+        this.enabled = false;
+        if (this.mcpServer) {
+            this.enabled = !!this.mcpServer.local;
+            this.class = this.enabled ? ManageMcpServerAction_1.Class : ManageMcpServerAction_1.HideManageExtensionClass;
+        }
+    }
+};
+ManageMcpServerAction = ManageMcpServerAction_1 = ( __decorate([
+    ( __param(1, IInstantiationService))
+], ManageMcpServerAction));
+let StartServerAction = class StartServerAction extends McpServerAction {
+    static { StartServerAction_1 = this; }
+    static { this.CLASS = `${this.LABEL_ACTION_CLASS} prominent start`; }
+    static { this.HIDE = `${this.CLASS} hide`; }
+    constructor(mcpService) {
+        super('extensions.start', ( localize(7894, "Start Server")), StartServerAction_1.CLASS, false);
+        this.mcpService = mcpService;
+        this.update();
+    }
+    update() {
+        this.enabled = false;
+        this.class = StartServerAction_1.HIDE;
+        const server = this.getServer();
+        if (!server) {
+            return;
+        }
+        const serverState = server.connectionState.get();
+        if (!McpConnectionState.canBeStarted(serverState.state)) {
+            return;
+        }
+        this.class = StartServerAction_1.CLASS;
+        this.enabled = true;
+        this.label = ( localize(7894, "Start Server"));
+    }
+    async run() {
+        const server = this.getServer();
+        if (!server) {
+            return;
+        }
+        await server.start({ isFromInteraction: true });
+        server.showOutput();
+    }
+    getServer() {
+        if (!this.mcpServer) {
+            return;
+        }
+        if (!this.mcpServer.local) {
+            return;
+        }
+        return this.mcpService.servers.get().find(s => s.definition.label === this.mcpServer?.name);
+    }
+};
+StartServerAction = StartServerAction_1 = ( __decorate([
+    ( __param(0, IMcpService))
+], StartServerAction));
+let StopServerAction = class StopServerAction extends McpServerAction {
+    static { StopServerAction_1 = this; }
+    static { this.CLASS = `${this.LABEL_ACTION_CLASS} prominent stop`; }
+    static { this.HIDE = `${this.CLASS} hide`; }
+    constructor(mcpService) {
+        super('extensions.stop', ( localize(7895, "Stop Server")), StopServerAction_1.CLASS, false);
+        this.mcpService = mcpService;
+        this.update();
+    }
+    update() {
+        this.enabled = false;
+        this.class = StopServerAction_1.HIDE;
+        const server = this.getServer();
+        if (!server) {
+            return;
+        }
+        const serverState = server.connectionState.get();
+        if (McpConnectionState.canBeStarted(serverState.state)) {
+            return;
+        }
+        this.class = StopServerAction_1.CLASS;
+        this.enabled = true;
+        this.label = ( localize(7895, "Stop Server"));
+    }
+    async run() {
+        const server = this.getServer();
+        if (!server) {
+            return;
+        }
+        await server.stop();
+    }
+    getServer() {
+        if (!this.mcpServer) {
+            return;
+        }
+        if (!this.mcpServer.local) {
+            return;
+        }
+        return this.mcpService.servers.get().find(s => s.definition.label === this.mcpServer?.name);
+    }
+};
+StopServerAction = StopServerAction_1 = ( __decorate([
+    ( __param(0, IMcpService))
+], StopServerAction));
+let RestartServerAction = class RestartServerAction extends McpServerAction {
+    static { RestartServerAction_1 = this; }
+    static { this.CLASS = `${this.LABEL_ACTION_CLASS} prominent restart`; }
+    static { this.HIDE = `${this.CLASS} hide`; }
+    constructor(mcpService) {
+        super('extensions.restart', ( localize(7896, "Restart Server")), RestartServerAction_1.CLASS, false);
+        this.mcpService = mcpService;
+        this.update();
+    }
+    update() {
+        this.enabled = false;
+        this.class = RestartServerAction_1.HIDE;
+        const server = this.getServer();
+        if (!server) {
+            return;
+        }
+        const serverState = server.connectionState.get();
+        if (McpConnectionState.canBeStarted(serverState.state)) {
+            return;
+        }
+        this.class = RestartServerAction_1.CLASS;
+        this.enabled = true;
+        this.label = ( localize(7896, "Restart Server"));
+    }
+    async run() {
+        const server = this.getServer();
+        if (!server) {
+            return;
+        }
+        await server.stop();
+        await server.start({ isFromInteraction: true });
+        server.showOutput();
+    }
+    getServer() {
+        if (!this.mcpServer) {
+            return;
+        }
+        if (!this.mcpServer.local) {
+            return;
+        }
+        return this.mcpService.servers.get().find(s => s.definition.label === this.mcpServer?.name);
+    }
+};
+RestartServerAction = RestartServerAction_1 = ( __decorate([
+    ( __param(0, IMcpService))
+], RestartServerAction));
+let ShowServerOutputAction = class ShowServerOutputAction extends McpServerAction {
+    static { ShowServerOutputAction_1 = this; }
+    static { this.CLASS = `${this.LABEL_ACTION_CLASS} prominent output`; }
+    static { this.HIDE = `${this.CLASS} hide`; }
+    constructor(mcpService) {
+        super('extensions.output', ( localize(7897, "Show Output")), ShowServerOutputAction_1.CLASS, false);
+        this.mcpService = mcpService;
+        this.update();
+    }
+    update() {
+        this.enabled = false;
+        this.class = ShowServerOutputAction_1.HIDE;
+        const server = this.getServer();
+        if (!server) {
+            return;
+        }
+        this.class = ShowServerOutputAction_1.CLASS;
+        this.enabled = true;
+        this.label = ( localize(7897, "Show Output"));
+    }
+    async run() {
+        const server = this.getServer();
+        if (!server) {
+            return;
+        }
+        server.showOutput();
+    }
+    getServer() {
+        if (!this.mcpServer) {
+            return;
+        }
+        if (!this.mcpServer.local) {
+            return;
+        }
+        return this.mcpService.servers.get().find(s => s.definition.label === this.mcpServer?.name);
+    }
+};
+ShowServerOutputAction = ShowServerOutputAction_1 = ( __decorate([
+    ( __param(0, IMcpService))
+], ShowServerOutputAction));
+let ShowServerConfigurationAction = class ShowServerConfigurationAction extends McpServerAction {
+    static { ShowServerConfigurationAction_1 = this; }
+    static { this.CLASS = `${this.LABEL_ACTION_CLASS} prominent config`; }
+    static { this.HIDE = `${this.CLASS} hide`; }
+    constructor(mcpService, mcpRegistry, editorService) {
+        super('extensions.config', ( localize(7898, "Show Configuration")), ShowServerConfigurationAction_1.CLASS, false);
+        this.mcpService = mcpService;
+        this.mcpRegistry = mcpRegistry;
+        this.editorService = editorService;
+        this.update();
+    }
+    update() {
+        this.enabled = false;
+        this.class = ShowServerConfigurationAction_1.HIDE;
+        const configurationTarget = this.getConfigurationTarget();
+        if (!configurationTarget) {
+            return;
+        }
+        this.class = ShowServerConfigurationAction_1.CLASS;
+        this.enabled = true;
+        this.label = ( localize(7898, "Show Configuration"));
+    }
+    async run() {
+        const configurationTarget = this.getConfigurationTarget();
+        if (!configurationTarget) {
+            return;
+        }
+        this.editorService.openEditor({
+            resource: URI.isUri(configurationTarget) ? configurationTarget : configurationTarget.uri,
+            options: { selection: URI.isUri(configurationTarget) ? undefined : configurationTarget.range }
+        });
+    }
+    getConfigurationTarget() {
+        if (!this.mcpServer) {
+            return;
+        }
+        if (!this.mcpServer.local) {
+            return;
+        }
+        const server = this.mcpService.servers.get().find(s => s.definition.label === this.mcpServer?.name);
+        if (!server) {
+            return;
+        }
+        const collection = this.mcpRegistry.collections.get().find(c => c.id === server.collection.id);
+        const serverDefinition = collection?.serverDefinitions.get().find(s => s.id === server.definition.id);
+        return serverDefinition?.presentation?.origin || collection?.presentation?.origin;
+    }
+};
+ShowServerConfigurationAction = ShowServerConfigurationAction_1 = ( __decorate([
+    ( __param(0, IMcpService)),
+    ( __param(1, IMcpRegistry)),
+    ( __param(2, IEditorService))
+], ShowServerConfigurationAction));
+
+export { DropDownAction, DropDownExtensionActionViewItem, InstallAction, ManageMcpServerAction, McpServerAction, RestartServerAction, ShowServerConfigurationAction, ShowServerOutputAction, StartServerAction, StopServerAction, UninstallAction };

package/vscode/src/vs/workbench/contrib/mcp/browser/mcpServerEditor.d.ts

@@ -0,0 +1,61 @@
+import { Dimension } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/dom";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
+import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { EditorPane } from "@codingame/monaco-vscode-dcfc2191-2da1-54c7-8fb7-e92c5d11ecef-common/vscode/vs/workbench/browser/parts/editor/editorPane";
+import { IEditorOpenContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor";
+import { IWebview } from "@codingame/monaco-vscode-4372ad43-a220-5e78-83e6-95a9cfd64384-common/vscode/vs/workbench/contrib/webview/browser/webview";
+import { IWebviewService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/webview/browser/webview.service";
+import { IEditorGroup } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
+import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
+import { McpServerEditorInput } from "./mcpServerEditorInput.js";
+import { IEditorOptions } from "@codingame/monaco-vscode-api/vscode/vs/platform/editor/common/editor";
+export declare class McpServerEditor extends EditorPane {
+    private readonly instantiationService;
+    private readonly notificationService;
+    private readonly openerService;
+    private readonly extensionService;
+    private readonly webviewService;
+    private readonly languageService;
+    private readonly contextKeyService;
+    private readonly hoverService;
+    static readonly ID: string;
+    private readonly _scopedContextKeyService;
+    private template;
+    private mcpServerReadme;
+    private initialScrollProgress;
+    private currentIdentifier;
+    private layoutParticipants;
+    private readonly contentDisposables;
+    private readonly transientDisposables;
+    private activeElement;
+    private dimension;
+    constructor(group: IEditorGroup, telemetryService: ITelemetryService, instantiationService: IInstantiationService, themeService: IThemeService, notificationService: INotificationService, openerService: IOpenerService, storageService: IStorageService, extensionService: IExtensionService, webviewService: IWebviewService, languageService: ILanguageService, contextKeyService: IContextKeyService, hoverService: IHoverService);
+    get scopedContextKeyService(): IContextKeyService | undefined;
+    protected createEditor(parent: HTMLElement): void;
+    setInput(input: McpServerEditorInput, options: IEditorOptions | undefined, context: IEditorOpenContext, token: CancellationToken): Promise<void>;
+    private render;
+    private renderNavbar;
+    clearInput(): void;
+    focus(): void;
+    showFind(): void;
+    runFindAction(previous: boolean): void;
+    get activeWebview(): IWebview | undefined;
+    private onNavbarChange;
+    private open;
+    private openMarkdown;
+    private renderMarkdown;
+    private renderBody;
+    private openDetails;
+    private renderAdditionalDetails;
+    private loadContents;
+    layout(dimension: Dimension): void;
+    private onError;
+}