claude-task-worker 0.23.0 → 0.25.0

package/dist/index.js

@@ -61,6 +61,7 @@ __export(herdr_exports, {
   HerdrUnavailableError: () => HerdrUnavailableError,
   checkHerdrAvailable: () => checkHerdrAvailable,
   paneProcessInfo: () => paneProcessInfo,
+  paneRead: () => paneRead,
   paneSendKeys: () => paneSendKeys,
   paneSendText: () => paneSendText,
   tabClose: () => tabClose,
@@ -129,6 +130,50 @@ async function tabList() {
     workspaceId: tab.workspace_id
   }));
 }
+function isPaneReadErrorPayload(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const keys = Object.keys(value);
+  if (keys.some((key) => !PANE_READ_ERROR_ALLOWED_KEYS.has(key))) {
+    return false;
+  }
+  const payload = value;
+  if (typeof payload.code !== "string") {
+    return false;
+  }
+  if ("message" in payload && typeof payload.message !== "string") {
+    return false;
+  }
+  return true;
+}
+async function paneRead(paneId, options) {
+  const args = ["pane", "read", paneId, "--source", options?.source ?? "visible"];
+  if (options?.lines !== void 0) {
+    args.push("--lines", String(options.lines));
+  }
+  const { execError, stdout, stderr } = await runHerdr(args);
+  const trimmed = stdout.trim();
+  if (trimmed.startsWith("{")) {
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      parsed = void 0;
+    }
+    if (isPaneReadErrorPayload(parsed)) {
+      throw new HerdrError(
+        `herdr ${args.join(" ")} failed: [${parsed.code}] ${parsed.message ?? ""}`.trim(),
+        parsed.code
+      );
+    }
+  }
+  if (execError) {
+    const stderrSuffix = stderr.trim() ? `: ${stderr.trim()}` : "";
+    throw new Error(`herdr ${args.join(" ")} failed: ${execError.message}${stderrSuffix}`);
+  }
+  return stdout;
+}
 async function paneSendText(paneId, text) {
   await execHerdr(["pane", "send-text", paneId, text], { allowEmptyResult: true });
 }
@@ -162,7 +207,7 @@ async function checkHerdrAvailable() {
     );
   }
 }
