@juspay/neurolink 10.0.0 → 10.1.0

package/dist/cli/commands/observability.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-/* eslint-disable no-console, curly */
 /**
  * NeuroLink CLI Observability Commands
  *
@@ -14,6 +13,7 @@ import ora from "ora";
 import { logger } from "../../lib/utils/logger.js";
 import { NeuroLink } from "../../lib/neurolink.js";
 import { formatRow, formatCost } from "../utils/formatters.js";
+import { redactUrlCredentials } from "../../lib/utils/logSanitize.js";
 /**
  * Observability Command Factory
  */
@@ -70,67 +70,72 @@ export class ObservabilityCommandFactory {
                 try {
                     const neurolink = new NeuroLink();
                     const status = neurolink.getTelemetryStatus();
-                    if (spinner)
+                    if (spinner) {
                         spinner.succeed("Status retrieved");
+                    }
                     if (args.format === "json") {
-                        console.log(JSON.stringify(status, null, 2));
+                        logger.always(JSON.stringify(status, (_key, value) => typeof value === "string" &&
+                            (_key === "baseUrl" || _key === "endpoint")
+                            ? redactUrlCredentials(value)
+                            : value, 2));
                     }
                     else {
-                        console.log("");
-                        console.log(chalk.bold.cyan("=== Observability Status ==="));
-                        console.log("");
+                        logger.always("");
+                        logger.always(chalk.bold.cyan("=== Observability Status ==="));
+                        logger.always("");
                         // Telemetry enabled status
                         const enabledIcon = status.enabled
                             ? chalk.green("ON")
                             : chalk.red("OFF");
-                        console.log(formatRow("Telemetry:", enabledIcon));
+                        logger.always(formatRow("Telemetry:", enabledIcon));
                         // Langfuse status
                         if (status.langfuse) {
-                            console.log("");
-                            console.log(chalk.bold("Langfuse:"));
+                            logger.always("");
+                            logger.always(chalk.bold("Langfuse:"));
                             const lfStatus = status.langfuse.enabled
                                 ? chalk.green("Enabled")
                                 : chalk.gray("Disabled");
-                            console.log(formatRow("  Status:", lfStatus));
+                            logger.always(formatRow("  Status:", lfStatus));
                             if (status.langfuse.baseUrl) {
-                                console.log(formatRow("  URL:", status.langfuse.baseUrl));
+                                logger.always(formatRow("  URL:", redactUrlCredentials(status.langfuse.baseUrl)));
                             }
                             if (status.langfuse.environment) {
-                                console.log(formatRow("  Environment:", status.langfuse.environment));
+                                logger.always(formatRow("  Environment:", status.langfuse.environment));
                             }
                         }
                         // OpenTelemetry status
                         if (status.openTelemetry) {
-                            console.log("");
-                            console.log(chalk.bold("OpenTelemetry:"));
+                            logger.always("");
+                            logger.always(chalk.bold("OpenTelemetry:"));
                             const otelStatus = status.openTelemetry.enabled
                                 ? chalk.green("Enabled")
                                 : chalk.gray("Disabled");
-                            console.log(formatRow("  Status:", otelStatus));
+                            logger.always(formatRow("  Status:", otelStatus));
                             if (status.openTelemetry.endpoint) {
-                                console.log(formatRow("  Endpoint:", status.openTelemetry.endpoint));
+                                logger.always(formatRow("  Endpoint:", redactUrlCredentials(status.openTelemetry.endpoint)));
                             }
                             if (status.openTelemetry.serviceName) {
-                                console.log(formatRow("  Service:", status.openTelemetry.serviceName));
+                                logger.always(formatRow("  Service:", status.openTelemetry.serviceName));
                             }
                         }
                         // Exporters summary
                         if (status.exporters && status.exporters.length > 0) {
-                            console.log("");
-                            console.log(chalk.bold("Active Exporters:"));
+                            logger.always("");
+                            logger.always(chalk.bold("Active Exporters:"));
                             for (const exporter of status.exporters) {
                                 const exporterStatus = exporter.healthy
                                     ? chalk.green("Healthy")
                                     : chalk.red("Unhealthy");
-                                console.log(formatRow(`  ${exporter.name}:`, exporterStatus));
+                                logger.always(formatRow(`  ${exporter.name}:`, exporterStatus));
                             }
                         }
-                        console.log("");
+                        logger.always("");
                     }
                 }
                 catch (error) {
-                    if (spinner)
+                    if (spinner) {
                         spinner.fail("Failed to get status");
+                    }
                     logger.error("Error:", error instanceof Error ? error.message : String(error));
                     process.exit(1);
                 }
@@ -171,74 +176,76 @@ export class ObservabilityCommandFactory {
                 try {
                     const neurolink = new NeuroLink();
                     const metrics = neurolink.getMetrics();
-                    if (spinner)
+                    if (spinner) {
                         spinner.succeed("Metrics retrieved");
+                    }
                     if (args.format === "json") {
-                        console.log(JSON.stringify(metrics, null, 2));
+                        logger.always(JSON.stringify(metrics, null, 2));
                     }
                     else {
-                        console.log("");
-                        console.log(chalk.bold.cyan("=== Metrics Summary ==="));
-                        console.log("");
+                        logger.always("");
+                        logger.always(chalk.bold.cyan("=== Metrics Summary ==="));
+                        logger.always("");
                         // Request statistics
-                        console.log(chalk.bold("Request Statistics:"));
-                        console.log(formatRow("  Total requests:", metrics.totalSpans.toLocaleString()));
-                        console.log(formatRow("  Successful:", metrics.successfulSpans.toLocaleString()));
-                        console.log(formatRow("  Failed:", metrics.failedSpans.toLocaleString()));
-                        console.log(formatRow("  Success rate:", `${(metrics.successRate * 100).toFixed(2)}%`));
+                        logger.always(chalk.bold("Request Statistics:"));
+                        logger.always(formatRow("  Total requests:", metrics.totalSpans.toLocaleString()));
+                        logger.always(formatRow("  Successful:", metrics.successfulSpans.toLocaleString()));
+                        logger.always(formatRow("  Failed:", metrics.failedSpans.toLocaleString()));
+                        logger.always(formatRow("  Success rate:", `${(metrics.successRate * 100).toFixed(2)}%`));
                         // Latency statistics
                         if (metrics.latency && metrics.latency.count > 0) {
-                            console.log("");
-                            console.log(chalk.bold("Latency (ms):"));
-                            console.log(formatRow("  Min:", metrics.latency.min.toFixed(2)));
-                            console.log(formatRow("  Max:", metrics.latency.max.toFixed(2)));
-                            console.log(formatRow("  Mean:", metrics.latency.mean.toFixed(2)));
-                            console.log(formatRow("  P50:", metrics.latency.p50.toFixed(2)));
-                            console.log(formatRow("  P95:", metrics.latency.p95.toFixed(2)));
-                            console.log(formatRow("  P99:", metrics.latency.p99.toFixed(2)));
+                            logger.always("");
+                            logger.always(chalk.bold("Latency (ms):"));
+                            logger.always(formatRow("  Min:", metrics.latency.min.toFixed(2)));
+                            logger.always(formatRow("  Max:", metrics.latency.max.toFixed(2)));
+                            logger.always(formatRow("  Mean:", metrics.latency.mean.toFixed(2)));
+                            logger.always(formatRow("  P50:", metrics.latency.p50.toFixed(2)));
+                            logger.always(formatRow("  P95:", metrics.latency.p95.toFixed(2)));
+                            logger.always(formatRow("  P99:", metrics.latency.p99.toFixed(2)));
                             if (args.detailed) {
-                                console.log(formatRow("  P75:", metrics.latency.p75.toFixed(2)));
-                                console.log(formatRow("  P90:", metrics.latency.p90.toFixed(2)));
-                                console.log(formatRow("  Std Dev:", metrics.latency.stdDev.toFixed(2)));
+                                logger.always(formatRow("  P75:", metrics.latency.p75.toFixed(2)));
+                                logger.always(formatRow("  P90:", metrics.latency.p90.toFixed(2)));
+                                logger.always(formatRow("  Std Dev:", metrics.latency.stdDev.toFixed(2)));
                             }
                         }
                         // Token statistics
                         if (metrics.tokens) {
-                            console.log("");
-                            console.log(chalk.bold("Token Usage:"));
-                            console.log(formatRow("  Input tokens:", metrics.tokens.totalInputTokens.toLocaleString()));
-                            console.log(formatRow("  Output tokens:", metrics.tokens.totalOutputTokens.toLocaleString()));
-                            console.log(formatRow("  Total tokens:", metrics.tokens.totalTokens.toLocaleString()));
+                            logger.always("");
+                            logger.always(chalk.bold("Token Usage:"));
+                            logger.always(formatRow("  Input tokens:", metrics.tokens.totalInputTokens.toLocaleString()));
+                            logger.always(formatRow("  Output tokens:", metrics.tokens.totalOutputTokens.toLocaleString()));
+                            logger.always(formatRow("  Total tokens:", metrics.tokens.totalTokens.toLocaleString()));
                             if (args.detailed &&
                                 metrics.tokens.cacheReadTokens &&
                                 metrics.tokens.cacheReadTokens > 0) {
-                                console.log(formatRow("  Cache read:", metrics.tokens.cacheReadTokens.toLocaleString()));
+                                logger.always(formatRow("  Cache read:", metrics.tokens.cacheReadTokens.toLocaleString()));
                             }
                             if (args.detailed &&
                                 metrics.tokens.reasoningTokens &&
                                 metrics.tokens.reasoningTokens > 0) {
-                                console.log(formatRow("  Reasoning:", metrics.tokens.reasoningTokens.toLocaleString()));
+                                logger.always(formatRow("  Reasoning:", metrics.tokens.reasoningTokens.toLocaleString()));
                             }
                         }
                         // Cost
                         if (metrics.totalCost !== undefined && metrics.totalCost > 0) {
-                            console.log("");
-                            console.log(chalk.bold("Cost:"));
-                            console.log(formatRow("  Total:", formatCost(metrics.totalCost)));
+                            logger.always("");
+                            logger.always(chalk.bold("Cost:"));
+                            logger.always(formatRow("  Total:", formatCost(metrics.totalCost)));
                         }
                         // Tracking duration
                         if (metrics.trackingDurationMs) {
                             const durationSec = metrics.trackingDurationMs / 1000;
                             const throughput = metrics.totalSpans > 0 ? metrics.totalSpans / durationSec : 0;
-                            console.log("");
-                            console.log(chalk.gray(`Tracking: ${durationSec.toFixed(1)}s (${throughput.toFixed(2)} req/s)`));
+                            logger.always("");
+                            logger.always(chalk.gray(`Tracking: ${durationSec.toFixed(1)}s (${throughput.toFixed(2)} req/s)`));
                         }
-                        console.log("");
+                        logger.always("");
                     }
                 }
                 catch (error) {
-                    if (spinner)
+                    if (spinner) {
                         spinner.fail("Failed to get metrics");
+                    }
                     logger.error("Error:", error instanceof Error ? error.message : String(error));
                     process.exit(1);
                 }
@@ -276,60 +283,62 @@ export class ObservabilityCommandFactory {
                 try {
                     const neurolink = new NeuroLink();
                     const status = neurolink.getTelemetryStatus();
-                    if (spinner)
+                    if (spinner) {
                         spinner.succeed("Exporters retrieved");
+                    }
                     const exporters = status.exporters ?? [];
                     if (args.format === "json") {
-                        console.log(JSON.stringify(exporters, null, 2));
+                        logger.always(JSON.stringify(exporters, null, 2));
                     }
                     else {
-                        console.log("");
-                        console.log(chalk.bold.cyan("=== Configured Exporters ==="));
-                        console.log("");
+                        logger.always("");
+                        logger.always(chalk.bold.cyan("=== Configured Exporters ==="));
+                        logger.always("");
                         if (exporters.length === 0) {
-                            console.log(chalk.gray("No exporters configured."));
-                            console.log("");
-                            console.log("Available exporters:");
-                            console.log("  - Langfuse (langfuse)");
-                            console.log("  - LangSmith (langsmith)");
-                            console.log("  - OpenTelemetry (otel)");
-                            console.log("  - Datadog (datadog)");
-                            console.log("  - Sentry (sentry)");
-                            console.log("  - Braintrust (braintrust)");
-                            console.log("  - Arize (arize)");
-                            console.log("  - PostHog (posthog)");
-                            console.log("  - Laminar (laminar)");
+                            logger.always(chalk.gray("No exporters configured."));
+                            logger.always("");
+                            logger.always("Available exporters:");
+                            logger.always("  - Langfuse (langfuse)");
+                            logger.always("  - LangSmith (langsmith)");
+                            logger.always("  - OpenTelemetry (otel)");
+                            logger.always("  - Datadog (datadog)");
+                            logger.always("  - Sentry (sentry)");
+                            logger.always("  - Braintrust (braintrust)");
+                            logger.always("  - Arize (arize)");
+                            logger.always("  - PostHog (posthog)");
+                            logger.always("  - Laminar (laminar)");
                         }
                         else {
                             for (const exporter of exporters) {
                                 const healthIcon = exporter.healthy
                                     ? chalk.green("[OK]")
                                     : chalk.red("[ERROR]");
-                                console.log(`${healthIcon} ${chalk.bold(exporter.name)}`);
+                                logger.always(`${healthIcon} ${chalk.bold(exporter.name)}`);
                                 if (exporter.latencyMs !== undefined) {
-                                    console.log(formatRow("    Latency:", `${exporter.latencyMs.toFixed(2)}ms`));
+                                    logger.always(formatRow("    Latency:", `${exporter.latencyMs.toFixed(2)}ms`));
                                 }
                                 if (exporter.pendingSpans !== undefined) {
-                                    console.log(formatRow("    Pending spans:", exporter.pendingSpans.toLocaleString()));
+                                    logger.always(formatRow("    Pending spans:", exporter.pendingSpans.toLocaleString()));
                                 }
                                 if (exporter.lastExportTime) {
                                     const lastExport = new Date(exporter.lastExportTime);
-                                    console.log(formatRow("    Last export:", lastExport.toISOString()));
+                                    logger.always(formatRow("    Last export:", lastExport.toISOString()));
                                 }
                                 if (exporter.errors && exporter.errors.length > 0) {
-                                    console.log(chalk.yellow("    Errors:"));
+                                    logger.always(chalk.yellow("    Errors:"));
                                     for (const error of exporter.errors.slice(0, 3)) {
-                                        console.log(chalk.red(`      - ${error}`));
+                                        logger.always(chalk.red(`      - ${error}`));
                                     }
                                 }
-                                console.log("");
+                                logger.always("");
                             }
                         }
                     }
                 }
                 catch (error) {
-                    if (spinner)
+                    if (spinner) {
                         spinner.fail("Failed to get exporters");
+                    }
                     logger.error("Error:", error instanceof Error ? error.message : String(error));
                     process.exit(1);
                 }
@@ -377,8 +386,9 @@ export class ObservabilityCommandFactory {
                 try {
                     const neurolink = new NeuroLink();
                     const metrics = neurolink.getMetrics();
-                    if (spinner)
+                    if (spinner) {
                         spinner.succeed("Costs calculated");
+                    }
                     if (args.format === "json") {
                         const jsonOutput = {
                             totalCost: metrics.totalCost,
@@ -389,60 +399,61 @@ export class ObservabilityCommandFactory {
                         if (args.byModel !== false) {
                             jsonOutput.costByModel = metrics.costByModel;
                         }
-                        console.log(JSON.stringify(jsonOutput, null, 2));
+                        logger.always(JSON.stringify(jsonOutput, null, 2));
                     }
                     else {
-                        console.log("");
-                        console.log(chalk.bold.cyan("=== Cost Breakdown ==="));
-                        console.log("");
+                        logger.always("");
+                        logger.always(chalk.bold.cyan("=== Cost Breakdown ==="));
+                        logger.always("");
                         // Total cost
-                        console.log(chalk.bold(`Total Cost: ${formatCost(metrics.totalCost ?? 0)}`));
+                        logger.always(chalk.bold(`Total Cost: ${formatCost(metrics.totalCost ?? 0)}`));
                         // Cost by provider
                         if (args.byProvider !== false &&
                             metrics.costByProvider &&
                             metrics.costByProvider.length > 0) {
-                            console.log("");
-                            console.log(chalk.bold("By Provider:"));
+                            logger.always("");
+                            logger.always(chalk.bold("By Provider:"));
                             // Sort by cost descending
                             const sortedProviders = [...metrics.costByProvider].sort((a, b) => b.totalCost - a.totalCost);
                             for (const provider of sortedProviders) {
                                 const costStr = formatCost(provider.totalCost);
                                 const avgCost = formatCost(provider.avgCostPerRequest);
-                                console.log(`  ${chalk.cyan(provider.provider.padEnd(15))} ${costStr}`);
-                                console.log(chalk.gray(`    ${provider.requestCount} requests, avg ${avgCost}/req`));
+                                logger.always(`  ${chalk.cyan(provider.provider.padEnd(15))} ${costStr}`);
+                                logger.always(chalk.gray(`    ${provider.requestCount} requests, avg ${avgCost}/req`));
                             }
                         }
                         // Cost by model
                         if (args.byModel !== false &&
                             metrics.costByModel &&
                             metrics.costByModel.length > 0) {
-                            console.log("");
-                            console.log(chalk.bold("By Model:"));
+                            logger.always("");
+                            logger.always(chalk.bold("By Model:"));
                             // Sort by cost descending
                             const sortedModels = [...metrics.costByModel].sort((a, b) => b.totalCost - a.totalCost);
                             for (const model of sortedModels) {
                                 const costStr = formatCost(model.totalCost);
                                 const avgCost = formatCost(model.avgCostPerRequest);
-                                console.log(`  ${chalk.cyan(model.model)}`);
-                                console.log(`    Cost: ${costStr}`);
-                                console.log(chalk.gray(`    ${model.requestCount} requests, avg ${avgCost}/req`));
-                                console.log(chalk.gray(`    ${model.inputTokens.toLocaleString()} input, ${model.outputTokens.toLocaleString()} output tokens`));
+                                logger.always(`  ${chalk.cyan(model.model)}`);
+                                logger.always(`    Cost: ${costStr}`);
+                                logger.always(chalk.gray(`    ${model.requestCount} requests, avg ${avgCost}/req`));
+                                logger.always(chalk.gray(`    ${model.inputTokens.toLocaleString()} input, ${model.outputTokens.toLocaleString()} output tokens`));
                             }
                         }
                         // No cost data
                         if ((!metrics.costByProvider ||
                             metrics.costByProvider.length === 0) &&
                             (!metrics.costByModel || metrics.costByModel.length === 0)) {
-                            console.log("");
-                            console.log(chalk.gray("No cost data available."));
-                            console.log(chalk.gray("Cost tracking is recorded when observability is enabled."));
+                            logger.always("");
+                            logger.always(chalk.gray("No cost data available."));
+                            logger.always(chalk.gray("Cost tracking is recorded when observability is enabled."));
                         }
-                        console.log("");
+                        logger.always("");
                     }
                 }
                 catch (error) {
-                    if (spinner)
+                    if (spinner) {
                         spinner.fail("Failed to get costs");
+                    }
                     logger.error("Error:", error instanceof Error ? error.message : String(error));
                     process.exit(1);
                 }

package/dist/cli/commands/proxyReplay.d.ts

@@ -0,0 +1,3 @@
+import type { CommandModule } from "yargs";
+import type { ProxyReplayArgs } from "../../lib/types/index.js";
+export declare const proxyReplayCommand: CommandModule<object, ProxyReplayArgs>;

package/dist/cli/commands/proxyReplay.js

@@ -0,0 +1,175 @@
+import { readFile, stat } from "node:fs/promises";
+import { resolve } from "node:path";
+import chalk from "chalk";
+import { compareProxyReplayBundle, exportProxyReplayBundle, isValidProxyReplayHeaderName, readProxyReplayBundle, writeProxyReplayDocument, } from "../../lib/proxy/proxyReplay.js";
+import { logger } from "../../lib/utils/logger.js";
+const ACTIONS = ["export", "compare"];
+const MAX_BODY_OVERRIDE_BYTES = 16 * 1024 * 1024;
+function requiredValue(value, option) {
+    if (!value) {
+        throw new Error(`${option} is required for this action`);
+    }
+    return value;
+}
+function resolveHeaderValues(mappings) {
+    const values = {};
+    for (const mapping of mappings ?? []) {
+        const separator = mapping.indexOf("=");
+        if (separator <= 0 || separator === mapping.length - 1) {
+            throw new Error(`Invalid --header-env value "${mapping}". Use header-name=ENV_VAR.`);
+        }
+        const header = mapping.slice(0, separator).trim().toLowerCase();
+        if (!isValidProxyReplayHeaderName(header)) {
+            throw new Error(`Invalid header name in --header-env: ${header}`);
+        }
+        const environmentName = mapping.slice(separator + 1).trim();
+        const value = process.env[environmentName];
+        if (!value) {
+            throw new Error(`Environment variable ${environmentName} is empty or unset for header ${header}`);
+        }
+        values[header] = value;
+    }
+    return values;
+}
+async function readBodyOverride(filePath) {
+    if (!filePath) {
+        return undefined;
+    }
+    const resolvedPath = resolve(filePath);
+    const info = await stat(resolvedPath);
+    if (!info.isFile() || info.size > MAX_BODY_OVERRIDE_BYTES) {
+        throw new Error(`Body override must be a regular file no larger than ${MAX_BODY_OVERRIDE_BYTES} bytes`);
+    }
+    return readFile(resolvedPath, "utf8");
+}
+function printResult(format, value) {
+    logger.always(format === "json"
+        ? JSON.stringify(value)
+        : Object.entries(value)
+            .map(([key, child]) => `${key}: ${String(child)}`)
+            .join("\n"));
+}
+export const proxyReplayCommand = {
+    command: "replay <action>",
+    describe: "Export captured proxy requests or compare them directly upstream",
+    builder: (yargs) => yargs
+        .positional("action", {
+        type: "string",
+        choices: [...ACTIONS],
+        describe: "Replay action",
+    })
+        .option("request-id", {
+        type: "string",
+        alias: "requestId",
+        description: "Captured proxy request ID to export",
+    })
+        .option("attempt", {
+        type: "number",
+        description: "Specific upstream attempt to reconstruct",
+    })
+        .option("logs-dir", {
+        type: "string",
+        alias: "logsDir",
+        description: "Proxy log directory",
+    })
+        .option("bundle", {
+        type: "string",
+        description: "Replay bundle to compare directly upstream",
+    })
+        .option("output", {
+        type: "string",
+        alias: "o",
+        description: "Destination JSON file",
+    })
+        .option("execute", {
+        type: "boolean",
+        default: false,
+        description: "Explicitly permit the direct upstream request",
+    })
+        .option("header-env", {
+        type: "string",
+        array: true,
+        alias: "headerEnv",
+        description: "Inject a redacted header from an environment variable (header=ENV_VAR)",
+    })
+        .option("body-file", {
+        type: "string",
+        alias: "bodyFile",
+        description: "Complete request body override for redacted/truncated captures",
+    })
+        .option("url", {
+        type: "string",
+        description: "Explicit direct endpoint override",
+    })
+        .option("timeout-ms", {
+        type: "number",
+        alias: "timeoutMs",
+        default: 120_000,
+        description: "Direct request timeout",
+    })
+        .option("format", {
+        type: "string",
+        choices: ["text", "json"],
+        default: "text",
+        description: "Command summary format",
+    })
+        .option("quiet", {
+        type: "boolean",
+        alias: "q",
+        default: false,
+        description: "Suppress non-essential output",
+    })
+        .example("neurolink proxy replay export --request-id req-123 --output replay.json", "Create a deterministic offline replay bundle")
+        .example("neurolink proxy replay compare --bundle replay.json --output comparison.json --execute --header-env authorization=ANTHROPIC_AUTHORIZATION", "Execute the captured upstream request with an environment-backed credential"),
+    handler: async (argv) => {
+        try {
+            const output = requiredValue(argv.output, "--output");
+            if (argv.action === "export") {
+                const requestId = requiredValue(argv.requestId, "--request-id");
+                const bundle = await exportProxyReplayBundle({
+                    requestId,
+                    logsDir: argv.logsDir,
+                    attempt: argv.attempt,
+                });
+                const written = await writeProxyReplayDocument(output, bundle);
+                if (!argv.quiet) {
+                    printResult(argv.format ?? "text", {
+                        action: "export",
+                        output: written.path,
+                        sha256: written.sha256,
+                        captures: bundle.completeness.captures,
+                        replayable: bundle.completeness.replayable,
+                        blockers: bundle.completeness.blockers.join(",") || "none",
+                    });
+                }
+                return;
+            }
+            const bundlePath = requiredValue(argv.bundle, "--bundle");
+            const bundle = await readProxyReplayBundle(bundlePath);
+            const comparison = await compareProxyReplayBundle(bundle, {
+                execute: argv.execute === true,
+                headerValues: resolveHeaderValues(argv.headerEnv),
+                bodyOverride: await readBodyOverride(argv.bodyFile),
+                urlOverride: argv.url,
+                timeoutMs: argv.timeoutMs,
+            });
+            const written = await writeProxyReplayDocument(output, comparison);
+            if (!argv.quiet) {
+                printResult(argv.format ?? "text", {
+                    action: "compare",
+                    output: written.path,
+                    sha256: written.sha256,
+                    status: comparison.direct.status,
+                    statusMatches: comparison.comparison.statusMatches,
+                    bodyHashMatches: comparison.comparison.bodyHashMatches,
+                    jsonShapeMatches: comparison.comparison.jsonShapeMatches,
+                });
+            }
+        }
+        catch (error) {
+            logger.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+            process.exitCode = 1;
+        }
+    },
+};
+//# sourceMappingURL=proxyReplay.js.map