mcp-handler/dist/cli/index.mjs

Framework-agnostic HTTP adapter for Model Context Protocol servers

#!/usr/bin/env node
import { __commonJS } from '../chunk-ZNCO4QRF.mjs';
import { Command } from 'commander';
import fs from 'fs/promises';
import path from 'path';
import chalk from 'chalk';

var require_cli = __commonJS({
  "src/cli/index.ts"() {
    var program = new Command();
    var ROUTE_TEMPLATE = `import { createMcpHandler } from 'mcp-handler';
import { z } from 'zod';

const handler = createMcpHandler(
  server => {
    server.registerTool(
      'roll_dice',
      {
        description: 'Rolls an N-sided die',
        inputSchema: z.object({
          sides: z.number().int().min(2),
        }),
      },
      async ({ sides }) => {
        const value = 1 + Math.floor(Math.random() * sides);
        return {
          content: [{ type: 'text', text: \`\u{1F3B2} You rolled a \${value}!\` }],
        };
      }
    );
  },
  {
    // Optional: server options plus handler extras
    verboseLogs: true,
  }
);

export { handler as GET, handler as POST };
`;
    async function detectPackageManager() {
      const cwd = process.cwd();
      try {
        const files = await fs.readdir(cwd);
        if (files.includes("bun.lockb"))
          return "bun";
        if (files.includes("pnpm-lock.yaml"))
          return "pnpm";
        if (files.includes("yarn.lock"))
          return "yarn";
        if (files.includes("package-lock.json"))
          return "npm";
        return "npm";
      } catch (error) {
        return "npm";
      }
    }
    async function installDependencies(packageManager) {
      const execSync = (await import('child_process')).execSync;
      const dependencies = ["mcp-handler", "@modelcontextprotocol/server", "zod"];
      const commands = {
        npm: `npm install ${dependencies.join(" ")}`,
        pnpm: `pnpm add ${dependencies.join(" ")}`,
        yarn: `yarn add ${dependencies.join(" ")}`,
        bun: `bun add ${dependencies.join(" ")}`
      };
      try {
        console.log(
          chalk.blue(`
Installing dependencies using ${packageManager}...`)
        );
        execSync(commands[packageManager], { stdio: "inherit" });
        console.log(chalk.green("\n\u2705 Dependencies installed successfully!"));
      } catch (error) {
        console.error(
          chalk.red(
            "\n\u274C Failed to install dependencies. You can install them manually:"
          )
        );
        console.log(chalk.yellow(`
${commands[packageManager]}`));
      }
    }
    async function init() {
      try {
        const packageJson = JSON.parse(
          await fs.readFile(path.join(process.cwd(), "package.json"), "utf-8")
        );
        if (!packageJson.dependencies?.next && !packageJson.devDependencies?.next) {
          console.error(
            chalk.red("\u274C This command must be run in a Next.js project")
          );
          process.exit(1);
        }
        const routePath = path.join(process.cwd(), "app", "api", "mcp");
        await fs.mkdir(routePath, { recursive: true });
        const routeFilePath = path.join(routePath, "route.ts");
        await fs.writeFile(routeFilePath, ROUTE_TEMPLATE);
        console.log(chalk.green("\u2705 Successfully created MCP route handler!"));
        const packageManager = await detectPackageManager();
        await installDependencies(packageManager);
      } catch (error) {
        console.error(chalk.red("Error creating MCP route handler:"), error);
        process.exit(1);
      }
    }
    program.name("mcp-handler").description("Initialize MCP route handler in your Next.js project").action(init);
    program.parse();
  }
});
var index = require_cli();

export { index as default };
//# sourceMappingURL=out.js.map
//# sourceMappingURL=index.mjs.map