@tenonhq/dovetail-dashboard 0.0.13 → 0.0.15

package/server.js

@@ -23,6 +23,11 @@ const recentEditsLimiter = RateLimit({
   windowMs: 15 * 60 * 1000,
   max: 100,
 });
+// Rate limiter for claude-plans destructive operations
+const claudePlansLimiter = RateLimit({
+  windowMs: 15 * 60 * 1000,
+  max: 60,
+});
 const SN_PASSWORD = process.env.SN_PASSWORD || "";
 const BASE_URL = `https://${SN_INSTANCE}`;
 
@@ -279,6 +284,7 @@ app.get("/api/recent-edits", recentEditsLimiter, async function (req, res) {
       }
 
       enriched.push({
+        sys_id: edit.sys_id,
         tableName: edit.tableName,
         name: edit.name,
         scope: edit.scope,
@@ -293,6 +299,28 @@ app.get("/api/recent-edits", recentEditsLimiter, async function (req, res) {
   }
 });
 
+// POST /api/recent-edits/dismiss — remove one entry from the local recent edits file
+app.post("/api/recent-edits/dismiss", function (req, res) {
+  try {
+    var sys_id = req.body.sys_id;
+    var tableName = req.body.tableName;
+    if (!sys_id || !tableName) {
+      return res.status(400).json({ error: "sys_id and tableName required" });
+    }
+    var edits = [];
+    if (fs.existsSync(RECENT_EDITS_FILE)) {
+      edits = JSON.parse(fs.readFileSync(RECENT_EDITS_FILE, "utf8"));
+    }
+    var filtered = edits.filter(function (e) {
+      return !(e.sys_id === sys_id && e.tableName === tableName);
+    });
+    fs.writeFileSync(RECENT_EDITS_FILE, JSON.stringify(filtered, null, 2));
+    res.json({ ok: true });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
 // GET /api/update-sets/:scope — list in-progress update sets for a scope
 app.get("/api/update-sets/:scope", async (req, res) => {
   try {
@@ -772,14 +800,244 @@ app.post("/api/clickup/deselect-task", function (req, res) {
   }
 });
 
+// --- Claude Plans Panel ---
+// Reads JSON records written by @tenonhq/dovetail-claude-plans into
+// ~/.dovetail/claude-plans/ and streams updates to the /claude-plans page.
+// Storage layout:
+//   <root>/<plan-slug>.json
+//   <root>/<plan-slug>/artifacts/<artifact-slug>.json
+const os = require("os");
+const chokidar = require("chokidar");
+
+const CLAUDE_PLANS_DIR =
+  process.env.DOVE_CLAUDE_PLANS_DIR ||
+  path.join(os.homedir(), ".dovetail", "claude-plans");
+
+// Slugs are written by @tenonhq/dovetail-claude-plans' slugify() — kebab-case,
+// max 64 chars. We re-validate on the read side so a request like `..%2Ffoo`
+// cannot escape CLAUDE_PLANS_DIR via path.join.
+const CLAUDE_PLAN_SLUG = /^[a-z0-9][a-z0-9-]{0,63}$/;
+
+function isValidSlug(slug) {
+  return typeof slug === "string" && CLAUDE_PLAN_SLUG.test(slug);
+}
+
+function planFilePath(slug) {
+  return path.join(CLAUDE_PLANS_DIR, slug + ".json");
+}
+
+function artifactsDirFor(slug) {
+  return path.join(CLAUDE_PLANS_DIR, slug, "artifacts");
+}
+
+function safeReadJson(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (e) {
+    return null;
+  }
+}
+
+function listClaudePlans() {
+  if (!fs.existsSync(CLAUDE_PLANS_DIR)) return [];
+  const entries = fs.readdirSync(CLAUDE_PLANS_DIR);
+  const plans = [];
+  for (let i = 0; i < entries.length; i++) {
+    const name = entries[i];
+    if (!name.endsWith(".json")) continue;
+    const plan = safeReadJson(path.join(CLAUDE_PLANS_DIR, name));
+    if (plan) plans.push(plan);
+  }
+  plans.sort(function (a, b) {
+    return (b.updated_at || "").localeCompare(a.updated_at || "");
+  });
+  return plans;
+}
+
+function listClaudeArtifacts(slug) {
+  if (!isValidSlug(slug)) return [];
+  const dir = artifactsDirFor(slug);
+  if (!fs.existsSync(dir)) return [];
+  const entries = fs.readdirSync(dir);
+  const artifacts = [];
+  for (let i = 0; i < entries.length; i++) {
+    if (!entries[i].endsWith(".json")) continue;
+    const a = safeReadJson(path.join(dir, entries[i]));
+    if (a) artifacts.push(a);
+  }
+  artifacts.sort(function (a, b) {
+    return (a.created_at || "").localeCompare(b.created_at || "");
+  });
+  return artifacts;
+}
+
+// Parse a watcher path like "<root>/<slug>.json" or
+// "<root>/<slug>/artifacts/<artifact-slug>.json" into { kind, slug, artifactSlug }.
+function classifyPath(filePath) {
+  const rel = path.relative(CLAUDE_PLANS_DIR, filePath);
+  if (!rel || rel.startsWith("..")) return null;
+  const parts = rel.split(path.sep);
+  if (parts.length === 1 && parts[0] === ".focus") {
+    return { kind: "focus" };
+  }
+  if (parts.length === 1 && parts[0].endsWith(".json")) {
+    return { kind: "plan", slug: parts[0].slice(0, -5) };
+  }
+  if (parts.length === 3 && parts[1] === "artifacts" && parts[2].endsWith(".json")) {
+    return { kind: "artifact", slug: parts[0], artifactSlug: parts[2].slice(0, -5) };
+  }
+  return null;
+}
+
+// SSE fan-out. Each connected client is a response object held open until the
+// client disconnects; broadcastClaudePlanEvent writes a single SSE frame to all.
+const claudePlanSseClients = new Set();
+
+function broadcastClaudePlanEvent(event, data) {
+  const frame = "event: " + event + "\ndata: " + JSON.stringify(data) + "\n\n";
+  for (const res of claudePlanSseClients) {
+    try {
+      res.write(frame);
+    } catch (err) {
+      claudePlanSseClients.delete(res);
+    }
+  }
+}
+
+function handleWatcherChange(event, filePath) {
+  const info = classifyPath(filePath);
+  if (!info) return;
+  if (info.kind === "focus") {
+    const focus = safeReadJson(filePath);
+    if (focus && isValidSlug(focus.slug)) {
+      broadcastClaudePlanEvent("plan:focus", { slug: focus.slug });
+    }
+    return;
+  }
+  if (info.kind === "plan") {
+    if (event === "unlink") {
+      broadcastClaudePlanEvent("plan:delete", { slug: info.slug });
+      return;
+    }
+    const plan = safeReadJson(filePath);
+    if (plan) broadcastClaudePlanEvent("plan:upsert", { plan: plan });
+    return;
+  }
+  if (info.kind === "artifact") {
+    if (event === "unlink") {
+      broadcastClaudePlanEvent("artifact:delete", {
+        plan_slug: info.slug,
+        slug: info.artifactSlug
+      });
+      return;
+    }
+    const artifact = safeReadJson(filePath);
+    if (artifact) broadcastClaudePlanEvent("artifact:upsert", { artifact: artifact });
+  }
+}
+
+// Start the watcher lazily — create the storage dir if missing so chokidar has
+// something to watch. ignoreInitial avoids replaying every file on boot
+// (clients fetch initial state via GET /api/claude-plans).
+let claudePlanWatcher = null;
+function startClaudePlanWatcher() {
+  if (claudePlanWatcher) return;
+  try {
+    fs.mkdirSync(CLAUDE_PLANS_DIR, { recursive: true });
+  } catch (err) {
+    console.warn("[claude-plans] could not create storage dir:", err.message);
+  }
+  claudePlanWatcher = chokidar.watch(CLAUDE_PLANS_DIR, {
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 50, pollInterval: 25 },
+    depth: 3
+  });
+  claudePlanWatcher.on("add", function (p) { handleWatcherChange("add", p); });
+  claudePlanWatcher.on("change", function (p) { handleWatcherChange("change", p); });
+  claudePlanWatcher.on("unlink", function (p) { handleWatcherChange("unlink", p); });
+}
+
+app.get("/claude-plans", function (req, res) {
+  res.sendFile(path.join(__dirname, "public", "claude-plans.html"));
+});
+
+app.get("/api/claude-plans", function (req, res) {
+  try {
+    res.json({ plans: listClaudePlans(), storage: CLAUDE_PLANS_DIR });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+app.get("/api/claude-plans/stream", function (req, res) {
+  res.set({
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+    "X-Accel-Buffering": "no"
+  });
+  res.flushHeaders();
+  res.write("event: hello\ndata: {}\n\n");
+  claudePlanSseClients.add(res);
+
+  const heartbeat = setInterval(function () {
+    try {
+      res.write(": heartbeat\n\n");
+    } catch (err) {
+      clearInterval(heartbeat);
+      claudePlanSseClients.delete(res);
+    }
+  }, 25000);
+
+  req.on("close", function () {
+    clearInterval(heartbeat);
+    claudePlanSseClients.delete(res);
+  });
+});
+
+// :slug must avoid the static "stream" route above; Express matches in order.
+app.get("/api/claude-plans/:slug", function (req, res) {
+  try {
+    const slug = req.params.slug;
+    if (!isValidSlug(slug)) return res.status(400).json({ error: "invalid slug" });
+    const plan = safeReadJson(planFilePath(slug));
+    if (!plan) return res.status(404).json({ error: "plan not found" });
+    res.json({ plan: plan, artifacts: listClaudeArtifacts(slug) });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+app.delete("/api/claude-plans/:slug", claudePlansLimiter, function (req, res) {
+  try {
+    var slug = req.params.slug;
+    if (!isValidSlug(slug)) return res.status(400).json({ error: "invalid slug" });
+    var baseDir = path.resolve(CLAUDE_PLANS_DIR);
+    var planFile = path.resolve(baseDir, slug + ".json");
+    if (!planFile.startsWith(baseDir + path.sep)) return res.status(400).json({ error: "invalid slug" });
+    if (!fs.existsSync(planFile)) return res.status(404).json({ error: "plan not found" });
+    fs.unlinkSync(planFile);
+    var artifactsDir = path.resolve(baseDir, slug);
+    if (artifactsDir.startsWith(baseDir + path.sep) && fs.existsSync(artifactsDir)) {
+      fs.rmSync(artifactsDir, { recursive: true, force: true });
+    }
+    res.json({ deleted: true });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
 // Only start the server when run directly (not when require()-d).
 // Callers like dashboardCommand.ts and allScopesCommands.ts use
 // spawn("node", [serverPath]) which sets require.main === module.
 if (require.main === module) {
+  startClaudePlanWatcher();
   app.listen(PORT, "127.0.0.1", function () {
     console.log("\n  Dovetail Update Set Dashboard");
     console.log("  Instance:  " + SN_INSTANCE);
     console.log("  Project:   " + PROJECT_ROOT);
-    console.log("  Dashboard: http://localhost:" + PORT + "\n");
+    console.log("  Dashboard: http://localhost:" + PORT);
+    console.log("  Claude:    http://localhost:" + PORT + "/claude-plans\n");
   });
 }