sisyphi 0.1.5 → 0.1.6

package/dist/daemon.js

@@ -20,12 +20,13 @@ import {
 } from "./chunk-N2BPQOO2.js";
 
 // src/daemon/index.ts
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync5, unlinkSync as unlinkSync2, existsSync as existsSync6 } from "fs";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync5, unlinkSync as unlinkSync2, existsSync as existsSync6 } from "fs";
+import { setTimeout as sleep } from "timers/promises";
 
 // src/shared/config.ts
 import { readFileSync } from "fs";
 var DEFAULT_CONFIG = {
-  pollIntervalMs: 1e3
+  pollIntervalMs: 5e3
 };
 function readJsonFile(filePath) {
   try {
@@ -43,7 +44,7 @@ function loadConfig(cwd) {
 
 // src/daemon/server.ts
 import { createServer } from "net";
-import { unlinkSync, existsSync as existsSync5, writeFileSync as writeFileSync4, readFileSync as readFileSync7, mkdirSync as mkdirSync4 } from "fs";
+import { unlinkSync, existsSync as existsSync5, writeFileSync as writeFileSync4, readFileSync as readFileSync8, mkdirSync as mkdirSync4 } from "fs";
 import { join as join4 } from "path";
 
 // src/daemon/session-manager.ts
@@ -70,16 +71,16 @@ description: >
 var sessionLocks = /* @__PURE__ */ new Map();
 async function withSessionLock(sessionId, fn) {
   const prev = sessionLocks.get(sessionId) ?? Promise.resolve();
-  let resolve3;
+  let resolve4;
   const next = new Promise((r) => {
-    resolve3 = r;
+    resolve4 = r;
   });
   sessionLocks.set(sessionId, next);
   await prev;
   try {
     return fn();
   } finally {
-    resolve3();
+    resolve4();
   }
 }
 function atomicWrite(filePath, data) {
@@ -328,6 +329,33 @@ function shellQuote(s) {
   return `'${s.replace(/'/g, "'\\''")}'`;
 }
 
+// src/daemon/pane-registry.ts
+var paneMap = /* @__PURE__ */ new Map();
+function registerPane(paneId, sessionId, role, agentId) {
+  paneMap.set(paneId, { sessionId, role, agentId });
+}
+function unregisterPane(paneId) {
+  paneMap.delete(paneId);
+}
+function unregisterAgentPane(sessionId, agentId) {
+  for (const [paneId, entry] of paneMap) {
+    if (entry.sessionId === sessionId && entry.agentId === agentId) {
+      paneMap.delete(paneId);
+      return;
+    }
+  }
+}
+function unregisterSessionPanes(sessionId) {
+  for (const [paneId, entry] of paneMap) {
+    if (entry.sessionId === sessionId) {
+      paneMap.delete(paneId);
+    }
+  }
+}
+function lookupPane(paneId) {
+  return paneMap.get(paneId);
+}
+
 // src/daemon/orchestrator.ts
 var sessionWindowMap = /* @__PURE__ */ new Map();
 var sessionOrchestratorPane = /* @__PURE__ */ new Map();
@@ -462,11 +490,13 @@ Review the current session and delegate the next cycle of work.`;
   const claudeCmd = `claude --dangerously-skip-permissions --settings "${settingsPath}" --plugin-dir "${pluginPath}" --append-system-prompt "$(cat '${promptFilePath}')" "$(cat '${userPromptFilePath}')"`;
   const paneId = createPane(windowId, cwd);
   sessionOrchestratorPane.set(sessionId, paneId);
+  registerPane(paneId, sessionId, "orchestrator");
   setPaneTitle(paneId, `orchestrator (${sessionId.slice(0, 8)})`);
   setPaneStyle(paneId, ORCHESTRATOR_COLOR);
   const bannerPath = resolve(import.meta.dirname, "../templates/banner.txt");
   const bannerCmd = existsSync(bannerPath) ? `cat '${bannerPath}' &&` : "";
-  sendKeys(paneId, `${bannerCmd} ${envExports} && ${claudeCmd}`);
+  const notifyCmd = `sisyphus notify pane-exited --pane-id ${paneId}`;
+  sendKeys(paneId, `${bannerCmd} ${envExports} && ${claudeCmd}; ${notifyCmd}`);
   await addOrchestratorCycle(cwd, sessionId, {
     cycle: cycleNum,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -485,6 +515,7 @@ async function handleOrchestratorYield(sessionId, cwd, nextPrompt) {
   const paneId = resolveOrchestratorPane(sessionId, cwd);
   if (paneId) {
     killPane(paneId);
+    unregisterPane(paneId);
     sessionOrchestratorPane.delete(sessionId);
   }
   const windowId = sessionWindowMap.get(sessionId);
@@ -504,6 +535,7 @@ async function handleOrchestratorComplete(sessionId, cwd, report) {
 function cleanupSessionMaps(sessionId) {
   sessionOrchestratorPane.delete(sessionId);
   sessionWindowMap.delete(sessionId);
+  unregisterSessionPanes(sessionId);
 }
 
 // src/daemon/agent.ts
@@ -712,6 +744,7 @@ async function spawnAgent(opts) {
     worktreeContext = { offset: portOffset, total: portOffset, branchName };
   }
   const paneId = createPane(windowId, paneCwd);
+  registerPane(paneId, sessionId, "agent", agentId);
   setPaneTitle(paneId, `${name} (${agentId})`);
   setPaneStyle(paneId, color);
   const suffix = renderAgentSuffix(sessionId, instruction, worktreeContext);
@@ -726,7 +759,8 @@ async function spawnAgent(opts) {
   ].join(" && ");
   const agentFlag = agentType ? ` --agent ${shellQuote3(agentType)}` : "";
   const claudeCmd = `claude --dangerously-skip-permissions --plugin-dir "${pluginPath}"${agentFlag} --append-system-prompt "$(cat '${suffixFilePath}')" ${shellQuote3(instruction)}`;
-  const fullCmd = `${bannerCmd} ${envExports} && ${claudeCmd}`;
+  const notifyCmd = `sisyphus notify pane-exited --pane-id ${paneId}`;
+  const fullCmd = `${bannerCmd} ${envExports} && ${claudeCmd}; ${notifyCmd}`;
   const agent = {
     id: agentId,
     name,
@@ -804,6 +838,7 @@ async function handleAgentSubmit(cwd, sessionId, agentId, report) {
   const agentArr = session.agents;
   const agent = agentArr.slice().reverse().find((a) => a.id === agentId);
   if (agent) {
+    unregisterPane(agent.paneId);
     killPane(agent.paneId);
   }
   const windowId = getWindowId(sessionId);
@@ -811,6 +846,7 @@ async function handleAgentSubmit(cwd, sessionId, agentId, report) {
   return allAgentsDone(session);
 }
 async function handleAgentKilled(cwd, sessionId, agentId, reason) {
+  unregisterAgentPane(sessionId, agentId);
   await updateAgent(cwd, sessionId, agentId, {
     status: "killed",
     killedReason: reason,
@@ -833,7 +869,7 @@ var onAllAgentsDone = null;
 function setRespawnCallback(cb) {
   onAllAgentsDone = cb;
 }
-function startMonitor(pollIntervalMs = 1e3) {
+function startMonitor(pollIntervalMs = 5e3) {
   if (monitorInterval) return;
   monitorInterval = setInterval(() => {
     pollAllSessions().catch((err) => {
@@ -922,8 +958,85 @@ async function pollSession(sessionId, cwd, windowId) {
   }
 }
 
+// src/daemon/updater.ts
+import { execSync as execSync3 } from "child_process";
+import { readFileSync as readFileSync7 } from "fs";
+import { resolve as resolve3 } from "path";
+import { get } from "https";
+function readPackageVersion() {
+  for (const rel of ["../package.json", "../../package.json"]) {
+    try {
+      const raw = readFileSync7(resolve3(import.meta.dirname, rel), "utf-8");
+      const pkg = JSON.parse(raw);
+      if (pkg.name === "sisyphi" && pkg.version) return pkg.version;
+    } catch {
+    }
+  }
+  return "0.0.0";
+}
+var currentVersion = readPackageVersion();
+function checkForUpdate() {
+  return new Promise((resolve4) => {
+    const timeout = setTimeout(() => {
+      resolve4(null);
+    }, 5e3);
+    const req = get("https://registry.npmjs.org/sisyphi/latest", (res) => {
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk.toString();
+      });
+      res.on("end", () => {
+        clearTimeout(timeout);
+        try {
+          const { version: latest } = JSON.parse(data);
+          if (latest && latest !== currentVersion) {
+            resolve4({ current: currentVersion, latest });
+          } else {
+            resolve4(null);
+          }
+        } catch {
+          resolve4(null);
+        }
+      });
+    });
+    req.on("error", () => {
+      clearTimeout(timeout);
+      resolve4(null);
+    });
+  });
+}
+function applyUpdate() {
+  try {
+    const nodeDir = resolve3(process.execPath, "..");
+    const env = { ...process.env, PATH: `${nodeDir}:${process.env.PATH ?? ""}` };
+    execSync3("npm install -g sisyphi", { timeout: 15e3, stdio: "pipe", env });
+    return true;
+  } catch (err) {
+    console.error("[sisyphus] Auto-update failed:", err);
+    return false;
+  }
+}
+async function checkAndApply() {
+  try {
+    const update = await checkForUpdate();
+    if (!update) return;
+    console.log(`[sisyphus] Update available: ${update.current} \u2192 ${update.latest}`);
+    const success = applyUpdate();
+    if (success) {
+      console.log(`[sisyphus] Updated to ${update.latest}, restarting daemon...`);
+      process.exit(0);
+    }
+  } catch (err) {
+    console.error("[sisyphus] Auto-update check failed:", err);
+  }
+}
+
 // src/daemon/session-manager.ts
 async function startSession(task, cwd, tmuxSession, windowId) {
+  const config = loadConfig(cwd);
+  if (config.autoUpdate !== false) {
+    await checkAndApply();
+  }
   const sessionId = uuidv4();
   const session = createSession(sessionId, task, cwd);
   await updateSessionTmux(cwd, sessionId, tmuxSession, windowId);
@@ -1042,10 +1155,10 @@ function onAllAgentsDone2(sessionId, cwd, windowId) {
       }).catch((err) => console.error(`[sisyphus] Failed to update merge status for ${result.agentId}:`, err));
     }
   }
-  setTimeout(() => {
+  setImmediate(() => {
     pendingRespawns.delete(sessionId);
     spawnOrchestrator(sessionId, cwd, windowId).then(() => updateTrackedWindow(sessionId, windowId)).catch((err) => console.error(`[sisyphus] Failed to respawn orchestrator for session ${sessionId}:`, err));
-  }, 2e3);
+  });
 }
 async function handleSpawn(sessionId, cwd, agentType, name, instruction, worktree) {
   const windowId = getWindowId(sessionId);
@@ -1117,12 +1230,40 @@ async function handleKill(sessionId, cwd) {
   }
   await updateSessionStatus(cwd, sessionId, "completed");
   untrackSession(sessionId);
+  unregisterSessionPanes(sessionId);
   if (windowId) {
     killWindow(windowId);
   }
   clearAgentCounter(sessionId);
   return killedAgents;
 }
+async function handlePaneExited(paneId, cwd, sessionId, role, agentId) {
+  const session = getSession(cwd, sessionId);
+  if (session.status !== "active") return;
+  if (role === "agent" && agentId) {
+    const agent = session.agents.find((a) => a.id === agentId);
+    if (!agent || agent.status !== "running") return;
+    const allDone = await handleAgentKilled(cwd, sessionId, agentId, "pane exited");
+    if (allDone) {
+      const windowId = getWindowId(sessionId);
+      if (windowId) {
+        onAllAgentsDone2(sessionId, cwd, windowId);
+      }
+    }
+  } else if (role === "orchestrator") {
+    const hasRunningAgents = session.agents.some((a) => a.status === "running");
+    if (!hasRunningAgents && session.agents.length > 0) {
+      const windowId = getWindowId(sessionId);
+      if (windowId) {
+        console.log(`[sisyphus] Orchestrator pane exited for session ${sessionId}, all agents done \u2014 triggering respawn`);
+        onAllAgentsDone2(sessionId, cwd, windowId);
+      }
+    } else if (!hasRunningAgents) {
+      await updateSessionStatus(cwd, sessionId, "paused");
+      console.log(`[sisyphus] Session ${sessionId} paused: orchestrator pane exited with no agents`);
+    }
+  }
+}
 
 // src/daemon/server.ts
 var server = null;
@@ -1145,7 +1286,7 @@ function loadSessionRegistry() {
   const p = registryPath();
   if (!existsSync5(p)) return {};
   try {
-    return JSON.parse(readFileSync7(p, "utf-8"));
+    return JSON.parse(readFileSync8(p, "utf-8"));
   } catch {
     return {};
   }
@@ -1267,6 +1408,18 @@ async function handleRequest(req) {
         persistSessionRegistry();
         return { ok: true, data: { killedAgents, sessionId: req.sessionId } };
       }
+      case "pane-exited": {
+        const entry = lookupPane(req.paneId);
+        if (!entry) return { ok: true };
+        const cwd = sessionCwdMap.get(entry.sessionId);
+        if (!cwd) {
+          unregisterPane(req.paneId);
+          return { ok: true };
+        }
+        unregisterPane(req.paneId);
+        await handlePaneExited(req.paneId, cwd, entry.sessionId, entry.role, entry.agentId);
+        return { ok: true };
+      }
       default:
         return { ok: false, error: `Unknown request type: ${req.type}` };
     }
@@ -1276,7 +1429,7 @@ async function handleRequest(req) {
   }
 }
 function startServer() {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const sock = socketPath();
     if (existsSync5(sock)) {
       unlinkSync(sock);
@@ -1308,14 +1461,14 @@ function startServer() {
     server.on("error", reject);
     server.listen(sock, () => {
       console.log(`[sisyphus] Daemon listening on ${sock}`);
-      resolve3(server);
+      resolve4(server);
     });
   });
 }
 function stopServer() {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     if (!server) {
-      resolve3();
+      resolve4();
       return;
     }
     server.close(() => {
@@ -1324,7 +1477,7 @@ function stopServer() {
         unlinkSync(sock);
       }
       server = null;
-      resolve3();
+      resolve4();
     });
   });
 }
@@ -1344,7 +1497,7 @@ function isProcessAlive(pid) {
 function readPid() {
   const pidFile = daemonPidPath();
   try {
-    const pid = parseInt(readFileSync8(pidFile, "utf-8").trim(), 10);
+    const pid = parseInt(readFileSync9(pidFile, "utf-8").trim(), 10);
     return pid && isProcessAlive(pid) ? pid : null;
   } catch {
     return null;
@@ -1411,7 +1564,7 @@ async function recoverSessions() {
       continue;
     }
     try {
-      const session = JSON.parse(readFileSync8(stateFile, "utf-8"));
+      const session = JSON.parse(readFileSync9(stateFile, "utf-8"));
       if (session.status === "active" || session.status === "paused") {
         registerSessionCwd(sessionId, cwd);
         resetAgentCounterFromState(sessionId, session.agents ?? []);
@@ -1425,6 +1578,18 @@ async function recoverSessions() {
             const lastIncompleteCycle = [...session.orchestratorCycles].reverse().find((c) => !c.completedAt && c.paneId);
             if (lastIncompleteCycle?.paneId) {
               setOrchestratorPaneId(sessionId, lastIncompleteCycle.paneId);
+              const livePaneIds = new Set(livePanes.map((p) => p.paneId));
+              if (livePaneIds.has(lastIncompleteCycle.paneId)) {
+                registerPane(lastIncompleteCycle.paneId, sessionId, "orchestrator");
+              }
+            }
+            for (const agent of session.agents) {
+              if (agent.status === "running" && agent.paneId) {
+                const livePaneIds = new Set(livePanes.map((p) => p.paneId));
+                if (livePaneIds.has(agent.paneId)) {
+                  registerPane(agent.paneId, sessionId, "agent", agent.id);
+                }
+              }
             }
             console.log(`[sisyphus] Reconnected session ${sessionId} to tmux window ${session.tmuxWindowId}`);
             if (session.status === "active" && session.agents.length > 0) {
@@ -1474,47 +1639,44 @@ async function startDaemon() {
   process.on("SIGINT", shutdown);
 }
 var command = process.argv[2];
-switch (command) {
-  case "stop":
-    stopDaemon();
-    break;
-  case "restart": {
-    stopDaemon();
-    const wait = Date.now() + 500;
-    while (Date.now() < wait) {
-    }
-    const respawnedPid = readPid();
-    if (respawnedPid) {
-      console.log(`[sisyphus] Daemon restarted (pid ${respawnedPid}) by process manager`);
+(async () => {
+  switch (command) {
+    case "stop":
+      stopDaemon();
+      break;
+    case "restart": {
+      stopDaemon();
+      await sleep(500);
+      const respawnedPid = readPid();
+      if (respawnedPid) {
+        console.log(`[sisyphus] Daemon restarted (pid ${respawnedPid}) by process manager`);
+        break;
+      }
+      await startDaemon();
       break;
     }
-    startDaemon().catch((err) => {
-      console.error("[sisyphus] Fatal error:", err);
+    case "start":
+    case void 0:
+      await startDaemon();
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+      console.log("Usage: sisyphusd [command]");
+      console.log("");
+      console.log("Commands:");
+      console.log("  start     Start the daemon (default if no command given)");
+      console.log("  stop      Stop the running daemon");
+      console.log("  restart   Stop and restart the daemon");
+      console.log("  help      Show this help message");
+      break;
+    default:
+      console.error(`[sisyphus] Unknown command: ${command}`);
+      console.error("Usage: sisyphusd [start|stop|restart|help]");
       process.exit(1);
-    });
-    break;
   }
-  case "start":
-  case void 0:
-    startDaemon().catch((err) => {
-      console.error("[sisyphus] Fatal error:", err);
-      process.exit(1);
-    });
-    break;
-  case "help":
-  case "--help":
-  case "-h":
-    console.log("Usage: sisyphusd [command]");
-    console.log("");
-    console.log("Commands:");
-    console.log("  start     Start the daemon (default if no command given)");
-    console.log("  stop      Stop the running daemon");
-    console.log("  restart   Stop and restart the daemon");
-    console.log("  help      Show this help message");
-    break;
-  default:
-    console.error(`[sisyphus] Unknown command: ${command}`);
-    console.error("Usage: sisyphusd [start|stop|restart|help]");
-    process.exit(1);
-}
+})().catch((err) => {
+  console.error("[sisyphus] Fatal error:", err);
+  process.exit(1);
+});
 //# sourceMappingURL=daemon.js.map