herdr-plugin-amq 0.1.9 → 0.1.11

package/src/protocol.mjs

@@ -83,17 +83,48 @@ function openNoFollow(filePath, flags, mode) {
   return fs.openSync(filePath, flags | noFollow, mode);
 }
 
-function descriptorPath(fd) {
+function isDirectoryHandle(handle) {
+  return Boolean(handle && typeof handle === "object");
+}
+
+function closeDirectory(handle) {
+  if (!isDirectoryHandle(handle)) fs.closeSync(handle);
+}
+
+function descriptorPath(handle) {
+  if (isDirectoryHandle(handle)) return handle.path;
   const base = process.platform === "darwin" ? "/dev/fd" : "/proc/self/fd";
-  return path.join(base, String(fd));
+  return path.join(base, String(handle));
 }
 
-function openRelativeNoFollow(dirFd, name, flags, mode) {
+function openRelativeNoFollow(dirHandle, name, flags, mode) {
   if (!name || path.basename(name) !== name) throw new Error("Invalid relative Maildir name");
-  return openNoFollow(path.join(descriptorPath(dirFd), name), flags, mode);
+  return openNoFollow(path.join(descriptorPath(dirHandle), name), flags, mode);
+}
+
+function resolveDarwinDirectory(dirPath) {
+  const resolved = path.resolve(dirPath);
+  const parsed = path.parse(resolved);
+  const segments = resolved.slice(parsed.root.length).split(path.sep).filter(Boolean);
+  const systemSymlinkRoots = new Set(["/private", "/tmp", "/var"]);
+  let current = parsed.root;
+  for (const segment of segments) {
+    current = path.join(current, segment);
+    const stat = fs.lstatSync(current);
+    if (stat.isSymbolicLink()) {
+      if (!systemSymlinkRoots.has(current)) throw new Error("Symlinked directory is not allowed");
+      current = fs.realpathSync(current);
+      continue;
+    }
+    if (!stat.isDirectory()) throw new Error("Maildir path is not a directory");
+  }
+  const realPath = fs.realpathSync(current);
+  if (!fs.statSync(realPath).isDirectory()) throw new Error("Maildir path is not a directory");
+  return realPath;
 }
 
 function openDirectorySecure(dirPath) {
+  if (process.platform === "darwin") return { path: resolveDarwinDirectory(dirPath) };
   const resolved = path.resolve(dirPath);
   const parsed = path.parse(resolved);
   const segments = resolved.slice(parsed.root.length).split(path.sep).filter(Boolean);
@@ -102,12 +133,12 @@ function openDirectorySecure(dirPath) {
   try {
     for (const segment of segments) {
       const next = openRelativeNoFollow(current, segment, directoryFlag);
-      fs.closeSync(current);
+      closeDirectory(current);
       current = next;
     }
     return current;
   } catch (error) {
-    fs.closeSync(current);
+    closeDirectory(current);
     throw error;
   }
 }
@@ -145,7 +176,7 @@ export function writeBoundedFileAtomic(filePath, content, maxBytes = MAX_MAILDIR
   try {
     writeFileAtomicBetweenDirectories(path.basename(filePath), dirFd, dirFd, content, maxBytes);
   } finally {
-    fs.closeSync(dirFd);
+    closeDirectory(dirFd);
   }
 }
 
@@ -154,7 +185,7 @@ export function listMaildirMessageFiles(dirPath) {
   try {
     return fs.readdirSync(descriptorPath(dirFd));
   } finally {
-    fs.closeSync(dirFd);
+    closeDirectory(dirFd);
   }
 }
 
@@ -176,8 +207,8 @@ export function moveMaildirMessage(amqRoot, handle, fromFolder, toFolder, fileNa
     );
     return path.join(toDir, fileName);
   } finally {
-    fs.closeSync(fromFd);
-    if (toFd !== undefined) fs.closeSync(toFd);
+    closeDirectory(fromFd);
+    if (toFd !== undefined) closeDirectory(toFd);
   }
 }
 
@@ -206,7 +237,7 @@ export function readMaildirMessageFile(filePath, maxBytes = MAX_MAILDIR_FILE_BYT
     return Buffer.concat(chunks, total).toString("utf8");
   } finally {
     if (fd !== undefined) fs.closeSync(fd);
-    fs.closeSync(dirFd);
+    closeDirectory(dirFd);
   }
 }
 
