claude-task-worker 0.115.0 → 0.117.0

package/dist/herdr-NDLUM6JF.js

@@ -0,0 +1,309 @@
+// src/herdr.ts
+import { createRequire } from "node:module";
+import { resolve as resolvePath } from "node:path";
+var childProcess = createRequire(import.meta.url)("node:child_process");
+var HerdrUnavailableError = class extends Error {
+  reason;
+  constructor(message, reason) {
+    super(message);
+    this.name = "HerdrUnavailableError";
+    this.reason = reason;
+  }
+};
+var HerdrError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "HerdrError";
+    this.code = code;
+  }
+};
+var HERDR_TIMEOUT_MS = 15 * 1e3;
+function runHerdr(args, timeoutMs = HERDR_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    childProcess.execFile("herdr", args, { timeout: timeoutMs, killSignal: "SIGKILL" }, (error, stdout, stderr) => {
+      const parsed = parseHerdrResponse(stdout);
+      const stderrError = parsed?.error ? void 0 : parseHerdrResponse(stderr)?.error;
+      resolve({ execError: error, parsed, stderrError, stdout, stderr });
+    });
+  });
+}
+function parseHerdrResponse(output) {
+  try {
+    const parsed = JSON.parse(output);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+async function execHerdr(args, options) {
+  const { execError, parsed, stderrError, stdout, stderr } = await runHerdr(args, options?.timeoutMs);
+  const stderrSuffix = stderr.trim() ? `: ${stderr.trim()}` : "";
+  const errorPayload = parsed?.error ?? stderrError;
+  if (errorPayload) {
+    throw new HerdrError(
+      `herdr ${args.join(" ")} failed: [${errorPayload.code}] ${errorPayload.message}`,
+      errorPayload.code
+    );
+  }
+  if (execError) {
+    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;
+}
+function envArgs(env) {
+  if (!env) return [];
+  return Object.entries(env).flatMap(([key, value]) => ["--env", `${key}=${value}`]);
+}
+function cwdArgs(cwd) {
+  return ["--cwd", resolvePath(cwd)];
+}
+async function tabCreate({
+  label,
+  cwd,
+  workspaceId,
+  env
+}) {
+  const result = await execHerdr([
+    "tab",
+    "create",
+    ...workspaceId ? ["--workspace", workspaceId] : [],
+    "--label",
+    label,
+    ...cwdArgs(cwd),
+    ...envArgs(env),
+    "--no-focus"
+  ]);
+  const paneId = result?.root_pane?.pane_id;
+  const tabId = result?.tab?.tab_id;
+  if (!paneId || !tabId) {
+    throw new Error("Failed to create tab: invalid response structure from herdr");
+  }
+  return { paneId, tabId };
+}
+async function tabRename(tabId, label) {
+  await execHerdr(["tab", "rename", tabId, label]);
+}
+async function paneClose(paneId) {
+  await execHerdr(["pane", "close", paneId]);
+}
+async function paneGet(paneId) {
+  const result = await execHerdr(["pane", "get", paneId]);
+  const pane = result?.pane;
+  if (!pane?.pane_id) {
+    throw new Error(`Failed to get pane ${paneId}: invalid response structure from herdr`);
+  }
+  return { paneId: pane.pane_id, tabId: pane.tab_id ?? "" };
+}
+async function tabClose(tabId) {
+  await execHerdr(["tab", "close", tabId]);
+}
+async function tabList() {
+  const result = await execHerdr(["tab", "list"]);
+  if (!result || !Array.isArray(result.tabs)) {
+    return [];
+  }
+  return result.tabs.map((tab) => ({
+    tabId: tab.tab_id,
+    label: tab.label,
+    workspaceId: tab.workspace_id
+  }));
+}
+async function workspaceCreate({
+  label,
+  cwd,
+  env
+}) {
+  const result = await execHerdr([
+    "workspace",
+    "create",
+    "--label",
+    label,
+    ...cwdArgs(cwd),
+    ...envArgs(env),
+    "--no-focus"
+  ]);
+  const workspaceId = result?.workspace?.workspace_id;
+  const paneId = result?.root_pane?.pane_id;
+  const tabId = result?.root_pane?.tab_id;
+  if (!workspaceId || !paneId || !tabId) {
+    throw new Error("Failed to create workspace: invalid response structure from herdr");
+  }
+  return { workspaceId, paneId, tabId };
+}
+async function workspaceList() {
+  const result = await execHerdr(["workspace", "list"]);
+  if (!result || !Array.isArray(result.workspaces)) {
+    return [];
+  }
+  return result.workspaces.map((workspace) => ({
+    workspaceId: workspace.workspace_id,
+    label: workspace.label ?? "",
+    focused: workspace.focused === true
+  }));
+}
+async function workspaceClose(workspaceId) {
+  await execHerdr(["workspace", "close", workspaceId]);
+}
+async function workspaceFocus(workspaceId) {
+  await execHerdr(["workspace", "focus", workspaceId]);
+}
+function toAgentStatus(value) {
+  return value === "working" || value === "idle" || value === "blocked" || value === "done" ? value : "unknown";
+}
+function toAgentInfo(agent) {
+  const session = agent.agent_session;
+  const sessionId = session?.kind === "id" && typeof session.value === "string" ? session.value : void 0;
+  return {
+    paneId: agent.pane_id ?? "",
+    tabId: agent.tab_id ?? "",
+    workspaceId: agent.workspace_id ?? "",
+    agentStatus: toAgentStatus(agent.agent_status),
+    sessionId
+  };
+}
+var AGENT_KIND = "claude";
+var AGENT_START_READY_TIMEOUT_MS = 120 * 1e3;
+var AGENT_START_EXEC_BUFFER_MS = 15 * 1e3;
+async function agentStart(paneId, {
+  name,
+  args,
+  kind = AGENT_KIND,
+  readyTimeoutMs = AGENT_START_READY_TIMEOUT_MS
+}) {
+  const result = await execHerdr(
+    ["agent", "start", name, "--kind", kind, "--pane", paneId, "--timeout", String(readyTimeoutMs), "--", ...args],
+    { timeoutMs: readyTimeoutMs + AGENT_START_EXEC_BUFFER_MS }
+  );
+  const agent = result?.agent;
+  if (!agent?.pane_id) {
+    throw new Error(`Failed to start agent in pane ${paneId}: invalid response structure from herdr`);
+  }
+  return toAgentInfo(agent);
+}
+async function agentPrompt(paneId, text) {
+  await execHerdr(["agent", "prompt", paneId, text], { allowEmptyResult: true });
+}
+async function agentGet(target) {
+  const result = await execHerdr(["agent", "get", target]);
+  const agent = result?.agent;
+  if (!agent?.pane_id) {
+    throw new Error(`Failed to get agent info for ${target}: invalid response structure from herdr`);
+  }
+  return toAgentInfo(agent);
+}
+function getCurrentWorkspaceId() {
+  const id = process.env.HERDR_WORKSPACE_ID;
+  return id && id.length > 0 ? id : void 0;
+}
+var PANE_READ_ERROR_ALLOWED_KEYS = /* @__PURE__ */ new Set(["code", "message"]);
+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 });
+}
+async function paneSendKeys(paneId, ...keys) {
+  await execHerdr(["pane", "send-keys", paneId, ...keys], { allowEmptyResult: true });
+}
+async function paneProcessInfo(paneId) {
+  const result = await execHerdr(["pane", "process-info", "--pane", paneId]);
+  const foregroundProcesses = result?.process_info?.foreground_processes ?? [];
+  return {
+    foregroundProcesses: foregroundProcesses.map((process2) => ({
+      name: process2.name,
+      argv: process2.argv,
+      cmdline: process2.cmdline,
+      pid: process2.pid
+    }))
+  };
+}
+async function checkHerdrAvailable() {
+  const { execError, parsed } = await runHerdr(["tab", "list"]);
+  if (execError?.code === "ENOENT") {
+    throw new HerdrUnavailableError(
+      "herdr\u304C\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u3055\u308C\u3066\u3044\u307E\u305B\u3093\u3002herdr CLI\u3092\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+      "not-installed"
+    );
+  }
+  if (!parsed) {
+    throw new HerdrUnavailableError(
+      "herdr\u30B5\u30FC\u30D0\u30FC\u306B\u63A5\u7D9A\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\u3002`herdr status` \u7B49\u3067\u8D77\u52D5\u72B6\u614B\u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+      "server-unreachable"
+    );
+  }
+}
+export {
+  AGENT_KIND,
+  AGENT_START_READY_TIMEOUT_MS,
+  HERDR_TIMEOUT_MS,
+  HerdrError,
+  HerdrUnavailableError,
+  agentGet,
+  agentPrompt,
+  agentStart,
+  checkHerdrAvailable,
+  getCurrentWorkspaceId,
+  paneClose,
+  paneGet,
+  paneProcessInfo,
+  paneRead,
+  paneSendKeys,
+  paneSendText,
+  tabClose,
+  tabCreate,
+  tabList,
+  tabRename,
+  workspaceClose,
+  workspaceCreate,
+  workspaceFocus,
+  workspaceList
+};

