herdr-plugin-amq 0.1.2

package/src/herdr.mjs

@@ -0,0 +1,215 @@
+/**
+ * herdr.mjs — Herdr Socket API client for AGmail
+ *
+ * Connects to the running Herdr server via its Unix socket and provides:
+ *   - getHerdrAgents()        – one-shot snapshot of live agent records
+ *   - subscribeAgentEvents()  – long-lived event subscription, calls cb on each state change
+ *   - getSocketPath()         – resolve the Herdr socket path
+ *
+ * Protocol: JSON-RPC 2.0 over a Unix domain socket (newline-delimited JSON frames).
+ * See: https://herdr.dev/docs/socket-api/
+ */
+
+import net from "node:net";
+import { execSync } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+
+// ─── Socket Path Resolution ──────────────────────────────────────────────────
+
+export function getSocketPath() {
+  if (process.env.HERDR_SOCKET_PATH) return process.env.HERDR_SOCKET_PATH;
+  // Default: ~/.config/herdr/herdr.sock
+  return path.join(os.homedir(), ".config", "herdr", "herdr.sock");
+}
+
+// ─── Low-level request helper (one-shot connect, send, read response) ────────
+
+function socketRequest(method, params = {}, timeoutMs = 8000) {
+  return new Promise((resolve, reject) => {
+    const socketPath = getSocketPath();
+    const id = `amq_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+    const payload = JSON.stringify({ id, method, params }) + "\n";
+
+    const sock = net.createConnection(socketPath);
+    let buf = "";
+    let settled = false;
+
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        sock.destroy();
+        reject(new Error(`herdr socket request timed out (${method})`));
+      }
+    }, timeoutMs);
+
+    sock.on("connect", () => {
+      sock.write(payload);
+    });
+
+    sock.on("data", (chunk) => {
+      buf += chunk.toString();
+      const lines = buf.split("\n");
+      buf = lines.pop(); // keep incomplete last line
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const msg = JSON.parse(line);
+          if (msg.id === id && !settled) {
+            settled = true;
+            clearTimeout(timer);
+            sock.destroy();
+            if (msg.error) reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+            else resolve(msg.result);
+          }
+        } catch {}
+      }
+    });
+
+    sock.on("error", (err) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        reject(err);
+      }
+    });
+
+    sock.on("close", () => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        reject(new Error("herdr socket closed before response"));
+      }
+    });
+  });
+}
+
+// ─── Public API ──────────────────────────────────────────────────────────────
+
+/**
+ * Returns the list of agent records from the live Herdr session snapshot.
+ * Each record has: { name, agent, agent_status, pane_id, workspace_id, cwd, terminal_title, ... }
+ * Returns [] if Herdr is not running or socket unavailable.
+ */
+export async function getHerdrAgents() {
+  try {
+    const result = await socketRequest("session.snapshot", {});
+    const snapshot = result?.snapshot || result || {};
+    return Array.isArray(snapshot.agents) ? snapshot.agents : [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Returns a map of  handle → { agent_status, pane_id, workspace_id, terminal_title }
+ * by matching `name` field from Herdr agent records to AMQ handles.
+ * Handles without a `name` in Herdr are skipped.
+ */
+export async function getHerdrStatusMap() {
+  const agents = await getHerdrAgents();
+  const map = new Map();
+  for (const a of agents) {
+    const handle = a.name; // e.g. "ballistics", "testkit"
+    if (handle) {
+      map.set(handle, {
+        herdrStatus: a.agent_status || "unknown",
+        herdrPaneId: a.pane_id,
+        herdrWorkspaceId: a.workspace_id,
+        herdrTabId: a.tab_id,
+        herdrTitle: a.terminal_title_stripped || a.terminal_title,
+        interactiveReady: a.interactive_ready || false,
+        agentType: a.agent,
+      });
+    }
+  }
+  return map;
+}
+
+// ─── Long-lived event subscription ──────────────────────────────────────────
+
+/**
+ * Opens a persistent connection to Herdr's events.subscribe endpoint.
+ * Calls onEvent(event) for each incoming event object.
+ * Calls onDisconnect() when the socket closes.
+ * Returns a { close() } handle.
+ *
+ * Relevant event types:
+ *   agent.state_changed   — { pane_id, name, agent_status, ... }
+ *   pane.created / pane.closed
+ *   workspace.created / workspace.closed
+ */
+export function subscribeHerdrEvents({ onEvent, onDisconnect, onConnect } = {}) {
+  const socketPath = getSocketPath();
+  const subId = `amq_sub_${Date.now()}`;
+  const payload =
+    JSON.stringify({
+      id: subId,
+      method: "events.subscribe",
+      params: {},
+    }) + "\n";
+
+  let sock = null;
+  let closed = false;
+  let buf = "";
+
+  function connect() {
+    if (closed) return;
+    try {
+      sock = net.createConnection(socketPath);
+
+      sock.on("connect", () => {
+        buf = "";
+        sock.write(payload);
+        if (onConnect) onConnect();
+      });
+
+      sock.on("data", (chunk) => {
+        buf += chunk.toString();
+        const lines = buf.split("\n");
+        buf = lines.pop();
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const msg = JSON.parse(line);
+            // Skip the ack for the subscribe call itself
+            if (msg.id === subId && msg.result) continue;
+            if (msg.method && msg.params && onEvent) {
+              onEvent({ type: msg.method, ...msg.params });
+            }
+          } catch {}
+        }
+      });
+
+      sock.on("error", () => {});
+      sock.on("close", () => {
+        if (!closed && onDisconnect) onDisconnect();
+      });
+    } catch {}
+  }
+
+  connect();
+
+  return {
+    close() {
+      closed = true;
+      if (sock) {
+        try { sock.destroy(); } catch {}
+      }
+    },
+  };
+}
+
+// ─── Herdr availability check ────────────────────────────────────────────────
+
+/**
+ * Returns true if the Herdr socket file exists and is reachable.
+ */
+export async function isHerdrAvailable() {
+  try {
+    await socketRequest("session.snapshot", {}, 2000);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/index.mjs

@@ -0,0 +1,4 @@
+export * from "./config.mjs";
+export * from "./bridge.mjs";
+export * from "./actions.mjs";
+export * from "./panes.mjs";

package/src/markdown.mjs

@@ -0,0 +1,167 @@
+export function escapeHtml(str) {
+  return String(str || "")
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#039;");
+}
+
+export function renderMarkdown(md) {
+  if (!md) return "";
+
+  // 1. Normalize line endings to LF
+  const text = String(md).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+
+  // 2. Extract fenced code blocks line-by-line so comments (# ...) are never treated as headings
+  const lines = text.split("\n");
+  let inCodeBlock = false;
+  let codeFence = "";
+  let codeLang = "";
+  let codeLines = [];
+  const proseLines = [];
+  const codeBlocks = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!inCodeBlock) {
+      const fenceMatch = line.match(/^[ \t]*(`{3,}|~{3,})([a-zA-Z0-9_+#.-]*)[^\n]*$/);
+      if (fenceMatch) {
+        inCodeBlock = true;
+        codeFence = fenceMatch[1];
+        codeLang = (fenceMatch[2] || "code").trim();
+        codeLines = [];
+        continue;
+      }
+      proseLines.push(line);
+    } else {
+      const closeMatch = line.match(/^[ \t]*(`{3,}|~{3,})[ \t]*$/);
+      if (closeMatch && closeMatch[1][0] === codeFence[0] && closeMatch[1].length >= codeFence.length) {
+        inCodeBlock = false;
+        const cleanCode = codeLines.join("\n");
+        const escapedCode = escapeHtml(cleanCode);
+        const blockHtml = `<div class="code-block-wrapper">
+  <div class="code-block-header">
+    <span class="code-lang">${escapeHtml(codeLang || "code")}</span>
+    <button class="copy-code-btn" onclick="copyCode(this)">Copy</button>
+  </div>
+  <pre><code>${escapedCode}</code></pre>
+</div>`;
+        const idx = codeBlocks.length;
+        codeBlocks.push(blockHtml);
+        proseLines.push(`\x00AMQ_BLOCK_${idx}_\x00`);
+        continue;
+      }
+      codeLines.push(line);
+    }
+  }
+
+  // Handle unclosed fenced code block at end of input
+  if (inCodeBlock) {
+    const cleanCode = codeLines.join("\n");
+    const escapedCode = escapeHtml(cleanCode);
+    const blockHtml = `<div class="code-block-wrapper">
+  <div class="code-block-header">
+    <span class="code-lang">${escapeHtml(codeLang || "code")}</span>
+    <button class="copy-code-btn" onclick="copyCode(this)">Copy</button>
+  </div>
+  <pre><code>${escapedCode}</code></pre>
+</div>`;
+    const idx = codeBlocks.length;
+    codeBlocks.push(blockHtml);
+    proseLines.push(`\x00AMQ_BLOCK_${idx}_\x00`);
+  }
+
+  let prose = proseLines.join("\n");
+
+  // 3. Extract inline code so inline snippets are not affected by prose formatting
+  const inlineCodes = [];
+  prose = prose.replace(/(`+)([\s\S]*?[^`])\1(?!`)/g, (match, fence, code) => {
+    const escaped = escapeHtml(code);
+    const idx = inlineCodes.length;
+    inlineCodes.push(`<code class="inline-code">${escaped}</code>`);
+    return `\x00AMQ_INLINE_${idx}_\x00`;
+  });
+
+  // 4. Escape remaining HTML in prose for injection protection
+  let html = escapeHtml(prose);
+
+  // 5. Blockquotes (handling both escaped &gt; and unescaped >)
+  html = html.replace(/^(?:&gt;|>)[ \t]?(.*$)/gm, '<blockquote class="md-quote">$1</blockquote>');
+  html = html.replace(/<\/blockquote>\n<blockquote class="md-quote">/g, "<br>");
+
+  // 6. Headings in prose (requiring whitespace after # to avoid false matches on tags or includes)
+  html = html.replace(/^######[ \t]+(.*$)/gm, '<h6 class="md-h6">$1</h6>');
+  html = html.replace(/^#####[ \t]+(.*$)/gm, '<h5 class="md-h5">$1</h5>');
+  html = html.replace(/^####[ \t]+(.*$)/gm, '<h4 class="md-h4">$1</h4>');
+  html = html.replace(/^###[ \t]+(.*$)/gm, '<h3 class="md-h3">$1</h3>');
+  html = html.replace(/^##[ \t]+(.*$)/gm, '<h2 class="md-h2">$1</h2>');
+  html = html.replace(/^#[ \t]+(.*$)/gm, '<h1 class="md-h1">$1</h1>');
+
+  // 7. Markdown tables in prose
+  const tableRegex = /((?:^[ \t]*\|?[^\n\r|]+(?:\|[^\n\r|]+)+\|?[ \t]*\n)(?:^[ \t]*\|?(?:[ \t]*:?-+:?[ \t]*\|)+(?:[ \t]*:?-+:?[ \t]*)\|?[ \t]*\n)(?:^[ \t]*\|?[^\n\r|]+(?:\|[^\n\r|]+)+\|?[ \t]*(?:\n|$))+)/gm;
+  html = html.replace(tableRegex, (match) => {
+    const tableLines = match.trim().split(/\n/).map((l) => l.trim()).filter(Boolean);
+    if (tableLines.length < 2) return match;
+    const parseRow = (line) => {
+      let clean = line;
+      if (clean.startsWith("|")) clean = clean.slice(1);
+      if (clean.endsWith("|")) clean = clean.slice(0, -1);
+      return clean.split("|").map((c) => c.trim());
+    };
+    const headerCols = parseRow(tableLines[0]);
+    const alignLine = parseRow(tableLines[1]);
+    const aligns = alignLine.map((col) => {
+      const left = col.startsWith(":");
+      const right = col.endsWith(":");
+      if (left && right) return "center";
+      if (right) return "right";
+      return "left";
+    });
+    let tableHtml = '<div class="table-container"><table class="md-table"><thead><tr>';
+    headerCols.forEach((col, idx) => {
+      const align = aligns[idx] || "left";
+      tableHtml += `<th style="text-align: ${align}">${col}</th>`;
+    });
+    tableHtml += "</tr></thead><tbody>";
+    for (let j = 2; j < tableLines.length; j++) {
+      const rowCols = parseRow(tableLines[j]);
+      tableHtml += "<tr>";
+      headerCols.forEach((_, idx) => {
+        const cell = rowCols[idx] !== undefined ? rowCols[idx] : "";
+        const align = aligns[idx] || "left";
+        tableHtml += `<td style="text-align: ${align}">${cell}</td>`;
+      });
+      tableHtml += "</tr>";
+    }
+    tableHtml += "</tbody></table></div>\n";
+    return tableHtml;
+  });
+
+  // 8. Bold, Italic, Strikethrough in prose
+  html = html.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+  html = html.replace(/(^|[^*])\*([^*]+)\*(?!\*)/g, "$1<em>$2</em>");
+  html = html.replace(/~~([^~]+)~~/g, "<del>$1</del>");
+
+  // 9. Lists in prose
+  html = html.replace(/^([0-9]+\.|\([0-9]+\))[ \t]+(.*$)/gm, '<div class="md-list-item"><span class="md-list-num">$1</span> <span>$2</span></div>');
+  html = html.replace(/^[-*+][ \t]+(.*$)/gm, '<div class="md-bullet-item">• $1</div>');
+
+  // 10. Links in prose: [text](url)
+  html = html.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2" target="_blank" rel="noopener" class="md-link">$1</a>');
+
+  // 11. Paragraph breaks in prose
+  html = html.replace(/\n{2,}/g, '<div class="md-para-break"></div>');
+
+  // 12. Restore inline code
+  for (let k = 0; k < inlineCodes.length; k++) {
+    html = html.replace(`\x00AMQ_INLINE_${k}_\x00`, () => inlineCodes[k]);
+  }
+
+  // 13. Restore code blocks
+  for (let b = 0; b < codeBlocks.length; b++) {
+    html = html.replace(`\x00AMQ_BLOCK_${b}_\x00`, () => codeBlocks[b]);
+  }
+
+  return html;
+}

package/src/panes.mjs

@@ -0,0 +1,68 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { findAmqRoot, getAgentHandles, execCmd } from "./config.mjs";
+import { listInbox } from "./bridge.mjs";
+
+import { startWebServer } from "./server.mjs";
+
+export function launchDashboardPane() {
+  const amqRoot = findAmqRoot();
+  console.log("\x1b[1m✉️  AGmail Dashboard (Pure JS)\x1b[0m\n");
+
+  if (!amqRoot) {
+    console.error("❌ No .agent-mail directory found in current workspace.");
+    process.exit(1);
+  }
+
+  const port = parseInt(process.env.AGMAIL_PORT || "8505", 10);
+  const server = startWebServer({ port, amqRoot });
+
+  // Open browser in background if xdg-open exists
+  try {
+    const opener = process.platform === "darwin" ? "open" : "xdg-open";
+    spawn(opener, [`http://localhost:${port}`], { stdio: "ignore", detached: true }).unref();
+  } catch {}
+
+  console.log("\nPress Ctrl+C to stop the dashboard server.");
+}
+
+export function launchInboxPeekPane() {
+  const amqRoot = findAmqRoot();
+  if (!amqRoot) {
+    console.log("❌ No .agent-mail directory found.");
+    process.exit(1);
+  }
+
+  renderInboxSummary(amqRoot);
+}
+
+export function renderInboxSummary(amqRoot) {
+  const handles = getAgentHandles(amqRoot);
+  console.log(`\x1b[1m📫 AMQ Mailbox Overview\x1b[0m: \x1b[36m${amqRoot}\x1b[0m\n`);
+
+  let totalMsgs = 0;
+  for (const h of handles) {
+    const msgs = listInbox(amqRoot, h);
+    if (!msgs.length) continue;
+    totalMsgs += msgs.length;
+
+    console.log(`\x1b[1m\x1b[33m📥 ${h}\x1b[0m (\x1b[32m${msgs.length} unread\x1b[0m)`);
+    for (const m of msgs.slice(0, 5)) {
+      const from = m.from || "unknown";
+      const subject = m.subject || "(no subject)";
+      const id = m.id ? `[${m.id.slice(0, 8)}]` : "";
+      console.log(`   • \x1b[90m${id}\x1b[0m \x1b[1m${from}\x1b[0m: ${subject}`);
+    }
+    if (msgs.length > 5) {
+      console.log(`   \x1b[90m... and ${msgs.length - 5} more\x1b[0m`);
+    }
+    console.log("");
+  }
+
+  if (totalMsgs === 0) {
+    console.log("✨ All inboxes are clear! No unread transmissions.");
+  }
+
+  console.log("\x1b[90mPress Enter or Escape to close.\x1b[0m");
+}