storkai 1.0.0

package/README.md

@@ -0,0 +1,90 @@
+# Stork MCP — The MCP Server for MCP Servers
+
+Search, discover, evaluate, and configure MCP servers from inside your IDE. Install once, find any MCP server instantly.
+
+**[stork.ai/mcp](https://www.stork.ai/mcp)**
+
+## Add to your MCP client in 30 seconds
+
+### Cursor
+
+Add to `~/.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "stork": {
+      "command": "npx",
+      "args": ["-y", "storkai"]
+    }
+  }
+}
+```
+
+### Claude Desktop
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+  "mcpServers": {
+    "stork": {
+      "command": "npx",
+      "args": ["-y", "storkai"]
+    }
+  }
+}
+```
+
+### Claude Code
+
+```bash
+claude mcp add stork -- npx -y storkai
+```
+
+### VS Code
+
+Add to `~/.vscode/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "stork": {
+      "command": "npx",
+      "args": ["-y", "storkai"]
+    }
+  }
+}
+```
+
+## What can you do with Stork?
+
+Once installed, just ask your AI assistant:
+
+- "Find me an MCP server that can manage Jira tickets"
+- "Show me MCP servers for database queries"
+- "Get me the install config for the Postgres MCP server for Cursor"
+- "Compare the GitHub and GitLab MCP servers"
+- "What MCP servers are available for cloud infrastructure?"
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `stork_search` | Find MCP servers by natural language description |
+| `stork_server_details` | Get full details about a specific MCP server |
+| `stork_get_install_config` | Get ready-to-paste config for your IDE |
+| `stork_compare` | Compare 2-5 MCP servers side by side |
+| `stork_list_filters` | Browse available categories and filters |
+| `stork_submit` | Submit a new MCP server to the registry |
+
+## Why Stork?
+
+- **One install, all MCP servers**: Search thousands of MCP servers without leaving your IDE
+- **Ready-to-paste configs**: Get correct JSON config for Cursor, Claude, VS Code, and more
+- **Trust signals**: See maintenance status, GitHub stars, downloads, and security scores
+- **Tool inventory**: Know exactly what tools each server exposes before installing
+
+## License
+
+MIT

package/bin/storkai.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+/**
+ * Stork MCP — The MCP server for MCP servers.
+ *
+ * Search, discover, evaluate, and configure MCP servers from inside your IDE.
+ * Install once: npx storkai
+ *
+ * https://www.stork.ai/mcp
+ */
+
+import process from "node:process";
+import { ConvexHttpClient } from "convex/browser";
+
+const SERVER_NAME = "storkai";
+const SERVER_VERSION = "1.0.0";
+const CONVEX_URL = "https://expert-egret-407.convex.cloud";
+
+const client = new ConvexHttpClient(process.env.STORK_CONVEX_URL || CONVEX_URL);
+
+let stdinBuffer = Buffer.alloc(0);
+
+function writeMessage(obj) {
+  const json = JSON.stringify(obj);
+  process.stdout.write(`Content-Length: ${Buffer.byteLength(json, "utf8")}\r\n\r\n`);
+  process.stdout.write(json);
+}
+
+function parseOneMessage(buffer) {
+  const headerEnd = buffer.indexOf("\r\n\r\n");
+  if (headerEnd === -1) return null;
+  const match = buffer.slice(0, headerEnd).toString("utf8").match(/Content-Length:\s*(\d+)/i);
+  if (!match) throw new Error("Missing Content-Length header");
+  const length = Number(match[1]);
+  const bodyStart = headerEnd + 4;
+  if (buffer.length < bodyStart + length) return null;
+  const body = buffer.slice(bodyStart, bodyStart + length).toString("utf8");
+  return { message: JSON.parse(body), rest: buffer.slice(bodyStart + length) };
+}
+
+function rpcError(id, code, message, data) {
+  return { jsonrpc: "2.0", id: id ?? null, error: { code, message, ...(data !== undefined ? { data } : {}) } };
+}
+
+function rpcResult(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+
+function obj(v) {
+  return v && typeof v === "object" && !Array.isArray(v) ? v : {};
+}
+
+function fmt(v) {
+  try { return JSON.stringify(v, null, 2); } catch { return String(v); }
+}
+
+function fmtSearch(data) {
+  if (!data?.results?.length) return "No MCP servers found. Try different keywords or use stork_list_filters to browse categories.";
+  const lines = [`Found ${data.results.length} MCP server(s):\n`];
+  for (const [i, r] of data.results.entries()) {
+    lines.push(`${i + 1}. **${r.name}** (${r.slug})`);
+    lines.push(`   ${r.summary}`);
+    if (r.trustScore != null) lines.push(`   Trust Score: ${r.trustScore}/100`);
+    if (r.tools.length) lines.push(`   Tools: ${r.tools.slice(0, 5).map(t => t.name).join(", ")}${r.tools.length > 5 ? ` (+${r.tools.length - 5} more)` : ""}`);
+    if (r.transportTypes.length) lines.push(`   Transport: ${r.transportTypes.join(", ")}`);
+    if (r.installCommand) lines.push(`   Install: ${r.installCommand}`);
+    if (r.authSummary) lines.push(`   Auth: ${r.authSummary}`);
+    if (r.npmPackage) lines.push(`   npm: ${r.npmPackage}`);
+    lines.push(`   Homepage: ${r.homepageUrl}`, "");
+  }
+  lines.push("Use stork_server_details for full info, or stork_get_install_config for ready-to-paste config.");
+  return lines.join("\n");
+}
+
+function fmtDetails(d) {
+  if (!d) return "Server not found.";
+  const l = [`# ${d.name}\n`, d.description || d.summary, ""];
+  if (d.trustScore != null) l.push(`**Trust Score**: ${d.trustScore}/100`);
+  l.push(`**Category**: ${d.primaryCategory}`);
+  if (d.transportTypes?.length) l.push(`**Transport**: ${d.transportTypes.join(", ")}`);
+  if (d.license) l.push(`**License**: ${d.license}`);
+  if (d.npmPackage) l.push(`**npm**: ${d.npmPackage}`);
+  if (d.installCommand) l.push(`**Install**: \`${d.installCommand}\``);
+  if (d.authSummary) l.push(`**Auth**: ${d.authSummary}`);
+  l.push(`**Homepage**: ${d.homepageUrl}`);
+  if (d.repoUrl) l.push(`**Repository**: ${d.repoUrl}`);
+  if (d.tools?.length) { l.push("\n## Tools"); for (const t of d.tools) l.push(`- **${t.name}**${t.description ? `: ${t.description}` : ""}`); }
+  l.push("\n---\nUse stork_get_install_config for ready-to-paste config.");
+  return l.join("\n");
+}
+
+function fmtConfig(d) {
+  if (d?.error) return `Error: ${d.error}`;
+  const l = [`# Install ${d.serverName} for ${d.client}\n`, d.instructions, "", "```json", d.configJson, "```"];
+  if (d.authSummary) l.push("", `**Auth required**: ${d.authSummary}`);
+  if (d.docsUrl) l.push(`**Documentation**: ${d.docsUrl}`);
+  return l.join("\n");
+}
+
+function fmtCompare(d) {
+  if (d?.error) return `Error: ${d.error}`;
+  if (!d?.comparison?.length) return "No servers to compare.";
+  const l = ["# MCP Server Comparison\n"];
+  for (const s of d.comparison) {
+    l.push(`## ${s.name} (${s.slug})`);
+    l.push(`- ${s.summary}`);
+    if (s.trustScore != null) l.push(`- Trust: ${s.trustScore}/100`);
+    l.push(`- Tools (${s.toolCount}): ${s.tools.slice(0, 8).join(", ") || "none"}`);
+    l.push(`- Transport: ${s.transportTypes.join(", ") || "stdio"}`);
+    l.push(`- License: ${s.license}`);
+    if (s.npmPackage) l.push(`- npm: ${s.npmPackage}`);
+    l.push(`- Homepage: ${s.homepageUrl}`, "");
+  }
+  return l.join("\n");
+}
+
+const tools = [
+  { name: "stork_search", description: "Search for MCP servers by natural language. Example: 'manage Jira tickets' or 'query Postgres databases'. Returns top matches with trust scores, tools, and install commands.", inputSchema: { type: "object", required: ["query"], properties: { query: { type: "string", description: "What you need the MCP server to do" }, category: { type: "string", description: "Category filter" }, transport: { type: "string", enum: ["stdio", "sse", "streamable-http"], description: "Transport filter" }, limit: { type: "number", minimum: 1, maximum: 10, description: "Max results (default 3)" } } },
+    handler: async (a) => { const args = { query: String(a.query || ""), category: a.category || undefined, transport: a.transport || undefined, limit: typeof a.limit === "number" ? a.limit : undefined }; try { return fmtSearch(await client.action("mcpDiscoveryActions:semanticSearchServers", args)); } catch { return fmtSearch(await client.query("mcpDiscovery:searchServers", args)); } } },
+  { name: "stork_server_details", description: "Get full details about an MCP server: tools, auth, trust scores, health, and more. Use the slug from search results.", inputSchema: { type: "object", required: ["slug"], properties: { slug: { type: "string", description: "Server slug" } } },
+    handler: async (a) => fmtDetails(await client.query("mcpDiscovery:getServerDetails", { slug: String(a.slug) })) },
+  { name: "stork_get_install_config", description: "Get ready-to-paste JSON config for installing an MCP server in your IDE. Supports cursor, claude-desktop, claude-code, vscode, and zed.", inputSchema: { type: "object", required: ["slug", "client"], properties: { slug: { type: "string", description: "Server slug" }, client: { type: "string", enum: ["cursor", "claude-desktop", "claude-code", "vscode", "zed"], description: "Target IDE" } } },
+    handler: async (a) => fmtConfig(await client.query("mcpDiscovery:getInstallConfig", { slug: String(a.slug), client: String(a.client) })) },
+  { name: "stork_compare", description: "Compare 2-5 MCP servers side by side on tools, trust, transport, auth, and more.", inputSchema: { type: "object", required: ["slugs"], properties: { slugs: { type: "array", items: { type: "string" }, minItems: 2, maxItems: 5, description: "Server slugs to compare" } } },
+    handler: async (a) => fmtCompare(await client.query("mcpDiscovery:compareServers", { slugs: Array.isArray(a.slugs) ? a.slugs.map(String) : [] })) },
+  { name: "stork_list_filters", description: "List available categories and hosting filters with server counts.", inputSchema: { type: "object", properties: {} },
+    handler: async () => { const r = await client.query("mcpServers:listServerFilters", {}); const l = ["# Available Filters\n"]; if (r?.categories?.length) { l.push("## Categories"); for (const c of r.categories) l.push(`- ${c.id} (${c.count})`); } if (r?.hosting?.length) { l.push("\n## Hosting"); for (const h of r.hosting) l.push(`- ${h.id} (${h.count})`); } return l.join("\n"); } },
+  { name: "stork_submit", description: "Submit a new MCP server to Stork. Provide a GitHub repo URL or npm package name.", inputSchema: { type: "object", required: ["url"], properties: { url: { type: "string", description: "GitHub repo URL or npm package" }, name: { type: "string", description: "Display name" }, description: { type: "string", description: "What the server does" } } },
+    handler: async (a) => `Submission received for: ${a.url}\n\nTo complete registration, visit: https://www.stork.ai/mcp/submit\nYour server will be auto-enriched with metadata, tools, and trust signals.` },
+];
+
+const toolMap = new Map(tools.map(t => [t.name, t]));
+
+async function handle(msg) {
+  const { id, method, params } = msg;
+  if (method === "initialize") return rpcResult(id, { protocolVersion: "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: SERVER_NAME, version: SERVER_VERSION } });
+  if (method === "tools/list") return rpcResult(id, { tools: tools.map(t => ({ name: t.name, description: t.description, inputSchema: t.inputSchema })) });
+  if (method === "tools/call") {
+    const p = obj(params);
+    const tool = toolMap.get(String(p.name ?? ""));
+    if (!tool) return rpcResult(id, { content: [{ type: "text", text: `Unknown tool: ${p.name}` }], isError: true });
+    try {
+      const result = await tool.handler(obj(p.arguments));
+      return rpcResult(id, { content: [{ type: "text", text: typeof result === "string" ? result : fmt(result) }] });
+    } catch (err) {
+      return rpcResult(id, { content: [{ type: "text", text: `Error: ${err?.message ?? String(err)}` }], isError: true });
+    }
+  }
+  if (method === "notifications/initialized" || method === "initialized") return null;
+  return rpcError(id, -32601, `Method not found: ${method}`);
+}
+
+process.stdin.on("data", async (chunk) => {
+  stdinBuffer = Buffer.concat([stdinBuffer, chunk]);
+  while (true) {
+    let parsed;
+    try { parsed = parseOneMessage(stdinBuffer); } catch (err) {
+      writeMessage(rpcError(null, -32700, "Parse error", err?.message));
+      stdinBuffer = Buffer.alloc(0);
+      return;
+    }
+    if (!parsed) return;
+    stdinBuffer = parsed.rest;
+    const msg = parsed.message;
+    if (!msg || typeof msg !== "object" || msg.jsonrpc !== "2.0" || !("method" in msg)) {
+      writeMessage(rpcError(msg?.id ?? null, -32600, "Invalid Request"));
+      continue;
+    }
+    if (!("id" in msg)) { try { await handle(msg); } catch {} continue; }
+    try { const r = await handle(msg); if (r) writeMessage(r); }
+    catch (err) { writeMessage(rpcError(msg.id ?? null, -32603, "Internal error", err?.message)); }
+  }
+});
+
+process.stdin.on("end", () => process.exit(0));

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "storkai",
+  "version": "1.0.0",
+  "description": "The MCP server for MCP servers. Search, discover, and configure MCP servers from inside your IDE.",
+  "type": "module",
+  "bin": {
+    "storkai": "bin/storkai.js"
+  },
+  "files": [
+    "bin/",
+    "README.md"
+  ],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "mcp-server",
+    "ai-tools",
+    "stork",
+    "storkai",
+    "discovery",
+    "registry",
+    "cursor",
+    "claude",
+    "vscode"
+  ],
+  "author": "Stork.AI",
+  "license": "MIT",
+  "homepage": "https://www.stork.ai/mcp",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/stork-ai/storkai"
+  },
+  "dependencies": {
+    "convex": "^1.31.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}