@groupchatai/claude-runner 0.2.3 → 0.4.0

package/dist/index.js

@@ -240,11 +240,15 @@ var ALLOWED_TOOLS = [
   "TodoWrite",
   "NotebookEdit"
 ];
-function spawnClaudeCode(prompt, config, runOptions) {
+function spawnClaudeCode(prompt, config, runOptions, resumeSessionId) {
   const format = config.verbose ? "stream-json" : "json";
-  const args = [
-    "-p",
-    prompt,
+  const args = [];
+  if (resumeSessionId) {
+    args.push("--resume", resumeSessionId, "-p", prompt);
+  } else {
+    args.push("-p", prompt);
+  }
+  args.push(
     "--output-format",
     format,
     "--verbose",
@@ -252,7 +256,7 @@ function spawnClaudeCode(prompt, config, runOptions) {
     "default",
     "--allowedTools",
     ...ALLOWED_TOOLS
-  ];
+  );
   const model = runOptions?.model ?? config.model;
   if (model) {
     args.push("--model", model);
@@ -263,61 +267,97 @@ function spawnClaudeCode(prompt, config, runOptions) {
     env: { ...process.env }
   });
   const pid = child.pid ?? 0;
-  const output = new Promise(
-    (resolve, reject) => {
-      const chunks = [];
-      const errChunks = [];
-      let lineBuf = "";
-      let lastResultJson = "";
-      child.stdout?.on("data", (data) => {
-        chunks.push(data);
-        if (!config.verbose) return;
-        lineBuf += data.toString("utf-8");
-        const lines = lineBuf.split("\n");
-        lineBuf = lines.pop() ?? "";
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed) continue;
-          try {
-            const event = JSON.parse(trimmed);
-            if (event.type === "result") lastResultJson = trimmed;
+  const output = new Promise((resolve, reject) => {
+    const chunks = [];
+    const errChunks = [];
+    let lineBuf = "";
+    let lastResultJson = "";
+    let capturedSessionId;
+    let capturedPrUrl;
+    function checkEventForPrUrl(event) {
+      if (capturedPrUrl) return;
+      const texts = [];
+      if (event.message?.content) {
+        for (const block of event.message.content) {
+          if (block.text) texts.push(block.text);
+        }
+      }
+      if (event.content_block?.text) texts.push(event.content_block.text);
+      if (typeof event.result === "string") texts.push(event.result);
+      const combined = texts.join("\n");
+      const match = combined.match(GITHUB_PR_URL_RE);
+      if (match) capturedPrUrl = match[match.length - 1];
+    }
+    child.stdout?.on("data", (data) => {
+      chunks.push(data);
+      const text = data.toString("utf-8");
+      lineBuf += text;
+      const lines = lineBuf.split("\n");
+      lineBuf = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const event = JSON.parse(trimmed);
+          if (event.type === "system" && event.subtype === "init" && event.session_id) {
+            capturedSessionId = event.session_id;
+          }
+          if (event.type === "result") lastResultJson = trimmed;
+          checkEventForPrUrl(event);
+          if (config.verbose) {
             const formatted = formatStreamEvent(event, pid);
             if (formatted) console.log(formatted);
-          } catch {
+          }
+        } catch {
+          if (config.verbose) {
             console.log(`${pidTag(pid)} ${C.dim}${trimmed}${C.reset}`);
           }
         }
-      });
-      child.stderr?.on("data", (data) => {
-        errChunks.push(data);
-        if (config.verbose) {
-          const text = data.toString("utf-8").trimEnd();
-          if (text) console.error(`${pidTag(pid)} ${C.dim}${text}${C.reset}`);
-        }
-      });
-      child.on("error", (err) => reject(new Error(`Failed to spawn claude: ${err.message}`)));
-      child.on("close", (code) => {
-        if (config.verbose && lineBuf.trim()) {
-          try {
-            const event = JSON.parse(lineBuf.trim());
-            if (event.type === "result") lastResultJson = lineBuf.trim();
+      }
+    });
+    child.stderr?.on("data", (data) => {
+      errChunks.push(data);
+      if (config.verbose) {
+        const text = data.toString("utf-8").trimEnd();
+        if (text) console.error(`${pidTag(pid)} ${C.dim}${text}${C.reset}`);
+      }
+    });
+    child.on("error", (err) => reject(new Error(`Failed to spawn claude: ${err.message}`)));
+    child.on("close", (code) => {
+      if (lineBuf.trim()) {
+        try {
+          const event = JSON.parse(lineBuf.trim());
+          if (event.type === "system" && event.subtype === "init" && event.session_id) {
+            capturedSessionId = event.session_id;
+          }
+          if (event.type === "result") lastResultJson = lineBuf.trim();
+          checkEventForPrUrl(event);
+          if (config.verbose) {
             const formatted = formatStreamEvent(event, pid);
             if (formatted) console.log(formatted);
-          } catch {
+          }
+        } catch {
+          if (config.verbose) {
             console.log(`${pidTag(pid)} ${C.dim}${lineBuf.trim()}${C.reset}`);
           }
         }
-        const rawOutput = Buffer.concat(chunks).toString("utf-8");
-        const stdout = config.verbose ? lastResultJson || rawOutput : rawOutput;
-        const stderr = Buffer.concat(errChunks).toString("utf-8");
-        if (code !== 0 && stdout.trim().length === 0) {
-          reject(new Error(`claude exited with code ${code}: ${stderr}`));
-        } else {
-          resolve({ stdout, rawOutput, exitCode: code ?? 0 });
-        }
-      });
-    }
-  );
+      }
+      const rawOutput = Buffer.concat(chunks).toString("utf-8");
+      const stdout = config.verbose ? lastResultJson || rawOutput : rawOutput;
+      const stderr = Buffer.concat(errChunks).toString("utf-8");
+      if (code !== 0 && stdout.trim().length === 0) {
+        reject(new Error(`claude exited with code ${code}: ${stderr}`));
+      } else {
+        resolve({
+          stdout,
+          rawOutput,
+          exitCode: code ?? 0,
+          sessionId: capturedSessionId,
+          streamPrUrl: capturedPrUrl
+        });
+      }
+    });
+  });
   return { process: child, output };
 }
 function findResultEvent(stdout) {
@@ -404,8 +444,11 @@ function runShellCommand(cmd, args, cwd) {
     });
   });
 }
