@groupchatai/claude-runner 0.3.1 → 0.4.0

package/dist/index.js

@@ -445,8 +445,10 @@ 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);
@@ -638,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 {
@@ -663,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);
@@ -673,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) => {
@@ -686,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;
@@ -699,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")) {
@@ -738,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.3.1",
+  "version": "0.4.0",
   "description": "Run GroupChat AI agent tasks locally with Claude Code",
   "type": "module",
   "bin": {