claude-task-worker 0.11.0 → 0.13.0

package/dist/index.js

@@ -81,13 +81,13 @@ function runHerdr(args) {
         } catch {
           parsed = void 0;
         }
-        resolve2({ execError: error, parsed, stderr });
+        resolve2({ execError: error, parsed, stdout, stderr });
       }
     );
   });
 }
-async function execHerdr(args) {
-  const { execError, parsed, stderr } = await runHerdr(args);
+async function execHerdr(args, options) {
+  const { execError, parsed, stdout, stderr } = await runHerdr(args);
   const stderrSuffix = stderr.trim() ? `: ${stderr.trim()}` : "";
   if (parsed?.error) {
     throw new HerdrError(
@@ -99,6 +99,9 @@ async function execHerdr(args) {
     throw new Error(`herdr ${args.join(" ")} failed: ${execError.message}${stderrSuffix}`);
   }
   if (!parsed) {
+    if (options?.allowEmptyResult && stdout.trim() === "" && stderr.trim() === "") {
+      return void 0;
+    }
     throw new Error(`herdr ${args.join(" ")} failed: invalid JSON output${stderrSuffix}`);
   }
   return parsed.result;
@@ -127,10 +130,10 @@ async function tabList() {
   }));
 }
 async function paneSendText(paneId, text) {
-  await execHerdr(["pane", "send-text", paneId, text]);
+  await execHerdr(["pane", "send-text", paneId, text], { allowEmptyResult: true });
 }
 async function paneSendKeys(paneId, ...keys) {
-  await execHerdr(["pane", "send-keys", paneId, ...keys]);
+  await execHerdr(["pane", "send-keys", paneId, ...keys], { allowEmptyResult: true });
 }
 async function paneProcessInfo(paneId) {
   const result = await execHerdr(["pane", "process-info", "--pane", paneId]);
@@ -190,6 +193,7 @@ __export(dispatcher_exports, {
   POLL_INTERVAL_MS: () => POLL_INTERVAL_MS,
   SHUTDOWN_RETRY_TIMEOUT_MS: () => SHUTDOWN_RETRY_TIMEOUT_MS,
   SHUTDOWN_TIMEOUT_MS: () => SHUTDOWN_TIMEOUT_MS,
+  createDispatcherShutdownHandler: () => createDispatcherShutdownHandler,
   formatUptime: () => formatUptime,
   monitorSessions: () => monitorSessions,
   pollOnce: () => pollOnce,
@@ -335,11 +339,9 @@ function monitorSessions(sessions, herdr, options) {
       }
     });
   }, pollIntervalMs);
-  pollInterval.unref();
   const renderInterval2 = setInterval(() => {
     renderSessionTable(sessions);
   }, renderIntervalMs);
-  renderInterval2.unref();
   return {
     stop: finish,
     done
@@ -433,6 +435,33 @@ async function shutdownDispatcher(sessions, monitorHandle, options) {
     shutdownPromise = void 0;
   }
 }
+function createDispatcherShutdownHandler(shutdown2) {
+  let shuttingDown2 = false;
+  let forceKilling = false;
+  const handle = async () => {
+    if (shuttingDown2) {
+      if (forceKilling) return;
+      forceKilling = true;
+      console.log("\n[dispatcher] Force killing sessions immediately...");
+      try {
+        await shutdown2({ forceKill: true });
+      } catch (error) {
+        console.error(`[dispatcher] force-kill shutdown failed: ${error}`);
+        process.exit(1);
+      }
+      return;
+    }
+    shuttingDown2 = true;
+    console.log("\n[dispatcher] Stopping sessions. Waiting for them to finish... (Press Ctrl-C again to force kill)");
+    try {
+      await shutdown2();
+    } catch (error) {
+      console.error(`[dispatcher] shutdown failed: ${error}`);
+      process.exit(1);
+    }
+  };
+  return { handle, isShuttingDown: () => shuttingDown2 };
+}
 var getDisplayWidth2, truncateToWidth2, padToWidth2, POLL_INTERVAL_MS, SHUTDOWN_TIMEOUT_MS, SHUTDOWN_RETRY_TIMEOUT_MS, shutdownPromise;
 var init_dispatcher = __esm({
   async "src/dispatcher.ts"() {
@@ -2569,20 +2598,28 @@ if (hasProjectFilter()) {
   (async () => {
     let sessions = /* @__PURE__ */ new Map();
     let monitorHandle;
-    const handleShutdown = async () => {
-      const { shutdownDispatcher: shutdownDispatcher2 } = await init_dispatcher().then(() => dispatcher_exports);
-      await shutdownDispatcher2(sessions, monitorHandle);
-    };
-    process.on("SIGTERM", handleShutdown);
-    process.on("SIGINT", handleShutdown);
     const herdr = await Promise.resolve().then(() => (init_herdr(), herdr_exports));
+    const dispatcher = await init_dispatcher().then(() => dispatcher_exports);
+    const shutdownController = dispatcher.createDispatcherShutdownHandler(
+      (options) => dispatcher.shutdownDispatcher(sessions, monitorHandle, options)
+    );
+    process.on("SIGTERM", shutdownController.handle);
+    process.on("SIGINT", shutdownController.handle);
     try {
       const config = loadProjectsConfig();
       const projects = resolveTargetProjects(parseProjectFilters(), config);
       const forwardedCommand = buildForwardedCommand(process.argv.slice(2));
-      const { runDispatcher: runDispatcher2, monitorSessions: monitorSessions2 } = await init_dispatcher().then(() => dispatcher_exports);
-      sessions = await runDispatcher2(projects, forwardedCommand);
-      monitorHandle = monitorSessions2(sessions, herdr);
+      sessions = await dispatcher.runDispatcher(projects, forwardedCommand);
+      if (sessions.size === 0) {
+        console.log("[dispatcher] no sessions were dispatched, exiting");
+        process.exit(0);
+      }
+      monitorHandle = dispatcher.monitorSessions(sessions, herdr);
+      await monitorHandle.done;
+      if (!shutdownController.isShuttingDown()) {
+        console.log("[dispatcher] all sessions finished, exiting");
+        process.exit(0);
+      }
     } catch (err) {
       if (err instanceof ProjectsConfigError || err instanceof herdr.HerdrUnavailableError) {
         console.error(`[dispatcher] ${err.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-task-worker",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "CLI tool that polls GitHub Issues/PRs and delegates work to Claude CLI",
   "type": "module",
   "main": "dist/index.js",