@mr-aftab-ahmad-khan/create-mcp-server 0.1.0

package/dist/index.cjs

@@ -0,0 +1,760 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  TEMPLATES: () => TEMPLATES,
+  scaffold: () => scaffold
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/scaffold.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+
+// src/templates/common.ts
+var TS_TSCONFIG = {
+  path: "tsconfig.json",
+  contents: JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        moduleResolution: "Bundler",
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        declaration: false,
+        outDir: "dist"
+      },
+      include: ["src/**/*"]
+    },
+    null,
+    2
+  ) + "\n"
+};
+function packageJson(opts, deps = {}) {
+  const isTs = opts.language === "typescript";
+  return {
+    path: "package.json",
+    contents: JSON.stringify(
+      {
+        name: opts.name,
+        version: "0.1.0",
+        private: true,
+        type: "module",
+        main: isTs ? "dist/index.js" : "src/index.js",
+        scripts: {
+          start: isTs ? "node dist/index.js" : "node src/index.js",
+          ...isTs ? { build: "tsc", dev: "tsx watch src/index.ts" } : {}
+        },
+        dependencies: {
+          "@modelcontextprotocol/sdk": "^1.0.0",
+          zod: "^3.22.4",
+          ...deps
+        },
+        ...isTs ? {
+          devDependencies: {
+            "@types/node": "^20.11.0",
+            tsx: "^4.7.0",
+            typescript: "^5.4.0"
+          }
+        } : {}
+      },
+      null,
+      2
+    ) + "\n"
+  };
+}
+function gitignore() {
+  return {
+    path: ".gitignore",
+    contents: ["node_modules", "dist", ".env", "*.log", ".DS_Store", ""].join("\n")
+  };
+}
+function envExample(vars) {
+  const lines = [
+    "# Environment variables for this MCP server",
+    ...vars.map((v) => `${v.name}=  # ${v.description}`),
+    ""
+  ];
+  return { path: ".env.example", contents: lines.join("\n") };
+}
+function authMiddleware(opts) {
+  if (!opts.auth) return "";
+  return `
+function requireAuth(extra: { request?: { headers?: Record<string, string> } }): void {
+  const expected = process.env.MCP_API_KEY;
+  if (!expected) return;
+  const provided = extra.request?.headers?.["x-api-key"];
+  if (provided !== expected) throw new Error("Unauthorized");
+}
+`.trim();
+}
+function readme(opts, extra) {
+  const bin = opts.language === "typescript" ? "node dist/index.js" : "node src/index.js";
+  const cmd = opts.transport === "stdio" ? bin : `${bin} --port 8080`;
+  return {
+    path: "README.md",
+    contents: `# ${opts.name}
+
+An MCP server scaffolded by \`create-mcp-server\`.
+
+## Run
+
+\`\`\`bash
+cp .env.example .env
+# fill in values
+npm install
+${opts.language === "typescript" ? "npm run build\n" : ""}npm start
+\`\`\`
+
+## Claude Desktop config
+
+\`\`\`json
+{
+  "mcpServers": {
+    "${opts.name}": {
+      "command": "${bin.split(" ")[0]}",
+      "args": ${JSON.stringify(bin.split(" ").slice(1))},
+      "env": {}
+    }
+  }
+}
+\`\`\`
+
+${extra}
+
+> Generated by \`create-mcp-server\`. Replace this README with your own.
+`
+  };
+}
+
+// src/templates/blank.ts
+var blankIndexTs = (auth) => `
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  type Tool,
+} from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+
+${auth ? authMiddleware({ auth: true, name: "", template: "blank", transport: "stdio", language: "typescript" }) : ""}
+
+const server = new Server(
+  { name: "blank-mcp-server", version: "0.1.0" },
+  { capabilities: { tools: {} } },
+);
+
+const TOOLS: Tool[] = [
+  {
+    name: "echo",
+    description: "Returns whatever message you send. The simplest possible tool.",
+    inputSchema: {
+      type: "object",
+      properties: { message: { type: "string" } },
+      required: ["message"],
+    },
+  },
+];
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+
+server.setRequestHandler(CallToolRequestSchema, async (request${auth ? ", extra" : ""}) => {
+  ${auth ? "requireAuth(extra as any);" : ""}
+  if (request.params.name === "echo") {
+    const args = z.object({ message: z.string() }).parse(request.params.arguments);
+    return { content: [{ type: "text", text: args.message }] };
+  }
+  return { content: [{ type: "text", text: "Unknown tool: " + request.params.name }], isError: true };
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error("blank-mcp-server: ready");
+`.trim() + "\n";
+var blankTemplate = {
+  name: "blank",
+  description: "Minimal MCP server with one example tool and explanatory comments.",
+  envVars: [],
+  files(opts) {
+    const files = [packageJson(opts), gitignore(), envExample([])];
+    if (opts.language === "typescript") {
+      files.push(TS_TSCONFIG);
+      files.push({ path: "src/index.ts", contents: blankIndexTs(opts.auth) });
+    } else {
+      files.push({
+        path: "src/index.js",
+        contents: blankIndexTs(opts.auth).replace(/: \w+(\[\])?/g, "").replace(/import type[\s\S]+?from[^;]+;\n/g, "")
+      });
+    }
+    files.push(
+      readme(opts, `
+## Tools
+
+- \`echo\` \u2014 echoes back the supplied \`message\`.
+
+## Adding more tools
+
+1. Append to the \`TOOLS\` array with a JSON Schema for inputs.
+2. Add a branch to the \`CallToolRequestSchema\` handler returning \`{ content: [...] }\`.
+`)
+    );
+    return files;
+  }
+};
+
+// src/templates/postgres.ts
+var postgresIndex = (auth) => `
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  type Tool,
+} from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import pg from "pg";
+
+const { Pool } = pg;
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+
+${auth ? authMiddleware({ auth: true, name: "", template: "postgres", transport: "stdio", language: "typescript" }) : ""}
+
+const server = new Server(
+  { name: "postgres-mcp", version: "0.1.0" },
+  { capabilities: { tools: {} } },
+);
+
+const TOOLS: Tool[] = [
+  {
+    name: "query",
+    description: "Run a read-only SQL query with bound parameters",
+    inputSchema: {
+      type: "object",
+      properties: { sql: { type: "string" }, params: { type: "array", items: {} } },
+      required: ["sql"],
+    },
+  },
+  {
+    name: "list_tables",
+    description: "List all tables in the public schema",
+    inputSchema: { type: "object", properties: {} },
+  },
+  {
+    name: "describe_table",
+    description: "Describe columns and types of a given table",
+    inputSchema: {
+      type: "object",
+      properties: { table: { type: "string" } },
+      required: ["table"],
+    },
+  },
+  {
+    name: "insert",
+    description: "Insert a row into the named table",
+    inputSchema: {
+      type: "object",
+      properties: { table: { type: "string" }, row: { type: "object" } },
+      required: ["table", "row"],
+    },
+  },
+  {
+    name: "update",
+    description: "Update rows in the named table matching a where clause (parameterised)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        table: { type: "string" },
+        set: { type: "object" },
+        where: { type: "object" },
+      },
+      required: ["table", "set", "where"],
+    },
+  },
+];
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+
+server.setRequestHandler(CallToolRequestSchema, async (request${auth ? ", extra" : ""}) => {
+  ${auth ? "requireAuth(extra as any);" : ""}
+  try {
+    if (request.params.name === "query") {
+      const args = z.object({ sql: z.string(), params: z.array(z.unknown()).optional() }).parse(request.params.arguments);
+      const res = await pool.query(args.sql, args.params as unknown[] | undefined);
+      return { content: [{ type: "text", text: JSON.stringify({ rowCount: res.rowCount, rows: res.rows }, null, 2) }] };
+    }
+    if (request.params.name === "list_tables") {
+      const res = await pool.query("SELECT tablename FROM pg_catalog.pg_tables WHERE schemaname = 'public'");
+      return { content: [{ type: "text", text: JSON.stringify(res.rows, null, 2) }] };
+    }
+    if (request.params.name === "describe_table") {
+      const args = z.object({ table: z.string() }).parse(request.params.arguments);
+      const res = await pool.query(
+        "SELECT column_name, data_type, is_nullable FROM information_schema.columns WHERE table_schema='public' AND table_name=$1 ORDER BY ordinal_position",
+        [args.table],
+      );
+      return { content: [{ type: "text", text: JSON.stringify(res.rows, null, 2) }] };
+    }
+    if (request.params.name === "insert") {
+      const args = z.object({ table: z.string(), row: z.record(z.unknown()) }).parse(request.params.arguments);
+      const cols = Object.keys(args.row);
+      const placeholders = cols.map((_, i) => "$" + (i + 1)).join(", ");
+      const sql = "INSERT INTO " + JSON.stringify(args.table).slice(1, -1) + " (" + cols.map((c) => '"' + c + '"').join(", ") + ") VALUES (" + placeholders + ") RETURNING *";
+      const res = await pool.query(sql, cols.map((c) => args.row[c]));
+      return { content: [{ type: "text", text: JSON.stringify(res.rows[0], null, 2) }] };
+    }
+    if (request.params.name === "update") {
+      const args = z.object({ table: z.string(), set: z.record(z.unknown()), where: z.record(z.unknown()) }).parse(request.params.arguments);
+      const setKeys = Object.keys(args.set);
+      const whereKeys = Object.keys(args.where);
+      const setSql = setKeys.map((k, i) => '"' + k + '" = $' + (i + 1)).join(", ");
+      const whereSql = whereKeys.map((k, i) => '"' + k + '" = $' + (i + 1 + setKeys.length)).join(" AND ");
+      const sql = "UPDATE " + JSON.stringify(args.table).slice(1, -1) + " SET " + setSql + " WHERE " + whereSql + " RETURNING *";
+      const params = [...setKeys.map((k) => args.set[k]), ...whereKeys.map((k) => args.where[k])];
+      const res = await pool.query(sql, params);
+      return { content: [{ type: "text", text: JSON.stringify({ updated: res.rowCount, rows: res.rows }, null, 2) }] };
+    }
+    return { content: [{ type: "text", text: "Unknown tool" }], isError: true };
+  } catch (err) {
+    return { content: [{ type: "text", text: String(err) }], isError: true };
+  }
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error("postgres-mcp: connected");
+`.trim() + "\n";
+var postgresTemplate = {
+  name: "postgres",
+  description: "MCP server backed by Postgres with query, list_tables, describe_table, insert, update tools.",
+  envVars: [
+    { name: "DATABASE_URL", description: "Postgres connection string e.g. postgres://user:pass@host:5432/db" }
+  ],
+  files(opts) {
+    const files = [
+      packageJson(opts, { pg: "^8.11.3" }),
+      gitignore(),
+      envExample(this.envVars)
+    ];
+    if (opts.language === "typescript") {
+      files.push(TS_TSCONFIG);
+      files.push({ path: "src/index.ts", contents: postgresIndex(opts.auth) });
+    } else {
+      files.push({
+        path: "src/index.js",
+        contents: postgresIndex(opts.auth).replace(/: \w+(\[\])?/g, "").replace(/import type[\s\S]+?from[^;]+;\n/g, "")
+      });
+    }
+    files.push(
+      readme(opts, `
+## Tools
+
+- \`query\` \u2014 run an arbitrary SQL query with bound parameters
+- \`list_tables\` \u2014 list public-schema tables
+- \`describe_table\` \u2014 describe columns of a table
+- \`insert\` \u2014 insert a row into a table
+- \`update\` \u2014 update rows matching a where clause
+`)
+    );
+    return files;
+  }
+};
+
+// src/templates/stripe.ts
+var stripeIndex = (auth) => `
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  type Tool,
+} from "@modelcontextprotocol/sdk/types.js";
+import Stripe from "stripe";
+import { z } from "zod";
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY ?? "");
+
+${auth ? authMiddleware({ auth: true, name: "", template: "stripe", transport: "stdio", language: "typescript" }) : ""}
+
+const server = new Server({ name: "stripe-mcp", version: "0.1.0" }, { capabilities: { tools: {} } });
+
+const TOOLS: Tool[] = [
+  { name: "list_customers", description: "List Stripe customers", inputSchema: { type: "object", properties: { limit: { type: "number" } } } },
+  { name: "get_customer", description: "Get a customer by id", inputSchema: { type: "object", properties: { id: { type: "string" } }, required: ["id"] } },
+  { name: "list_invoices", description: "List recent invoices", inputSchema: { type: "object", properties: { limit: { type: "number" } } } },
+  {
+    name: "create_payment_link",
+    description: "Create a Stripe payment link for a price",
+    inputSchema: { type: "object", properties: { price: { type: "string" }, quantity: { type: "number" } }, required: ["price"] },
+  },
+  { name: "get_balance", description: "Get the current Stripe balance", inputSchema: { type: "object", properties: {} } },
+];
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+
+server.setRequestHandler(CallToolRequestSchema, async (request${auth ? ", extra" : ""}) => {
+  ${auth ? "requireAuth(extra as any);" : ""}
+  try {
+    if (request.params.name === "list_customers") {
+      const args = z.object({ limit: z.number().optional() }).parse(request.params.arguments ?? {});
+      const res = await stripe.customers.list({ limit: args.limit ?? 10 });
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+    if (request.params.name === "get_customer") {
+      const args = z.object({ id: z.string() }).parse(request.params.arguments);
+      const c = await stripe.customers.retrieve(args.id);
+      return { content: [{ type: "text", text: JSON.stringify(c, null, 2) }] };
+    }
+    if (request.params.name === "list_invoices") {
+      const args = z.object({ limit: z.number().optional() }).parse(request.params.arguments ?? {});
+      const res = await stripe.invoices.list({ limit: args.limit ?? 10 });
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+    if (request.params.name === "create_payment_link") {
+      const args = z.object({ price: z.string(), quantity: z.number().default(1) }).parse(request.params.arguments);
+      const link = await stripe.paymentLinks.create({ line_items: [{ price: args.price, quantity: args.quantity }] });
+      return { content: [{ type: "text", text: JSON.stringify(link, null, 2) }] };
+    }
+    if (request.params.name === "get_balance") {
+      const b = await stripe.balance.retrieve();
+      return { content: [{ type: "text", text: JSON.stringify(b, null, 2) }] };
+    }
+    return { content: [{ type: "text", text: "Unknown tool" }], isError: true };
+  } catch (err) {
+    return { content: [{ type: "text", text: String(err) }], isError: true };
+  }
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error("stripe-mcp: connected");
+`.trim() + "\n";
+var stripeTemplate = {
+  name: "stripe",
+  description: "Stripe customer / invoice / payment link tools via the official Stripe SDK.",
+  envVars: [{ name: "STRIPE_SECRET_KEY", description: "Stripe secret key (sk_test_... or sk_live_...)" }],
+  files(opts) {
+    const files = [
+      packageJson(opts, { stripe: "^14.20.0" }),
+      gitignore(),
+      envExample(this.envVars)
+    ];
+    if (opts.language === "typescript") {
+      files.push(TS_TSCONFIG);
+      files.push({ path: "src/index.ts", contents: stripeIndex(opts.auth) });
+    } else {
+      files.push({
+        path: "src/index.js",
+        contents: stripeIndex(opts.auth).replace(/: \w+(\[\])?/g, "").replace(/import type[\s\S]+?from[^;]+;\n/g, "")
+      });
+    }
+    files.push(
+      readme(opts, `
+## Tools
+
+- \`list_customers\`, \`get_customer\` \u2014 customer reads
+- \`list_invoices\` \u2014 invoice reads
+- \`create_payment_link\` \u2014 create a Stripe payment link
+- \`get_balance\` \u2014 current balance
+`)
+    );
+    return files;
+  }
+};
+
+// src/templates/filesystem.ts
+var fsIndex = (auth) => `
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  type Tool,
+} from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { readFile, writeFile, readdir, stat } from "node:fs/promises";
+import { join, resolve, sep } from "node:path";
+
+const ROOT = resolve(process.env.SANDBOX_ROOT ?? process.cwd());
+
+function safePath(p: string): string {
+  const abs = resolve(ROOT, p);
+  if (!abs.startsWith(ROOT + sep) && abs !== ROOT) throw new Error("Path escapes sandbox");
+  return abs;
+}
+
+${auth ? authMiddleware({ auth: true, name: "", template: "filesystem", transport: "stdio", language: "typescript" }) : ""}
+
+const server = new Server({ name: "filesystem-mcp", version: "0.1.0" }, { capabilities: { tools: {} } });
+
+const TOOLS: Tool[] = [
+  { name: "read_file", description: "Read a UTF-8 file", inputSchema: { type: "object", properties: { path: { type: "string" } }, required: ["path"] } },
+  { name: "write_file", description: "Write a UTF-8 file", inputSchema: { type: "object", properties: { path: { type: "string" }, contents: { type: "string" } }, required: ["path", "contents"] } },
+  { name: "list_directory", description: "List a directory", inputSchema: { type: "object", properties: { path: { type: "string" } }, required: ["path"] } },
+  { name: "search_files", description: "Recursively grep files for a substring", inputSchema: { type: "object", properties: { needle: { type: "string" }, path: { type: "string" } }, required: ["needle"] } },
+  { name: "get_file_info", description: "stat a file or directory", inputSchema: { type: "object", properties: { path: { type: "string" } }, required: ["path"] } },
+];
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+
+server.setRequestHandler(CallToolRequestSchema, async (request${auth ? ", extra" : ""}) => {
+  ${auth ? "requireAuth(extra as any);" : ""}
+  try {
+    if (request.params.name === "read_file") {
+      const args = z.object({ path: z.string() }).parse(request.params.arguments);
+      const content = await readFile(safePath(args.path), "utf8");
+      return { content: [{ type: "text", text: content }] };
+    }
+    if (request.params.name === "write_file") {
+      const args = z.object({ path: z.string(), contents: z.string() }).parse(request.params.arguments);
+      await writeFile(safePath(args.path), args.contents, "utf8");
+      return { content: [{ type: "text", text: "OK" }] };
+    }
+    if (request.params.name === "list_directory") {
+      const args = z.object({ path: z.string() }).parse(request.params.arguments);
+      const entries = await readdir(safePath(args.path), { withFileTypes: true });
+      return { content: [{ type: "text", text: JSON.stringify(entries.map((e) => ({ name: e.name, dir: e.isDirectory() })), null, 2) }] };
+    }
+    if (request.params.name === "search_files") {
+      const args = z.object({ needle: z.string(), path: z.string().default(".") }).parse(request.params.arguments);
+      const hits = await search(safePath(args.path), args.needle);
+      return { content: [{ type: "text", text: JSON.stringify(hits, null, 2) }] };
+    }
+    if (request.params.name === "get_file_info") {
+      const args = z.object({ path: z.string() }).parse(request.params.arguments);
+      const s = await stat(safePath(args.path));
+      return { content: [{ type: "text", text: JSON.stringify({ size: s.size, isDir: s.isDirectory(), mtime: s.mtime }, null, 2) }] };
+    }
+    return { content: [{ type: "text", text: "Unknown tool" }], isError: true };
+  } catch (err) {
+    return { content: [{ type: "text", text: String(err) }], isError: true };
+  }
+});
+
+async function search(root: string, needle: string): Promise<{ file: string; line: number; text: string }[]> {
+  const out: { file: string; line: number; text: string }[] = [];
+  async function walk(d: string): Promise<void> {
+    const entries = await readdir(d, { withFileTypes: true });
+    for (const e of entries) {
+      const p = join(d, e.name);
+      if (e.isDirectory()) await walk(p);
+      else if (e.isFile()) {
+        try {
+          const txt = await readFile(p, "utf8");
+          const lines = txt.split(/\\r?\\n/);
+          for (let i = 0; i < lines.length; i++) {
+            const line = lines[i] ?? "";
+            if (line.includes(needle)) out.push({ file: p, line: i + 1, text: line });
+          }
+        } catch {
+          // skip binary or unreadable files
+        }
+      }
+    }
+  }
+  await walk(root);
+  return out;
+}
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error("filesystem-mcp: ready under " + ROOT);
+`.trim() + "\n";
+var filesystemTemplate = {
+  name: "filesystem",
+  description: "Sandboxed filesystem tools (read, write, list, search, stat).",
+  envVars: [{ name: "SANDBOX_ROOT", description: "Absolute path the server is allowed to read/write" }],
+  files(opts) {
+    const files = [packageJson(opts), gitignore(), envExample(this.envVars)];
+    if (opts.language === "typescript") {
+      files.push(TS_TSCONFIG);
+      files.push({ path: "src/index.ts", contents: fsIndex(opts.auth) });
+    } else {
+      files.push({
+        path: "src/index.js",
+        contents: fsIndex(opts.auth).replace(/: \w+(\[\])?/g, "").replace(/import type[\s\S]+?from[^;]+;\n/g, "")
+      });
+    }
+    files.push(readme(opts, "## Tools\n\n- read_file, write_file, list_directory, search_files, get_file_info"));
+    return files;
+  }
+};
+
+// src/templates/rest.ts
+var restIndex = (auth) => `
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  type Tool,
+} from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { readFile } from "node:fs/promises";
+
+${auth ? authMiddleware({ auth: true, name: "", template: "rest", transport: "stdio", language: "typescript" }) : ""}
+
+interface OpenApiSpec {
+  servers?: Array<{ url: string }>;
+  paths: Record<string, Record<string, { operationId?: string; summary?: string; parameters?: Array<{ name: string; in: string; required?: boolean; schema?: { type?: string } }>; requestBody?: { content?: { "application/json"?: { schema?: { type: string; properties?: Record<string, unknown> } } } } }>>;
+}
+
+const specPath = process.env.OPENAPI_SPEC_PATH ?? "openapi.json";
+const spec = JSON.parse(await readFile(specPath, "utf8")) as OpenApiSpec;
+const baseUrl = spec.servers?.[0]?.url ?? process.env.API_BASE_URL ?? "";
+
+interface ToolEntry { method: string; path: string; spec: NonNullable<OpenApiSpec["paths"]>[string][string]; }
+const toolMap = new Map<string, ToolEntry>();
+
+const TOOLS: Tool[] = [];
+for (const [route, methods] of Object.entries(spec.paths)) {
+  for (const [method, op] of Object.entries(methods)) {
+    if (!["get", "post"].includes(method)) continue;
+    const name = op.operationId ?? (method + "_" + route).replace(/[^a-zA-Z0-9_]/g, "_");
+    const props: Record<string, unknown> = {};
+    const required: string[] = [];
+    for (const p of op.parameters ?? []) {
+      props[p.name] = { type: p.schema?.type ?? "string" };
+      if (p.required) required.push(p.name);
+    }
+    const bodySchema = op.requestBody?.content?.["application/json"]?.schema;
+    if (bodySchema?.properties) {
+      for (const [k, v] of Object.entries(bodySchema.properties)) {
+        props[k] = v;
+      }
+    }
+    TOOLS.push({
+      name,
+      description: op.summary ?? (method.toUpperCase() + " " + route),
+      inputSchema: { type: "object", properties: props, required },
+    });
+    toolMap.set(name, { method, path: route, spec: op });
+  }
+}
+
+const server = new Server({ name: "rest-mcp", version: "0.1.0" }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+server.setRequestHandler(CallToolRequestSchema, async (request${auth ? ", extra" : ""}) => {
+  ${auth ? "requireAuth(extra as any);" : ""}
+  const entry = toolMap.get(request.params.name);
+  if (!entry) return { content: [{ type: "text", text: "Unknown tool" }], isError: true };
+  const args = z.record(z.unknown()).parse(request.params.arguments ?? {});
+
+  let url = baseUrl + entry.path;
+  for (const p of entry.spec.parameters ?? []) {
+    if (p.in === "path") url = url.replace("{" + p.name + "}", encodeURIComponent(String(args[p.name] ?? "")));
+  }
+  const query: string[] = [];
+  for (const p of entry.spec.parameters ?? []) {
+    if (p.in === "query" && args[p.name] !== undefined) {
+      query.push(encodeURIComponent(p.name) + "=" + encodeURIComponent(String(args[p.name])));
+    }
+  }
+  if (query.length) url += "?" + query.join("&");
+
+  const headers: Record<string, string> = { "content-type": "application/json" };
+  if (process.env.API_BEARER_TOKEN) headers.authorization = "Bearer " + process.env.API_BEARER_TOKEN;
+  if (process.env.API_KEY_HEADER && process.env.API_KEY) headers[process.env.API_KEY_HEADER] = process.env.API_KEY;
+
+  const init: RequestInit = { method: entry.method.toUpperCase(), headers };
+  if (entry.method !== "get") {
+    const bodyKeys = Object.keys(entry.spec.requestBody?.content?.["application/json"]?.schema?.properties ?? {});
+    const body: Record<string, unknown> = {};
+    for (const k of bodyKeys) if (args[k] !== undefined) body[k] = args[k];
+    init.body = JSON.stringify(body);
+  }
+  const res = await fetch(url, init);
+  const text = await res.text();
+  return { content: [{ type: "text", text }], isError: !res.ok };
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error("rest-mcp: ready (" + TOOLS.length + " tools)");
+`.trim() + "\n";
+var restTemplate = {
+  name: "rest",
+  description: "Wraps any OpenAPI 3.0 REST API as MCP tools.",
+  envVars: [
+    { name: "OPENAPI_SPEC_PATH", description: "Path to an OpenAPI 3.0 JSON file" },
+    { name: "API_BASE_URL", description: "Override servers[0].url from the spec" },
+    { name: "API_BEARER_TOKEN", description: "Optional Bearer token" },
+    { name: "API_KEY_HEADER", description: "Optional API-key header name" },
+    { name: "API_KEY", description: "Optional API-key value" }
+  ],
+  files(opts) {
+    const files = [packageJson(opts), gitignore(), envExample(this.envVars)];
+    if (opts.language === "typescript") {
+      files.push(TS_TSCONFIG);
+      files.push({ path: "src/index.ts", contents: restIndex(opts.auth) });
+    } else {
+      files.push({
+        path: "src/index.js",
+        contents: restIndex(opts.auth).replace(/: \w+(\[\])?/g, "").replace(/import type[\s\S]+?from[^;]+;\n/g, "")
+      });
+    }
+    files.push({
+      path: "openapi.json",
+      contents: JSON.stringify({
+        openapi: "3.0.0",
+        info: { title: "Example", version: "1.0.0" },
+        servers: [{ url: "https://api.example.com" }],
+        paths: {
+          "/ping": { get: { operationId: "ping", summary: "Health check" } }
+        }
+      }, null, 2) + "\n"
+    });
+    files.push(readme(opts, "## Tools\n\nAuto-generated from `openapi.json`. Replace the spec to expose your own API."));
+    return files;
+  }
+};
+
+// src/scaffold.ts
+var TEMPLATES = {
+  blank: blankTemplate,
+  postgres: postgresTemplate,
+  stripe: stripeTemplate,
+  filesystem: filesystemTemplate,
+  rest: restTemplate
+};
+function scaffold(opts) {
+  const tpl = TEMPLATES[opts.template];
+  if (!tpl) throw new Error(`Unknown template: ${opts.template}`);
+  const target = (0, import_node_path.resolve)(opts.target ?? opts.name);
+  if ((0, import_node_fs.existsSync)(target) && (0, import_node_fs.readdirSync)(target).length > 0) {
+    throw new Error(`Target directory is not empty: ${target}`);
+  }
+  (0, import_node_fs.mkdirSync)(target, { recursive: true });
+  for (const file of tpl.files(opts)) {
+    const out = (0, import_node_path.join)(target, file.path);
+    (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(out), { recursive: true });
+    (0, import_node_fs.writeFileSync)(out, file.contents, "utf8");
+  }
+  return target;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TEMPLATES,
+  scaffold
+});
+//# sourceMappingURL=index.cjs.map