package/dist/herdr-runner-33D6C2KI.js

@@ -0,0 +1,307 @@
+import {
+  CONTROL_CHARS
+} from "./chunk-N42YU3GJ.js";
+
+// src/transcript.ts
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function transcriptRoot() {
+  return join(homedir(), ".claude", "projects");
+}
+function findTranscriptPath(sessionId, root = transcriptRoot()) {
+  if (sessionId === "") return null;
+  let entries;
+  try {
+    entries = readdirSync(root);
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    const candidate = join(root, entry, `${sessionId}.jsonl`);
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function textOf(entry) {
+  const content = entry.message?.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter(
+    (block) => typeof block === "object" && block !== null && block.type === "text" && typeof block.text === "string"
+  ).map((block) => block.text).join("\n").trim();
+}
+function extractFinalAssistantText(jsonl) {
+  const lines = jsonl.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (line === "") continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry.type !== "assistant" || entry.isSidechain === true) continue;
+    const text = textOf(entry);
+    if (text !== "") return text;
+  }
+  return "";
+}
+function readFinalReport(sessionId, root = transcriptRoot()) {
+  if (!sessionId) return "";
+  const path = findTranscriptPath(sessionId, root);
+  if (!path) return "";
+  try {
+    return extractFinalAssistantText(readFileSync(path, "utf-8"));
+  } catch (err) {
+    console.error(`[transcript] failed to read ${path}: ${err}`);
+    return "";
+  }
+}
+
+// src/herdr-runner.ts
+async function loadHerdr() {
+  return await import("./herdr-NDLUM6JF.js");
+}
+var AGENT_POLL_INTERVAL_MS = 3 * 1e3;
+var PANE_OUTPUT_LINES = 300;
+function taskTabLabel(projectName, number) {
+  return `ctw:${projectName}:#${number}`;
+}
+function toAgentName(label) {
+  const sanitized = label.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/-+/g, "-").replace(/^[-_]+/, "");
+  const withLeadingLetter = /^[a-z]/.test(sanitized) ? sanitized : `ctw-${sanitized}`;
+  return withLeadingLetter.slice(0, 32).replace(/[-_]+$/, "");
+}
+function createCompletionTracker() {
+  return { seenWorking: false, warnedBlocked: false };
+}
+function observeAgentStatus(tracker, status) {
+  if (status === "working") {
+    return { tracker: { ...tracker, seenWorking: true }, decision: "running" };
+  }
+  if (status === "done") {
+    return { tracker, decision: "completed" };
+  }
+  if (status === "blocked") {
+    if (tracker.warnedBlocked) return { tracker, decision: "running" };
+    return { tracker: { ...tracker, warnedBlocked: true }, decision: "blocked-first-seen" };
+  }
+  if (status === "idle" && tracker.seenWorking) {
+    return { tracker, decision: "completed" };
+  }
+  return { tracker, decision: "running" };
+}
+var CLOUD_SESSION_URL_RE = /https:\/\/claude\.ai\/code\/([A-Za-z0-9_-]+)/;
+var CLOUD_SESSION_CREATED_RE = /Created cloud session:\s*(session_[A-Za-z0-9_-]+)/;
+function extractCloudSessionId(text) {
+  return CLOUD_SESSION_URL_RE.exec(text)?.[1] ?? CLOUD_SESSION_CREATED_RE.exec(text)?.[1];
+}
+function normalizePtyOutput(text) {
+  return text.replace(CONTROL_CHARS, "");
+}
+function buildHerdrTaskResult(paneOutput, options) {
+  const report = options?.report?.trim() ?? "";
+  if (report !== "") {
+    return { status: "completed", output: report };
+  }
+  if (paneOutput.trim() === "") {
+    return {
+      status: "failed",
+      output: "[worker] the claude session became idle but its pane produced no output (session aborted before the model ran; e.g. a skill preamble command failed)"
+    };
+  }
+  return { status: "completed", output: paneOutput };
+}
+var PANE_READY_TIMEOUT_MS = 30 * 1e3;
+var PANE_READY_POLL_INTERVAL_MS = 200;
+var PROMPT_ACCEPT_TIMEOUT_MS = 20 * 1e3;
+var PROMPT_ACCEPT_POLL_INTERVAL_MS = 500;
+async function startHerdrTask({
+  label,
+  cwd,
+  args,
+  prompt,
+  env,
+  workspaceId,
+  herdr,
+  timing
+}) {
+  const mod = herdr ?? await loadHerdr();
+  const { tabId, paneId } = await mod.tabCreate({ label, cwd, workspaceId, env });
+  try {
+    const ready = await waitForPaneReady(paneId, mod, {
+      timeoutMs: timing?.paneReadyTimeoutMs,
+      pollIntervalMs: timing?.paneReadyPollIntervalMs
+    });
+    if (!ready) {
+      console.warn(`[herdr-runner] pane ${paneId} produced no prompt before the timeout, launching anyway`);
+    }
+    await mod.agentStart(paneId, { name: toAgentName(label), args, readyTimeoutMs: timing?.agentStartReadyTimeoutMs });
+    await mod.agentPrompt(paneId, prompt);
+    await ensurePromptAccepted(paneId, prompt, mod, timing);
+  } catch (err) {
+    console.error(`[herdr-runner] failed to start task in pane ${paneId}: ${err}`);
+    await mod.tabClose(tabId).catch(() => {
+    });
+    throw err;
+  }
+  return { paneId, tabId };
+}
+async function ensurePromptAccepted(paneId, prompt, mod, timing) {
+  if (await waitForPromptAccepted(paneId, mod, timing)) return;
+  console.warn(`[herdr-runner] the prompt was not accepted in pane ${paneId} (claude stayed idle); resending it`);
+  await mod.agentPrompt(paneId, prompt);
+  if (await waitForPromptAccepted(paneId, mod, timing)) return;
+  throw new Error(
+    `the claude session in pane ${paneId} did not start the task after the prompt was submitted twice (a startup dialog most likely swallowed it)`
+  );
+}
+async function waitForPromptAccepted(paneId, mod, timing) {
+  const timeoutMs = timing?.promptAcceptTimeoutMs ?? PROMPT_ACCEPT_TIMEOUT_MS;
+  const pollIntervalMs = timing?.promptAcceptPollIntervalMs ?? PROMPT_ACCEPT_POLL_INTERVAL_MS;
+  const deadline = Date.now() + timeoutMs;
+  let loggedError = false;
+  for (; ; ) {
+    try {
+      const { agentStatus } = await mod.agentGet(paneId);
+      if (agentStatus === "working" || agentStatus === "done") return true;
+    } catch (err) {
+      if (!loggedError) {
+        console.error(`[herdr-runner] failed to read agent status for pane ${paneId} after the prompt: ${err}`);
+        loggedError = true;
+      }
+    }
+    if (Date.now() >= deadline) return false;
+    await sleep(pollIntervalMs);
+  }
+}
+async function waitForPaneReady(paneId, mod, options) {
+  const timeoutMs = options?.timeoutMs ?? PANE_READY_TIMEOUT_MS;
+  const pollIntervalMs = options?.pollIntervalMs ?? PANE_READY_POLL_INTERVAL_MS;
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    let content = "";
+    try {
+      content = await mod.paneRead(paneId, { source: "visible" });
+    } catch (err) {
+      console.error(`[herdr-runner] failed to read pane ${paneId} while waiting for its prompt: ${err}`);
+    }
+    if (content.trim() !== "") return true;
+    if (Date.now() >= deadline) return false;
+    await sleep(pollIntervalMs);
+  }
+}
+async function waitForHerdrTask(paneId, options) {
+  const mod = options?.herdr ?? await loadHerdr();
+  const pollIntervalMs = options?.pollIntervalMs ?? AGENT_POLL_INTERVAL_MS;
+  let tracker = createCompletionTracker();
+  let sessionId;
+  for (; ; ) {
+    if (options?.signal?.aborted) {
+      return { status: "failed", output: "[worker] the worker is shutting down; the task was interrupted" };
+    }
+    let status;
+    try {
+      const agent = await mod.agentGet(paneId);
+      status = agent.agentStatus;
+      if (agent.sessionId) sessionId = agent.sessionId;
+    } catch (err) {
+      if (err instanceof mod.HerdrError && (err.code === "pane_not_found" || err.code === "agent_not_found")) {
+        return {
+          status: "failed",
+          output: "[worker] the claude agent disappeared before the task completed (claude died or the tab was closed)"
+        };
+      }
+      console.error(`[herdr-runner] failed to read agent status for pane ${paneId}: ${err}`);
+      await sleep(pollIntervalMs);
+      continue;
+    }
+    options?.onStatus?.(status);
+    const observed = observeAgentStatus(tracker, status);
+    tracker = observed.tracker;
+    if (observed.decision === "completed") {
+      const output = await readPaneOutput(paneId, mod);
+      const report = (options?.readReport ?? readFinalReport)(sessionId);
+      return buildHerdrTaskResult(output, { report });
+    }
+    if (observed.decision === "blocked-first-seen") {
+      options?.onBlocked?.();
+    }
+    await sleep(pollIntervalMs);
+  }
+}
+async function readPaneOutput(paneId, mod) {
+  try {
+    return await mod.paneRead(paneId, { source: "recent", lines: PANE_OUTPUT_LINES });
+  } catch (err) {
+    console.error(`[herdr-runner] failed to read pane ${paneId}: ${err}`);
+    return "";
+  }
+}
+var CLAUDE_EXIT_TIMEOUT_MS = 15 * 1e3;
+var CLAUDE_EXIT_POLL_INTERVAL_MS = 200;
+async function waitForAgentGone(paneId, mod, options) {
+  const timeoutMs = options?.timeoutMs ?? CLAUDE_EXIT_TIMEOUT_MS;
+  const pollIntervalMs = options?.pollIntervalMs ?? CLAUDE_EXIT_POLL_INTERVAL_MS;
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    try {
+      await mod.agentGet(paneId);
+    } catch (err) {
+      if (err instanceof mod.HerdrError && (err.code === "agent_not_found" || err.code === "pane_not_found")) {
+        return true;
+      }
+    }
+    if (Date.now() >= deadline) return false;
+    await sleep(pollIntervalMs);
+  }
+}
+async function stopHerdrTask(task, herdr, options) {
+  const mod = herdr ?? await loadHerdr();
+  try {
+    await mod.paneSendKeys(task.paneId, "ctrl+c", "ctrl+c");
+    const exited = await waitForAgentGone(task.paneId, mod, {
+      timeoutMs: options?.exitTimeoutMs,
+      pollIntervalMs: options?.exitPollIntervalMs
+    });
+    if (!exited) {
+      console.warn(
+        `[herdr-runner] claude did not exit in pane ${task.paneId} after ctrl-c, closing the tab forcefully`
+      );
+    }
+  } catch (err) {
+    console.error(`[herdr-runner] failed to send ctrl-c to pane ${task.paneId}: ${err}`);
+  }
+  try {
+    await mod.tabClose(task.tabId);
+  } catch (err) {
+    if (err instanceof mod.HerdrError && (err.code === "tab_not_found" || err.code === "pane_not_found")) return;
+    console.error(`[herdr-runner] failed to close tab ${task.tabId}: ${err}`);
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export {
+  AGENT_POLL_INTERVAL_MS,
+  CLAUDE_EXIT_POLL_INTERVAL_MS,
+  CLAUDE_EXIT_TIMEOUT_MS,
+  PANE_OUTPUT_LINES,
+  PANE_READY_POLL_INTERVAL_MS,
+  PANE_READY_TIMEOUT_MS,
+  PROMPT_ACCEPT_POLL_INTERVAL_MS,
+  PROMPT_ACCEPT_TIMEOUT_MS,
+  buildHerdrTaskResult,
+  createCompletionTracker,
+  extractCloudSessionId,
+  normalizePtyOutput,
+  observeAgentStatus,
+  startHerdrTask,
+  stopHerdrTask,
+  taskTabLabel,
+  toAgentName,
+  waitForHerdrTask,
+  waitForPaneReady
+};