agent-coord-mcp 0.2.0 → 0.3.0

package/src/tools.ts

@@ -1,9 +1,13 @@
 import { randomUUID } from "node:crypto";
-import { watch } from "node:fs";
+import { existsSync, openSync, watch } from "node:fs";
+import { promises as fsp } from "node:fs";
+import { spawn, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
 import { z } from "zod";
 import path from "node:path";
 import {
   AGENTS_FILE,
+  CURSOR_DIR,
   INBOX_DIR,
   ROOM_FILE,
   STATUS_FILE,
@@ -12,10 +16,15 @@ import {
   deleteFile,
   fileSize,
   inboxFile,
+  listCursorFiles,
   listInboxFiles,
+  listTransportFiles,
+  logFile,
+  pidFile,
   readJson,
   readJsonl,
   rewriteJsonl,
+  transportFile,
   updateJson,
 } from "./store.js";
 
@@ -25,6 +34,15 @@ type AgentEntry = {
   role?: string;
   registeredAt: number;
   lastHeartbeat: number;
+  capabilities?: string[];
+};
+
+type TransportMarker = {
+  agentId: string;
+  transport: string;
+  pid: number;
+  tmuxTarget?: string;
+  since: number;
 };
 
 type AgentRegistry = Record<string, AgentEntry>;
@@ -114,14 +132,57 @@ export async function listAgentsTool() {
     }
     return current;
   });
-  const agents = Object.values(reg).map((a) => ({
-    ...a,
-    online: now - a.lastHeartbeat < STALE_MS,
-    secondsSinceHeartbeat: Math.floor((now - a.lastHeartbeat) / 1000),
-  }));
+
+  // Merge in live transport markers (e.g. tmux-push from the pusher daemon).
+  // A marker counts only if its pid is still alive; stale markers are pruned.
+  const liveTransports = await loadLiveTransports();
+
+  const agents = Object.values(reg).map((a) => {
+    const transport = liveTransports.get(a.agentId);
+    const merged = [...(a.capabilities ?? [])];
+    if (transport && !merged.includes(transport.transport)) merged.push(transport.transport);
+    return {
+      ...a,
+      online: now - a.lastHeartbeat < STALE_MS,
+      secondsSinceHeartbeat: Math.floor((now - a.lastHeartbeat) / 1000),
+      capabilities: merged.length > 0 ? merged : undefined,
+      transport: transport
+        ? { kind: transport.transport, tmuxTarget: transport.tmuxTarget, pid: transport.pid }
+        : undefined,
+    };
+  });
   return { agents, evicted };
 }
 
+async function loadLiveTransports(): Promise<Map<string, TransportMarker>> {
+  const out = new Map<string, TransportMarker>();
+  for (const fname of await listTransportFiles()) {
+    const file = path.join(path.dirname(transportFile("x")), fname);
+    const marker = await readJson<TransportMarker | null>(file, null);
+    if (!marker) {
+      await deleteFile(file);
+      continue;
+    }
+    if (!isPidAlive(marker.pid)) {
+      await deleteFile(file);
+      continue;
+    }
+    out.set(marker.agentId, marker);
+  }
+  return out;
+}
+
+function isPidAlive(pid: number): boolean {
+  if (!pid || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code;
+    return code === "EPERM"; // EPERM = exists but not ours; ESRCH = gone
+  }
+}
+
 // ---------- send_message ----------
 
 export const sendMessageSchema = {
@@ -193,7 +254,19 @@ export async function readMessagesTool(args: {
     });
   }
 
-  return { messages: limited, totalNew, returned: limited.length };
+  // Drop the agent's own posts on shared channels — reading your own broadcast
+  // back is never useful and confuses turn-based agents into self-replies.
+  // Cursor has already advanced past them, so they won't reappear.
+  const visible =
+    args.source === "room" || args.source === "status"
+      ? limited.filter((e) => entryAuthor(e) !== args.agentId)
+      : limited;
+
+  return { messages: visible, totalNew, returned: visible.length };
+}
+
+function entryAuthor(e: Message | StatusEntry): string | undefined {
+  return "from" in e ? e.from : e.agentId;
 }
 
 // ---------- post_status ----------