@@ -410,8 +441,8 @@ export function sendMaildirMessage(amqRoot, options = {}) {
       newFd = openDirectorySecure(path.join(recipientDir, "inbox", "new"));
       writeFileAtomicBetweenDirectories(`${msgId}.md`, tmpFd, newFd, fileText);
     } finally {
-      fs.closeSync(tmpFd);
-      if (newFd !== undefined) fs.closeSync(newFd);
+      closeDirectory(tmpFd);
+      if (newFd !== undefined) closeDirectory(newFd);
     }
   }
 
@@ -420,7 +451,7 @@ export function sendMaildirMessage(amqRoot, options = {}) {
   try {
     writeFileAtomicBetweenDirectories(`${msgId}.md`, sentFd, sentFd, fileText);
   } finally {
-    fs.closeSync(sentFd);
+    closeDirectory(sentFd);
   }
 
   return {
@@ -449,8 +480,9 @@ export function markMaildirMessageRead(amqRoot, handle, msgId) {
     if (!agentDir) return { ok: false, error: "Mailbox not found" };
     const newPath = path.join(agentDir, "inbox", "new", `${msgId}.md`);
     const curPath = path.join(agentDir, "inbox", "cur", `${msgId}.md`);
+    const logicalCurPath = path.join(amqRoot, "agents", handle, "inbox", "cur", `${msgId}.md`);
     if (!fs.existsSync(newPath)) {
-      if (fs.existsSync(curPath)) return { ok: true, alreadyRead: true, id: msgId, filePath: curPath };
+      if (fs.existsSync(curPath)) return { ok: true, alreadyRead: true, id: msgId, filePath: logicalCurPath };
       return { ok: false, error: "Message not found" };
     }
 
@@ -464,7 +496,7 @@ export function markMaildirMessageRead(amqRoot, handle, msgId) {
 
     const filePath = moveMaildirMessage(amqRoot, handle, "new", "cur", `${msgId}.md`);
     if (!filePath) return { ok: false, error: "Message could not be marked read" };
-    return { ok: true, alreadyRead: false, id: msgId, filePath };
+    return { ok: true, alreadyRead: false, id: msgId, filePath: logicalCurPath };
   } catch (error) {
     return { ok: false, error: error.message };
   }

package/src/server.mjs

@@ -1,8 +1,9 @@
 import http from "node:http";
 import fs from "node:fs";
 import path from "node:path";
+import { execFile } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { findAmqRoot, getAgentHandles } from "./config.mjs";
+import { findAmqRoot, getAgentHandles, getHerdrBin } from "./config.mjs";
 import { markMaildirMessageRead } from "./protocol.mjs";
 import {
   loadAllMessages,
@@ -37,6 +38,7 @@ import {
 import {
   getHerdrAgents,
   getHerdrStatusMap,
+  normalizeHerdrStatus,
   subscribeHerdrEvents,
   isHerdrAvailable,
   getSocketPath,
@@ -58,6 +60,55 @@ import {
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const WEB_ROOT = path.join(__dirname, "web");
+const HERDR_STATUS_EVENT_TYPES = new Set(["pane_agent_status_changed", "pane.agent_status_changed", "pane.updated", "agent.state_changed", "agent.updated"]);
+const HERDR_REFRESH_EVENT_TYPES = new Set(["pane_agent_detected", "pane.created", "pane.closed", "workspace.created", "workspace.closed", "agent.created", "agent.closed"]);
+
+// Strict CSP for the local dashboard. media-src 'self' covers same-origin
+// <video> attachments streamed from /api/blob/* and /api/file.
+export const CONTENT_SECURITY_POLICY =
+  "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob:; media-src 'self'; connect-src 'self'; frame-ancestors 'none';";
+
+export function isHerdrStatusEvent(type) {
+  return HERDR_STATUS_EVENT_TYPES.has(String(type || ""));
+}
+
+export function isHerdrRefreshEvent(type) {
+  return HERDR_REFRESH_EVENT_TYPES.has(String(type || ""));
+}
+
+export function findHerdrEventHandle(cache, event) {
+  if (!cache || !event) return null;
+  const directHandle = String(event.name || event.handle || "").trim();
+  if (directHandle && cache.has(directHandle)) return directHandle;
+  const paneId = String(event.pane_id || "").trim();
+  if (!paneId) return null;
+  for (const [handle, activity] of cache.entries()) {
+    if (activity?.herdrPaneId === paneId) return handle;
+  }
+  return null;
+}
+
+export function mergeHerdrStatusEvent(cache, event, observedAt = new Date().toISOString()) {
+  const handle = findHerdrEventHandle(cache, event);
+  if (!handle || !event?.agent_status) return null;
+  const current = cache.get(handle) || {};
+  const nextSeq = Number(event.state_change_seq);
+  const currentSeq = Number(current.herdrStateChangeSeq);
+  if (Number.isFinite(nextSeq) && Number.isFinite(currentSeq) && nextSeq < currentSeq) return null;
+
+  const next = {
+    ...current,
+    herdrStatus: normalizeHerdrStatus(event.agent_status),
+    herdrObservedAt: observedAt,
+  };
+  if (Number.isFinite(nextSeq)) next.herdrStateChangeSeq = nextSeq;
+  if (event.state_labels && typeof event.state_labels === "object" && !Array.isArray(event.state_labels)) {
+    next.herdrStateLabels = { ...event.state_labels };
+  }
+  if (typeof event.title === "string" && event.title.trim()) next.herdrTitle = event.title.trim();
+  cache.set(handle, next);
+  return { handle, activity: next };
+}
 
 export function startWebServer({
   port = 8505,
@@ -77,6 +128,8 @@ export function startWebServer({
   let herdrStatusCache = new Map();
   let herdrSubscription = null;
   let herdrRefreshDebounce = null;
+  let herdrStatusFlushTimer = null;
+  const pendingHerdrStatusEvents = new Map();
 
   function broadcastSSE(payload) {
     const msg = `data: ${JSON.stringify(payload)}\n\n`;
@@ -100,6 +153,36 @@ export function startWebServer({
     }, 80);
   }
 
+  function queueHerdrStatusEvent(event) {
+    const handle = findHerdrEventHandle(herdrStatusCache, event);
+    if (!handle || !event?.agent_status) {
+      scheduleHerdrRefresh("status");
+      return;
+    }
+    const current = herdrStatusCache.get(handle);
+    const nextStatus = normalizeHerdrStatus(event.agent_status);
+    if (current?.herdrStatus === nextStatus && !event.state_labels && !event.title) return;
+    pendingHerdrStatusEvents.set(handle, event);
+    if (herdrStatusFlushTimer) return;
+    herdrStatusFlushTimer = setTimeout(() => {
+      herdrStatusFlushTimer = null;
+      const pending = new Map(pendingHerdrStatusEvents);
+      pendingHerdrStatusEvents.clear();
+      for (const [pendingHandle, pendingEvent] of pending) {
+        const merged = mergeHerdrStatusEvent(herdrStatusCache, pendingEvent);
+        if (!merged || merged.handle !== pendingHandle) continue;
+        broadcastSSE({
+          type: "herdr_agent_update",
+          handle: merged.handle,
+          herdrStatus: merged.activity.herdrStatus,
+          stateLabels: merged.activity.herdrStateLabels || {},
+          title: merged.activity.herdrTitle || null,
+          at: merged.activity.herdrObservedAt,
+        });
+      }
+    }, 250);
+  }
+
   let isClosing = false;
   let herdrReconnectTimeout = null;
 
@@ -114,17 +197,17 @@ export function startWebServer({
       },
       onEvent: (event) => {
         const type = String(event?.type || "");
-        if (
-          type.startsWith("pane.") ||
-          type.startsWith("agent.") ||
-          type === "workspace.created" ||
-          type === "workspace.closed"
-        ) {
+        if (isHerdrStatusEvent(type)) {
+          queueHerdrStatusEvent(event);
+        } else if (isHerdrRefreshEvent(type)) {
           scheduleHerdrRefresh(type);
         }
       },
       onDisconnect: () => {
         herdrStatusCache = new Map();
+        pendingHerdrStatusEvents.clear();
+        if (herdrStatusFlushTimer) clearTimeout(herdrStatusFlushTimer);
+        herdrStatusFlushTimer = null;
         broadcastSSE({ type: "herdr_agents_refresh", reason: "disconnected", at: new Date().toISOString() });
         if (!isClosing) {
           herdrReconnectTimeout = setTimeout(startHerdrSubscription, 5000);
@@ -136,6 +219,26 @@ export function startWebServer({
   // Start Herdr integration (non-fatal if Herdr not running)
   refreshHerdrCache().then(() => startHerdrSubscription()).catch(() => {});
 
+  // Safety poll: socket events alone left the cache 28+ minutes stale when
+  // status transitions arrived under an unsubscribed type. Re-poll on a
+  // timer and broadcast only when the status signature actually changed.
+  const HERDR_SAFETY_POLL_MS = parseInt(process.env.HERDR_SAFETY_POLL_MS || "20000", 10);
+  const herdrCacheSignature = () =>
+    [...herdrStatusCache].map(([h, v]) => `${h}:${v?.herdrStatus || "?"}`).sort().join("|");
+  let lastHerdrSignature = herdrCacheSignature();
+  const herdrSafetyTimer = setInterval(async () => {
+    if (isClosing) return;
+    try {
+      await refreshHerdrCache();
+      const sig = herdrCacheSignature();
+      if (sig !== lastHerdrSignature) {
+        lastHerdrSignature = sig;
+        broadcastSSE({ type: "herdr_agents_refresh", reason: "safety-poll", at: new Date().toISOString() });
+      }
+    } catch {}
+  }, HERDR_SAFETY_POLL_MS);
+  if (herdrSafetyTimer.unref) herdrSafetyTimer.unref();
+
   let watchDebounce = null;
   let watcher = null;
   try {
@@ -177,7 +280,7 @@ export function startWebServer({
     res.setHeader("X-Frame-Options", "DENY");
     res.setHeader(
       "Content-Security-Policy",
-      "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob:; connect-src 'self'; frame-ancestors 'none';"
+      CONTENT_SECURITY_POLICY
     );
     res.setHeader("Referrer-Policy", "no-referrer");
 
@@ -306,11 +409,50 @@ export function startWebServer({
     if (pathname === "/api/herdr-agents" && req.method === "GET") {
       // Raw Herdr agent snapshot — all panes, not just named ones
       const agents = await getHerdrAgents();
-      res.writeHead(200, { "Content-Type": "application/json" });
+      res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
       res.end(JSON.stringify(agents));
       return;
     }
 
+    if (pathname === "/api/panes" && req.method === "GET") {
+      // Live terminal tails per registered lane via `herdr agent read`.
+      // Bounded: clamped line count, per-pane timeout, truncated output.
+      const rawLines = parseInt(url.searchParams.get("lines") || "40", 10);
+      const lineCount = Number.isFinite(rawLines) ? Math.min(200, Math.max(5, rawLines)) : 40;
+      const only = (url.searchParams.get("handle") || "").trim();
+      const agents = loadAgentDirectory(amqRoot).filter((a) => !only || a.handle === only);
+      const panes = await Promise.all(
+        agents.map(
+          (a) =>
+            new Promise((resolve) => {
+              execFile(
+                getHerdrBin(),
+                ["agent", "read", a.handle, "--lines", String(lineCount), "--format", "text"],
+                { timeout: 8000, maxBuffer: 1024 * 1024 },
+                (err, stdout) => {
+                  const clean = String(stdout || "")
+                    // eslint-disable-next-line no-control-regex
+                    .replace(/\u001b\[[0-9;]*m/g, "")
+                    .replace(/\r/g, "");
+                  // Stable error code only: raw spawn errors leak tmp paths
+                  // and binary locations into the UI (and API responses).
+                  resolve({
+                    handle: a.handle,
+                    ok: !err,
+                    error: err ? "herdr-unavailable" : null,
+                    output: clean.slice(-6000),
+                    at: new Date().toISOString(),
+                  });
+                }
+              );
+            })
+        )
+      );
+      res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
+      res.end(JSON.stringify(panes));
+      return;
+    }
+
     if (pathname === "/api/agents" && req.method === "POST") {
       const body = await parseJsonBody(req);
       if (body.__error) {
@@ -813,6 +955,9 @@ export function startWebServer({
     }
     if (herdrReconnectTimeout) clearTimeout(herdrReconnectTimeout);
     if (herdrRefreshDebounce) clearTimeout(herdrRefreshDebounce);
+    if (herdrStatusFlushTimer) clearTimeout(herdrStatusFlushTimer);
+    if (herdrSafetyTimer) clearInterval(herdrSafetyTimer);
+    pendingHerdrStatusEvents.clear();
     if (watchDebounce) clearTimeout(watchDebounce);
     if (herdrSubscription) {
       try { herdrSubscription.close(); } catch {}

package/src/store.mjs

@@ -13,6 +13,7 @@ const PALETTE = [
   "#9c27b0", "#009688", "#e91e63", "#3f51b5", "#00bcd4",
   "#795548", "#607d8b", "#673ab7", "#2e7d32", "#c2185b"
 ];
+const LEGACY_PLACEHOLDER_MODEL = "gemini 3.8 flash (high)";
 
 export function getAgentColor(handle = "") {
   let hash = 0;
@@ -205,6 +206,7 @@ export function extractAttachments(body = "", metaAttachments = [], amqRoot = nu
 
     const ext = path.extname(clean).toLowerCase();
     const isImage = [".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".bmp"].includes(ext);
+    const isVideo = [".mp4", ".m4v", ".webm"].includes(ext);
     const isLog = [".log", ".txt", ".csv", ".json", ".out", ".diff", ".patch"].includes(ext);
 
     // 1. Check disk resolution first (sub-millisecond)
@@ -221,6 +223,7 @@ export function extractAttachments(body = "", metaAttachments = [], amqRoot = nu
         name: base,
         ext,
         isImage,
+        isVideo,
         isLog,
         exists: true,
         sizeBytes,
@@ -236,6 +239,10 @@ export function extractAttachments(body = "", metaAttachments = [], amqRoot = nu
       if (hashMatch) {
         const stored = getBlob(hashMatch[1], amqRoot);
         if (stored) {
+          const storedExt = (stored.ext || ext).toLowerCase();
+          const storedIsImage = [".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".bmp"].includes(storedExt);
+          const storedIsVideo = [".mp4", ".m4v", ".webm"].includes(storedExt);
+          const storedIsLog = [".log", ".txt", ".csv", ".json", ".out", ".diff", ".patch"].includes(storedExt);
           attachments.push({
             type: "blob",
             sha256: stored.sha256,
@@ -243,8 +250,9 @@ export function extractAttachments(body = "", metaAttachments = [], amqRoot = nu
             ext: stored.ext,
             mime: stored.mime,
             sizeBytes: stored.sizeBytes,
-            isImage,
-            isLog,
+            isImage: storedIsImage,
+            isVideo: storedIsVideo,
+            isLog: storedIsLog,
             exists: true,
             sizeDisplay: formatFileSize(stored.sizeBytes),
             url: `/api/blob/${stored.sha256}${stored.ext ? `?ext=${encodeURIComponent(stored.ext)}` : ""}`,
@@ -261,6 +269,7 @@ export function extractAttachments(body = "", metaAttachments = [], amqRoot = nu
       name: base,
       ext,
       isImage,
+      isVideo,
       isLog,
       exists: false,
       sizeBytes: 0,
@@ -822,7 +831,7 @@ export function loadAgentDirectory(amqRoot) {
     const brief = briefs.get(h) || null;
     const name = customProfile?.name || presence?.name || brief?.name || formatAgentTitle(h);
     const role = customProfile?.role || (presence?.role && presence.role !== "Swarm Agent" ? presence.role : null) || brief?.role || brief?.description || (h === "user" ? "Human Operator" : "Swarm Agent");
-    const model = customProfile?.model || brief?.model || "claude-3-7-sonnet";
+    const model = normalizeModel(customProfile?.model) || normalizeModel(brief?.model);
     const emoji = customProfile?.emoji || presence?.emoji || (h === "user" ? "👤" : h.slice(0, 1).toUpperCase());
     const color = customProfile?.color || presence?.color || getAgentColor(h);
     const worktree = customProfile?.worktree || null;
@@ -883,6 +892,12 @@ function normalizeText(value, fallback, maxLength) {
   return normalized ? normalized.slice(0, maxLength) : fallback;
 }
 
+function normalizeModel(value, fallback = null) {
+  const normalized = normalizeText(value, fallback, 200);
+  if (typeof normalized !== "string") return normalized;
+  return normalized.toLowerCase() === LEGACY_PLACEHOLDER_MODEL ? null : normalized;
+}
+
 function normalizeMultiline(value, fallback, maxLength) {
   if (typeof value !== "string") return fallback;
   const normalized = value
@@ -980,7 +995,7 @@ function registerAgentLocked(amqRoot, agentDir, safeHandle, options) {
     handle: safeHandle,
     name: normalizeText(name, normalizeText(existingProfile?.name, defaultName, 120), 120),
     role: normalizeText(role, normalizeText(existingProfile?.role, "Autonomous Specialist", 240), 240),
-    model: normalizeText(model, normalizeText(existingProfile?.model, "claude-3-7-sonnet", 200), 200),
+    model: normalizeModel(model, normalizeModel(existingProfile?.model)),
     emoji: normalizeText(emoji, normalizeText(existingProfile?.emoji, defaultEmoji, 16), 16),
     color: normalizeText(color, normalizeText(existingProfile?.color, getAgentColor(safeHandle), 64), 64),
     worktree: normalizeText(worktree, normalizeText(existingProfile?.worktree, "", 1024), 1024) || null,