@pi-unipi/mcp 0.1.0 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/mcp",
-  "version": "0.1.0",
+  "version": "0.1.6",
   "description": "MCP server management extension for Pi coding agent — browse, add, configure, and use MCP servers",
   "type": "module",
   "license": "MIT",

package/src/bridge/registry.ts

@@ -94,9 +94,28 @@ export class ServerRegistry {
     this.entries.set(name, entry);
 
     try {
+      // Defensive: ensure server definition has correct types before passing
+      // to the client. Catches rare serialization bugs where env/args become
+      // strings instead of objects/arrays.
+      const safeCommand = typeof def.command === "string" ? def.command : String(def.command);
+      const safeArgs = Array.isArray(def.args) ? def.args : [];
+      let safeEnv: Record<string, string> | undefined;
+      if (def.env !== undefined && def.env !== null) {
+        if (typeof def.env === "object" && !Array.isArray(def.env)) {
+          safeEnv = {};
+          for (const [k, v] of Object.entries(def.env)) {
+            safeEnv[k] = typeof v === "string" ? v : String(v);
+          }
+        } else {
+          console.error(
+            `[MCP] Server '${name}': env is not an object (${typeof def.env}), skipping env vars`,
+          );
+        }
+      }
+
       // Create and connect client
       const client = new McpClient({ timeoutMs: this.timeoutMs });
-      await client.connect(def.command, def.args ?? [], def.env);
+      await client.connect(safeCommand, safeArgs, safeEnv);
 
       entry.client = client;
 

package/src/bridge/translator.ts

@@ -16,12 +16,29 @@ interface ToolParameters {
   required?: string[];
 }
 
+/** Content block returned by a pi tool */
+interface PiContentBlock {
+  type: "text";
+  text: string;
+}
+
+/** Pi tool execution result shape */
+interface PiToolResult {
+  content: PiContentBlock[];
+  details?: Record<string, unknown>;
+}
+
 /** Pi-compatible external tool */
 export interface PiExternalTool {
   name: string;
   description: string;
   parameters: ToolParameters;
-  execute: (params: Record<string, unknown>) => Promise<string>;
+  execute: (
+    toolCallId: string,
+    params: Record<string, unknown>,
+    signal?: AbortSignal,
+    onUpdate?: (update: string) => void,
+  ) => Promise<PiToolResult>;
 }
 
 /**
@@ -55,39 +72,66 @@ export function translateMcpTool(
   ].join(" ");
 
   const execute = async (
+    _toolCallId: string,
     params: Record<string, unknown>,
-  ): Promise<string> => {
+    _signal?: AbortSignal,
+    _onUpdate?: (update: string) => void,
+  ): Promise<PiToolResult> => {
     try {
       const result: McpToolResult = await client.callTool(
         mcpTool.name,
         params,
       );
 
-      // Join all text content blocks
-      const textParts: string[] = [];
-      for (const block of result.content) {
+      // Defensive: some MCP servers return malformed results without content
+      const contentBlocks = result.content ?? [];
+      const blocks: PiContentBlock[] = [];
+
+      for (const block of contentBlocks) {
         if (block.type === "text" && block.text) {
-          textParts.push(block.text);
+          blocks.push({ type: "text", text: block.text });
         } else if (block.type === "image" && block.data) {
-          textParts.push(`[Image: ${block.mimeType ?? "unknown"}]`);
+          blocks.push({
+            type: "text",
+            text: `[Image: ${block.mimeType ?? "unknown"}]`,
+          });
         } else if (block.type === "resource") {
-          textParts.push(`[Resource: ${block.text ?? block.mimeType ?? "unknown"}]`);
+          blocks.push({
+            type: "text",
+            text: `[Resource: ${block.text ?? block.mimeType ?? "unknown"}]`,
+          });
         }
       }
 
       if (result.isError) {
-        const joined = textParts.join("\n") || "Unknown error";
-        throw new Error(`MCP tool error from ${serverName}: ${joined}`);
+        const errorText = blocks.map((b) => b.text).join("\n") || "Unknown error";
+        return {
+          content: [{ type: "text", text: `MCP tool error from ${serverName}: ${errorText}` }],
+          details: { error: true, server: serverName, tool: mcpTool.name },
+        };
+      }
+
+      if (blocks.length === 0) {
+        blocks.push({ type: "text", text: "(no output)" });
       }
 
-      return textParts.join("\n") || "(no output)";
+      return {
+        content: blocks,
+        details: { server: serverName, tool: mcpTool.name },
+      };
     } catch (err) {
-      const message =
-        err instanceof Error ? err.message : String(err);
-      throw new Error(
-        `MCP tool "${mcpTool.name}" on server "${serverName}" failed: ${message}\n` +
-          `Check server status via /unipi:mcp-settings`,
-      );
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        content: [
+          {
+            type: "text",
+            text:
+              `MCP tool "${mcpTool.name}" on server "${serverName}" failed: ${message}\n` +
+              `Check server status via /unipi:mcp-settings`,
+          },
+        ],
+        details: { error: true, server: serverName, tool: mcpTool.name },
+      };
     }
   };
 

package/src/index.ts

@@ -119,19 +119,38 @@ export default function (pi: ExtensionAPI) {
             { id: "failed", label: "Failed", show: true },
           ],
         },
-        dataProvider: async () => ({
-          total: { value: String(reg.getAll().length) },
-          active: { value: String(reg.getActive().length) },
-          tools: { value: String(reg.getTotalToolCount()) },
-          failed: {
-            value: String(reg.getFailed().length),
-            detail:
-              reg.getFailed().length > 0
-                ? reg.getFailed().map((f) => f.name).join(", ")
-                : undefined,
-          },
-        }),
+        dataProvider: async () => {
+          try {
+            const all = reg.getAll();
+            const active = reg.getActive();
+            const failed = reg.getFailed();
+            const toolCount = reg.getTotalToolCount();
+            return {
+              total: { value: String(all.length) },
+              active: { value: String(active.length) },
+              tools: { value: String(toolCount) },
+              failed: {
+                value: String(failed.length),
+                detail:
+                  failed.length > 0
+                    ? failed.map((f) => f.name).join(", ")
+                    : undefined,
+              },
+            };
+          } catch (err) {
+            console.error("[MCP] Info dataProvider error:", err);
+            return {
+              total: { value: "?" },
+              active: { value: "?" },
+              tools: { value: "?" },
+              failed: { value: "?" },
+            };
+          }
+        },
       });
+      // Trigger initial data fetch so the info overlay shows real values
+      // instead of the empty GroupData from notifyGroupRegistered.
+      infoRegistry.getGroupData("mcp").catch(() => {});
     }
 
     // Emit MODULE_READY
@@ -144,6 +163,7 @@ export default function (pi: ExtensionAPI) {
         `unipi:${MCP_COMMANDS.SETTINGS}`,
         `unipi:${MCP_COMMANDS.SYNC}`,
         `unipi:${MCP_COMMANDS.STATUS}`,
+        `unipi:${MCP_COMMANDS.RELOAD}`,
       ],
       tools: activeServers.flatMap((s) =>
         registry?.getEntry(s.name)?.toolNames ?? [],
@@ -294,4 +314,44 @@ export default function (pi: ExtensionAPI) {
       openSettings();
     },
   });
+
+  // /unipi:mcp-reload — restart all MCP servers
+  pi.registerCommand(`unipi:${MCP_COMMANDS.RELOAD}`, {
+    description: "Reload all MCP servers (restart with current config)",
+    handler: async (_args: string, ctx: any) => {
+      const reg = getRegistry();
+      if (!reg) {
+        ctx.ui.notify("MCP extension not initialized", "warning");
+        return;
+      }
+
+      const all = reg.getAll();
+      if (all.length === 0) {
+        ctx.ui.notify("No MCP servers configured. Use /unipi:mcp-add to add one.", "info");
+        return;
+      }
+
+      ctx.ui.notify(`Reloading ${all.length} MCP server(s)...`, "info");
+
+      let restarted = 0;
+      let failed = 0;
+      for (const state of all) {
+        try {
+          await reg.restartServer(state.name);
+          restarted++;
+        } catch (err) {
+          failed++;
+          console.error(
+            `[MCP] Failed to restart server '${state.name}':`,
+            err instanceof Error ? err.message : err,
+          );
+        }
+      }
+
+      const msg = failed > 0
+        ? `Reloaded: ${restarted} ok, ${failed} failed`
+        : `Reloaded ${restarted} MCP server(s) successfully`;
+      ctx.ui.notify(msg, failed > 0 ? "warning" : "info");
+    },
+  });
 }