tines 0.0.82 → 0.0.84

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync4, readdirSync, readFileSync as readFileSync4, statSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync4, readdirSync, readFileSync as readFileSync5, statSync as statSync2, writeFileSync as writeFileSync3 } from "node:fs";
 import { hostname as hostname2 } from "node:os";
 import { basename, dirname as dirname4, join as join4 } from "node:path";
 import { createInterface } from "node:readline/promises";
@@ -40,7 +40,15 @@ function readBodyValue(value, stdin = processStdin) {
 
 // src/daemon/daemon.ts
 import { spawn as spawn2 } from "node:child_process";
-import { mkdirSync as mkdirSync3, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import {
+  createWriteStream,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync4,
+  rmSync,
+  statSync,
+  unlinkSync,
+  writeFileSync as writeFileSync2
+} from "node:fs";
 import { hostname, platform, arch } from "node:os";
 import { dirname as dirname3, join as join3 } from "node:path";
 
@@ -108,6 +116,8 @@ var RUNNER_OFFLINE_FAIL_MS = 5 * 60 * 1e3;
 var LAUNCH_STALL_MS = 5 * 60 * 1e3;
 var RUN_KEY_SLACK_MS = 10 * 60 * 1e3;
 var RUN_LOG_MAX_BYTES = 256 * 1024;
+var RUN_LOG_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
+var RUN_LOG_RAW_MAX_BYTES = 64 * 1024 * 1024;
 var MODEL_PREDECESSORS = {
   "claude-fable-5": ["claude-opus-5", "claude-opus-4-8", "claude-opus-4-7", "claude-opus-4-6"],
   "claude-opus-5": ["claude-opus-4-8", "claude-opus-4-7", "claude-opus-4-6", "claude-opus-4-5", "claude-opus-4-1"],
@@ -497,6 +507,19 @@ function createApiClient(options) {
     // Agent runs
     listRuns: (filters = {}) => get(`/api/v1/runs${query(filters)}`),
     getRun: (id) => get(`/api/v1/runs/${id}`),
+    /**
+     * The run's complete log (not the 256 KB tail `getRun` returns) as a
+     * streamed Response, so a multi-megabyte log never has to be held in
+     * memory. `raw` asks for the unrendered harness stream instead.
+     */
+    getRunLogFull: (id, opts = {}) => raw("GET", `/api/v1/runs/${id}/log${opts.raw ? "?raw=1" : ""}`, {
+      headers: { accept: "text/plain" }
+    }),
+    /** Daemon-only: uploads the raw harness stream for a settled run. */
+    putRunLogRaw: (id, body) => raw("PUT", `/api/v1/runs/${id}/log/raw`, {
+      body,
+      headers: { "content-type": "application/x-ndjson", "content-length": String(body.byteLength) }
+    }),
     cancelRun: (id) => request("POST", `/api/v1/runs/${id}/cancel`),
     // Routing rules (one per exact scope; responses carry shadow hints)
     listRoutingRules: () => get("/api/v1/routing-rules"),
@@ -550,6 +573,101 @@ var PLACEHOLDER_DESCRIPTIONS = {
 };
 var TEMPLATE_PLACEHOLDERS = Object.keys(PLACEHOLDER_DESCRIPTIONS).map((key) => ({ key, description: PLACEHOLDER_DESCRIPTIONS[key] }));
 
+// src/daemon/claude-stream.ts
+function clip(value, max) {
+  return value.length > max ? `${value.slice(0, max)}\u2026` : value;
+}
+function resultText(content) {
+  if (typeof content === "string") return content.trim();
+  if (Array.isArray(content)) {
+    return content.map((block) => typeof block?.text === "string" ? block.text : "").join("").trim();
+  }
+  return "";
+}
+function renderStreamEvent(event) {
+  switch (event.type) {
+    case "system":
+      if (event.subtype === "init") {
+        return [`[session] started${event.model ? ` (model ${event.model})` : ""}`];
+      }
+      return [];
+    case "assistant": {
+      const lines = [];
+      for (const block of event.message?.content ?? []) {
+        if (block.type === "text" && block.text?.trim()) {
+          lines.push(`[agent] ${clip(block.text.trim(), 2e3)}`);
+        } else if (block.type === "tool_use") {
+          const args = block.input === void 0 ? "" : JSON.stringify(block.input);
+          lines.push(`[tool] ${block.name ?? "tool"} ${clip(args, 300)}`.trimEnd());
+        }
+      }
+      return lines;
+    }
+    case "user": {
+      const lines = [];
+      for (const block of event.message?.content ?? []) {
+        if (block.type === "tool_result" && block.is_error) {
+          lines.push(`[tool] error: ${clip(resultText(block.content), 300)}`);
+        }
+      }
+      return lines;
+    }
+    case "result": {
+      const parts = [];
+      if (typeof event.num_turns === "number") parts.push(`${event.num_turns} turns`);
+      if (typeof event.total_cost_usd === "number") parts.push(`$${event.total_cost_usd.toFixed(2)}`);
+      const detail = parts.length > 0 ? ` (${parts.join(", ")})` : "";
+      const lines = [`[session] result: ${event.subtype ?? "done"}${detail}`];
+      if (event.is_error && event.result) lines.push(`[error] ${clip(event.result, 2e3)}`);
+      return lines;
+    }
+    default:
+      return [];
+  }
+}
+var ClaudeStreamRenderer = class {
+  constructor(emit) {
+    this.emit = emit;
+  }
+  emit;
+  pending = "";
+  write(chunk) {
+    this.pending += chunk;
+    let nl = this.pending.indexOf("\n");
+    while (nl !== -1) {
+      this.line(this.pending.slice(0, nl));
+      this.pending = this.pending.slice(nl + 1);
+      nl = this.pending.indexOf("\n");
+    }
+  }
+  /** Renders any trailing partial line. Call once the harness has exited. */
+  finish() {
+    if (this.pending) {
+      this.line(this.pending);
+      this.pending = "";
+    }
+  }
+  line(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) return;
+    if (!trimmed.startsWith("{")) {
+      this.emit(`${raw}
+`);
+      return;
+    }
+    let event;
+    try {
+      event = JSON.parse(trimmed);
+    } catch {
+      this.emit(`${raw}
+`);
+      return;
+    }
+    for (const line of renderStreamEvent(event)) this.emit(`${line}
+`);
+  }
+};
+
 // src/daemon/cli-refresh.ts
 import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync as readFileSync2 } from "node:fs";
@@ -571,7 +689,7 @@ function buildHarnessInvocation(spec, input) {
         file: "sh",
         args: [
           "-c",
-          `claude -p${input.model ? ` --model ${shellQuote(input.model)}` : ""} < ${shellQuote(input.promptFile)}`
+          `claude -p --output-format stream-json --verbose${input.model ? ` --model ${shellQuote(input.model)}` : ""} < ${shellQuote(input.promptFile)}`
         ]
       };
     case "codex":
@@ -626,6 +744,7 @@ var RunTable = class {
   async finishAndCleanup(run, status, error) {
     if (run.settled) return this.cleanup(run);
     run.settled = true;
+    run.drain?.();
     await run.flush?.();
     try {
       await this.effects.finish(run, status, error);
@@ -661,10 +780,13 @@ var LogBatcher = class {
   buffer = "";
   timer = null;
   sending = Promise.resolve();
+  seq = 0;
+  /** Chunks awaiting a successful send, oldest first. */
+  pending = [];
   append(text2) {
     if (!text2) return;
     this.buffer += text2;
-    if (Buffer.byteLength(this.buffer, "utf8") >= (this.opts.maxBytes ?? 8 * 1024)) {
+    if (Buffer.byteLength(this.buffer, "utf8") >= (this.opts.maxBytes ?? 32 * 1024)) {
       void this.flush();
     } else if (!this.timer) {
       this.timer = setTimeout(() => void this.flush(), this.opts.intervalMs ?? 2e3);
@@ -677,13 +799,53 @@ var LogBatcher = class {
       clearTimeout(this.timer);
       this.timer = null;
     }
-    const chunk = this.buffer;
-    this.buffer = "";
-    if (chunk) {
-      this.sending = this.sending.then(() => this.send(chunk)).catch((err) => this.opts.onError?.(err));
+    if (this.buffer) {
+      this.pending.push({ chunk: this.buffer, seq: ++this.seq });
+      this.buffer = "";
+      this.trimPending();
     }
+    if (this.pending.length === 0) return this.sending;
+    this.sending = this.sending.then(() => this.drain());
     return this.sending;
   }
+  /**
+   * Sends queued chunks in order, stopping at the first failure so the
+   * survivors keep their place — and their seq, which is what lets the
+   * server recognise a resend of a chunk it already applied.
+   */
+  async drain() {
+    while (this.pending.length > 0) {
+      const next = this.pending[0];
+      try {
+        await this.send(next.chunk, next.seq);
+      } catch (err) {
+        this.opts.onError?.(err);
+        return;
+      }
+      this.pending.shift();
+    }
+  }
+  /**
+   * Bounds the retry backlog: a daemon that cannot reach the supervisor for
+   * a long time must not grow its heap without limit. The oldest chunks go
+   * first, with a marker so the gap is visible in the log rather than
+   * silent.
+   */
+  trimPending() {
+    const cap = this.opts.maxPendingBytes ?? 1024 * 1024;
+    let held = this.pending.reduce((n, p) => n + Buffer.byteLength(p.chunk, "utf8"), 0);
+    if (held <= cap) return;
+    let lost = 0;
+    while (this.pending.length > 1 && held > cap) {
+      const dropped = this.pending.shift();
+      const bytes = Buffer.byteLength(dropped.chunk, "utf8");
+      held -= bytes;
+      lost += bytes;
+    }
+    const head = this.pending[0];
+    head.chunk = `[log] ${lost} bytes lost (supervisor unreachable)
+${head.chunk}`;
+  }
 };
 var AMBIENT_CLI = { binDir: null, version: null, source: "ambient" };
 var CliRefresher = class {
@@ -884,6 +1046,32 @@ function processStartTimeMs(pid) {
 
 // src/daemon/daemon.ts
 var CLI_REFRESH_TTL_MS = 10 * 6e4;
+async function uploadRawLog(run) {
+  const path2 = run.rawSpoolPath;
+  if (!path2 || !run.rawUpload) return;
+  run.rawSpoolPath = void 0;
+  try {
+    await new Promise((resolve) => run.rawSpool?.end(resolve) ?? resolve());
+    const size = statSync(path2).size;
+    if (size > 0) {
+      let body = readFileSync4(path2);
+      if (body.byteLength > RUN_LOG_RAW_MAX_BYTES) {
+        const marker = Buffer.from(
+          `{"type":"tines_truncated","dropped_bytes":${body.byteLength - RUN_LOG_RAW_MAX_BYTES}}
+`
+        );
+        body = Buffer.concat([marker, body.subarray(body.byteLength - RUN_LOG_RAW_MAX_BYTES + marker.byteLength)]);
+      }
+      await run.rawUpload(body);
+    }
+  } catch {
+  } finally {
+    try {
+      unlinkSync(path2);
+    } catch {
+    }
+  }
+}
 var log = (message3) => console.log(`[${(/* @__PURE__ */ new Date()).toISOString().slice(11, 19)}] ${message3}`);
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 function killTree(pid, signal) {
@@ -943,7 +1131,9 @@ async function runDaemon(opts) {
     },
     release: (run) => {
       if (run.timeout) clearTimeout(run.timeout);
+      run.renderer?.finish();
       rmSync(run.workspace, { recursive: true, force: true });
+      void uploadRawLog(run);
     },
     persist: () => {
       const entries = table2.values().filter((run) => run.child?.pid !== void 0).map((run) => ({
@@ -999,10 +1189,11 @@ async function runDaemon(opts) {
       timedOut: false,
       settled: false,
       keyFingerprint: assignment.run_key.slice(0, 14),
-      batcher: new LogBatcher((chunk) => client2.appendRunLog(runId, { chunk }).then(() => {
-      }), {
-        onError: (err) => log(`log append for run ${runId} failed: ${message2(err)}`)
-      })
+      batcher: new LogBatcher(
+        (chunk, seq) => client2.appendRunLog(runId, { chunk, seq }).then(() => {
+        }),
+        { onError: (err) => log(`log append for run ${runId} failed: ${message2(err)}`) }
+      )
     };
     run.flush = () => run.batcher.flush();
     table2.track(run);
@@ -1066,7 +1257,22 @@ async function runDaemon(opts) {
       run.spawnedAt = Date.now();
       table2.persist();
       log(`run ${runId}: launched ${invocation.file} (pid ${child.pid})`);
-      child.stdout?.on("data", (data) => run.batcher.append(data.toString("utf8")));
+      if (opts.harness === "claude_code") {
+        const renderer = new ClaudeStreamRenderer((line) => run.batcher.append(line));
+        run.renderer = renderer;
+        run.drain = () => renderer.finish();
+        const spoolPath = join3(opts.configDir, "rawlogs", `${runId}.ndjson`);
+        mkdirSync3(dirname3(spoolPath), { recursive: true });
+        run.rawSpoolPath = spoolPath;
+        run.rawSpool = createWriteStream(spoolPath);
+        run.rawUpload = (body) => client2.putRunLogRaw(runId, body);
+        child.stdout?.on("data", (data) => {
+          run.rawSpool?.write(data);
+          renderer.write(data.toString("utf8"));
+        });
+      } else {
+        child.stdout?.on("data", (data) => run.batcher.append(data.toString("utf8")));
+      }
       child.stderr?.on("data", (data) => run.batcher.append(data.toString("utf8")));
       run.timeout = setTimeout(
         () => {
@@ -4643,14 +4849,14 @@ function readJsonBody(inline, file) {
   if (file !== void 0 && file !== "-") {
     let raw;
     try {
-      raw = readFileSync4(file, "utf8");
+      raw = readFileSync5(file, "utf8");
     } catch (err) {
       die(`cannot read ${file}: ${err instanceof Error ? err.message : String(err)}`);
     }
     return parseJsonObject(raw, file);
   }
   if (file === "-" || !process.stdin.isTTY) {
-    const raw = readFileSync4(0, "utf8");
+    const raw = readFileSync5(0, "utf8");
     if (raw.trim() === "") {
       if (file === "-") die("no JSON on stdin");
       return void 0;
@@ -4792,7 +4998,7 @@ function parseFileSpec(spec) {
   }
   const file = source.slice(1);
   try {
-    return { path: path2, content: readFileSync4(file, "utf8") };
+    return { path: path2, content: readFileSync5(file, "utf8") };
   } catch (err) {
     die(`cannot read ${file}: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -4990,7 +5196,7 @@ warning: ${w}`);
 function cliVersion() {
   try {
     const manifest = new URL("../package.json", import.meta.url);
-    return JSON.parse(readFileSync4(manifest, "utf8")).version ?? "0.0.0-unknown";
+    return JSON.parse(readFileSync5(manifest, "utf8")).version ?? "0.0.0-unknown";
   } catch {
     return "0.0.0-unknown";
   }
@@ -5451,7 +5657,7 @@ function walkFolder(dir) {
       const nextRel = rel ? `${rel}/${entry.name}` : entry.name;
       if (entry.isDirectory()) walk(nextAbs, nextRel);
       else if (entry.isFile()) {
-        files.push({ path: nextRel, contentType: sniffContentType(entry.name), bytes: readFileSync4(nextAbs) });
+        files.push({ path: nextRel, contentType: sniffContentType(entry.name), bytes: readFileSync5(nextAbs) });
       }
     }
   };
@@ -5526,7 +5732,7 @@ withCommon(
     const issue = await resolveIssue(api, ref);
     let artifact;
     if (opts.folder !== void 0) {
-      if (!existsSync3(opts.folder) || !statSync(opts.folder).isDirectory()) {
+      if (!existsSync3(opts.folder) || !statSync2(opts.folder).isDirectory()) {
         die(`--folder needs a directory, got "${opts.folder}"`);
       }
       const files = walkFolder(opts.folder);
@@ -5538,7 +5744,7 @@ withCommon(
     } else if (opts.file !== void 0) {
       let bytes;
       try {
-        bytes = readFileSync4(opts.file);
+        bytes = readFileSync5(opts.file);
       } catch (err) {
         die(`cannot read ${opts.file}: ${err instanceof Error ? err.message : String(err)}`);
       }
@@ -5615,7 +5821,7 @@ withCommon(
       if (opts.out === void 0) {
         die(`artifact "${name2}" is a folder \u2014 pass --out <dir> to write its tree`);
       }
-      if (existsSync3(opts.out) && !statSync(opts.out).isDirectory()) {
+      if (existsSync3(opts.out) && !statSync2(opts.out).isDirectory()) {
         die(`--out for a folder must be a directory, and "${opts.out}" is a file`);
       }
       const files = version.files ?? [];
@@ -5638,7 +5844,7 @@ withCommon(
     const bytes = Buffer.from(content.bytes);
     if (opts.out !== void 0) {
       let target2 = opts.out;
-      if (existsSync3(target2) && statSync(target2).isDirectory()) {
+      if (existsSync3(target2) && statSync2(target2).isDirectory()) {
         target2 = join4(target2, version.filename ?? name2);
       }
       writeFileSync3(target2, bytes);
@@ -6457,7 +6663,7 @@ withList(
   });
 });
 withCommon(
-  runsCmd.command("show <id>").description("Show a run; --logs prints the captured log tail").option("--logs", "print the log tail")
+  runsCmd.command("show <id>").description("Show a run; --logs prints the captured log tail, --logs --full the whole log").option("--logs", "print the log tail").option("--full", "with --logs: print the complete log, not the 256 KB tail").option("--raw", "with --logs --full: print the unrendered harness stream instead")
 ).action(async (id, opts) => {
   const api = client(opts);
   const run = await api.getRun(id);
@@ -6486,8 +6692,24 @@ withCommon(
   if (run.error) console.log(`error: ${run.error}`);
   if (opts.logs) {
     console.log("");
+    if (opts.full || opts.raw) {
+      const res = await api.getRunLogFull(id, { raw: opts.raw });
+      const body = res.body;
+      if (!body) return;
+      const reader = body.getReader();
+      const decoder = new TextDecoder();
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value) process.stdout.write(decoder.decode(value, { stream: true }));
+      }
+      process.stdout.write(decoder.decode());
+      return;
+    }
     if (run.log_bytes_dropped > 0) {
-      console.log(`[${Math.round(run.log_bytes_dropped / 1024)} KB truncated from the head]`);
+      console.log(
+        `[${Math.round(run.log_bytes_dropped / 1024)} KB truncated from the head \u2014 ` + (run.log_expired ? "past its retention window; only this tail remains]" : `run \`tines runs show ${run.id} --logs --full\` for the complete ${Math.round(run.log_full_bytes / 1024)} KB log]`)
+      );
     }
     console.log(run.log || "(no log output captured)");
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tines",
-  "version": "0.0.82",
+  "version": "0.0.84",
   "description": "CLI for Tines, an orchestration layer for AI agents",
   "repository": {
     "type": "git",