agent-coord-mcp 0.3.5 → 0.3.8

package/hooks/peek-coord.mjs

@@ -10,21 +10,31 @@
 // Optional env: AGENT_COORD_DIR (default ~/agent-coord)
 // Optional env: AGENT_COORD_INCLUDE_ROOM=1 to also drain the shared room
 
-import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, writeFileSync, renameSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
 
 const MODE = (process.argv.find((a) => a.startsWith("--mode="))?.slice(7)) ?? "user-prompt";
-const AGENT_ID = process.env.AGENT_COORD_ID;
-if (!AGENT_ID) {
-  // No agent id configured — silently no-op so the hook never blocks the user.
-  process.exit(0);
-}
 
 const ROOT =
   process.env.AGENT_COORD_DIR ??
   process.env.CLAUDE_COORD_DIR ??
   path.join(homedir(), "agent-coord");
+
+// Prefer the agentId that is actually attached to this tmux pane (via the
+// transports/ registry) over the env-provided one. This is what lets the
+// generic settings.json hook command — which derives AGENT_COORD_ID from the
+// cwd basename — still resolve to the agent that registered with a custom id
+// (e.g. "claude-david" rather than "linkaroo.io"). Without this, peek reads
+// the wrong cursor + inbox files and the m.from === AGENT_ID self-filter
+// below never matches the agent's own room posts.
+const AGENT_ID = resolveAgentId();
+if (!AGENT_ID) {
+  // No agent id configured and no tmux transport match — silently no-op so
+  // the hook never blocks the user.
+  process.exit(0);
+}
+
 const INBOX = path.join(ROOT, "inbox", `${sanitize(AGENT_ID)}.jsonl`);
 const ROOM = path.join(ROOT, "room.jsonl");
 const CURSOR = path.join(ROOT, "cursors", `${sanitize(AGENT_ID)}.json`);
