claude-task-worker 0.24.0 → 0.26.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";
   }
@@ -1510,10 +1639,86 @@ function isGeneratedWorktreeName(name) {
 
 // src/slack.ts
 import { exec } from "node:child_process";
-import { readFileSync as readFileSync2, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join as join2 } from "node:path";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join3 } from "node:path";
 import { promisify as promisify2 } from "node:util";
+
+// src/runcat.ts
+import { mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join as join2 } from "node:path";
+var RUNCAT_OUT_FILE = process.env.RUNCAT_OUT_FILE ?? join2(process.env.HOME ?? homedir(), ".claude", "runcat-usage.json");
+var JST = "Asia/Tokyo";
+function formatG(value) {
+  return String(Number(value.toPrecision(6)));
+}
+function jstFields(date) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: JST,
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hourCycle: "h23"
+  }).formatToParts(date);
+  const pick2 = (type) => parts.find((p) => p.type === type)?.value ?? "";
+  return { month: pick2("month"), day: pick2("day"), hour: pick2("hour"), minute: pick2("minute") };
+}
+function parseResetsAt(isoString) {
+  const date = new Date(isoString);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+function resetStamp(isoString, now = /* @__PURE__ */ new Date()) {
+  const date = parseResetsAt(isoString);
+  if (!date) return "";
+  const reset = jstFields(date);
+  const today = jstFields(now);
+  const time = `${reset.hour}:${reset.minute}`;
+  if (reset.month === today.month && reset.day === today.day) return time;
+  return `${reset.month}/${reset.day} ${time}`;
+}
+function resetHour(isoString) {
+  const date = parseResetsAt(isoString);
+  return date ? jstFields(date).hour : "";
+}
+function metric(title, pct, resetsAt, now) {
+  const stamp = resetStamp(resetsAt, now);
+  return {
+    title,
+    formattedValue: `${formatG(pct)}%` + (stamp ? ` \u21BB${stamp}` : ""),
+    normalizedValue: Math.round(pct / 100 * 1e4) / 1e4
+  };
+}
+function buildRuncatSnapshot(usage, now = /* @__PURE__ */ new Date()) {
+  const bar = `${formatG(usage.fiveHourUtilization)}/${formatG(usage.sevenDayUtilization)}`;
+  const stamp = resetHour(usage.fiveHourResetsAt);
+  return {
+    title: "Claude Code",
+    symbol: "staroflife",
+    metrics: [
+      metric("5h", usage.fiveHourUtilization, usage.fiveHourResetsAt, now),
+      metric("7d", usage.sevenDayUtilization, usage.sevenDayResetsAt, now)
+    ],
+    metricsBarValue: stamp ? `${bar} \u21BB${stamp}` : bar,
+    lastUpdatedDate: now.toISOString().replace(/\.\d{3}Z$/, "Z")
+  };
+}
+function writeRuncatUsage(usage, outFile = RUNCAT_OUT_FILE) {
+  const snapshot = buildRuncatSnapshot(usage);
+  const dir = dirname(outFile);
+  const tmp = join2(dir, `.runcat-${process.pid}-${Date.now()}.json`);
+  try {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(tmp, JSON.stringify(snapshot), "utf-8");
+    renameSync(tmp, outFile);
+  } catch (err) {
+    rmSync(tmp, { force: true });
+    console.error(`[runcat] Failed to write ${outFile}: ${err}`);
+  }
+}
+
+// src/slack.ts
 var execAsync = promisify2(exec);
 var WEBHOOK_URL = process.env.CLAUDE_TASK_WORKER_SLACK_WEBHOOK_URL;
 var USAGE_CACHE_PATH = "/tmp/claude-usage-cache.json";
@@ -1539,7 +1744,7 @@ async function getOAuthToken() {
     const { stdout } = await execAsync('security find-generic-password -s "Claude Code-credentials" -w');
     return extractToken(JSON.parse(stdout.trim()));
   } catch {
-    const raw = readFileSync2(join2(homedir(), ".claude", ".credentials.json"), "utf-8");
+    const raw = readFileSync2(join3(homedir2(), ".claude", ".credentials.json"), "utf-8");
     return extractToken(JSON.parse(raw));
   }
 }
@@ -1556,7 +1761,7 @@ function readUsageCache() {
 }
 function writeUsageCache(data) {
   try {
-    writeFileSync(USAGE_CACHE_PATH, JSON.stringify({ timestamp: Date.now(), data }));
+    writeFileSync2(USAGE_CACHE_PATH, JSON.stringify({ timestamp: Date.now(), data }));
   } catch {
   }
 }
@@ -1604,9 +1809,7 @@ function formatResetTimeJST(isoString) {
     minute: "2-digit"
   });
 }
-async function buildTokenLimitText() {
-  const usage = await fetchUsageInfo();
-  if (!usage) return "";
+function formatTokenLimitText(usage) {
   const fiveH = usage.fiveHourUtilization.toFixed(1);
   const sevenD = usage.sevenDayUtilization.toFixed(1);
   const emoji = utilizationEmoji(Math.max(usage.fiveHourUtilization, usage.sevenDayUtilization));
@@ -1614,6 +1817,12 @@ async function buildTokenLimitText() {
   const sevenDReset = formatResetTimeJST(usage.sevenDayResetsAt);
   return ` | ${emoji} 5h: ${fiveH}% (reset: ${fiveHReset}) / 7d: ${sevenD}% (reset: ${sevenDReset})`;
 }
+async function buildTokenLimitText() {
+  const usage = await fetchUsageInfo();
+  if (!usage) return "";
+  writeRuncatUsage(usage);
+  return formatTokenLimitText(usage);
+}
 async function notifyTaskCompleted(workerName, repoName, id, title, url, output) {
   const tokenText = await buildTokenLimitText();
   const truncatedOutput = output && output.length > 1e3 ? `\u2026${output.slice(-1e3)}` : output;
@@ -2473,11 +2682,11 @@ async function update() {
 
 // src/commands/version.ts
 import { readFileSync as readFileSync3 } from "node:fs";
-import { dirname, join as join3 } from "node:path";
+import { dirname as dirname2, join as join4 } from "node:path";
 import { fileURLToPath } from "node:url";
 function version() {
-  const here = dirname(fileURLToPath(import.meta.url));
-  const pkgPath = join3(here, "..", "package.json");
+  const here = dirname2(fileURLToPath(import.meta.url));
+  const pkgPath = join4(here, "..", "package.json");
   try {
     const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
     console.log(pkg.version ?? "unknown");
@@ -2532,8 +2741,8 @@ function buildForwardedCommand(argv) {
 
 // src/projects-config.ts
 import { readFileSync as readFileSync4, statSync } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { isAbsolute, join as join4 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { isAbsolute, join as join5 } from "node:path";
 var RESERVED_ALL = "all";
 var ProjectsConfigError = class extends Error {
   constructor(message) {
@@ -2543,8 +2752,8 @@ var ProjectsConfigError = class extends Error {
 };
 function getProjectsConfigPath() {
   const xdg = process.env.XDG_CONFIG_HOME;
-  const configHome = xdg && xdg.length > 0 ? xdg : join4(homedir2(), ".config");
-  return join4(configHome, "claude-task-worker", "projects.json");
+  const configHome = xdg && xdg.length > 0 ? xdg : join5(homedir3(), ".config");
+  return join5(configHome, "claude-task-worker", "projects.json");
 }
 var PROJECTS_CONFIG_PATH = getProjectsConfigPath();
 function isDirectory(path) {

package/package.json

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