quadwork 1.19.3 → 2.0.1

package/server/install-agentchattr.js

@@ -1,64 +1,11 @@
-// Shared AgentChattr install helper used by both the CLI wizard
-// (bin/quadwork.js) and the web setup route (server/routes.js).
-//
-// Extracted as part of #185 (Phase 2D of master #181) so the web UI
-// can clone AgentChattr per-project without duplicating the locking,
-// idempotency, and cleanup-safety logic that #183 + #187 added.
-//
-// Public API:
-//   findAgentChattr(dir)               → string|null
-//   installAgentChattr(dir)            → string|null  (.lastError on failure)
-//   chattrSpawnArgs(dir, extraArgs)    → { command, spawnArgs, cwd } | null
-//   AGENTCHATTR_REPO                   → upstream URL constant
-//
-// Self-contained — depends only on Node built-ins so it's safe to require
-// from anywhere in the project (CLI bin, server routes, future tests).
+// Retained for `npx quadwork cleanup --legacy` — locates AC directories on disk.
 
-const { execFileSync } = require("child_process");
 const fs = require("fs");
 const path = require("path");
 
-const AGENTCHATTR_REPO = "https://github.com/bcurts/agentchattr.git";
-
-// Stale-lock thresholds for installAgentChattr().
-// Lock files older than this OR whose owning pid is no longer alive are
-// treated as crashed and reclaimed. Tuned to comfortably exceed the longest
-// step (pip install of agentchattr requirements, ~120s timeout).
-const INSTALL_LOCK_STALE_MS = 10 * 60 * 1000; // 10 min
-const INSTALL_LOCK_WAIT_TOTAL_MS = 30 * 1000;  // wait up to 30s for a peer
-const INSTALL_LOCK_POLL_MS = 500;
-
-function _run(cmd, args = [], opts = {}) {
-  try { return execFileSync(cmd, args, { encoding: "utf-8", stdio: "pipe", ...opts }).trim(); }
-  catch { return null; }
-}
-
-function _isPidAlive(pid) {
-  if (!pid || !Number.isFinite(pid)) return false;
-  try { process.kill(pid, 0); return true; }
-  catch (e) { return e.code === "EPERM"; }
-}
-
-function _readLock(lockFile) {
-  try {
-    const raw = fs.readFileSync(lockFile, "utf-8").trim();
-    const [pidStr, tsStr] = raw.split(":");
-    return { pid: parseInt(pidStr, 10), ts: parseInt(tsStr, 10) || 0 };
-  } catch { return null; }
-}
-
-function _isLockStale(lockFile) {
-  const info = _readLock(lockFile);
-  if (!info) return true;
-  if (Date.now() - info.ts > INSTALL_LOCK_STALE_MS) return true;
-  if (!_isPidAlive(info.pid)) return true;
-  return false;
-}
-
 /**
- * Check if AgentChattr is fully installed (cloned + venv ready) at `dir`.
+ * Check if AgentChattr is installed (cloned + venv ready) at `dir`.
  * Returns the directory path if both run.py and .venv/bin/python exist, or null.
- * Caller must pass an explicit `dir` — there is no default.
  */
 function findAgentChattr(dir) {
   if (!dir) return null;
@@ -66,232 +13,4 @@ function findAgentChattr(dir) {
   return null;
 }
 
-/**
- * Clone AgentChattr and set up its venv at `dir`. Idempotent — safe to
- * re-run on the same path, and safe to call repeatedly with different
- * paths in the same process. Designed to support per-project clones (#181).
- *
- * Behavior on re-run:
- *   - Fully-installed path → no-op (skips clone, skips venv create, skips pip)
- *   - Missing run.py        → clones (only after refusing to overwrite
- *                             unrelated content; see safety rules below)
- *   - Missing venv          → creates venv and reinstalls requirements
- *
- * Safety rules — never accidentally clean up unrelated directories:
- *   - Empty dir                                  → safe to remove
- *   - Git repo whose origin contains "agentchattr" → safe to remove
- *   - Anything else                              → refuse, return null
- *
- * Concurrency: a per-target lock at `${dir}.install.lock` serializes
- * concurrent installs to the same path. Stale locks (dead pid OR older
- * than 10 min) are reclaimed atomically via rename → unlink. Live
- * peers are polled for up to 30s; after that, returns null with a
- * clear lastError.
- *
- * On failure, returns null and stores a human-readable reason on
- * `installAgentChattr.lastError` so callers can surface it without
- * changing the return shape.
- */
-function installAgentChattr(dir) {
-  if (!dir) {
-    installAgentChattr.lastError = "installAgentChattr: dir is required";
-    return null;
-  }
-  installAgentChattr.lastError = null;
-  const setError = (msg) => { installAgentChattr.lastError = msg; return null; };
-
-  // --- Per-target lock ---
-  const lockFile = `${dir}.install.lock`;
-  try { fs.mkdirSync(path.dirname(lockFile), { recursive: true, mode: 0o700 }); }
-  catch (e) { return setError(`Cannot create parent of ${dir}: ${e.message}`); }
-
-  let acquired = false;
-  const deadline = Date.now() + INSTALL_LOCK_WAIT_TOTAL_MS;
-  while (!acquired) {
-    try {
-      fs.writeFileSync(lockFile, `${process.pid}:${Date.now()}`, { mode: 0o600, flag: "wx" });
-      try { fs.chmodSync(lockFile, 0o600); } catch {}
-      acquired = true;
-    } catch (e) {
-      if (e.code !== "EEXIST") return setError(`Cannot create install lock ${lockFile}: ${e.message}`);
-      if (_isLockStale(lockFile)) {
-        const sideline = `${lockFile}.stale.${process.pid}.${Date.now()}`;
-        try {
-          fs.renameSync(lockFile, sideline);
-          try { fs.unlinkSync(sideline); } catch {}
-        } catch (renameErr) {
-          if (renameErr.code !== "ENOENT") {
-            return setError(`Cannot reclaim stale lock ${lockFile}: ${renameErr.message}`);
-          }
-        }
-        continue;
-      }
-      if (Date.now() >= deadline) {
-        const info = _readLock(lockFile) || { pid: "?", ts: 0 };
-        return setError(`Another install is in progress at ${dir} (pid ${info.pid}); timed out after ${INSTALL_LOCK_WAIT_TOTAL_MS}ms. Re-run after it finishes, or remove ${lockFile} if stale.`);
-      }
-      try { execFileSync("sleep", [String(INSTALL_LOCK_POLL_MS / 1000)], { stdio: "pipe" }); }
-      catch { /* sleep interrupted; loop will recheck */ }
-    }
-  }
-
-  try {
-    return _installAgentChattrLocked(dir, setError);
-  } finally {
-    try { fs.unlinkSync(lockFile); } catch {}
-  }
-}
-installAgentChattr.lastError = null;
-
-function _installAgentChattrLocked(dir, setError) {
-  const runPy = path.join(dir, "run.py");
-  const venvPython = path.join(dir, ".venv", "bin", "python");
-  let venvJustCreated = false;
-
-  // 1. Clone if run.py is missing.
-  if (!fs.existsSync(runPy)) {
-    if (fs.existsSync(dir)) {
-      let entries;
-      try { entries = fs.readdirSync(dir); }
-      catch (e) { return setError(`Cannot read ${dir}: ${e.message}`); }
-      const isEmpty = entries.length === 0;
-      if (isEmpty) {
-        try { fs.rmSync(dir, { recursive: true, force: true }); }
-        catch (e) { return setError(`Cannot remove empty dir ${dir}: ${e.message}`); }
-      } else if (fs.existsSync(path.join(dir, ".git"))) {
-        const remote = _run("git", ["-C", dir, "remote", "get-url", "origin"]);
-        if (remote && remote.includes("agentchattr")) {
-          try { fs.rmSync(dir, { recursive: true, force: true }); }
-          catch (e) { return setError(`Cannot remove failed clone at ${dir}: ${e.message}`); }
-        } else {
-          return setError(`Refusing to overwrite ${dir}: contains a non-AgentChattr git repo`);
-        }
-      } else {
-        return setError(`Refusing to overwrite ${dir}: directory exists with unrelated content`);
-      }
-    }
-    try { fs.mkdirSync(path.dirname(dir), { recursive: true, mode: 0o700 }); }
-    catch (e) { return setError(`Cannot create parent of ${dir}: ${e.message}`); }
-    const cloneResult = _run("git", ["clone", AGENTCHATTR_REPO, dir], { timeout: 60000 });
-    if (cloneResult === null) return setError(`git clone of ${AGENTCHATTR_REPO} into ${dir} failed`);
-    if (!fs.existsSync(runPy)) return setError(`Clone completed but run.py missing at ${dir}`);
-  }
-
-  // 2. Create venv if missing.
-  if (!fs.existsSync(venvPython)) {
-    const venvResult = _run("python3", ["-m", "venv", path.join(dir, ".venv")], { timeout: 60000 });
-    if (venvResult === null) return setError(`python3 -m venv failed at ${dir}/.venv (is python3 installed?)`);
-    if (!fs.existsSync(venvPython)) return setError(`venv created but ${venvPython} missing`);
-    venvJustCreated = true;
-  }
-
-  // 3. Install requirements only when the venv was just (re)created.
-  if (venvJustCreated) {
-    const reqFile = path.join(dir, "requirements.txt");
-    if (fs.existsSync(reqFile)) {
-      const pipResult = _run(venvPython, ["-m", "pip", "install", "-r", reqFile], { timeout: 120000 });
-      if (pipResult === null) return setError(`pip install -r ${reqFile} failed`);
-    }
-  }
-  // #388: patch sender-column overflow CSS after clone/install
-  patchAgentchattrCss(dir);
-  // #629: patch crash timeout before AC's first import
-  patchCrashTimeout(dir);
-  return dir;
-}
-
-/**
- * Get spawn args for launching AgentChattr from its cloned directory.
- * Returns { command, spawnArgs, cwd } or null if not fully installed.
- * Requires .venv/bin/python — never falls back to bare python3.
- */
-function chattrSpawnArgs(dir, extraArgs) {
-  if (!dir) return null;
-  const venvPython = path.join(dir, ".venv", "bin", "python");
-  if (!fs.existsSync(path.join(dir, "run.py")) || !fs.existsSync(venvPython)) return null;
-  return { command: venvPython, spawnArgs: ["run.py", ...(extraArgs || [])], cwd: dir };
-}
-
-/**
- * #388: Patch AgentChattr's static files for sender-column overflow.
- * Idempotent — skips if the marker is already present.
- * Called after install and after update (git pull overwrites static/).
- *
- * CSS: cap .msg-sender width with ellipsis truncation.
- * JS:  add title attribute to .msg-sender spans for hover tooltip.
- */
-function patchAgentchattrCss(dir) {
-  if (!dir) return;
-  // --- CSS patch ---
-  const cssPath = path.join(dir, "static", "style.css");
-  if (fs.existsSync(cssPath)) {
-    try {
-      const content = fs.readFileSync(cssPath, "utf-8");
-      if (!content.includes("/* quadwork#388 sender-overflow fix */")) {
-        const patch = `
-/* quadwork#388 sender-overflow fix */
-.msg-sender {
-  max-width: 80px;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-  display: inline-block;
-  vertical-align: middle;
-}
-`;
-        fs.writeFileSync(cssPath, content + patch);
-      }
-    } catch {}
-  }
-  // --- JS patch: add title attribute to .msg-sender for hover tooltip ---
-  const jsPath = path.join(dir, "static", "chat.js");
-  if (fs.existsSync(jsPath)) {
-    try {
-      const content = fs.readFileSync(jsPath, "utf-8");
-      if (!content.includes("quadwork#388")) {
-        // Add title= to the msg-sender span so truncated names show full on hover
-        const patched = content.replace(
-          /(<span class="msg-sender" style="color: \$\{senderColor\}">)/g,
-          `<span class="msg-sender" title="\${escapeHtml(msg.sender)}" style="color: \${senderColor}">`,
-        );
-        if (patched !== content) {
-          fs.writeFileSync(jsPath, patched + "\n// quadwork#388\n");
-        }
-      }
-    } catch {}
-  }
-}
-
-/**
- * #629: Patch AC's crash timeout from 15s to 120s.
- * Must run at clone time (before any `python run.py`) so the first
- * AC process imports the patched value. Idempotent.
- */
-function patchCrashTimeout(dir) {
-  if (!dir) return;
-  const appPath = path.join(dir, "app.py");
-  if (!fs.existsSync(appPath)) return;
-  try {
-    let app = fs.readFileSync(appPath, "utf-8");
-    if (app.includes("_CRASH_TIMEOUT = 15")) {
-      app = app.replace("_CRASH_TIMEOUT = 15", "_CRASH_TIMEOUT = 120");
-      app = app.replace(
-        "# Crash timeout: if a wrapper hasn't heartbeated for 60s,\n",
-        "# Crash timeout: if a wrapper hasn't heartbeated for 120s,\n",
-      );
-      fs.writeFileSync(appPath, app);
-      console.log(`[idle-fix] patched crash timeout to 120s at clone time (#629): ${dir}`);
-    }
-  } catch (err) {
-    console.warn(`[idle-fix] failed to patch crash timeout in ${appPath}: ${err.message}`);
-  }
-}
-
-module.exports = {
-  AGENTCHATTR_REPO,
-  findAgentChattr,
-  installAgentChattr,
-  chattrSpawnArgs,
-  patchAgentchattrCss,
-  patchCrashTimeout,
-};
+module.exports = { findAgentChattr };

package/server/mcp-chat-shim.js

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+"use strict";
+
+const http = require("http");
+const readline = require("readline");
+
+const args = process.argv.slice(2);
+function flag(name) {
+  const i = args.indexOf(`--${name}`);
+  return i >= 0 && i + 1 < args.length ? args[i + 1] : null;
+}
+
+const PROJECT = flag("project");
+const AGENT = flag("agent");
+const PORT = flag("port");
+const TOKEN = flag("token");
+
+if (!PROJECT || !AGENT || !PORT) {
+  process.stderr.write("Usage: node mcp-chat-shim.js --project <id> --agent <id> --port <port> [--token <token>]\n");
+  process.exit(1);
+}
+
+const BASE = `http://127.0.0.1:${PORT}`;
+
+const TOOLS = [
+  {
+    name: "chat_send",
+    description: "Send a message to the project chat",
+    inputSchema: {
+      type: "object",
+      properties: {
+        channel: { type: "string", default: "general" },
+        message: { type: "string" },
+      },
+      required: ["message"],
+    },
+  },
+  {
+    name: "chat_read",
+    description: "Read recent messages from project chat",
+    inputSchema: {
+      type: "object",
+      properties: {
+        channel: { type: "string", default: "general" },
+        limit: { type: "number", default: 50 },
+        since_id: { type: "number" },
+      },
+    },
+  },
+];
+
+function jsonRpc(id, result) {
+  return JSON.stringify({ jsonrpc: "2.0", id, result });
+}
+
+function jsonRpcError(id, code, message) {
+  return JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } });
+}
+
+function httpRequest(method, urlPath, body, extraHeaders) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(urlPath, BASE);
+    const opts = {
+      hostname: url.hostname,
+      port: url.port,
+      path: url.pathname + url.search,
+      method,
+      headers: { "Content-Type": "application/json", ...extraHeaders },
+    };
+    const req = http.request(opts, (res) => {
+      let data = "";
+      res.on("data", (c) => (data += c));
+      res.on("end", () => {
+        try {
+          resolve({ status: res.statusCode, body: JSON.parse(data) });
+        } catch {
+          resolve({ status: res.statusCode, body: data });
+        }
+      });
+    });
+    req.on("error", reject);
+    if (body) req.write(JSON.stringify(body));
+    req.end();
+  });
+}
+
+async function handleToolCall(id, name, params) {
+  try {
+    if (name === "chat_send") {
+      const res = await httpRequest("POST", `/api/chat?project=${encodeURIComponent(PROJECT)}`, {
+        text: params.message || "",
+        channel: params.channel || "general",
+      }, { "X-Chat-Sender": AGENT, ...(TOKEN ? { "X-Chat-Token": TOKEN } : {}) });
+      if (res.status >= 400) {
+        return jsonRpcError(id, -32000, `API error ${res.status}: ${JSON.stringify(res.body)}`);
+      }
+      return jsonRpc(id, { content: [{ type: "text", text: JSON.stringify(res.body) }] });
+    }
+
+    if (name === "chat_read") {
+      const qs = new URLSearchParams({ project: PROJECT });
+      if (params.channel) qs.set("channel", params.channel);
+      if (params.limit) qs.set("limit", String(params.limit));
+      if (params.since_id) qs.set("since_id", String(params.since_id));
+      const res = await httpRequest("GET", `/api/chat?${qs.toString()}`);
+      if (res.status >= 400) {
+        return jsonRpcError(id, -32000, `API error ${res.status}: ${JSON.stringify(res.body)}`);
+      }
+      return jsonRpc(id, { content: [{ type: "text", text: JSON.stringify(res.body) }] });
+    }
+
+    return jsonRpcError(id, -32601, `Unknown tool: ${name}`);
+  } catch (err) {
+    return jsonRpcError(id, -32000, err.message);
+  }
+}
+
+// --- MCP stdio protocol ---
+
+async function handleMessage(msg) {
+  const { id, method, params } = msg;
+
+  if (method === "initialize") {
+    return jsonRpc(id, {
+      protocolVersion: "2024-11-05",
+      capabilities: { tools: {} },
+      serverInfo: { name: "quadwork-chat", version: "1.0.0" },
+    });
+  }
+
+  if (method === "initialized") {
+    return null;
+  }
+
+  if (method === "tools/list") {
+    return jsonRpc(id, { tools: TOOLS });
+  }
+
+  if (method === "tools/call") {
+    return handleToolCall(id, params?.name, params?.arguments || {});
+  }
+
+  if (method === "ping") {
+    return jsonRpc(id, {});
+  }
+
+  if (id != null) {
+    return jsonRpcError(id, -32601, `Method not found: ${method}`);
+  }
+  return null;
+}
+
+const rl = readline.createInterface({ input: process.stdin, terminal: false });
+
+rl.on("line", async (line) => {
+  let msg;
+  try {
+    msg = JSON.parse(line);
+  } catch {
+    process.stdout.write(jsonRpcError(null, -32700, "Parse error") + "\n");
+    return;
+  }
+  const response = await handleMessage(msg);
+  if (response) {
+    process.stdout.write(response + "\n");
+  }
+});
+
+rl.on("close", () => {
+  process.exit(0);
+});

