quadwork 0.1.2 → 1.0.0

package/server/index.js

@@ -5,9 +5,10 @@ const fs = require("fs");
 const { WebSocketServer } = require("ws");
 const pty = require("node-pty");
 const { spawn } = require("child_process");
-const { readConfig, resolveAgentCwd, resolveAgentCommand } = require("./config");
+const { readConfig, resolveAgentCwd, resolveAgentCommand, resolveProjectChattr, syncChattrToken } = require("./config");
 const routes = require("./routes");
 
+const net = require("net");
 const config = readConfig();
 const PORT = config.port || 8400;
 
@@ -25,13 +26,110 @@ app.get("/api/health", (_req, res) => {
   res.json({ status: "ok" });
 });
 
+// --- CLI status detection ---
+
+const { execSync } = require("child_process");
+
+function isCliInstalled(cmd) {
+  try {
+    execSync(`which ${cmd}`, { encoding: "utf-8", stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+app.get("/api/cli-status", (_req, res) => {
+  res.json({
+    claude: isCliInstalled("claude"),
+    codex: isCliInstalled("codex"),
+  });
+});
+
+// --- Port availability check ---
+
+function checkPort(port) {
+  return new Promise((resolve) => {
+    const srv = net.createServer();
+    srv.once("error", () => resolve(false));
+    srv.once("listening", () => { srv.close(); resolve(true); });
+    srv.listen(port, "127.0.0.1");
+  });
+}
+
+app.get("/api/port-check", async (req, res) => {
+  const port = parseInt(req.query.port, 10);
+  if (!port || port < 1 || port > 65535) {
+    return res.status(400).json({ error: "Invalid port" });
+  }
+  const free = await checkPort(port);
+  res.json({ port, free });
+});
+
+app.get("/api/port-check/auto", async (req, res) => {
+  const start = parseInt(req.query.start, 10) || 8300;
+  const count = Math.min(parseInt(req.query.count, 10) || 3, 10);
+  const results = [];
+  let port = start;
+  for (let i = 0; i < count; i++) {
+    while (!(await checkPort(port)) && port < 65535) port++;
+    results.push(port);
+    port++;
+  }
+  res.json({ ports: results });
+});
+
+// --- Caffeinate (sleep prevention) ---
+
+let caffeinateProcess = { process: null, pid: null, startedAt: null, duration: null };
+
+app.post("/api/caffeinate/start", (req, res) => {
+  if (process.platform !== "darwin") {
+    return res.status(400).json({ ok: false, error: "Sleep prevention is only available on macOS" });
+  }
+  // Kill existing if running
+  if (caffeinateProcess.process) {
+    try { caffeinateProcess.process.kill("SIGTERM"); } catch {}
+  }
+  const duration = req.body?.duration || 0; // seconds, 0 = indefinite
+  const args = ["-d", "-i", "-s"];
+  if (duration > 0) args.push("-t", String(duration));
+  const child = spawn("caffeinate", args, { stdio: "ignore", detached: true });
+  child.unref();
+  child.on("exit", () => {
+    if (caffeinateProcess.process === child) {
+      caffeinateProcess = { process: null, pid: null, startedAt: null, duration: null };
+    }
+  });
+  caffeinateProcess = { process: child, pid: child.pid, startedAt: Date.now(), duration: duration || null };
+  res.json({ ok: true, active: true, pid: child.pid, duration });
+});
+
+app.post("/api/caffeinate/stop", (_req, res) => {
+  if (caffeinateProcess.process) {
+    try { caffeinateProcess.process.kill("SIGTERM"); } catch {}
+  }
+  caffeinateProcess = { process: null, pid: null, startedAt: null, duration: null };
+  res.json({ ok: true, active: false });
+});
+
+app.get("/api/caffeinate/status", (_req, res) => {
+  const active = !!(caffeinateProcess.process && caffeinateProcess.pid);
+  let remaining = null;
+  if (active && caffeinateProcess.duration && caffeinateProcess.startedAt) {
+    const elapsed = Math.floor((Date.now() - caffeinateProcess.startedAt) / 1000);
+    remaining = Math.max(0, caffeinateProcess.duration - elapsed);
+  }
+  res.json({ active, pid: caffeinateProcess.pid, remaining, platform: process.platform });
+});
+
 // --- Unified agent sessions ---
 // Single map: key = "project/agent" → { projectId, agentId, term, ws, state, error }
 // PTY (term) is the source of truth for "running". WS is optional (attaches to view terminal).
 const agentSessions = new Map();
 
-// AgentChattr server process (separate — not a PTY agent)
-let chattrProcess = { process: null, state: "stopped", error: null };
+// AgentChattr server processes — per-project (key = projectId)
+const chattrProcesses = new Map();
 
 // Helper: spawn a PTY for a project/agent and register in agentSessions
 function spawnAgentPty(project, agent) {
@@ -99,78 +197,178 @@ app.get("/api/agents", (_req, res) => {
   for (const [key, session] of agentSessions) {
     agents[key] = { state: session.state, error: session.error || null };
   }
-  agents["_agentchattr"] = { state: chattrProcess.state, error: chattrProcess.error };
+  for (const [pid, proc] of chattrProcesses) {
+    agents[`_agentchattr/${pid}`] = { state: proc.state, error: proc.error };
+  }
   res.json(agents);
 });
 
-app.post("/api/agentchattr/:action", (req, res) => {
-  const { action } = req.params;
-  const cfg = readConfig();
-  const chattrUrl = cfg.agentchattr_url || "http://127.0.0.1:8300";
+// Per-project AgentChattr lifecycle: /api/agentchattr/:project/:action
+// Backward compat: /api/agentchattr/:action uses first project
+function handleAgentChattr(req, res) {
+  let projectId, action;
+  if (req.params.action) {
+    projectId = req.params.projectOrAction;
+    action = req.params.action;
+  } else {
+    // Backward compat: single-param = action, use first project
+    action = req.params.projectOrAction;
+    const cfg = readConfig();
+    projectId = cfg.projects?.[0]?.id || "_default";
+  }
+
+  const { url: chattrUrl } = resolveProjectChattr(projectId);
   const chattrPort = new URL(chattrUrl).port || "8300";
 
+  // Find per-project config.toml (prefer project working_dir/agentchattr/config.toml)
+  const cfg = readConfig();
+  const project = cfg.projects?.find((p) => p.id === projectId);
+  const projectConfigToml = project?.working_dir
+    ? path.join(project.working_dir, "agentchattr", "config.toml")
+    : null;
+
+  function getProc() {
+    return chattrProcesses.get(projectId) || { process: null, state: "stopped", error: null };
+  }
+  function setProc(val) {
+    chattrProcesses.set(projectId, val);
+  }
+
+  function regenerateConfigToml() {
+    // If project has a config.toml, update the port to match current config
+    if (!projectConfigToml || !fs.existsSync(projectConfigToml)) return;
+    try {
+      let content = fs.readFileSync(projectConfigToml, "utf-8");
+      content = content.replace(/^port = \d+/m, `port = ${chattrPort}`);
+      fs.writeFileSync(projectConfigToml, content);
+    } catch {}
+  }
+
+  function spawnChattr() {
+    // Sync config.toml port before starting
+    regenerateConfigToml();
+
+    // Use project config.toml if available (isolated data dir + ports), otherwise fall back to --port
+    const args = (projectConfigToml && fs.existsSync(projectConfigToml))
+      ? ["--config", projectConfigToml]
+      : ["--port", chattrPort];
+    const child = spawn("agentchattr", args, {
+      env: process.env,
+      stdio: "ignore",
+      detached: true,
+    });
+
+    // If pid is undefined, spawn failed (binary not found)
+    if (!child.pid) {
+      setProc({ process: null, state: "error", error: "Failed to start AgentChattr — is it installed? Run: pipx install agentchattr" });
+      // Still register error handler to prevent unhandled error crash
+      child.on("error", () => {});
+      return null;
+    }
+
+    child.unref();
+    child.on("error", (err) => {
+      setProc({ process: null, state: "error", error: err.message });
+    });
+    child.on("exit", (code) => {
+      const cur = getProc();
+      if (cur.process === child) {
+        setProc({ process: null, state: "stopped", error: code ? `exit:${code}` : null });
+      }
+    });
+    setProc({ process: child, state: "running", error: null });
+    return child;
+  }
+
   if (action === "start") {
-    if (chattrProcess.state === "running" && chattrProcess.process) {
+    const proc = getProc();
+    if (proc.state === "running" && proc.process) {
       return res.json({ ok: true, state: "running", message: "Already running" });
     }
     try {
-      const child = spawn("agentchattr", ["--port", chattrPort], {
-        env: process.env,
-        stdio: "ignore",
-        detached: true,
-      });
-      child.unref();
-      child.on("error", (err) => {
-        chattrProcess = { process: null, state: "error", error: err.message };
-      });
-      child.on("exit", (code) => {
-        if (chattrProcess.process === child) {
-          chattrProcess = { process: null, state: "stopped", error: code ? `exit:${code}` : null };
-        }
-      });
-      chattrProcess = { process: child, state: "running", error: null };
+      const child = spawnChattr();
+      if (!child) {
+        const errProc = getProc();
+        return res.status(500).json({ ok: false, state: "error", error: errProc.error || "Failed to start AgentChattr" });
+      }
+      // Sync token after AgentChattr starts (it generates its own)
+      setTimeout(() => syncChattrToken(projectId), 2000);
       res.json({ ok: true, state: "running", pid: child.pid });
     } catch (err) {
-      chattrProcess = { process: null, state: "error", error: err.message };
+      setProc({ process: null, state: "error", error: err.message });
       res.status(500).json({ ok: false, state: "error", error: err.message });
     }
   } else if (action === "stop") {
-    if (chattrProcess.process) {
-      try { chattrProcess.process.kill("SIGTERM"); } catch {}
+    const proc = getProc();
+    if (proc.process) {
+      try { proc.process.kill("SIGTERM"); } catch {}
     }
-    chattrProcess = { process: null, state: "stopped", error: null };
+    setProc({ process: null, state: "stopped", error: null });
     res.json({ ok: true, state: "stopped" });
   } else if (action === "restart") {
-    if (chattrProcess.process) {
-      try { chattrProcess.process.kill("SIGTERM"); } catch {}
+    const proc = getProc();
+    if (proc.process) {
+      try { proc.process.kill("SIGTERM"); } catch {}
     }
-    chattrProcess = { process: null, state: "stopped", error: null };
+    setProc({ process: null, state: "stopped", error: null });
     setTimeout(() => {
       try {
-        const child = spawn("agentchattr", ["--port", chattrPort], {
-          env: process.env,
-          stdio: "ignore",
-          detached: true,
-        });
-        child.unref();
-        child.on("error", (err) => {
-          chattrProcess = { process: null, state: "error", error: err.message };
-        });
-        child.on("exit", (code) => {
-          if (chattrProcess.process === child) {
-            chattrProcess = { process: null, state: "stopped", error: code ? `exit:${code}` : null };
-          }
-        });
-        chattrProcess = { process: child, state: "running", error: null };
+        const child = spawnChattr();
+        if (!child) {
+          const errProc = getProc();
+          return res.status(500).json({ ok: false, state: "error", error: errProc.error || "Failed to start AgentChattr" });
+        }
+        // Sync token after AgentChattr restarts
+        setTimeout(() => syncChattrToken(projectId), 2000);
         res.json({ ok: true, state: "running", pid: child.pid });
       } catch (err) {
-        chattrProcess = { process: null, state: "error", error: err.message };
+        setProc({ process: null, state: "error", error: err.message });
         res.status(500).json({ ok: false, state: "error", error: err.message });
       }
     }, 500);
   } else {
     res.status(400).json({ error: "Unknown action" });
   }
+}
+app.post("/api/agentchattr/:projectOrAction/:action", handleAgentChattr);
+app.post("/api/agentchattr/:projectOrAction", handleAgentChattr);
+
+// --- Reset agents: deregister all registered slots ---
+// AgentChattr doesn't expose staleness metadata, so this clears all slots.
+// Agents' wrapper heartbeat will auto-re-register with clean names.
+
+app.post("/api/agents/:project/reset", async (req, res) => {
+  const projectId = req.params.project;
+  const { url: chattrUrl, token: chattrToken } = resolveProjectChattr(projectId);
+  const headers = {};
+  if (chattrToken) headers["x-session-token"] = chattrToken;
+
+  try {
+    // Fetch current agent status from AgentChattr
+    const statusRes = await fetch(`${chattrUrl}/api/status`, { headers });
+    if (!statusRes.ok) {
+      return res.status(statusRes.status).json({ ok: false, error: `AgentChattr status failed: ${statusRes.status}` });
+    }
+    const status = await statusRes.json();
+    const slots = status.agents || status.slots || [];
+
+    let cleared = 0;
+    for (const agent of slots) {
+      const name = typeof agent === "string" ? agent : agent.name || agent.sender;
+      if (!name) continue;
+      try {
+        const dereg = await fetch(`${chattrUrl}/api/deregister/${encodeURIComponent(name)}`, {
+          method: "POST",
+          headers,
+        });
+        if (dereg.ok) cleared++;
+      } catch {}
+    }
+
+    res.json({ ok: true, cleared, total: slots.length });
+  } catch (err) {
+    res.status(500).json({ ok: false, error: err.message });
+  }
 });
 
 // --- Lifecycle: start spawns PTY (visible in terminal panel) ---
@@ -262,17 +460,17 @@ app.post("/api/agents/:project/:agent/write", (req, res) => {
 
 const triggers = new Map();
 
-const DEFAULT_MESSAGE = `@t1 @t2a @t2b @t3 — Queue check.
-T1: Merge any PR with both approvals, assign next from queue.
-T3: Work on assigned ticket or address review feedback.
-T2a/T2b: Review open PRs. If T3 pushed fixes, re-review. Post verdict on PR AND notify here.
+const DEFAULT_MESSAGE = `@head @reviewer1 @reviewer2 @dev — Queue check.
+Head: Merge any PR with both approvals, assign next from queue.
+Dev: Work on assigned ticket or address review feedback.
+Reviewer1/Reviewer2: Review open PRs. If Dev pushed fixes, re-review. Post verdict on PR AND notify here.
 ALL: Communicate via this chat by tagging agents. Your terminal is NOT visible.`;
 
 async function sendTriggerMessage(projectId) {
   const cfg = readConfig();
   const project = cfg.projects && cfg.projects.find((p) => p.id === projectId);
-  const chattrUrl = cfg.agentchattr_url || "http://127.0.0.1:8300";
-  const token = cfg.agentchattr_token || "";
+  const { url: chattrUrl, token: chattrToken } = resolveProjectChattr(projectId);
+  const token = chattrToken || "";
   const message = (project && project.trigger_message) || DEFAULT_MESSAGE;
   const headers = { "Content-Type": "application/json" };
   if (token) headers["x-session-token"] = token;
@@ -312,29 +510,60 @@ app.get("/api/triggers", (_req, res) => {
       lastSent: info.lastSent,
       nextAt: info.nextAt,
       lastError: info.lastError || null,
+      expiresAt: info.expiresAt || null,
     };
   }
   res.json(result);
 });
 
+function stopTrigger(project) {
+  const existing = triggers.get(project);
+  if (existing) {
+    if (existing.timer) clearInterval(existing.timer);
+    if (existing.durationTimer) clearTimeout(existing.durationTimer);
+  }
+  triggers.delete(project);
+}
+
 app.post("/api/triggers/:project/start", (req, res) => {
   const { project } = req.params;
-  const { interval } = req.body || {};
+  const { interval, duration } = req.body || {};
   const ms = (interval || 30) * 60 * 1000;
+  const durationMs = duration ? duration * 60 * 1000 : 0; // duration in minutes, 0 = indefinite
 
   const existing = triggers.get(project);
-  if (existing && existing.timer) clearInterval(existing.timer);
+  if (existing) {
+    if (existing.timer) clearInterval(existing.timer);
+    if (existing.durationTimer) clearTimeout(existing.durationTimer);
+  }
 
   const timer = setInterval(() => sendTriggerMessage(project), ms);
-  triggers.set(project, { interval: ms, timer, lastSent: null, nextAt: Date.now() + ms });
-  res.json({ ok: true, enabled: true, interval: ms, nextAt: Date.now() + ms });
+  const expiresAt = durationMs > 0 ? Date.now() + durationMs : null;
+
+  const triggerInfo = {
+    interval: ms,
+    timer,
+    lastSent: null,
+    nextAt: Date.now() + ms,
+    lastError: null,
+    expiresAt,
+    durationTimer: null,
+  };
+
+  // Auto-stop after duration
+  if (durationMs > 0) {
+    triggerInfo.durationTimer = setTimeout(() => {
+      stopTrigger(project);
+    }, durationMs);
+  }
+
+  triggers.set(project, triggerInfo);
+  res.json({ ok: true, enabled: true, interval: ms, nextAt: Date.now() + ms, expiresAt });
 });
 
 app.post("/api/triggers/:project/stop", (req, res) => {
   const { project } = req.params;
-  const existing = triggers.get(project);
-  if (existing && existing.timer) clearInterval(existing.timer);
-  triggers.delete(project);
+  stopTrigger(project);
   res.json({ ok: true, enabled: false });
 });
 
@@ -354,16 +583,62 @@ app.set("syncTriggers", syncTriggersFromConfig);
 
 // --- Serve static frontend (built Next.js export) ---
 
+// Strip trailing slashes (redirect /settings/ → /settings, /setup/ → /setup)
+app.use((req, res, next) => {
+  if (req.path !== "/" && req.path.endsWith("/")) {
+    const clean = req.path.slice(0, -1);
+    const query = req.url.includes("?") ? req.url.slice(req.url.indexOf("?")) : "";
+    return res.redirect(301, clean + query);
+  }
+  next();
+});
+
 const outDir = path.join(__dirname, "..", "out");
+
+// HEAD requests: express.static extensions don't resolve when a same-name
+// directory exists (e.g. /settings dir shadows settings.html for HEAD).
+// Resolve extensionless HEAD requests to their .html file explicitly.
+app.use((req, res, next) => {
+  if (req.method !== "HEAD" || req.path.startsWith("/api/") || path.extname(req.path)) {
+    return next();
+  }
+  const htmlPath = path.join(outDir, req.path + ".html");
+  if (fs.existsSync(htmlPath)) {
+    return res.sendFile(htmlPath);
+  }
+  next();
+});
+
 if (fs.existsSync(outDir)) {
-  app.use(express.static(outDir));
+  app.use(express.static(outDir, { redirect: false, extensions: ["html"] }));
 }
 
-// SPA fallback: serve index.html for all non-API, non-WS routes
+// SPA fallback: serve the pre-rendered template for dynamic routes,
+// fall back to index.html for everything else.
 app.use((req, res, next) => {
-  if (req.method !== "GET" || req.path.startsWith("/api/")) {
+  if ((req.method !== "GET" && req.method !== "HEAD") || req.path.startsWith("/api/")) {
     return next();
   }
+
+  // Dynamic routes → serve their pre-rendered template (has the right JS chunks).
+  // Hydration #418 is cosmetic — dashboard renders and functions correctly.
+  // NOTE: app-shell.html does NOT work — it has no route JS chunks and renders blank.
+  const dynamicRoutes = [
+    { pattern: /^\/project\/[^/]+\/memory\/?$/, template: "project/_/memory.html" },
+    { pattern: /^\/project\/[^/]+\/queue\/?$/, template: "project/_/queue.html" },
+    { pattern: /^\/project\/[^/]+\/?$/, template: "project/_.html" },
+  ];
+
+  for (const route of dynamicRoutes) {
+    if (route.pattern.test(req.path)) {
+      const templatePath = path.join(outDir, route.template);
+      if (fs.existsSync(templatePath)) {
+        return res.sendFile(templatePath);
+      }
+    }
+  }
+
+  // Everything else → index.html
   const indexPath = path.join(outDir, "index.html");
   if (fs.existsSync(indexPath)) {
     res.sendFile(indexPath);
@@ -463,6 +738,7 @@ function syncTriggersFromConfig() {
   for (const [id, info] of triggers) {
     if (!activeIds.has(id)) {
       if (info.timer) clearInterval(info.timer);
+      if (info.durationTimer) clearTimeout(info.durationTimer);
       triggers.delete(id);
     }
   }
@@ -473,4 +749,9 @@ function syncTriggersFromConfig() {
 server.listen(PORT, "127.0.0.1", () => {
   console.log(`QuadWork server listening on http://127.0.0.1:${PORT}`);
   syncTriggersFromConfig();
+  // Sync AgentChattr tokens for all projects on startup
+  const startupCfg = readConfig();
+  for (const p of (startupCfg.projects || [])) {
+    syncChattrToken(p.id);
+  }
 });