@lesscap/baton-cli 0.1.3 → 0.2.1

package/dist/baton.mjs

@@ -578,6 +578,7 @@ var sessionsClient = (baseUrl) => {
     resume: (id) => request(u(`/sessions/${id}/resume`), { method: "POST" }),
     stop: (id) => request(u(`/sessions/${id}/stop`), { method: "POST" }),
     clear: (id) => request(u(`/sessions/${id}/clear`), { method: "POST" }),
+    abort: (id) => request(u(`/sessions/${id}/abort`), { method: "POST" }),
     rename: (id, name) => request(u(`/sessions/${id}/rename`), { method: "POST", body: { name } }),
     listByProject: (projectId) => request(u(`/projects/${projectId}/sessions`), { method: "GET" }),
     get: (id) => request(u(`/sessions/${id}`), { method: "GET" }),
@@ -1035,6 +1036,22 @@ var resolveSession = async (client, projectId, handle) => {
   throw new Error(`session "${handle}" not found in project ${projectId}`);
 };
 
+// src/commands/session/abort.ts
+var sessionAbortCommand = defineCommand({
+  meta: { name: "abort", description: "interrupt the in-flight turn (like Esc); keeps the session" },
+  args: {
+    session: { type: "positional", required: true, description: "session int id or name" },
+    project: { type: "string", description: "project id (overrides .baton.json)" },
+    ...common
+  },
+  run: async ({ args }) => {
+    const c = clientFor(args);
+    const handle = await resolveSession(c, resolveProjectId(args), args.session);
+    const s = await c.sessions.abort(handle.id);
+    console.log(renderOne(s, fmtSession, Boolean(args.json)));
+  }
+});
+
 // src/commands/session/clear.ts
 var sessionClearCommand = defineCommand({
   meta: { name: "clear", description: "reset the conversation context (keeps the session + worktree)" },
@@ -1637,34 +1654,15 @@ function getBaseURL() {
 }
 
 // src/session/runner.ts
-import { spawn, spawnSync } from "node:child_process";
+import { spawnSync } from "node:child_process";
+import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
 
 // src/session/runner/log.ts
-var claudeBin = () => process.env.BATON_CLAUDE_BIN ?? "claude";
-var buildClaudeArgs = (claudeSessionId, text, resuming) => [
-  "--print",
-  resuming ? "--resume" : "--session-id",
-  claudeSessionId,
-  "--output-format",
-  "stream-json",
-  "--verbose",
-  "--dangerously-skip-permissions",
-  text
-];
-var STDERR_TAIL_BYTES = 2048;
-var tailBuffer = (cap = STDERR_TAIL_BYTES) => {
-  let buf = "";
-  return {
-    append(chunk) {
-      buf = (buf + chunk).slice(-cap);
-    },
-    toString() {
-      return buf;
-    }
-  };
-};
 var maskedEnvKeys = (env) => env ? Object.keys(env).sort().join(", ") : "(none)";
-var previewText = (text, max = 80) => text.length > max ? `${text.slice(0, max)}\u2026` : text;
+
+// src/session/runner/sdk-env.ts
+var buildSdkEnv = (overlay) => overlay ? { ...process.env, ...overlay } : void 0;
+var claudeExecutable = () => process.env.BATON_CLAUDE_BIN;
 
 // src/session/runner/transcript.ts
 import { readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
@@ -1788,90 +1786,74 @@ var augmentPrompt = (text, relPaths, labels) => {
 ${text}` : header;
 };
 
-// src/session/runner/spawn.ts
-import { createInterface as createInterface2 } from "node:readline";
-var spawnClaude = async (config, worker2, text, resuming, spawnImpl, log, envOverlay) => {
-  const childEnv = envOverlay ? { ...process.env, ...envOverlay } : process.env;
-  const bin = claudeBin();
-  const args = buildClaudeArgs(config.agentSessionId, text, resuming);
-  log(`[spawn] ${bin} ${args.slice(0, -1).join(" ")} -- "${previewText(text)}"`);
-  log(`[spawn] cwd: ${config.worktreePath}`);
-  log(`[spawn] runtime env keys: ${maskedEnvKeys(envOverlay)}`);
-  let child;
-  try {
-    child = spawnImpl(bin, args, {
-      cwd: config.worktreePath,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: childEnv
-    });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    log(`[spawn] failed: ${message}`);
-    await worker2.emitEvent("turn_error", { message: `spawn failed: ${message}` });
-    return null;
-  }
-  if (!child.stdout) {
-    log("[spawn] no stdout from claude \u2014 aborting turn");
-    await worker2.emitEvent("turn_error", { message: "no stdout from claude" });
-    return null;
-  }
-  const tail = tailBuffer();
-  if (child.stderr) {
-    const errLines = createInterface2({ input: child.stderr });
-    void (async () => {
-      for await (const line of errLines) {
-        tail.append(`${line}
-`);
-        log(`[claude] ${line}`);
-      }
-    })();
-  }
-  return { child, tail };
+// src/session/runner/query.ts
+import "@anthropic-ai/claude-agent-sdk";
+var startQuery = (config, text, resuming, queryFn, abortController, log, envOverlay) => {
+  const env = buildSdkEnv(envOverlay);
+  const exe = claudeExecutable();
+  const options = {
+    cwd: config.worktreePath,
+    permissionMode: "bypassPermissions",
+    includePartialMessages: false,
+    abortController,
+    stderr: (line) => log(`[claude] ${line.trimEnd()}`),
+    ...resuming ? { resume: config.agentSessionId } : { sessionId: config.agentSessionId },
+    ...env ? { env } : {},
+    ...exe ? { pathToClaudeCodeExecutable: exe } : {}
+  };
+  return queryFn({ prompt: text, options });
 };
 
 // src/session/runner/stream.ts
-import { createInterface as createInterface3 } from "node:readline";
-var streamSdkEvents = async (stdout, worker2) => {
-  const rl = createInterface3({ input: stdout });
-  for await (const line of rl) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    let payload;
-    try {
-      payload = JSON.parse(trimmed);
-    } catch {
-      payload = { raw: trimmed };
-    }
-    await worker2.emitEvent("sdk_event", payload);
+var streamSdkEvents = async (messages, worker2) => {
+  let result = null;
+  for await (const message of messages) {
+    await worker2.emitEvent("sdk_event", message);
+    if (message.type === "result") result = toTurnResult(message);
   }
+  return result;
+};
+var toTurnResult = (message) => {
+  const rec = message;
+  const subtype = typeof rec.subtype === "string" ? rec.subtype : "unknown";
+  const isError = rec.is_error === true || subtype !== "success";
+  const resultText = typeof rec.result === "string" ? rec.result : "";
+  return { subtype, isError, resultText };
 };
 
 // src/session/runner/turn.ts
-var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var turnTimeoutMs = () => Number(process.env.BATON_TURN_TIMEOUT_MS) || 30 * 6e4;
-var DRAIN_GRACE_MS = 3e3;
-var waitExit = (child) => {
-  if (typeof child.exitCode === "number") return Promise.resolve(child.exitCode);
-  if (typeof child.signalCode === "string") return Promise.resolve(-1);
-  return new Promise((resolve) => child.once("exit", (code) => resolve(code ?? -1)));
-};
-var finalizeTurn = async (exitCode, tail, worker2, log) => {
-  log(`[exit] code=${exitCode}`);
-  const stderrTail = tail.toString();
-  if (exitCode !== 0) {
+var TIMEOUT = /* @__PURE__ */ Symbol("turn-timeout");
+var ABORTED = /* @__PURE__ */ Symbol("turn-aborted");
+var finalizeTurn = async (result, worker2, log) => {
+  if (!result) {
+    log("[exit] stream ended with no result");
+    await worker2.emitEvent("turn_error", { message: "claude produced no result" });
+    await worker2.emitEvent("turn_complete", {});
+    return -1;
+  }
+  log(`[exit] subtype=${result.subtype} isError=${result.isError}`);
+  if (result.isError) {
     await worker2.emitEvent("turn_error", {
-      message: `claude exited with code ${exitCode}`,
-      exitCode,
-      stderrTail
+      message: result.resultText || `claude result: ${result.subtype}`,
+      subtype: result.subtype
     });
   }
-  await worker2.emitEvent("turn_complete", {
-    exitCode,
-    ...stderrTail ? { stderrTail } : {}
+  await worker2.emitEvent("turn_complete", { subtype: result.subtype });
+  return result.isError ? 1 : 0;
+};
+var buildPrompt = async (config, rawText, attachments, log, fetchImpl) => {
+  if (attachments.length === 0) return rawText;
+  const relPaths = await materializeAttachments({
+    worktreePath: config.worktreePath,
+    serverBase: config.server,
+    attachments,
+    fetchImpl
   });
-  return exitCode;
+  log(`[attach] downloaded ${relPaths.length} file(s) \u2192 ${config.worktreePath}/attachments`);
+  return augmentPrompt(rawText, relPaths, labelAttachments(attachments));
 };
-var runTurn = async (config, worker2, msg, resuming, spawnImpl, log = (m) => console.log(m), envOverlay, fetchImpl) => {
+var runTurn = async (config, worker2, msg, resuming, queryFn, log = (m) => console.log(m), envOverlay, fetchImpl, externalSignal) => {
   await worker2.emitEvent("turn_start", { messageId: msg.id });
   const payload = msg.payload;
   const rawText = typeof payload?.text === "string" ? payload.text : "";
@@ -1880,61 +1862,58 @@ var runTurn = async (config, worker2, msg, resuming, spawnImpl, log = (m) => con
     await worker2.emitEvent("turn_error", { message: "user_message missing text and attachments" });
     return -1;
   }
-  let text = rawText;
-  if (attachments.length > 0) {
-    try {
-      const relPaths = await materializeAttachments({
-        worktreePath: config.worktreePath,
-        serverBase: config.server,
-        attachments,
-        fetchImpl
-      });
-      log(`[attach] downloaded ${relPaths.length} file(s) \u2192 ${config.worktreePath}/attachments`);
-      text = augmentPrompt(rawText, relPaths, labelAttachments(attachments));
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      await worker2.emitEvent("turn_error", { message: `attachment download failed: ${message}` });
-      return -1;
-    }
+  let text;
+  try {
+    text = await buildPrompt(config, rawText, attachments, log, fetchImpl);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    await worker2.emitEvent("turn_error", { message: `attachment download failed: ${message}` });
+    return -1;
   }
-  const result = await spawnClaude(config, worker2, text, resuming, spawnImpl, log, envOverlay);
-  if (!result) return -1;
-  const { child, tail } = result;
-  const stdout = child.stdout;
-  const exited = waitExit(child);
-  let timedOut = false;
+  const abort = new AbortController();
   const ceiling = turnTimeoutMs();
-  const watchdog = setTimeout(() => {
-    timedOut = true;
-    log(`[watchdog] turn exceeded ${ceiling}ms \u2014 killing claude`);
-    child.kill("SIGKILL");
-  }, ceiling);
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(TIMEOUT), ceiling);
+  });
+  const interrupted = new Promise((resolve) => {
+    if (externalSignal?.aborted) resolve(ABORTED);
+    else externalSignal?.addEventListener("abort", () => resolve(ABORTED), { once: true });
+  });
   try {
-    const streaming = streamSdkEvents(stdout, worker2);
-    void streaming.catch(() => {
+    const messages = startQuery(config, text, resuming, queryFn, abort, log, envOverlay);
+    const consume = streamSdkEvents(messages, worker2);
+    void consume.catch(() => {
     });
-    await Promise.race([streaming, exited.then(() => delay(DRAIN_GRACE_MS))]);
-    stdout.destroy();
-    const exitCode = await exited;
-    if (timedOut) {
-      await worker2.emitEvent("turn_error", {
-        message: `turn exceeded ${ceiling}ms \u2014 claude killed`,
-        stderrTail: tail.toString()
-      });
+    const outcome = await Promise.race([consume, timeout, interrupted]);
+    if (outcome === ABORTED) {
+      log("[abort] interrupted by user");
+      abort.abort();
+      await worker2.emitEvent("turn_error", { message: "interrupted by user" });
+      await worker2.emitEvent("turn_complete", {});
+      return -1;
     }
-    return await finalizeTurn(exitCode, tail, worker2, log);
+    if (outcome === TIMEOUT) {
+      log(`[watchdog] turn exceeded ${ceiling}ms \u2014 aborting claude`);
+      abort.abort();
+      await worker2.emitEvent("turn_error", { message: `turn exceeded ${ceiling}ms \u2014 claude aborted` });
+      await worker2.emitEvent("turn_complete", {});
+      return -1;
+    }
+    return await finalizeTurn(outcome, worker2, log);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     log(`[run] ${message}`);
-    await worker2.emitEvent("turn_error", { message, stderrTail: tail.toString() });
+    await worker2.emitEvent("turn_error", { message });
+    await worker2.emitEvent("turn_complete", {});
     return -1;
   } finally {
-    clearTimeout(watchdog);
+    clearTimeout(timer);
   }
 };
 
 // src/session/runner.ts
-var subscribeStream = (url, ESCtor, seen, log, onUserMessage, onReady) => {
+var subscribeStream = (url, ESCtor, seen, log, onUserMessage, onInterrupt, onReady) => {
   const es = new ESCtor(url);
   es.onopen = onReady;
   es.onmessage = (e) => {
@@ -1943,6 +1922,8 @@ var subscribeStream = (url, ESCtor, seen, log, onUserMessage, onReady) => {
       if (seen.has(ev.sequence)) return;
       seen.add(ev.sequence);
       if (ev.type === "user_message") onUserMessage(ev);
+      else if (ev.type === "system" && ev.payload?.action === "interrupt")
+        onInterrupt();
     } catch {
     }
   };
@@ -1964,9 +1945,9 @@ var restoreTty = () => {
 };
 var runDaemon = async (config, deps, signal) => {
   const log = deps.log ?? ((m) => console.log(`[#${config.sessionId} ${config.name}] ${m}`));
-  const sp = deps.spawnImpl ?? spawn;
+  const qf = deps.queryFn ?? query2;
   const ESCtor = deps.eventSourceImpl ?? EventSource;
-  log(`bin: ${claudeBin()}  cwd: ${config.worktreePath}`);
+  log(`bin: ${claudeExecutable() ?? "(sdk bundled)"}  cwd: ${config.worktreePath}`);
   log(`runtime env keys: ${maskedEnvKeys(deps.env)}`);
   const state = {
     firstSpawnDone: findTranscriptPath(config.agentSessionId) !== null,
@@ -1975,6 +1956,7 @@ var runDaemon = async (config, deps, signal) => {
   const pendingQueue = [];
   let busy = false;
   let lastActivity = Date.now();
+  let currentTurn;
   const drain = async () => {
     if (busy) return;
     busy = true;
@@ -1984,16 +1966,20 @@ var runDaemon = async (config, deps, signal) => {
         if (!msg) break;
         const resuming = state.firstSpawnDone;
         log(`\u25B6 msg #${msg.sequence} (${resuming ? "resume" : "first"})`);
+        const turnAbort = new AbortController();
+        currentTurn = turnAbort;
         const code = await runTurn(
           config,
           deps.worker,
           msg,
           resuming,
-          sp,
+          qf,
           log,
           deps.env,
-          deps.fetchImpl
+          deps.fetchImpl,
+          turnAbort.signal
         );
+        currentTurn = void 0;
         state.firstSpawnDone = true;
         lastActivity = Date.now();
         log(`\u2714 msg #${msg.sequence}${code === 0 ? "" : ` (exit ${code})`}`);
@@ -2014,6 +2000,13 @@ var runDaemon = async (config, deps, signal) => {
       pendingQueue.push(ev);
       void drain();
     },
+    () => {
+      lastActivity = Date.now();
+      if (currentTurn) {
+        log("interrupt \u2014 aborting current turn");
+        currentTurn.abort();
+      }
+    },
     // Report active only now that we're subscribed — before this, a message
     // sent right after spawn would be missed (no replay on the live stream).
     () => {
@@ -2194,6 +2187,7 @@ var session = defineCommand({
     resume: sessionResumeCommand,
     stop: sessionStopCommand,
     clear: sessionClearCommand,
+    abort: sessionAbortCommand,
     rename: sessionRenameCommand,
     rm: sessionRmCommand,
     send: sessionSendCommand,
@@ -2345,11 +2339,12 @@ var task = defineCommand({
 import { hostname as osHostname } from "node:os";
 
 // src/worker/daemon.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { existsSync as existsSync4 } from "node:fs";
 import { dirname as dirname2, join as join5 } from "node:path";
 import { fileURLToPath } from "node:url";
+import { query as query3 } from "@anthropic-ai/claude-agent-sdk";
 
 // src/session/runner/title.ts
 var clip = (s, max) => s.length > max ? s.slice(0, max) : s;
@@ -2357,7 +2352,7 @@ var isDeclined = (title) => title.replace(/[^a-z]/gi, "").toUpperCase() === "NON
 var sanitizeTitle = (raw) => raw.replace(/[\r\n]+/g, " ").replace(/["'`]/g, "").replace(/^\s*(title|session)\s*[:-]\s*/i, "").replace(/\s+/g, " ").trim().slice(0, 40).trim();
 var TITLE_TIMEOUT_MS = 3e4;
 var generateTitle = async (input) => {
-  const { worktreePath, userText, assistantText, spawnImpl } = input;
+  const { worktreePath, userText, assistantText, queryFn } = input;
   if (`${userText}${assistantText}`.trim().length < 4) return null;
   const exchange = [
     `User: ${clip(userText, 800)}`,
@@ -2365,44 +2360,31 @@ var generateTitle = async (input) => {
   ].filter(Boolean).join("\n");
   const prompt = `Reply with ONLY a 2-5 word title (no quotes, no punctuation) summarizing this coding session. If it is too short or generic to title meaningfully, reply with exactly NONE:
 ${exchange}`;
-  const out = await new Promise((resolve) => {
-    let buf = "";
-    let done = false;
-    const finish = (s) => {
-      if (!done) {
-        done = true;
-        resolve(s);
-      }
-    };
-    let child;
-    try {
-      child = spawnImpl(claudeBin(), ["--print", "--dangerously-skip-permissions", prompt], {
+  const exe = claudeExecutable();
+  const abort = new AbortController();
+  const timer = setTimeout(() => abort.abort(), TITLE_TIMEOUT_MS);
+  let out = "";
+  try {
+    const messages = queryFn({
+      prompt,
+      options: {
         cwd: worktreePath,
-        stdio: ["ignore", "pipe", "pipe"],
-        env: process.env
-      });
-    } catch {
-      return finish("");
-    }
-    const timer = setTimeout(() => {
-      try {
-        child.kill();
-      } catch {
+        permissionMode: "bypassPermissions",
+        allowedTools: [],
+        includePartialMessages: false,
+        abortController: abort,
+        ...exe ? { pathToClaudeCodeExecutable: exe } : {}
       }
-      finish("");
-    }, TITLE_TIMEOUT_MS);
-    child.stdout?.on("data", (d) => {
-      buf += String(d);
-    });
-    child.on("exit", () => {
-      clearTimeout(timer);
-      finish(buf);
-    });
-    child.on("error", () => {
-      clearTimeout(timer);
-      finish("");
     });
-  });
+    for await (const m of messages) {
+      if (m.type === "result" && typeof m.result === "string")
+        out = m.result;
+    }
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
   const title = sanitizeTitle(out);
   return !title || isDeclined(title) ? null : title;
 };
@@ -2468,7 +2450,7 @@ var runWorkerDaemon = async (cfg, client, signal) => {
   };
   const spawnChild = (sessionId, worktreePath) => {
     if (children.has(sessionId)) return;
-    const child = spawn2(process.execPath, [binPath(), "session", "run", String(sessionId)], {
+    const child = spawn(process.execPath, [binPath(), "session", "run", String(sessionId)], {
       detached: true,
       stdio: "inherit",
       env: {
@@ -2528,7 +2510,7 @@ var runWorkerDaemon = async (cfg, client, signal) => {
       worktreePath,
       userText: exchange.userText,
       assistantText: exchange.assistantText,
-      spawnImpl: spawn2
+      queryFn: query3
     });
     if (!title) return log(`title #${sessionId}: not enough to title yet, skipping`);
     await client.sessions.setName(sessionId, title, cfg.apiToken);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lesscap/baton-cli",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "type": "module",
   "description": "baton CLI — register/run a worker, manage projects/requirements/tasks/sessions",
   "bin": {
@@ -11,7 +11,7 @@
   ],
   "scripts": {
     "baton": "tsx src/index.ts",
-    "build": "esbuild src/index.ts --bundle --platform=node --format=esm --packages=bundle --banner:js=\"#!/usr/bin/env node\" --outfile=dist/baton.mjs && chmod +x dist/baton.mjs",
+    "build": "esbuild src/index.ts --bundle --platform=node --format=esm --packages=bundle --external:@anthropic-ai/claude-agent-sdk --banner:js=\"#!/usr/bin/env node\" --outfile=dist/baton.mjs && chmod +x dist/baton.mjs",
     "prepublishOnly": "pnpm build",
     "typecheck": "tsc --noEmit -p tsconfig.json",
     "test": "tsx --test 'src/**/*.test.ts'"
@@ -24,5 +24,8 @@
     "eventsource": "^4.1.0",
     "tsx": "^4.22.4",
     "typescript": "^6.0.3"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.161"
   }
 }