@nexusbloom/mcp-server 1.0.0 → 1.0.2

package/index.js

@@ -76,6 +76,7 @@ async function fetchTools() {
       price_type: t.price_type || t.pricing || "free",
       version: t.version || "1.0.0",
       type: "builtin",
+      input_schema: t.input_schema || null,
     }));
     toolsCacheTime = now;
     return toolsCache;
@@ -90,42 +91,16 @@ async function fetchTools() {
 // ---------------------------------------------------------------------------
 
 async function fetchToolSchema(slug) {
-  try {
-    const res = await fetch(`${API_URL}/tools/${encodeURIComponent(slug)}`, {
-      headers: apiHeaders(),
-      ...FETCH_OPTS,
-    });
-    if (res.ok) {
-      const json = await res.json();
-      const tool = json.tool || json.data || json;
-      if (tool && tool.slug) {
-        return {
-          slug: tool.slug,
-          name: tool.name,
-          description: tool.short_description || tool.full_description || tool.description || "",
-          tags: (tool.tags || []).flat().filter(Boolean),
-          input_schema: tool.input_schema || {},
-          output_schema: tool.output_schema || {},
-          icon: tool.icon || "🔧",
-          price_type: tool.price_type || tool.pricing || "free",
-          version: tool.version || "1.0.0",
-          category: tool.category || "Platform Tools",
-        };
-      }
-    }
-  } catch (err) {
-    console.error(`Failed to fetch schema for ${slug}:`, err.message);
-  }
-
-  // Fallback: try the manifest endpoint
+  // Primary: fetch manifest from /api/run/{slug} (the reliable endpoint)
   try {
     const res = await fetch(`${API_URL}/run/${encodeURIComponent(slug)}`, {
       headers: apiHeaders(),
       ...FETCH_OPTS,
     });
     if (res.ok) {
-      const json = await res.json();
-      const manifest = json.manifest || json.data?.manifest || json;
+      // API returns { success: true, data: { manifest: { ... } } }
+      const body = await res.json();
+      const manifest = body.data?.manifest || body.manifest || body;
       if (manifest && manifest.slug) {
         return {
           slug: manifest.slug,
@@ -156,7 +131,7 @@ async function executeTool(slug, params) {
   const res = await fetch(`${API_URL}/run/${encodeURIComponent(slug)}`, {
     method: "POST",
     headers: apiHeaders(),
-    body: JSON.stringify({ input: params }),
+    body: JSON.stringify(params),
     ...FETCH_OPTS,
   });
 
@@ -199,6 +174,16 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     description: `${t.name}: ${t.short_description || "No description"}${
       t.category ? ` [${t.category}]` : ""
     }`,
+    inputSchema: t.input_schema || {
+      type: "object",
+      properties: {},
+    },
+  }));
+
+  // Also expose the meta-tool for list/schema/run
+  toolList.push({
+    name: "nexusbloom",
+    description: `Meta-tool to list, inspect, or run any NexusBloom tool. Use this when you need to discover tools or get schema details.`,
     inputSchema: {
       type: "object",
       properties: {
@@ -221,7 +206,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       required: ["command"],
     },
-  }));
+  });
 
   return { tools: toolList };
 });
@@ -230,10 +215,34 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name: toolName, arguments: args } = request.params;
 
+  // ── Direct tool execution by slug ──────────────────────────────
+  // AI agents can call any tool directly by its slug name.
+  // The tool's own input_schema defines the expected parameters.
+  // We verify the slug exists by checking against our tool list.
   if (toolName !== "nexusbloom") {
-    throw new Error(`Unknown tool: ${toolName}`);
+    const tools = await fetchTools();
+    const matched = tools.find((t) => t.slug === toolName);
+    if (!matched) {
+      return {
+        content: [{ type: "text", text: `Unknown tool: "${toolName}". Use the "nexusbloom" tool with command "list" to see available tools.` }],
+        isError: true,
+      };
+    }
+    try {
+      const result = await executeTool(toolName, args || {});
+      const formatted = JSON.stringify(result.data, null, 2);
+      return {
+        content: [
+          { type: "text", text: `# ${matched.name} (${toolName})\n\n\`\`\`json\n${formatted}\n\`\`\`` },
+          { type: "resource", resource: { text: formatted, uri: "data:application/json,", mimeType: "application/json" } },
+        ],
+      };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error executing "${toolName}": ${err.message}` }], isError: true };
+    }
   }
 
+  // ── Legacy meta-tool: list/schema/run via sub-commands ─────────
   const command = args?.command;
 
   if (!command || !["list", "schema", "run"].includes(command)) {
@@ -363,16 +372,44 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 // ---- Start ----
 async function main() {
   try {
-    // Verify API connectivity
-    try {
-      const res = await fetch(`${API_URL}/tools`, { ...FETCH_OPTS });
-      if (res.ok) {
-        console.error(`NexusBloom MCP server connected to ${API_URL}`);
-      } else {
-        console.error(`WARNING: API at ${API_URL} returned ${res.status}`);
+    // Verify API connectivity — try multiple possible API URLs
+    const apiUrlCandidates = [
+      API_URL,
+      API_URL.replace("/api", ""), // base domain without /api
+    ];
+
+    let connected = false;
+    for (const url of apiUrlCandidates) {
+      try {
+        const testUrl = url.includes("/api") ? `${url}/tools` : `${url}/api/tools`;
+        const res = await fetch(testUrl, { ...FETCH_OPTS });
+        if (res.ok || res.status === 429) {
+          console.error(`NexusBloom MCP server connected to ${url}`);
+          connected = true;
+          break;
+        } else if (res.status === 404) {
+          // Try without /tools path
+          const res2 = await fetch(url, { ...FETCH_OPTS });
+          if (res2.ok) {
+            console.error(`NexusBloom MCP server connected to ${url}`);
+            connected = true;
+            break;
+          }
+        }
+      } catch (_) {
+        // Continue to next candidate
       }
-    } catch (err) {
-      console.error(`WARNING: Could not reach API at ${API_URL}: ${err.message}`);
+    }
+
+    if (!connected) {
+      console.error(
+        `WARNING: Could not reach NexusBloom API. ` +
+        `The MCP server will start in degraded mode — tool execution requires a working API.\n` +
+        `Checked endpoints:\n` +
+        apiUrlCandidates.map(u => `  - ${u.includes("/api") ? `${u}/tools` : `${u}/api/tools`}`).join("\n") + "\n" +
+        `To fix: ensure NEXUSBLOOM_API_URL is set correctly (default: https://nexusbloom.dev/api)\n` +
+        `Or deploy the platform API and verify the Vercel rewrite from your frontend project.`
+      );
     }
 
     const transport = new StdioServerTransport();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexusbloom/mcp-server",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "MCP server for NexusBloom — AI agents discover and execute tools through a single interface. No Supabase credentials needed, just connect to our API.",
   "type": "module",
   "main": "index.js",
@@ -13,4 +13,4 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.8.0"
   }
