create-multicast 0.4.2 → 0.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-multicast",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Create a Multicast MCP gateway — one command to scaffold, configure, and deploy your parallel MCP server.",
   "type": "module",
   "bin": "./dist/cli.js",

package/templates/default/src/index.ts

@@ -919,66 +919,118 @@ Clears the cache and re-fetches tools/list from every registered server.`,
 
     this.server.tool(
       "fetch_result",
-      `Retrieve the full output of a large result that was stored by reference.
-When multicast returns an output_ref instead of inline output, call this
-tool with the ref ID to get the complete data. Results expire after 1 hour.`,
+      `Retrieve the full output of large results stored by reference.
+When multicast returns output_ref instead of inline output, call this tool
+to get the complete data. Accepts a SINGLE ref or MULTIPLE refs at once.
+Always pass ALL refs in one call — don't call this tool multiple times.
+Results expire after 1 hour.
+
+Example (single): { "ref": "ref_abc123" }
+Example (batch):  { "refs": ["ref_abc123", "ref_def456"] }`,
       {
         ref: z
           .string()
-          .describe("The output_ref ID from a multicast result (e.g., ref_abc123def456)"),
+          .optional()
+          .describe("Single output_ref ID (use this OR refs, not both)"),
+        refs: z
+          .array(z.string())
+          .optional()
+          .describe("Multiple output_ref IDs to fetch at once (use this OR ref, not both)"),
       },
-      async ({ ref }) => {
+      async ({ ref, refs }) => {
         const db = this.env.DB;
 
-        const row = await db
-          .prepare(
-            "SELECT server_name, tool_name, output, created_at FROM result_cache WHERE ref_id = ?"
-          )
-          .bind(ref)
-          .first<{
-            server_name: string;
-            tool_name: string;
-            output: string;
-            created_at: string;
-          }>();
-
-        if (!row) {
+        // Normalize: single ref or batch refs into one array
+        const refIds: string[] = [];
+        if (refs && refs.length > 0) {
+          refIds.push(...refs);
+        } else if (ref) {
+          refIds.push(ref);
+        } else {
           return {
-            content: [
-              {
-                type: "text" as const,
-                text: JSON.stringify({
-                  error: `Result not found for ref "${ref}". It may have expired (results are kept for 1 hour).`,
-                }),
-              },
-            ],
+            content: [{
+              type: "text" as const,
+              text: JSON.stringify({ error: "Provide either 'ref' (single) or 'refs' (array)." }),
+            }],
           };
         }
 
-        // Parse the stored output back
-        let parsedOutput: unknown;
-        try {
-          parsedOutput = JSON.parse(row.output);
-        } catch {
-          parsedOutput = row.output;
+        // Fetch all refs in one D1 batch
+        const results: Array<{
+          ref_id: string;
+          server: string;
+          tool: string;
+          output: unknown;
+          cached_at: string;
+          error?: string;
+        }> = [];
+
+        for (const refId of refIds) {
+          const row = await db
+            .prepare(
+              "SELECT server_name, tool_name, output, created_at FROM result_cache WHERE ref_id = ?"
+            )
+            .bind(refId)
+            .first<{
+              server_name: string;
+              tool_name: string;
+              output: string;
+              created_at: string;
+            }>();
+
+          if (!row) {
+            results.push({
+              ref_id: refId,
+              server: "unknown",
+              tool: "unknown",
+              output: null,
+              cached_at: "",
+              error: `Not found — may have expired (1 hour TTL).`,
+            });
+            continue;
+          }
+
+          let parsedOutput: unknown;
+          try {
+            parsedOutput = JSON.parse(row.output);
+          } catch {
+            parsedOutput = row.output;
+          }
+
+          results.push({
+            ref_id: refId,
+            server: row.server_name,
+            tool: row.tool_name,
+            output: parsedOutput,
+            cached_at: row.created_at,
+          });
         }
 
-        return {
-          content: [
-            {
+        // Single ref: return flat (backwards compatible)
+        if (refIds.length === 1 && results.length === 1 && !results[0].error) {
+          return {
+            content: [{
               type: "text" as const,
-              text: JSON.stringify(
-                {
-                  server: row.server_name,
-                  tool: row.tool_name,
-                  output: parsedOutput,
-                  cached_at: row.created_at,
-                },
-                null,
-                2
-              ),
-            },
-          ],
+              text: JSON.stringify({
+                server: results[0].server,
+                tool: results[0].tool,
+                output: results[0].output,
+                cached_at: results[0].cached_at,
+              }, null, 2),
+            }],
+          };
+        }
+
+        // Batch: return array of results
+        return {
+          content: [{
+            type: "text" as const,
+            text: JSON.stringify({
+              results,
+              fetched: results.filter((r) => !r.error).length,
+              errors: results.filter((r) => r.error).length,
+            }, null, 2),
+          }],
         };
       }
     );
@@ -1024,6 +1076,86 @@ export default {
       );
     }
 
+    // Status endpoint — full server + tool listing
+    // Use: curl https://your-multicast.workers.dev/status
+    // Or:  curl https://your-multicast.workers.dev/status | jq .
+    if (url.pathname === "/status") {
+      try {
+        const registry = getRegisteredServers(env);
+        const db = env.DB;
+
+        const servers = await db
+          .prepare(
+            "SELECT name, url, status, tool_count, last_error, last_discovered_at FROM servers ORDER BY name"
+          )
+          .all<{
+            name: string;
+            url: string;
+            status: string;
+            tool_count: number;
+            last_error: string | null;
+            last_discovered_at: string | null;
+          }>();
+
+        const serverDetails = [];
+        for (const server of servers.results) {
+          // Only include servers that are in the current registry
+          if (!registry.has(server.name)) continue;
+
+          const regServer = registry.get(server.name)!;
+          const tools = await db
+            .prepare(
+              "SELECT tool_name, description FROM tools WHERE server_name = ? ORDER BY tool_name"
+            )
+            .bind(server.name)
+            .all<{ tool_name: string; description: string }>();
+
+          serverDetails.push({
+            name: server.name,
+            url: server.url,
+            status: server.status,
+            auth: regServer.isOAuth ? "oauth" : regServer.auth ? "static" : "none",
+            tool_count: server.tool_count,
+            last_error: server.last_error,
+            last_discovered: server.last_discovered_at,
+            tools: tools.results.map((t) => ({
+              name: t.tool_name,
+              description: t.description.slice(0, 120) + (t.description.length > 120 ? "..." : ""),
+            })),
+          });
+        }
+
+        const totalTools = serverDetails.reduce((sum, s) => sum + s.tool_count, 0);
+
+        return new Response(
+          JSON.stringify(
+            {
+              name: "Multicast",
+              version: "0.4.2",
+              description: "MCP gateway — one integration, all your servers, parallel execution",
+              total_servers: serverDetails.length,
+              total_tools: totalTools,
+              servers: serverDetails,
+            },
+            null,
+            2
+          ),
+          {
+            headers: {
+              "Content-Type": "application/json",
+              "Access-Control-Allow-Origin": "*",
+            },
+          }
+        );
+      } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : "unknown error";
+        return new Response(
+          JSON.stringify({ error: message }),
+          { status: 500, headers: { "Content-Type": "application/json" } }
+        );
+      }
+    }
+
     // Return clean 404 for OAuth discovery and other non-MCP paths
     // Claude Code's HTTP transport probes /.well-known/oauth-authorization-server
     // If this returns a JSON-RPC error, Claude Code's OAuth parser breaks.