mono-pilot 0.2.9 → 0.2.12

package/dist/{tools → src/tools}/fetch-mcp-resource.js

@@ -1,7 +1,11 @@
-import { homedir } from "node:os";
+import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, resolve } from "node:path";
+import { keyHint } from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
-import { createRpcRequestId, extractStringHeaders, formatErrorMessage, formatJsonRpcError, inferTransport, isRecord, isServerEnabled, MCP_CONFIG_RELATIVE_PATH, parseMcpConfig, postJsonRpcRequest, resolveMcpConfigPath, toNonEmptyString, initializeMcpSession, } from "../src/utils/mcp-client.js";
+import { McpServerError, resolveTargetServer } from "../mcp/servers.js";
+import { createRpcRequestId, formatJsonRpcError, initializeMcpSession, postJsonRpcRequest } from "../mcp/protocol.js";
+import { formatErrorMessage, isRecord, toNonEmptyString } from "../mcp/config.js";
 const DESCRIPTION = `Reads a specific resource from an MCP server, identified by server name and resource URI. Optionally, set downloadPath (relative to the workspace) to save the resource to disk; when set, the resource will be downloaded and not returned to the model.`;
 const fetchMcpResourceSchema = Type.Object({
     server: Type.String({ description: "The MCP server identifier" }),
@@ -19,9 +23,7 @@ async function fetchRemoteMcpResource(options) {
             jsonrpc: "2.0",
             id: createRpcRequestId(`${options.toolCallId}:resources.read`),
             method: "resources/read",
-            params: {
-                uri: options.uri,
-            },
+            params: { uri: options.uri },
         },
         parentSignal: options.signal,
         sessionId,
@@ -83,6 +85,32 @@ export default function fetchMcpResourceExtension(pi) {
         label: "FetchMcpResource",
         description: DESCRIPTION,
         parameters: fetchMcpResourceSchema,
+        renderCall(args, theme) {
+            const input = args;
+            const server = typeof input.server === "string" && input.server.trim().length > 0 ? input.server : "(missing server)";
+            const uri = typeof input.uri === "string" && input.uri.trim().length > 0 ? input.uri : "(missing uri)";
+            let text = theme.fg("toolTitle", theme.bold("FetchMcpResource"));
+            text += ` ${theme.fg("toolOutput", `${server} :: ${uri}`)}`;
+            return new Text(text, 0, 0);
+        },
+        renderResult(result, { expanded, isPartial }, theme) {
+            if (isPartial) {
+                return new Text(theme.fg("muted", "Fetching resource..."), 0, 0);
+            }
+            const textBlock = result.content.find((entry) => entry.type === "text" && typeof entry.text === "string");
+            if (!textBlock) {
+                return new Text(theme.fg("error", "No text result returned."), 0, 0);
+            }
+            const fullText = textBlock.text;
+            const lineCount = fullText.split("\n").length;
+            if (!expanded) {
+                const summary = `${lineCount} lines (click or ${keyHint("expandTools", "to expand")})`;
+                return new Text(theme.fg("muted", summary), 0, 0);
+            }
+            let text = fullText.split("\n").map((line) => theme.fg("toolOutput", line)).join("\n");
+            text += theme.fg("muted", `\n(click or ${keyHint("expandTools", "to collapse")})`);
+            return new Text(text, 0, 0);
+        },
         async execute(toolCallId, params, signal, _onUpdate, ctx) {
             let serverName;
             let uri;
@@ -104,90 +132,21 @@ export default function fetchMcpResourceExtension(pi) {
                     isError: true,
                 };
             }
-            const configPath = resolveMcpConfigPath(ctx.cwd);
-            if (!configPath) {
-                const workspaceCandidate = resolve(ctx.cwd, MCP_CONFIG_RELATIVE_PATH);
-                const homeCandidate = resolve(homedir(), MCP_CONFIG_RELATIVE_PATH);
-                const message = `MCP config not found. Checked:\n- ${workspaceCandidate}\n- ${homeCandidate}`;
-                return {
-                    content: [{ type: "text", text: message }],
-                    details: {
-                        server: serverName,
-                        uri,
-                        error: message,
-                    },
-                    isError: true,
-                };
-            }
-            let servers;
+            let server;
+            let configPaths;
             try {
-                servers = await parseMcpConfig(configPath);
+                const result = await resolveTargetServer(ctx.cwd, serverName);
+                server = result.server;
+                configPaths = result.configPaths;
             }
             catch (error) {
                 const message = formatErrorMessage(error);
+                const transport = error instanceof McpServerError ? error.transport : undefined;
+                const paths = error instanceof McpServerError ? error.configPaths : undefined;
                 return {
                     content: [{ type: "text", text: message }],
                     details: {
-                        config_path: configPath,
-                        server: serverName,
-                        uri,
-                        error: message,
-                    },
-                    isError: true,
-                };
-            }
-            const serverConfig = servers[serverName];
-            if (!serverConfig) {
-                const message = `MCP server '${serverName}' not found in ${configPath}.`;
-                return {
-                    content: [{ type: "text", text: message }],
-                    details: {
-                        config_path: configPath,
-                        server: serverName,
-                        uri,
-                        error: message,
-                    },
-                    isError: true,
-                };
-            }
-            if (!isServerEnabled(serverConfig)) {
-                const message = `MCP server '${serverName}' is disabled in config.`;
-                return {
-                    content: [{ type: "text", text: message }],
-                    details: {
-                        config_path: configPath,
-                        server: serverName,
-                        uri,
-                        transport: inferTransport(serverConfig),
-                        error: message,
-                    },
-                    isError: true,
-                };
-            }
-            const transport = inferTransport(serverConfig);
-            if (transport === "stdio") {
-                const command = toNonEmptyString(serverConfig.command);
-                const message = `MCP stdio transport is not supported yet in FetchMcpResource.` +
-                    (command ? ` Configured command: ${command}` : "");
-                return {
-                    content: [{ type: "text", text: message }],
-                    details: {
-                        config_path: configPath,
-                        server: serverName,
-                        uri,
-                        transport,
-                        error: message,
-                    },
-                    isError: true,
-                };
-            }
-            const serverUrl = toNonEmptyString(serverConfig.url);
-            if (!serverUrl) {
-                const message = `MCP server '${serverName}' is missing a remote URL.`;
-                return {
-                    content: [{ type: "text", text: message }],
-                    details: {
-                        config_path: configPath,
+                        config_paths: paths,
                         server: serverName,
                         uri,
                         transport,
@@ -196,11 +155,10 @@ export default function fetchMcpResourceExtension(pi) {
                     isError: true,
                 };
             }
-            const headers = extractStringHeaders(serverConfig.headers);
             try {
                 const contents = await fetchRemoteMcpResource({
-                    serverUrl,
-                    serverHeaders: headers,
+                    serverUrl: server.url,
+                    serverHeaders: server.headers,
                     uri,
                     signal,
                     toolCallId,
@@ -209,20 +167,19 @@ export default function fetchMcpResourceExtension(pi) {
                     return {
                         content: [{ type: "text", text: `Resource '${uri}' returned no content.` }],
                         details: {
-                            config_path: configPath,
+                            config_paths: configPaths,
                             server: serverName,
                             uri,
-                            transport,
-                            server_url: serverUrl,
+                            transport: "remote",
+                            server_url: server.url,
                             contents_count: 0,
                         },
                     };
                 }
                 if (downloadPath) {
-                    // We only support downloading the first content item currently
+                    // Only the first content item is downloaded
                     const contentToDownload = contents[0];
                     const absoluteTarget = resolve(ctx.cwd, downloadPath);
-                    const { mkdir, writeFile } = await import("node:fs/promises");
                     await mkdir(dirname(absoluteTarget), { recursive: true });
                     let bytesWritten = 0;
                     if (contentToDownload.blob !== undefined) {
@@ -245,17 +202,16 @@ export default function fetchMcpResourceExtension(pi) {
                             },
                         ],
                         details: {
-                            config_path: configPath,
+                            config_paths: configPaths,
                             server: serverName,
                             uri,
-                            transport,
-                            server_url: serverUrl,
+                            transport: "remote",
+                            server_url: server.url,
                             contents_count: contents.length,
                             downloaded_to: downloadPath,
                         },
                     };
                 }
-                // Return contents directly
                 const lines = [];
                 for (let i = 0; i < contents.length; i++) {
                     const item = contents[i];
@@ -279,11 +235,11 @@ export default function fetchMcpResourceExtension(pi) {
                 return {
                     content: [{ type: "text", text: lines.join("\n").trim() }],
                     details: {
-                        config_path: configPath,
+                        config_paths: configPaths,
                         server: serverName,
                         uri,
-                        transport,
-                        server_url: serverUrl,
+                        transport: "remote",
+                        server_url: server.url,
                         contents_count: contents.length,
                     },
                 };
@@ -293,11 +249,11 @@ export default function fetchMcpResourceExtension(pi) {
                 return {
                     content: [{ type: "text", text: `FetchMcpResource failed: ${message}` }],
                     details: {
-                        config_path: configPath,
+                        config_paths: configPaths,
                         server: serverName,
                         uri,
-                        transport,
-                        server_url: serverUrl,
+                        transport: "remote",
+                        server_url: server.url,
                         error: message,
                     },
                     isError: true,