@iowarp/clio-coder 0.3.9 → 0.4.0

package/dist/chunk-IQ7KR472.js

@@ -0,0 +1,362 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  clioStateDir,
+  stateRootRemoved
+} from "./chunk-BYP5D4HI.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/dispatch/run-event-journal.ts
+init_esm_shims();
+import { appendFileSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+var RUN_EVENT_JOURNAL_DIR = "runs";
+var RUN_EVENT_JOURNAL_FILE = "events.ndjson";
+var RUN_EVENT_JOURNAL_CAP_BYTES = 2 * 1024 * 1024;
+var RUN_EVENT_JOURNAL_FLUSH_BYTES = 8 * 1024;
+var RUN_EVENT_JOURNAL_ENV_VAR = "CLIO_CODER_RUN_JOURNAL";
+var configuredEnabled;
+function configureRunEventJournal(enabled) {
+  configuredEnabled = enabled;
+}
+function parseEnvFlag(raw) {
+  if (raw === void 0) return void 0;
+  const normalized = raw.trim().toLowerCase();
+  if (normalized === "1" || normalized === "true" || normalized === "on") return true;
+  if (normalized === "0" || normalized === "false" || normalized === "off") return false;
+  return void 0;
+}
+function runEventJournalEnabled(env = process.env) {
+  return parseEnvFlag(env[RUN_EVENT_JOURNAL_ENV_VAR]) ?? configuredEnabled ?? true;
+}
+function runEventJournalRoot() {
+  return join(clioStateDir(), RUN_EVENT_JOURNAL_DIR);
+}
+function runEventJournalDir(runId, root) {
+  return join(root ?? runEventJournalRoot(), runId);
+}
+function runEventJournalPath(runId, root) {
+  return join(runEventJournalDir(runId, root), RUN_EVENT_JOURNAL_FILE);
+}
+function newestRunEventJournalRunId(root) {
+  if (stateRootRemoved()) return null;
+  const dir = root ?? runEventJournalRoot();
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return null;
+  }
+  let newest = null;
+  for (const runId of names) {
+    if (!isSafeRunId(runId)) continue;
+    const stats = statSync(runEventJournalPath(runId, dir), { throwIfNoEntry: false });
+    if (stats === void 0 || !stats.isFile()) continue;
+    const at = stats.mtimeMs;
+    if (newest === null || at > newest.at) newest = { runId, at };
+  }
+  return newest?.runId ?? null;
+}
+function removeRunEventJournals(runIds, root) {
+  if (stateRootRemoved()) return;
+  for (const runId of runIds) {
+    if (!isSafeRunId(runId)) continue;
+    try {
+      rmSync(runEventJournalDir(runId, root), { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+function isSafeRunId(runId) {
+  return /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(runId) && runId !== "." && runId !== "..";
+}
+var RUN_STATE_LIMIT = 256;
+function createRunEventJournal(options = {}) {
+  const capBytes = options.capBytes ?? RUN_EVENT_JOURNAL_CAP_BYTES;
+  const flushBytes = options.flushBytes ?? RUN_EVENT_JOURNAL_FLUSH_BYTES;
+  const warn = options.warn ?? ((message) => process.stderr.write(`[clio:journal] ${message}
+`));
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const isEnabled = options.isEnabled ?? (() => runEventJournalEnabled());
+  const runs = /* @__PURE__ */ new Map();
+  let degraded = false;
+  const degrade = (error) => {
+    if (degraded) return;
+    degraded = true;
+    runs.clear();
+    warn(
+      `run event journal disabled for this process: ${error instanceof Error ? error.message : String(error)}. Dispatch is unaffected; \`clio-coder fleet view\` will have no transcript for runs started from here.`
+    );
+  };
+  const pruneRunStates = () => {
+    while (runs.size > RUN_STATE_LIMIT) {
+      let oldestKey = null;
+      let oldestSeen = Number.POSITIVE_INFINITY;
+      for (const [key, state] of runs) {
+        if (state.pending.length > 0 || state.touchedAt >= oldestSeen) continue;
+        oldestKey = key;
+        oldestSeen = state.touchedAt;
+      }
+      if (oldestKey === null) break;
+      runs.delete(oldestKey);
+    }
+  };
+  const stateFor = (runId) => {
+    if (degraded || !isSafeRunId(runId) || !isEnabled()) return null;
+    const existing = runs.get(runId);
+    if (existing !== void 0) {
+      if (existing.closed) return null;
+      existing.touchedAt = Date.now();
+      return existing;
+    }
+    if (stateRootRemoved()) return null;
+    let path;
+    try {
+      const dir = runEventJournalDir(runId, options.root);
+      mkdirSync(dir, { recursive: true });
+      path = join(dir, RUN_EVENT_JOURNAL_FILE);
+    } catch (error) {
+      degrade(error);
+      return null;
+    }
+    let bytes = 0;
+    let seq = 0;
+    try {
+      const stat = statSync(path);
+      bytes = stat.size;
+    } catch {
+    }
+    if (bytes > 0) seq = countJournalSeq(path);
+    const state = {
+      path,
+      seq,
+      bytes,
+      pending: [],
+      pendingBytes: 0,
+      dropping: bytes >= capBytes,
+      closed: false,
+      touchedAt: Date.now()
+    };
+    runs.set(runId, state);
+    pruneRunStates();
+    return state;
+  };
+  const flushState = (state) => {
+    if (state.pending.length === 0) return;
+    const payload = state.pending.join("");
+    state.pending = [];
+    state.pendingBytes = 0;
+    if (stateRootRemoved()) return;
+    try {
+      appendFileSync(state.path, payload, "utf8");
+    } catch (error) {
+      degrade(error);
+    }
+  };
+  const write = (state, line, droppable) => {
+    if (droppable && state.dropping) return;
+    if (droppable && state.bytes + state.pendingBytes >= capBytes) {
+      state.dropping = true;
+      write(state, { kind: "journal_truncated", reason: "per-run size cap", droppedFromSeq: state.seq + 1 }, false);
+      return;
+    }
+    state.seq += 1;
+    const serialized = `${JSON.stringify({ seq: state.seq, at: now().toISOString(), ...line })}
+`;
+    const size = Buffer.byteLength(serialized, "utf8");
+    state.pending.push(serialized);
+    state.pendingBytes += size;
+    state.bytes += size;
+    if (!droppable || state.pendingBytes >= flushBytes) flushState(state);
+  };
+  return {
+    open(runId, agentId) {
+      const state = stateFor(runId);
+      if (state === null) return;
+      write(state, { kind: "open", runId, agentId }, false);
+    },
+    append(runId, entry) {
+      const state = stateFor(runId);
+      if (state === null) return;
+      write(
+        state,
+        entry.detail === void 0 ? { kind: "event", type: entry.type } : { kind: "event", type: entry.type, detail: entry.detail },
+        true
+      );
+    },
+    receipt(runId, receipt) {
+      const state = stateFor(runId);
+      if (state === null) return;
+      write(
+        state,
+        {
+          kind: "receipt",
+          outcome: receipt.outcome,
+          exitCode: receipt.exitCode,
+          ...receipt.digest !== void 0 ? { digest: receipt.digest } : {},
+          ...receipt.receiptPath !== void 0 ? { receiptPath: receipt.receiptPath } : {},
+          ...receipt.attemptRunId !== void 0 ? { attemptRunId: receipt.attemptRunId } : {}
+        },
+        false
+      );
+    },
+    terminal(runId, outcome, detail) {
+      const state = stateFor(runId);
+      if (state === null) return;
+      write(state, detail === void 0 ? { kind: "terminal", outcome } : { kind: "terminal", outcome, detail }, false);
+      flushState(state);
+      state.closed = true;
+    },
+    flush() {
+      for (const state of runs.values()) flushState(state);
+    },
+    degraded() {
+      return degraded;
+    }
+  };
+}
+function countJournalSeq(path) {
+  try {
+    const raw = readFileSync(path, "utf8");
+    let highest = 0;
+    for (const line of raw.split("\n")) {
+      if (line.length === 0) continue;
+      const parsed = parseJournalLine(line);
+      if (parsed !== null && parsed.seq > highest) highest = parsed.seq;
+    }
+    return highest;
+  } catch {
+    return 0;
+  }
+}
+var defaultJournal = null;
+function defaultRunEventJournal() {
+  defaultJournal ??= createRunEventJournal();
+  return defaultJournal;
+}
+var RUN_EVENT_JOURNAL_READ_TAIL_BYTES = 256 * 1024;
+function parseJournalLine(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+  const record = parsed;
+  if (typeof record.seq !== "number" || typeof record.at !== "string" || typeof record.kind !== "string") return null;
+  switch (record.kind) {
+    case "open":
+      if (typeof record.runId !== "string" || typeof record.agentId !== "string") return null;
+      return { seq: record.seq, at: record.at, kind: "open", runId: record.runId, agentId: record.agentId };
+    case "event": {
+      if (typeof record.type !== "string") return null;
+      const detail = typeof record.detail === "string" ? record.detail : void 0;
+      return {
+        seq: record.seq,
+        at: record.at,
+        kind: "event",
+        type: record.type,
+        ...detail === void 0 ? {} : { detail }
+      };
+    }
+    case "journal_truncated":
+      return {
+        seq: record.seq,
+        at: record.at,
+        kind: "journal_truncated",
+        reason: typeof record.reason === "string" ? record.reason : "unknown",
+        droppedFromSeq: typeof record.droppedFromSeq === "number" ? record.droppedFromSeq : record.seq
+      };
+    case "receipt": {
+      if (typeof record.outcome !== "string") return null;
+      return {
+        seq: record.seq,
+        at: record.at,
+        kind: "receipt",
+        outcome: record.outcome,
+        exitCode: typeof record.exitCode === "number" ? record.exitCode : null,
+        ...typeof record.digest === "string" ? { digest: record.digest } : {},
+        ...typeof record.receiptPath === "string" ? { receiptPath: record.receiptPath } : {},
+        ...typeof record.attemptRunId === "string" ? { attemptRunId: record.attemptRunId } : {}
+      };
+    }
+    case "terminal": {
+      if (typeof record.outcome !== "string") return null;
+      const detail = typeof record.detail === "string" ? record.detail : void 0;
+      return {
+        seq: record.seq,
+        at: record.at,
+        kind: "terminal",
+        outcome: record.outcome,
+        ...detail === void 0 ? {} : { detail }
+      };
+    }
+    default:
+      return null;
+  }
+}
+function readRunEventJournal(runId, options = {}) {
+  const path = runEventJournalPath(runId, options.root);
+  const empty = {
+    path,
+    present: false,
+    bytes: 0,
+    lines: [],
+    truncated: false,
+    terminal: null,
+    agentId: null
+  };
+  if (!isSafeRunId(runId)) return empty;
+  const tailBytes = options.tailBytes ?? RUN_EVENT_JOURNAL_READ_TAIL_BYTES;
+  let raw;
+  let size;
+  let headDropped = false;
+  try {
+    size = statSync(path).size;
+    if (size <= tailBytes) {
+      raw = readFileSync(path, "utf8");
+    } else {
+      const buffer = readFileSync(path);
+      raw = buffer.subarray(size - tailBytes).toString("utf8");
+      const firstBreak = raw.indexOf("\n");
+      raw = firstBreak === -1 ? "" : raw.slice(firstBreak + 1);
+      headDropped = true;
+    }
+  } catch {
+    return empty;
+  }
+  const lines = [];
+  let truncated = headDropped;
+  let terminal = null;
+  let agentId = null;
+  for (const candidate of raw.split("\n")) {
+    if (candidate.length === 0) continue;
+    const parsed = parseJournalLine(candidate);
+    if (parsed === null) continue;
+    if (parsed.kind === "journal_truncated") truncated = true;
+    if (parsed.kind === "open") agentId = parsed.agentId;
+    if (parsed.kind === "terminal") {
+      terminal = parsed.detail === void 0 ? { outcome: parsed.outcome } : { outcome: parsed.outcome, detail: parsed.detail };
+    }
+    lines.push(parsed);
+  }
+  const maxLines = options.maxLines;
+  if (maxLines !== void 0 && lines.length > maxLines) {
+    lines.splice(0, lines.length - maxLines);
+    truncated = true;
+  }
+  return { path, present: true, bytes: size, lines, truncated, terminal, agentId };
+}
+
+export {
+  configureRunEventJournal,
+  runEventJournalRoot,
+  runEventJournalPath,
+  newestRunEventJournalRunId,
+  removeRunEventJournals,
+  defaultRunEventJournal,
+  readRunEventJournal
+};
+//# sourceMappingURL=chunk-IQ7KR472.js.map