@@ -107,3 +117,31 @@ function writeJsonAtomic(file, data) {
 function sanitize(id) {
   return id.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
+
+function resolveAgentId() {
+  const pane = process.env.TMUX_PANE;
+  if (pane) {
+    const fromTransport = lookupAgentByPane(pane);
+    if (fromTransport) return fromTransport;
+  }
+  return process.env.AGENT_COORD_ID || null;
+}
+
+function lookupAgentByPane(pane) {
+  const dir = path.join(ROOT, "transports");
+  if (!existsSync(dir)) return null;
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return null;
+  }
+  for (const name of entries) {
+    if (!name.endsWith(".json")) continue;
+    const data = readJson(path.join(dir, name), null);
+    if (data && data.tmuxTarget === pane && typeof data.agentId === "string") {
+      return data.agentId;
+    }
+  }
+  return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-coord-mcp",
-  "version": "0.3.5",
+  "version": "0.3.8",
   "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

@@ -53,29 +53,97 @@ const CURSOR_FILE = path.join(CURSOR_DIR, `${sanitize(ID)}.json`);
 mkdirSync(INBOX_DIR, { recursive: true });
 mkdirSync(CURSOR_DIR, { recursive: true });
 
+// ---------- ANSI helpers ----------
+
+const A = {
+  reset: "\x1b[0m",
+  bold: (s) => `\x1b[1m${s}\x1b[0m`,
+  dim: (s) => `\x1b[2m${s}\x1b[0m`,
+  red: (s) => `\x1b[31m${s}\x1b[0m`,
+  green: (s) => `\x1b[32m${s}\x1b[0m`,
+  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+  blue: (s) => `\x1b[34m${s}\x1b[0m`,
+  magenta: (s) => `\x1b[35m${s}\x1b[0m`,
+  cyan: (s) => `\x1b[36m${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];
+function agentColor(id) {
+  let h = 0;
+  for (let i = 0; i < id.length; i++) h = (h * 31 + id.charCodeAt(i)) >>> 0;
+  return AGENT_COLORS[h % AGENT_COLORS.length];
+}
+
 // ---------- register and start UI ----------
 
 await register();
 
+// Visual separator above the prompt — delimits "typing area starts here."
+// Embedded in the prompt string itself so readline owns the redraw; no
+// scroll-region gymnastics needed (those don't survive tmux cleanly).
+const TTY = !!process.stdout.isTTY;
+let COLS = process.stdout.columns || 80;
+const sepLine = () => A.dim("─".repeat(Math.max(10, COLS)));
+
+// inputAreaReady flips to true after the banner + initial drain finish and
+// we lay down the first separator. From that point say() treats the line
+// above the prompt as a separator slot it owns.
+let inputAreaReady = false;
+
+if (TTY) {
+  process.stdout.on("resize", () => {
+    COLS = process.stdout.columns || 80;
+    if (typeof rl !== "undefined") {
+      rl.setPrompt(makePrompt());
+      rl.prompt(true);
+    }
+  });
+}
+
+const SLASH_COMMANDS = [
+  "/dm", "/list", "/who", "/whoami", "/last", "/clear", "/cls",
+  "/me", "/help", "/?", "/quit", "/exit",
+];
+
+function completer(line) {
+  // Tab-complete slash commands and DM targets.
+  if (line.startsWith("/dm ")) {
+    const partial = line.slice(4);
+    const reg = readJsonSafe(AGENTS_FILE, {});
+    const ids = Object.keys(reg).filter((id) => id !== ID && id.startsWith(partial));
+    const hits = ids.map((id) => `/dm ${id} `);
+    return [hits, line];
+  }
+  if (line.startsWith("/")) {
+    const hits = SLASH_COMMANDS.filter((c) => c.startsWith(line));
+    return [hits, line];
+  }
+  return [[], line];
+}
+
 const rl = readline.createInterface({
   input: process.stdin,
   output: process.stdout,
-  prompt: `${ID}> `,
+  prompt: makePrompt(),
+  completer,
 });
 
-const dim = (s) => `\x1b[2m${s}\x1b[0m`;
-const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
-const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
-const red = (s) => `\x1b[31m${s}\x1b[0m`;
-
-say(dim(`coord-chat — agentId=${ID}  dir=${ROOT}`));
-say(dim("commands: <text>=room  /dm <id> <text>  /list  /help  /quit"));
-
+// Banner — printed once on launch. Keep it tight; this is a CLI, not a poster.
+printBanner();
 await drainAndPrint();
 
+// Lay down the first separator, then activate input-area mode so subsequent
+// say() calls maintain a sep line directly above the prompt.
+process.stdout.write(sepLine() + "\n");
+inputAreaReady = true;
+
 try { watch(INBOX_FILE, () => void drainAndPrint()); } catch {}
 try { watch(ROOM_FILE, () => void drainAndPrint()); } catch {}
+try { watch(AGENTS_FILE, () => refreshPrompt()); } catch {}
 setInterval(() => void drainAndPrint(), 1000);
+setInterval(refreshPrompt, 5000);
 
 rl.prompt();
 
@@ -85,34 +153,56 @@ rl.on("line", async (line) => {
   try {
     if (text === "/quit" || text === "/exit") {
       await unregister();
-      say("bye.");
+      teardownFooter();
+      process.stdout.write(A.dim("bye.\n"));
       process.exit(0);
-    } else if (text === "/help") {
-      say("commands: <text>=room  /dm <id> <text>  /list  /help  /quit");
-    } else if (text === "/list") {
+    } else if (text === "/help" || text === "/?") {
+      printHelp();
+    } else if (text === "/list" || text === "/who") {
       await printAgents();
+    } else if (text === "/whoami") {
+      await printWhoami();
+    } else if (text === "/clear" || text === "/cls") {
+      process.stdout.write("\x1b[2J\x1b[H");
+      printBanner();
+    } else if (text.startsWith("/last")) {
+      const m = text.match(/^\/last(?:\s+(\d+))?$/);
+      const n = m && m[1] ? parseInt(m[1], 10) : 20;
+      await printRecent(n);
+    } else if (text.startsWith("/me ")) {
+      const action = text.slice(4).trim();
+      if (!action) say(A.red("usage: /me <action>"));
+      else await sendRoom(`* ${ID} ${action}`);
     } else if (text.startsWith("/dm ")) {
       const m = text.match(/^\/dm\s+(\S+)\s+([\s\S]+)$/);
-      if (!m) say(red("usage: /dm <agentId> <text>"));
+      if (!m) say(A.red("usage: /dm <agentId> <text>"));
       else await sendDm(m[1], m[2]);
     } else if (text.startsWith("/")) {
-      say(red(`unknown command: ${text.split(" ")[0]}`));
+      say(A.red(`unknown command: ${text.split(" ")[0]}`) + A.dim("  (try /help)"));
     } else {
       await sendRoom(text);
     }
   } catch (e) {
-    say(red(`error: ${e?.message ?? e}`));
+    say(A.red(`error: ${e?.message ?? e}`));
   }
+  // After Enter, terminal advanced to a new line. Print a fresh separator
+  // there so the next prompt sits below a sep line, maintaining the layout.
+  process.stdout.write(sepLine() + "\n");
   rl.prompt();
 });
 
 process.on("SIGINT", async () => {
   try { await unregister(); } catch {}
-  process.stdout.write("\n");
-  say("bye.");
+  teardownFooter();
+  process.stdout.write("\n" + A.dim("bye.\n"));
   process.exit(0);
 });
 
+process.on("exit", () => {
+  // Final safety net — restore terminal state if we exit via any path.
+  teardownFooter();
+});
+
 // ---------- helpers ----------
 
 function parseArgs(argv) {
@@ -134,14 +224,97 @@ function sanitize(s) {
   return s.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
 
-// Write output without clobbering whatever the user is typing.
 function say(line) {
-  readline.clearLine(process.stdout, 0);
-  readline.cursorTo(process.stdout, 0);
+  if (!inputAreaReady) {
+    process.stdout.write(line + "\n");
+    return;
+  }
+  // We're on the prompt line. The line above is the current separator.
+  // Move up to it, clear it, drop our message there, then a fresh separator,
+  // then re-render the prompt on the next line.
+  process.stdout.write("\x1b[1A\r\x1b[2K");
   process.stdout.write(line + "\n");
+  process.stdout.write(sepLine() + "\n");
   if (typeof rl !== "undefined") rl.prompt(true);
 }
 
+function makePrompt() {
+  const reg = readJsonSafe(AGENTS_FILE, {});
+  const now = Date.now();
+  const STALE = 5 * 60 * 1000;
+  let online = 0;
+  for (const id of Object.keys(reg)) {
+    if (id === ID) continue;
+    const a = reg[id];
+    const marker = readJsonSafe(path.join(TRANSPORT_DIR, `${sanitize(id)}.json`), null);
+    const live = marker && marker.pid && pidAlive(marker.pid);
+    if (live || now - a.lastHeartbeat < STALE) online++;
+  }
+  const peers = online === 1 ? "1 peer" : `${online} peers`;
+  return `${agentColor(ID)(ID)} ${A.dim(`(${peers})`)}${A.dim(">")} `;
+}
+
+// No-op stubs kept so the exit paths don't reference deleted functions.
+function teardownFooter() {}
+
+function refreshPrompt() {
+  if (typeof rl === "undefined") return;
+  rl.setPrompt(makePrompt());
+  rl.prompt(true);
+}
+
+function printBanner() {
+  // Compact banner — three lines plus a separator. ASCII so it renders
+  // anywhere; no UTF-8 box-drawing surprises.
+  const lines = [
+    A.bold(A.cyan("  agent-coord  ")) + A.dim("— shared chat for agents and humans"),
+    A.dim(`  agentId=${A.reset}${agentColor(ID)(ID)}${A.dim("  dir=" + ROOT)}`),
+    A.dim("  type /help for commands · /quit to leave"),
+  ];
+  for (const l of lines) say(l);
+  say(A.dim("  " + "─".repeat(60)));
+}
+
+function printHelp() {
+  const rows = [
+    ["<text>",              "post to the shared room"],
+    ["/dm <agent> <text>",  "send a direct message"],
+    ["/me <action>",        "post an IRC-style action (* you wave)"],
+    ["/list, /who",         "show registered agents + transports"],
+    ["/whoami",             "show your registration + transport"],
+    ["/last [n]",           "show last n messages (default 20)"],
+    ["/clear",              "clear the screen"],
+    ["/help, /?",           "this list"],
+    ["/quit, /exit",        "unregister and leave"],
+  ];
+  say(A.bold("commands:"));
+  for (const [cmd, desc] of rows) {
+    say(`  ${A.cyan(cmd.padEnd(22))} ${A.dim(desc)}`);
+  }
+}
+
+async function printWhoami() {
+  const reg = readJsonSafe(AGENTS_FILE, {});
+  const a = reg[ID];
+  const marker = readJsonSafe(path.join(TRANSPORT_DIR, `${sanitize(ID)}.json`), null);
+  const live = marker && marker.pid && pidAlive(marker.pid);
+  say(A.bold("you:"));
+  say(`  ${A.cyan("id")}        ${agentColor(ID)(ID)}`);
+  say(`  ${A.cyan("role")}      ${a?.role ?? "-"}`);
+  say(`  ${A.cyan("dir")}       ${A.dim(ROOT)}`);
+  say(`  ${A.cyan("transport")} ${live ? A.green(marker.transport) : A.dim("none")}`);
+  say(`  ${A.cyan("registered")} ${a ? A.green("yes") : A.red("no")}`);
+}
+
+async function printRecent(n) {
+  const inbox = readJsonl(INBOX_FILE).slice(-n).map((m) => ({ ...m, _kind: "DM" }));
+  const room = readJsonl(ROOM_FILE).slice(-n).map((m) => ({ ...m, _kind: "room" }));
+  const all = [...inbox, ...room].sort((a, b) => a.ts - b.ts).slice(-n);
+  if (!all.length) return say(A.dim("(no history)"));
+  say(A.bold(`last ${all.length} message(s):`));
+  for (const m of all) printMsg(m._kind, m, { history: true });
+}
+
 async function withLock(file, fn) {
   await ensureFile(file);
   const release = await lockfile.lock(file, {
@@ -184,7 +357,7 @@ async function unregister() {
 async function sendDm(to, text) {
   const target = path.join(INBOX_DIR, `${sanitize(to)}.jsonl`);
   await appendMessage(target, { from: ID, to, text });
-  say(dim(`→ DM sent to ${to}`));
+  say(A.dim(`→ DM sent to ${to}`));
 }
 
 async function sendRoom(text) {
@@ -226,10 +399,21 @@ async function drainAndPrint() {
   if (changed) writeJsonAtomic(CURSOR_FILE, cursor);
 }
 
-function printMsg(kind, m) {
-  const t = new Date(m.ts).toLocaleTimeString();
-  const color = kind === "DM" ? cyan : yellow;
-  say(`${color(`[${kind} ${t} ${m.from}]`)} ${m.text ?? ""}`);
+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 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 first = body[0] ?? "";
+  const rest = body.slice(1).map((l) => indent + A.dim("│ ") + l);
+  const prefix = opts.history ? A.dim("  ") : "";
+  say(`${prefix}${meta} ${first}`);
+  for (const line of rest) say(`${prefix}${line}`);
 }
 
 async function printAgents() {
@@ -237,14 +421,28 @@ async function printAgents() {
   const now = Date.now();
   const STALE = 5 * 60 * 1000;
   const ids = Object.keys(reg).sort();
-  if (!ids.length) return say(dim("(no agents)"));
+  if (!ids.length) return say(A.dim("(no agents)"));
+  // Compute column widths from data so things line up.
+  const idW = Math.max(8, ...ids.map((i) => i.length));
+  const roleW = Math.max(4, ...ids.map((i) => (reg[i].role ?? "-").length));
+  say(A.bold(`agents (${ids.length}):`));
+  say(
+    "  " +
+      A.dim(
+        `${"id".padEnd(idW)}  ${"status".padEnd(7)}  ${"role".padEnd(roleW)}  transport`,
+      ),
+  );
   for (const id of ids) {
     const a = reg[id];
     const marker = readJsonSafe(path.join(TRANSPORT_DIR, `${sanitize(id)}.json`), null);
     const live = marker && marker.pid && pidAlive(marker.pid);
-    const status = live || now - a.lastHeartbeat < STALE ? "online " : "offline";
-    const trans = live ? ` transport=${marker.transport}` : "";
-    say(`  ${id.padEnd(20)} ${status}${trans}  role=${a.role ?? "-"}`);
+    const onlineNow = live || now - a.lastHeartbeat < STALE;
+    const dot = onlineNow ? A.green("●") : A.dim("○");
+    const status = onlineNow ? "online " : "offline";
+    const role = (a.role ?? "-").padEnd(roleW);
+    const trans = live ? A.green(marker.transport) : A.dim("none");
+    const me = id === ID ? A.dim(" (you)") : "";
+    say(`  ${dot} ${agentColor(id)(id.padEnd(idW))}  ${A.dim(status)}  ${role}  ${trans}${me}`);
   }
 }