@@ -229,46 +302,57 @@ export async function waitForMessageTool(args: {
   source: "inbox" | "room" | "status";
   timeoutMs?: number;
 }) {
-  const timeout = Math.min(args.timeoutMs ?? 30_000, MAX_WAIT_MS);
+  const totalTimeout = Math.min(args.timeoutMs ?? 30_000, MAX_WAIT_MS);
   const file = sourceFile(args.source, args.agentId);
-  const startSize = await fileSize(file);
-
-  const result = await new Promise<{ changed: boolean }>((resolve) => {
-    let settled = false;
-    const finish = (changed: boolean) => {
-      if (settled) return;
-      settled = true;
-      clearInterval(poll);
+  const deadline = Date.now() + totalTimeout;
+
+  // Loop so that file growth caused only by the agent's own self-posts (which
+  // readMessagesTool now filters out for room/status) doesn't return an empty
+  // result — keep waiting until we have something to deliver or time out.
+  while (Date.now() < deadline) {
+    const startSize = await fileSize(file);
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) break;
+
+    const changed = await new Promise<boolean>((resolve) => {
+      let settled = false;
+      const finish = (v: boolean) => {
+        if (settled) return;
+        settled = true;
+        clearInterval(poll);
+        try {
+          watcher?.close();
+        } catch {
+          // ignore
+        }
+        clearTimeout(t);
+        resolve(v);
+      };
+
+      const check = async () => {
+        const sz = await fileSize(file);
+        if (sz > startSize) finish(true);
+      };
+
+      let watcher: ReturnType<typeof watch> | undefined;
       try {
-        watcher?.close();
+        watcher = watch(file, () => {
+          void check();
+        });
       } catch {
-        // ignore
+        // file may not exist; polling will handle
       }
-      clearTimeout(t);
-      resolve({ changed });
-    };
-
-    const check = async () => {
-      const sz = await fileSize(file);
-      if (sz > startSize) finish(true);
-    };
-
-    let watcher: ReturnType<typeof watch> | undefined;
-    try {
-      watcher = watch(file, () => {
-        void check();
-      });
-    } catch {
-      // file may not exist; polling will handle
-    }
-    const poll = setInterval(() => void check(), 500);
-    const t = setTimeout(() => finish(false), timeout);
-  });
+      const poll = setInterval(() => void check(), 500);
+      const t = setTimeout(() => finish(false), remaining);
+    });
 
-  if (!result.changed) {
-    return { ok: false, timedOut: true };
+    if (!changed) break;
+    const result = await readMessagesTool({ agentId: args.agentId, source: args.source });
+    if (result.returned > 0) return result;
+    // otherwise, only self-posts arrived; keep waiting on the remaining budget
   }
-  return readMessagesTool({ agentId: args.agentId, source: args.source });
+
+  return { ok: false, timedOut: true };
 }
 
 // ---------- prune ----------
