trickle-cli 0.1.0

package/dist/commands/init.js

@@ -0,0 +1,395 @@
+"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 });
+exports.initCommand = initCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+function detectProject(dir, forcePython) {
+    const info = {
+        dir,
+        hasPackageJson: false,
+        hasTsConfig: false,
+        isPython: forcePython,
+        framework: null,
+        entryFile: null,
+        packageJson: null,
+        tsConfig: null,
+    };
+    // Check for package.json
+    const pkgPath = path.join(dir, "package.json");
+    if (fs.existsSync(pkgPath)) {
+        info.hasPackageJson = true;
+        try {
+            info.packageJson = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        }
+        catch {
+            // ignore parse errors
+        }
+    }
+    // Check for tsconfig.json
+    const tsPath = path.join(dir, "tsconfig.json");
+    if (fs.existsSync(tsPath)) {
+        info.hasTsConfig = true;
+        try {
+            // Strip comments (simple approach: remove // and /* */ comments)
+            const raw = fs.readFileSync(tsPath, "utf-8");
+            const cleaned = raw
+                .replace(/\/\/.*$/gm, "")
+                .replace(/\/\*[\s\S]*?\*\//g, "");
+            info.tsConfig = JSON.parse(cleaned);
+        }
+        catch {
+            // ignore parse errors
+        }
+    }
+    // Check for Python project
+    if (fs.existsSync(path.join(dir, "pyproject.toml")) ||
+        fs.existsSync(path.join(dir, "setup.py")) ||
+        fs.existsSync(path.join(dir, "requirements.txt"))) {
+        info.isPython = true;
+    }
+    // Detect framework from dependencies
+    if (info.packageJson) {
+        const deps = {
+            ...info.packageJson.dependencies,
+            ...info.packageJson.devDependencies,
+        };
+        if (deps.express)
+            info.framework = "express";
+    }
+    if (info.isPython) {
+        // Check requirements.txt or pyproject.toml for framework
+        const reqPath = path.join(dir, "requirements.txt");
+        if (fs.existsSync(reqPath)) {
+            const reqs = fs.readFileSync(reqPath, "utf-8").toLowerCase();
+            if (reqs.includes("fastapi"))
+                info.framework = "fastapi";
+            else if (reqs.includes("flask"))
+                info.framework = "flask";
+            else if (reqs.includes("django"))
+                info.framework = "django";
+        }
+    }
+    // Detect entry file
+    if (info.packageJson) {
+        const main = info.packageJson.main;
+        if (main && fs.existsSync(path.join(dir, main))) {
+            info.entryFile = main;
+        }
+        else {
+            // Common entry points
+            for (const candidate of ["src/index.ts", "src/index.js", "index.ts", "index.js", "app.ts", "app.js", "server.ts", "server.js"]) {
+                if (fs.existsSync(path.join(dir, candidate))) {
+                    info.entryFile = candidate;
+                    break;
+                }
+            }
+        }
+    }
+    if (info.isPython && !info.entryFile) {
+        for (const candidate of ["app.py", "main.py", "server.py", "wsgi.py"]) {
+            if (fs.existsSync(path.join(dir, candidate))) {
+                info.entryFile = candidate;
+                break;
+            }
+        }
+    }
+    return info;
+}
+function createTrickleConfig(dir, info) {
+    const configPath = path.join(dir, ".tricklerc.json");
+    if (fs.existsSync(configPath))
+        return false;
+    // Also check for package.json "trickle" field
+    if (info.packageJson && info.packageJson.trickle) {
+        return false;
+    }
+    const config = {};
+    // Suggest stubs directory based on project structure
+    if (fs.existsSync(path.join(dir, "src"))) {
+        config.stubs = "src/";
+    }
+    else {
+        config.stubs = ".";
+    }
+    // Default exclude patterns
+    config.exclude = ["node_modules", "dist", "build", "__pycache__"];
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    return true;
+}
+function ensureTrickleDir(dir) {
+    const trickleDir = path.join(dir, ".trickle");
+    if (!fs.existsSync(trickleDir)) {
+        fs.mkdirSync(trickleDir, { recursive: true });
+    }
+    return trickleDir;
+}
+function writeInitialTypes(trickleDir, isPython) {
+    if (isPython) {
+        const pyPath = path.join(trickleDir, "types.pyi");
+        if (!fs.existsSync(pyPath)) {
+            fs.writeFileSync(pyPath, [
+                "# Auto-generated by trickle from runtime type observations",
+                "# Run your app to populate types, then: trickle codegen --python --out .trickle/types.pyi",
+                "#",
+                "# This file will be updated automatically when using: trickle codegen --python --watch --out .trickle/types.pyi",
+                "",
+                "from typing import TypedDict",
+                "",
+                "# Types will appear here after your app processes its first requests.",
+                "",
+            ].join("\n"), "utf-8");
+        }
+    }
+    else {
+        const tsPath = path.join(trickleDir, "types.d.ts");
+        if (!fs.existsSync(tsPath)) {
+            fs.writeFileSync(tsPath, [
+                "// Auto-generated by trickle from runtime type observations",
+                "// Run your app to populate types, then: trickle codegen --out .trickle/types.d.ts",
+                "//",
+                "// This file will be updated automatically when using: trickle codegen --watch --out .trickle/types.d.ts",
+                "",
+                "// Types will appear here after your app processes its first requests.",
+                "",
+            ].join("\n"), "utf-8");
+        }
+        // Also create an api-client placeholder
+        const clientPath = path.join(trickleDir, "api-client.ts");
+        if (!fs.existsSync(clientPath)) {
+            fs.writeFileSync(clientPath, [
+                "// Auto-generated typed API client by trickle",
+                "// Run your app to populate types, then: trickle codegen --client --out .trickle/api-client.ts",
+                "",
+                "// A fully-typed fetch client will appear here after your app serves its first API requests.",
+                "",
+            ].join("\n"), "utf-8");
+        }
+    }
+}
+function updateTsConfig(dir, info) {
+    const tsConfigPath = path.join(dir, "tsconfig.json");
+    if (!info.hasTsConfig || !info.tsConfig) {
+        // No tsconfig — create a minimal one that includes .trickle
+        if (!info.isPython) {
+            const newConfig = {
+                compilerOptions: {
+                    target: "ES2022",
+                    module: "commonjs",
+                    strict: true,
+                    esModuleInterop: true,
+                    skipLibCheck: true,
+                    outDir: "./dist",
+                    rootDir: "./src",
+                },
+                include: ["src", ".trickle"],
+            };
+            fs.writeFileSync(tsConfigPath, JSON.stringify(newConfig, null, 2) + "\n", "utf-8");
+            return true;
+        }
+        return false;
+    }
+    // Read the raw file to preserve formatting as much as possible
+    const raw = fs.readFileSync(tsConfigPath, "utf-8");
+    const config = info.tsConfig;
+    // Check if .trickle is already included
+    const include = config.include;
+    if (include && include.some((p) => p === ".trickle" || p.startsWith(".trickle/"))) {
+        return false; // Already configured
+    }
+    // Add .trickle to include array
+    if (include) {
+        include.push(".trickle");
+    }
+    else {
+        config.include = ["src", ".trickle"];
+    }
+    fs.writeFileSync(tsConfigPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    return true;
+}
+function updatePackageJson(dir, info) {
+    if (!info.hasPackageJson || !info.packageJson) {
+        return { scriptsAdded: [] };
+    }
+    const pkgPath = path.join(dir, "package.json");
+    const pkg = info.packageJson;
+    const scripts = pkg.scripts || {};
+    const added = [];
+    // Add trickle:dev script for watch mode
+    if (!scripts["trickle:dev"]) {
+        const outFile = info.isPython ? ".trickle/types.pyi" : ".trickle/types.d.ts";
+        const langFlag = info.isPython ? " --python" : "";
+        scripts["trickle:dev"] = `trickle codegen${langFlag} --watch --out ${outFile}`;
+        added.push("trickle:dev");
+    }
+    // Add trickle:client script for API client generation
+    if (!info.isPython && !scripts["trickle:client"]) {
+        scripts["trickle:client"] = "trickle codegen --client --out .trickle/api-client.ts";
+        added.push("trickle:client");
+    }
+    // Add trickle:mock script
+    if (!scripts["trickle:mock"]) {
+        scripts["trickle:mock"] = "trickle mock";
+        added.push("trickle:mock");
+    }
+    // Detect current start script and create a trickle-wrapped version
+    const startScript = scripts.start || scripts.dev;
+    if (startScript && !scripts["trickle:start"]) {
+        // Check if it's a node command we can add -r to
+        if (startScript.match(/\bnode\s/)) {
+            scripts["trickle:start"] = startScript.replace(/\bnode\s/, "node -r trickle-observe/register ");
+            added.push("trickle:start");
+        }
+        else if (startScript.match(/\bts-node\s/)) {
+            scripts["trickle:start"] = startScript.replace(/\bts-node\s/, "ts-node -r trickle-observe/register ");
+            added.push("trickle:start");
+        }
+        else if (startScript.match(/\bnodemon\s/)) {
+            scripts["trickle:start"] = startScript.replace(/\bnodemon\s/, "nodemon -r trickle-observe/register ");
+            added.push("trickle:start");
+        }
+    }
+    if (added.length > 0) {
+        pkg.scripts = scripts;
+        fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+    }
+    return { scriptsAdded: added };
+}
+function updateGitignore(dir) {
+    const giPath = path.join(dir, ".gitignore");
+    let content = "";
+    if (fs.existsSync(giPath)) {
+        content = fs.readFileSync(giPath, "utf-8");
+        if (content.includes(".trickle")) {
+            return false; // Already has it
+        }
+    }
+    const addition = content.endsWith("\n") || content === ""
+        ? ".trickle/\n"
+        : "\n.trickle/\n";
+    fs.writeFileSync(giPath, content + addition, "utf-8");
+    return true;
+}
+async function initCommand(opts) {
+    const dir = path.resolve(opts.dir || ".");
+    console.log("");
+    console.log(chalk_1.default.bold("  trickle init"));
+    console.log("");
+    // Step 1: Detect project
+    const info = detectProject(dir, opts.python === true);
+    if (!info.hasPackageJson && !info.isPython) {
+        console.log(chalk_1.default.yellow("  No package.json or Python project detected."));
+        console.log(chalk_1.default.gray("  Run this command from your project root.\n"));
+        process.exit(1);
+    }
+    const lang = info.isPython ? "Python" : "Node.js";
+    console.log(chalk_1.default.gray(`  Detected: ${lang} project${info.framework ? ` (${info.framework})` : ""}`));
+    if (info.entryFile) {
+        console.log(chalk_1.default.gray(`  Entry: ${info.entryFile}`));
+    }
+    console.log("");
+    // Step 2: Create .tricklerc.json
+    const configCreated = createTrickleConfig(dir, info);
+    if (configCreated) {
+        console.log(`  ${chalk_1.default.green("+")} Created ${chalk_1.default.bold(".tricklerc.json")} — project config`);
+    }
+    else {
+        console.log(`  ${chalk_1.default.gray("-")} .tricklerc.json already exists`);
+    }
+    // Step 3: Create .trickle directory
+    const trickleDir = ensureTrickleDir(dir);
+    console.log(`  ${chalk_1.default.green("+")} Created ${chalk_1.default.bold(".trickle/")} directory`);
+    // Step 3: Write initial type files
+    writeInitialTypes(trickleDir, info.isPython);
+    if (info.isPython) {
+        console.log(`  ${chalk_1.default.green("+")} Created ${chalk_1.default.bold(".trickle/types.pyi")} (type stubs)`);
+    }
+    else {
+        console.log(`  ${chalk_1.default.green("+")} Created ${chalk_1.default.bold(".trickle/types.d.ts")} (type declarations)`);
+        console.log(`  ${chalk_1.default.green("+")} Created ${chalk_1.default.bold(".trickle/api-client.ts")} (typed API client)`);
+    }
+    // Step 4: Update tsconfig.json
+    if (!info.isPython) {
+        const tsUpdated = updateTsConfig(dir, info);
+        if (tsUpdated) {
+            if (info.hasTsConfig) {
+                console.log(`  ${chalk_1.default.green("~")} Updated ${chalk_1.default.bold("tsconfig.json")} — added .trickle to include`);
+            }
+            else {
+                console.log(`  ${chalk_1.default.green("+")} Created ${chalk_1.default.bold("tsconfig.json")} with .trickle included`);
+            }
+        }
+        else {
+            console.log(`  ${chalk_1.default.gray("-")} tsconfig.json already includes .trickle`);
+        }
+    }
+    // Step 5: Update package.json scripts
+    if (info.hasPackageJson) {
+        const { scriptsAdded } = updatePackageJson(dir, info);
+        if (scriptsAdded.length > 0) {
+            for (const name of scriptsAdded) {
+                console.log(`  ${chalk_1.default.green("+")} Added npm script: ${chalk_1.default.bold(name)}`);
+            }
+        }
+    }
+    // Step 6: Update .gitignore
+    const giUpdated = updateGitignore(dir);
+    if (giUpdated) {
+        console.log(`  ${chalk_1.default.green("~")} Updated ${chalk_1.default.bold(".gitignore")} — added .trickle/`);
+    }
+    // Step 7: Print next steps
+    console.log("");
+    console.log(chalk_1.default.bold("  Next steps:"));
+    console.log("");
+    const entryFile = info.entryFile || (info.isPython ? "app.py" : "app.js");
+    console.log(chalk_1.default.white("  1. Run your app with trickle (one command does everything):"));
+    console.log(chalk_1.default.cyan(`     trickle run ${entryFile}`));
+    console.log("");
+    console.log(chalk_1.default.white("  2. That's it! trickle auto-detects the runtime, observes types,"));
+    console.log(chalk_1.default.white("     and generates stubs from .tricklerc.json settings."));
+    console.log("");
+    console.log(chalk_1.default.gray("  Customize .tricklerc.json:"));
+    console.log(chalk_1.default.gray('     { "stubs": "src/", "annotate": "src/", "exclude": ["test"] }'));
+    console.log("");
+    console.log(chalk_1.default.gray("  Other commands:"));
+    console.log(chalk_1.default.gray("     trickle functions         — list observed functions"));
+    console.log(chalk_1.default.gray("     trickle types <name>      — see types + sample data"));
+    console.log(chalk_1.default.gray("     trickle annotate src/     — add type annotations to source files"));
+    console.log("");
+}

package/dist/commands/mock.d.ts

@@ -0,0 +1,5 @@
+export interface MockOptions {
+    port?: string;
+    cors?: boolean;
+}
+export declare function mockCommand(opts: MockOptions): Promise<void>;

package/dist/commands/mock.js

@@ -0,0 +1,232 @@
+"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 });
+exports.mockCommand = mockCommand;
+const http = __importStar(require("http"));
+const chalk_1 = __importDefault(require("chalk"));
+const api_client_1 = require("../api-client");
+/**
+ * Convert an Express-style path like `/api/users/:id` to a regex
+ * that captures named path params.
+ */
+function pathToRegex(routePath) {
+    const paramNames = [];
+    const pattern = routePath.replace(/:(\w+)/g, (_match, paramName) => {
+        paramNames.push(paramName);
+        return "([^/]+)";
+    });
+    return { regex: new RegExp(`^${pattern}$`), paramNames };
+}
+/**
+ * Build a description of the mock server routes for the startup banner.
+ */
+function formatRouteTable(routes) {
+    const lines = [];
+    const methodColors = {
+        GET: chalk_1.default.green,
+        POST: chalk_1.default.yellow,
+        PUT: chalk_1.default.blue,
+        DELETE: chalk_1.default.red,
+        PATCH: chalk_1.default.magenta,
+    };
+    for (const route of routes) {
+        const color = methodColors[route.method] || chalk_1.default.white;
+        const method = color(route.method.padEnd(7));
+        const path = chalk_1.default.white(route.path);
+        const age = formatTimeAgo(route.observedAt);
+        lines.push(`    ${method} ${path}  ${chalk_1.default.gray(`(sample from ${age})`)}`);
+    }
+    return lines.join("\n");
+}
+function formatTimeAgo(isoDate) {
+    try {
+        const date = new Date(isoDate.replace(" ", "T") + (isoDate.includes("Z") ? "" : "Z"));
+        const now = Date.now();
+        const diffSec = Math.floor((now - date.getTime()) / 1000);
+        if (diffSec < 60)
+            return `${diffSec}s ago`;
+        const diffMin = Math.floor(diffSec / 60);
+        if (diffMin < 60)
+            return `${diffMin}m ago`;
+        const diffHr = Math.floor(diffMin / 60);
+        if (diffHr < 24)
+            return `${diffHr}h ago`;
+        const diffDay = Math.floor(diffHr / 24);
+        return `${diffDay}d ago`;
+    }
+    catch {
+        return isoDate;
+    }
+}
+/**
+ * Substitute path params in sample output to match the requested values.
+ * For example, if the sample output has { id: 1 } but the request has :id = "42",
+ * replace numeric id fields with the requested value.
+ */
+function substituteSampleOutput(sample, paramValues) {
+    if (sample === null || sample === undefined)
+        return sample;
+    if (typeof sample !== "object")
+        return sample;
+    if (Array.isArray(sample)) {
+        return sample.map((item) => substituteSampleOutput(item, paramValues));
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(sample)) {
+        // If this key matches a path param name, substitute the value
+        if (key in paramValues) {
+            const paramVal = paramValues[key];
+            // Try to preserve the original type (number vs string)
+            if (typeof value === "number") {
+                const num = Number(paramVal);
+                result[key] = isNaN(num) ? paramVal : num;
+            }
+            else {
+                result[key] = paramVal;
+            }
+        }
+        else if (typeof value === "object" && value !== null) {
+            result[key] = substituteSampleOutput(value, paramValues);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+async function mockCommand(opts) {
+    const port = parseInt(opts.port || "3000", 10);
+    const enableCors = opts.cors !== false;
+    // Fetch mock configuration from the backend
+    let routes;
+    try {
+        const config = await (0, api_client_1.fetchMockConfig)();
+        routes = config.routes;
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            console.error(chalk_1.default.red(`\n  Error fetching mock config: ${err.message}\n`));
+        }
+        process.exit(1);
+    }
+    if (routes.length === 0) {
+        console.log("");
+        console.log(chalk_1.default.yellow("  No API routes found."));
+        console.log(chalk_1.default.gray("  Instrument your app and make some requests first."));
+        console.log("");
+        process.exit(0);
+    }
+    // Build route matchers
+    const matchers = routes.map((route) => {
+        const { regex, paramNames } = pathToRegex(route.path);
+        return { route, regex, paramNames };
+    });
+    // Create the mock HTTP server
+    const server = http.createServer((req, res) => {
+        const reqUrl = new URL(req.url || "/", `http://localhost:${port}`);
+        const reqMethod = (req.method || "GET").toUpperCase();
+        const reqPath = reqUrl.pathname;
+        // CORS headers
+        if (enableCors) {
+            res.setHeader("Access-Control-Allow-Origin", "*");
+            res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
+            res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+        }
+        // Handle preflight
+        if (reqMethod === "OPTIONS") {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        // Find matching route
+        for (const { route, regex, paramNames } of matchers) {
+            if (route.method !== reqMethod)
+                continue;
+            const match = reqPath.match(regex);
+            if (!match)
+                continue;
+            // Extract path params
+            const paramValues = {};
+            for (let i = 0; i < paramNames.length; i++) {
+                paramValues[paramNames[i]] = match[i + 1];
+            }
+            // Get sample output, substituting path param values
+            let output = route.sampleOutput;
+            if (output && Object.keys(paramValues).length > 0) {
+                output = substituteSampleOutput(output, paramValues);
+            }
+            // Log the request
+            const methodColor = reqMethod === "GET" ? chalk_1.default.green :
+                reqMethod === "POST" ? chalk_1.default.yellow :
+                    reqMethod === "PUT" ? chalk_1.default.blue :
+                        reqMethod === "DELETE" ? chalk_1.default.red :
+                            chalk_1.default.white;
+            console.log(`  ${chalk_1.default.gray(new Date().toLocaleTimeString())} ${methodColor(reqMethod.padEnd(7))} ${reqPath} ${chalk_1.default.gray("→ 200")}`);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(output ?? {}));
+            return;
+        }
+        // No route matched
+        console.log(`  ${chalk_1.default.gray(new Date().toLocaleTimeString())} ${chalk_1.default.red(reqMethod.padEnd(7))} ${reqPath} ${chalk_1.default.red("→ 404")}`);
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Not found", path: reqPath, method: reqMethod }));
+    });
+    server.listen(port, () => {
+        console.log("");
+        console.log(chalk_1.default.bold("  Trickle Mock Server"));
+        console.log("");
+        console.log(chalk_1.default.gray("  Routes (from runtime observations):"));
+        console.log(formatRouteTable(routes));
+        console.log("");
+        console.log(`  Listening on ${chalk_1.default.cyan(`http://localhost:${port}`)}`);
+        if (enableCors) {
+            console.log(chalk_1.default.gray("  CORS enabled (Access-Control-Allow-Origin: *)"));
+        }
+        console.log(chalk_1.default.gray("  Press Ctrl+C to stop.\n"));
+    });
+    // Handle graceful shutdown
+    process.on("SIGINT", () => {
+        console.log(chalk_1.default.gray("\n  Stopping mock server...\n"));
+        server.close(() => process.exit(0));
+    });
+    process.on("SIGTERM", () => {
+        server.close(() => process.exit(0));
+    });
+    // Keep process alive
+    await new Promise(() => { });
+}

package/dist/commands/openapi.d.ts

@@ -0,0 +1,8 @@
+export interface OpenApiOptions {
+    out?: string;
+    env?: string;
+    title?: string;
+    apiVersion?: string;
+    server?: string;
+}
+export declare function openapiCommand(opts: OpenApiOptions): Promise<void>;