mcp-handler/dist/cli/index.js

Framework-agnostic HTTP adapter for Model Context Protocol servers

#!/usr/bin/env node
'use strict';

var chunkY2F7D3TJ_js = require('../chunk-Y2F7D3TJ.js');
var commander = require('commander');
var fs = require('fs/promises');
var path = require('path');
var chalk = require('chalk');

function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }

var fs__default = /*#__PURE__*/_interopDefault(fs);
var path__default = /*#__PURE__*/_interopDefault(path);
var chalk__default = /*#__PURE__*/_interopDefault(chalk);

var require_cli = chunkY2F7D3TJ_js.__commonJS({
  "src/cli/index.ts"() {
    var program = new commander.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__default.default.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__default.default.blue(`
Installing dependencies using ${packageManager}...`)
        );
        execSync(commands[packageManager], { stdio: "inherit" });
        console.log(chalk__default.default.green("\n\u2705 Dependencies installed successfully!"));
      } catch (error) {
        console.error(
          chalk__default.default.red(
            "\n\u274C Failed to install dependencies. You can install them manually:"
          )
        );
        console.log(chalk__default.default.yellow(`
${commands[packageManager]}`));
      }
    }
    async function init() {
      try {
        const packageJson = JSON.parse(
          await fs__default.default.readFile(path__default.default.join(process.cwd(), "package.json"), "utf-8")
        );
        if (!packageJson.dependencies?.next && !packageJson.devDependencies?.next) {
          console.error(
            chalk__default.default.red("\u274C This command must be run in a Next.js project")
          );
          process.exit(1);
        }
        const routePath = path__default.default.join(process.cwd(), "app", "api", "mcp");
        await fs__default.default.mkdir(routePath, { recursive: true });
        const routeFilePath = path__default.default.join(routePath, "route.ts");
        await fs__default.default.writeFile(routeFilePath, ROUTE_TEMPLATE);
        console.log(chalk__default.default.green("\u2705 Successfully created MCP route handler!"));
        const packageManager = await detectPackageManager();
        await installDependencies(packageManager);
      } catch (error) {
        console.error(chalk__default.default.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();

module.exports = index;
//# sourceMappingURL=out.js.map
//# sourceMappingURL=index.js.map