create-multicast 0.1.0

package/dist/cli.js

@@ -0,0 +1,583 @@
+#!/usr/bin/env node
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { execFileSync, spawnSync } from "node:child_process";
+import { cp, readdir, readFile, writeFile, unlink, rename } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { resolve, join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const TEMPLATES_DIR = resolve(__dirname, "..", "templates", "default");
+// ── Command Helpers ──────────────────────────────────────────
+function runCommand(cmd, args, cwd) {
+    try {
+        const output = execFileSync(cmd, args, {
+            cwd,
+            stdio: ["inherit", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+        return { success: true, output: output ?? "" };
+    }
+    catch (err) {
+        const error = err;
+        const parts = [error.stdout, error.stderr, error.message].filter(Boolean);
+        return {
+            success: false,
+            output: parts.join("\n").trim() || "Unknown error",
+        };
+    }
+}
+function runCommandLive(cmd, args, cwd) {
+    try {
+        const result = spawnSync(cmd, args, {
+            cwd,
+            stdio: ["inherit", "inherit", "inherit"],
+            encoding: "utf-8",
+        });
+        return { success: result.status === 0, output: "" };
+    }
+    catch (err) {
+        const error = err;
+        return { success: false, output: error.message ?? "" };
+    }
+}
+function parseDatabaseId(output) {
+    const match = output.match(/database_id\s*=\s*"([^"]+)"/) ??
+        output.match(/"database_id"\s*:\s*"([^"]+)"/);
+    return match?.[1] ?? null;
+}
+function parseDeployUrl(output) {
+    const match = output.match(/(https:\/\/[^\s]+\.workers\.dev)/);
+    return match?.[1] ?? null;
+}
+async function processTemplates(targetDir, replacements) {
+    const entries = await readdir(targetDir, {
+        recursive: true,
+        withFileTypes: true,
+    });
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".tmpl"))
+            continue;
+        const tmplPath = join(entry.parentPath ?? entry.path, entry.name);
+        let content = await readFile(tmplPath, "utf-8");
+        for (const [key, value] of Object.entries(replacements)) {
+            content = content.replaceAll(`{{${key}}}`, value);
+        }
+        const finalPath = tmplPath.replace(/\.tmpl$/, "");
+        await writeFile(finalPath, content, "utf-8");
+        await unlink(tmplPath);
+    }
+}
+// ── MCP Config Discovery ─────────────────────────────────────
+// Scans known locations for existing MCP server configurations.
+function getMcpConfigPaths() {
+    const home = homedir();
+    const paths = [];
+    // Claude Code
+    const claudeJson = join(home, ".claude.json");
+    if (existsSync(claudeJson)) {
+        paths.push({ path: claudeJson, label: "Claude Code (~/.claude.json)" });
+    }
+    // Claude Desktop (macOS)
+    const claudeDesktopMac = join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    if (existsSync(claudeDesktopMac)) {
+        paths.push({ path: claudeDesktopMac, label: "Claude Desktop (macOS)" });
+    }
+    // Claude Desktop (Windows via WSL or native)
+    const appdata = process.env.APPDATA || join(home, "AppData", "Roaming");
+    const claudeDesktopWin = join(appdata, "Claude", "claude_desktop_config.json");
+    if (existsSync(claudeDesktopWin)) {
+        paths.push({ path: claudeDesktopWin, label: "Claude Desktop (Windows)" });
+    }
+    // Cursor
+    const cursorConfig = join(home, ".cursor", "mcp.json");
+    if (existsSync(cursorConfig)) {
+        paths.push({ path: cursorConfig, label: "Cursor (~/.cursor/mcp.json)" });
+    }
+    // VS Code (project-level)
+    const vscodeConfig = join(process.cwd(), ".vscode", "mcp.json");
+    if (existsSync(vscodeConfig)) {
+        paths.push({ path: vscodeConfig, label: "VS Code (.vscode/mcp.json)" });
+    }
+    return paths;
+}
+function classifyServer(name, config, source) {
+    // HTTP server — has a url field
+    if (typeof config.url === "string" && config.url.startsWith("http")) {
+        const server = {
+            name,
+            url: config.url,
+            transport: "http",
+            source,
+        };
+        // Try to find auth
+        if (config.headers && typeof config.headers === "object") {
+            const headers = config.headers;
+            if (headers.Authorization) {
+                server.auth = headers.Authorization;
+            }
+        }
+        return server;
+    }
+    // Check env vars for URL patterns (some stdio configs have HTTP URLs in env)
+    if (config.env && typeof config.env === "object") {
+        const env = config.env;
+        for (const [key, value] of Object.entries(env)) {
+            if (typeof value === "string" && value.startsWith("http")) {
+                // Found an HTTP URL in env — might be usable
+                const server = {
+                    name,
+                    url: value,
+                    transport: "http",
+                    source,
+                };
+                // Look for auth tokens in env
+                for (const [authKey, authVal] of Object.entries(env)) {
+                    if (typeof authVal === "string" &&
+                        (authKey.includes("KEY") ||
+                            authKey.includes("TOKEN") ||
+                            authKey.includes("SECRET") ||
+                            authKey.includes("AUTH"))) {
+                        server.auth = `Bearer ${authVal}`;
+                        break;
+                    }
+                }
+                return server;
+            }
+        }
+    }
+    // stdio server
+    return {
+        name,
+        command: typeof config.command === "string" ? config.command : "unknown",
+        transport: "stdio",
+        source,
+    };
+}
+async function discoverMcpServers() {
+    const configs = getMcpConfigPaths();
+    const servers = [];
+    const seenNames = new Set();
+    for (const { path: configPath, label } of configs) {
+        try {
+            const content = await readFile(configPath, "utf-8");
+            const parsed = JSON.parse(content);
+            const mcpServers = parsed.mcpServers || parsed.servers || {};
+            for (const [name, config] of Object.entries(mcpServers)) {
+                if (seenNames.has(name))
+                    continue; // skip duplicates across configs
+                seenNames.add(name);
+                const server = classifyServer(name, config, label);
+                servers.push(server);
+            }
+        }
+        catch {
+            // Skip unparseable configs silently
+        }
+    }
+    return servers;
+}
+// ── Main CLI ─────────────────────────────────────────────────
+async function main() {
+    p.intro(pc.bgCyan(pc.black(" create-multicast ")));
+    p.log.info(`MCP gateway for Claude.ai — one integration, all your servers, parallel execution.\n` +
+        `${pc.dim("Runs on Cloudflare Workers (free tier). Costs $0/month.")}`);
+    // Step 1: Project name
+    const argName = process.argv[2];
+    let projectName;
+    if (argName && !argName.startsWith("-")) {
+        projectName = argName;
+        p.log.info(`Project name: ${pc.cyan(projectName)}`);
+    }
+    else {
+        const nameResult = await p.text({
+            message: "What should your project be called?",
+            placeholder: "my-multicast",
+            defaultValue: "my-multicast",
+            validate: (value) => {
+                if (!value.trim())
+                    return "Project name is required";
+                if (!/^[a-z0-9-]+$/.test(value))
+                    return "Use lowercase letters, numbers, and hyphens only";
+                return undefined;
+            },
+        });
+        if (p.isCancel(nameResult)) {
+            p.cancel("Setup cancelled.");
+            process.exit(0);
+        }
+        projectName = nameResult;
+    }
+    const targetDir = resolve(process.cwd(), projectName);
+    if (existsSync(targetDir)) {
+        p.log.error(`Directory ${pc.red(projectName)} already exists.`);
+        process.exit(1);
+    }
+    // Step 2: Discover existing MCP servers
+    p.log.step("Scanning for existing MCP configurations...");
+    const discovered = await discoverMcpServers();
+    const httpServers = discovered.filter((s) => s.transport === "http");
+    const stdioServers = discovered.filter((s) => s.transport === "stdio");
+    if (discovered.length === 0) {
+        p.log.warn("No MCP configurations found on this machine.");
+        p.log.info(`You can add servers manually after setup using:\n` +
+            `  ${pc.cyan("npx wrangler secret put MCP_SERVER_MYSERVER")}`);
+    }
+    else {
+        // Display discovered servers
+        p.log.info(`Found ${pc.bold(String(discovered.length))} MCP servers:\n`);
+        for (const server of httpServers) {
+            p.log.message(`  ${pc.green("✓")} ${pc.bold(server.name)}  ${pc.dim(server.url || "")}  ${pc.cyan("[HTTP]")}  ${pc.dim(`from ${server.source}`)}`);
+        }
+        for (const server of stdioServers) {
+            p.log.message(`  ${pc.red("✗")} ${pc.bold(server.name)}  ${pc.dim(`command: ${server.command}`)}  ${pc.yellow("[stdio — skipped]")}`);
+        }
+        if (stdioServers.length > 0) {
+            p.log.info(`\n  ${pc.dim(`${stdioServers.length} stdio server(s) skipped — they run locally and can't be called from a cloud worker.`)}`);
+        }
+    }
+    // Step 3: Select servers to register
+    let selectedServers = [];
+    if (httpServers.length > 0) {
+        const selections = await p.multiselect({
+            message: "Select servers to register with Multicast:",
+            options: httpServers.map((s) => ({
+                value: s.name,
+                label: s.name,
+                hint: s.url,
+            })),
+            initialValues: httpServers.map((s) => s.name), // all selected by default
+            required: false,
+        });
+        if (p.isCancel(selections)) {
+            p.cancel("Setup cancelled.");
+            process.exit(0);
+        }
+        const selectedNames = selections;
+        // Confirm/collect auth for each selected server
+        for (const name of selectedNames) {
+            const server = httpServers.find((s) => s.name === name);
+            let auth = server.auth;
+            if (auth) {
+                const useExisting = await p.confirm({
+                    message: `${name} — found auth credentials. Use them?`,
+                    initialValue: true,
+                });
+                if (p.isCancel(useExisting)) {
+                    p.cancel("Setup cancelled.");
+                    process.exit(0);
+                }
+                if (!useExisting)
+                    auth = undefined;
+            }
+            if (!auth) {
+                const needsAuth = await p.confirm({
+                    message: `${name} — does this server require authentication?`,
+                    initialValue: false,
+                });
+                if (!p.isCancel(needsAuth) && needsAuth) {
+                    const authResult = await p.text({
+                        message: `Enter auth header for ${name}:`,
+                        placeholder: "Bearer your-token-here",
+                    });
+                    if (p.isCancel(authResult)) {
+                        p.cancel("Setup cancelled.");
+                        process.exit(0);
+                    }
+                    auth = authResult;
+                }
+            }
+            selectedServers.push({
+                name,
+                url: server.url,
+                auth: auth || undefined,
+            });
+        }
+    }
+    // Option to add servers manually
+    let addMore = true;
+    while (addMore) {
+        const shouldAdd = await p.confirm({
+            message: selectedServers.length === 0
+                ? "Add an MCP server manually?"
+                : "Add another MCP server?",
+            initialValue: selectedServers.length === 0,
+        });
+        if (p.isCancel(shouldAdd) || !shouldAdd) {
+            addMore = false;
+            break;
+        }
+        const manualName = await p.text({
+            message: "Server name:",
+            placeholder: "my-server",
+            validate: (v) => {
+                if (!v.trim())
+                    return "Name is required";
+                if (!/^[a-z0-9-]+$/.test(v))
+                    return "Use lowercase letters, numbers, and hyphens";
+                return undefined;
+            },
+        });
+        if (p.isCancel(manualName))
+            break;
+        const manualUrl = await p.text({
+            message: "Server URL (MCP endpoint):",
+            placeholder: "https://my-server.example.com/mcp",
+            validate: (v) => {
+                if (!v.startsWith("http"))
+                    return "URL must start with http:// or https://";
+                return undefined;
+            },
+        });
+        if (p.isCancel(manualUrl))
+            break;
+        const manualNeedsAuth = await p.confirm({
+            message: "Does this server require authentication?",
+            initialValue: false,
+        });
+        let manualAuth;
+        if (!p.isCancel(manualNeedsAuth) && manualNeedsAuth) {
+            const authInput = await p.text({
+                message: "Auth header value:",
+                placeholder: "Bearer your-token-here",
+            });
+            if (!p.isCancel(authInput)) {
+                manualAuth = authInput;
+            }
+        }
+        selectedServers.push({
+            name: manualName,
+            url: manualUrl,
+            auth: manualAuth,
+        });
+    }
+    if (selectedServers.length === 0) {
+        p.log.warn("No servers registered. You can add them later with:\n" +
+            `  ${pc.cyan("npx wrangler secret put MCP_SERVER_MYSERVER")}`);
+    }
+    else {
+        p.log.success(`${selectedServers.length} server(s) will be registered.`);
+    }
+    // Step 4: Scaffold project
+    const scaffoldSpinner = p.spinner();
+    scaffoldSpinner.start("Scaffolding project files...");
+    await cp(TEMPLATES_DIR, targetDir, { recursive: true });
+    const gitignorePath = join(targetDir, "gitignore");
+    if (existsSync(gitignorePath)) {
+        await rename(gitignorePath, join(targetDir, ".gitignore"));
+    }
+    await processTemplates(targetDir, {
+        PROJECT_NAME: projectName,
+        DB_ID: "PLACEHOLDER",
+    });
+    scaffoldSpinner.stop("Project scaffolded.");
+    // Step 5: Install dependencies
+    p.log.step("Installing dependencies...");
+    const installResult = runCommandLive("npm", ["install"], targetDir);
+    if (!installResult.success) {
+        p.log.warn(`npm install failed. Run manually: ${pc.cyan(`cd ${projectName} && npm install`)}`);
+    }
+    else {
+        p.log.success("Dependencies installed.");
+    }
+    // Step 6: Cloudflare setup
+    const setupCloudflare = await p.confirm({
+        message: "Set up Cloudflare? (login, create database, deploy)",
+        initialValue: true,
+    });
+    if (p.isCancel(setupCloudflare) || !setupCloudflare) {
+        printManualSteps(projectName, selectedServers);
+        p.outro(pc.green("Project created! Follow the steps above to finish setup."));
+        process.exit(0);
+    }
+    // Step 7: Wrangler login
+    const loginSpinner = p.spinner();
+    loginSpinner.start("Checking Cloudflare authentication...");
+    const whoami = runCommand("npx", ["wrangler", "whoami"], targetDir);
+    if (whoami.success && !whoami.output.includes("not authenticated")) {
+        loginSpinner.stop("Already logged in to Cloudflare.");
+    }
+    else {
+        loginSpinner.stop("Need to log in to Cloudflare.");
+        p.log.info("Opening browser for Cloudflare login...");
+        const loginResult = runCommandLive("npx", ["wrangler", "login"], targetDir);
+        if (!loginResult.success) {
+            p.log.error("Cloudflare login failed.");
+            printManualSteps(projectName, selectedServers, "login");
+            p.outro(pc.yellow("Fix the login issue and continue with the steps above."));
+            process.exit(1);
+        }
+        p.log.success("Logged in to Cloudflare.");
+    }
+    // Step 8: Create D1 database
+    const dbName = `${projectName}-db`;
+    const dbSpinner = p.spinner();
+    dbSpinner.start(`Creating D1 database "${dbName}"...`);
+    const dbResult = runCommand("npx", ["wrangler", "d1", "create", dbName], targetDir);
+    if (!dbResult.success) {
+        dbSpinner.stop(pc.red("Failed to create D1 database."));
+        p.log.error(dbResult.output);
+        printManualSteps(projectName, selectedServers, "db");
+        p.outro(pc.yellow("Fix the issue and continue with the steps above."));
+        process.exit(1);
+    }
+    const databaseId = parseDatabaseId(dbResult.output);
+    if (!databaseId) {
+        dbSpinner.stop(pc.yellow("Database created but couldn't parse database_id."));
+        p.log.warn("Check the output above and manually update wrangler.json.");
+        p.log.message(dbResult.output);
+    }
+    else {
+        dbSpinner.stop(`Database created: ${pc.cyan(databaseId)}`);
+        // Update wrangler.json with actual DB ID
+        const wranglerPath = join(targetDir, "wrangler.json");
+        let wranglerContent = await readFile(wranglerPath, "utf-8");
+        wranglerContent = wranglerContent.replace("PLACEHOLDER", databaseId);
+        await writeFile(wranglerPath, wranglerContent, "utf-8");
+        p.log.success("Updated wrangler.json with database ID.");
+    }
+    // Step 9: Run migration
+    p.log.step("Running database migration...");
+    const migrateResult = runCommandLive("npx", ["wrangler", "d1", "execute", dbName, "--remote", "--file=./migrations/0001_init.sql"], targetDir);
+    if (!migrateResult.success) {
+        p.log.warn(`Migration failed. Run manually:\n  ${pc.cyan(`cd ${projectName} && npx wrangler d1 execute ${dbName} --remote --file=./migrations/0001_init.sql`)}`);
+    }
+    else {
+        p.log.success("Database migration complete.");
+    }
+    // Step 10: Set MCP server secrets
+    if (selectedServers.length > 0) {
+        p.log.step("Setting MCP server credentials...");
+        for (const server of selectedServers) {
+            const envName = server.name.toUpperCase().replace(/-/g, "_");
+            // Set server URL
+            const urlResult = spawnSync("npx", ["wrangler", "secret", "put", `MCP_SERVER_${envName}`], {
+                cwd: targetDir,
+                input: server.url + "\n",
+                stdio: ["pipe", "inherit", "inherit"],
+                encoding: "utf-8",
+            });
+            if (urlResult.status !== 0) {
+                p.log.warn(`Failed to set URL for ${server.name}. Run manually:\n` +
+                    `  ${pc.cyan(`npx wrangler secret put MCP_SERVER_${envName}`)}`);
+            }
+            else {
+                p.log.success(`${server.name} URL set.`);
+            }
+            // Set auth if present
+            if (server.auth) {
+                const authResult = spawnSync("npx", ["wrangler", "secret", "put", `MCP_AUTH_${envName}`], {
+                    cwd: targetDir,
+                    input: server.auth + "\n",
+                    stdio: ["pipe", "inherit", "inherit"],
+                    encoding: "utf-8",
+                });
+                if (authResult.status !== 0) {
+                    p.log.warn(`Failed to set auth for ${server.name}. Run manually:\n` +
+                        `  ${pc.cyan(`npx wrangler secret put MCP_AUTH_${envName}`)}`);
+                }
+                else {
+                    p.log.success(`${server.name} auth set.`);
+                }
+            }
+        }
+    }
+    // Step 11: Deploy
+    p.log.step("Deploying to Cloudflare Workers...");
+    const deployResult = runCommand("npx", ["wrangler", "deploy"], targetDir);
+    let deployedUrl = null;
+    if (!deployResult.success) {
+        p.log.warn(`Deploy failed. Run manually: ${pc.cyan(`cd ${projectName} && npx wrangler deploy`)}`);
+        p.log.message(deployResult.output);
+    }
+    else {
+        deployedUrl = parseDeployUrl(deployResult.output);
+        if (deployedUrl) {
+            p.log.success(`Deployed to ${pc.cyan(deployedUrl)}`);
+        }
+        else {
+            p.log.success("Deployed successfully.");
+            p.log.message(deployResult.output);
+        }
+    }
+    // Step 12: Claude Code connection
+    if (deployedUrl) {
+        const mcpUrl = `${deployedUrl}/mcp`;
+        const setupClaude = await p.confirm({
+            message: "Configure Claude Code connection?",
+            initialValue: true,
+        });
+        if (!p.isCancel(setupClaude) && setupClaude) {
+            const claudeSpinner = p.spinner();
+            claudeSpinner.start("Adding MCP server to Claude Code...");
+            const claudeResult = spawnSync("claude", ["mcp", "add", "--transport", "http", "--scope", "user", "multicast", mcpUrl], {
+                stdio: ["inherit", "pipe", "pipe"],
+                encoding: "utf-8",
+            });
+            if (claudeResult.status !== 0) {
+                claudeSpinner.stop(pc.yellow("Couldn't configure Claude Code automatically."));
+                p.log.warn(`Run manually:\n` +
+                    `  ${pc.cyan(`claude mcp add --transport http --scope user multicast ${mcpUrl}`)}`);
+            }
+            else {
+                claudeSpinner.stop("Claude Code connected.");
+            }
+        }
+        // Claude.ai connection instructions
+        p.log.step(pc.bold("Connect to Claude.ai:"));
+        p.log.message(`  1. Go to ${pc.cyan("claude.ai/settings/connectors")}\n` +
+            `  2. Click ${pc.bold('"Add custom connector"')}\n` +
+            `  3. Enter URL: ${pc.cyan(mcpUrl)}\n` +
+            `  4. Click ${pc.bold("Add")} then ${pc.bold("Connect")}`);
+    }
+    // Step 13: Summary
+    p.log.step(pc.bold("Summary"));
+    const summaryLines = [
+        `  ${pc.green("✓")} Project:   ${pc.cyan(targetDir)}`,
+    ];
+    if (deployedUrl) {
+        summaryLines.push(`  ${pc.green("✓")} URL:       ${pc.cyan(deployedUrl)}`);
+        summaryLines.push(`  ${pc.green("✓")} MCP:       ${pc.cyan(deployedUrl + "/mcp")}`);
+    }
+    summaryLines.push(`  ${pc.green("✓")} Servers:   ${pc.cyan(String(selectedServers.length))} registered`);
+    for (const server of selectedServers) {
+        summaryLines.push(`    ${pc.dim("•")} ${server.name} ${pc.dim(server.url)}`);
+    }
+    summaryLines.push(`\n  ${pc.dim("Add more servers later:")}`, `  ${pc.cyan("npx wrangler secret put MCP_SERVER_NEWNAME")}`, `  ${pc.cyan("npx wrangler deploy")}`);
+    p.log.message(summaryLines.join("\n"));
+    p.outro(pc.green("Multicast is live!") +
+        pc.dim(" Use list_servers in Claude to see your connected servers."));
+}
+// ── Manual Steps ─────────────────────────────────────────────
+function printManualSteps(projectName, servers, from) {
+    const steps = [];
+    let n = 1;
+    if (!from || from === "login") {
+        steps.push(`  ${n++}. ${pc.cyan(`cd ${projectName}`)}`);
+        steps.push(`  ${n++}. ${pc.cyan("npx wrangler login")}`);
+    }
+    if (!from || from === "login" || from === "db") {
+        steps.push(`  ${n++}. ${pc.cyan(`npx wrangler d1 create ${projectName}-db`)}`);
+        steps.push(`  ${n++}. Update ${pc.bold("wrangler.json")} with the database_id`);
+        steps.push(`  ${n++}. ${pc.cyan(`npx wrangler d1 execute ${projectName}-db --remote --file=./migrations/0001_init.sql`)}`);
+    }
+    // Server secrets
+    for (const server of servers) {
+        const envName = server.name.toUpperCase().replace(/-/g, "_");
+        steps.push(`  ${n++}. ${pc.cyan(`npx wrangler secret put MCP_SERVER_${envName}`)}`);
+        steps.push(`     ${pc.dim(`Enter: ${server.url}`)}`);
+        if (server.auth) {
+            steps.push(`  ${n++}. ${pc.cyan(`npx wrangler secret put MCP_AUTH_${envName}`)}`);
+            steps.push(`     ${pc.dim("Enter your auth header")}`);
+        }
+    }
+    steps.push(`  ${n++}. ${pc.cyan("npx wrangler deploy")}`);
+    p.log.step(pc.bold("Remaining steps:"));
+    p.log.message(steps.join("\n"));
+}
+main().catch((err) => {
+    p.log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "create-multicast",
+  "version": "0.1.0",
+  "description": "Create a Multicast MCP gateway — one command to scaffold, configure, and deploy your parallel MCP server.",
+  "type": "module",
+  "bin": "./dist/cli.js",
+  "files": [
+    "dist/",
+    "templates/"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "create",
+    "multicast",
+    "mcp",
+    "claude",
+    "claude-ai",
+    "parallel",
+    "gateway",
+    "cloudflare-workers",
+    "model-context-protocol"
+  ],
+  "author": "Mayank Bohra",
+  "license": "MIT",
+  "dependencies": {
+    "@clack/prompts": "^0.9.1",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/templates/default/gitignore

@@ -0,0 +1,8 @@
+node_modules/
+dist/
+.wrangler/
+.dev.vars
+*.log
+.DS_Store
+.env
+.env.local

package/templates/default/migrations/0001_init.sql

@@ -0,0 +1,33 @@
+-- Multicast MCP Gateway - Initial Schema
+-- Stores server registry and cached tool discovery data
+
+-- Servers: registered downstream MCP servers
+-- URL + auth come from env vars (MCP_SERVER_*, MCP_AUTH_*)
+-- This table stores metadata discovered via tools/list
+CREATE TABLE IF NOT EXISTS servers (
+    name TEXT PRIMARY KEY,
+    url TEXT NOT NULL,
+    description TEXT DEFAULT '',
+    tool_count INTEGER DEFAULT 0,
+    status TEXT DEFAULT 'active',         -- active, unreachable, error
+    last_error TEXT DEFAULT NULL,
+    last_discovered_at TEXT DEFAULT NULL,
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now'))
+);
+
+-- Tools: cached tools/list responses from downstream servers
+-- Refreshed periodically (24h TTL) or on-demand
+CREATE TABLE IF NOT EXISTS tools (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    server_name TEXT NOT NULL REFERENCES servers(name) ON DELETE CASCADE,
+    tool_name TEXT NOT NULL,
+    description TEXT DEFAULT '',
+    input_schema TEXT DEFAULT '{}',
+    cached_at TEXT DEFAULT (datetime('now')),
+    UNIQUE(server_name, tool_name)
+);
+
+-- Indexes for common queries
+CREATE INDEX IF NOT EXISTS idx_tools_server ON tools(server_name);
+CREATE INDEX IF NOT EXISTS idx_servers_status ON servers(status);

package/templates/default/package.json.tmpl

@@ -0,0 +1,23 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "version": "0.1.0",
+  "description": "Multicast MCP gateway — one integration, all your MCP servers, parallel execution.",
+  "main": "src/index.ts",
+  "scripts": {
+    "dev": "wrangler dev",
+    "deploy": "wrangler deploy",
+    "db:migrate": "wrangler d1 execute {{PROJECT_NAME}}-db --local --file=./migrations/0001_init.sql",
+    "db:migrate:remote": "wrangler d1 execute {{PROJECT_NAME}}-db --remote --file=./migrations/0001_init.sql",
+    "typecheck": "tsc --noEmit"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.25.2",
+    "agents": "^0.3.6"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20250313.0",
+    "typescript": "^5.7.0",
+    "wrangler": "^4.0.0"
+  }
+}

package/templates/default/src/index.ts

@@ -0,0 +1,583 @@
+import { McpAgent } from "agents/mcp";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+
+// ── Types ────────────────────────────────────────────────────
+
+export interface Env {
+  DB: D1Database;
+  MULTICAST: DurableObjectNamespace;
+  [key: string]: unknown; // MCP_SERVER_* and MCP_AUTH_* env vars
+}
+
+interface RegisteredServer {
+  name: string;
+  url: string;
+  auth?: string;
+}
+
+interface CallResult {
+  server: string;
+  tool: string;
+  success: boolean;
+  output?: unknown;
+  error?: string;
+  duration_ms: number;
+}
+
+interface CachedTool {
+  tool_name: string;
+  description: string;
+  input_schema: string;
+}
+
+// ── Server Registry ──────────────────────────────────────────
+// Parses MCP_SERVER_* and MCP_AUTH_* env vars at request time.
+// MCP_SERVER_CONTEXT_HUB=https://... → server name: "context-hub"
+// MCP_AUTH_CONTEXT_HUB=Bearer key... → auth header for "context-hub"
+
+function getRegisteredServers(env: Env): Map<string, RegisteredServer> {
+  const servers = new Map<string, RegisteredServer>();
+
+  for (const [key, value] of Object.entries(env)) {
+    if (key.startsWith("MCP_SERVER_") && typeof value === "string") {
+      const rawName = key.replace("MCP_SERVER_", "");
+      const name = rawName.toLowerCase().replace(/_/g, "-");
+      const authKey = `MCP_AUTH_${rawName}`;
+      const auth = typeof env[authKey] === "string" ? (env[authKey] as string) : undefined;
+
+      servers.set(name, { name, url: value, auth });
+    }
+  }
+
+  return servers;
+}
+
+// ── Downstream MCP Client ────────────────────────────────────
+// Calls a single downstream MCP server via JSON-RPC over HTTP.
+
+async function callMcpServer(
+  server: RegisteredServer,
+  tool: string,
+  args: Record<string, unknown>,
+  timeoutMs: number
+): Promise<CallResult> {
+  const start = Date.now();
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+    };
+    if (server.auth) {
+      headers["Authorization"] = server.auth;
+    }
+
+    const response = await fetch(server.url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        method: "tools/call",
+        params: { name: tool, arguments: args },
+        id: crypto.randomUUID(),
+      }),
+      signal: controller.signal,
+    });
+
+    if (!response.ok) {
+      return {
+        server: server.name,
+        tool,
+        success: false,
+        error: `HTTP ${response.status}: ${response.statusText}`,
+        duration_ms: Date.now() - start,
+      };
+    }
+
+    const data = (await response.json()) as {
+      result?: unknown;
+      error?: { message?: string; code?: number };
+    };
+
+    if (data.error) {
+      return {
+        server: server.name,
+        tool,
+        success: false,
+        error: data.error.message || `JSON-RPC error ${data.error.code}`,
+        duration_ms: Date.now() - start,
+      };
+    }
+
+    return {
+      server: server.name,
+      tool,
+      success: true,
+      output: data.result,
+      duration_ms: Date.now() - start,
+    };
+  } catch (err: unknown) {
+    const message =
+      err instanceof Error
+        ? err.name === "AbortError"
+          ? `timeout after ${timeoutMs}ms`
+          : err.message
+        : "unknown error";
+
+    return {
+      server: server.name,
+      tool,
+      success: false,
+      error: message,
+      duration_ms: Date.now() - start,
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// ── Tool Discovery ───────────────────────────────────────────
+// Calls tools/list on a downstream MCP server and caches results in D1.
+
+async function discoverServerTools(
+  server: RegisteredServer,
+  db: D1Database
+): Promise<{ tool_count: number; error?: string }> {
+  try {
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+    };
+    if (server.auth) {
+      headers["Authorization"] = server.auth;
+    }
+
+    // MCP initialize handshake
+    const initResponse = await fetch(server.url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        method: "initialize",
+        params: {
+          protocolVersion: "2024-11-05",
+          capabilities: {},
+          clientInfo: { name: "multicast", version: "0.1.0" },
+        },
+        id: "init-" + crypto.randomUUID(),
+      }),
+    });
+
+    if (!initResponse.ok) {
+      // Some servers don't require initialize — try tools/list directly
+    }
+
+    // Request tools list
+    const response = await fetch(server.url, {
+      method: "POST",
+      headers: {
+        ...headers,
+        // Pass session ID from init response if available
+        ...(initResponse.headers.get("mcp-session-id")
+          ? { "mcp-session-id": initResponse.headers.get("mcp-session-id")! }
+          : {}),
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        method: "tools/list",
+        params: {},
+        id: "discover-" + crypto.randomUUID(),
+      }),
+    });
+
+    if (!response.ok) {
+      const errText = `HTTP ${response.status}`;
+      await db
+        .prepare(
+          `INSERT OR REPLACE INTO servers (name, url, status, last_error, updated_at)
+           VALUES (?, ?, 'error', ?, datetime('now'))`
+        )
+        .bind(server.name, server.url, errText)
+        .run();
+      return { tool_count: 0, error: errText };
+    }
+
+    const data = (await response.json()) as {
+      result?: { tools?: Array<{ name: string; description?: string; inputSchema?: unknown }> };
+      error?: { message?: string };
+    };
+
+    if (data.error) {
+      const errMsg = data.error.message || "tools/list failed";
+      await db
+        .prepare(
+          `INSERT OR REPLACE INTO servers (name, url, status, last_error, updated_at)
+           VALUES (?, ?, 'error', ?, datetime('now'))`
+        )
+        .bind(server.name, server.url, errMsg)
+        .run();
+      return { tool_count: 0, error: errMsg };
+    }
+
+    const tools = data.result?.tools || [];
+
+    // Clear old tools for this server
+    await db
+      .prepare("DELETE FROM tools WHERE server_name = ?")
+      .bind(server.name)
+      .run();
+
+    // Insert discovered tools
+    for (const tool of tools) {
+      await db
+        .prepare(
+          `INSERT INTO tools (server_name, tool_name, description, input_schema, cached_at)
+           VALUES (?, ?, ?, ?, datetime('now'))`
+        )
+        .bind(
+          server.name,
+          tool.name,
+          tool.description || "",
+          JSON.stringify(tool.inputSchema || {})
+        )
+        .run();
+    }
+
+    // Update server metadata
+    await db
+      .prepare(
+        `INSERT OR REPLACE INTO servers (name, url, description, tool_count, status, last_error, last_discovered_at, updated_at)
+         VALUES (?, ?, '', ?, 'active', NULL, datetime('now'), datetime('now'))`
+      )
+      .bind(server.name, server.url, tools.length)
+      .run();
+
+    return { tool_count: tools.length };
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : "discovery failed";
+    await db
+      .prepare(
+        `INSERT OR REPLACE INTO servers (name, url, status, last_error, updated_at)
+         VALUES (?, ?, 'unreachable', ?, datetime('now'))`
+      )
+      .bind(server.name, server.url, message)
+      .run();
+    return { tool_count: 0, error: message };
+  }
+}
+
+// Check if tool cache is stale (older than 24 hours)
+async function isCacheStale(db: D1Database, serverName: string): Promise<boolean> {
+  const row = await db
+    .prepare("SELECT last_discovered_at FROM servers WHERE name = ?")
+    .bind(serverName)
+    .first<{ last_discovered_at: string | null }>();
+
+  if (!row || !row.last_discovered_at) return true;
+
+  const discoveredAt = new Date(row.last_discovered_at + "Z").getTime();
+  const hoursSince = (Date.now() - discoveredAt) / (1000 * 60 * 60);
+  return hoursSince > 24;
+}
+
+// ── MCP Gateway Agent ────────────────────────────────────────
+
+export class Multicast extends McpAgent<Env> {
+  server = new McpServer({
+    name: "Multicast",
+    version: "0.1.0",
+  });
+
+  async init() {
+    // ── Tool: list_servers ──────────────────────────────────
+
+    this.server.tool(
+      "list_servers",
+      `List all registered MCP servers and their available tools.
+Returns server names, descriptions, tool counts, and individual tool details from the discovery cache.
+Use this to understand what servers and tools are available before calling multicast.
+If the cache is stale (>24h), it will be refreshed automatically in the background.`,
+      {},
+      async () => {
+        const db = this.env.DB;
+        const registry = getRegisteredServers(this.env);
+
+        // Sync registry: ensure all env var servers are in D1
+        for (const [name, server] of registry) {
+          const existing = await db
+            .prepare("SELECT name FROM servers WHERE name = ?")
+            .bind(name)
+            .first();
+
+          if (!existing) {
+            // New server — discover its tools
+            await discoverServerTools(server, db);
+          } else if (await isCacheStale(db, name)) {
+            // Stale cache — refresh
+            await discoverServerTools(server, db);
+          }
+        }
+
+        // Fetch all servers and their tools
+        const servers = await db
+          .prepare(
+            "SELECT name, url, description, tool_count, status, last_error, last_discovered_at FROM servers WHERE name IN (" +
+              Array.from(registry.keys())
+                .map(() => "?")
+                .join(",") +
+              ")"
+          )
+          .bind(...Array.from(registry.keys()))
+          .all<{
+            name: string;
+            url: string;
+            description: string;
+            tool_count: number;
+            status: string;
+            last_error: string | null;
+            last_discovered_at: string | null;
+          }>();
+
+        const result = [];
+
+        for (const server of servers.results) {
+          const tools = await db
+            .prepare(
+              "SELECT tool_name, description FROM tools WHERE server_name = ?"
+            )
+            .bind(server.name)
+            .all<{ tool_name: string; description: string }>();
+
+          result.push({
+            name: server.name,
+            status: server.status,
+            tool_count: server.tool_count,
+            last_error: server.last_error,
+            last_discovered_at: server.last_discovered_at,
+            tools: tools.results.map((t) => ({
+              name: t.tool_name,
+              description: t.description,
+            })),
+          });
+        }
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                {
+                  servers: result,
+                  total_servers: result.length,
+                  total_tools: result.reduce((sum, s) => sum + s.tool_count, 0),
+                },
+                null,
+                2
+              ),
+            },
+          ],
+        };
+      }
+    );
+
+    // ── Tool: multicast ─────────────────────────────────────
+
+    this.server.tool(
+      "multicast",
+      `Call multiple MCP servers in parallel and return all results at once.
+Each call runs independently — failures in one server don't block others.
+Always returns partial results even if some calls fail.
+
+Use list_servers first to discover available servers and their tools.
+
+Example:
+{
+  "calls": [
+    { "server": "context-hub", "tool": "search_memories", "args": { "query": "project ideas" } },
+    { "server": "supabase", "tool": "execute_sql", "args": { "sql": "SELECT count(*) FROM users" } }
+  ]
+}`,
+      {
+        calls: z
+          .array(
+            z.object({
+              server: z.string().describe("Registered server name (from list_servers)"),
+              tool: z.string().describe("Tool name to call on that server"),
+              args: z
+                .record(z.string(), z.unknown())
+                .optional()
+                .default({})
+                .describe("Arguments to pass to the tool"),
+            })
+          )
+          .min(1)
+          .describe("Array of MCP server calls to execute in parallel"),
+        timeout_ms: z
+          .number()
+          .optional()
+          .default(15000)
+          .describe("Max timeout per call in milliseconds (default: 15000)"),
+      },
+      async ({ calls, timeout_ms }) => {
+        const registry = getRegisteredServers(this.env);
+        const timeout = timeout_ms ?? 15000;
+        const totalStart = Date.now();
+
+        // Validate all servers exist before executing
+        const validationErrors: CallResult[] = [];
+        const validCalls: Array<{
+          server: RegisteredServer;
+          tool: string;
+          args: Record<string, unknown>;
+        }> = [];
+
+        for (const call of calls) {
+          const server = registry.get(call.server);
+          if (!server) {
+            validationErrors.push({
+              server: call.server,
+              tool: call.tool,
+              success: false,
+              error: `unknown server "${call.server}". Use list_servers to see available servers.`,
+              duration_ms: 0,
+            });
+          } else {
+            validCalls.push({
+              server,
+              tool: call.tool,
+              args: (call.args || {}) as Record<string, unknown>,
+            });
+          }
+        }
+
+        // Execute all valid calls in parallel
+        const promises = validCalls.map((call) =>
+          callMcpServer(call.server, call.tool, call.args, timeout)
+        );
+
+        const settled = await Promise.allSettled(promises);
+
+        const results: CallResult[] = [
+          ...validationErrors,
+          ...settled.map((result, i) => {
+            if (result.status === "fulfilled") {
+              return result.value;
+            }
+            return {
+              server: validCalls[i].server.name,
+              tool: validCalls[i].tool,
+              success: false,
+              error: result.reason?.message || "unexpected error",
+              duration_ms: Date.now() - totalStart,
+            };
+          }),
+        ];
+
+        const completed = results.filter((r) => r.success).length;
+        const failed = results.filter((r) => !r.success).length;
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                {
+                  results,
+                  total_ms: Date.now() - totalStart,
+                  completed,
+                  failed,
+                },
+                null,
+                2
+              ),
+            },
+          ],
+        };
+      }
+    );
+
+    // ── Tool: refresh_servers ────────────────────────────────
+
+    this.server.tool(
+      "refresh_servers",
+      `Force re-discovery of all registered MCP servers' tools.
+Use this if you've added new servers or if tools seem outdated.
+Clears the cache and re-fetches tools/list from every registered server.`,
+      {},
+      async () => {
+        const db = this.env.DB;
+        const registry = getRegisteredServers(this.env);
+        const results: Array<{ server: string; tool_count: number; error?: string }> = [];
+
+        for (const [name, server] of registry) {
+          const result = await discoverServerTools(server, db);
+          results.push({ server: name, ...result });
+        }
+
+        const totalTools = results.reduce((sum, r) => sum + r.tool_count, 0);
+        const errors = results.filter((r) => r.error);
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                {
+                  message: `Refreshed ${results.length} servers. ${totalTools} tools cached.${errors.length > 0 ? ` ${errors.length} server(s) had errors.` : ""}`,
+                  servers: results,
+                },
+                null,
+                2
+              ),
+            },
+          ],
+        };
+      }
+    );
+  }
+}
+
+// ── Worker Entry Point ───────────────────────────────────────
+// McpAgent.serve() handles Durable Object routing, session management,
+// and MCP protocol negotiation (Streamable HTTP) automatically.
+
+const mcpHandler = Multicast.serve("/mcp", {
+  binding: "MULTICAST",
+  corsOptions: {
+    origin: "*",
+    methods: "GET, POST, OPTIONS, DELETE",
+    headers: "Content-Type, Authorization, mcp-session-id",
+  },
+});
+
+export default {
+  async fetch(
+    request: Request,
+    env: Env,
+    ctx: ExecutionContext
+  ): Promise<Response> {
+    const url = new URL(request.url);
+
+    // Health check
+    if (url.pathname === "/" || url.pathname === "/health") {
+      const registry = getRegisteredServers(env);
+      return new Response(
+        JSON.stringify({
+          name: "Multicast",
+          version: "0.1.0",
+          description: "MCP gateway — one integration, all your servers, parallel execution",
+          status: "ok",
+          registered_servers: Array.from(registry.keys()),
+          endpoints: ["/mcp"],
+        }),
+        {
+          headers: { "Content-Type": "application/json" },
+        }
+      );
+    }
+
+    // Delegate MCP traffic
+    return mcpHandler.fetch(request, env, ctx);
+  },
+} satisfies ExportedHandler<Env>;

package/templates/default/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "types": ["@cloudflare/workers-types"],
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules"]
+}

package/templates/default/wrangler.json.tmpl

@@ -0,0 +1,32 @@
+{
+  "$schema": "node_modules/wrangler/config-schema.json",
+  "name": "{{PROJECT_NAME}}",
+  "main": "src/index.ts",
+  "compatibility_date": "2025-03-14",
+  "compatibility_flags": [
+    "nodejs_compat"
+  ],
+  "d1_databases": [
+    {
+      "binding": "DB",
+      "database_name": "{{PROJECT_NAME}}-db",
+      "database_id": "{{DB_ID}}"
+    }
+  ],
+  "durable_objects": {
+    "bindings": [
+      {
+        "name": "MULTICAST",
+        "class_name": "Multicast"
+      }
+    ]
+  },
+  "migrations": [
+    {
+      "tag": "v1",
+      "new_sqlite_classes": [
+        "Multicast"
+      ]
+    }
+  ]
+}