@iowarp/clio-coder 0.3.8 → 0.4.0

package/dist/chunk-IBEBSCYA.js

@@ -0,0 +1,564 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  truncateToWidth
+} from "./chunk-NYS75XW5.js";
+import {
+  openLedger,
+  readFleetRun
+} from "./chunk-BUMFYQFY.js";
+import {
+  formatTrustSummaryLine,
+  inspectRunReceiptTrustStatus
+} from "./chunk-B7OBL7PK.js";
+import {
+  WRITE_BOUNDARY_VIOLATION_REASON
+} from "./chunk-U77AMWDL.js";
+import {
+  readRunEventJournal,
+  runEventJournalPath
+} from "./chunk-IQ7KR472.js";
+import {
+  sanitizeCallTargetText
+} from "./chunk-TVHHYFHE.js";
+import {
+  clioStateDir,
+  resetXdgCache
+} from "./chunk-BYP5D4HI.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/cli/fleet-view.ts
+init_esm_shims();
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var HELP = `clio-coder fleet view <runId|fleetRootId> [--follow]
+clio-coder fleet view --watch <selection-file>
+
+Follow one dispatched run from its durable state: the run ledger entry, the
+run event journal, and the sealed receipt once it exists.
+
+  --follow    keep tailing until the run's terminal line, then stay open (q exits)
+  --watch     follow whichever run id the selection file names, retargeting
+              live as the file changes (q exits). This is the process the
+              interactive workers view (Alt+W) runs inside its watch pane.
+
+Without --follow the current snapshot is printed and the command exits.
+The transcript comes from <state>/runs/<runId>/events.ndjson, which the
+orchestrator writes when panes.journal is on (the default). A run dispatched
+with the journal off shows its ledger and receipt but no transcript.
+
+Given the fleet root id that \`fleet run\` prints (fleet-<hex>), this prints the
+run's step index instead: one line per step with its run id and outcome. Pass
+one of those run ids back to see that step.
+`;
+var POLL_MS = 250;
+var TRANSCRIPT_LIMIT = 400;
+var TASK_MAX_WIDTH = 400;
+var DETAIL_MAX_WIDTH = 200;
+var DEFAULT_WIDTH = 100;
+var MIN_WIDTH = 40;
+var QUIT_CTRL_C = String.fromCharCode(3);
+var QUIT_ESCAPE = String.fromCharCode(27);
+function sanitizeBounded(value, maxWidth) {
+  const sanitized = sanitizeCallTargetText(value);
+  if (sanitized.length === 0) return "";
+  return sanitizeCallTargetText(truncateToWidth(sanitized, maxWidth, "\u2026", false));
+}
+function receiptPathFor(run) {
+  return run.receiptPath ?? join(clioStateDir(), "receipts", `${run.id}.json`);
+}
+function evidenceLine(run) {
+  if (run.receiptPath === null && run.endedAt === null) {
+    return { text: "receipt pending; the run has not finalized", receiptPath: null };
+  }
+  const path = receiptPathFor(run);
+  let receipt;
+  try {
+    receipt = JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    return {
+      text: `receipt unavailable: cannot read ${path} (${error instanceof Error ? error.message : String(error)})`,
+      receiptPath: null
+    };
+  }
+  const inspection = inspectRunReceiptTrustStatus(receipt, run);
+  if (!inspection.integrity.ok) {
+    return {
+      text: `RECEIPT INTEGRITY FAILED: ${inspection.integrity.reason}; stored receipt fields are untrusted`,
+      receiptPath: path
+    };
+  }
+  return { text: formatTrustSummaryLine(inspection.status), receiptPath: path };
+}
+function transcriptLine(line) {
+  switch (line.kind) {
+    case "open":
+      return { at: line.at, label: `run opened (${sanitizeBounded(line.agentId, 64)})`, detail: void 0 };
+    case "event":
+      return {
+        at: line.at,
+        label: sanitizeBounded(line.type, 64),
+        detail: line.detail === void 0 ? void 0 : sanitizeBounded(line.detail, DETAIL_MAX_WIDTH)
+      };
+    case "journal_truncated":
+      return { at: line.at, label: "journal truncated", detail: sanitizeBounded(line.reason, 64) };
+    case "receipt":
+      return {
+        at: line.at,
+        label: `receipt sealed (${sanitizeBounded(line.outcome, 32)})`,
+        detail: line.digest === void 0 ? void 0 : `sha256:${sanitizeBounded(line.digest, 64)}`
+      };
+    case "terminal":
+      return {
+        at: line.at,
+        label: `terminal (${sanitizeBounded(line.outcome, 32)})`,
+        detail: line.detail === void 0 ? void 0 : sanitizeBounded(line.detail, DETAIL_MAX_WIDTH)
+      };
+    default:
+      return null;
+  }
+}
+function resolveRunId(runId) {
+  const ledger = openLedger();
+  if (ledger.get(runId) !== null) return { runId };
+  const candidates = ledger.list().filter((run) => run.id.startsWith(runId)).map((run) => run.id);
+  if (candidates.length === 1 && candidates[0] !== void 0) return { runId: candidates[0] };
+  return { candidates };
+}
+function loadRunViewModel(runId, options = {}) {
+  const run = openLedger().get(runId);
+  if (run === null) return null;
+  const now = options.now ?? (() => Date.now());
+  const journal = readRunEventJournal(runId, {
+    maxLines: TRANSCRIPT_LIMIT,
+    ...options.journalRoot === void 0 ? {} : { root: options.journalRoot }
+  });
+  const transcript = [];
+  for (const line of journal.lines) {
+    const rendered = transcriptLine(line);
+    if (rendered !== null) transcript.push(rendered);
+  }
+  const evidence = evidenceLine(run);
+  const startedMs = Date.parse(run.startedAt);
+  const endedMs = run.endedAt === null ? now() : Date.parse(run.endedAt);
+  const task = sanitizeBounded(run.task, TASK_MAX_WIDTH);
+  return {
+    runId: run.id,
+    agentId: run.agentId,
+    model: run.wireModelId,
+    target: run.targetId,
+    node: run.node?.id ?? "local",
+    phase: run.outcome ?? run.status,
+    startedAt: run.startedAt,
+    elapsedMs: Number.isFinite(startedMs) && Number.isFinite(endedMs) ? Math.max(0, endedMs - startedMs) : 0,
+    task: task.length > 0 ? task : void 0,
+    transcript,
+    transcriptTruncated: journal.truncated,
+    journalPresent: journal.present,
+    journalPath: runEventJournalPath(runId, options.journalRoot === void 0 ? void 0 : options.journalRoot),
+    evidence: evidence.text,
+    receiptPath: evidence.receiptPath,
+    outcome: journal.terminal?.outcome ?? run.outcome ?? null,
+    outcomeDetail: journal.terminal?.detail ?? run.outcomeDetail ?? null,
+    terminal: journal.terminal !== null || run.endedAt !== null
+  };
+}
+function formatElapsed(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m${String(seconds % 60).padStart(2, "0")}s`;
+  return `${Math.floor(minutes / 60)}h${String(minutes % 60).padStart(2, "0")}m`;
+}
+function clockOf(iso) {
+  const time = iso.slice(11, 19);
+  return time.length === 8 ? time : iso.slice(0, 8);
+}
+function renderRunView(model, width = DEFAULT_WIDTH) {
+  const columns = Math.max(MIN_WIDTH, width);
+  const rule = "\u2500".repeat(columns);
+  const lines = [];
+  lines.push(truncateToWidth(`run ${model.runId}  ${model.agentId}`, columns, "\u2026", false));
+  lines.push(
+    truncateToWidth(
+      `model ${model.model}  target ${model.target}  node ${model.node}  phase ${model.phase}  elapsed ${formatElapsed(model.elapsedMs)}`,
+      columns,
+      "\u2026",
+      false
+    )
+  );
+  if (model.task !== void 0) {
+    lines.push(truncateToWidth(`task ${model.task}`, columns, "\u2026", false));
+  }
+  lines.push(rule);
+  if (!model.journalPresent) {
+    lines.push("no event journal for this run.");
+    lines.push(`expected ${model.journalPath} (panes.journal may have been off when it ran)`);
+  } else if (model.transcript.length === 0) {
+    lines.push("journal is empty; no events recorded yet.");
+  } else {
+    if (model.transcriptTruncated) lines.push("\u2026 earlier events dropped (journal truncated)");
+    for (const entry of model.transcript) {
+      const head = `${clockOf(entry.at)} ${entry.label}`;
+      lines.push(truncateToWidth(entry.detail === void 0 ? head : `${head}: ${entry.detail}`, columns, "\u2026", false));
+    }
+  }
+  lines.push(rule);
+  lines.push(truncateToWidth(`evidence  ${model.evidence}`, columns, "\u2026", false));
+  if (model.receiptPath !== null) {
+    lines.push(truncateToWidth(`receipt   ${model.receiptPath}`, columns, "\u2026", false));
+  }
+  const outcome = model.outcome === null ? model.terminal ? "terminal, outcome not recorded" : "running" : model.outcomeDetail === null || model.outcomeDetail.length === 0 ? model.outcome : `${model.outcome} (${sanitizeBounded(model.outcomeDetail, DETAIL_MAX_WIDTH)})`;
+  lines.push(truncateToWidth(`outcome   ${outcome}`, columns, "\u2026", false));
+  return lines;
+}
+function renderWatchView(runId, model, width = DEFAULT_WIDTH, ledgerRoot = clioStateDir()) {
+  const columns = Math.max(MIN_WIDTH, width);
+  if (runId === null) {
+    return [
+      "no worker selected.",
+      "",
+      "In clio-coder, open the workers view (Alt+W), pick a run, press Enter.",
+      "Arrow keys there retarget this pane live."
+    ];
+  }
+  if (model === null) {
+    const missing = `run ${sanitizeBounded(runId, 64)} is not in the run ledger under ${ledgerRoot}.`;
+    const wrappedMissing = [];
+    for (let offset = 0; offset < missing.length; offset += columns) {
+      wrappedMissing.push(missing.slice(offset, offset + columns));
+    }
+    return [
+      ...wrappedMissing,
+      "",
+      "If this run is queued, it has not started yet; this view will update when its ledger entry appears.",
+      "If it already started or finished, it was not found in this ledger."
+    ];
+  }
+  return renderRunView(model, columns);
+}
+var FLEET_ROOT_PREFIX = "fleet-";
+var STEP_ID_MAX_WIDTH = 32;
+function fleetRunsDir() {
+  return join(clioStateDir(), "fleet-runs");
+}
+function resolveFleetRootId(token) {
+  if (readFleetRun(token) !== null) return { rootId: token };
+  let entries;
+  try {
+    entries = readdirSync(fleetRunsDir());
+  } catch {
+    return { candidates: [] };
+  }
+  const candidates = entries.filter((name) => name.endsWith(".json")).map((name) => name.slice(0, -".json".length)).filter((id) => id.startsWith(token));
+  if (candidates.length === 1 && candidates[0] !== void 0) return { rootId: candidates[0] };
+  return { candidates };
+}
+function stepResultOf(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function loadFleetRunViewModel(rootId, options = {}) {
+  const record = readFleetRun(rootId);
+  if (record === null) return null;
+  const ledger = openLedger();
+  const now = options.now ?? (() => Date.now());
+  const settled = /* @__PURE__ */ new Map();
+  for (const entry of record.steps ?? []) {
+    if (typeof entry?.stepId === "string") settled.set(entry.stepId, stepResultOf(entry.result));
+  }
+  const stepIds = record.stepIds?.length > 0 ? record.stepIds : [...settled.keys()];
+  const steps = stepIds.map((stepId) => {
+    const result = settled.get(stepId);
+    const runId = typeof result?.terminalRunId === "string" ? result.terminalRunId : null;
+    if (result === void 0 || runId === null) {
+      return { stepId, runId: null, agentId: null, outcome: "not run", detail: void 0 };
+    }
+    const envelope = ledger.get(runId);
+    const outcome = envelope?.outcome ?? (result.succeeded === true ? "succeeded" : "failed");
+    const detail = result.boundaryViolated === true ? WRITE_BOUNDARY_VIOLATION_REASON : result.failureReason;
+    return {
+      stepId,
+      runId,
+      agentId: envelope?.agentId ?? null,
+      outcome,
+      detail: typeof detail === "string" && detail.length > 0 ? detail : void 0
+    };
+  });
+  const startedMs = Date.parse(record.startedAt);
+  const endedMs = record.endedAt === null ? now() : Date.parse(record.endedAt);
+  return {
+    rootId: record.id,
+    fleet: record.fleet,
+    startedAt: record.startedAt,
+    elapsedMs: Number.isFinite(startedMs) && Number.isFinite(endedMs) ? Math.max(0, endedMs - startedMs) : 0,
+    running: record.endedAt === null,
+    resumedFrom: record.resumedFrom,
+    plannedSteps: stepIds.length,
+    recordedSteps: settled.size,
+    steps
+  };
+}
+function renderFleetRunView(model, width = DEFAULT_WIDTH) {
+  const columns = Math.max(MIN_WIDTH, width);
+  const rule = "\u2500".repeat(columns);
+  const lines = [];
+  lines.push(truncateToWidth(`fleet ${sanitizeBounded(model.fleet, 64)}  root ${model.rootId}`, columns, "\u2026", false));
+  const resumed = model.resumedFrom === null ? "" : `  resumed from ${sanitizeBounded(model.resumedFrom, 64)}`;
+  lines.push(
+    truncateToWidth(
+      `started ${model.startedAt}  elapsed ${formatElapsed(model.elapsedMs)}  ${model.recordedSteps} of ${model.plannedSteps} steps recorded${model.running ? "  (running)" : ""}${resumed}`,
+      columns,
+      "\u2026",
+      false
+    )
+  );
+  lines.push(rule);
+  if (model.steps.length === 0) {
+    lines.push("no steps recorded for this fleet run.");
+  } else {
+    const rows = model.steps.map((step) => ({
+      step: sanitizeBounded(step.stepId, STEP_ID_MAX_WIDTH),
+      runId: step.runId ?? "-",
+      outcome: sanitizeBounded(step.outcome, 32),
+      tail: [step.agentId, step.detail].filter((part) => part !== null && part !== void 0).join(": ")
+    }));
+    const stepWidth = Math.max(...rows.map((row) => row.step.length));
+    const runWidth = Math.max(...rows.map((row) => row.runId.length));
+    const outcomeWidth = Math.max(...rows.map((row) => row.outcome.length));
+    for (const row of rows) {
+      const head = `${row.step.padEnd(stepWidth)}  ${row.runId.padEnd(runWidth)}  ${row.outcome.padEnd(outcomeWidth)}`;
+      const text = row.tail.length === 0 ? head : `${head}  ${sanitizeBounded(row.tail, DETAIL_MAX_WIDTH)}`;
+      lines.push(truncateToWidth(text.trimEnd(), columns, "\u2026", false));
+    }
+  }
+  lines.push(rule);
+  lines.push("clio-coder fleet view <run id> for one step's transcript, receipt, and ledger entry");
+  return lines;
+}
+function fail(message) {
+  process.stderr.write(`clio-coder fleet view: ${message}
+`);
+  return 2;
+}
+function parseViewArgs(args) {
+  const parsed = { follow: false, help: false };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === void 0) continue;
+    if (arg === "--follow" || arg === "-f") {
+      parsed.follow = true;
+      continue;
+    }
+    if (arg === "--watch") {
+      const value = args[i + 1];
+      if (value === void 0 || value.startsWith("-")) return "--watch requires a selection-file path";
+      parsed.watchPath = value;
+      i += 1;
+      continue;
+    }
+    const dirRole = arg === "--config-dir" ? "config" : arg === "--data-dir" ? "data" : arg === "--state-dir" ? "state" : arg === "--cache-dir" ? "cache" : null;
+    if (dirRole !== null) {
+      const value = args[i + 1];
+      if (value === void 0 || value.startsWith("-")) return `${arg} requires a directory path`;
+      parsed.dirs ??= {};
+      parsed.dirs[dirRole] = value;
+      i += 1;
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+      continue;
+    }
+    if (arg.startsWith("-")) return `unknown flag: ${arg}`;
+    if (parsed.runId !== void 0) return `unexpected argument: ${arg}`;
+    parsed.runId = arg;
+  }
+  if (parsed.watchPath !== void 0 && parsed.runId !== void 0) {
+    return "--watch follows the selection file; it does not take a run id";
+  }
+  if (parsed.watchPath !== void 0 && parsed.follow) {
+    return "--watch already follows; drop --follow";
+  }
+  return parsed;
+}
+function applyViewDirs(dirs) {
+  if (dirs === void 0) return;
+  if (dirs.config !== void 0) process.env.CLIO_CODER_CONFIG_DIR = dirs.config;
+  if (dirs.data !== void 0) process.env.CLIO_CODER_DATA_DIR = dirs.data;
+  if (dirs.state !== void 0) process.env.CLIO_CODER_STATE_DIR = dirs.state;
+  if (dirs.cache !== void 0) process.env.CLIO_CODER_CACHE_DIR = dirs.cache;
+  resetXdgCache();
+}
+function readWatchSelection(path) {
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch {
+    return null;
+  }
+  const line = raw.split("\n", 1)[0]?.trim() ?? "";
+  return line.length > 0 && line.length <= 128 ? line : null;
+}
+function terminalWidth() {
+  const columns = process.stdout.columns;
+  return typeof columns === "number" && columns >= MIN_WIDTH ? columns : DEFAULT_WIDTH;
+}
+async function runFleetView(args) {
+  const parsed = parseViewArgs(args);
+  if (typeof parsed === "string") {
+    process.stderr.write(`clio-coder fleet view: ${parsed}
+`);
+    process.stdout.write(HELP);
+    return 2;
+  }
+  if (parsed.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  applyViewDirs(parsed.dirs);
+  if (parsed.watchPath !== void 0) {
+    if (process.stdout.isTTY !== true || process.stdin.isTTY !== true) {
+      const selected = readWatchSelection(parsed.watchPath);
+      const model = selected === null ? null : loadRunViewModel(selected);
+      process.stdout.write(`${renderWatchView(selected, model, terminalWidth()).join("\n")}
+`);
+      return 0;
+    }
+    return watchSelection(parsed.watchPath);
+  }
+  if (parsed.runId === void 0) {
+    process.stderr.write(HELP);
+    return 2;
+  }
+  if (parsed.runId.startsWith(FLEET_ROOT_PREFIX)) {
+    const root = resolveFleetRootId(parsed.runId);
+    if (!("rootId" in root)) {
+      return root.candidates.length === 0 ? fail(`unknown fleet run '${parsed.runId}' (no record under ${fleetRunsDir()})`) : fail(`fleet root id '${parsed.runId}' is ambiguous: ${root.candidates.slice(0, 8).join(", ")}`);
+    }
+    const fleetModel = loadFleetRunViewModel(root.rootId);
+    if (fleetModel === null) return fail(`unknown fleet run '${root.rootId}'`);
+    if (parsed.follow) {
+      process.stderr.write("clio-coder fleet view: --follow applies to a run id, not a fleet root; printing the index\n");
+    }
+    process.stdout.write(`${renderFleetRunView(fleetModel, terminalWidth()).join("\n")}
+`);
+    return 0;
+  }
+  const resolved = resolveRunId(parsed.runId);
+  if (!("runId" in resolved)) {
+    return resolved.candidates.length === 0 ? fail(`unknown run '${parsed.runId}' (not in the run ledger under ${clioStateDir()})`) : fail(`run id '${parsed.runId}' is ambiguous: ${resolved.candidates.slice(0, 8).join(", ")}`);
+  }
+  const runId = resolved.runId;
+  const snapshot = loadRunViewModel(runId);
+  if (snapshot === null) return fail(`unknown run '${runId}'`);
+  if (!parsed.follow || process.stdout.isTTY !== true || process.stdin.isTTY !== true) {
+    if (parsed.follow) {
+      process.stderr.write("clio-coder fleet view: --follow needs an interactive terminal; printing a snapshot\n");
+    }
+    process.stdout.write(`${renderRunView(snapshot, terminalWidth()).join("\n")}
+`);
+    return 0;
+  }
+  return followRun(runId);
+}
+async function watchSelection(selectionPath) {
+  const { ProcessTerminal, TuiAltScreen } = await import("./tui-primitives-2AKXQNZK.js");
+  const terminal = new ProcessTerminal();
+  const tui = new TuiAltScreen(terminal);
+  let selected = readWatchSelection(selectionPath);
+  let model = selected === null ? null : loadRunViewModel(selected);
+  const view = {
+    render(width) {
+      const lines = renderWatchView(selected, model, width);
+      lines.push("");
+      lines.push("watching the workers-view selection\u2026 q to quit");
+      return lines;
+    },
+    invalidate() {
+    }
+  };
+  tui.addChild(view);
+  return await new Promise((resolve) => {
+    let settled = false;
+    const timer = setInterval(() => {
+      selected = readWatchSelection(selectionPath);
+      model = selected === null ? null : loadRunViewModel(selected);
+      tui.requestRender();
+    }, POLL_MS);
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      clearInterval(timer);
+      removeInput();
+      tui.stop();
+      resolve(0);
+    };
+    const removeInput = tui.addInputListener((data) => {
+      if (data === "q" || data === QUIT_CTRL_C || data === QUIT_ESCAPE) {
+        finish();
+        return { consume: true };
+      }
+      return void 0;
+    });
+    tui.start();
+    tui.requestRender();
+  });
+}
+async function followRun(runId) {
+  const { ProcessTerminal, TuiAltScreen } = await import("./tui-primitives-2AKXQNZK.js");
+  const terminal = new ProcessTerminal();
+  const tui = new TuiAltScreen(terminal);
+  let model = loadRunViewModel(runId);
+  let following = true;
+  const view = {
+    render(width) {
+      if (model === null) return [`run ${runId} left the ledger.`];
+      const lines = renderRunView(model, width);
+      lines.push("");
+      lines.push(following ? "following\u2026 q to quit" : "run finished. q to quit");
+      return lines;
+    },
+    invalidate() {
+    }
+  };
+  tui.addChild(view);
+  return await new Promise((resolve) => {
+    let settled = false;
+    const timer = setInterval(() => {
+      model = loadRunViewModel(runId);
+      if (model?.terminal === true) following = false;
+      tui.requestRender();
+    }, POLL_MS);
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      clearInterval(timer);
+      removeInput();
+      tui.stop();
+      resolve(0);
+    };
+    const removeInput = tui.addInputListener((data) => {
+      if (data === "q" || data === QUIT_CTRL_C || data === QUIT_ESCAPE) {
+        finish();
+        return { consume: true };
+      }
+      return void 0;
+    });
+    tui.start();
+    tui.requestRender();
+  });
+}
+
+export {
+  resolveRunId,
+  loadRunViewModel,
+  renderRunView,
+  renderWatchView,
+  resolveFleetRootId,
+  loadFleetRunViewModel,
+  renderFleetRunView,
+  readWatchSelection,
+  runFleetView
+};
+//# sourceMappingURL=chunk-IBEBSCYA.js.map