@alcedocore/cli 0.0.1-rc.0

package/dist/commands/init.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = void 0;
+const commander_1 = require("commander");
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const logger_1 = require("../utils/logger");
+const ejs_renderer_1 = require("../utils/ejs-renderer");
+const config_1 = require("../config");
+const node_readline_1 = __importDefault(require("node:readline"));
+exports.initCommand = new commander_1.Command("init")
+    .argument("<name>", "Plugin project name (e.g., my-plugin)")
+    .option("-l, --language <language>", "Plugin language (python or node)")
+    .description("Scaffold a new plugin project")
+    .action(async (name, options, cmd) => {
+    const config = (0, config_1.loadConfig)(cmd.optsWithGlobals());
+    const pluginDir = config.pluginDir || process.cwd();
+    const targetDir = node_path_1.default.resolve(pluginDir, name);
+    const slug = slugify(name);
+    if (node_fs_1.default.existsSync(targetDir)) {
+        (0, logger_1.error)(`Directory already exists: ${targetDir}`);
+        process.exit(1);
+    }
+    const language = options.language
+        ? parseLanguage(options.language)
+        : await promptLanguage();
+    const templatesDir = node_path_1.default.resolve(__dirname, "../../templates");
+    const registryUrl = config.registryUrl || "localhost:5000";
+    const data = {
+        name,
+        slug,
+        version: "1.0.0",
+        description: `A new AlcedoCore plugin`,
+        language,
+        registryUrl,
+    };
+    const spinner = (0, logger_1.createSpinner)(`Scaffolding plugin: ${name}`);
+    try {
+        // Create target directory
+        node_fs_1.default.mkdirSync(targetDir, { recursive: true });
+        // Generate files from templates
+        // manifest.json
+        (0, ejs_renderer_1.renderAndWrite)(node_path_1.default.join(templatesDir, "plugin", "manifest.json.ejs"), node_path_1.default.join(targetDir, "manifest.json"), data);
+        // Dockerfile (language-specific)
+        const dockerTemplate = language === "python"
+            ? "Dockerfile.ejs"
+            : "Dockerfile.node.ejs";
+        (0, ejs_renderer_1.renderAndWrite)(node_path_1.default.join(templatesDir, "plugin", dockerTemplate), node_path_1.default.join(targetDir, "Dockerfile"), data);
+        // Server stub (language-specific)
+        const serverTemplate = language === "python" ? "server.py.ejs" : "server.js.ejs";
+        (0, ejs_renderer_1.renderAndWrite)(node_path_1.default.join(templatesDir, "plugin", serverTemplate), node_path_1.default.join(targetDir, `server.${language === "python" ? "py" : "js"}`), data);
+        // .gitignore
+        (0, ejs_renderer_1.renderAndWrite)(node_path_1.default.join(templatesDir, "plugin", "gitignore.ejs"), node_path_1.default.join(targetDir, ".gitignore"), data);
+        // README.md
+        (0, ejs_renderer_1.renderAndWrite)(node_path_1.default.join(templatesDir, "plugin", "README.md.ejs"), node_path_1.default.join(targetDir, "README.md"), data);
+        copyGitkeep(templatesDir, targetDir, "migrations");
+        copyGitkeep(templatesDir, targetDir, "pages");
+        copyGitkeep(templatesDir, targetDir, "public");
+        spinner.succeed();
+        (0, logger_1.success)(`Plugin scaffolded: ${targetDir}`);
+        (0, logger_1.info)(`Next steps:
+      cd ${name}
+      # Edit server.${language === "python" ? "py" : "js"} and manifest.json
+      # Build with: docker build -t ${registryUrl}/${slug}:1.0.0 .`);
+    }
+    catch (err) {
+        spinner.fail();
+        (0, logger_1.error)(`Failed to scaffold plugin: ${err.message}`);
+        process.exit(1);
+    }
+});
+function promptLanguage() {
+    const rl = node_readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question("Select plugin language (python/node): ", (answer) => {
+            rl.close();
+            const lang = answer.trim().toLowerCase();
+            if (lang === "python" || lang === "py") {
+                resolve("python");
+            }
+            else if (lang === "node" ||
+                lang === "nodejs" ||
+                lang === "javascript" ||
+                lang === "js") {
+                resolve("node");
+            }
+            else {
+                // Default to python on invalid input, matching hello-world
+                (0, logger_1.info)(`Unknown language "${lang}", defaulting to Python`);
+                resolve("python");
+            }
+        });
+    });
+}
+function slugify(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "");
+}
+function copyGitkeep(templateDir, targetDir, subDir) {
+    const src = node_path_1.default.join(templateDir, "plugin", subDir, ".gitkeep");
+    const dest = node_path_1.default.join(targetDir, subDir, ".gitkeep");
+    if (node_fs_1.default.existsSync(src)) {
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(dest), { recursive: true });
+        node_fs_1.default.writeFileSync(dest, "");
+    }
+}
+function parseLanguage(lang) {
+    const v = lang.trim().toLowerCase();
+    if (v === "python" || v === "py")
+        return "python";
+    if (v === "node" || v === "nodejs" || v === "javascript" || v === "js")
+        return "node";
+    throw new Error(`Unknown language "${lang}". Use "python" or "node".`);
+}
+//# sourceMappingURL=init.js.map

