quadwork 1.2.5 → 1.4.0

package/server/index.js

@@ -16,7 +16,13 @@ const config = readConfig();
 const PORT = config.port || 8400;
 
 const app = express();
-app.use(express.json());
+// #412 / quadwork#279: bump the global JSON body limit to 10mb so
+// POST /api/project-history can accept full chat exports. The
+// default ~100kb 413'd long before the route-local parser had a
+// chance to apply its own 10mb cap (the global parser runs first).
+// All other routes are well within 10mb in practice; this is the
+// least invasive fix and matches the documented import ceiling.
+app.use(express.json({ limit: "10mb" }));
 
 // --- Mount migrated API routes (from Next.js) ---
 app.use(routes);
@@ -658,6 +664,55 @@ app.get("/api/agents", (_req, res) => {
   res.json(agents);
 });
 
+// #424 / quadwork#304: best-effort auto-snapshot of chat history
+// before any AgentChattr restart. Defense-in-depth against
+// destructive ops like /clear that rewrite AC's JSONL log in place
+// — per #303 the log itself IS persistent across normal restarts,
+// so the snapshot's job is to give the operator a point-in-time
+// rollback if the log gets clobbered, not to prevent history loss
+// on ordinary lifecycle events.
+//
+// Snapshot contents = the same envelope GET /api/project-history
+// returns, so an operator (or a future "restore" button) can feed
+// the file straight into POST /api/project-history for replay.
+const HISTORY_SNAPSHOT_LIMIT = 5;
+
+async function snapshotProjectHistory(projectId) {
+  try {
+    const snapDir = path.join(require("os").homedir(), ".quadwork", projectId, "history-snapshots");
+    if (!fs.existsSync(snapDir)) fs.mkdirSync(snapDir, { recursive: true });
+    const res = await fetch(`http://127.0.0.1:${PORT}/api/project-history?project=${encodeURIComponent(projectId)}`, {
+      signal: AbortSignal.timeout(30000),
+    });
+    if (!res.ok) {
+      console.warn(`[snapshot] ${projectId} history fetch returned ${res.status}; skipping snapshot`);
+      return false;
+    }
+    const text = await res.text();
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const outPath = path.join(snapDir, `${stamp}.json`);
+    fs.writeFileSync(outPath, text);
+    console.log(`[snapshot] ${projectId} → ${outPath}`);
+    // Prune to the newest HISTORY_SNAPSHOT_LIMIT files so the
+    // directory can't grow unbounded across weeks of restarts.
+    try {
+      const entries = fs.readdirSync(snapDir)
+        .filter((f) => f.endsWith(".json"))
+        .map((f) => ({ f, t: fs.statSync(path.join(snapDir, f)).mtimeMs }))
+        .sort((a, b) => b.t - a.t);
+      for (const old of entries.slice(HISTORY_SNAPSHOT_LIMIT)) {
+        try { fs.unlinkSync(path.join(snapDir, old.f)); } catch {}
+      }
+    } catch {
+      // non-fatal — stale snapshots just linger
+    }
+    return true;
+  } catch (err) {
+    console.warn(`[snapshot] ${projectId} snapshot failed: ${err.message || err}`);
+    return false;
+  }
+}
+
 // Per-project AgentChattr lifecycle: /api/agentchattr/:project/:action
 // Backward compat: /api/agentchattr/:action uses first project
 async function handleAgentChattr(req, res) {
@@ -779,6 +834,18 @@ async function handleAgentChattr(req, res) {
     setProc({ process: null, state: "stopped", error: null });
     res.json({ ok: true, state: "stopped" });
   } else if (action === "restart") {
+    // #424 / quadwork#304: snapshot history before killing the
+    // process. Best-effort and non-blocking-on-failure so a flaky
+    // snapshot doesn't leave the operator unable to restart AC.
+    await snapshotProjectHistory(projectId).catch(() => {});
+    // #424 / quadwork#304 Phase 3: latch the opt-in BEFORE the
+    // spawn so a restart that itself clears the flag can't starve
+    // the auto-restore. We capture the snapshot filename we just
+    // wrote + the project's auto_restore_after_restart flag and
+    // replay it in the post-spawn tick below if both are set.
+    const preRestartCfg = readConfig();
+    const preRestartProject = preRestartCfg.projects?.find((p) => p.id === projectId);
+    const shouldAutoRestore = !!(preRestartProject && preRestartProject.auto_restore_after_restart);
     const proc = getProc();
     if (proc.process) {
       try { proc.process.kill("SIGTERM"); } catch {}
@@ -793,6 +860,30 @@ async function handleAgentChattr(req, res) {
         }
         // Sync token after AgentChattr restarts
         setTimeout(() => syncChattrToken(projectId), 2000);
+        // #424 / quadwork#304 Phase 3: optional auto-restore.
+        // Fire the restore 3s after spawn so AC's ws is ready.
+        // Best-effort: never blocks the restart response or
+        // rolls back on error.
+        if (shouldAutoRestore) {
+          setTimeout(async () => {
+            try {
+              const snapDir = path.join(require("os").homedir(), ".quadwork", projectId, "history-snapshots");
+              if (!fs.existsSync(snapDir)) return;
+              const newest = fs.readdirSync(snapDir)
+                .filter((f) => f.endsWith(".json"))
+                .map((f) => ({ f, t: fs.statSync(path.join(snapDir, f)).mtimeMs }))
+                .sort((a, b) => b.t - a.t)[0];
+              if (!newest) return;
+              const r = await fetch(`http://127.0.0.1:${PORT}/api/project-history/restore?project=${encodeURIComponent(projectId)}&name=${encodeURIComponent(newest.f)}`, {
+                method: "POST",
+              });
+              if (r.ok) console.log(`[snapshot] ${projectId} auto-restored ${newest.f}`);
+              else console.warn(`[snapshot] ${projectId} auto-restore returned ${r.status}`);
+            } catch (err) {
+              console.warn(`[snapshot] ${projectId} auto-restore failed: ${err.message || err}`);
+            }
+          }, 3000);
+        }
         res.json({ ok: true, state: "running", pid: child.pid });
       } catch (err) {
         setProc({ process: null, state: "error", error: err.message });
@@ -808,7 +899,16 @@ async function handleAgentChattr(req, res) {
     try {
       const { execSync } = require("child_process");
 
-      // Stop running process before pulling
+      // Stop running process before pulling. Snapshot first so a
+      // botched git pull can still be rolled back from disk.
+      // #424 / quadwork#304: best-effort.
+      await snapshotProjectHistory(projectId).catch(() => {});
+      // Latch the auto-restore opt-in BEFORE stop, same as the
+      // explicit restart branch above — a config mutation during
+      // the git pull shouldn't starve the replay.
+      const updateCfgPre = readConfig();
+      const updateProjectPre = updateCfgPre.projects?.find((p) => p.id === projectId);
+      const updateShouldAutoRestore = !!(updateProjectPre && updateProjectPre.auto_restore_after_restart);
       const proc = getProc();
       const wasRunning = proc.process && proc.state === "running";
       if (wasRunning) {
@@ -833,6 +933,30 @@ async function handleAgentChattr(req, res) {
         restarted = !!child;
         if (child) {
           setTimeout(() => syncChattrToken(projectId).catch(() => {}), 2000);
+          // #424 / quadwork#304 Phase 3: auto-restore after an
+          // update-triggered restart too (t2a re-review). Same
+          //3s wait + newest-snapshot-by-mtime path as the explicit
+          // restart branch, using the pre-stop latched opt-in.
+          if (updateShouldAutoRestore) {
+            setTimeout(async () => {
+              try {
+                const snapDir = path.join(require("os").homedir(), ".quadwork", projectId, "history-snapshots");
+                if (!fs.existsSync(snapDir)) return;
+                const newest = fs.readdirSync(snapDir)
+                  .filter((f) => f.endsWith(".json"))
+                  .map((f) => ({ f, t: fs.statSync(path.join(snapDir, f)).mtimeMs }))
+                  .sort((a, b) => b.t - a.t)[0];
+                if (!newest) return;
+                const r = await fetch(`http://127.0.0.1:${PORT}/api/project-history/restore?project=${encodeURIComponent(projectId)}&name=${encodeURIComponent(newest.f)}`, {
+                  method: "POST",
+                });
+                if (r.ok) console.log(`[snapshot] ${projectId} auto-restored ${newest.f} after update`);
+                else console.warn(`[snapshot] ${projectId} post-update auto-restore returned ${r.status}`);
+              } catch (err) {
+                console.warn(`[snapshot] ${projectId} post-update auto-restore failed: ${err.message || err}`);
+              }
+            }, 3000);
+          }
         }
       }
 
@@ -983,19 +1107,24 @@ 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 { 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;
+
+  // #401 / quadwork#277: route trigger sends through the local
+  // /api/chat path that already works for the chat panel. The old
+  // direct /api/send call required a registration token (not the
+  // session token we have on hand) and 401'd silently — agents never
+  // saw the queue-check pulse. /api/chat opens the AC ws with the
+  // session token and inherits the #230 token-resync-on-401 retry,
+  // so the trigger now gets the same proven path as the chat panel.
+  const qwPort = cfg.port || 8400;
+  const url = `http://127.0.0.1:${qwPort}/api/chat?project=${encodeURIComponent(projectId)}`;
 
   const info = triggers.get(projectId);
   try {
-    let tokenParam = token ? `?token=${encodeURIComponent(token)}` : "";
-    const res = await fetch(`${chattrUrl}/api/send${tokenParam}`, {
+    const res = await fetch(url, {
       method: "POST",
-      headers,
-      body: JSON.stringify({ text: message, channel: "general", sender: "user" }),
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ text: message, channel: "general" }),
     });
     if (!res.ok) {
       const err = await res.text().catch(() => "");
@@ -1075,7 +1204,12 @@ function stopTrigger(project) {
 
 app.post("/api/triggers/:project/start", (req, res) => {
   const { project } = req.params;
-  const { interval, duration, message, sendImmediately } = req.body || {};
+  // #418 / quadwork#306: sendImmediately was an always-true
+  // "Send Message and Start Trigger" flag from #210; operators
+  // asked for a pure scheduler ("Start Trigger" — wait for the
+  // first interval). The field is ignored here; the send-now
+  // endpoint below still exists for the explicit one-shot path.
+  const { interval, duration, message } = req.body || {};
   const ms = (interval || 30) * 60 * 1000;
   const durationMs = duration ? duration * 60 * 1000 : 0; // duration in minutes, 0 = indefinite
 
@@ -1102,16 +1236,12 @@ app.post("/api/triggers/:project/start", (req, res) => {
     if (existing.durationTimer) clearTimeout(existing.durationTimer);
   }
 
-  // #210: the Scheduled Trigger widget's "Send Message and Start
-  // Trigger" button expects an immediate send, not the first fire
-  // one interval in the future. setInterval won't do that on its
-  // own, so trigger a one-shot send when sendImmediately is true.
-  if (sendImmediately) {
-    // Don't await — keep the response fast. sendTriggerMessage logs
-    // its own errors and updates lastError on the trigger info.
-    sendTriggerMessage(project).catch(() => {});
-  }
-
+  // #418 / quadwork#306: no immediate fire — the first send happens
+  // at T + interval via the setInterval below. Operators set the
+  // trigger up in advance of going afk and don't want it interrupting
+  // whatever agents are currently mid-task. The explicit "send now"
+  // path still lives at /api/triggers/:project/send-now for the
+  // rare case an operator actually wants to kick things off.
   const timer = setInterval(() => sendTriggerMessage(project), ms);
   const expiresAt = durationMs > 0 ? Date.now() + durationMs : null;
 
@@ -1379,6 +1509,123 @@ function syncTriggersFromConfig() {
   }
 }
 
+// #422 / quadwork#310: auto-continue after loop guard.
+//
+// Per opted-in project, poll AC's /api/status every 10s. When we see
+// a false → true transition on `paused`, wait the configured delay
+// (default 30s) and POST /continue to /api/chat — same path the
+// operator would use manually. The delay gives a human a chance to
+// intervene on an actually-runaway loop, and acts as a soft rate
+// limit against pathological loops that would otherwise just loop
+// forever under an auto-continue.
+//
+// Detection is deliberately polling rather than a long-lived ws:
+// a ws subscription per project would complicate lifecycle and
+// reconnection, and 10s polling latency is acceptable when the
+// delay is tens of seconds. Skipping projects without the opt-in
+// keeps the poller cheap for single-project setups.
+
+const _loopGuardPausedState = new Map(); // projectId -> { paused: bool, scheduled: Timeout? }
+const LOOP_GUARD_POLL_INTERVAL_MS = 10000;
+
+async function checkLoopGuardPause(project) {
+  if (!project || !project.auto_continue_loop_guard) return;
+  const { url: base, token: sessionToken } = resolveProjectChattr(project.id);
+  if (!base) return;
+  let paused = false;
+  try {
+    const r = await fetch(`${base}/api/status`, {
+      headers: sessionToken ? { "x-session-token": sessionToken } : {},
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!r.ok) return;
+    const data = await r.json();
+    paused = !!(data && data.paused);
+  } catch {
+    return;
+  }
+  const state = _loopGuardPausedState.get(project.id) || { paused: false, scheduled: null };
+  // Transition false → true: schedule an auto-continue after the delay.
+  if (paused && !state.paused && !state.scheduled) {
+    const delaySec = Number.isFinite(project.auto_continue_delay_sec) && project.auto_continue_delay_sec >= 5
+      ? project.auto_continue_delay_sec
+      : 30;
+    console.log(`[loop-guard] ${project.id} paused — auto-continue in ${delaySec}s`);
+    state.scheduled = setTimeout(async () => {
+      try {
+        // Re-check the opt-in at fire time so a checkbox disable
+        // mid-wait actually stops the auto-continue.
+        const freshCfg = readConfig();
+        const fresh = freshCfg.projects?.find((p) => p.id === project.id);
+        if (!fresh || !fresh.auto_continue_loop_guard) {
+          console.log(`[loop-guard] ${project.id} auto-continue cancelled (opt-in disabled during wait)`);
+        } else {
+          // Re-check the router's pause state at fire time too. The
+          // 10s status poller may not have seen a manual operator
+          // /continue yet when the delay window (5–9s) is shorter
+          // than the poll interval — without this, a manual resume
+          // inside a 5s wait would be followed by a stale auto
+          // /continue that clobbers hop_count on an already-running
+          // chain (router.continue_routing resets the counter
+          // unconditionally). The re-check closes the race.
+          let stillPaused = false;
+          try {
+            const { url: freshBase, token: freshToken } = resolveProjectChattr(project.id);
+            if (freshBase) {
+              const sr = await fetch(`${freshBase}/api/status`, {
+                headers: freshToken ? { "x-session-token": freshToken } : {},
+                signal: AbortSignal.timeout(5000),
+              });
+              if (sr.ok) {
+                const sd = await sr.json();
+                stillPaused = !!(sd && sd.paused);
+              }
+            }
+          } catch {
+            // Status re-check failed — fall back to "don't fire".
+            // Stuck pause will still be caught on the next 10s tick.
+          }
+          if (!stillPaused) {
+            console.log(`[loop-guard] ${project.id} auto-continue cancelled (router already resumed)`);
+          } else {
+            const res = await fetch(`http://127.0.0.1:${PORT}/api/chat?project=${encodeURIComponent(project.id)}`, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({ text: "/continue", channel: "general" }),
+            });
+            if (res.ok) console.log(`[loop-guard] ${project.id} auto-continued`);
+            else console.warn(`[loop-guard] ${project.id} auto-continue POST returned ${res.status}`);
+          }
+        }
+      } catch (err) {
+        console.warn(`[loop-guard] ${project.id} auto-continue failed: ${err.message || err}`);
+      }
+      const s2 = _loopGuardPausedState.get(project.id);
+      if (s2) s2.scheduled = null;
+    }, delaySec * 1000);
+  }
+  // Transition true → false: clear any pending timer.
+  if (!paused && state.paused && state.scheduled) {
+    clearTimeout(state.scheduled);
+    state.scheduled = null;
+  }
+  state.paused = paused;
+  _loopGuardPausedState.set(project.id, state);
+}
+
+function runLoopGuardPollingTick() {
+  try {
+    const cfg = readConfig();
+    for (const p of (cfg.projects || [])) {
+      if (p && p.auto_continue_loop_guard) checkLoopGuardPause(p);
+    }
+  } catch {
+    // config unreadable — next tick will retry
+  }
+}
+
+setInterval(runLoopGuardPollingTick, LOOP_GUARD_POLL_INTERVAL_MS);
+
 // --- Start ---
 
 server.listen(PORT, "127.0.0.1", () => {