package/server/migrate-ac.js

@@ -0,0 +1,158 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { ensureSecureDir, writeSecureFile } = require("./config");
+const { parseMentions } = require("./file-chat");
+
+const KNOWN_FIELDS = new Set([
+  "id", "timestamp", "ts", "sender", "channel", "type", "text", "message", "mentions",
+]);
+
+function convertAcRecord(record, nextId) {
+  let ts;
+  if (record.timestamp) {
+    const raw = Number(record.timestamp);
+    ts = !isNaN(raw) && raw > 0
+      ? new Date(raw * 1000).toISOString()
+      : String(record.timestamp);
+  } else if (record.ts) {
+    const raw = Number(record.ts);
+    ts = !isNaN(raw) && raw > 0
+      ? new Date(raw * 1000).toISOString()
+      : String(record.ts);
+  } else {
+    ts = new Date().toISOString();
+  }
+
+  const text = record.text || record.message || "";
+  const known = {
+    id: nextId,
+    seq: nextId,
+    ts,
+    sender: record.sender || "unknown",
+    channel: record.channel || "general",
+    type: record.type === "system" ? "system" : "message",
+    text,
+    mentions: parseMentions(text),
+  };
+
+  const legacy = {};
+  for (const [key, val] of Object.entries(record)) {
+    if (!KNOWN_FIELDS.has(key)) {
+      legacy[key] = val;
+    }
+  }
+  if (record.type && record.type !== known.type) {
+    legacy.type = record.type;
+  }
+  if (Object.keys(legacy).length > 0) known._legacy = legacy;
+  return known;
+}
+
+function migrateProject(projectId) {
+  const chatDir = path.join(os.homedir(), ".quadwork", projectId, "chat");
+  const migratedPath = path.join(chatDir, ".migrated");
+  const targetPath = path.join(chatDir, "general.jsonl");
+
+  if (fs.existsSync(migratedPath)) return null;
+
+  if (fs.existsSync(targetPath)) {
+    console.log(`[migration] ${projectId}: general.jsonl already exists without .migrated — skipping (Phase 1 test project)`);
+    return null;
+  }
+
+  const acLogPath = path.join(
+    os.homedir(), ".quadwork", projectId, "agentchattr", "data", "agentchattr_log.jsonl"
+  );
+  if (!fs.existsSync(acLogPath)) return null;
+
+  const content = fs.readFileSync(acLogPath, "utf-8");
+  const lines = content.split("\n");
+  const converted = [];
+  let nextId = 0;
+  let skipped = 0;
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    try {
+      const record = JSON.parse(line);
+      converted.push(convertAcRecord(record, nextId));
+      nextId++;
+    } catch {
+      skipped++;
+    }
+  }
+
+  if (converted.length === 0 && skipped === 0) return null;
+
+  if (converted.length === 0 && skipped > 0) {
+    console.log(`[migration] ${projectId}: AC log has ${skipped} lines but none are valid JSON — skipping`);
+    return null;
+  }
+
+  ensureSecureDir(chatDir);
+
+  const tmpPath = targetPath + ".tmp";
+  const output = converted.map((r) => JSON.stringify(r)).join("\n") + "\n";
+  writeSecureFile(tmpPath, output);
+
+  const verifyContent = fs.readFileSync(tmpPath, "utf-8");
+  const verifyLines = verifyContent.trim().split("\n");
+  let verified = 0;
+  for (const vl of verifyLines) {
+    try {
+      JSON.parse(vl);
+      verified++;
+    } catch {
+      fs.unlinkSync(tmpPath);
+      throw new Error(`Migration validation failed for ${projectId}: corrupt line in tmp file`);
+    }
+  }
+  if (verified !== converted.length) {
+    fs.unlinkSync(tmpPath);
+    throw new Error(`Migration validation failed for ${projectId}: expected ${converted.length} records, got ${verified}`);
+  }
+
+  fs.renameSync(tmpPath, targetPath);
+  try { fs.chmodSync(targetPath, 0o600); } catch {}
+
+  const systemMsg = {
+    id: nextId,
+    seq: nextId,
+    ts: new Date().toISOString(),
+    sender: "system",
+    channel: "general",
+    type: "system",
+    text: `Chat history migrated from AC (${converted.length} messages)`,
+    mentions: [],
+  };
+  fs.appendFileSync(targetPath, JSON.stringify(systemMsg) + "\n", { mode: 0o600 });
+
+  const manifest = {
+    migrated_at: new Date().toISOString(),
+    source: acLogPath,
+    messages: converted.length,
+    skipped,
+  };
+  writeSecureFile(migratedPath, JSON.stringify(manifest, null, 2) + "\n");
+
+  console.log(`[migration] ${projectId}: migrated ${converted.length} messages, ${skipped} skipped (invalid JSON)`);
+  return { messages: converted.length, skipped };
+}
+
+function runAcMigration(config) {
+  const failed = [];
+  const projects = config.projects || [];
+  for (const project of projects) {
+    if (!project || !project.id) continue;
+    try {
+      migrateProject(project.id);
+    } catch (err) {
+      console.error(`[migration] ${project.id}: failed — ${err.message}`);
+      failed.push(project.id);
+    }
+  }
+  return failed;
+}
+
+module.exports = { runAcMigration, migrateProject, convertAcRecord };