-}
+}

package/test-mcp-client.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+/**
+ * MCP Server Test — uses the MCP SDK Client directly.
+ * Tests both direct slug execution and meta-tool paths.
+ *
+ * Usage: node test-mcp-client.mjs
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+
+async function main() {
+  console.log("═══ MCP Server Test ═══\n");
+
+  const transport = new StdioClientTransport({
+    command: "npx",
+    args: ["@nexusbloom/mcp-server"],
+  });
+
+  const client = new Client(
+    { name: "mcp-test-client", version: "1.0.0" },
+    { capabilities: {} }
+  );
+
+  await client.connect(transport);
+  console.log("✅ Connected to MCP server\n");
+
+  // ── Test 1: ListTools ─────────────────────────────────────────
+  const { tools } = await client.listTools();
+  console.log(`✅ Tools available: ${tools.length}`);
+  const slugs = tools.filter((t) => t.name !== "nexusbloom").map((t) => t.name);
+  const metaTool = tools.find((t) => t.name === "nexusbloom");
+  if (metaTool) console.log(`✅ Meta-tool "nexusbloom" registered`);
+  console.log(`   Example tools: ${slugs.slice(0, 5).join(", ")}...`);
+  console.log();
+
+  // ── Test 2: Direct slug execution ─────────────────────────────
+  // AI agents call tools by their slug name directly
+  console.log("── Test: Direct slug execution ──");
+  const cronResult = await client.callTool({
+    name: "cron-expression-builder",
+    arguments: { expression: "0 0 * * *" },
+  });
+  const cronText = cronResult.content.find((c) => c.type === "text")?.text || "";
+  if (cronText.includes(`"valid": true`)) {
+    console.log("✅ cron-expression-builder executed directly by slug");
+    console.log(`   → ${cronText.split("\n")[1] || "valid=true"}`);
+  } else {
+    console.log(`⚠  Unexpected: ${cronText.substring(0, 100)}`);
+  }
+
+  const dataResult = await client.callTool({
+    name: "data-generator",
+    arguments: { count: 2 },
+  });
+  const dataText = dataResult.content.find((c) => c.type === "text")?.text || "";
+  if (dataText.includes("data-generator")) {
+    console.log("✅ data-generator executed directly by slug");
+  }
+  console.log();
+
+  // ── Test 3: Meta-tool "list" ──────────────────────────────────
+  console.log("── Test: Meta-tool list ──");
+  const listResult = await client.callTool({
+    name: "nexusbloom",
+    arguments: { command: "list" },
+  });
+  const listText = listResult.content.find((c) => c.type === "text")?.text || "";
+  if (listText.includes("NexusBloom Tools")) {
+    console.log("✅ Meta-tool list works");
+  }
+  console.log();
+
+  // ── Test 4: Meta-tool "schema" ────────────────────────────────
+  console.log("── Test: Meta-tool schema ──");
+  const schemaResult = await client.callTool({
+    name: "nexusbloom",
+    arguments: { command: "schema", slug: "cron-expression-builder" },
+  });
+  const schemaText = schemaResult.content.find((c) => c.type === "text")?.text || "";
+  if (schemaText.includes("Cron Expression Builder")) {
+    console.log("✅ Meta-tool schema works");
+  }
+  console.log();
+
+  // ── Test 5: Meta-tool "run" ───────────────────────────────────
+  console.log("── Test: Meta-tool run ──");
+  const runResult = await client.callTool({
+    name: "nexusbloom",
+    arguments: { command: "run", slug: "data-generator", params: { count: 3 } },
+  });
+  const runText = runResult.content.find((c) => c.type === "text")?.text || "";
+  if (runText.includes("data-generator")) {
+    console.log("✅ Meta-tool run works");
+  }
+  console.log();
+
+  await client.close();
+  console.log("═══ All MCP tests passed! ═══");
+}
+
+main().catch((err) => {
+  console.error("❌ MCP test failed:", err.message);
+  process.exit(1);
+});