@matthugh1/conductor-cli 0.1.0 → 0.2.2

package/dist/daemon-GGOJDZDB.js

@@ -0,0 +1,598 @@
+#!/usr/bin/env node
+
+// ../../src/cli/daemon.ts
+function writeOut(text) {
+  process.stdout.write(text + "\n");
+}
+function writeErr(text) {
+  process.stderr.write(text + "\n");
+}
+function ts() {
+  return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+}
+function log(msg) {
+  writeOut(`[${ts()}] ${msg}`);
+}
+async function cmdDaemonCancel(projectRoot, projectName, jsonOutput, apiUrl, apiKey) {
+  const { existsSync, readFileSync, unlinkSync } = await import("fs");
+  const { join } = await import("path");
+  const { createDaemonClient } = await import("./daemon-client-BE64H437.js");
+  const resolvedUrl = apiUrl ?? process.env.CONDUCTOR_API_URL;
+  const client = createDaemonClient(resolvedUrl, apiKey);
+  let projectId;
+  try {
+    const project = projectName ? await client.resolveProject({ name: projectName }) : await client.resolveProject({ path: projectRoot });
+    projectId = project.id;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    writeErr(msg);
+    return 1;
+  }
+  const pidPath = join(projectRoot, ".conductor", `daemon-${projectId}.pid`);
+  if (!existsSync(pidPath)) {
+    if (jsonOutput) {
+      writeOut(JSON.stringify({ error: "No daemon running for this project." }));
+    } else {
+      writeErr("No daemon running for this project.");
+    }
+    return 1;
+  }
+  const pid = parseInt(readFileSync(pidPath, "utf8").trim(), 10);
+  if (!Number.isFinite(pid)) {
+    unlinkSync(pidPath);
+    writeErr("Stale PID file removed.");
+    return 1;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    if (jsonOutput) {
+      writeOut(JSON.stringify({ cancelled: true, pid }));
+    } else {
+      writeOut(`Sent shutdown signal to daemon (PID ${pid}).`);
+    }
+    return 0;
+  } catch {
+    unlinkSync(pidPath);
+    if (jsonOutput) {
+      writeOut(
+        JSON.stringify({ error: "Daemon process not found. Cleaned up stale PID file." })
+      );
+    } else {
+      writeErr("Daemon process not found. Cleaned up stale PID file.");
+    }
+    return 1;
+  }
+}
+async function cmdDaemon(opts) {
+  const { mkdirSync, writeFileSync, unlinkSync, existsSync, readFileSync } = await import("fs");
+  const { join } = await import("path");
+  const { createDaemonClient } = await import("./daemon-client-BE64H437.js");
+  const resolvedUrl = opts.apiUrl ?? process.env.CONDUCTOR_API_URL;
+  const client = createDaemonClient(resolvedUrl, opts.apiKey);
+  let projectPath;
+  let projectId;
+  try {
+    const { readProjectId } = await import("./cli-config-2ZDXUUQN.js");
+    const configProjectId = readProjectId();
+    if (configProjectId) {
+      projectId = configProjectId;
+      projectPath = opts.projectRoot;
+      log(`Using project ID from config: ${projectId}`);
+    } else if (opts.projectName) {
+      const project = await client.resolveProject({ name: opts.projectName });
+      projectId = project.id;
+      projectPath = project.path;
+    } else {
+      const project = await client.resolveProject({ path: opts.projectRoot });
+      projectId = project.id;
+      projectPath = project.path;
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    writeErr(msg);
+    return 1;
+  }
+  const conductorDir = join(projectPath, ".conductor");
+  mkdirSync(conductorDir, { recursive: true });
+  const pidPath = join(conductorDir, `daemon-${projectId}.pid`);
+  if (existsSync(pidPath)) {
+    const existingPid = parseInt(
+      readFileSync(pidPath, "utf8").trim(),
+      10
+    );
+    if (Number.isFinite(existingPid)) {
+      try {
+        process.kill(existingPid, 0);
+        writeErr(
+          `A daemon is already running for this project (PID ${existingPid}).`
+        );
+        writeErr("Run: conductor daemon cancel --project <name>");
+        return 1;
+      } catch {
+        log("Cleaned up stale PID file from a previous daemon.");
+        unlinkSync(pidPath);
+      }
+    } else {
+      unlinkSync(pidPath);
+    }
+  }
+  writeFileSync(pidPath, String(process.pid), "utf8");
+  let running = true;
+  const activeTasks = /* @__PURE__ */ new Map();
+  function runningCountForAgent(agentId) {
+    let count = 0;
+    for (const t of activeTasks.values()) {
+      if (t.agentId === agentId) count++;
+    }
+    return count;
+  }
+  const shutdown = () => {
+    log("Shutting down daemon gracefully...");
+    running = false;
+    for (const task of activeTasks.values()) {
+      task.cancel();
+    }
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  let fileConfig = {};
+  try {
+    const { readConfig } = await import("./cli-config-2ZDXUUQN.js");
+    const config = readConfig(projectPath);
+    fileConfig = config.daemon ?? {};
+  } catch {
+  }
+  const CLI_DEFAULTS = {
+    checkInterval: 3e4,
+    maxPerDay: 50,
+    maxConsecutiveFailures: 3,
+    timeout: 120,
+    maxConcurrent: 1,
+    skipPermissions: false
+  };
+  const daemonConfig = {
+    checkInterval: opts.checkInterval !== CLI_DEFAULTS.checkInterval ? opts.checkInterval : fileConfig.checkInterval ?? CLI_DEFAULTS.checkInterval,
+    maxPerDay: opts.maxPerDay !== CLI_DEFAULTS.maxPerDay ? opts.maxPerDay : fileConfig.maxPerDay ?? CLI_DEFAULTS.maxPerDay,
+    maxConsecutiveFailures: opts.maxConsecutiveFailures !== CLI_DEFAULTS.maxConsecutiveFailures ? opts.maxConsecutiveFailures : fileConfig.maxConsecutiveFailures ?? CLI_DEFAULTS.maxConsecutiveFailures,
+    timeout: opts.timeout !== CLI_DEFAULTS.timeout ? opts.timeout : fileConfig.timeout ?? CLI_DEFAULTS.timeout,
+    maxConcurrent: opts.maxConcurrent !== CLI_DEFAULTS.maxConcurrent ? opts.maxConcurrent : fileConfig.maxConcurrent ?? CLI_DEFAULTS.maxConcurrent,
+    useWorktree: !opts.noWorktree,
+    skipPermissions: opts.skipPermissions || (fileConfig.skipPermissions ?? false)
+  };
+  try {
+    await client.upsertHeartbeat({
+      projectId,
+      pid: process.pid,
+      state: "idle",
+      config: daemonConfig,
+      stats: { completedToday: 0, failedToday: 0 }
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    writeErr(`Failed to write initial heartbeat: ${msg}`);
+    unlinkSync(pidPath);
+    return 1;
+  }
+  try {
+    const purged = await client.purgeOldRuns(30);
+    if (purged > 0) {
+      log(`Cleaned up ${purged} daemon run(s) older than 30 days`);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log(`Warning: cleanup of old runs failed: ${msg}`);
+  }
+  log(`Daemon started for project: ${projectPath}`);
+  log(
+    `PID: ${process.pid} | Poll interval: ${daemonConfig.checkInterval}ms | Max per day: ${daemonConfig.maxPerDay} | Max concurrent: ${daemonConfig.maxConcurrent}`
+  );
+  const attemptedIds = /* @__PURE__ */ new Set();
+  let consecutiveFailures = 0;
+  let completedToday = 0;
+  let failedToday = 0;
+  async function sleepWithCheck(ms) {
+    const intervals = Math.ceil(ms / 1e3);
+    for (let i = 0; i < intervals && running; i++) {
+      await new Promise((r) => setTimeout(r, 1e3));
+    }
+  }
+  const heartbeatInterval = setInterval(async () => {
+    try {
+      const firstActive = activeTasks.values().next().value;
+      await client.upsertHeartbeat({
+        projectId,
+        pid: process.pid,
+        state: activeTasks.size > 0 ? "executing" : "idle",
+        currentDeliverableId: firstActive?.deliverableId ?? void 0,
+        currentRunId: firstActive?.runId,
+        config: daemonConfig,
+        stats: { completedToday, failedToday, activeCount: activeTasks.size }
+      });
+    } catch {
+    }
+  }, 3e4);
+  while (running) {
+    try {
+      if (consecutiveFailures >= daemonConfig.maxConsecutiveFailures) {
+        log(
+          `Stopping: ${consecutiveFailures} consecutive failures reached limit.`
+        );
+        break;
+      }
+      const freeSlots = daemonConfig.maxConcurrent - activeTasks.size;
+      if (freeSlots > 0) {
+        const todayCount = await client.getQuota(projectId);
+        if (todayCount >= daemonConfig.maxPerDay) {
+          log(
+            `Daily quota reached (${todayCount}/${daemonConfig.maxPerDay}). Waiting...`
+          );
+        } else {
+          await fillSlots(freeSlots, todayCount);
+        }
+      }
+      const firstActive = activeTasks.values().next().value;
+      await client.upsertHeartbeat({
+        projectId,
+        pid: process.pid,
+        state: activeTasks.size > 0 ? "executing" : "idle",
+        currentDeliverableId: firstActive?.deliverableId ?? void 0,
+        currentRunId: firstActive?.runId,
+        config: daemonConfig,
+        stats: { completedToday, failedToday, activeCount: activeTasks.size }
+      });
+      try {
+        const ingested = await client.ingestAutonomousDeliverables(
+          projectId,
+          projectPath
+        );
+        if (ingested > 0) {
+          log(`Ingested ${ingested} auto-generated task(s) into task backlog`);
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log(`Warning: auto-task ingestion failed: ${msg}`);
+      }
+      try {
+        const { routed, decisions } = await client.routePendingTasks(
+          projectId,
+          projectPath
+        );
+        for (const decision of decisions) {
+          log(
+            `Routed task "${decision.taskTitle}" to ${decision.agentName} (${decision.explanation.summary}; weight=${decision.explanation.weight}; load=${decision.explanation.activeQueuedCount})`
+          );
+        }
+        if (routed > 0) {
+          log(`Auto-routed ${routed} pending daemon task(s)`);
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log(`Warning: daemon task routing failed: ${msg}`);
+      }
+      if (activeTasks.size > 0) {
+        const taggedPromises = [...activeTasks.entries()].map(
+          ([id, task]) => task.promise.then((result) => ({ id, result }))
+        );
+        const sleepPromise = sleepWithCheck(daemonConfig.checkInterval).then(() => null);
+        const completed = await Promise.race([...taggedPromises, sleepPromise]);
+        if (completed !== null) {
+          await handleCompletion(completed.id, completed.result);
+        }
+      } else {
+        await sleepWithCheck(daemonConfig.checkInterval);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log(`Unexpected error in daemon loop: ${msg}`);
+      consecutiveFailures++;
+      failedToday++;
+      await sleepWithCheck(daemonConfig.checkInterval);
+    }
+  }
+  if (activeTasks.size > 0) {
+    log(`Waiting for ${activeTasks.size} active task(s) to finish...`);
+    const remaining = [...activeTasks.entries()].map(
+      ([id, task]) => task.promise.then((result) => ({ id, result }))
+    );
+    const results = await Promise.allSettled(remaining);
+    for (const r of results) {
+      if (r.status === "fulfilled") {
+        await handleCompletion(r.value.id, r.value.result);
+      }
+    }
+  }
+  clearInterval(heartbeatInterval);
+  log("Daemon stopped.");
+  try {
+    await client.clearHeartbeat(projectId);
+  } catch {
+  }
+  try {
+    unlinkSync(pidPath);
+  } catch {
+  }
+  return 0;
+  async function fillSlots(freeSlots, todayCount) {
+    let agents;
+    try {
+      agents = await client.listEnabledAgents(projectId);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log(`Failed to list agents: ${msg}`);
+      consecutiveFailures++;
+      failedToday++;
+      return;
+    }
+    if (agents.length === 0) return;
+    const activeInitiativeIds = new Set(
+      [...activeTasks.values()].map((t) => t.initiativeId).filter((id) => id !== null)
+    );
+    let globalSlotsRemaining = Math.min(freeSlots, daemonConfig.maxPerDay - todayCount);
+    for (const agent of agents) {
+      if (globalSlotsRemaining <= 0 || !running) break;
+      const agentRunning = runningCountForAgent(agent.id);
+      const agentCapacity = agent.maxConcurrent - agentRunning;
+      if (agentCapacity <= 0) continue;
+      const fetchLimit = Math.min(agentCapacity, globalSlotsRemaining);
+      let candidates;
+      try {
+        candidates = await client.getNextTasksForAgent(agent.id, fetchLimit);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log(`Failed to fetch tasks for agent "${agent.name}": ${msg}`);
+        continue;
+      }
+      for (const task of candidates) {
+        if (globalSlotsRemaining <= 0 || !running) break;
+        if (attemptedIds.has(task.id)) continue;
+        attemptedIds.add(task.id);
+        if (task.initiativeId !== null && activeInitiativeIds.has(task.initiativeId)) {
+          log(`Skipping "${task.title}" \u2014 another task from the same initiative is already running.`);
+          continue;
+        }
+        if (task.type === "deliverable" && task.deliverableId) {
+          try {
+            const delivDetail = await client.getDeliverableDetail(task.deliverableId);
+            if (delivDetail && ["feature", "enhancement", "refactor"].includes(delivDetail.type ?? "feature") && !delivDetail.prompt) {
+              log(`Skipping "${task.title}" \u2014 deliverable needs an implementation brief (prompt).`);
+              continue;
+            }
+          } catch {
+          }
+        }
+        let claimed;
+        try {
+          claimed = await client.claimTask(task.id);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          log(`Failed to claim task "${task.title}": ${msg}`);
+          continue;
+        }
+        if (!claimed) {
+          continue;
+        }
+        const spawned = await spawnAgentTask(claimed, agent);
+        if (spawned) {
+          globalSlotsRemaining--;
+          if (task.initiativeId !== null) {
+            activeInitiativeIds.add(task.initiativeId);
+          }
+        }
+      }
+    }
+  }
+  async function spawnAgentTask(task, agent) {
+    let worktreePath = null;
+    let initiativeTitle = null;
+    if (task.initiativeId) {
+      try {
+        const init = task.deliverableId ? await client.getInitiativeForDeliverable(task.deliverableId) : null;
+        initiativeTitle = init?.initiativeTitle ?? null;
+      } catch {
+      }
+    }
+    if (daemonConfig.useWorktree && task.initiativeId) {
+      try {
+        const {
+          createWorktree,
+          getWorktreeForInitiative
+        } = await import("./worktree-manager-2ZUJEL3L.js");
+        const existing = await getWorktreeForInitiative(projectId, task.initiativeId);
+        if (existing) {
+          worktreePath = existing.worktreePath;
+          log(`Reusing existing worktree at ${worktreePath}`);
+        } else {
+          const wt = await createWorktree(
+            projectId,
+            projectPath,
+            task.initiativeId,
+            initiativeTitle ?? "unknown"
+          );
+          worktreePath = wt.worktreePath;
+          log(`Created worktree for "${initiativeTitle}" at ${worktreePath}`);
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log(`Worktree setup failed: ${msg}`);
+        if (task.deliverableId) {
+          log("Skipping \u2014 useWorktree is enabled. Refusing to run in main repo without isolation.");
+          consecutiveFailures++;
+          failedToday++;
+          return false;
+        }
+      }
+    } else if (daemonConfig.useWorktree && task.deliverableId && !task.initiativeId) {
+      log(`Skipping "${task.title}" \u2014 useWorktree is enabled but no initiative set. Refusing to run without isolation.`);
+      consecutiveFailures++;
+      failedToday++;
+      return false;
+    }
+    const agentCwd = worktreePath ?? projectPath;
+    let run;
+    try {
+      run = await client.createRun({
+        projectId,
+        deliverableId: task.deliverableId ?? task.id,
+        pid: process.pid,
+        worktreePath: worktreePath ?? void 0
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log(`Failed to create daemon run record: ${msg}`);
+      consecutiveFailures++;
+      failedToday++;
+      return false;
+    }
+    try {
+      await client.updateTask(task.id, { status: "running", runId: run.id });
+    } catch {
+    }
+    const { readFile } = await import("fs/promises");
+    const { join: join2 } = await import("path");
+    let claudeMd = "";
+    try {
+      claudeMd = await readFile(join2(agentCwd, "CLAUDE.md"), "utf8");
+    } catch {
+    }
+    const { assembleTaskPrompt } = await import("./runner-prompt-MOOPKA5P.js");
+    const assembledPrompt = assembleTaskPrompt(
+      { name: agent.name, systemPrompt: agent.systemPrompt },
+      {
+        title: task.title,
+        prompt: task.prompt,
+        deliverableId: task.deliverableId,
+        projectName: projectPath
+      },
+      claudeMd
+    );
+    log(
+      `Spawning "${agent.name}" for: "${task.title}"${worktreePath ? ` (worktree: ${worktreePath})` : ""} [${activeTasks.size + 1}/${daemonConfig.maxConcurrent} slots]`
+    );
+    const { spawnAgent } = await import("./agent-spawner-BNOGEYDK.js");
+    const spawned = spawnAgent({
+      item: {
+        priority: task.priority,
+        tier: "active",
+        type: "deliverable",
+        title: task.title,
+        reason: `Agent task: ${task.title}`,
+        action: "Execute task",
+        agentRole: agent.role ?? "implementation-engineer",
+        entityId: task.deliverableId ?? task.id,
+        entityType: "deliverable"
+      },
+      projectRoot: agentCwd,
+      runId: run.id,
+      projectId,
+      deliverableId: task.deliverableId ?? void 0,
+      timeoutMs: daemonConfig.timeout * 6e4,
+      client,
+      assembledPrompt,
+      modelOverride: agent.model !== "claude-sonnet-4-20250514" ? agent.model : void 0,
+      skipPermissions: daemonConfig.skipPermissions,
+      onLine: (stream, line) => {
+        if (stream === "stderr") {
+          writeErr(line);
+        }
+      }
+    });
+    if (spawned.pid !== null) {
+      try {
+        await client.updateRunPid(run.id, spawned.pid);
+      } catch {
+      }
+    }
+    activeTasks.set(task.id, {
+      promise: spawned.done,
+      cancel: spawned.cancel,
+      taskId: task.id,
+      runId: run.id,
+      agentId: agent.id,
+      agentName: agent.name,
+      deliverableId: task.deliverableId,
+      initiativeId: task.initiativeId,
+      worktreePath,
+      title: task.title
+    });
+    log(
+      `Picked: "${task.title}" (P${task.priority}) \u2192 agent "${agent.name}"${initiativeTitle ? ` [${initiativeTitle}]` : ""}`
+    );
+    return true;
+  }
+  async function handleCompletion(taskId, result) {
+    const task = activeTasks.get(taskId);
+    if (!task) return;
+    activeTasks.delete(taskId);
+    log(
+      `Agent "${task.agentName}" finished: ${result.outcome} (exit ${result.exitCode ?? "n/a"}, ${result.lineCount} lines, ${Math.round(result.durationMs / 1e3)}s)`
+    );
+    try {
+      await client.completeRun(task.runId, {
+        status: result.outcome === "completed" ? "completed" : result.outcome === "timeout" ? "timeout" : result.outcome === "cancelled" ? "cancelled" : "failed",
+        exitCode: result.exitCode ?? void 0,
+        errorMessage: result.errorMessage
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log(`Failed to update daemon run: ${msg}`);
+    }
+    if (result.outcome === "completed") {
+      log(`Completed: "${task.title}" (agent: ${task.agentName})`);
+      consecutiveFailures = 0;
+      completedToday++;
+      try {
+        await client.updateTask(task.taskId, {
+          status: "completed",
+          result: `Completed successfully in ${Math.round(result.durationMs / 1e3)}s`
+        });
+      } catch {
+      }
+      if (task.worktreePath) {
+        log(`Worktree preserved at ${task.worktreePath} for reuse by next task.`);
+      }
+    } else if (result.outcome === "cancelled") {
+      log(`Cancelled: "${task.title}" (agent: ${task.agentName})`);
+      failedToday++;
+      try {
+        await client.updateTask(task.taskId, { status: "cancelled" });
+      } catch {
+      }
+      if (task.deliverableId) {
+        try {
+          await client.updateDeliverableStatus(task.deliverableId, "parked");
+        } catch {
+        }
+      }
+      if (task.worktreePath) {
+        log(`Worktree preserved at ${task.worktreePath} for debugging`);
+      }
+    } else {
+      const reason = result.errorMessage ?? `exit ${result.exitCode}`;
+      log(
+        `${result.outcome === "timeout" ? "Timed out" : "Failed"}: "${task.title}" (agent: ${task.agentName}) \u2014 ${reason}`
+      );
+      consecutiveFailures++;
+      failedToday++;
+      try {
+        await client.updateTask(task.taskId, {
+          status: "failed",
+          errorMessage: reason
+        });
+      } catch {
+      }
+      if (task.deliverableId) {
+        try {
+          await client.updateDeliverableStatus(task.deliverableId, "parked");
+        } catch {
+        }
+      }
+      if (task.worktreePath) {
+        log(`Worktree preserved at ${task.worktreePath} for debugging`);
+      }
+    }
+  }
+}
+export {
+  cmdDaemon,
+  cmdDaemonCancel
+};