quadwork 0.1.3 → 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, resolveProjectChattr } = 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,6 +26,103 @@ 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).
@@ -136,7 +234,20 @@ function handleAgentChattr(req, res) {
     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]
@@ -146,6 +257,15 @@ function handleAgentChattr(req, res) {
       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 });
@@ -167,6 +287,12 @@ function handleAgentChattr(req, res) {
     }
     try {
       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) {
       setProc({ process: null, state: "error", error: err.message });
@@ -188,6 +314,12 @@ function handleAgentChattr(req, res) {
     setTimeout(() => {
       try {
         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) {
         setProc({ process: null, state: "error", error: err.message });
@@ -201,6 +333,44 @@ function handleAgentChattr(req, res) {
 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) ---
 
 app.post("/api/agents/:project/:agent/start", (req, res) => {
@@ -340,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 });
 });
 
@@ -382,20 +583,46 @@ 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 the correct pre-rendered HTML for dynamic routes.
-// Static export only generates templates for placeholder params (e.g. /project/_),
-// so we map real dynamic segments back to those template files.
+// 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();
   }
 
-  // Map dynamic routes to their pre-rendered template HTML
+  // 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" },
@@ -411,7 +638,7 @@ app.use((req, res, next) => {
     }
   }
 
-  // Default fallback to index.html
+  // Everything else → index.html
   const indexPath = path.join(outDir, "index.html");
   if (fs.existsSync(indexPath)) {
     res.sendFile(indexPath);
@@ -511,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);
     }
   }
@@ -521,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);
+  }
 });

package/server/routes.js

@@ -456,6 +456,73 @@ function exec(cmd, args, opts) {
   }
 }
 
+// ─── GitHub helpers for Setup Wizard ──────────────────────────────────────
+
+// GitHub user info
+router.get("/api/github/user", (_req, res) => {
+  try {
+    const out = execFileSync("gh", ["api", "user", "--jq", "{login: .login}"], { encoding: "utf-8", timeout: 10000 });
+    res.json(JSON.parse(out));
+  } catch {
+    res.status(502).json({ error: "GitHub CLI not authenticated" });
+  }
+});
+
+// GitHub repo list for an owner (only repos with push access)
+router.get("/api/github/repos", (req, res) => {
+  const owner = req.query.owner;
+  if (!owner) return res.status(400).json({ error: "Missing owner" });
+  try {
+    const out = execFileSync("gh", ["repo", "list", String(owner), "--json", "name,description,isPrivate,viewerPermission", "--limit", "50"], { encoding: "utf-8", timeout: 15000 });
+    const repos = JSON.parse(out);
+    // Filter to repos with push access (ADMIN, MAINTAIN, WRITE)
+    const pushAccess = new Set(["ADMIN", "MAINTAIN", "WRITE"]);
+    res.json(repos.filter((r) => pushAccess.has(r.viewerPermission)));
+  } catch {
+    res.json([]);
+  }
+});
+
+// Auto-detect existing clone of a repo
+router.get("/api/setup/detect-clone", (req, res) => {
+  const repoName = req.query.repo; // "owner/repo"
+  if (!repoName) return res.status(400).json({ error: "Missing repo" });
+  const slug = String(repoName).split("/").pop();
+  const home = os.homedir();
+  const searchDirs = [
+    path.join(home, "Projects"),
+    path.join(home, "Developer"),
+    path.join(home, "repos"),
+    path.join(home, "code"),
+    path.join(home, "src"),
+    path.join(home, "workspace"),
+    home,
+  ];
+  for (const dir of searchDirs) {
+    const candidate = path.join(dir, slug);
+    if (fs.existsSync(path.join(candidate, ".git"))) {
+      return res.json({ found: true, path: candidate, suggested: path.join(searchDirs[0], slug) });
+    }
+  }
+  // Not found — suggest a default location
+  const defaultDir = fs.existsSync(searchDirs[0]) ? searchDirs[0] : home;
+  return res.json({ found: false, path: null, suggested: path.join(defaultDir, slug) });
+});
+
+// Save reviewer token securely
+router.post("/api/setup/save-token", (req, res) => {
+  const { token } = req.body;
+  if (!token) return res.status(400).json({ error: "Missing token" });
+  const tokenPath = path.join(os.homedir(), ".quadwork", "reviewer-token");
+  const dir = path.dirname(tokenPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(tokenPath, token.trim() + "\n", { mode: 0o600 });
+  try { fs.chmodSync(tokenPath, 0o600); } catch {}
+  res.json({ ok: true, path: tokenPath });
+});
+
+// ─── Setup Wizard ─────────────────────────────────────────────────────────
+
 router.post("/api/setup", (req, res) => {
   const step = req.query.step;
   const body = req.body || {};
@@ -464,8 +531,16 @@ router.post("/api/setup", (req, res) => {
     case "verify-repo": {
       const repo = body.repo;
       if (!repo || !REPO_RE.test(repo)) return res.json({ ok: false, error: "Invalid repo format (use owner/repo)" });
-      const result = exec("gh", ["repo", "view", repo, "--json", "name,owner"]);
-      return res.json({ ok: result.ok, error: result.ok ? undefined : "Cannot access repo. Check gh auth and repo permissions." });
+      const result = exec("gh", ["repo", "view", repo, "--json", "name,owner,viewerPermission"]);
+      if (!result.ok) return res.json({ ok: false, error: "Cannot access repo. Check gh auth and repo permissions." });
+      try {
+        const info = JSON.parse(result.output);
+        const pushAccess = new Set(["ADMIN", "MAINTAIN", "WRITE"]);
+        if (!pushAccess.has(info.viewerPermission)) {
+          return res.json({ ok: false, error: "You don't have push access to this repo. Agents need push access to create branches and PRs." });
+        }
+      } catch {}
+      return res.json({ ok: true });
     }
     case "create-worktrees": {
       const workingDir = body.workingDir;
@@ -544,6 +619,20 @@ router.post("/api/setup", (req, res) => {
           }
           seeded.push(`${agent}/CLAUDE.md`);
         }
+
+        // .gitignore — ensure token files are never committed
+        const gitignorePath = path.join(wtDir, ".gitignore");
+        const tokenIgnorePatterns = "reviewer-token\n*-token\n";
+        if (!fs.existsSync(gitignorePath)) {
+          fs.writeFileSync(gitignorePath, tokenIgnorePatterns);
+          seeded.push(`${agent}/.gitignore`);
+        } else {
+          const existing = fs.readFileSync(gitignorePath, "utf-8");
+          if (!existing.includes("*-token")) {
+            fs.appendFileSync(gitignorePath, "\n" + tokenIgnorePatterns);
+            seeded.push(`${agent}/.gitignore (updated)`);
+          }
+        }
       }
       return res.json({ ok: true, seeded });
     }