@codingame/monaco-vscode-mcp-service-override 23.2.2 → 24.1.0

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

@@ -1,5 +1,6 @@
 import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
-import { DisposableStore, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { DisposableStore, IDisposable, Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
@@ -11,28 +12,46 @@ import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench
 import { IViewsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service";
 import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
 import { IChatAttachmentResolveService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatAttachmentResolveService.service";
-import { IChatRequestVariableEntry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatVariableEntries";
 import { IMcpResource, IMcpResourceTemplate, IMcpServer } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
 import { IMcpService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service";
-export declare class McpResourcePickHelper {
+import { ChatContextPickAttachment } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContextPickService";
+export declare class McpResourcePickHelper extends Disposable {
     private readonly _mcpService;
     private readonly _fileService;
     private readonly _quickInputService;
     private readonly _notificationService;
     private readonly _chatAttachmentResolveService;
+    private _resources;
+    private _pickItemsStack;
+    private _inDirectory;
     static sep(server: IMcpServer): IQuickPickSeparator;
+    addCurrentMCPQuickPickItemLevel(server: IMcpServer, resources: (IMcpResource | IMcpResourceTemplate)[]): void;
+    navigateBack(): boolean;
     static item(resource: IMcpResource | IMcpResourceTemplate): IQuickPickItem;
     hasServersWithResources: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").IObservableWithChange<boolean, void>;
     explicitServers?: IMcpServer[];
     constructor(_mcpService: IMcpService, _fileService: IFileService, _quickInputService: IQuickInputService, _notificationService: INotificationService, _chatAttachmentResolveService: IChatAttachmentResolveService);
-    toAttachment(resource: IMcpResource | IMcpResourceTemplate): Promise<IChatRequestVariableEntry | undefined>;
+    /**
+     * Navigate to a resource if it's a directory.
+     * Returns true if the resource is a directory with children (navigation succeeded).
+     * Returns false if the resource is a leaf file (no navigation).
+     * When returning true, statefully updates the picker state to display directory contents.
+     */
+    navigate(resource: IMcpResource | IMcpResourceTemplate, server: IMcpServer): Promise<boolean>;
+    toAttachment(resource: IMcpResource | IMcpResourceTemplate, server: IMcpServer): Promise<ChatContextPickAttachment> | "noop";
+    checkIfDirectoryAndPopulate(resource: IMcpResource | IMcpResourceTemplate, server: IMcpServer): Promise<boolean>;
     toURI(resource: IMcpResource | IMcpResourceTemplate): Promise<URI | undefined>;
+    checkIfNestedResources: () => boolean;
     private _resourceToAttachment;
     private _resourceTemplateToAttachment;
     private _verifyUriIfNeeded;
     private _resourceTemplateToURI;
     private _promptForTemplateValue;
-    getPicks(onChange: (value: Map<IMcpServer, (IMcpResourceTemplate | IMcpResource)[]>) => void, token?: CancellationToken): Promise<void[]>;
+    private _isDirectoryResource;
+    getPicks(token?: CancellationToken): IObservable<{
+        picks: Map<IMcpServer, (IMcpResourceTemplate | IMcpResource)[]>;
+        isBusy: boolean;
+    }>;
 }
 export declare abstract class AbstractMcpResourceAccessPick {
     private readonly _scopeTo;

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

@@ -4,7 +4,7 @@ import { RunOnceScheduler, disposableTimeout, DeferredPromise } from '@codingame
 import { CancellationTokenSource, CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
 import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
@@ -21,11 +21,15 @@ import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workb
 import { IChatAttachmentResolveService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatAttachmentResolveService.service';
 import { isMcpResourceTemplate, McpCapability, McpResourceURI, McpConnectionState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
 import { IMcpService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
+import { McpIcons } from '../common/mcpIcons.js';
 import { openPanelChatAndGetWidget } from './openPanelChatAndGetWidget.js';
-import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { LinkedList } from '@codingame/monaco-vscode-api/vscode/vs/base/common/linkedList';
+import { asArray } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
 
-let McpResourcePickHelper = class McpResourcePickHelper {
+let McpResourcePickHelper = class McpResourcePickHelper extends Disposable {
     static sep(server) {
         return {
             id: server.definition.id,
@@ -33,6 +37,32 @@ let McpResourcePickHelper = class McpResourcePickHelper {
             label: server.definition.label,
         };
     }
+    addCurrentMCPQuickPickItemLevel(server, resources) {
+        let isValidPush = false;
+        isValidPush = this._pickItemsStack.isEmpty();
+        if (!isValidPush) {
+            const stackedItem = this._pickItemsStack.peek();
+            if (stackedItem?.server === server && stackedItem.resources === resources) {
+                isValidPush = false;
+            }
+            else {
+                isValidPush = true;
+            }
+        }
+        if (isValidPush) {
+            this._pickItemsStack.push({ server, resources });
+        }
+    }
+    navigateBack() {
+        const items = this._pickItemsStack.pop();
+        if (items) {
+            this._inDirectory.set({ server: items.server, resources: items.resources }, undefined);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
     static item(resource) {
         const iconPath = resource.icons.getUrl(22);
         if (isMcpResourceTemplate(resource)) {
@@ -40,7 +70,7 @@ let McpResourcePickHelper = class McpResourcePickHelper {
                 id: resource.template.template,
                 label: resource.title || resource.name,
                 description: resource.description,
-                detail: ( localize(8733, 'Resource template: {0}', resource.template.template)),
+                detail: ( localize(8864, 'Resource template: {0}', resource.template.template)),
                 iconPath,
             };
         }
@@ -53,11 +83,15 @@ let McpResourcePickHelper = class McpResourcePickHelper {
         };
     }
     constructor(_mcpService, _fileService, _quickInputService, _notificationService, _chatAttachmentResolveService) {
+        super();
         this._mcpService = _mcpService;
         this._fileService = _fileService;
         this._quickInputService = _quickInputService;
         this._notificationService = _notificationService;
         this._chatAttachmentResolveService = _chatAttachmentResolveService;
+        this._resources = observableValue(this, { picks: ( new Map()), isBusy: true });
+        this._pickItemsStack = ( new LinkedList());
+        this._inDirectory = observableValue(this, undefined);
         this.hasServersWithResources = derived(reader => {
             let enabled = false;
             for (const server of this._mcpService.servers.read(reader)) {
@@ -72,13 +106,62 @@ let McpResourcePickHelper = class McpResourcePickHelper {
             }
             return enabled;
         });
+        this.checkIfNestedResources = () => !this._pickItemsStack.isEmpty();
+    }
+    async navigate(resource, server) {
+        if (isMcpResourceTemplate(resource)) {
+            return false;
+        }
+        const uri = resource.uri;
+        let stat = undefined;
+        try {
+            stat = await this._fileService.resolve(uri, { resolveMetadata: false });
+        }
+        catch (e) {
+            return false;
+        }
+        if (stat && this._isDirectoryResource(resource) && (stat.children?.length ?? 0) > 0) {
+            const currentResources = this._resources.get().picks.get(server);
+            if (currentResources) {
+                this.addCurrentMCPQuickPickItemLevel(server, currentResources);
+            }
+            const childResources = ( stat.children.map(child => {
+                const mcpUri = McpResourceURI.fromServer(server.definition, ( child.resource.toString()));
+                return {
+                    uri: mcpUri,
+                    mcpUri: child.resource.path,
+                    name: child.name,
+                    title: child.name,
+                    description: resource.description,
+                    mimeType: undefined,
+                    sizeInBytes: child.size,
+                    icons: McpIcons.fromParsed(undefined)
+                };
+            }));
+            this._inDirectory.set({ server, resources: childResources }, undefined);
+            return true;
+        }
+        return false;
     }
-    async toAttachment(resource) {
+    toAttachment(resource, server) {
+        const noop = 'noop';
+        if (this._isDirectoryResource(resource)) {
+            this.checkIfDirectoryAndPopulate(resource, server);
+            return noop;
+        }
         if (isMcpResourceTemplate(resource)) {
-            return this._resourceTemplateToAttachment(resource);
+            return this._resourceTemplateToAttachment(resource).then(val => val || noop);
         }
         else {
-            return this._resourceToAttachment(resource);
+            return this._resourceToAttachment(resource).then(val => val || noop);
+        }
+    }
+    async checkIfDirectoryAndPopulate(resource, server) {
+        try {
+            return !(await this.navigate(resource, server));
+        }
+        catch (error) {
+            return false;
         }
     }
     async toURI(resource) {
@@ -120,7 +203,7 @@ let McpResourcePickHelper = class McpResourcePickHelper {
             return uri;
         }
         this._notificationService.warn(( localize(
-            8734,
+            8865,
             "The resource {0} was not found.",
             (McpResourceURI.toServer(uri).resourceURL.toString())
         )));
@@ -161,13 +244,13 @@ let McpResourcePickHelper = class McpResourcePickHelper {
             }
         }
         let placeholder = ( localize(
-            8735,
+            8866,
             "Value for ${0} in {1}",
             variable.name.toUpperCase(),
             rt.template.resolve(variablesWithPlaceholders).replaceAll('%24', '$')
         ));
         if (variable.optional) {
-            placeholder += ' (' + ( localize(8736, "Optional")) + ')';
+            placeholder += ' (' + ( localize(8867, "Optional")) + ')';
         }
         input.placeholder = placeholder;
         input.value = '';
@@ -180,11 +263,12 @@ let McpResourcePickHelper = class McpResourcePickHelper {
                 items.unshift({ id: currentID, label: value });
             }
             else if (variable.optional) {
-                items.unshift({ id: currentID, label: ( localize(8737, "<Empty>")) });
+                items.unshift({ id: currentID, label: ( localize(8868, "<Empty>")) });
             }
             input.items = items;
         };
-        let changeCancellation = store.add(( new CancellationTokenSource()));
+        let changeCancellation = ( new CancellationTokenSource());
+        store.add(toDisposable(() => changeCancellation.dispose(true)));
         const getCompletionItems = () => {
             const inputValue = input.value;
             let promise = completions.get(inputValue);
@@ -222,8 +306,7 @@ let McpResourcePickHelper = class McpResourcePickHelper {
             store.add(input.onDidChangeValue(value => {
                 input.busy = true;
                 changeCancellation.dispose(true);
-                store.delete(changeCancellation);
-                changeCancellation = store.add(( new CancellationTokenSource()));
+                changeCancellation = ( new CancellationTokenSource());
                 getCompletionItemsScheduler.cancel();
                 setItems(value);
                 if (( completions.has(input.value))) {
@@ -236,12 +319,23 @@ let McpResourcePickHelper = class McpResourcePickHelper {
             getCompletionItems();
         })).finally(() => store.dispose());
     }
-    getPicks(onChange, token) {
+    _isDirectoryResource(resource) {
+        if (resource.mimeType && resource.mimeType === 'inode/directory') {
+            return true;
+        }
+        else if (isMcpResourceTemplate(resource)) {
+            return resource.template.template.endsWith('/');
+        }
+        else {
+            return resource.uri.path.endsWith('/');
+        }
+    }
+    getPicks(token) {
         const cts = ( new CancellationTokenSource(token));
-        const store = ( new DisposableStore());
-        store.add(toDisposable(() => cts.dispose(true)));
+        let isBusyLoadingPicks = true;
+        this._register(toDisposable(() => cts.dispose(true)));
         let showInSequence = true;
-        store.add(disposableTimeout(() => {
+        this._register(disposableTimeout(() => {
             showInSequence = false;
             publish();
         }, 5_000));
@@ -261,10 +355,10 @@ let McpResourcePickHelper = class McpResourcePickHelper {
                     break;
                 }
             }
-            onChange(output);
+            this._resources.set({ picks: output, isBusy: isBusyLoadingPicks }, undefined);
         };
         const servers = ( new Map());
-        return Promise.all(( (this.explicitServers || this._mcpService.servers.get()).map(async (server) => {
+        Promise.all(( (this.explicitServers || this._mcpService.servers.get()).map(async (server) => {
             let cap = server.capabilities.get();
             const rec = {
                 templates: ( new DeferredPromise()),
@@ -279,8 +373,8 @@ let McpResourcePickHelper = class McpResourcePickHelper {
                             resolve(undefined);
                         }
                     });
-                    store.add(cts.token.onCancellationRequested(() => resolve(undefined)));
-                    store.add(autorun(reader => {
+                    this._register(cts.token.onCancellationRequested(() => resolve(undefined)));
+                    this._register(autorun(reader => {
                         const cap2 = server.capabilities.read(reader);
                         if (cap2 !== undefined) {
                             resolve(cap2);
@@ -303,9 +397,15 @@ let McpResourcePickHelper = class McpResourcePickHelper {
                 rec.templates.complete([]);
                 rec.resources.complete([]);
             }
-            publish();
         }))).finally(() => {
-            store.dispose();
+            isBusyLoadingPicks = false;
+            publish();
+        });
+        return derived(this, reader => {
+            const directoryResource = this._inDirectory.read(reader);
+            return directoryResource
+                ? { picks: ( new Map([[directoryResource.server, directoryResource.resources]])), isBusy: false }
+                : this._resources.read(reader);
         });
     }
 };
@@ -328,51 +428,78 @@ let AbstractMcpResourceAccessPick = class AbstractMcpResourceAccessPick {
         picker.canAcceptInBackground = true;
         picker.busy = true;
         picker.keepScrollPosition = true;
-        const attachButton = ( localize(8738, "Attach to chat"));
-        const helper = this._instantiationService.createInstance(McpResourcePickHelper);
+        const store = ( new DisposableStore());
+        const goBackId = '_goback_';
+        const attachButton = ( localize(8869, "Attach to chat"));
+        const helper = store.add(this._instantiationService.createInstance(McpResourcePickHelper));
         if (this._scopeTo) {
             helper.explicitServers = [this._scopeTo];
         }
-        helper.getPicks(servers => {
+        const picksObservable = helper.getPicks(token);
+        store.add(autorun(reader => {
+            const pickItems = picksObservable.read(reader);
+            const isBusy = pickItems.isBusy;
             const items = [];
-            for (const [server, resources] of servers) {
+            for (const [server, resources] of pickItems.picks) {
                 items.push(McpResourcePickHelper.sep(server));
                 for (const resource of resources) {
                     const pickItem = McpResourcePickHelper.item(resource);
                     pickItem.buttons = [{ iconClass: ThemeIcon.asClassName(Codicon.attach), tooltip: attachButton }];
-                    items.push({ ...pickItem, resource });
+                    items.push({ ...pickItem, resource, server });
                 }
             }
+            if (helper.checkIfNestedResources()) {
+                const goBackItem = {
+                    id: goBackId,
+                    label: ( localize(8870, 'Go back ↩')),
+                    alwaysShow: true
+                };
+                items.push(goBackItem);
+            }
             picker.items = items;
-        }, token).finally(() => {
-            picker.busy = false;
-        });
-        const store = ( new DisposableStore());
+            picker.busy = isBusy;
+        }));
         store.add(picker.onDidTriggerItemButton(event => {
             if (event.button.tooltip === attachButton) {
                 picker.busy = true;
-                helper.toAttachment(event.item.resource).then(async (a) => {
-                    if (a) {
-                        const widget = await openPanelChatAndGetWidget(this._viewsService, this._chatWidgetService);
-                        widget?.attachmentModel.addContext(a);
-                    }
-                    picker.hide();
-                });
+                const resourceItem = event.item;
+                const attachment = helper.toAttachment(resourceItem.resource, resourceItem.server);
+                if (attachment instanceof Promise) {
+                    attachment.then(async (a) => {
+                        if (a !== 'noop') {
+                            const widget = await openPanelChatAndGetWidget(this._viewsService, this._chatWidgetService);
+                            widget?.attachmentModel.addContext(...asArray(a));
+                        }
+                        picker.hide();
+                    });
+                }
             }
         }));
+        store.add(picker.onDidHide(() => {
+            helper.dispose();
+        }));
         store.add(picker.onDidAccept(async (event) => {
-            if (!event.inBackground) {
-                picker.hide();
-            }
-            if (runOptions?.handleAccept) {
-                runOptions.handleAccept?.(picker.activeItems[0], event.inBackground);
-            }
-            else {
+            try {
+                picker.busy = true;
                 const [item] = picker.selectedItems;
-                const uri = await helper.toURI(item.resource);
-                if (uri) {
-                    this._editorService.openEditor({ resource: uri, options: { preserveFocus: event.inBackground } });
+                if (item.id === goBackId) {
+                    helper.navigateBack();
+                    picker.busy = false;
+                    return;
                 }
+                const resourceItem = item;
+                const resource = resourceItem.resource;
+                const isNested = await helper.navigate(resource, resourceItem.server);
+                if (!isNested) {
+                    const uri = await helper.toURI(resource);
+                    if (uri) {
+                        picker.hide();
+                        this._editorService.openEditor({ resource: uri, options: { preserveFocus: event.inBackground } });
+                    }
+                }
+            }
+            finally {
+                picker.busy = false;
             }
         }));
         return store;
@@ -392,7 +519,7 @@ let McpResourceQuickPick = class McpResourceQuickPick extends AbstractMcpResourc
     async pick(token = CancellationToken.None) {
         const store = ( new DisposableStore());
         const qp = store.add(this._quickInputService.createQuickPick({ useSeparators: true }));
-        qp.placeholder = ( localize(8739, "Search for resources"));
+        qp.placeholder = ( localize(8871, "Search for resources"));
         store.add(this.applyToPick(qp, token));
         store.add(qp.onDidHide(() => store.dispose()));
         qp.show();

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

@@ -19,7 +19,7 @@ import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs
 import { IQuickInputService } from "@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service";
 import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
 import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
-import { ExtensionAction } from "@codingame/monaco-vscode-9ed6fe06-a052-57c2-a234-5d9b94d2e7e0-common/vscode/vs/workbench/contrib/extensions/browser/extensionsActions";
+import { ExtensionAction } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/browser/extensionsActions";
 import { ActionWithDropdownActionViewItem, IActionWithDropdownActionViewItemOptions } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/dropdown/dropdownActionViewItem";
 import { IContextMenuProvider } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/contextmenu";
 export interface IMcpServerActionChangeEvent extends IActionChangeEvent {