@itsaplan/runner 0.3.0 → 0.5.0

package/dist/cli.js

@@ -25,11 +25,13 @@ class AnswerStream {
   sawPartialText = false;
   sawAnyText = false;
   sending = Promise.resolve();
+  usage;
   constructor(format, threadId, runId, send) {
     this.format = format;
     this.threadId = threadId;
     this.runId = runId;
     this.send = send;
+    this.usage = new UsageReader(format);
     this.messageId = `msg-${runId}`;
     this.queued.push({ type: "RUN_STARTED", threadId, runId });
   }
@@ -48,6 +50,9 @@ class AnswerStream {
   startedSession() {
     return this.sessionId;
   }
+  contextUsage() {
+    return this.usage.value();
+  }
   async flush() {
     const sending = this.sending.catch(() => {}).then(() => this.sendQueued());
     this.sending = sending.catch(() => {});
@@ -127,6 +132,7 @@ class AnswerStream {
     }
     if (!parsed || typeof parsed !== "object")
       return;
+    this.usage.readLine(parsed);
     switch (this.format) {
       case "claude-stream-json":
         this.readClaudeLine(parsed);
@@ -275,7 +281,9 @@ class AnswerStream {
     }
   }
   readPartial(event) {
-    if (event?.type !== "content_block_delta")
+    if (!event)
+      return;
+    if (event.type !== "content_block_delta")
       return;
     if (event.delta?.type === "text_delta" && event.delta.text) {
       this.sawPartialText = true;
@@ -313,6 +321,108 @@ class AnswerStream {
     });
   }
 }
+
+class UsageReader {
+  format;
+  last = null;
+  buffered = "";
+  constructor(format) {
+    this.format = format;
+  }
+  write(chunk) {
+    if (this.format === "text")
+      return;
+    this.buffered += chunk;
+    const lines = this.buffered.split(`
+`);
+    this.buffered = lines.pop() ?? "";
+    for (const line of lines)
+      this.readText(line);
+  }
+  end() {
+    if (!this.buffered)
+      return;
+    this.readText(this.buffered);
+    this.buffered = "";
+  }
+  value() {
+    if (this.format === "copilot-json")
+      return null;
+    return this.last ?? undefined;
+  }
+  readText(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      return;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === "object")
+        this.readLine(parsed);
+    } catch {}
+  }
+  readLine(parsed) {
+    switch (this.format) {
+      case "claude-stream-json":
+        this.readClaude(parsed);
+        return;
+      case "codex-jsonl":
+        this.readCodex(parsed);
+        return;
+      case "opencode-json":
+        this.readOpencode(parsed);
+        return;
+      case "antigravity-stream-json":
+        this.readAntigravity(parsed);
+        return;
+    }
+  }
+  readClaude(message) {
+    const event = message.type === "stream_event" ? message.event : undefined;
+    if (!event)
+      return;
+    const usage = event.type === "message_start" ? event.message?.usage : event.usage;
+    if (!usage)
+      return;
+    const read = (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
+    const written = usage.output_tokens ?? 0;
+    if (event.type === "message_start") {
+      this.last = { inputTokens: read, outputTokens: written };
+      return;
+    }
+    if (event.type !== "message_delta")
+      return;
+    this.last = { inputTokens: read || (this.last?.inputTokens ?? 0), outputTokens: written };
+  }
+  readCodex(message) {
+    if (message.type !== "turn.completed" || !message.usage)
+      return;
+    this.last = {
+      inputTokens: message.usage.input_tokens ?? 0,
+      outputTokens: message.usage.output_tokens ?? 0
+    };
+  }
+  readOpencode(message) {
+    const tokens = message.part?.type === "step-finish" ? message.part.tokens : undefined;
+    if (!tokens)
+      return;
+    this.last = {
+      inputTokens: (tokens.input ?? 0) + (tokens.cache?.read ?? 0) + (tokens.cache?.write ?? 0),
+      outputTokens: (tokens.output ?? 0) + (tokens.reasoning ?? 0)
+    };
+  }
+  readAntigravity(message) {
+    const step = message.step_update;
+    if (!step)
+      return;
+    const usage = step.usage ?? message.usage;
+    if (!usage)
+      return;
+    this.last = {
+      inputTokens: (usage.input_tokens ?? 0) + (usage.cache_read_tokens ?? 0),
+      outputTokens: (usage.output_tokens ?? 0) + (usage.thinking_tokens ?? 0)
+    };
+  }
+}
 function tail(text, limit) {
   return text.length <= limit ? text : `…${text.slice(-limit)}`;
 }
@@ -620,7 +730,7 @@ function stdinText(preset, task) {
     return "";
   return presetPrompt(preset, task.systemPrompt, task.prompt);
 }
-async function execute(config, task, onData) {
+async function execute(config, task, opts = {}) {
   const preset = presetOf(config);
   const [bin, args] = spawnArgs(config, preset, task);
   const child = spawn(bin, args, {
@@ -628,19 +738,23 @@ async function execute(config, task, onData) {
     env: childEnv(config, task),
     detached: true
   });
+  const kill = () => {
+    if (child.pid !== undefined)
+      killGroup(child.pid);
+  };
   let timedOut = false;
   const timer = setTimeout(() => {
     timedOut = true;
-    if (child.pid !== undefined)
-      killGroup(child.pid);
+    kill();
   }, config.timeoutMs);
+  opts.signal?.addEventListener("abort", kill, { once: true });
   let stdout = "";
   let stderr = "";
   child.stdout.setEncoding("utf8");
   child.stderr.setEncoding("utf8");
   child.stdout.on("data", (chunk) => {
     stdout = tail2(stdout + chunk, OUTPUT_LIMIT);
-    onData?.(chunk);
+    opts.onData?.(chunk);
   });
   child.stderr.on("data", (chunk) => {
     stderr = tail2(stderr + chunk, ERROR_LIMIT);
@@ -657,6 +771,7 @@ async function execute(config, task, onData) {
     ({ code, signal } = await exited);
   } finally {
     clearTimeout(timer);
+    opts.signal?.removeEventListener("abort", kill);
   }
   const output = stdout.trim();
   if (code === 0)
@@ -672,13 +787,14 @@ async function execute(config, task, onData) {
 
 // src/chat.ts
 var FLUSH_MS = 500;
-async function answer(config, client, message) {
+async function answer(config, client, message, stop) {
   let reported = message.sessionId !== null;
-  const stream = new AnswerStream(config.outputFormat, message.threadId, String(message.id), (events) => {
+  const stream = new AnswerStream(config.outputFormat, message.threadId, String(message.id), async (events) => {
     const started = reported ? undefined : stream.startedSession() ?? undefined;
     if (started)
       reported = true;
-    return client.chatEvents(message.id, events, started);
+    if (await client.chatEvents(message.id, events, started))
+      stop.abort();
   });
   const flushing = setInterval(() => {
     stream.flush().catch(() => {});
@@ -694,15 +810,17 @@ async function answer(config, client, message) {
       ITSAPLAN_MESSAGE_ID: String(message.id),
       ITSAPLAN_SESSION_ID: message.sessionId ?? ""
     }
-  }, (chunk) => stream.write(chunk)).finally(() => clearInterval(flushing));
+  }, { onData: (chunk) => stream.write(chunk), signal: stop.signal }).finally(() => clearInterval(flushing));
+  if (stop.signal.aborted)
+    return;
   if (outcome.status === "success") {
     await stream.finish(outcome.output);
-    await client.chatResult(message.id, { status: "success" });
+    await client.chatResult(message.id, { status: "success", usage: stream.contextUsage() });
     return;
   }
   const error = outcome.error ?? "The command failed";
   await stream.fail(error, outcome.output);
-  await client.chatResult(message.id, { status: "failed", error });
+  await client.chatResult(message.id, { status: "failed", error, usage: stream.contextUsage() });
 }
 
 // src/client.ts
@@ -754,18 +872,23 @@ class Client {
     return body.message;
   }
   async chatEvents(messageId, events, sessionId) {
-    await this.post(`/agent-chats/${messageId}/events`, {
+    const res = await this.post(`/agent-chats/${messageId}/events`, {
       events,
       ...sessionId && { sessionId }
     });
+    return canceled(res);
   }
   async chatHeartbeat(messageId) {
-    await this.post(`/agent-chats/${messageId}/heartbeat`);
+    return canceled(await this.post(`/agent-chats/${messageId}/heartbeat`));
   }
   async chatResult(messageId, result) {
     await this.post(`/agent-chats/${messageId}/result`, result);
   }
 }
+async function canceled(res) {
+  const body = await res.json().catch(() => ({}));
+  return body.canceled === true;
+}
 
 // src/cli.ts
 var HEARTBEAT_MS = 60000;
@@ -803,8 +926,10 @@ async function handle(config, client, log2, run) {
   const label = run.issueIdentifier ?? `run ${run.id}`;
   log2(`${label}: started (${run.trigger})`);
   try {
-    const outcome = await withHeartbeat(log2, () => client.heartbeat(run.id), execute(config, taskOf(run)));
-    await client.report(run.id, outcome);
+    const usage = new UsageReader(config.outputFormat);
+    const outcome = await withHeartbeat(log2, () => client.heartbeat(run.id), execute(config, taskOf(run), { onData: (chunk) => usage.write(chunk) }));
+    usage.end();
+    await client.report(run.id, { ...outcome, usage: usage.value() });
     log2(`${label}: ${outcome.status}${outcome.error ? ` — ${outcome.error}` : ""}`);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -814,14 +939,21 @@ async function handle(config, client, log2, run) {
 }
 async function handleChat(config, client, log2, message) {
   log2(`chat ${message.id}: answering`);
+  const stop = new AbortController;
   try {
-    await withHeartbeat(log2, () => client.chatHeartbeat(message.id), answer(config, client, message));
-    log2(`chat ${message.id}: answered`);
+    await withHeartbeat(log2, async () => {
+      if (await client.chatHeartbeat(message.id))
+        stop.abort();
+    }, answer(config, client, message, stop));
   } catch (err) {
-    const text = err instanceof Error ? err.message : String(err);
-    log2(`chat ${message.id}: runner error — ${text}`);
-    await client.chatResult(message.id, { status: "failed", error: text }).catch(() => {});
+    if (!stop.signal.aborted) {
+      const text = err instanceof Error ? err.message : String(err);
+      log2(`chat ${message.id}: runner error — ${text}`);
+      await client.chatResult(message.id, { status: "failed", error: text }).catch(() => {});
+      return;
+    }
   }
+  log2(`chat ${message.id}: ${stop.signal.aborted ? "stopped" : "answered"}`);
 }
 async function drain(state, log2, concurrency, take, run, onEmpty) {
   const active = new Set;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itsaplan/runner",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Runs an Itsaplan external agent's queued tasks and answers its chat on your own machine",
   "keywords": [
     "itsaplan",