+var sessionCache = /* @__PURE__ */ new Map();
+var runCounter = 0;
 async function processRun(client, run, config) {
-  const runTag = `  ${C.pid}[${run.id.slice(-8)}]${C.reset}`;
+  const runNum = ++runCounter;
+  const runTag = `  ${C.pid}[${runNum}]${C.reset}`;
   const log = (msg) => console.log(`${runTag} ${msg}`);
   const logGreen = (msg) => console.log(`${runTag} ${C.green}${msg}${C.reset}`);
   const detail = await client.getRunDetail(run.id);
@@ -446,14 +489,41 @@ async function processRun(client, run, config) {
       });
       await new Promise((resolve) => git.on("close", () => resolve()));
     }
+    const cachedSessionId = sessionCache.get(run.taskId);
+    const isFollowUp = cachedSessionId !== void 0;
+    const effectivePrompt = isFollowUp ? detail.prompt : prompt;
+    const resumeSession = isFollowUp ? cachedSessionId : void 0;
     if (config.verbose) {
-      log(`\u{1F4DD} Prompt (${prompt.length} chars)`);
+      if (isFollowUp) {
+        log(`\u{1F504} Resuming session ${cachedSessionId.slice(0, 12)}\u2026`);
+      }
+      log(`\u{1F4DD} Prompt (${effectivePrompt.length} chars)`);
       if (effectiveModel) log(`\u{1F9E0} Model: ${effectiveModel}`);
     }
