@runcofactor/cli 0.10.0

package/dist/workflow-debug-BGD4UIXU.js

@@ -0,0 +1,927 @@
+import { createRequire as __cr } from "module"; const require = __cr(import.meta.url);
+import {
+  runTrace
+} from "./chunk-Q4BO4Z5V.js";
+import {
+  apiRequest
+} from "./chunk-WOHL4FTB.js";
+import "./chunk-SJJW77WN.js";
+import "./chunk-3CZU7XCS.js";
+import {
+  getArgValue,
+  hasFlag
+} from "./chunk-A4OFTUVV.js";
+import "./chunk-4PNOV7OV.js";
+import "./chunk-JWHYXEA2.js";
+import "./chunk-6LEZCKKV.js";
+import "./chunk-ZD3KHESI.js";
+import "./chunk-VKVL7WBN.js";
+
+// src/workflow-debug.ts
+import process from "process";
+import os from "os";
+import path from "path";
+import fs from "fs/promises";
+function printDebugHelp() {
+  console.log(
+    [
+      "Usage: canary workflow debug <sub-command> [options]",
+      "",
+      "Triangulate three signals to debug a workflow run:",
+      "  1. Visual    \u2014 what happened on screen?  \u2192 debug playwright <runId>",
+      "  2. DOM       \u2014 what did the agent see?   \u2192 debug trace-snapshot <runId>",
+      "  3. Telemetry \u2014 what did we record?       \u2192 debug steps | cache | thoughts | logs",
+      "",
+      "Start with:   canary workflow debug <runId>    # diagnosis + pointers",
+      "Then drill in with the subcommand matching your question:",
+      '  "Where did we miss the cache?"   \u2192 debug cache --misses-only',
+      '  "What steps were slow?"          \u2192 debug steps --slow',
+      '  "Why did the agent click X?"     \u2192 debug thoughts --step <stepId>',
+      '  "What was on the page?"          \u2192 debug trace-snapshot <runId>',
+      '  "What errors did we log?"        \u2192 debug logs --level error',
+      '  "What variables did we have?"    \u2192 debug variables <runId>',
+      '  "What changed since it worked?"  \u2192 debug compare <oldRun> <newRun>',
+      '  "Give me everything for a run"   \u2192 debug bundle <runId> --out <dir>',
+      "",
+      "Sub-commands:",
+      "  overview <runId>                        Diagnosis summary (default when no sub given)",
+      "  steps <runId> [--slow] [--json]         Step timings + status",
+      "  cache <runId> [--misses-only] [--json]  Cache hit/miss breakdown",
+      "  thoughts <runId> [--step <id>] [--grep <text>] [--json]",
+      "                                           Agent reasoning for this run",
+      "  navigation <runId> [--transitions-only] [--json]",
+      "                                           Timestamped browser-URL history + cross-host transitions",
+      "  logs <runId> [--step <id>] [--level info|warning|error] [--json]",
+      "                                           Sentry logs for this run",
+      "  trace <runId> [--step <id>] [--json]    Sentry span tree",
+      "  playwright <runId> [--open] [--json]    Playwright trace viewer URL",
+      "  trace-fetch <runId> [--out <path>] [--json]",
+      "                                           Download trace.zip to disk",
+      "  trace-snapshot <runId> [--action <index>] [--output-dir <path>] [--screenshots] [--html]",
+      "                                           Download Playwright trace + reconstruct DOM snapshots",
+      "  snapshot <runId> [--out <path>] [--json] Workflow definition that ran (published or draft)",
+      "  cache-debug <runId> [--step <id>] [--json]",
+      "                                           Per-step cache compilation + replay details",
+      "  variables <runId> [--name <var>] [--json]",
+      "                                           Run-input + captured variables with definition timestamps",
+      "  compare <runIdA> <runIdB> [--out <dir>] [--json]",
+      "                                           Diff two runs (steps, thoughts, cache, snapshot)",
+      "  bundle <runId> --out <dir>               Pull all debug artifacts into one directory",
+      "  materialize <runId> [--out <dir>] [--json]",
+      "                                           Materialize the canonical diagnostic workspace (same shape",
+      "                                           the v2 failure-diagnostic agent uses). Start with `summary.md`.",
+      "",
+      "Options:",
+      "  --workflow <id>    Workflow ID (auto-resolved from runId if omitted)",
+      "  --json             Raw JSON output",
+      "  --env <env>        Target environment (prod, dev, local)"
+    ].join("\n")
+  );
+}
+async function handleWorkflowDebug(argv, apiUrl, token) {
+  const [maybeSub, ...rest] = argv;
+  if (!maybeSub || maybeSub === "help" || hasFlag(argv, "--help", "-h")) {
+    printDebugHelp();
+    return;
+  }
+  if (looksLikeRunId(maybeSub)) {
+    await handleOverview([maybeSub, ...rest], apiUrl, token);
+    return;
+  }
+  switch (maybeSub) {
+    case "overview":
+      await handleOverview(rest, apiUrl, token);
+      return;
+    case "steps":
+      await handleSteps(rest, apiUrl, token);
+      return;
+    case "cache":
+      await handleCache(rest, apiUrl, token);
+      return;
+    case "thoughts":
+      await handleThoughts(rest, apiUrl, token);
+      return;
+    case "navigation":
+      await handleNavigation(rest, apiUrl, token);
+      return;
+    case "logs":
+      await handleLogs(rest, apiUrl, token);
+      return;
+    case "trace":
+      await handleSentryTrace(rest, apiUrl, token);
+      return;
+    case "playwright":
+      await handlePlaywright(rest, apiUrl, token);
+      return;
+    case "trace-snapshot":
+      await handleTraceSnapshot(rest, apiUrl, token);
+      return;
+    case "trace-fetch":
+      await handleTraceFetch(rest, apiUrl, token);
+      return;
+    case "snapshot":
+      await handleSnapshot(rest, apiUrl, token);
+      return;
+    case "cache-debug":
+      await handleCacheDebug(rest, apiUrl, token);
+      return;
+    case "variables":
+      await handleVariables(rest, apiUrl, token);
+      return;
+    case "compare":
+      await handleCompare(rest, apiUrl, token);
+      return;
+    case "bundle":
+      await handleBundle(rest, apiUrl, token);
+      return;
+    case "materialize":
+      await handleMaterialize(rest, apiUrl, token);
+      return;
+    default:
+      console.error(`Unknown debug sub-command: ${maybeSub}`);
+      printDebugHelp();
+      process.exit(1);
+  }
+}
+function looksLikeRunId(s) {
+  return !!s && !s.startsWith("-") && s.length >= 8 && !/^[a-z-]+$/i.test(s.slice(0, 8));
+}
+function requireRunId(argv) {
+  const runId = argv.find((a) => !a.startsWith("-"));
+  if (!runId) {
+    console.error("Error: <runId> is required");
+    process.exit(1);
+  }
+  return runId;
+}
+async function resolveWorkflowId(argv, runId, apiUrl, token) {
+  const explicit = getArgValue(argv, "--workflow");
+  if (explicit) return explicit;
+  const res = await apiRequest(apiUrl, token, "GET", `/workflows/runs/${encodeURIComponent(runId)}/lookup`);
+  if (res.ok && res.data?.workflowId) return res.data.workflowId;
+  console.error(
+    `Error: could not resolve workflowId from runId (${res.error ?? "unknown error"}).`
+  );
+  console.error(
+    `       Pass --workflow <workflowId> explicitly, or run: canary workflow runs list <workflowId>`
+  );
+  process.exit(1);
+  return "";
+}
+async function fetchDebug(apiUrl, token, workflowId, runId, subpath = "") {
+  return apiRequest(
+    apiUrl,
+    token,
+    "GET",
+    `/workflows/${encodeURIComponent(workflowId)}/runs/${encodeURIComponent(runId)}/debug${subpath}`
+  );
+}
+function fmtMs(ms) {
+  if (ms === null) return "\u2014";
+  if (ms < 1e3) return `${ms}ms`;
+  return `${(ms / 1e3).toFixed(2)}s`;
+}
+async function handleOverview(argv, apiUrl, token) {
+  const runId = requireRunId(argv);
+  const workflowId = await resolveWorkflowId(argv, runId, apiUrl, token);
+  const res = await fetchDebug(apiUrl, token, workflowId, runId);
+  if (!res.ok) {
+    console.error(`Failed: ${res.error ?? "unknown error"}`);
+    process.exit(1);
+  }
+  if (hasFlag(argv, "--json")) {
+    console.log(JSON.stringify(res.data, null, 2));
+    return;
+  }
+  const d = res.data;
+  console.log(`Run ${d.run.id.slice(0, 8)}  \xB7  ${d.run.status}  \xB7  ${fmtMs(d.run.durationMs)}`);
+  if (d.run.errorMessage) console.log(`  error: ${d.run.errorMessage}`);
+  console.log(
+    `  cache: ${Math.round(d.cache.hitRate * 100)}% hit (${d.cache.hitCount}/${d.cache.hitCount + d.cache.missCount})`
+  );
+  console.log(`  thoughts: ${d.thoughts.count} recorded`);
+  console.log(
+    `  playwright trace: ${d.playwright.traceStorageKey ? "available" : "not captured"}`
+  );
+  if (d.diagnosis.failedSteps.length > 0) {
+    console.log("\nFailed steps:");
+    for (const s of d.diagnosis.failedSteps) {
+      console.log(`  \u2717 ${s.name ?? s.stepId.slice(0, 8)}  ${s.errorMessage ?? ""}`);
+    }
+  }
+  if (d.diagnosis.slowestSteps.length > 0) {
+    console.log("\nSlowest steps:");
+    for (const s of d.diagnosis.slowestSteps) {
+      console.log(`  \xB7 ${s.name ?? s.stepId.slice(0, 8)}  ${fmtMs(s.durationMs)}`);
+    }
+  }
+  if (d.diagnosis.cacheMissHotspots.length > 0) {
+    console.log("\nCache miss hotspots:");
+    for (const s of d.diagnosis.cacheMissHotspots) {
+      console.log(`  \xB7 ${s.stepId.slice(0, 8)}  ${s.reason}`);
+    }
+  }
+  console.log("\nNext:");
+  console.log(
+    `  canary workflow debug steps ${runId} --slow          # timings`
+  );
+  console.log(
+    `  canary workflow debug cache ${runId} --misses-only   # cache diagnosis`
+  );
+  console.log(
+    `  canary workflow debug thoughts ${runId} --step <id>  # agent reasoning`
+  );
+  console.log(
+    `  canary workflow debug trace-snapshot ${runId}        # DOM the agent saw`
+  );
+}
+async function handleSteps(argv, apiUrl, token) {
+  const runId = requireRunId(argv);
+  const workflowId = await resolveWorkflowId(argv, runId, apiUrl, token);
+  const res = await fetchDebug(apiUrl, token, workflowId, runId, "/steps");
+  if (!res.ok) {
+    console.error(`Failed: ${res.error ?? "unknown error"}`);
+    process.exit(1);
+  }
+  const steps = [...res.data.steps];
+  if (hasFlag(argv, "--slow")) {
+    steps.sort((a, b) => (b.durationMs ?? 0) - (a.durationMs ?? 0));
+  }
+  if (hasFlag(argv, "--json")) {
+    console.log(JSON.stringify(steps, null, 2));
+    return;
+  }
+  console.log("STEP                         STATUS     DURATION   CACHE");
+  for (const s of steps) {
+    const name = (s.name ?? s.id.slice(0, 8)).padEnd(28).slice(0, 28);
+    const status = s.status.padEnd(10);
+    const dur = fmtMs(s.durationMs).padEnd(10);
+    const cache = s.cacheHitSource ?? (s.cacheOutcome ?? "\u2014");
+    console.log(`${name} ${status} ${dur} ${cache}`);
+    if (s.errorMessage) console.log(`  \u21B3 ${s.errorMessage}`);
+  }
+}
+async function handleNavigation(argv, apiUrl, token) {
+  const runId = requireRunId(argv);
+  const workflowId = await resolveWorkflowId(argv, runId, apiUrl, token);
+  const res = await fetchDebug(
+    apiUrl,
+    token,
+    workflowId,
+    runId,
+    "/navigation"
+  );
+  if (!res.ok) {
+    console.error(`Failed: ${res.error ?? "unknown error"}`);
+    process.exit(1);
+  }
+  const transitionsOnly = hasFlag(argv, "--transitions-only");
+  const payload = res.data;
+  if (hasFlag(argv, "--json")) {
+    console.log(
+      JSON.stringify(
+        transitionsOnly ? { startTimestamp: payload.startTimestamp, transitions: payload.transitions } : payload,
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (payload.entries.length === 0) {
+    console.log("No navigation events recorded for this run.");
+    return;
+  }
+  if (payload.transitions.length > 0) {
+    console.log(
+      `\u26A0  ${payload.transitions.length} cross-host transition${payload.transitions.length === 1 ? "" : "s"}:`
+    );
+    for (const t of payload.transitions) {
+      console.log(
+        `   ${formatRelMs(t.timestampMs)}  ${t.fromHostname} \u2192 ${t.toHostname}`
+      );
+    }
+    console.log("");
+  }
+  if (transitionsOnly) return;
+  const transitionTo = new Set(payload.transitions.map((t) => t.toIndex));
+  console.log("TIME         HOSTNAME                  URL");
+  payload.entries.forEach((e, idx) => {
+    const time = formatRelMs(e.timestampMs).padEnd(12);
+    const host = (e.hostname ?? "\u2014").padEnd(25).slice(0, 25);
+    const marker = transitionTo.has(idx) ? "\u2192" : " ";
+    console.log(`${time} ${marker} ${host} ${e.url}`);
+  });
+}
+function formatRelMs(ms) {
+  if (ms < 0) ms = 0;
+  const totalSeconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  const millis = ms % 1e3;
+  return `${minutes}:${String(seconds).padStart(2, "0")}.${String(millis).padStart(3, "0")}`;
+}
+async function handleCache(argv, apiUrl, token) {
+  const runId = requireRunId(argv);
+  const workflowId = await resolveWorkflowId(argv, runId, apiUrl, token);
+  const res = await fetchDebug(apiUrl, token, workflowId, runId);
+  if (!res.ok) {
+    console.error(`Failed: ${res.error ?? "unknown error"}`);
+    process.exit(1);
+  }
+  const { cache, steps } = res.data;
+  if (hasFlag(argv, "--json")) {
+    console.log(JSON.stringify(cache, null, 2));
+    return;
+  }
+  console.log(
+    `Cache hit rate: ${Math.round(cache.hitRate * 100)}%  (${cache.hitCount} hit, ${cache.missCount} miss)`
+  );
+  if (Object.keys(cache.bySource).length > 0) {
+    console.log("By source:");
+    for (const [src, n] of Object.entries(cache.bySource)) {
+      console.log(`  ${src.padEnd(16)} ${n}`);
+    }
+  }
+  const stepById = new Map(steps.map((s) => [s.id, s]));
+  if (!hasFlag(argv, "--misses-only")) {
+    console.log("\nHits:");
+    for (const s of steps.filter((x) => x.cacheHitSource)) {
+      console.log(`  \u2713 ${(s.name ?? s.id.slice(0, 8)).padEnd(28)}  ${s.cacheHitSource}`);
+    }
+  }
+  if (cache.misses.length > 0) {
+    console.log("\nMisses:");
+    for (const m of cache.misses) {
+      const s = stepById.get(m.stepId);
+      console.log(`  \u2717 ${(s?.name ?? m.stepId.slice(0, 8)).padEnd(28)}  ${m.reason}`);
+    }
+  }
+}
+async function handleThoughts(argv, apiUrl, token) {
+  const runId = requireRunId(argv);
+  const workflowId = await resolveWorkflowId(argv, runId, apiUrl, token);
+  const stepId = getArgValue(argv, "--step");
+  const grep = getArgValue(argv, "--grep");
+  const qs = stepId ? `?step=${encodeURIComponent(stepId)}` : "";
+  const res = await fetchDebug(
+    apiUrl,
+    token,
+    workflowId,
+    runId,
+    `/thoughts${qs}`
+  );
+  if (!res.ok) {
+    console.error(`Failed: ${res.error ?? "unknown error"}`);
+    process.exit(1);
+  }
+  const totalThoughts = res.data.thoughts.length;
+  let thoughts = res.data.thoughts;
+  if (grep) {
+    const needle = grep.toLowerCase();
+    thoughts = thoughts.filter((t) => t.content.toLowerCase().includes(needle));
+  }
+  if (hasFlag(argv, "--json")) {
+    console.log(JSON.stringify(thoughts, null, 2));
+    return;
+  }
+  for (const t of thoughts) {
+    const tag = t.toolName ? `[${t.toolName}] ` : "";
+    const step = t.stepId ? `step ${t.stepId.slice(0, 8)}  ` : "";
+    console.log(`${step}${tag}${t.content}`);
+    console.log("");
+  }
+  if (thoughts.length === 0) {
+    if (totalThoughts === 0) {
+      const scope = stepId ? ` for step ${stepId.slice(0, 8)}` : "";
+      console.log(`(no thoughts recorded${scope})`);
+    } else if (grep) {
+      console.log(
+        `(no thoughts matched --grep "${grep}"; ${totalThoughts} total thought${totalThoughts === 1 ? "" : "s"} in scope)`
+      );
+    } else {
+      console.log("(no thoughts to display)");
+    }
+  }
+}
+async function handleLogs(argv, apiUrl, token) {
+  const runId = requireRunId(argv);
+  const workflowId = await resolveWorkflowId(argv, runId, apiUrl, token);
+  const level = getArgValue(argv, "--level");
+  const stepId = getArgValue(argv, "--step");
+  const params = new URLSearchParams();
+  if (level) params.set("level", level);
+  if (stepId) params.set("step", stepId);
+  const qs = params.toString() ? `?${params.toString()}` : "";
+  const res = await fetchDebug(apiUrl, token, workflowId, runId, `/logs${qs}`);
+  if (!res.ok) {
+    console.error(`Failed: ${res.error ?? "unknown error"}`);
+    process.exit(1);
+  }
+  if (hasFlag(argv, "--json")) {
+    console.log(JSON.stringify(res.data, null, 2));
+    return;
+  }
+  if (res.data.partial) {
+    console.log(`(partial result: ${res.data.reason ?? "unknown"})`);
+  }
+  for (const row of res.data.rows) {
+    console.log(`${row.timestamp}  ${row.level.padEnd(8)}  ${row.message}`);
+  }
+  if (res.data.rows.length === 0 && !res.data.partial) {
+    console.log("(no logs)");
+  }
+}
+async function handleSentryTrace(argv, apiUrl, token) {
+  const runId = requireRunId(argv);
+  const workflowId = await resolveWorkflowId(argv, runId, apiUrl, token);
+  const stepId = getArgValue(argv, "--step");
+  const qs = stepId ? `?step=${encodeURIComponent(stepId)}` : "";
+  const res = await fetchDebug(
+    apiUrl,
+    token,
+    workflowId,
+    runId,
+    `/sentry-trace${qs}`
+  );
+  if (!res.ok) {
+    console.error(`Failed: ${res.error ?? "unknown error"}`);
+    process.exit(1);
+  }
+  if (hasFlag(argv, "--json")) {
+    console.log(JSON.stringify(res.data, null, 2));
+    return;
+  }
+  if (res.data.partial) {
+    console.log(`(partial result: ${res.data.reason ?? "unknown"})`);
+  }
+  if (res.data.traceId) console.log(`trace ${res.data.traceId}`);
+  for (const span of res.data.spans) {
+    const op = (span.op ?? "span").padEnd(22);
+    const desc = (span.description ?? "").padEnd(40);
+    const dur = span.durationMs !== null ? `${span.durationMs}ms` : "";
+    console.log(`  ${op} ${desc} ${dur}`);
+  }
+  if (res.data.spans.length === 0 && !res.data.partial) {
+    console.log("(no spans)");
+  }
+}
+async function handlePlaywright(argv, apiUrl, token) {
+  const runId = requireRunId(argv);
+  const workflowId = await resolveWorkflowId(argv, runId, apiUrl, token);
+  const res = await fetchDebug(apiUrl, token, workflowId, runId, "/trace");
+  if (!res.ok) {
+    console.error(`Failed: ${res.error ?? "unknown error"}`);
+    process.exit(1);
+  }
+  if (hasFlag(argv, "--json")) {
+    console.log(JSON.stringify(res.data, null, 2));
+    return;
+  }
+  console.log(res.data.viewerUrl);
+  if (hasFlag(argv, "--open")) {
+    const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    const { spawn } = await import("child_process");
+    spawn(opener, [res.data.viewerUrl], { detached: true, stdio: "ignore" }).unref();
+  }
+}
+async function handleTraceSnapshot(argv, apiUrl, token) {
+  const runId = requireRunId(argv);
+  if (getArgValue(argv, "--step")) {
+    console.error(
+      "Error: trace-snapshot --step is not supported by the local trace reconstructor. Use --action <0-based trace action index> or omit filtering."
+    );
+    process.exit(1);
+  }
+  const workflowId = await resolveWorkflowId(argv, runId, apiUrl, token);
+  const res = await fetchDebug(apiUrl, token, workflowId, runId, "/trace");
+  if (!res.ok) {
+    console.error(`Failed: ${res.error ?? "unknown error"}`);
+    process.exit(1);
+  }
+  const tmp = await fs.mkdtemp(path.join(os.tmpdir(), `canary-trace-${runId}-`));
+  const traceFile = path.join(tmp, "trace.zip");
+  const download = await fetch(res.data.signedUrl);
+  if (!download.ok) {
+    console.error(`Failed to download trace: HTTP ${download.status}`);
+    process.exit(1);
+  }
+  const buf = Buffer.from(await download.arrayBuffer());
+  await fs.writeFile(traceFile, buf);
+  const forwarded = ["snapshot", traceFile];
+  for (const flag of ["--output-dir", "--filter", "--action"]) {
+    const v = getArgValue(argv, flag);
+    if (v !== void 0) forwarded.push(flag, v);
+  }
+  if (hasFlag(argv, "--screenshots")) forwarded.push("--screenshots");
+  if (hasFlag(argv, "--html")) forwarded.push("--html");
+  await runTrace(forwarded);
+}
+async function handleTraceFetch(argv, apiUrl, token) {
+  const runId = requireRunId(argv);
+  const workflowId = await resolveWorkflowId(argv, runId, apiUrl, token);
+  const res = await fetchDebug(apiUrl, token, workflowId, runId, "/trace");
+  if (!res.ok) {
+    console.error(`Failed: ${res.error ?? "unknown error"}`);
+    process.exit(1);
+  }
+  const out = getArgValue(argv, "--out") ?? `./trace-${runId}.zip`;
+  const download = await fetch(res.data.signedUrl);
+  if (!download.ok) {
+    console.error(`Failed to download trace: HTTP ${download.status}`);
+    process.exit(1);
+  }
+  const buf = Buffer.from(await download.arrayBuffer());
+  await fs.writeFile(out, buf);
+  if (hasFlag(argv, "--json")) {
+    console.log(JSON.stringify({ path: out, storageKey: res.data.storageKey }, null, 2));
+    return;
+  }
+  console.log(out);
+}
+async function fetchRunDetail(apiUrl, token, workflowId, runId) {
+  const res = await apiRequest(
+    apiUrl,
+    token,
+    "GET",
+    `/workflows/${encodeURIComponent(workflowId)}/runs/${encodeURIComponent(runId)}`
+  );
+  if (!res.run) {
+    console.error(`Failed to load run: ${res.error ?? "unknown error"}`);
+    process.exit(1);
+  }
+  return res.run;
+}
+async function handleSnapshot(argv, apiUrl, token) {
+  const runId = requireRunId(argv);
+  const workflowId = await resolveWorkflowId(argv, runId, apiUrl, token);
+  const run = await fetchRunDetail(apiUrl, token, workflowId, runId);
+  if (!run) return;
+  let snapshotPath;
+  let kind;
+  if (run.draftSnapshot) {
+    snapshotPath = `/workflows/${encodeURIComponent(workflowId)}/draft-snapshots/${encodeURIComponent(run.draftSnapshot.version)}`;
+    kind = "draft";
+  } else if (run.snapshotVersion !== null && run.snapshotVersion !== void 0) {
+    snapshotPath = `/workflows/${encodeURIComponent(workflowId)}/snapshots/${run.snapshotVersion}`;
+    kind = "published";
+  } else {
+    console.error("Run has no snapshotVersion or draftSnapshotId \u2014 cannot resolve definition.");
+    process.exit(1);
+  }
+  const snap = await apiRequest(
+    apiUrl,
+    token,
+    "GET",
+    snapshotPath
+  );
+  if (!snap.snapshot) {
+    console.error(`Failed to load snapshot: ${snap.error ?? "unknown error"}`);
+    process.exit(1);
+  }
+  const out = getArgValue(argv, "--out");
+  const text = JSON.stringify(snap.snapshot.snapshotJson, null, 2);
+  if (out) {
+    await fs.writeFile(out, text);
+    if (hasFlag(argv, "--json")) {
+      console.log(JSON.stringify({ path: out, kind, version: snap.snapshot.version }, null, 2));
+    } else {
+      console.log(`${kind} snapshot v${snap.snapshot.version} \u2192 ${out}`);
+    }
+    return;
+  }
+  if (hasFlag(argv, "--json")) {
+    console.log(JSON.stringify({ kind, version: snap.snapshot.version, snapshotJson: snap.snapshot.snapshotJson }, null, 2));
+    return;
+  }
+  console.log(text);
+}
+async function handleVariables(argv, apiUrl, token) {
+  const runId = requireRunId(argv);
+  const workflowId = await resolveWorkflowId(argv, runId, apiUrl, token);
+  const res = await fetchDebug(apiUrl, token, workflowId, runId, "/variables");
+  if (!res.ok) {
+    console.error(`Failed: ${res.error ?? "unknown error"}`);
+    process.exit(1);
+  }
+  const filter = getArgValue(argv, "--name");
+  const data = filter ? {
+    inputs: res.data.inputs.filter((v) => v.name === filter),
+    captures: res.data.captures.filter((v) => v.name === filter)
+  } : res.data;
+  if (hasFlag(argv, "--json")) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  const fmtValue = (v) => v.length > 80 ? `${v.slice(0, 77)}...` : v;
+  console.log(`Run inputs (${data.inputs.length})`);
+  if (data.inputs.length === 0) {
+    console.log("  (none)");
+  } else {
+    for (const v of data.inputs) {
+      console.log(`  ${v.name} = ${fmtValue(v.value)}    [defined ${v.definedAt}]`);
+    }
+  }
+  console.log("");
+  console.log(`Captures (${data.captures.length})`);
+  if (data.captures.length === 0) {
+    console.log("  (none)");
+  } else {
+    for (const v of data.captures) {
+      const where = v.nodeName ? `${v.nodeName} (${v.stepId})` : v.stepId;
+      console.log(`  ${v.name} = ${fmtValue(v.value)}    [${v.definedAt} \xB7 ${where}]`);
+    }
+  }
+}
+async function handleCacheDebug(argv, apiUrl, token) {
+  const runId = requireRunId(argv);
+  const workflowId = await resolveWorkflowId(argv, runId, apiUrl, token);
+  const res = await apiRequest(
+    apiUrl,
+    token,
+    "GET",
+    `/workflows/${encodeURIComponent(workflowId)}/runs/${encodeURIComponent(runId)}/cache-debug`
+  );
+  if (res.ok === false) {
+    console.error(`Failed: ${res.error ?? "unknown error"}`);
+    process.exit(1);
+  }
+  const stepFilter = getArgValue(argv, "--step");
+  const payload = res.data ?? res;
+  const data = stepFilter ? {
+    ...payload,
+    steps: (payload.steps ?? []).filter(
+      (s) => s["stepId"] === stepFilter || s["nodeId"] === stepFilter
+    )
+  } : payload;
+  if (hasFlag(argv, "--json")) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  console.log(JSON.stringify(data, null, 2));
+}
+async function loadRunBundle(apiUrl, token, workflowId, runId) {
+  const overview = await fetchDebug(apiUrl, token, workflowId, runId);
+  if (!overview.ok) {
+    console.error(`Failed to load run ${runId}: ${overview.error ?? "unknown error"}`);
+    process.exit(1);
+  }
+  const stepsRes = await fetchDebug(apiUrl, token, workflowId, runId, "/steps");
+  const thoughtsRes = await fetchDebug(apiUrl, token, workflowId, runId, "/thoughts");
+  return {
+    runId,
+    overview: overview.data,
+    steps: stepsRes.ok ? stepsRes.data.steps : [],
+    thoughts: thoughtsRes.ok ? thoughtsRes.data.thoughts : []
+  };
+}
+async function handleCompare(argv, apiUrl, token) {
+  const positional = argv.filter((a2) => !a2.startsWith("-"));
+  if (positional.length < 2) {
+    console.error("Usage: canary workflow debug compare <runIdA> <runIdB> [--workflow <id>] [--out <dir>] [--json]");
+    process.exit(1);
+  }
+  const [runA, runB] = positional;
+  const workflowId = await resolveWorkflowId(argv, runA, apiUrl, token);
+  const [a, b] = await Promise.all([
+    loadRunBundle(apiUrl, token, workflowId, runA),
+    loadRunBundle(apiUrl, token, workflowId, runB)
+  ]);
+  const stepsByNode = (steps) => {
+    const m = /* @__PURE__ */ new Map();
+    for (const s of steps) m.set(s.nodeId, s);
+    return m;
+  };
+  const aMap = stepsByNode(a.steps);
+  const bMap = stepsByNode(b.steps);
+  const allNodes = /* @__PURE__ */ new Set([...aMap.keys(), ...bMap.keys()]);
+  const stepDiffs = [];
+  for (const nodeId of allNodes) {
+    const sa = aMap.get(nodeId) ?? null;
+    const sb = bMap.get(nodeId) ?? null;
+    const flipped = [];
+    if ((sa?.status ?? null) !== (sb?.status ?? null)) flipped.push("status");
+    if ((sa?.cacheHitSource ?? null) !== (sb?.cacheHitSource ?? null)) flipped.push("cache");
+    const durA = sa?.durationMs ?? null;
+    const durB = sb?.durationMs ?? null;
+    let durationDeltaPct = null;
+    if (durA !== null && durB !== null && durA > 0) {
+      durationDeltaPct = Math.round((durB - durA) / durA * 100);
+      if (Math.abs(durationDeltaPct) >= 100) flipped.push("duration");
+    }
+    if (flipped.length > 0 || !sa || !sb) {
+      stepDiffs.push({
+        nodeId,
+        name: sa?.name ?? sb?.name ?? null,
+        statusA: sa?.status ?? null,
+        statusB: sb?.status ?? null,
+        durationA: durA,
+        durationB: durB,
+        durationDeltaPct,
+        cacheA: sa?.cacheHitSource ?? null,
+        cacheB: sb?.cacheHitSource ?? null,
+        flipped: !sa ? ["only-in-B"] : !sb ? ["only-in-A"] : flipped
+      });
+    }
+  }
+  const thoughtsByStep = (bundle) => {
+    const m = /* @__PURE__ */ new Map();
+    for (const t of bundle.thoughts) {
+      const key = t.stepId ?? "";
+      const arr = m.get(key) ?? [];
+      arr.push(t);
+      m.set(key, arr);
+    }
+    return m;
+  };
+  const aThoughts = thoughtsByStep(a);
+  const bThoughts = thoughtsByStep(b);
+  const thoughtDeltas = stepDiffs.map((d) => {
+    const sa = aMap.get(d.nodeId);
+    const sb = bMap.get(d.nodeId);
+    return {
+      nodeId: d.nodeId,
+      thoughtsA: sa ? aThoughts.get(sa.id)?.map((t) => t.content) ?? [] : [],
+      thoughtsB: sb ? bThoughts.get(sb.id)?.map((t) => t.content) ?? [] : []
+    };
+  });
+  const result = {
+    runA,
+    runB,
+    workflowId,
+    cacheHitRateDelta: b.overview.cache.hitRate - a.overview.cache.hitRate,
+    statusA: a.overview.run.status,
+    statusB: b.overview.run.status,
+    durationA: a.overview.run.durationMs,
+    durationB: b.overview.run.durationMs,
+    stepDiffs,
+    thoughtDeltas
+  };
+  const outDir = getArgValue(argv, "--out");
+  if (outDir) {
+    await fs.mkdir(outDir, { recursive: true });
+    await fs.writeFile(path.join(outDir, "compare.json"), JSON.stringify(result, null, 2));
+    for (const [label, runId] of [["runA", runA], ["runB", runB]]) {
+      const sub = path.join(outDir, label);
+      await fs.mkdir(sub, { recursive: true });
+      await tryWriteSnapshot(apiUrl, token, workflowId, runId, path.join(sub, "snapshot.json"));
+      await tryWriteTrace(apiUrl, token, workflowId, runId, path.join(sub, "trace.zip"));
+    }
+    if (!hasFlag(argv, "--json")) console.log(`Wrote compare bundle to ${outDir}`);
+  }
+  if (hasFlag(argv, "--json") || !outDir) {
+    console.log(JSON.stringify(result, null, 2));
+  }
+}
+async function tryWriteTrace(apiUrl, token, workflowId, runId, outPath) {
+  const res = await fetchDebug(apiUrl, token, workflowId, runId, "/trace");
+  if (!res.ok) return;
+  const dl = await fetch(res.data.signedUrl);
+  if (!dl.ok) return;
+  await fs.writeFile(outPath, Buffer.from(await dl.arrayBuffer()));
+}
+async function tryWriteSnapshot(apiUrl, token, workflowId, runId, outPath) {
+  const run = await fetchRunDetail(apiUrl, token, workflowId, runId);
+  if (!run) return;
+  const snapPath = run.draftSnapshot ? `/workflows/${encodeURIComponent(workflowId)}/draft-snapshots/${encodeURIComponent(run.draftSnapshot.version)}` : run.snapshotVersion !== null && run.snapshotVersion !== void 0 ? `/workflows/${encodeURIComponent(workflowId)}/snapshots/${run.snapshotVersion}` : null;
+  if (!snapPath) return;
+  const snap = await apiRequest(
+    apiUrl,
+    token,
+    "GET",
+    snapPath
+  );
+  if (!snap.snapshot) return;
+  await fs.writeFile(outPath, JSON.stringify(snap.snapshot.snapshotJson, null, 2));
+}
+async function handleBundle(argv, apiUrl, token) {
+  const runId = requireRunId(argv);
+  const workflowId = await resolveWorkflowId(argv, runId, apiUrl, token);
+  const outDir = getArgValue(argv, "--out");
+  if (!outDir) {
+    console.error("Error: --out <dir> is required");
+    process.exit(1);
+  }
+  await fs.mkdir(outDir, { recursive: true });
+  const manifest = [];
+  const writeJson = async (file, source, fetcher) => {
+    try {
+      const data = await fetcher();
+      await fs.writeFile(path.join(outDir, file), JSON.stringify(data, null, 2));
+      manifest.push({ file, source, ok: true });
+    } catch (err) {
+      manifest.push({ file, source, ok: false, error: String(err) });
+    }
+  };
+  await writeJson("overview.json", `GET /workflows/${workflowId}/runs/${runId}/debug`, async () => {
+    const r = await fetchDebug(apiUrl, token, workflowId, runId);
+    if (!r.ok) throw new Error(r.error ?? "failed");
+    return r.data;
+  });
+  await writeJson("steps.json", `/debug/steps`, async () => {
+    const r = await fetchDebug(apiUrl, token, workflowId, runId, "/steps");
+    if (!r.ok) throw new Error(r.error ?? "failed");
+    return r.data;
+  });
+  await writeJson("thoughts.json", `/debug/thoughts`, async () => {
+    const r = await fetchDebug(apiUrl, token, workflowId, runId, "/thoughts");
+    if (!r.ok) throw new Error(r.error ?? "failed");
+    return r.data;
+  });
+  await writeJson("cache-debug.json", `/cache-debug`, async () => {
+    const r = await apiRequest(
+      apiUrl,
+      token,
+      "GET",
+      `/workflows/${encodeURIComponent(workflowId)}/runs/${encodeURIComponent(runId)}/cache-debug`
+    );
+    if (r.ok === false) throw new Error(r.error ?? "failed");
+    return r;
+  });
+  await writeJson("logs.json", `/debug/logs`, async () => {
+    const r = await fetchDebug(apiUrl, token, workflowId, runId, "/logs");
+    if (!r.ok) throw new Error(r.error ?? "failed");
+    return r.data;
+  });
+  await writeJson("sentry-trace.json", `/debug/sentry-trace`, async () => {
+    const r = await fetchDebug(apiUrl, token, workflowId, runId, "/sentry-trace");
+    if (!r.ok) throw new Error(r.error ?? "failed");
+    return r.data;
+  });
+  await writeJson("variables.json", `/debug/variables`, async () => {
+    const r = await fetchDebug(apiUrl, token, workflowId, runId, "/variables");
+    if (!r.ok) throw new Error(r.error ?? "failed");
+    return r.data;
+  });
+  try {
+    await tryWriteSnapshot(apiUrl, token, workflowId, runId, path.join(outDir, "snapshot.json"));
+    manifest.push({ file: "snapshot.json", source: "snapshots/:version", ok: true });
+  } catch (err) {
+    manifest.push({ file: "snapshot.json", source: "snapshots/:version", ok: false, error: String(err) });
+  }
+  try {
+    await tryWriteTrace(apiUrl, token, workflowId, runId, path.join(outDir, "trace.zip"));
+    manifest.push({ file: "trace.zip", source: "/debug/trace", ok: true });
+  } catch (err) {
+    manifest.push({ file: "trace.zip", source: "/debug/trace", ok: false, error: String(err) });
+  }
+  await fs.writeFile(path.join(outDir, "bundle.json"), JSON.stringify({ runId, workflowId, manifest }, null, 2));
+  console.log(`Wrote bundle to ${outDir}`);
+  for (const m of manifest) {
+    console.log(`  ${m.ok ? "\u2713" : "\u2717"} ${m.file}${m.ok ? "" : `  (${m.error ?? "failed"})`}`);
+  }
+}
+async function handleMaterialize(argv, apiUrl, token) {
+  const runId = requireRunId(argv);
+  const workflowId = await resolveWorkflowId(argv, runId, apiUrl, token);
+  const outDir = getArgValue(argv, "--out") ?? `./diag-${runId}`;
+  const { assembleWorkspace } = await import("./src-LB4HBTJQ.js");
+  const dataUrl = `${apiUrl}/workflows/${encodeURIComponent(workflowId)}/runs/${encodeURIComponent(runId)}/debug/materialize-data`;
+  const dataRes = await fetch(dataUrl, { headers: { Authorization: `Bearer ${token}` } });
+  if (!dataRes.ok) {
+    const errText = await dataRes.text().catch(() => "");
+    console.error(`Failed to fetch run data: HTTP ${dataRes.status} ${errText}`);
+    process.exit(1);
+  }
+  const envelope = await dataRes.json();
+  if (!envelope.ok) {
+    console.error(`Failed: ${envelope.error ?? "unknown error"}`);
+    process.exit(1);
+  }
+  const { runData, signedTraceUrl } = envelope.data;
+  await fs.mkdir(outDir, { recursive: true });
+  let traceZipPath = null;
+  if (signedTraceUrl) {
+    traceZipPath = path.join(outDir, ".trace-source.zip");
+    const traceRes = await fetch(signedTraceUrl);
+    if (!traceRes.ok || !traceRes.body) {
+      console.warn(`Trace download failed (HTTP ${traceRes.status}); workspace will be marked partial.`);
+      traceZipPath = null;
+    } else {
+      const handle = await fs.open(traceZipPath, "w");
+      try {
+        const reader = traceRes.body.getReader();
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) break;
+          if (value) await handle.write(value);
+        }
+      } finally {
+        await handle.close();
+      }
+    }
+  }
+  await assembleWorkspace({ runData, workspaceRoot: outDir, traceZipPath });
+  if (traceZipPath) {
+    await fs.rm(traceZipPath, { force: true }).catch(() => void 0);
+  }
+  if (hasFlag(argv, "--json")) {
+    console.log(JSON.stringify({ workspace: outDir, runId, workflowId }, null, 2));
+    return;
+  }
+  console.log(`Materialized workspace at ${outDir}`);
+  console.log(`Start with: cat ${path.join(outDir, "summary.md")}`);
+}
+export {
+  handleWorkflowDebug
+};
+//# sourceMappingURL=workflow-debug-BGD4UIXU.js.map