@@ -322,6 +406,9 @@ export async function pruneTool(args: {
   const inboxFiles = await listInboxFiles();
   let inboxRemoved = 0;
   const deletedOrphans: string[] = [];
+  // perAgentInboxRemoved: how many entries were stripped from each *kept* agent's
+  // inbox, so we can shift only that agent's inboxOffset cursor below.
+  const perAgentInboxRemoved: Record<string, number> = {};
   for (const fname of inboxFiles) {
     const id = fname.replace(/\.jsonl$/, "");
     const filePath = path.join(INBOX_DIR, fname);
@@ -334,6 +421,35 @@ export async function pruneTool(args: {
     }
     const r = await rewriteJsonl<Message>(filePath, (e) => e.ts > cutoff);
     inboxRemoved += r.removed;
+    perAgentInboxRemoved[id] = r.removed;
+  }
+
+  // Cursor adjustment: appendJsonl is time-ordered and rewriteJsonl removes
+  // the oldest entries (ts <= cutoff). Any cursor offset shifts down by the
+  // removed count, clamped at 0. Without this, an offset past the new file
+  // length would make read_messages return [] forever.
+  const cursorsAdjusted: string[] = [];
+  for (const cname of await listCursorFiles()) {
+    const id = cname.replace(/\.json$/, "");
+    const cursorPath = path.join(CURSOR_DIR, cname);
+    let touched = false;
+    await updateJson<Cursor>(cursorPath, {}, (current) => {
+      if (current.roomOffset !== undefined && roomResult.removed > 0) {
+        current.roomOffset = Math.max(0, current.roomOffset - roomResult.removed);
+        touched = true;
+      }
+      if (current.statusOffset !== undefined && statusResult.removed > 0) {
+        current.statusOffset = Math.max(0, current.statusOffset - statusResult.removed);
+        touched = true;
+      }
+      const myInboxRemoved = perAgentInboxRemoved[id] ?? 0;
+      if (current.inboxOffset !== undefined && myInboxRemoved > 0) {
+        current.inboxOffset = Math.max(0, current.inboxOffset - myInboxRemoved);
+        touched = true;
+      }
+      return current;
+    });
+    if (touched) cursorsAdjusted.push(id);
   }
 
   return {
@@ -346,10 +462,129 @@ export async function pruneTool(args: {
       inboxMessages: inboxRemoved,
       orphanInboxes: deletedOrphans,
     },
-    note: "Cursors not adjusted; clients may see stale offsets but read_messages clamps via slice().",
+    cursorsAdjusted,
   };
 }
 
+// ---------- attach_agent / detach_agent (tmux push transport) ----------
+
+export const attachAgentSchema = {
+  agentId: z.string().min(1),
+  tmuxTarget: z.string().optional(),
+  includeRoom: z.boolean().optional(),
+  allowlist: z.array(z.string()).optional(),
+  debounceMs: z.number().int().positive().max(60_000).optional(),
+};
+
+export async function attachAgentTool(args: {
+  agentId: string;
+  tmuxTarget?: string;
+  includeRoom?: boolean;
+  allowlist?: string[];
+  debounceMs?: number;
+}) {
+  // Resolve target: explicit arg > MCP server's own TMUX_PANE env.
+  const target = args.tmuxTarget ?? process.env.TMUX_PANE;
+  if (!target) {
+    return {
+      ok: false,
+      error:
+        "tmuxTarget not provided and the MCP server is not running inside tmux (no $TMUX_PANE). Pass tmuxTarget explicitly (e.g. '%42' or 'session:window.pane').",
+    };
+  }
+
+  // Validate target exists.
+  const probe = spawnSync("tmux", ["display-message", "-p", "-t", target, "ok"]);
+  if (probe.status !== 0) {
+    return {
+      ok: false,
+      error: `tmux target '${target}' not found: ${(probe.stderr ?? "").toString().trim()}`,
+    };
+  }
+
+  // If something's already attached, refuse rather than spawn a second pusher.
+  const existing = await readJson<TransportMarker | null>(transportFile(args.agentId), null);
+  if (existing && isPidAlive(existing.pid)) {
+    return {
+      ok: false,
+      error: `agent '${args.agentId}' already has a live ${existing.transport} attached (pid ${existing.pid}). Call detach_agent first.`,
+      existing,
+    };
+  }
+  // Clean up dead marker, if any.
+  if (existing) await deleteFile(transportFile(args.agentId));
+
+  const pusher = resolvePusherPath();
+  if (!existsSync(pusher)) {
+    return { ok: false, error: `tmux-pusher not found at ${pusher}` };
+  }
+
+  // Detached spawn so the pusher outlives this MCP request/process.
+  const log = logFile(args.agentId, "pusher");
+  await fsp.mkdir(path.dirname(log), { recursive: true });
+  await fsp.mkdir(path.dirname(pidFile(args.agentId, "pusher")), { recursive: true });
+  await fsp.mkdir(path.dirname(transportFile(args.agentId)), { recursive: true });
+  const out = openSync(log, "a");
+  const err = openSync(log, "a");
+  const child = spawn("node", [pusher], {
+    detached: true,
+    stdio: ["ignore", out, err],
+    env: {
+      ...process.env,
+      AGENT_COORD_ID: args.agentId,
+      AGENT_COORD_TMUX_TARGET: target,
+      ...(args.includeRoom ? { AGENT_COORD_INCLUDE_ROOM: "1" } : {}),
+      ...(args.allowlist && args.allowlist.length > 0
+        ? { AGENT_COORD_ALLOWLIST: args.allowlist.join(",") }
+        : {}),
+      ...(args.debounceMs ? { AGENT_COORD_DEBOUNCE_MS: String(args.debounceMs) } : {}),
+    },
+  });
+  child.unref();
+  const pid = child.pid;
+  if (!pid) return { ok: false, error: "spawn returned no pid" };
+
+  // Write pid file (for scripts) and transport marker (for list_agents).
+  await fsp.writeFile(pidFile(args.agentId, "pusher"), String(pid), "utf8");
+  const marker: TransportMarker = {
+    agentId: args.agentId,
+    transport: "tmux-push",
+    pid,
+    tmuxTarget: target,
+    since: Date.now(),
+  };
+  // Use updateJson so it lockfile-protects and creates the file atomically.
+  await updateJson<TransportMarker>(transportFile(args.agentId), marker, () => marker);
+
+  return { ok: true, agentId: args.agentId, transport: "tmux-push", tmuxTarget: target, pid, log };
+}
+
+export const detachAgentSchema = {
+  agentId: z.string().min(1),
+};
+
+export async function detachAgentTool(args: { agentId: string }) {
+  const marker = await readJson<TransportMarker | null>(transportFile(args.agentId), null);
+  let killed = false;
+  if (marker && isPidAlive(marker.pid)) {
+    try {
+      process.kill(marker.pid, "SIGTERM");
+      killed = true;
+    } catch {
+      // already gone
+    }
+  }
+  await deleteFile(transportFile(args.agentId));
+  await deleteFile(pidFile(args.agentId, "pusher"));
+  return { ok: true, agentId: args.agentId, killed, hadMarker: marker !== null };
+}
+
+function resolvePusherPath(): string {
+  // tools.js (compiled) lives in dist/; pusher lives in hooks/ at repo root.
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, "..", "hooks", "tmux-pusher.mjs");
+}
+
 // ---------- helpers ----------
 
 function sourceFile(source: "inbox" | "room" | "status", agentId: string): string {