package/dist/commands/init.test.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+(0, vitest_1.describe)("Init command", () => {
+    const testDir = node_path_1.default.join(node_os_1.default.tmpdir(), `alcedo-test-init-${Date.now()}`);
+    (0, vitest_1.beforeAll)(() => {
+        node_fs_1.default.mkdirSync(testDir, { recursive: true });
+    });
+    (0, vitest_1.afterAll)(() => {
+        node_fs_1.default.rmSync(testDir, { recursive: true, force: true });
+    });
+    (0, vitest_1.it)("validates slug format correctly", () => {
+        // Test the validation logic used by init command
+        const validSlugs = ["my-plugin", "hello-world", "test123"];
+        const invalidSlugs = ["My Plugin", "my_plugin", "", "UPPERCASE"];
+        // The validation function requires lowercase alphanumeric + hyphens
+        const isValid = (slug) => slug.length > 0 && /^[a-z0-9]+(-[a-z0-9]+)*$/.test(slug);
+        for (const slug of validSlugs) {
+            (0, vitest_1.expect)(isValid(slug)).toBe(true);
+        }
+        for (const slug of invalidSlugs) {
+            (0, vitest_1.expect)(isValid(slug)).toBe(false);
+        }
+    });
+    (0, vitest_1.it)("generates valid plugin directory structure", () => {
+        // Verify the expected directory structure matches what init would create
+        const expectedDirs = ["migrations", "pages"];
+        for (const dir of expectedDirs) {
+            const dirPath = node_path_1.default.join(testDir, dir);
+            node_fs_1.default.mkdirSync(dirPath, { recursive: true });
+            (0, vitest_1.expect)(node_fs_1.default.existsSync(dirPath)).toBe(true);
+        }
+        // Verify key files that init should generate
+        const expectedFiles = ["manifest.json", "Dockerfile", "server.py"];
+        for (const file of expectedFiles) {
+            const filePath = node_path_1.default.join(testDir, file);
+            // Only test structure, not content — init command generates these via templates
+            if (file === "manifest.json") {
+                node_fs_1.default.writeFileSync(filePath, JSON.stringify({
+                    slug: "test-plugin",
+                    version: "1.0.0",
+                    plugin_type: "dynamic",
+                }));
+            }
+            if (file === "Dockerfile") {
+                node_fs_1.default.writeFileSync(filePath, "FROM python:3.11-slim\n");
+            }
+            if (file === "server.py") {
+                node_fs_1.default.writeFileSync(filePath, 'print("hello")\n');
+            }
+            (0, vitest_1.expect)(node_fs_1.default.existsSync(filePath)).toBe(true);
+        }
+    });
+    (0, vitest_1.it)("generates versioned migration filenames correctly", () => {
+        // Migration filenames follow pattern: YYYYMMDD_<name>.up.sql
+        const date = "20260527";
+        const name = "create_users_table";
+        const upFilename = `${date}_${name}.up.sql`;
+        const downFilename = `${date}_${name}.down.sql`;
+        (0, vitest_1.expect)(upFilename).toMatch(/^\d{8}_.+\.up\.sql$/);
+        (0, vitest_1.expect)(downFilename).toMatch(/^\d{8}_.+\.down\.sql$/);
+    });
+    (0, vitest_1.it)("generates endpoint handler with correct structure", () => {
+        // Endpoint template generates: slug-safe endpoint path + handler stub
+        const endpointName = "user-data";
+        const expectedMethod = "GET";
+        // Simulate the manifest endpoint entry format
+        const endpointEntry = {
+            method: expectedMethod,
+            path: `/${endpointName}`,
+            handler: `${endpointName}_handler`,
+        };
+        (0, vitest_1.expect)(endpointEntry.path).toBe(`/${endpointName}`);
+        (0, vitest_1.expect)(endpointEntry.method).toBe(expectedMethod);
+        (0, vitest_1.expect)(endpointEntry.handler).toBeTruthy();
+    });
+});
+//# sourceMappingURL=init.test.js.map

