@groupchatai/claude-runner 0.4.1 → 0.4.3

package/dist/index.js

@@ -461,15 +461,24 @@ function getDefaultBranch(repoDir) {
     return "main";
   }
 }
-function createWorktree(repoDir, taskId) {
+function createWorktree(repoDir, taskId, existingBranch) {
   const name = worktreeNameForTask(taskId);
-  const branchName = `agent/${name}-${Date.now()}`;
   const worktreeBase = path.join(repoDir, WORKTREE_DIR);
   const worktreePath = path.join(worktreeBase, name);
   if (existsSync(worktreePath)) {
     return worktreePath;
   }
+  if (existingBranch) {
+    try {
+      execGit(["fetch", "origin", existingBranch, "--quiet"], repoDir);
+    } catch {
+    }
+    execGit(["worktree", "add", worktreePath, `origin/${existingBranch}`], repoDir);
+    writeFileSync(path.join(worktreePath, ".agent-branch"), existingBranch, "utf-8");
+    return worktreePath;
+  }
   const baseBranch = getDefaultBranch(repoDir);
+  const branchName = `agent/${name}-${Date.now()}`;
   try {
     execGit(["fetch", "origin", baseBranch, "--quiet"], repoDir);
   } catch {
@@ -478,6 +487,39 @@ function createWorktree(repoDir, taskId) {
   writeFileSync(path.join(worktreePath, ".agent-branch"), branchName, "utf-8");
   return worktreePath;
 }
+async function resolveExistingPrBranch(detail, workDir) {
+  try {
+    if (detail.branchName) return detail.branchName;
+    if (detail.pullRequestUrl) {
+      try {
+        const branch2 = await runShellCommand(
+          "gh",
+          ["pr", "view", detail.pullRequestUrl, "--json", "headRefName", "--jq", ".headRefName"],
+          workDir
+        );
+        if (branch2?.trim()) return branch2.trim();
+      } catch {
+      }
+    }
+    const prUrls = [];
+    for (const item of detail.activity) {
+      if (item.body) {
+        const matches = item.body.match(GITHUB_PR_URL_RE);
+        if (matches) prUrls.push(...matches);
+      }
+    }
+    const prUrl = prUrls[prUrls.length - 1];
+    if (!prUrl) return void 0;
+    const branch = await runShellCommand(
+      "gh",
+      ["pr", "view", prUrl, "--json", "headRefName", "--jq", ".headRefName"],
+      workDir
+    );
+    if (branch?.trim()) return branch.trim();
+  } catch {
+  }
+  return void 0;
+}
 async function listOurWorktrees(workDir) {
   const worktreeDir = path.join(workDir, WORKTREE_DIR);
   let entries;
@@ -640,12 +682,11 @@ Removing ${safe.length} safe worktree(s)\u2026`);
   }
   console.log();
 }
-async function processRun(client, run, config, worktreeDir) {
+async function processRun(client, run, config, worktreeDir, detail) {
   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);
   const ownerName = run.owner?.name ?? detail.owner?.name ?? "unknown";
   log(`\u{1F4CB} "${run.taskTitle}" \u2014 delegated by ${ownerName}`);
   if (detail.status !== "PENDING") {
@@ -782,9 +823,9 @@ Commands:
 
 Options:
   --work-dir <path>     Repo directory for Claude Code to work in (default: cwd)
-  --poll                Use HTTP polling instead of WebSocket (default: websocket)
-  --poll-interval <ms>  Polling interval in milliseconds (default: 5000, only with --poll)
-  --max-concurrent <n>  Max concurrent tasks (default: 1)
+  --poll                Use HTTP polling fallback (default: websocket, see below)
+  --poll-interval <ms>  Polling interval in milliseconds (default: 30000, only with --poll)
+  --max-concurrent <n>  Max concurrent tasks (default: 5)
   --model <model>       Claude model to use (passed to claude CLI)
   --dry-run             Poll and log runs without executing Claude Code
   --once                Process one batch of pending runs and exit (implies --poll)
@@ -808,8 +849,8 @@ function parseArgs() {
     apiUrl: process.env.GCA_API_URL ?? API_URL,
     convexUrl: process.env.GCA_CONVEX_URL ?? CONVEX_URL,
     workDir: process.cwd(),
-    pollInterval: 5e3,
-    maxConcurrent: 1,
+    pollInterval: 3e4,
+    maxConcurrent: 5,
     poll: false,
     dryRun: false,
     once: false,
@@ -823,7 +864,7 @@ function parseArgs() {
         config.workDir = path.resolve(args[++i] ?? ".");
         break;
       case "--poll-interval":
-        config.pollInterval = parseInt(args[++i] ?? "5000", 10);
+        config.pollInterval = parseInt(args[++i] ?? "30000", 10);
         break;
       case "--max-concurrent":
         config.maxConcurrent = parseInt(args[++i] ?? "1", 10);
@@ -919,6 +960,12 @@ var TaskScheduler = class {
     return this.slots.size === 0;
   }
 };
+function drainSchedulerSlot(scheduler, run) {
+  let current = run;
+  while (current) {
+    current = scheduler.complete(current);
+  }
+}
 function handlePendingRuns(runs, scheduler, client, config) {
   if (runs.length > 0 && config.verbose) {
     console.log(`\u{1F4EC} ${runs.length} pending run(s)`);
@@ -943,27 +990,47 @@ function handlePendingRuns(runs, scheduler, client, config) {
   }
 }
 async function processRunWithDrain(client, run, scheduler, config) {
+  let detail;
+  try {
+    detail = await client.getRunDetail(run.id);
+  } catch (err) {
+    console.error(`  \u274C Failed to fetch run detail for ${run.id}:`, err);
+    drainSchedulerSlot(scheduler, run);
+    return;
+  }
   let worktreeDir;
   if (config.useWorktrees) {
     try {
-      worktreeDir = createWorktree(config.workDir, run.taskId);
-      console.log(
-        `  \u{1F333} Worktree created from main \u2192 ${path.relative(config.workDir, worktreeDir)}`
-      );
+      const existingBranch = await resolveExistingPrBranch(detail, config.workDir);
+      worktreeDir = createWorktree(config.workDir, run.taskId, existingBranch);
+      const rel = path.relative(config.workDir, worktreeDir);
+      if (existingBranch) {
+        console.log(`  \u{1F333} Worktree from existing PR branch ${existingBranch} \u2192 ${rel}`);
+      } else {
+        console.log(`  \u{1F333} Worktree created from main \u2192 ${rel}`);
+      }
     } catch (err) {
       console.error(`  \u26A0  Failed to create worktree, running in-place:`, err);
     }
   }
   let current = run;
+  let currentDetail = detail;
   while (current) {
     try {
-      await processRun(client, current, config, worktreeDir);
+      await processRun(client, current, config, worktreeDir, currentDetail);
     } 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`);
+      try {
+        currentDetail = await client.getRunDetail(current.id);
+      } catch (err) {
+        console.error(`  \u274C Failed to fetch detail for follow-up ${current.id}:`, err);
+        drainSchedulerSlot(scheduler, current);
+        break;
+      }
     }
   }
   if (worktreeDir) {
@@ -984,6 +1051,7 @@ async function runWithWebSocket(client, config, scheduler) {
     ({ anyApi } = await import("convex/server"));
   } catch {
     console.warn("\u26A0  convex package not found \u2014 falling back to HTTP polling.");
+    console.warn("   WebSocket mode is recommended for instant task pickup and zero idle cost.");
     console.warn("   Install convex for WebSocket mode: npm i convex\n");
     await runWithPolling(client, config, scheduler);
     return;
@@ -1009,8 +1077,14 @@ async function runWithWebSocket(client, config, scheduler) {
   });
 }
 async function runWithPolling(client, config, scheduler) {
-  console.log(`\u{1F4E1} Polling every ${config.pollInterval}ms \u2014 listening for tasks\u2026
-`);
+  console.log(`\u{1F4E1} Polling every ${config.pollInterval / 1e3}s \u2014 listening for tasks\u2026`);
+  console.log(
+    `${C.dim}   Tip: WebSocket mode (default) picks up tasks instantly with zero idle cost.${C.reset}`
+  );
+  console.log(
+    `${C.dim}   Remove --poll unless your network blocks WebSocket connections.${C.reset}
+`
+  );
   let running = true;
   const shutdown = () => {
     console.log("\n\u{1F6D1} Shutting down\u2026");

package/package.json

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