@christopher_dondici/mcp-gen 2.1.2

package/dist/cli/index.js

@@ -0,0 +1,685 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const path_1 = __importDefault(require("path"));
+const generator_1 = require("../core/generator");
+const registry_1 = require("../core/registry");
+const fs_1 = __importDefault(require("fs"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const SUPPORTED_LANGS = ["typescript", "python", "go"];
+const SUPPORTED_EXTS = [".json", ".yaml", ".yml"];
+const VERSION = (() => {
+    try {
+        return require("../../package.json").version;
+    }
+    catch {
+        return "0.0.0";
+    }
+})();
+function resolveInput(input) {
+    if (input.startsWith("http://") || input.startsWith("https://"))
+        return input;
+    return path_1.default.resolve(input);
+}
+function validateLang(lang) {
+    if (!SUPPORTED_LANGS.includes(lang)) {
+        console.error(chalk_1.default.red(`\n  ✗ Unsupported language: "${lang}". Choose: ${SUPPORTED_LANGS.join(" | ")}\n`));
+        process.exit(1);
+    }
+}
+function validateInputExt(input) {
+    if (input.startsWith("http"))
+        return;
+    const ext = path_1.default.extname(input).toLowerCase();
+    if (!SUPPORTED_EXTS.includes(ext)) {
+        console.error(chalk_1.default.red(`\n  ✗ Unsupported file extension: "${ext}". Accepted: ${SUPPORTED_EXTS.join(", ")}\n`));
+        process.exit(1);
+    }
+}
+const program = new commander_1.Command();
+program
+    .name("mcp-gen")
+    .description("OpenAPI to MCP Server generator")
+    .version(VERSION);
+program
+    .command("generate")
+    .alias("g")
+    .description("Generate an MCP server from an OpenAPI spec (JSON or YAML)")
+    .requiredOption("-i, --input <path>", "Path or URL to the OpenAPI spec (.json | .yaml | .yml)")
+    .option("-l, --lang <language>", `Target language: ${SUPPORTED_LANGS.join(" | ")}`, "typescript")
+    .option("-o, --out <dir>", "Output directory for the generated project", "./mcp-server")
+    .option("-f, --force", "Overwrite existing files without prompting", false)
+    .option("--incremental", "Preserve custom handler code on re-generation (@@mcp-gen markers)", false)
+    .option("--http", "Generate handlers that call the real API over HTTP instead of returning example stubs", false)
+    .option("--env-file <path>", "Path to an .env-style file whose TOKEN/BASE_URL are embedded into the generated client")
+    .option("--name <name>", "Override the server name")
+    .option("--server-version <version>", "Override the server version")
+    .option("--plugin <path>", "Path to a plugin module or folder to load", (val, acc) => {
+    if (!acc)
+        return [val];
+    acc.push(val);
+    return acc;
+}, [])
+    .action(async (opts) => {
+    validateLang(opts.lang);
+    const input = resolveInput(opts.input);
+    validateInputExt(input);
+    const plugins = opts.plugin ?? [];
+    const options = {
+        input,
+        lang: opts.lang,
+        out: path_1.default.resolve(opts.out),
+        force: opts.force,
+        incremental: opts.incremental,
+        http: opts.http,
+        envFile: opts.envFile,
+        plugins,
+        serverName: opts.name,
+        serverVersion: opts.serverVersion,
+    };
+    console.log(chalk_1.default.bold("\nmcp-gen") + ` v${VERSION} — OpenAPI to MCP Server\n`);
+    console.log(`  Input:       ${chalk_1.default.cyan(options.input)}`);
+    console.log(`  Language:    ${chalk_1.default.cyan(options.lang)}`);
+    console.log(`  Output:      ${chalk_1.default.cyan(options.out)}`);
+    if (options.http) {
+        console.log(`  HTTP mode:   ${chalk_1.default.green("on — handlers will call the real API")}`);
+    }
+    if (options.incremental) {
+        console.log(`  Incremental: ${chalk_1.default.yellow("on — custom handlers will be preserved")}`);
+    }
+    console.log();
+    const spinner = (0, ora_1.default)("Parsing OpenAPI spec...").start();
+    try {
+        const result = await (0, generator_1.generate)(options);
+        if (result.warnings.length > 0) {
+            spinner.warn("Completed with warnings");
+            for (const w of result.warnings)
+                console.log(chalk_1.default.yellow(`  ⚠ ${w}`));
+            console.log();
+        }
+        if (!result.success) {
+            spinner.fail("Generation failed");
+            for (const err of result.errors)
+                console.error(chalk_1.default.red(`  ✗ ${err}`));
+            process.exit(1);
+        }
+        spinner.succeed("Generation complete");
+        console.log(chalk_1.default.green(`\n  ✓ ${result.filesCreated.length} files created\n`));
+        for (const f of result.filesCreated) {
+            console.log(`    ${chalk_1.default.dim(result.outputDir + "/")}${f}`);
+        }
+        if (result.filesPreserved && result.filesPreserved.length > 0) {
+            console.log(chalk_1.default.cyan(`\n  ↺ ${result.filesPreserved.length} handler(s) preserved\n`));
+            for (const f of result.filesPreserved)
+                console.log(`    ${chalk_1.default.dim("↺ ")}${f}`);
+        }
+        const isTs = options.lang === "typescript";
+        const isPy = options.lang === "python";
+        console.log(chalk_1.default.bold("\nNext steps:\n"));
+        console.log(`  cd ${opts.out}`);
+        if (isTs) {
+            console.log("  npm install");
+            console.log("  npm run build");
+            console.log("  npm start\n");
+        }
+        else if (isPy) {
+            console.log("  pip install -r requirements.txt");
+            console.log("  python server.py\n");
+        }
+        else {
+            console.log("  go mod tidy");
+            console.log("  go run .\n");
+        }
+    }
+    catch (err) {
+        spinner.fail("Unexpected error");
+        console.error(chalk_1.default.red(err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+    }
+});
+program
+    .command("validate")
+    .alias("v")
+    .description("Validate an OpenAPI spec without generating")
+    .requiredOption("-i, --input <path>", "Path or URL to the OpenAPI spec")
+    .action(async (opts) => {
+    const input = resolveInput(opts.input);
+    validateInputExt(input);
+    const spinner = (0, ora_1.default)("Validating spec...").start();
+    try {
+        const result = await (0, generator_1.validateSpec)(input);
+        if (!result.valid) {
+            spinner.fail("Spec is invalid");
+            for (const err of result.errors)
+                console.error(chalk_1.default.red(`  ✗ ${err}`));
+            process.exit(1);
+        }
+        spinner.succeed("Spec is valid");
+        console.log(chalk_1.default.dim(`\n  Tools: ${result.tools}  Models: ${result.models}  Base URL: ${result.baseUrl}\n`));
+        if (result.warnings.length > 0) {
+            console.log(chalk_1.default.yellow(`  ${result.warnings.length} warning(s):`));
+            for (const w of result.warnings)
+                console.log(chalk_1.default.yellow(`  ⚠ ${w}`));
+            console.log();
+        }
+    }
+    catch (err) {
+        spinner.fail("Validation failed");
+        console.error(chalk_1.default.red(err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+    }
+});
+program
+    .command("init")
+    .description("Initialize a local spec from a known public registry (e.g. stripe, github)")
+    .requiredOption("--from <key>", "Registry key to fetch spec from. Use 'list' to show known keys")
+    .option("--generate", "Run generation after fetching the spec", false)
+    .option("-i, --input <path>", "If provided, use this as the saved filename instead of the registry default")
+    .option("-l, --lang <language>", `Target language: ${SUPPORTED_LANGS.join(" | ")}`, "typescript")
+    .option("-o, --out <dir>", "Output directory for the generated project", "./mcp-server")
+    .action(async (opts) => {
+    const key = opts.from;
+    try {
+        if (key === "list") {
+            const specs = (0, registry_1.listKnownSpecs)();
+            console.log(chalk_1.default.bold("\nKnown Public Specs:\n"));
+            for (const k of specs) {
+                const info = (0, registry_1.getSpecInfo)(k);
+                console.log(chalk_1.default.cyan(`  ${k.padEnd(15)}`), info?.description || "");
+            }
+            console.log("\n" + chalk_1.default.dim(`Usage: mcp-gen init --from <key> [--generate -o ./output]`));
+            console.log(chalk_1.default.dim(`Example: mcp-gen init --from stripe --generate -o ./stripe-mcp\n`));
+            return;
+        }
+        const spinner = (0, ora_1.default)(`Fetching ${key}...`).start();
+        const saved = await (0, registry_1.fetchSpecToCwd)(key, opts.input ? resolveInput(opts.input) : undefined);
+        spinner.succeed(`Saved spec to ${chalk_1.default.green(path_1.default.basename(saved))}`);
+        if (opts.generate) {
+            const input = saved;
+            validateInputExt(input);
+            const options = {
+                input,
+                lang: opts.lang,
+                out: path_1.default.resolve(opts.out),
+                force: false,
+                incremental: false,
+                http: false,
+            };
+            const result = await (0, generator_1.generate)(options);
+            if (!result.success) {
+                for (const err of result.errors)
+                    console.error(chalk_1.default.red(`  ✗ ${err}`));
+                process.exit(1);
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+    }
+});
+program
+    .command("security")
+    .alias("sec")
+    .description("Scan a generated MCP project for security and lint issues")
+    .requiredOption("-p, --project <path>", "Path to the generated MCP project to scan")
+    .option("--fail-on-warn", "Exit with code 1 if warnings are found", false)
+    .option("--json", "Output results as JSON", false)
+    .action(async (opts) => {
+    const projectPath = path_1.default.resolve(opts.project);
+    if (!fs_1.default.existsSync(projectPath)) {
+        console.error(chalk_1.default.red(`\n  ✗ Project not found: ${projectPath}\n`));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.bold("\nmcp-gen security") + ` v${VERSION} — Security & Lint Scan\n`);
+    console.log(`  Project:    ${chalk_1.default.cyan(projectPath)}\n`);
+    const { scanProject, formatReport } = await Promise.resolve().then(() => __importStar(require("../core/security-lint")));
+    const spinner = (0, ora_1.default)("Scanning project...").start();
+    try {
+        const report = await scanProject(projectPath);
+        if (opts.json) {
+            spinner.stop();
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            spinner.succeed("Scan complete");
+            console.log(formatReport(report));
+        }
+        if (!report.passed || (opts.failOnWarn && report.summary.warnings > 0)) {
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        spinner.fail("Scan failed");
+        console.error(chalk_1.default.red(err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+    }
+});
+program
+    .command("watch")
+    .description("Watch a spec (file or URL) and regenerate on changes")
+    .requiredOption("-i, --input <path>", "Path or URL to the OpenAPI spec to watch")
+    .option("-l, --lang <language>", `Target language: ${SUPPORTED_LANGS.join(" | ")}`, "typescript")
+    .option("-o, --out <dir>", "Output directory for the generated project", "./mcp-server")
+    .option("--once", "Run generation once on first change then exit", false)
+    .option("--interval <ms>", "Polling interval for URL inputs (ms)", "30000")
+    .option("--plugin <path>", "Path to a plugin module or folder to load", (val, acc) => {
+    if (!acc)
+        return [val];
+    acc.push(val);
+    return acc;
+}, [])
+    .action(async (opts) => {
+    const input = resolveInput(opts.input);
+    validateInputExt(input);
+    validateLang(opts.lang);
+    const commonOptions = {
+        lang: opts.lang,
+        out: path_1.default.resolve(opts.out),
+        force: false,
+        incremental: true,
+        http: false,
+        plugins: opts.plugin,
+    };
+    const runGenerate = async () => {
+        const options = {
+            input,
+            lang: commonOptions.lang,
+            out: commonOptions.out,
+            force: false,
+            incremental: true,
+            http: false,
+            plugins: commonOptions.plugins,
+        };
+        console.log(chalk_1.default.dim(`[watch] regenerating from ${opts.input} → ${options.out}`));
+        try {
+            const res = await (0, generator_1.generate)(options);
+            if (!res.success) {
+                console.error(chalk_1.default.red("Generation failed:"));
+                for (const e of res.errors)
+                    console.error(chalk_1.default.red(`  ${e}`));
+            }
+            else {
+                console.log(chalk_1.default.green(`[watch] generated ${res.filesCreated.length} files`));
+            }
+        }
+        catch (e) {
+            console.error(chalk_1.default.red(String(e)));
+        }
+    };
+    if (opts.input.startsWith("http://") || opts.input.startsWith("https://")) {
+        let last = "";
+        const interval = Number(opts.interval) || 30000;
+        console.log(chalk_1.default.dim(`[watch] polling ${opts.input} every ${interval}ms`));
+        const check = async () => {
+            try {
+                const r = await fetch(opts.input);
+                if (!r.ok)
+                    throw new Error(`HTTP ${r.status}`);
+                const body = await r.text();
+                if (!last) {
+                    last = body;
+                    await runGenerate();
+                    if (opts.once)
+                        process.exit(0);
+                    return;
+                }
+                if (body !== last) {
+                    last = body;
+                    await runGenerate();
+                    if (opts.once)
+                        process.exit(0);
+                }
+            }
+            catch (e) {
+                console.error(chalk_1.default.red(String(e)));
+            }
+        };
+        await check();
+        setInterval(check, interval);
+        return;
+    }
+    const abs = path_1.default.resolve(opts.input);
+    if (!fs_1.default.existsSync(abs)) {
+        console.error(chalk_1.default.red(`File not found: ${abs}`));
+        process.exit(1);
+    }
+    let timeout = null;
+    const watcher = fs_1.default.watch(abs, async () => {
+        if (timeout)
+            clearTimeout(timeout);
+        timeout = setTimeout(async () => {
+            await runGenerate();
+            if (opts.once) {
+                watcher.close();
+                process.exit(0);
+            }
+        }, 200);
+    });
+    console.log(chalk_1.default.dim(`[watch] watching ${abs}`));
+    await runGenerate();
+});
+async function interactive() {
+    while (true) {
+        const { cmd } = await inquirer_1.default.prompt([
+            {
+                type: "list",
+                name: "cmd",
+                message: "Choose an action:",
+                choices: [
+                    { name: "Generate (Generate an MCP server from a spec)", value: "generate" },
+                    { name: "Validate (Validate an OpenAPI spec)", value: "validate" },
+                    { name: "Init (Download a known public spec)", value: "init" },
+                    { name: "Watch (Watch and auto-regenerate on changes)", value: "watch" },
+                    { name: "Security (Scan project for security/lint issues)", value: "security" },
+                    { name: "Exit", value: "exit" },
+                ],
+            },
+        ]);
+        if (cmd === "exit")
+            return;
+        if (cmd === "generate") {
+            const answers = await inquirer_1.default.prompt([
+                { type: "input", name: "input", message: "Path or URL to the OpenAPI spec (.json|.yaml):" },
+                { type: "list", name: "lang", message: "Target language:", choices: [...SUPPORTED_LANGS] },
+                { type: "input", name: "out", message: "Output directory:", default: "./mcp-server" },
+                { type: "confirm", name: "force", message: "Overwrite existing files?", default: false },
+                { type: "confirm", name: "incremental", message: "Preserve custom handlers?", default: false },
+                { type: "confirm", name: "http", message: "Generate real HTTP handlers?", default: false },
+                { type: "input", name: "name", message: "Server name (optional):", default: "" },
+                { type: "input", name: "serverVersion", message: "Server version (optional):", default: "" },
+            ]);
+            const input = resolveInput(answers.input);
+            validateInputExt(input);
+            validateLang(answers.lang);
+            const options = {
+                input,
+                lang: answers.lang,
+                out: path_1.default.resolve(answers.out),
+                force: Boolean(answers.force),
+                incremental: Boolean(answers.incremental),
+                http: Boolean(answers.http),
+                plugins: [],
+                serverName: answers.name || undefined,
+                serverVersion: answers.serverVersion || undefined,
+            };
+            console.log(chalk_1.default.bold("\nmcp-gen") + " — OpenAPI to MCP Server\n");
+            const spinner = (0, ora_1.default)("Parsing OpenAPI spec...").start();
+            try {
+                const result = await (0, generator_1.generate)(options);
+                if (result.warnings.length > 0) {
+                    spinner.warn("Completed with warnings");
+                    for (const w of result.warnings)
+                        console.log(chalk_1.default.yellow(`  ⚠ ${w}`));
+                    console.log();
+                }
+                if (!result.success) {
+                    spinner.fail("Generation failed");
+                    for (const err of result.errors)
+                        console.error(chalk_1.default.red(`  ✗ ${err}`));
+                }
+                else {
+                    spinner.succeed("Generation complete");
+                    console.log(chalk_1.default.green(`\n  ✓ ${result.filesCreated.length} files created\n`));
+                }
+            }
+            catch (err) {
+                spinner.fail("Unexpected error");
+                console.error(chalk_1.default.red(err instanceof Error ? err.message : String(err)));
+            }
+        }
+        if (cmd === "validate") {
+            const { input } = await inquirer_1.default.prompt([{ type: "input", name: "input", message: "Path or URL to the OpenAPI spec:" }]);
+            const resolved = resolveInput(input);
+            validateInputExt(resolved);
+            const spinner = (0, ora_1.default)("Validating spec...").start();
+            try {
+                const { parseOpenAPI } = await Promise.resolve().then(() => __importStar(require("../core/parser")));
+                const ast = await parseOpenAPI(resolved);
+                spinner.succeed("Spec is valid");
+                console.log(chalk_1.default.dim(`\n  Tools: ${ast.tools.length}  Models: ${ast.models.length}  Base URL: ${ast.baseUrl}\n`));
+            }
+            catch (err) {
+                spinner.fail("Validation failed");
+                console.error(chalk_1.default.red(err instanceof Error ? err.message : String(err)));
+            }
+        }
+        if (cmd === "init") {
+            const specs = (0, registry_1.listKnownSpecs)();
+            const { key } = await inquirer_1.default.prompt([
+                {
+                    type: "list",
+                    name: "key",
+                    message: "Which public spec?",
+                    choices: specs.map((k) => ({
+                        name: `${k.padEnd(15)} — ${(0, registry_1.getSpecInfo)(k)?.description || ""}`,
+                        value: k,
+                    })),
+                },
+            ]);
+            try {
+                const spinner = (0, ora_1.default)(`Downloading ${key}...`).start();
+                const saved = await (0, registry_1.fetchSpecToCwd)(key);
+                spinner.succeed(`Saved to ${chalk_1.default.green(path_1.default.basename(saved))}`);
+                const { autoGen } = await inquirer_1.default.prompt([
+                    {
+                        type: "confirm",
+                        name: "autoGen",
+                        message: "Generate MCP server now?",
+                        default: true,
+                    },
+                ]);
+                if (autoGen) {
+                    const { lang, out } = await inquirer_1.default.prompt([
+                        {
+                            type: "list",
+                            name: "lang",
+                            message: "Target language:",
+                            choices: [...SUPPORTED_LANGS],
+                        },
+                        {
+                            type: "input",
+                            name: "out",
+                            message: "Output directory:",
+                            default: `./${key}-mcp`,
+                        },
+                    ]);
+                    const options = {
+                        input: resolveInput(saved),
+                        lang: lang,
+                        out: path_1.default.resolve(out),
+                        force: false,
+                        incremental: false,
+                        http: false,
+                    };
+                    const genSpinner = (0, ora_1.default)("Generating MCP server...").start();
+                    try {
+                        const result = await (0, generator_1.generate)(options);
+                        if (result.warnings.length > 0) {
+                            genSpinner.warn("Generated with warnings");
+                            for (const w of result.warnings)
+                                console.log(chalk_1.default.yellow(`  ⚠ ${w}`));
+                        }
+                        if (!result.success) {
+                            genSpinner.fail("Generation failed");
+                            for (const err of result.errors)
+                                console.error(chalk_1.default.red(`  ✗ ${err}`));
+                        }
+                        else {
+                            genSpinner.succeed("MCP server generated!");
+                            console.log(chalk_1.default.green(`\n  ✓ ${result.filesCreated.length} files created\n`));
+                            console.log(chalk_1.default.bold("Next steps:\n"));
+                            console.log(`  cd ${out}`);
+                            console.log(lang === "typescript" ? "  npm install && npm run build\n" : "  pip install -r requirements.txt\n");
+                        }
+                    }
+                    catch (err) {
+                        genSpinner.fail("Generation error");
+                        console.error(chalk_1.default.red(err instanceof Error ? err.message : String(err)));
+                    }
+                }
+            }
+            catch (err) {
+                console.error(chalk_1.default.red(err instanceof Error ? err.message : String(err)));
+            }
+        }
+        if (cmd === "watch") {
+            const answers = await inquirer_1.default.prompt([
+                { type: "input", name: "input", message: "Path or URL to the OpenAPI spec:" },
+                { type: "list", name: "lang", message: "Target language:", choices: [...SUPPORTED_LANGS] },
+                { type: "input", name: "out", message: "Output directory:", default: "./mcp-server" },
+            ]);
+            const input = resolveInput(answers.input);
+            validateInputExt(input);
+            validateLang(answers.lang);
+            const commonOptions = {
+                lang: answers.lang,
+                out: path_1.default.resolve(answers.out),
+                force: false,
+                incremental: false,
+                http: false,
+                plugins: [],
+            };
+            const runGenerate = async () => {
+                const options = {
+                    input: answers.input,
+                    lang: commonOptions.lang,
+                    out: commonOptions.out,
+                    force: false,
+                    incremental: false,
+                    http: false,
+                    plugins: commonOptions.plugins,
+                };
+                console.log(chalk_1.default.dim(`[watch] regenerating from ${answers.input} → ${options.out}`));
+                try {
+                    const res = await (0, generator_1.generate)(options);
+                    if (!res.success) {
+                        console.error(chalk_1.default.red("Generation failed:"));
+                        for (const e of res.errors)
+                            console.error(chalk_1.default.red(`  ${e}`));
+                    }
+                    else {
+                        console.log(chalk_1.default.green(`[watch] generated ${res.filesCreated.length} files`));
+                    }
+                }
+                catch (e) {
+                    console.error(chalk_1.default.red(String(e)));
+                }
+            };
+            if (answers.input.startsWith("http://") || answers.input.startsWith("https://")) {
+                console.log(chalk_1.default.dim(`[watch] polling ${answers.input} every 30000ms`));
+                let last = "";
+                const check = async () => {
+                    try {
+                        const r = await fetch(answers.input);
+                        if (!r.ok)
+                            throw new Error(`HTTP ${r.status}`);
+                        const body = await r.text();
+                        if (!last) {
+                            last = body;
+                            await runGenerate();
+                            return;
+                        }
+                        if (body !== last) {
+                            last = body;
+                            await runGenerate();
+                        }
+                    }
+                    catch (e) {
+                        console.error(chalk_1.default.red(String(e)));
+                    }
+                };
+                await check();
+                setInterval(check, 30000);
+            }
+            else {
+                const abs = path_1.default.resolve(answers.input);
+                if (!fs_1.default.existsSync(abs)) {
+                    console.error(chalk_1.default.red(`File not found: ${abs}`));
+                }
+                else {
+                    let timeout = null;
+                    const watcher = fs_1.default.watch(abs, async () => {
+                        if (timeout)
+                            clearTimeout(timeout);
+                        timeout = setTimeout(async () => {
+                            await runGenerate();
+                        }, 200);
+                    });
+                    console.log(chalk_1.default.dim(`[watch] watching ${abs}`));
+                    await runGenerate();
+                }
+            }
+        }
+        if (cmd === "security") {
+            const { project } = await inquirer_1.default.prompt([
+                { type: "input", name: "project", message: "Path to the generated MCP project to scan:" },
+            ]);
+            const projectPath = path_1.default.resolve(project);
+            if (!fs_1.default.existsSync(projectPath)) {
+                console.error(chalk_1.default.red(`\n  ✗ Project not found: ${projectPath}\n`));
+                continue;
+            }
+            console.log(chalk_1.default.bold("\nmcp-gen security") + ` v${VERSION} — Security & Lint Scan\n`);
+            console.log(`  Project:    ${chalk_1.default.cyan(projectPath)}\n`);
+            const { scanProject, formatReport } = await Promise.resolve().then(() => __importStar(require("../core/security-lint")));
+            const spinner = (0, ora_1.default)("Scanning project...").start();
+            try {
+                const report = await scanProject(projectPath);
+                spinner.succeed("Scan complete");
+                console.log(formatReport(report));
+            }
+            catch (err) {
+                spinner.fail("Scan failed");
+                console.error(chalk_1.default.red(err instanceof Error ? err.message : String(err)));
+            }
+        }
+    }
+}
+(async () => {
+    if (process.argv.length <= 2 && process.stdin.isTTY) {
+        await interactive();
+        process.exit(0);
+    }
+    program.parse();
+})();
+//# sourceMappingURL=index.js.map