agent-coord-mcp 0.4.0 → 0.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-coord-mcp",
-  "version": "0.4.0",
+  "version": "0.4.3",
   "description": "File-backed MCP server for coordinating multiple AI coding agents (Claude Code, Cursor, Cline, etc.) on the same machine.",
   "type": "module",
   "bin": {

package/scripts/coord-chat.mjs

@@ -67,11 +67,19 @@ const A = {
   blue: (s) => `\x1b[34m${s}\x1b[0m`,
   magenta: (s) => `\x1b[35m${s}\x1b[0m`,
   cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+  brightGreen:   (s) => `\x1b[92m${s}\x1b[0m`,
+  brightYellow:  (s) => `\x1b[93m${s}\x1b[0m`,
+  brightBlue:    (s) => `\x1b[94m${s}\x1b[0m`,
+  brightMagenta: (s) => `\x1b[95m${s}\x1b[0m`,
+  brightCyan:    (s) => `\x1b[96m${s}\x1b[0m`,
 };
 
-// Stable per-agent color from agentId hash. Skip red (reserved for errors)
-// and white/black; cycle the remaining 5 bright colors.
-const AGENT_COLORS = [A.green, A.yellow, A.blue, A.magenta, A.cyan];
+// Stable per-agent color from agentId hash. 10 colors (standard + bright)
+// to reduce collisions. Red is reserved for errors so we skip it.
+const AGENT_COLORS = [
+  A.green, A.yellow, A.blue, A.magenta, A.cyan,
+  A.brightGreen, A.brightYellow, A.brightBlue, A.brightMagenta, A.brightCyan,
+];
 function agentColor(id) {
   let h = 0;
   for (let i = 0; i < id.length; i++) h = (h * 31 + id.charCodeAt(i)) >>> 0;
@@ -429,23 +437,92 @@ async function postStatus(status) {
 async function pruneOld(days) {
   const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
   let total = 0;
-  const files = [ROOM_FILE, STATUS_FILE_PATH];
+  // Per-file removal counts so we can shift the corresponding cursor
+  // offsets — without this, every other agent's roomOffset/statusOffset/
+  // inboxOffset would point past the now-shorter file and they'd silently
+  // miss messages until enough new ones piled up to overtake the stale offset.
+  let roomRemoved = 0;
+  let statusRemoved = 0;
+  const inboxRemoved = {}; // agentId → count
+
+  const files = [
+    { path: ROOM_FILE, kind: "room" },
+    { path: STATUS_FILE_PATH, kind: "status" },
+  ];
   if (existsSync(INBOX_DIR)) {
     for (const n of readdirSync(INBOX_DIR)) {
-      if (n.endsWith(".jsonl")) files.push(path.join(INBOX_DIR, n));
+      if (n.endsWith(".jsonl")) {
+        files.push({ path: path.join(INBOX_DIR, n), kind: "inbox", agentId: n.replace(/\.jsonl$/, "") });
+      }
     }
   }
-  for (const file of files) {
-    if (!existsSync(file)) continue;
-    const all = readJsonl(file);
+  for (const f of files) {
+    if (!existsSync(f.path)) continue;
+    const all = readJsonl(f.path);
     const kept = all.filter((e) => e && e.ts > cutoff);
-    if (kept.length < all.length) {
+    const removed = all.length - kept.length;
+    if (removed > 0) {
       const body = kept.length ? kept.map((e) => JSON.stringify(e)).join("\n") + "\n" : "";
-      writeFileSync(file, body);
-      total += all.length - kept.length;
+      writeFileSync(f.path, body);
+      total += removed;
+      if (f.kind === "room") roomRemoved += removed;
+      else if (f.kind === "status") statusRemoved += removed;
+      else inboxRemoved[f.agentId] = (inboxRemoved[f.agentId] ?? 0) + removed;
+    }
+  }
+  if (roomRemoved || statusRemoved || Object.keys(inboxRemoved).length) {
+    shiftAllCursors({ roomRemoved, statusRemoved, inboxRemoved });
+  }
+  say(A.dim(`→ pruned ${total} entries older than ${days}d (cursors adjusted)`));
+}
+
+async function wipeRoom() {
+  await ensureFile(ROOM_FILE);
+  writeFileSync(ROOM_FILE, "");
+  // Reset every agent's roomOffset to 0 so they start reading the (now empty)
+  // file from the beginning. Otherwise their stale offsets point past EOF.
+  resetAllRoomOffsets();
+  say(A.dim("→ room wiped (all room cursors reset)"));
+}
+
+// Walk every cursor file and shift offsets down by the per-channel removed
+// counts. Mirrors what the MCP prune tool does server-side.
+function shiftAllCursors({ roomRemoved = 0, statusRemoved = 0, inboxRemoved = {} }) {
+  if (!existsSync(CURSOR_DIR)) return;
+  for (const name of readdirSync(CURSOR_DIR)) {
+    if (!name.endsWith(".json")) continue;
+    const cursorPath = path.join(CURSOR_DIR, name);
+    const cur = readJsonSafe(cursorPath, {});
+    const id = name.replace(/\.json$/, "");
+    let touched = false;
+    if (cur.roomOffset !== undefined && roomRemoved > 0) {
+      cur.roomOffset = Math.max(0, cur.roomOffset - roomRemoved);
+      touched = true;
+    }
+    if (cur.statusOffset !== undefined && statusRemoved > 0) {
+      cur.statusOffset = Math.max(0, cur.statusOffset - statusRemoved);
+      touched = true;
+    }
+    const myInbox = inboxRemoved[id] ?? 0;
+    if (cur.inboxOffset !== undefined && myInbox > 0) {
+      cur.inboxOffset = Math.max(0, cur.inboxOffset - myInbox);
+      touched = true;
+    }
+    if (touched) writeJsonAtomic(cursorPath, cur);
+  }
+}
+
+function resetAllRoomOffsets() {
+  if (!existsSync(CURSOR_DIR)) return;
+  for (const name of readdirSync(CURSOR_DIR)) {
+    if (!name.endsWith(".json")) continue;
+    const cursorPath = path.join(CURSOR_DIR, name);
+    const cur = readJsonSafe(cursorPath, {});
+    if (cur.roomOffset !== undefined && cur.roomOffset !== 0) {
+      cur.roomOffset = 0;
+      writeJsonAtomic(cursorPath, cur);
     }
   }
-  say(A.dim(`→ pruned ${total} entries older than ${days}d`));
 }
 
 async function kickAgent(target) {
@@ -471,19 +548,13 @@ async function kickAgent(target) {
     try { process.kill(marker.pid, "SIGTERM"); } catch {}
   }
   try { if (existsSync(markerPath)) unlinkSync(markerPath); } catch {}
-  say(A.dim(`→ kicked ${target} (registry + transport cleared)`));
-}
-
-async function wipeRoom() {
-  await ensureFile(ROOM_FILE);
-  writeFileSync(ROOM_FILE, "");
-  // Reset cursors so prior offsets don't point past the now-shorter file.
-  const cur = readJsonSafe(CURSOR_FILE, {});
-  if (cur.roomOffset !== undefined) {
-    delete cur.roomOffset;
-    writeJsonAtomic(CURSOR_FILE, cur);
-  }
-  say(A.dim("→ room wiped"));
+  // Remove the kicked agent's inbox + cursor so they don't sit orphaned in
+  // ~/agent-coord/ taking up listing space and confusing future bookkeeping.
+  const inboxPath = path.join(INBOX_DIR, `${sanitize(target)}.jsonl`);
+  const cursorPath = path.join(CURSOR_DIR, `${sanitize(target)}.json`);
+  try { if (existsSync(inboxPath)) unlinkSync(inboxPath); } catch {}
+  try { if (existsSync(cursorPath)) unlinkSync(cursorPath); } catch {}
+  say(A.dim(`→ kicked ${target} (registry, transport, inbox, cursor all cleared)`));
 }
 
 async function findInHistory(term) {
@@ -541,19 +612,51 @@ function printMsg(kind, m, opts = {}) {
   const d = new Date(m.ts);
   const t = `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
   const who = m.from ?? "?";
+  const color = agentColor(who);
+  const gutter = color("▎");
   const tag = kind === "DM" ? A.bold(A.cyan("DM")) : A.dim("room");
-  const meta = `${A.dim(t)} ${tag} ${agentColor(who)(who)}`;
-  // Multi-line bodies: first line on the meta row, subsequent lines indented
-  // to the body column for readability.
-  const body = (m.text ?? "").split("\n");
-  const indent = "       ";
+  const nick = A.bold(color(who));
+  const meta = `${A.dim(t)} ${tag} ${nick}`;
+  const body = (m.text ?? "").split("\n").map(formatBody);
+  const indent = "         ";
   const first = body[0] ?? "";
-  const rest = body.slice(1).map((l) => indent + A.dim("│ ") + l);
+  const rest = body.slice(1).map((l) => `${gutter} ${indent}${A.dim("│ ")}${l}`);
   const prefix = opts.history ? A.dim("  ") : "";
-  say(`${prefix}${meta} ${first}`);
+  say(`${prefix}${gutter} ${meta} ${first}`);
   for (const line of rest) say(`${prefix}${line}`);
 }
 
+// Lightweight inline-only "chat markdown" formatter — no dep. Handles bold,
+// italic, inline code, links, and @mentions. Order matters: pull out inline
+// code spans first so we don't touch their contents, then run the rest.
+function formatBody(text) {
+  return text.split(/(`[^`\n]+`)/).map((part) => {
+    if (part.startsWith("`") && part.endsWith("`") && part.length >= 2) {
+      return A.dim("`") + A.cyan(part.slice(1, -1)) + A.dim("`");
+    }
+    let s = part;
+    // @mentions first — colored in the mentioned agent's hash color, bold if
+    // it's the current user (so you can spot pings at a glance).
+    s = s.replace(/@([A-Za-z0-9._-]+)/g, (_, name) => {
+      const colored = agentColor(name)(`@${name}`);
+      return name === ID ? A.bold(colored) : colored;
+    });
+    // **bold**
+    s = s.replace(/\*\*([^*\n]+)\*\*/g, (_, t) => A.bold(t));
+    // *italic* and _italic_ (avoid matching inside **bold** by requiring
+    // non-asterisk neighbors)
+    s = s.replace(/(?<![*\w])\*([^*\n]+)\*(?![*\w])/g, (_, t) => `\x1b[3m${t}\x1b[0m`);
+    s = s.replace(/(?<![_\w])_([^_\n]+)_(?![_\w])/g, (_, t) => `\x1b[3m${t}\x1b[0m`);
+    // [text](url) — show text underlined with a dim trailing (url)
+    s = s.replace(/\[([^\]]+)\]\((https?:\/\/[^)\s]+)\)/g, (_, t, u) =>
+      `\x1b[4m${t}\x1b[0m${A.dim(` (${u})`)}`,
+    );
+    // Bare URLs — underline only the URL itself
+    s = s.replace(/\bhttps?:\/\/[^\s)]+/g, (u) => `\x1b[4m${u}\x1b[0m`);
+    return s;
+  }).join("");
+}
+
 async function printAgents() {
   const reg = readJsonSafe(AGENTS_FILE, {});
   const now = Date.now();