-    const { process: child, output } = spawnClaudeCode(prompt, config, runOptions);
-    log(`\u{1F916} Claude Code spawned (pid ${child.pid})`);
-    const { stdout, rawOutput, exitCode } = await output;
-    const pullRequestUrl = await detectPullRequestUrl(config.workDir) ?? extractPullRequestUrlFromOutput(stdout) ?? extractPullRequestUrlFromOutput(rawOutput);
+    const { process: child, output } = spawnClaudeCode(
+      effectivePrompt,
+      config,
+      runOptions,
+      resumeSession
+    );
+    log(`\u{1F916} Claude Code spawned (pid ${child.pid})${isFollowUp ? " (follow-up)" : ""}`);
+    let { stdout, rawOutput, exitCode, sessionId, streamPrUrl } = await output;
+    if (exitCode !== 0 && isFollowUp) {
+      log(`\u26A0  Session resume failed, retrying with fresh session\u2026`);
+      sessionCache.delete(run.taskId);
+      const retry = spawnClaudeCode(prompt, config, runOptions);
+      log(`\u{1F916} Claude Code spawned (pid ${retry.process.pid}) (fresh)`);
+      const retryResult = await retry.output;
+      stdout = retryResult.stdout;
+      rawOutput = retryResult.rawOutput;
+      exitCode = retryResult.exitCode;
+      sessionId = retryResult.sessionId;
+      streamPrUrl = retryResult.streamPrUrl;
+    }
+    if (sessionId) {
+      sessionCache.set(run.taskId, sessionId);
+    }
+    const pullRequestUrl = streamPrUrl ?? await detectPullRequestUrl(config.workDir) ?? extractPullRequestUrlFromOutput(stdout) ?? extractPullRequestUrlFromOutput(rawOutput);
     if (exitCode !== 0) {
       const errorMsg = `Claude Code exited with code ${exitCode}:
 \`\`\`
@@ -570,23 +640,89 @@ function parseArgs() {
 async function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function handlePendingRuns(runs, activeRuns, client, config) {
+var TaskScheduler = class {
+  slots = /* @__PURE__ */ new Map();
+  processing = /* @__PURE__ */ new Set();
+  get activeTaskCount() {
+    return this.slots.size;
+  }
+  isRunActive(runId) {
+    return this.processing.has(runId);
+  }
+  hasActiveTask(taskId) {
+    return this.slots.has(taskId);
+  }
+  tryStart(run, maxConcurrent) {
+    if (this.processing.has(run.id)) return "at_limit";
+    const existingSlot = this.slots.get(run.taskId);
+    if (existingSlot) {
+      if (!existingSlot.queue.some((q) => q.id === run.id)) {
+        existingSlot.queue.push(run);
+      }
+      return "queued";
+    }
+    if (this.slots.size >= maxConcurrent) {
+      return "at_limit";
+    }
+    this.slots.set(run.taskId, { activeRunId: run.id, queue: [] });
+    this.processing.add(run.id);
+    return "start";
+  }
+  complete(run) {
+    this.processing.delete(run.id);
+    const slot = this.slots.get(run.taskId);
+    if (!slot) return void 0;
+    const next = slot.queue.shift();
+    if (next) {
+      slot.activeRunId = next.id;
+      this.processing.add(next.id);
+      return next;
+    }
+    this.slots.delete(run.taskId);
+    return void 0;
+  }
+  isEmpty() {
+    return this.slots.size === 0;
+  }
+};
+function handlePendingRuns(runs, scheduler, client, config) {
   if (runs.length > 0 && config.verbose) {
     console.log(`\u{1F4EC} ${runs.length} pending run(s)`);
   }
   for (const run of runs) {
-    if (activeRuns.has(run.id)) continue;
-    if (activeRuns.size >= config.maxConcurrent) {
+    const result = scheduler.tryStart(run, config.maxConcurrent);
+    if (result === "at_limit") {
       if (config.verbose) {
-        console.log(`\u23F8  At concurrency limit (${config.maxConcurrent}), waiting\u2026`);
+        console.log(`\u23F8  At concurrency limit (${config.maxConcurrent} tasks), waiting\u2026`);
       }
       break;
     }
-    activeRuns.add(run.id);
-    processRun(client, run, config).catch((err) => console.error(`Unhandled error processing run ${run.id}:`, err)).finally(() => activeRuns.delete(run.id));
+    if (result === "queued") {
+      if (config.verbose) {
+        console.log(`  ${C.dim}Queued follow-up for active task${C.reset}`);
+      }
+      continue;
+    }
+    processRunWithDrain(client, run, scheduler, config).catch(
+      (err) => console.error(`Unhandled error processing run ${run.id}:`, err)
+    );
+  }
+}
+async function processRunWithDrain(client, run, scheduler, config) {
+  let current = run;
+  while (current) {
+    try {
+      await processRun(client, current, config);
+    } catch (err) {
+      console.error(`Unhandled error processing run ${current.id}:`, err);
+    }
+    current = scheduler.complete(current);
+    if (current) {
+      console.log(`  \u23ED  Processing queued follow-up\u2026`);
+    }
   }
 }
-async function runWithWebSocket(client, config, activeRuns) {
+async function runWithWebSocket(client, config, scheduler) {
   let ConvexClient;
   let anyApi;
   try {
@@ -595,7 +731,7 @@ async function runWithWebSocket(client, config, activeRuns) {
   } catch {
     console.warn("\u26A0  convex package not found \u2014 falling back to HTTP polling.");
     console.warn("   Install convex for WebSocket mode: npm i convex\n");
-    await runWithPolling(client, config, activeRuns);
+    await runWithPolling(client, config, scheduler);
     return;
   }
   const convex = new ConvexClient(config.convexUrl);
@@ -605,7 +741,7 @@ async function runWithWebSocket(client, config, activeRuns) {
     { token: config.token },
     (runs) => {
       if (!runs || runs.length === 0) return;
-      handlePendingRuns(runs, activeRuns, client, config);
+      handlePendingRuns(runs, scheduler, client, config);
     }
   );
   await new Promise((resolve) => {
@@ -618,7 +754,7 @@ async function runWithWebSocket(client, config, activeRuns) {
     process.on("SIGTERM", shutdown);
   });
 }
-async function runWithPolling(client, config, activeRuns) {
+async function runWithPolling(client, config, scheduler) {
   console.log(`\u{1F4E1} Polling every ${config.pollInterval}ms \u2014 listening for tasks\u2026
 `);
   let running = true;
@@ -631,17 +767,17 @@ async function runWithPolling(client, config, activeRuns) {
   if (config.once) {
     try {
       const pending = await client.listPendingRuns();
-      handlePendingRuns(pending, activeRuns, client, config);
+      handlePendingRuns(pending, scheduler, client, config);
     } catch (err) {
       console.error(`Poll error: ${err instanceof Error ? err.message : err}`);
     }
-    while (activeRuns.size > 0) await sleep(1e3);
+    while (!scheduler.isEmpty()) await sleep(1e3);
     return;
   }
   while (running) {
     try {
       const pending = await client.listPendingRuns();
-      handlePendingRuns(pending, activeRuns, client, config);
+      handlePendingRuns(pending, scheduler, client, config);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       if (config.verbose || !msg.includes("fetch")) {
@@ -670,15 +806,15 @@ async function main() {
   if (config.model) console.log(`   Model: ${config.model}`);
   if (config.dryRun) console.log(`   Mode:  DRY RUN`);
   console.log();
-  const activeRuns = /* @__PURE__ */ new Set();
+  const scheduler = new TaskScheduler();
   if (config.poll || config.once) {
-    await runWithPolling(client, config, activeRuns);
+    await runWithPolling(client, config, scheduler);
   } else {
-    await runWithWebSocket(client, config, activeRuns);
+    await runWithWebSocket(client, config, scheduler);
   }
-  if (activeRuns.size > 0) {
-    console.log(`\u23F3 Waiting for ${activeRuns.size} in-flight run(s)\u2026`);
-    while (activeRuns.size > 0) {
+  if (!scheduler.isEmpty()) {
+    console.log(`\u23F3 Waiting for ${scheduler.activeTaskCount} in-flight task(s)\u2026`);
+    while (!scheduler.isEmpty()) {
       await sleep(1e3);
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groupchatai/claude-runner",
-  "version": "0.2.3",
+  "version": "0.4.0",
   "description": "Run GroupChat AI agent tasks locally with Claude Code",
   "type": "module",
   "bin": {