package/dist/commands/migrate.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateCommand = void 0;
+const commander_1 = require("commander");
+const logger_1 = require("../utils/logger");
+const add_migration_1 = require("./add-migration");
+const generateCommand = new commander_1.Command("generate")
+    .argument("<name>", "Migration name (e.g., create_users_table)")
+    .description("Alias for `alcedo add migration` — generate a versioned SQL migration pair")
+    .action(async (name) => {
+    try {
+        await (0, add_migration_1.addMigrationAction)(name);
+    }
+    catch (err) {
+        (0, logger_1.error)(`Generate failed: ${err.message}`);
+        process.exit(1);
+    }
+});
+exports.migrateCommand = new commander_1.Command("migrate")
+    .description("Alias for `alcedo add migration`");
+exports.migrateCommand.addCommand(generateCommand);
+//# sourceMappingURL=migrate.js.map

package/dist/commands/proxy.js

@@ -0,0 +1,157 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxyCommand = void 0;
+const commander_1 = require("commander");
+const node_http_1 = __importDefault(require("node:http"));
+const node_path_1 = __importDefault(require("node:path"));
+const config_1 = require("../config");
+const logger_1 = require("../utils/logger");
+exports.proxyCommand = new commander_1.Command("proxy")
+    .description("Start a dev proxy that forwards requests to a local dev server")
+    .option("-p, --port <port>", "Proxy listen port", "3099")
+    .option("-t, --target <url>", "Target dev server URL (e.g., localhost:8080)", "localhost:3000")
+    .option("-k, --api-key <key>", "Core API key (or ALCEDO_API_KEY env var)")
+    .action(async (opts, cmd) => {
+    const config = (0, config_1.loadConfig)(cmd.optsWithGlobals());
+    const coreUrl = config.coreUrl || "http://localhost:8080";
+    const pluginDir = node_path_1.default.resolve(config.pluginDir || process.cwd());
+    const slug = node_path_1.default.basename(pluginDir);
+    const apiKey = opts.apiKey || config.apiKey || process.env.ALCEDO_API_KEY || "";
+    const proxyPort = parseInt(opts.port || "3099", 10);
+    const target = opts.target || "localhost:3000";
+    if (isNaN(proxyPort) || proxyPort < 1 || proxyPort > 65535) {
+        (0, logger_1.error)(`Invalid proxy port: ${opts.port}`);
+        process.exit(1);
+    }
+    const parsedTarget = parseTarget(target);
+    const validateSpinner = (0, logger_1.createSpinner)("Validating API key...");
+    const testId = await registerRequest(coreUrl, apiKey || undefined, slug);
+    if (!testId) {
+        validateSpinner.fail();
+        (0, logger_1.error)(`Failed to connect to core at ${coreUrl}`);
+        (0, logger_1.error)("Make sure the AlcedoCore instance is running and API key is correct");
+        process.exit(1);
+    }
+    validateSpinner.succeed();
+    const server = node_http_1.default.createServer(async (clientReq, clientRes) => {
+        const startTime = Date.now();
+        const requestId = await registerRequest(coreUrl, apiKey || undefined, slug);
+        if (!requestId) {
+            (0, logger_1.error)("Failed to register request ID with core");
+            clientRes.statusCode = 502;
+            clientRes.setHeader("Content-Type", "text/plain");
+            clientRes.end("Bad Gateway: core unavailable");
+            return;
+        }
+        // Clone headers and inject X-Request-ID
+        const headers = {};
+        for (const [key, value] of Object.entries(clientReq.headers)) {
+            if (value !== undefined) {
+                headers[key] = Array.isArray(value)
+                    ? value.join(", ")
+                    : value;
+            }
+        }
+        headers["X-Request-ID"] = requestId;
+        headers["host"] = `${parsedTarget.hostname}:${parsedTarget.port}`;
+        const options = {
+            hostname: parsedTarget.hostname,
+            port: parsedTarget.port,
+            path: clientReq.url,
+            method: clientReq.method,
+            headers,
+        };
+        const proxyReq = node_http_1.default.request(options, (proxyRes) => {
+            const chunks = [];
+            proxyRes.on("data", (chunk) => chunks.push(chunk));
+            proxyRes.on("end", () => {
+                const duration = Date.now() - startTime;
+                const statusCode = proxyRes.statusCode || 0;
+                (0, logger_1.info)(`  ${statusCode} ${clientReq.method} ${duration}ms ${clientReq.url}`);
+                const responseHeaders = { ...proxyRes.headers };
+                clientRes.writeHead(statusCode, responseHeaders);
+                clientRes.end(Buffer.concat(chunks));
+            });
+        });
+        proxyReq.on("error", (err) => {
+            (0, logger_1.error)(`Proxy request error: ${err.message}`);
+            if (!clientRes.headersSent) {
+                clientRes.statusCode = 502;
+                clientRes.setHeader("Content-Type", "text/plain");
+                clientRes.end(`Bad Gateway: ${err.message}`);
+            }
+        });
+        clientReq.pipe(proxyReq);
+    });
+    let shuttingDown = false;
+    function handleShutdown() {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        console.log("");
+        (0, logger_1.info)("Shutting down proxy...");
+        server.close(() => {
+            (0, logger_1.success)("Proxy stopped");
+            process.exit(0);
+        });
+        setTimeout(() => {
+            (0, logger_1.warn)("Proxy did not close gracefully, forcing exit");
+            process.exit(0);
+        }, 3000);
+    }
+    process.on("SIGINT", handleShutdown);
+    process.on("SIGTERM", handleShutdown);
+    process.on("SIGHUP", handleShutdown);
+    server.listen(proxyPort, () => {
+        (0, logger_1.success)(`Dev proxy listening on http://localhost:${proxyPort}`);
+        (0, logger_1.info)(`Forwarding to http://${target}`);
+        (0, logger_1.info)(`Plugin slug: ${slug}`);
+        (0, logger_1.info)(`Core URL: ${coreUrl}`);
+        if (apiKey) {
+            (0, logger_1.info)("API key authentication enabled");
+        }
+        (0, logger_1.info)("Press Ctrl+C to stop");
+    });
+});
+async function coreFetch(coreUrl, apiKey, endpoint, body) {
+    try {
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        if (apiKey) {
+            headers["Authorization"] = `Bearer ${apiKey}`;
+        }
+        return await fetch(`${coreUrl.replace(/\/$/, "")}${endpoint}`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+        });
+    }
+    catch {
+        return null;
+    }
+}
+async function registerRequest(coreUrl, apiKey, slug) {
+    const res = await coreFetch(coreUrl, apiKey, "/api/dev/request-id", {
+        slug,
+    });
+    if (!res || !res.ok)
+        return null;
+    try {
+        const data = (await res.json());
+        return data.request_id;
+    }
+    catch {
+        return null;
+    }
+}
+function parseTarget(target) {
+    let cleaned = target.replace(/^https?:\/\//, "");
+    const [hostname, portStr] = cleaned.split(":");
+    const port = portStr ? parseInt(portStr, 10) : 3000;
+    return { hostname, port };
+}
+//# sourceMappingURL=proxy.js.map

package/dist/commands/publish.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publishCommand = void 0;
+const commander_1 = require("commander");
+const logger_1 = require("../utils/logger");
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../config");
+const fs_1 = require("fs");
+const child_process_1 = require("child_process");
+exports.publishCommand = new commander_1.Command("publish")
+    .description("Build and push a plugin to an image registry")
+    .action(async (slug, options, cmd) => {
+    const spinner = (0, logger_1.createSpinner)(`Preparing build...`);
+    const config = (0, config_1.loadConfig)();
+    const pluginDir = config.pluginDir || process.cwd();
+    const manifestPath = path_1.default.resolve(pluginDir, "manifest.json");
+    const dockerFilePath = path_1.default.resolve(pluginDir, "Dockerfile");
+    if (!(0, fs_1.existsSync)(manifestPath)) {
+        spinner.fail();
+        (0, logger_1.error)(`Could not build, manifest.json is missing!`);
+        process.exit(1);
+    }
+    if (!config.registryUrl) {
+        spinner.fail();
+        (0, logger_1.error)(`Registery URL not set`);
+        process.exit(1);
+    }
+    if (!(0, fs_1.existsSync)(dockerFilePath)) {
+        spinner.fail();
+        (0, logger_1.error)(`Could not build, Dockerfile is missing!`);
+        process.exit(1);
+    }
+    if (!checkDocker) {
+        spinner.fail();
+        (0, logger_1.error)(`Could not build, Docker is unreachable!`);
+        process.exit(1);
+    }
+    const manifest = JSON.parse((0, fs_1.readFileSync)(manifestPath, "utf-8"));
+    try {
+        spinner.text = "Building Docker image...";
+        await buildDockerImage(pluginDir, config.registryUrl, manifest.name, manifest.version);
+        (0, logger_1.success)(`Plugin has been build`);
+        spinner.text = "Pushing Docker image...";
+        await pushDockerImage(config.registryUrl, manifest.name, manifest.version);
+        spinner.succeed();
+        (0, logger_1.success)(`Plugin has been build and pushed under ${manifest.name}:${manifest.version}`);
+    }
+    catch (err) {
+        spinner.fail();
+        (0, logger_1.error)(`Failed to deploy: ${err.message}`);
+        process.exit(1);
+    }
+});
+function buildDockerImage(pluginDir, registryURL, image, version) {
+    (0, child_process_1.execSync)(`docker build -t ${registryURL}/${image}:${version} ${pluginDir}`, {
+        stdio: "pipe",
+    });
+    return true;
+}
+function pushDockerImage(registryURL, image, version) {
+    (0, child_process_1.execSync)(`docker push ${registryURL}/${image}:${version}`, {
+        stdio: "pipe",
+    });
+    return true;
+}
+function checkDocker() {
+    try {
+        (0, child_process_1.execSync)("docker info --format '{{.ServerVersion}}'", {
+            stdio: "pipe",
+            timeout: 5000,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=publish.js.map

package/dist/commands/replay.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replayCommand = void 0;
+const commander_1 = require("commander");
+const config_js_1 = require("../config.js");
+const chalk_1 = __importDefault(require("chalk"));
+const logger_js_1 = require("../utils/logger.js");
+// ---------------------------------------------------------------------------
+// API helper — fetch request details from core
+// ---------------------------------------------------------------------------
+async function fetchRequestDetail(coreUrl, slug, requestId, apiKey) {
+    const url = `${coreUrl.replace(/\/$/, "")}/api/plugins/${slug}/logs/${requestId}`;
+    const headers = { "Content-Type": "application/json" };
+    if (apiKey) {
+        headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+    const res = await fetch(url, { headers });
+    if (!res.ok) {
+        const errBody = await res.json().catch(() => ({ error: res.statusText }));
+        throw new Error(errBody.error || `HTTP ${res.status}: ${res.statusText}`);
+    }
+    const body = await res.json();
+    if (!body.data) {
+        throw new Error(body.error || "Empty response from detail endpoint");
+    }
+    return body.data.request;
+}
+async function replayRequest(devUrl, original, timeoutMs) {
+    const path = original.path || "/";
+    const targetUrl = `${devUrl.replace(/\/$/, "")}/${path.replace(/^\//, "")}`;
+    const headers = {};
+    if (original.request_headers) {
+        const skipHeaders = new Set(["host", "content-length", "transfer-encoding", "x-request-id"]);
+        for (const [key, value] of Object.entries(original.request_headers)) {
+            if (!skipHeaders.has(key.toLowerCase())) {
+                headers[key] = value;
+            }
+        }
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const startTime = Date.now();
+        const res = await fetch(targetUrl, {
+            method: original.method,
+            headers,
+            body: original.request_body || undefined,
+            signal: controller.signal,
+        });
+        const duration = Date.now() - startTime;
+        const resBody = await res.text();
+        return {
+            original: { status_code: original.status_code, duration_ms: original.duration_ms },
+            replayed: { status_code: res.status, duration_ms: duration, body: resBody.length > 500 ? resBody.slice(0, 500) + "\n... (truncated)" : resBody },
+            statusMatch: original.status_code === res.status,
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+// ---------------------------------------------------------------------------
+// Display helpers
+// ---------------------------------------------------------------------------
+function displayComparison(result) {
+    const statusIcon = result.statusMatch ? chalk_1.default.green("✓") : chalk_1.default.red("✗");
+    console.log("");
+    console.log(chalk_1.default.bold("  Response Comparison:"));
+    console.log(chalk_1.default.bold("  ─────────────────────"));
+    console.log(`  ${chalk_1.default.bold("Status Code:")}    Original: ${chalk_1.default.cyan(String(result.original.status_code))}  →  Replayed: ${chalk_1.default.cyan(String(result.replayed.status_code))}  ${statusIcon}`);
+    console.log(`  ${chalk_1.default.bold("Duration:")}        Original: ${chalk_1.default.cyan(`${result.original.duration_ms}ms`)}  →  Replayed: ${chalk_1.default.cyan(`${result.replayed.duration_ms}ms`)}`);
+    if (!result.statusMatch) {
+        (0, logger_js_1.warn)(`  Status code mismatch: expected ${result.original.status_code}, got ${result.replayed.status_code}`);
+    }
+    if (result.replayed.body) {
+        console.log("");
+        console.log(chalk_1.default.bold("  Replayed Response Body:"));
+        console.log(`  ${result.replayed.body}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Main replay command
+// ---------------------------------------------------------------------------
+exports.replayCommand = new commander_1.Command("replay")
+    .description("Replay a historical request against the local dev server")
+    .argument("<requestId>", "Request UUID from the plugin logs")
+    .option("--dev-port <port>", "Local dev server port", "3000")
+    .option("-t, --timeout <ms>", "Request timeout in milliseconds", "30000")
+    .option("--api-key <key>", "API key for core authentication")
+    .action(async (requestId, opts, cmd) => {
+    const config = (0, config_js_1.loadConfig)(cmd.optsWithGlobals());
+    const coreUrl = config.coreUrl || "http://localhost:8080";
+    const pluginDir = config.pluginDir || process.cwd();
+    const slug = require("node:path").basename(pluginDir);
+    const port = parseInt(opts.devPort || "3000", 10);
+    const timeout = parseInt(opts.timeout || "30000", 10);
+    const apiKey = opts.apiKey || process.env.ALCEDO_API_KEY || "";
+    if (isNaN(port) || port < 1 || port > 65535) {
+        (0, logger_js_1.error)(`Invalid port: ${opts.devPort}`);
+        process.exit(1);
+    }
+    const devUrl = `http://localhost:${port}`;
+    // Step 1: Fetch original request details
+    const fetchSpinner = (0, logger_js_1.createSpinner)(`Fetching request ${requestId}...`);
+    let requestDetail;
+    try {
+        requestDetail = await fetchRequestDetail(coreUrl, slug, requestId, apiKey || undefined);
+        fetchSpinner.succeed();
+    }
+    catch (err) {
+        fetchSpinner.fail();
+        (0, logger_js_1.error)(`Failed to fetch request details: ${err.message}`);
+        process.exit(1);
+    }
+    (0, logger_js_1.info)(`Original request: ${requestDetail.method} ${requestDetail.path}`);
+    (0, logger_js_1.info)(`  Status: ${requestDetail.status_code} (${requestDetail.duration_ms}ms)`);
+    (0, logger_js_1.info)(`  Timestamp: ${requestDetail.created_at}`);
+    // Step 2: Replay against dev server
+    const replaySpinner = (0, logger_js_1.createSpinner)(`Replaying against ${devUrl}...`);
+    try {
+        const result = await replayRequest(devUrl, requestDetail, timeout);
+        replaySpinner.succeed();
+        displayComparison(result);
+        if (result.statusMatch) {
+            (0, logger_js_1.success)("Response status matches original");
+        }
+    }
+    catch (err) {
+        replaySpinner.fail();
+        if (err.name === "AbortError") {
+            (0, logger_js_1.error)(`Request timed out after ${timeout}ms`);
+        }
+        else {
+            (0, logger_js_1.error)(`Replay failed: ${err.message}`);
+        }
+        process.exit(1);
+    }
+});
+//# sourceMappingURL=replay.js.map