-var childProcess2, HerdrUnavailableError, HerdrError, HERDR_TIMEOUT_MS;
+var childProcess2, HerdrUnavailableError, HerdrError, HERDR_TIMEOUT_MS, PANE_READ_ERROR_ALLOWED_KEYS;
 var init_herdr = __esm({
   "src/herdr.ts"() {
     "use strict";
@@ -184,25 +229,36 @@ var init_herdr = __esm({
       }
     };
     HERDR_TIMEOUT_MS = 15 * 1e3;
+    PANE_READ_ERROR_ALLOWED_KEYS = /* @__PURE__ */ new Set(["code", "message"]);
   }
 });
 
 // src/dispatcher.ts
 var dispatcher_exports = {};
 __export(dispatcher_exports, {
+  PANE_READY_POLL_INTERVAL_MS: () => PANE_READY_POLL_INTERVAL_MS,
+  PANE_READY_TIMEOUT_MS: () => PANE_READY_TIMEOUT_MS,
   POLL_INTERVAL_MS: () => POLL_INTERVAL_MS,
+  SEND_MAX_ATTEMPTS: () => SEND_MAX_ATTEMPTS,
   SHUTDOWN_RETRY_TIMEOUT_MS: () => SHUTDOWN_RETRY_TIMEOUT_MS,
   SHUTDOWN_TIMEOUT_MS: () => SHUTDOWN_TIMEOUT_MS,
   TAB_LABEL_PREFIX: () => TAB_LABEL_PREFIX,
+  WORKER_STARTUP_POLL_INTERVAL_MS: () => WORKER_STARTUP_POLL_INTERVAL_MS,
+  WORKER_STARTUP_TIMEOUT_MS: () => WORKER_STARTUP_TIMEOUT_MS,
   createDispatcherShutdownHandler: () => createDispatcherShutdownHandler,
   formatUptime: () => formatUptime,
+  isShellProcess: () => isShellProcess,
+  isWorkerProcess: () => isWorkerProcess,
   monitorSessions: () => monitorSessions,
   pollOnce: () => pollOnce,
   removeSession: () => removeSession,
   renderSessionTable: () => renderSessionTable,
   runDispatcher: () => runDispatcher,
   shutdownDispatcher: () => shutdownDispatcher,
-  tabLabelFor: () => tabLabelFor
+  startWorkerInPane: () => startWorkerInPane,
+  tabLabelFor: () => tabLabelFor,
+  waitForPaneReady: () => waitForPaneReady,
+  waitForWorkerStartup: () => waitForWorkerStartup
 });
 async function loadHerdr() {
   return await Promise.resolve().then(() => (init_herdr(), herdr_exports));
@@ -213,8 +269,72 @@ async function loadTable() {
 function tabLabelFor(projectName) {
   return `${TAB_LABEL_PREFIX}${projectName}`;
 }
-async function runDispatcher(projects, forwardedCommand) {
-  const { checkHerdrAvailable: checkHerdrAvailable2, tabCreate: tabCreate2, tabClose: tabClose2, tabList: tabList2, paneSendText: paneSendText2, paneSendKeys: paneSendKeys2 } = await loadHerdr();
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function isWorkerProcess(process2) {
+  return process2.cmdline?.includes("claude-task-worker") ?? false;
+}
+function isShellProcess(process2) {
+  return SHELL_NAME_PATTERN.test(process2.name ?? "") || SHELL_NAME_PATTERN.test(process2.cmdline ?? "");
+}
+async function waitForPaneReady(paneId, herdr, options) {
+  const timeoutMs = options?.timeoutMs ?? PANE_READY_TIMEOUT_MS;
+  const pollIntervalMs = options?.pollIntervalMs ?? PANE_READY_POLL_INTERVAL_MS;
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    const content = await herdr.paneRead(paneId, { source: "visible" });
+    if (content.trim() !== "") return true;
+    if (Date.now() >= deadline) return false;
+    await sleep(pollIntervalMs);
+  }
+}
+async function waitForWorkerStartup(paneId, herdr, options) {
+  const timeoutMs = options?.timeoutMs ?? WORKER_STARTUP_TIMEOUT_MS;
+  const pollIntervalMs = options?.pollIntervalMs ?? WORKER_STARTUP_POLL_INTERVAL_MS;
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    const { foregroundProcesses } = await herdr.paneProcessInfo(paneId);
+    if (foregroundProcesses.some(isWorkerProcess)) return "started";
+    if (foregroundProcesses.length > 0 && !foregroundProcesses.every(isShellProcess)) return "other";
+    if (Date.now() >= deadline) return "shell";
+    await sleep(pollIntervalMs);
+  }
+}
+async function startWorkerInPane(paneId, forwardedCommand, herdr, options) {
+  const maxAttempts = options?.sendMaxAttempts ?? SEND_MAX_ATTEMPTS;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const ready = await waitForPaneReady(paneId, herdr, {
+      timeoutMs: options?.paneReadyTimeoutMs,
+      pollIntervalMs: options?.paneReadyPollIntervalMs
+    });
+    if (!ready) {
+      console.warn(`[dispatcher] pane ${paneId} produced no prompt before the timeout, sending the command anyway`);
+    }
+    await herdr.paneSendText(paneId, forwardedCommand);
+    await herdr.paneSendKeys(paneId, "enter");
+    const result = await waitForWorkerStartup(paneId, herdr, {
+      timeoutMs: options?.workerStartupTimeoutMs,
+      pollIntervalMs: options?.workerStartupPollIntervalMs
+    });
+    if (result === "started") return true;
+    if (result === "other") {
+      console.warn(
+        `[dispatcher] pane ${paneId} foreground is neither the shell nor the worker, giving up without resending`
+      );
+      return false;
+    }
+    if (attempt < maxAttempts) {
+      console.warn(
+        `[dispatcher] worker did not start in pane ${paneId} (attempt ${attempt}/${maxAttempts}), resending the command`
+      );
+    }
+  }
+  return false;
+}
+async function runDispatcher(projects, forwardedCommand, timing) {
+  const herdr = await loadHerdr();
+  const { checkHerdrAvailable: checkHerdrAvailable2, tabCreate: tabCreate2, tabClose: tabClose2, tabList: tabList2 } = herdr;
   try {
     await checkHerdrAvailable2();
   } catch (error) {
@@ -241,8 +361,12 @@ async function runDispatcher(projects, forwardedCommand) {
         startedAt: /* @__PURE__ */ new Date(),
         status: "running"
       });
-      await paneSendText2(paneId, forwardedCommand);
-      await paneSendKeys2(paneId, "enter");
+      const started = await startWorkerInPane(paneId, forwardedCommand, herdr, timing);
+      if (!started) {
+        throw new Error(
+          `worker did not start in pane ${paneId} after ${timing?.sendMaxAttempts ?? SEND_MAX_ATTEMPTS} attempt(s)`
+        );
+      }
     } catch (error) {
       console.error(`[dispatcher] failed to dispatch project "${project.name}": ${error}`);
       sessions.delete(project.name);
@@ -270,8 +394,7 @@ async function pollOnce(sessions, herdr) {
   for (const [name, session] of [...sessions.entries()]) {
     try {
       const { foregroundProcesses } = await herdr.paneProcessInfo(session.paneId);
-      const isAlive = foregroundProcesses.some((process2) => process2.cmdline?.includes("claude-task-worker"));
-      if (!isAlive) {
+      if (!foregroundProcesses.some(isWorkerProcess)) {
         await removeSession(sessions, name, { closeTab: true });
       }
     } catch (error) {
@@ -467,14 +590,20 @@ function createDispatcherShutdownHandler(shutdown2) {
   };
   return { handle, isShuttingDown: () => shuttingDown2 };
 }
-var getDisplayWidth2, truncateToWidth2, padToWidth2, POLL_INTERVAL_MS, SHUTDOWN_TIMEOUT_MS, TAB_LABEL_PREFIX, SHUTDOWN_RETRY_TIMEOUT_MS, CTRL_C_KEY, shutdownPromise;
+var getDisplayWidth2, truncateToWidth2, padToWidth2, POLL_INTERVAL_MS, SHUTDOWN_TIMEOUT_MS, PANE_READY_TIMEOUT_MS, PANE_READY_POLL_INTERVAL_MS, WORKER_STARTUP_TIMEOUT_MS, WORKER_STARTUP_POLL_INTERVAL_MS, SEND_MAX_ATTEMPTS, TAB_LABEL_PREFIX, SHELL_NAME_PATTERN, SHUTDOWN_RETRY_TIMEOUT_MS, CTRL_C_KEY, shutdownPromise;
 var init_dispatcher = __esm({
   async "src/dispatcher.ts"() {
     "use strict";
     ({ getDisplayWidth: getDisplayWidth2, truncateToWidth: truncateToWidth2, padToWidth: padToWidth2 } = await loadTable());
     POLL_INTERVAL_MS = 7 * 1e3;
     SHUTDOWN_TIMEOUT_MS = 10 * 60 * 1e3;
+    PANE_READY_TIMEOUT_MS = 30 * 1e3;
+    PANE_READY_POLL_INTERVAL_MS = 200;
+    WORKER_STARTUP_TIMEOUT_MS = 30 * 1e3;
+    WORKER_STARTUP_POLL_INTERVAL_MS = 500;
+    SEND_MAX_ATTEMPTS = 3;
     TAB_LABEL_PREFIX = "ctw:";
+    SHELL_NAME_PATTERN = /^-?(zsh|bash|sh)$/;
     SHUTDOWN_RETRY_TIMEOUT_MS = 90 * 1e3;
     CTRL_C_KEY = "ctrl+c";
   }
@@ -1024,16 +1153,12 @@ import { spawn } from "node:child_process";
 init_table();
 
 // src/task-result.ts
-var TASK_TIMEOUT_MS = 120 * 60 * 1e3;
 var STDERR_TAIL_LIMIT = 8 * 1024;
-function buildTaskResult(code, timedOut, stdout, stderrTail) {
+function buildTaskResult(code, stdout, stderrTail) {
   const emptyOutput = stdout.trim() === "";
-  const completed = !timedOut && code === 0 && !emptyOutput;
+  const completed = code === 0 && !emptyOutput;
   let output = stdout;
-  if (timedOut) {
-    output += `
-[worker] task timed out after ${TASK_TIMEOUT_MS / 1e3}s`;
-  } else if (code === 0 && emptyOutput) {
+  if (code === 0 && emptyOutput) {
     output += "[worker] claude exited with code 0 but produced no output (session aborted before the model ran; e.g. a skill preamble command failed)";
   } else if (!completed) {
     output += `
@@ -1194,27 +1319,9 @@ function run(command, args, id, title, workerName, path, onComplete, cwd, env) {
       stderrChunks.shift();
     }
   });
-  let timedOut = false;
-  const timeoutHandle = setTimeout(() => {
-    timedOut = true;
-    console.error(`[worker] task #${id} timed out after ${TASK_TIMEOUT_MS / 1e3}s, terminating`);
-    if (child.pid) {
-      try {
-        process.kill(-child.pid, "SIGTERM");
-      } catch {
-        try {
-          child.kill("SIGTERM");
-        } catch {
-        }
-      }
-    }
-  }, TASK_TIMEOUT_MS);
-  timeoutHandle.unref();
   child.on("close", async (code) => {
-    clearTimeout(timeoutHandle);
     const { status: finalStatus, output } = buildTaskResult(
       code,
-      timedOut,
       Buffer.concat(outputChunks).toString("utf-8"),
       Buffer.concat(stderrChunks).toString("utf-8").slice(-STDERR_TAIL_LIMIT)
     );
@@ -1237,7 +1344,6 @@ function run(command, args, id, title, workerName, path, onComplete, cwd, env) {
     renderTable();
   });
   child.on("error", async (err) => {
-    clearTimeout(timeoutHandle);
     console.error(`[worker] failed to spawn process for #${id}: ${err.message}`);
     try {
       await Promise.race([

package/package.json

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