@nexusbloom/mcp-server 1.0.0

package/index.js

@@ -0,0 +1,387 @@
+#!/usr/bin/env node
+
+/**
+ * @nexusbloom/mcp-server
+ *
+ * MCP (Model Context Protocol) server for NexusBloom.
+ * AI agents use a single tool to discover, inspect, and execute
+ * any tool in the NexusBloom ecosystem.
+ *
+ * No Supabase credentials needed. Connects to the NexusBloom API.
+ *
+ * Usage:
+ *   npx @nexusbloom/mcp-server
+ *
+ * Environment variables (all optional):
+ *   NEXUSBLOOM_API_KEY    — API key for authenticated tool execution
+ *   NEXUSBLOOM_API_URL    — API base URL (default: https://nexusbloom.dev/api)
+ */
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+// ---------------------------------------------------------------------------
+// Configuration
+// ---------------------------------------------------------------------------
+
+const API_KEY = process.env.NEXUSBLOOM_API_KEY || "";
+const API_URL = (process.env.NEXUSBLOOM_API_URL || "https://nexusbloom.dev/api").replace(/\/+$/, "");
+
+// Optional: if the API URL is a local dev server, allow insecure HTTPS
+const FETCH_OPTS = API_URL.includes("localhost") || API_URL.includes("127.0.0.1")
+  ? {}
+  : {};
+
+function apiHeaders() {
+  const headers = { "Content-Type": "application/json" };
+  if (API_KEY) headers["Authorization"] = `Bearer ${API_KEY}`;
+  return headers;
+}
+
+// ---------------------------------------------------------------------------
+// Tool manifest cache
+// ---------------------------------------------------------------------------
+
+let toolsCache = null;
+let toolsCacheTime = 0;
+const CACHE_TTL = 30_000; // 30 seconds
+
+async function fetchTools() {
+  const now = Date.now();
+  if (toolsCache && now - toolsCacheTime < CACHE_TTL) return toolsCache;
+
+  try {
+    const res = await fetch(`${API_URL}/tools`, {
+      headers: apiHeaders(),
+      ...FETCH_OPTS,
+    });
+    if (!res.ok) {
+      console.error(`API returned ${res.status} for /tools`);
+      return toolsCache || [];
+    }
+    const json = await res.json();
+    const tools = (json.tools || json.data || json || []).filter(Boolean);
+
+    toolsCache = tools.map(t => ({
+      slug: t.slug,
+      name: t.name,
+      short_description: t.short_description || t.description || "",
+      tags: (t.tags || []).flat().filter(Boolean),
+      category: t.category || "Platform Tools",
+      icon: t.icon || "🔧",
+      price_type: t.price_type || t.pricing || "free",
+      version: t.version || "1.0.0",
+      type: "builtin",
+    }));
+    toolsCacheTime = now;
+    return toolsCache;
+  } catch (err) {
+    console.error("Failed to fetch tools:", err.message);
+    return toolsCache || [];
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Fetch a single tool's schema
+// ---------------------------------------------------------------------------
+
+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
+  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;
+      if (manifest && manifest.slug) {
+        return {
+          slug: manifest.slug,
+          name: manifest.name,
+          description: manifest.short_description || "",
+          tags: manifest.tags || [],
+          input_schema: manifest.input_schema || {},
+          output_schema: manifest.output_schema || {},
+          icon: manifest.icon || "🔧",
+          price_type: manifest.pricing || "free",
+          version: manifest.version || "1.0.0",
+          category: manifest.category || "Platform Tools",
+        };
+      }
+    }
+  } catch (err) {
+    console.error(`Failed to fetch manifest for ${slug}:`, err.message);
+  }
+
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Execute a tool
+// ---------------------------------------------------------------------------
+
+async function executeTool(slug, params) {
+  const res = await fetch(`${API_URL}/run/${encodeURIComponent(slug)}`, {
+    method: "POST",
+    headers: apiHeaders(),
+    body: JSON.stringify({ input: params }),
+    ...FETCH_OPTS,
+  });
+
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: res.statusText }));
+    throw new Error(err.error || `API returned ${res.status}`);
+  }
+
+  const json = await res.json();
+  return {
+    success: true,
+    data: json.data || json,
+    tool: slug,
+    execution: "live",
+  };
+}
+
+// ---------------------------------------------------------------------------
+// MCP Server
+// ---------------------------------------------------------------------------
+
+const server = new Server(
+  {
+    name: "nexusbloom-mcp",
+    version: "1.0.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  },
+);
+
+// ---- ListTools ----
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  const tools = await fetchTools();
+
+  const toolList = tools.map((t) => ({
+    name: t.slug,
+    description: `${t.name}: ${t.short_description || "No description"}${
+      t.category ? ` [${t.category}]` : ""
+    }`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          enum: ["list", "schema", "run"],
+          description:
+            "What to do: 'list' returns all available tools, 'schema' returns a tool's full input/output schema, 'run' executes a tool",
+        },
+        slug: {
+          type: "string",
+          description:
+            "Tool slug (required for 'schema' and 'run' commands). Use 'list' first to see available slugs.",
+        },
+        params: {
+          type: "object",
+          description:
+            "Input parameters matching the tool's input_schema (required for 'run' command). Use 'schema' first to see the expected format.",
+        },
+      },
+      required: ["command"],
+    },
+  }));
+
+  return { tools: toolList };
+});
+
+// ---- CallTool ----
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name: toolName, arguments: args } = request.params;
+
+  if (toolName !== "nexusbloom") {
+    throw new Error(`Unknown tool: ${toolName}`);
+  }
+
+  const command = args?.command;
+
+  if (!command || !["list", "schema", "run"].includes(command)) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "Invalid command. Use one of: 'list', 'schema', 'run'.",
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  // ---- COMMAND: list ----
+  if (command === "list") {
+    const tools = await fetchTools();
+
+    const summary = tools
+      .map((t) => `• ${t.icon} **${t.name}** (\`${t.slug}\`) — ${t.short_description || "No description"} [${t.category}]`)
+      .join("\n");
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: `# NexusBloom Tools\n\nAvailable tools: ${tools.length}\n\n${summary}\n\n---\nTo inspect a tool's schema, call with \`command: "schema"\` and its \`slug\`.\nTo run a tool, call with \`command: "run"\`, its \`slug\`, and matching \`params\`.`,
+        },
+        {
+          type: "resource",
+          resource: {
+            text: JSON.stringify(tools, null, 2),
+            uri: "data:application/json,",
+            mimeType: "application/json",
+          },
+        },
+      ],
+    };
+  }
+
+  // ---- COMMAND: schema ----
+  if (command === "schema") {
+    const slug = args?.slug;
+    if (!slug) {
+      return {
+        content: [{ type: "text", text: "Missing required parameter: 'slug'" }],
+        isError: true,
+      };
+    }
+
+    const schema = await fetchToolSchema(slug);
+    if (!schema) {
+      return {
+        content: [{ type: "text", text: `Tool "${slug}" not found. Use 'list' to see available tools.` }],
+        isError: true,
+      };
+    }
+
+    const inputProps = schema.input_schema?.properties || {};
+    const requiredFields = schema.input_schema?.required || [];
+    const paramDocs = Object.entries(inputProps)
+      .map(([key, prop]) => {
+        const req = requiredFields.includes(key) ? " (required)" : "";
+        const def = prop.default !== undefined ? ` (default: ${JSON.stringify(prop.default)})` : "";
+        const enum_ = prop.enum ? ` [${prop.enum.join(", ")}]` : "";
+        return `  • \`${key}\`: ${prop.type || "any"}${req}${def}${enum_} — ${prop.description || ""}`;
+      })
+      .join("\n");
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: `# ${schema.icon} ${schema.name}\n\n**Slug:** \`${schema.slug}\`\n**Description:** ${schema.description}\n**Category:** ${schema.category || "Uncategorized"}\n**Price:** ${schema.price_type}\n**Version:** ${schema.version}\n\n## Input Parameters\n${paramDocs || "  _(no parameters)_"}\n\nTo run this tool, call with \`command: "run"\`, \`slug: "${schema.slug}"\`, and \`params\` matching the above schema.`,
+        },
+        {
+          type: "resource",
+          resource: {
+            text: JSON.stringify(schema, null, 2),
+            uri: "data:application/json,",
+            mimeType: "application/json",
+          },
+        },
+      ],
+    };
+  }
+
+  // ---- COMMAND: run ----
+  if (command === "run") {
+    const slug = args?.slug;
+    const params = args?.params || {};
+
+    if (!slug) {
+      return {
+        content: [{ type: "text", text: "Missing required parameter: 'slug'" }],
+        isError: true,
+      };
+    }
+
+    try {
+      const result = await executeTool(slug, params);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `# Tool Result: ${slug}\n\n**Execution:** ${result.execution}\n\`\`\`json\n${JSON.stringify(result.data, null, 2)}\n\`\`\``,
+          },
+          {
+            type: "resource",
+            resource: {
+              text: JSON.stringify(result, null, 2),
+              uri: "data:application/json,",
+              mimeType: "application/json",
+            },
+          },
+        ],
+      };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: `Error executing "${slug}": ${err.message}` }],
+        isError: true,
+      };
+    }
+  }
+});
+
+// ---- 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}`);
+      }
+    } catch (err) {
+      console.error(`WARNING: Could not reach API at ${API_URL}: ${err.message}`);
+    }
+
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("NexusBloom MCP server running on stdio");
+  } catch (err) {
+    console.error("Fatal error:", err);
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@nexusbloom/mcp-server",
+  "version": "1.0.0",
+  "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",
+  "bin": {
+    "nexusbloom-mcp": "index.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.8.0"
+  }
+}