claude-task-worker 0.123.0 → 0.124.0

package/dist/chunk-HFU27QHT.js

@@ -0,0 +1,579 @@
+// src/table.ts
+import { appendFileSync, chmodSync, mkdirSync } from "node:fs";
+import { dirname, join as join2, resolve as resolve3 } from "node:path";
+import { format } from "node:util";
+
+// src/dispatch-args.ts
+import { resolve } from "node:path";
+var FLAG_INCOMPATIBLE_COMMANDS = [
+  "init",
+  "apply-labels",
+  "install",
+  "update",
+  "cloud-setup",
+  "usage",
+  "version",
+  "list-workers"
+];
+function collectFlagValues(argv, flag) {
+  const values = [];
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] !== flag) continue;
+    const raw = argv[i + 1];
+    if (!raw || raw.startsWith("--")) {
+      console.error(`[dispatcher] ${flag} requires a value`);
+      process.exit(1);
+    }
+    values.push(raw);
+  }
+  return values;
+}
+function parseProjectFilters() {
+  return collectFlagValues(process.argv, "--project");
+}
+function hasProjectFilter() {
+  return process.argv.includes("--project");
+}
+function assertProjectCompatibleCommand(command) {
+  if (FLAG_INCOMPATIBLE_COMMANDS.includes(command)) {
+    console.error(`[dispatcher] --project cannot be used with the "${command}" command`);
+    process.exit(1);
+  }
+}
+var cachedCloudFlag;
+function hasCloudFlag() {
+  if (cachedCloudFlag === void 0) {
+    cachedCloudFlag = process.argv.includes("--cloud");
+  }
+  return cachedCloudFlag;
+}
+var cachedDebugFlag;
+function hasDebugFlag() {
+  if (cachedDebugFlag === void 0) {
+    cachedDebugFlag = process.argv.includes("--debug");
+  }
+  return cachedDebugFlag;
+}
+var INHERIT_CONFIG_FLAG = "--inherit-config";
+var cachedInheritConfigPath;
+function getInheritConfigPath() {
+  if (cachedInheritConfigPath === void 0) {
+    const values = collectFlagValues(process.argv, INHERIT_CONFIG_FLAG);
+    cachedInheritConfigPath = values.length > 0 ? resolve(values[values.length - 1]) : null;
+  }
+  return cachedInheritConfigPath;
+}
+function assertCloudCompatibleCommand(command) {
+  if (FLAG_INCOMPATIBLE_COMMANDS.includes(command)) {
+    console.error(`[worker] --cloud cannot be used with the "${command}" command`);
+    process.exit(1);
+  }
+}
+function shellQuote(value) {
+  if (value === "") return "''";
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function buildForwardedCommand(argv) {
+  const tokens = [];
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--project") {
+      i++;
+      continue;
+    }
+    if (argv[i] === INHERIT_CONFIG_FLAG && i + 1 < argv.length) {
+      tokens.push(argv[i], resolve(argv[i + 1]));
+      i++;
+      continue;
+    }
+    tokens.push(argv[i]);
+  }
+  return ["claude-task-worker", ...tokens.map(shellQuote)].join(" ");
+}
+
+// src/user-config.ts
+import { readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve as resolve2 } from "node:path";
+var RESERVED_ALL = "all";
+var DEFAULT_RUN_MODE = "default";
+var DEFAULT_ADVISOR_ENABLED = false;
+var PERMISSION_MODES = [
+  "manual",
+  "auto",
+  "acceptEdits",
+  "dontAsk",
+  "plan",
+  "bypassPermissions"
+];
+var DEFAULT_PERMISSION_MODE = "bypassPermissions";
+var UserConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UserConfigError";
+  }
+};
+function getConfigDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  const configHome = xdg && xdg.length > 0 ? xdg : join(homedir(), ".config");
+  return join(configHome, "claude-task-worker");
+}
+function getUserConfigPath() {
+  return join(getConfigDir(), "config.json");
+}
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function parseConfigFile(path) {
+  let content;
+  try {
+    content = readFileSync(path, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") return void 0;
+    throw err;
+  }
+  try {
+    return JSON.parse(content);
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      throw new UserConfigError(`config file contains invalid JSON: ${path}: ${err.message}`);
+    }
+    throw err;
+  }
+}
+function readRawConfig() {
+  return parseConfigFile(getUserConfigPath());
+}
+function parseMode(raw, path) {
+  if (!("mode" in raw)) return DEFAULT_RUN_MODE;
+  const value = raw["mode"];
+  if (value === "default" || value === "herdr") return value;
+  console.warn(`[config] invalid mode: ${JSON.stringify(value)} in ${path}, using "${DEFAULT_RUN_MODE}"`);
+  return DEFAULT_RUN_MODE;
+}
+function parseAdvisor(raw, path) {
+  if (!("advisor" in raw)) return DEFAULT_ADVISOR_ENABLED;
+  const value = raw["advisor"];
+  if (typeof value === "boolean") return value;
+  console.warn(`[config] invalid advisor: ${JSON.stringify(value)} in ${path}, using ${DEFAULT_ADVISOR_ENABLED}`);
+  return DEFAULT_ADVISOR_ENABLED;
+}
+function parsePermission(raw, path) {
+  if (!("permission" in raw)) return DEFAULT_PERMISSION_MODE;
+  const value = raw["permission"];
+  if (typeof value === "string" && PERMISSION_MODES.includes(value)) return value;
+  console.warn(`[config] invalid permission: ${JSON.stringify(value)} in ${path}, using "${DEFAULT_PERMISSION_MODE}"`);
+  return DEFAULT_PERMISSION_MODE;
+}
+function loadUserConfig() {
+  const path = getUserConfigPath();
+  const raw = readRawConfig();
+  if (raw === void 0) {
+    throw new UserConfigError(`config.json not found: ${path}`);
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new UserConfigError(`config.json must contain a JSON object: ${path}`);
+  }
+  if (!("projects" in raw) || typeof raw["projects"] !== "object" || raw["projects"] === null || Array.isArray(raw["projects"])) {
+    throw new UserConfigError(`config.json must contain a "projects" section as an object: ${path}`);
+  }
+  if ("projectGroups" in raw && (typeof raw["projectGroups"] !== "object" || raw["projectGroups"] === null || Array.isArray(raw["projectGroups"]))) {
+    throw new UserConfigError(`config.json "projectGroups" must be an object: ${path}`);
+  }
+  const mode = parseMode(raw, path);
+  const advisor = parseAdvisor(raw, path);
+  const permission = parsePermission(raw, path);
+  const rawProjects = raw["projects"];
+  const rawProjectGroups = "projectGroups" in raw ? raw["projectGroups"] : {};
+  const projectKeys = Object.keys(rawProjects);
+  const groupKeys = Object.keys(rawProjectGroups);
+  if (projectKeys.includes(RESERVED_ALL) || groupKeys.includes(RESERVED_ALL)) {
+    throw new UserConfigError(
+      `"${RESERVED_ALL}" is a reserved word and cannot be used as a key in "projects" or "projectGroups"`
+    );
+  }
+  const groupKeySet = new Set(groupKeys);
+  const duplicateKeys = projectKeys.filter((key) => groupKeySet.has(key));
+  if (duplicateKeys.length > 0) {
+    throw new UserConfigError(
+      `"projects" and "projectGroups" share the same key namespace; duplicate keys are not allowed: ${duplicateKeys.join(", ")}`
+    );
+  }
+  const projects = {};
+  for (const [name, value] of Object.entries(rawProjects)) {
+    if (name === "__proto__") {
+      throw new UserConfigError(`"__proto__" cannot be used as a key in "projects": ${path}`);
+    }
+    if (typeof value !== "string" || !isAbsolute(value)) {
+      console.warn(`[config] invalid projects.${name}: expected an absolute path, skipping`);
+      continue;
+    }
+    if (!isDirectory(value)) {
+      console.warn(`[config] projects.${name} does not exist as a directory: ${value}, skipping`);
+      continue;
+    }
+    projects[name] = value;
+  }
+  const projectGroups = {};
+  for (const [groupName, value] of Object.entries(rawProjectGroups)) {
+    if (groupName === "__proto__") {
+      throw new UserConfigError(`"__proto__" cannot be used as a key in "projectGroups": ${path}`);
+    }
+    if (!Array.isArray(value)) {
+      console.warn(`[config] invalid projectGroups.${groupName}: expected an array, skipping`);
+      continue;
+    }
+    const members = [];
+    for (const member of value) {
+      if (typeof member !== "string" || !Object.prototype.hasOwnProperty.call(projects, member)) {
+        console.warn(`[config] projectGroups.${groupName} references unknown project "${String(member)}", skipping`);
+        continue;
+      }
+      members.push(member);
+    }
+    projectGroups[groupName] = members;
+  }
+  return { mode, advisor, permission, projects, projectGroups };
+}
+var cachedRunMode;
+function getRunMode() {
+  if (cachedRunMode === void 0) {
+    cachedRunMode = readRunMode();
+  }
+  return cachedRunMode;
+}
+var cachedAdvisorEnabled;
+function isAdvisorEnabled() {
+  if (cachedAdvisorEnabled === void 0) {
+    cachedAdvisorEnabled = readAdvisorEnabled();
+  }
+  return cachedAdvisorEnabled;
+}
+var cachedPermissionMode;
+function getPermissionMode() {
+  if (cachedPermissionMode === void 0) {
+    cachedPermissionMode = readTopLevel(parsePermission, DEFAULT_PERMISSION_MODE, "permission");
+  }
+  return cachedPermissionMode;
+}
+function readTopLevel(parse, fallback, label) {
+  let raw;
+  try {
+    raw = readRawConfig();
+  } catch (err) {
+    console.warn(`[config] failed to read config file, using default ${label}: ${err}`);
+    return fallback;
+  }
+  if (raw === void 0) return fallback;
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return fallback;
+  }
+  return parse(raw, getUserConfigPath());
+}
+function readAdvisorEnabled() {
+  return readTopLevel(parseAdvisor, DEFAULT_ADVISOR_ENABLED, "advisor");
+}
+function readRunMode() {
+  return readTopLevel(parseMode, DEFAULT_RUN_MODE, "mode");
+}
+function findProjectNameByPath(path) {
+  let config;
+  try {
+    config = loadUserConfig();
+  } catch {
+    return void 0;
+  }
+  const target = resolve2(path);
+  for (const [name, projectPath] of Object.entries(config.projects)) {
+    if (resolve2(projectPath) === target) return name;
+  }
+  return void 0;
+}
+function resolveTargetProjects(requested, config) {
+  const resolved = /* @__PURE__ */ new Map();
+  for (const name of requested) {
+    if (name === RESERVED_ALL) {
+      for (const [projectName, projectPath] of Object.entries(config.projects)) {
+        resolved.set(projectName, { name: projectName, path: projectPath });
+      }
+      continue;
+    }
+    if (Object.prototype.hasOwnProperty.call(config.projects, name)) {
+      resolved.set(name, { name, path: config.projects[name] });
+      continue;
+    }
+    if (Object.prototype.hasOwnProperty.call(config.projectGroups, name)) {
+      for (const projectName of config.projectGroups[name]) {
+        const projectPath = config.projects[projectName];
+        if (projectPath === void 0) continue;
+        resolved.set(projectName, { name: projectName, path: projectPath });
+      }
+      continue;
+    }
+    const availableProjects = Object.keys(config.projects).join(", ") || "(none)";
+    const availableGroups = Object.keys(config.projectGroups).join(", ") || "(none)";
+    throw new UserConfigError(
+      `Unknown project or group: "${name}". Available projects: ${availableProjects}. Available groups: ${availableGroups}.`
+    );
+  }
+  const resolvedProjects = Array.from(resolved.values());
+  if (resolvedProjects.length === 0) {
+    throw new UserConfigError(`No projects resolved from requested targets: ${requested.join(", ")}`);
+  }
+  return resolvedProjects;
+}
+
+// src/table.ts
+function getDisplayWidth(str) {
+  let width = 0;
+  for (const char of str.replace(CONTROL_CHARS, "")) {
+    const code = char.codePointAt(0);
+    if (code >= 4352 && code <= 4447 || code >= 11904 && code <= 12350 || code >= 12352 && code <= 13247 || code >= 13312 && code <= 19903 || code >= 19968 && code <= 42191 || code >= 44032 && code <= 55215 || code >= 63744 && code <= 64255 || code >= 65072 && code <= 65135 || code >= 65281 && code <= 65376 || code >= 65504 && code <= 65510 || code >= 131072 && code <= 196605 || code >= 196608 && code <= 262141) {
+      width += 2;
+    } else {
+      width += 1;
+    }
+  }
+  return width;
+}
+function truncateToWidth(str, maxWidth) {
+  let width = 0;
+  let i = 0;
+  const chars = [...str];
+  while (i < chars.length) {
+    const charWidth = getDisplayWidth(chars[i]);
+    if (width + charWidth > maxWidth - 3) {
+      return chars.slice(0, i).join("") + "...";
+    }
+    width += charWidth;
+    i++;
+  }
+  return str;
+}
+function wrapToWidth(str, maxWidth) {
+  const lines = [];
+  let current = "";
+  let width = 0;
+  for (const char of str) {
+    const charWidth = getDisplayWidth(char);
+    if (width + charWidth > maxWidth && current !== "") {
+      lines.push(current);
+      current = "";
+      width = 0;
+    }
+    current += char;
+    width += charWidth;
+  }
+  lines.push(current);
+  return lines;
+}
+function padToWidth(str, targetWidth) {
+  const currentWidth = getDisplayWidth(str);
+  const padding = targetWidth - currentWidth;
+  return padding > 0 ? str + " ".repeat(padding) : str;
+}
+var CLOUD_WORKTREE_LABEL = "\x1B[36m\u2601 running in cloud\x1B[0m";
+function formatDuration(start, end = /* @__PURE__ */ new Date()) {
+  const diffMs = end.getTime() - start.getTime();
+  const totalSeconds = Math.floor(diffMs / 1e3);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${minutes}m ${String(seconds).padStart(2, "0")}s`;
+}
+function formatTime(date) {
+  const h = String(date.getHours()).padStart(2, "0");
+  const m = String(date.getMinutes()).padStart(2, "0");
+  const s = String(date.getSeconds()).padStart(2, "0");
+  return `${h}:${m}:${s}`;
+}
+function renderBoxTable(headers, groups) {
+  const allRows = groups.flat();
+  const widths = headers.map(
+    (h, i) => Math.max(1, getDisplayWidth(h), ...allRows.map((r) => getDisplayWidth(r[i] ?? "")))
+  );
+  const border = (l, m, r) => `${l}${widths.map((w) => "\u2500".repeat(w + 2)).join(m)}${r}`;
+  const row = (cells) => `\u2502 ${cells.map((c, i) => padToWidth(c ?? "", widths[i])).join(" \u2502 ")} \u2502`;
+  const lines = [];
+  lines.push(border("\u250C", "\u252C", "\u2510"));
+  lines.push(row(headers));
+  lines.push(border("\u251C", "\u253C", "\u2524"));
+  const nonEmpty = groups.filter((g) => g.length > 0);
+  nonEmpty.forEach((group, gi) => {
+    if (gi > 0) lines.push(border("\u251C", "\u253C", "\u2524"));
+    for (const r of group) lines.push(row(r));
+  });
+  lines.push(border("\u2514", "\u2534", "\u2518"));
+  return lines;
+}
+var TASK_DISPLAY_LIMIT = 20;
+var LOG_DISPLAY_LIMIT = 20;
+function taskRecency(t) {
+  return (t.finishedAt ?? t.startedAt).getTime();
+}
+function selectRecentTasks(entries, limit = TASK_DISPLAY_LIMIT) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const e of entries) byId.set(e.id, e);
+  const unique = [...byId.values()];
+  const running = unique.filter((t) => t.status === "running").sort((a, b) => taskRecency(b) - taskRecency(a));
+  const finished = unique.filter((t) => t.status !== "running").sort((a, b) => taskRecency(b) - taskRecency(a));
+  return [...running, ...finished].slice(0, limit);
+}
+function buildTaskTableLines(entries, now = /* @__PURE__ */ new Date()) {
+  if (entries.length === 0) return [];
+  const runningTasks = entries.filter((t) => t.status === "running");
+  const finishedTasks = entries.filter((t) => t.status !== "running");
+  const maxTitleWidth = 40;
+  const maxPathWidth = 40;
+  const truncTitle = (s) => getDisplayWidth(s) > maxTitleWidth ? truncateToWidth(s, maxTitleWidth) : s;
+  const truncPath = (p) => p ? getDisplayWidth(p) > maxPathWidth ? truncateToWidth(p, maxPathWidth) : p : "";
+  const hasPath = entries.some((t) => truncPath(t.path) !== "");
+  const runningRows = runningTasks.map(
+    (t) => taskRow(
+      t,
+      truncTitle(t.title),
+      truncPath(t.path),
+      hasPath,
+      t.agentStatus ? `${t.status}:${t.agentStatus}` : t.status,
+      formatTime(t.startedAt),
+      formatDuration(t.startedAt, now)
+    )
+  );
+  const finishedRows = finishedTasks.map(
+    (t) => taskRow(
+      t,
+      truncTitle(t.title),
+      truncPath(t.path),
+      hasPath,
+      t.status,
+      formatTime(t.finishedAt ?? t.startedAt),
+      formatDuration(t.startedAt, t.finishedAt ?? now)
+    )
+  );
+  const headers = hasPath ? ["#", "Title", "Worker", "Worktree", "Status", "Time", "Duration"] : ["#", "Title", "Worker", "Status", "Time", "Duration"];
+  return renderBoxTable(headers, [runningRows, finishedRows]);
+}
+function taskRow(t, title, path, hasPath, status, time, duration) {
+  return hasPath ? [`#${t.id}`, title, t.workerName, path, status, time, duration] : [`#${t.id}`, title, t.workerName, status, time, duration];
+}
+var logLines = [];
+function pushLogLine(entry) {
+  if (entry.text.trim().length === 0) return;
+  if (logFileEnabled) appendLogFile(entry);
+  logLines.push(entry);
+  if (logLines.length > LOG_DISPLAY_LIMIT) {
+    logLines.splice(0, logLines.length - LOG_DISPLAY_LIMIT);
+  }
+}
+var logFileEnabled = false;
+function logFilePath(time) {
+  const y = time.getFullYear();
+  const m = String(time.getMonth() + 1).padStart(2, "0");
+  const d = String(time.getDate()).padStart(2, "0");
+  return join2(getConfigDir(), "logs", `${y}-${m}-${d}.log`);
+}
+function formatLogFileLine(entry) {
+  const id = entry.id === void 0 ? "-" : `#${entry.id}`;
+  return `${entry.time.toISOString()} ${resolve3(entry.path ?? ".")} ${id} ${entry.stream} ${entry.text.replace(CONTROL_CHARS, "")}
+`;
+}
+var securedLogPath;
+var logFileErrorReported = false;
+function appendLogFile(entry) {
+  try {
+    const path = logFilePath(entry.time);
+    if (path !== securedLogPath) {
+      mkdirSync(dirname(path), { recursive: true, mode: 448 });
+      chmodSync(dirname(path), 448);
+    }
+    appendFileSync(path, formatLogFileLine(entry), { mode: 384 });
+    if (path !== securedLogPath) {
+      chmodSync(path, 384);
+      securedLogPath = path;
+    }
+  } catch (err) {
+    if (logFileErrorReported) return;
+    logFileErrorReported = true;
+    rawError(`[log-file] failed to write debug log: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+var rawLog = console.log.bind(console);
+var rawClear = console.clear.bind(console);
+var rawError = console.error.bind(console);
+function writeScreen(lines) {
+  rawClear();
+  rawLog(lines.join("\n"));
+}
+var consoleCaptured = false;
+function captureConsole() {
+  if (consoleCaptured) return;
+  consoleCaptured = true;
+  logFileEnabled = hasDebugFlag();
+  process.on("exit", () => {
+    if (logLines.length > 0) rawLog(buildLogTableLines(logLines).join("\n"));
+  });
+  const streams = { log: "stdout", info: "stdout", warn: "stderr", error: "stderr" };
+  for (const [method, stream] of Object.entries(streams)) {
+    console[method] = (...args) => {
+      for (const line of format(...args).split("\n")) {
+        pushLogLine({ stream, text: line, time: /* @__PURE__ */ new Date() });
+      }
+    };
+  }
+}
+var CONTROL_CHARS = (
+  // eslint-disable-next-line no-control-regex -- ANSI/制御文字を意図的に対象にする
+  /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b\[[0-9;?]*[ -/]*[@-~]|[\x00-\x08\x0b-\x1f\x7f]/g
+);
+function sanitizeLogText(text) {
+  return text.replace(CONTROL_CHARS, " ").replace(/\t/g, " ");
+}
+function buildLogTableLines(entries) {
+  if (entries.length === 0) return [];
+  const maxTextWidth = 100;
+  const rows = [...entries].reverse().flatMap(
+    (e) => wrapToWidth(sanitizeLogText(e.text), maxTextWidth).map(
+      (chunk, i) => i === 0 ? [formatTime(e.time), e.id === void 0 ? "-" : `#${e.id}`, e.stream, chunk] : ["", "", "", chunk]
+    )
+  );
+  return renderBoxTable(["Time", "#", "Stream", "Log"], [rows]);
+}
+
+export {
+  parseProjectFilters,
+  hasProjectFilter,
+  assertProjectCompatibleCommand,
+  hasCloudFlag,
+  hasDebugFlag,
+  INHERIT_CONFIG_FLAG,
+  getInheritConfigPath,
+  assertCloudCompatibleCommand,
+  buildForwardedCommand,
+  DEFAULT_PERMISSION_MODE,
+  UserConfigError,
+  loadUserConfig,
+  getRunMode,
+  isAdvisorEnabled,
+  getPermissionMode,
+  findProjectNameByPath,
+  resolveTargetProjects,
+  getDisplayWidth,
+  truncateToWidth,
+  wrapToWidth,
+  padToWidth,
+  CLOUD_WORKTREE_LABEL,
+  TASK_DISPLAY_LIMIT,
+  LOG_DISPLAY_LIMIT,
+  selectRecentTasks,
+  buildTaskTableLines,
+  logLines,
+  pushLogLine,
+  logFilePath,
+  formatLogFileLine,
+  writeScreen,
+  captureConsole,
+  CONTROL_CHARS,
+  buildLogTableLines
+};