agent-comm-hub 0.1.6

package/lib/cli.js

@@ -0,0 +1,1239 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { createServer } from "node:http";
+
+// src/hub.ts
+import { randomUUID } from "node:crypto";
+
+// src/protocol.ts
+var BROADCAST = "all";
+function decodeContent(kind, content) {
+  if (kind !== "task" && kind !== "ack") return content;
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed !== null && typeof parsed === "object") return parsed;
+  } catch {
+  }
+  return content;
+}
+
+// src/hub.ts
+var AgentHub = class {
+  constructor(options) {
+    this.options = options;
+    const idle = options.peerIdleTimeoutMs ?? 6e5;
+    if (idle > 0) {
+      const interval = Math.min(6e4, Math.max(1e3, idle / 2));
+      this.gcTimer = setInterval(() => this.gcTick(idle), interval);
+      this.gcTimer.unref?.();
+    }
+  }
+  queues = /* @__PURE__ */ new Map();
+  waiters = /* @__PURE__ */ new Map();
+  historyRing = [];
+  lastSeen = /* @__PURE__ */ new Map();
+  gcTimer;
+  /** Stop the idle GC (call when the hub shuts down). */
+  dispose() {
+    if (this.gcTimer !== void 0) clearInterval(this.gcTimer);
+  }
+  gcTick(idleTimeoutMs) {
+    const now = Date.now();
+    for (const peerId of this.peers()) {
+      if (now - (this.lastSeen.get(peerId) ?? 0) > idleTimeoutMs) {
+        if (this.options.isPeerLive?.(peerId) === true) continue;
+        this.options.onPeerGc?.(peerId);
+        this.unregister(peerId);
+      }
+    }
+  }
+  /** All registered peer ids, insertion order. */
+  peers() {
+    return [...this.lastSeen.keys()];
+  }
+  /** Register a peer; throws if the id is already taken. */
+  register(peerId) {
+    if (this.lastSeen.has(peerId)) throw new Error(`peer already registered: ${peerId}`);
+    this.lastSeen.set(peerId, Date.now());
+    this.options.onPeersChanged?.(this.peers());
+  }
+  /** Remove a peer and its queued messages; pending waiters resolve as timeouts. */
+  unregister(peerId) {
+    this.queues.delete(peerId);
+    for (const waiter of this.waiters.get(peerId) ?? []) {
+      clearTimeout(waiter.timer);
+      waiter.onAbort();
+    }
+    this.waiters.delete(peerId);
+    this.lastSeen.delete(peerId);
+    this.options.onPeersChanged?.(this.peers());
+  }
+  /** Mark activity for `peer` (called on every tool call from that peer). */
+  touch(peerId) {
+    if (this.lastSeen.has(peerId)) this.lastSeen.set(peerId, Date.now());
+  }
+  /** Is the peer currently registered? */
+  has(peerId) {
+    return this.lastSeen.has(peerId);
+  }
+  /** Is the peer "active" (tool/activity within the connected window)? */
+  isActive(peerId) {
+    const last = this.lastSeen.get(peerId);
+    return last !== void 0 && Date.now() - last < (this.options.connectedWindowMs ?? 3e4);
+  }
+  /** Send a chat/notice text message to `to` (or {@link BROADCAST}). */
+  send(from, to, kind, content) {
+    return this.route(from, to, kind, content);
+  }
+  /** Send a structured task message to `to` (or {@link BROADCAST}). */
+  sendTask(from, to, task) {
+    return this.route(from, to, "task", JSON.stringify(task));
+  }
+  /** Send an acknowledgement back to the sender of `ref`. */
+  sendAck(from, ref, ack) {
+    const original = this.historyRing.findLast((message) => message.id === ref);
+    if (!original) throw new Error(`cannot ack unknown message: ${ref}`);
+    return this.route(from, original.from, "ack", JSON.stringify(ack), ref);
+  }
+  /** Recent messages involving `peer` (inbound and outbound), newest first. */
+  history(peerId, limit) {
+    const filtered = this.historyRing.filter((message) => message.from === peerId || message.to === peerId || message.to === BROADCAST);
+    return filtered.slice(-Math.max(0, limit)).reverse();
+  }
+  /**
+   * Live summary for the status tool. `livePeers` (sessions with a live SSE
+   * stream) count as connected even without recent tool activity.
+   */
+  status(livePeers) {
+    const now = Date.now();
+    return {
+      server: "agent-comm-hub",
+      peers: this.peers().map((peer) => ({
+        id: peer,
+        connected: this.isActive(peer) || livePeers?.has(peer) === true,
+        lastSeenMs: this.lastSeen.get(peer) ?? 0,
+        queued: (this.queues.get(peer) ?? []).length,
+        waiting: (this.waiters.get(peer) ?? []).length
+      })),
+      historyLimit: this.options.historyLimit,
+      maxQueue: this.options.maxQueue
+    };
+  }
+  /** Non-blocking drain of everything queued for `peer` (optionally from one sender). */
+  poll(peerId, from) {
+    const queue = this.queues.get(peerId) ?? [];
+    const drained = from === void 0 ? queue.splice(0, queue.length) : drainFrom(queue, from);
+    for (const message of drained) this.remember(message);
+    return drained;
+  }
+  /**
+   * Long-poll for the next message addressed to `peer`: resolves immediately
+   * when a matching one is queued, otherwise waits up to `timeoutMs` (capped
+   * by `waitTimeoutMs`) or until `signal` aborts. `from` narrows to one sender.
+   */
+  wait(peerId, timeoutMs, from, signal) {
+    const startedAt = Date.now();
+    const queued = this.poll(peerId, from)[0];
+    if (queued) return Promise.resolve({ type: "message", message: queued });
+    const budget = Math.max(1, Math.min(Math.floor(timeoutMs), this.options.waitTimeoutMs));
+    return new Promise((resolve) => {
+      let settled = false;
+      const settle = (result) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+        resolve(result);
+      };
+      const onAbort = () => {
+        removeFromRegistry();
+        settle({ type: "timeout", waitedMs: Date.now() - startedAt });
+      };
+      const removeFromRegistry = () => {
+        const list2 = this.waiters.get(peerId);
+        if (list2) this.waiters.set(peerId, list2.filter((waiter) => waiter.resolve !== settle));
+      };
+      const timer = setTimeout(() => {
+        removeFromRegistry();
+        settle({ type: "timeout", waitedMs: Date.now() - startedAt });
+      }, budget);
+      if (signal?.aborted) {
+        onAbort();
+        return;
+      }
+      signal?.addEventListener("abort", onAbort, { once: true });
+      const list = this.waiters.get(peerId) ?? [];
+      list.push({ resolve: settle, timer, onAbort, ...from !== void 0 ? { from } : {} });
+      this.waiters.set(peerId, list);
+    });
+  }
+  /** Create a message from `from` addressed to `to` and deliver it. */
+  route(from, to, kind, content, ref) {
+    if (!this.lastSeen.has(from)) throw new Error(`sender not registered: ${from}`);
+    if (to !== BROADCAST && !this.lastSeen.has(to)) throw new Error(`unknown recipient: ${to} (registered peers: ${this.peers().join(", ") || "none"})`);
+    const message = {
+      id: randomUUID(),
+      from,
+      to,
+      kind,
+      content,
+      ...ref !== void 0 ? { ref } : {},
+      ts: Date.now()
+    };
+    this.lastSeen.set(from, message.ts);
+    if (to === BROADCAST) {
+      for (const peer of this.peers()) {
+        if (peer !== from) this.deliver(peer, message);
+      }
+    } else {
+      this.deliver(to, message);
+    }
+    return message;
+  }
+  /** Queue or hand off a message; wake the first matching waiter for its target. */
+  deliver(target, message) {
+    const list = this.waiters.get(target) ?? [];
+    const index = list.findIndex((waiter) => waiter.from === void 0 || waiter.from === message.from);
+    if (index >= 0) {
+      const [waiter] = list.splice(index, 1);
+      this.waiters.set(target, list);
+      clearTimeout(waiter.timer);
+      this.remember(message);
+      waiter.resolve({ type: "message", message });
+      return;
+    }
+    const queue = this.queues.get(target) ?? [];
+    if (queue.length >= this.options.maxQueue) queue.shift();
+    queue.push(message);
+    this.queues.set(target, queue);
+    this.options.onQueued?.(message);
+  }
+  /** Append a delivered message to the history ring. */
+  remember(message) {
+    this.historyRing.push(message);
+    if (this.historyRing.length > this.options.historyLimit) this.historyRing.splice(0, this.historyRing.length - this.options.historyLimit);
+  }
+};
+function drainFrom(queue, from) {
+  const kept = [];
+  const drained = [];
+  for (const message of queue) {
+    if (message.from === from) drained.push(message);
+    else kept.push(message);
+  }
+  queue.splice(0, queue.length, ...kept);
+  return drained;
+}
+
+// src/hub-tools.ts
+var DEFAULT_WAIT_MS = 3e4;
+function present(message) {
+  const { ref, ...rest } = message;
+  return {
+    ...rest,
+    ...ref !== void 0 ? { ref } : {},
+    content: decodeContent(message.kind, message.content)
+  };
+}
+function sanitizePeerId(name) {
+  const cleaned = name.toLowerCase().replace(/[^a-z0-9._:-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+  return cleaned === "" ? "agent" : cleaned;
+}
+function autoRegisterPeer(hub, registry, sessionId, clientName) {
+  if (sessionId === void 0) return void 0;
+  const bound = registry.peerFor(sessionId);
+  if (bound !== void 0) return bound;
+  if (registry.isSuppressed(sessionId)) return void 0;
+  const peerId = sanitizePeerId(clientName ?? "agent");
+  if (!hub.has(peerId)) hub.register(peerId);
+  registry.bindPeer(sessionId, peerId);
+  hub.touch(peerId);
+  return peerId;
+}
+function livePeersFor(registry) {
+  const live = /* @__PURE__ */ new Set();
+  const streams = registry.liveSessions();
+  for (const [sessionId, peerId] of registry.peerBindings) {
+    if (streams.has(sessionId)) live.add(peerId);
+  }
+  return live;
+}
+function hubTools(hub, registry, options) {
+  const schema = (properties, required = []) => ({
+    type: "object",
+    properties,
+    required,
+    additionalProperties: false
+  });
+  const str = (description) => ({ type: "string", description });
+  const int = (description) => ({ type: "integer", description });
+  const optStr = str;
+  const requirePeer = (sessionId) => {
+    const bound = registry.peerFor(sessionId);
+    if (bound !== void 0) {
+      hub.touch(bound);
+      return bound;
+    }
+    const auto = autoRegisterPeer(hub, registry, sessionId, registry.clientName(sessionId));
+    if (auto !== void 0) {
+      hub.touch(auto);
+      return auto;
+    }
+    throw new Error("not registered \u2014 call bridge_register(peerId) first");
+  };
+  const receipt = (message) => ({
+    ok: true,
+    id: message.id,
+    from: message.from,
+    to: message.to,
+    kind: message.kind,
+    ts: message.ts
+  });
+  const presentWait = (result) => result.type === "timeout" ? result : { type: "message", message: present(result.message) };
+  const wrap = (peerAware, handler) => async (args, sessionId) => {
+    const peer = peerAware ? requirePeer(sessionId) : "";
+    return handler(args, peer, sessionId);
+  };
+  return [
+    {
+      name: "bridge_register",
+      description: 'Claim or rename your identity on the hub. Sessions auto-share a peer id derived from the client name; call this to switch to a readable unique peerId such as "mavis" or "opencode:myproject". Rejects when the id is claimed by another connection. Returns the current peer list.',
+      inputSchema: schema({ peerId: str("Unique peer id: letters/digits/._:- , 1-64 chars.") }, ["peerId"]),
+      handler: async (args, sessionId) => {
+        const peerId = String(args.peerId);
+        if (!/^[A-Za-z0-9._:-]{1,64}$/.test(peerId)) {
+          throw new Error(`invalid peerId: ${peerId} (expected [A-Za-z0-9._:-]{1,64})`);
+        }
+        if (hub.has(peerId) && registry.peerFor(sessionId) !== peerId) {
+          throw new Error(`peer already registered by another connection: ${peerId}`);
+        }
+        const current = registry.peerFor(sessionId);
+        if (current !== void 0 && current !== peerId) {
+          registry.unbindPeer(sessionId);
+          if (registry.attachedCount(current) === 0) hub.unregister(current);
+        }
+        registry.bindPeer(sessionId, peerId);
+        if (!hub.has(peerId)) hub.register(peerId);
+        registry.clearSuppress(sessionId);
+        hub.touch(peerId);
+        return { ok: true, peerId, peers: hub.peers() };
+      }
+    },
+    {
+      name: "bridge_unregister",
+      description: "Leave the hub: detaches your session (and drops the peer when no other session shares it); auto-registration stays off until an explicit bridge_register. Idempotent.",
+      inputSchema: schema({}),
+      handler: async (_args, sessionId) => {
+        const peer = registry.peerFor(sessionId);
+        if (peer !== void 0) {
+          registry.unbindPeer(sessionId);
+          if (registry.attachedCount(peer) === 0) hub.unregister(peer);
+        }
+        registry.suppressAuto(sessionId);
+        return { ok: true, peerId: peer ?? null };
+      }
+    },
+    {
+      name: "bridge_chat",
+      description: 'Send a chat message to another agent on the hub. Use bridge_wait (long-poll) or bridge_poll to receive replies. `to` is the target peerId, or "all" to broadcast.',
+      inputSchema: schema(
+        { to: str('Target peerId, or "all" to broadcast.'), message: str("The message text.") },
+        ["to", "message"]
+      ),
+      handler: wrap(true, async (args, peer) => receipt(hub.send(peer, String(args.to), "chat", String(args.message))))
+    },
+    {
+      name: "bridge_task",
+      description: "Delegate a structured task to another agent. The receiving agent decides whether to accept; expect an ack (accepted/rejected/done/failed) via bridge_wait / bridge_poll.",
+      inputSchema: schema(
+        {
+          to: str('Target peerId, or "all" to broadcast.'),
+          prompt: str("What the receiving agent should do."),
+          context: optStr("Optional background information for the task."),
+          deliverable: optStr("Optional expected deliverable description.")
+        },
+        ["to", "prompt"]
+      ),
+      handler: wrap(true, async (args, peer) => receipt(hub.sendTask(peer, String(args.to), {
+        prompt: String(args.prompt),
+        ...args.context !== void 0 ? { context: String(args.context) } : {},
+        ...args.deliverable !== void 0 ? { deliverable: String(args.deliverable) } : {}
+      })))
+    },
+    {
+      name: "bridge_ack",
+      description: "Acknowledge a message received from another agent (usually a delegated task): accepted | rejected | done | failed. The ack is routed back to the original sender of `ref`.",
+      inputSchema: schema(
+        {
+          ref: str("The id of the message being acknowledged."),
+          status: { type: "string", enum: ["accepted", "rejected", "done", "failed"], description: "acknowledgement status." },
+          note: optStr("Optional explanation for the acknowledgement.")
+        },
+        ["ref", "status"]
+      ),
+      handler: wrap(true, async (args, peer) => {
+        const status = String(args.status);
+        const valid = ["accepted", "rejected", "done", "failed"];
+        if (!valid.includes(status)) {
+          throw new Error(`invalid ack status: ${status} (expected ${valid.join(" | ")})`);
+        }
+        return receipt(hub.sendAck(peer, String(args.ref), { status, ...args.note !== void 0 ? { note: String(args.note) } : {} }));
+      })
+    },
+    {
+      name: "bridge_wait",
+      description: "Wait (long-poll) for the next message addressed to you. Resolves immediately when one is queued; otherwise blocks until one arrives or the timeout fires. `from` narrows to one sender. Loop this tool to hold a real-time conversation.",
+      inputSchema: schema({
+        from: optStr("Only wait for messages from this peerId."),
+        timeoutMs: int(`Max wait in milliseconds (default ${DEFAULT_WAIT_MS}, ceiling is server waitTimeoutMs).`)
+      }),
+      handler: wrap(true, async (args, peer) => presentWait(await hub.wait(peer, args.timeoutMs === void 0 ? options.defaultWaitMs ?? DEFAULT_WAIT_MS : Number(args.timeoutMs), args.from === void 0 ? void 0 : String(args.from))))
+    },
+    {
+      name: "bridge_poll",
+      description: "Non-blocking: drain every message currently queued for you. Empty list when nothing is waiting. `from` narrows to one sender.",
+      inputSchema: schema({ from: optStr("Only drain messages from this peerId.") }),
+      handler: wrap(true, async (args, peer) => ({ messages: hub.poll(peer, args.from === void 0 ? void 0 : String(args.from)).map(present) }))
+    },
+    {
+      name: "bridge_status",
+      description: "Hub health: server info, every registered peer with connected/queued/waiting state. A peer is connected when it was active recently or its SSE channel is alive.",
+      inputSchema: schema({}),
+      handler: wrap(true, async () => hub.status(livePeersFor(registry)))
+    },
+    {
+      name: "bridge_peers",
+      description: "List registered peers and whether each is connected (recent activity or a live SSE channel).",
+      inputSchema: schema({}),
+      handler: wrap(true, async () => {
+        const status = hub.status(livePeersFor(registry));
+        return { peers: hub.peers().map((id) => ({ id, connected: status.peers.find((peer) => peer.id === id)?.connected ?? false })) };
+      })
+    },
+    {
+      name: "bridge_history",
+      description: "Recent messages involving you (newest first); pass `peer` to inspect another peer's conversation. Use to refresh context after a reconnect.",
+      inputSchema: schema({ peer: optStr("PeerId whose conversation to inspect; default: yourself."), limit: int("How many messages to return (default 20).") }),
+      handler: wrap(true, async (args, peer) => ({ messages: hub.history(args.peer === void 0 ? peer : String(args.peer), Math.min(args.limit === void 0 ? 20 : Number(args.limit), 100)).map(present) }))
+    }
+  ];
+}
+
+// src/mcp-server.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+var SUPPORTED_VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"];
+var LATEST_VERSION = SUPPORTED_VERSIONS[0];
+var MAX_BODY_BYTES = 1048576;
+var SessionRegistry = class {
+  sessions = /* @__PURE__ */ new Set();
+  /** sessionId → peerId claimed via `bridge_register`. */
+  peerBindings = /* @__PURE__ */ new Map();
+  /** Session id from the request header, if any. */
+  sessionIdFor(req) {
+    return req.headers["mcp-session-id"];
+  }
+  /** Track `sessionId`, generating a fresh one when absent. */
+  ensureSession(sessionId) {
+    const id = sessionId ?? randomUUID2();
+    this.sessions.add(id);
+    return id;
+  }
+  /** Peer bound to a session, if any. */
+  peerFor(sessionId) {
+    if (sessionId === void 0) return void 0;
+    return this.peerBindings.get(sessionId);
+  }
+  /** Bind `peerId` to `sessionId`; rejects when the session already claimed
+   * a different peer or the session id is absent. */
+  bindPeer(sessionId, peerId) {
+    if (sessionId === void 0) throw new Error("no MCP session \u2014 re-initialize the connection");
+    const existing = this.peerBindings.get(sessionId);
+    if (existing !== void 0 && existing !== peerId) {
+      throw new Error(`this connection is already registered as '${existing}'`);
+    }
+    this.peerBindings.set(sessionId, peerId);
+    this.sessions.add(sessionId);
+    return sessionId;
+  }
+  /** Drop the binding of a session (used by bridge_unregister). */
+  unbindPeer(sessionId) {
+    if (sessionId !== void 0) this.peerBindings.delete(sessionId);
+  }
+  /** Client-reported name per session (from the initialize clientInfo). */
+  clientNames = /* @__PURE__ */ new Map();
+  /** Remember the client name reported by a session (on initialize). */
+  noteClient(sessionId, name) {
+    this.clientNames.set(sessionId, name);
+  }
+  /** Client-reported name for a session, if any. */
+  clientName(sessionId) {
+    if (sessionId === void 0) return void 0;
+    return this.clientNames.get(sessionId);
+  }
+  /** Sessions whose owner explicitly unregistered; auto-registration is
+   * suppressed for them until an explicit `bridge_register`. */
+  suppressedAuto = /* @__PURE__ */ new Set();
+  /** Suppress auto-registration for this session (on bridge_unregister). */
+  suppressAuto(sessionId) {
+    if (sessionId !== void 0) this.suppressedAuto.add(sessionId);
+  }
+  /** Allow auto-registration again (on explicit bridge_register). */
+  clearSuppress(sessionId) {
+    if (sessionId !== void 0) this.suppressedAuto.delete(sessionId);
+  }
+  /** Whether this session may not auto-register. */
+  isSuppressed(sessionId) {
+    return sessionId !== void 0 && this.suppressedAuto.has(sessionId);
+  }
+  /** Sessions with a live SSE stream (server→client channel). */
+  liveStreams = /* @__PURE__ */ new Set();
+  /** Mark a session's SSE stream open (server→client channel alive). */
+  markSseOpen(sessionId) {
+    this.liveStreams.add(sessionId);
+  }
+  /** Mark a session's SSE stream closed. */
+  markSseClosed(sessionId) {
+    this.liveStreams.delete(sessionId);
+  }
+  /** Session ids with a live SSE stream. */
+  liveSessions() {
+    return this.liveStreams;
+  }
+  /** Drop every binding that points at `peerId` (used by the idle GC). */
+  unbindPeerId(peerId) {
+    for (const [sessionId, bound] of this.peerBindings) {
+      if (bound === peerId) this.peerBindings.delete(sessionId);
+    }
+  }
+  /** How many sessions are currently attached to `peerId`. */
+  attachedCount(peerId) {
+    let count = 0;
+    for (const bound of this.peerBindings.values()) {
+      if (bound === peerId) count++;
+    }
+    return count;
+  }
+};
+var McpStreamableHttpServer = class {
+  constructor(tools, info, registry, log2 = () => {
+  }, onInitialize = () => {
+  }) {
+    this.tools = tools;
+    this.info = info;
+    this.registry = registry;
+    this.log = log2;
+    this.onInitialize = onInitialize;
+  }
+  sseStreams = /* @__PURE__ */ new Map();
+  /** Attach request handling for `path` (e.g. `/mcp`) to an http server. */
+  attach(server, path) {
+    server.on("request", (req, res) => {
+      const url = new URL(req.url ?? "/", "http://localhost");
+      if (url.pathname !== path) {
+        res.writeHead(404, { "Content-Type": "application/json" }).end(JSON.stringify({ error: "not found" }));
+        return;
+      }
+      if (req.method === "GET") {
+        this.handleGet(req, res);
+        return;
+      }
+      if (req.method === "POST") {
+        void this.handlePost(req, res);
+        return;
+      }
+      if (req.method === "OPTIONS") {
+        res.writeHead(204, corsHeaders()).end();
+        return;
+      }
+      res.writeHead(405, corsHeaders()).end();
+    });
+  }
+  /** Close all open SSE streams (called on server shutdown). */
+  close() {
+    for (const stream of this.sseStreams.values()) stream.end();
+    this.sseStreams.clear();
+  }
+  handleGet(req, res) {
+    const sessionId = this.registry.ensureSession(this.registry.sessionIdFor(req));
+    res.writeHead(200, {
+      ...corsHeaders(),
+      "Content-Type": "text/event-stream; charset=utf-8",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      ...req.headers["mcp-session-id"] ? {} : { "Mcp-Session-Id": sessionId }
+    });
+    res.write(": connected\n\n");
+    this.sseStreams.set(sessionId, res);
+    this.registry.markSseOpen(sessionId);
+    req.on("close", () => {
+      this.sseStreams.delete(sessionId);
+      this.registry.markSseClosed(sessionId);
+    });
+  }
+  async handlePost(req, res) {
+    let body;
+    try {
+      body = await readBody(req);
+    } catch (error) {
+      this.jsonRpcError(res, null, -32700, `parse error: ${error.message}`);
+      return;
+    }
+    let message;
+    try {
+      message = JSON.parse(body.toString("utf8"));
+    } catch {
+      this.jsonRpcError(res, null, -32700, "parse error: invalid JSON");
+      return;
+    }
+    if (typeof message !== "object" || message === null || message.method === void 0) {
+      this.jsonRpcError(res, message?.id ?? null, -32600, "invalid request");
+      return;
+    }
+    const id = message.id ?? null;
+    const sessionId = this.registry.sessionIdFor(req);
+    if (id === null) {
+      res.writeHead(202, { ...corsHeaders(), "Content-Length": "0" }).end();
+      return;
+    }
+    try {
+      const { result, extraHeaders } = await this.dispatch(message, sessionId);
+      res.writeHead(200, {
+        ...corsHeaders(),
+        "Content-Type": "application/json; charset=utf-8",
+        "Mcp-Protocol-Version": messageProtocolVersion(req),
+        ...extraHeaders
+      });
+      res.end(JSON.stringify({ jsonrpc: "2.0", id, result }));
+    } catch (error) {
+      const code = error.code ?? -32603;
+      this.jsonRpcError(res, id, code, error.message, void 0, messageProtocolVersion(req));
+    }
+  }
+  async dispatch(message, sessionId) {
+    const method = message.method ?? "";
+    switch (method) {
+      case "initialize": {
+        const newSessionId = this.registry.ensureSession(sessionId);
+        const clientInfo = message.params?.clientInfo;
+        const clientName = typeof clientInfo?.name === "string" && clientInfo.name !== "" ? clientInfo.name : void 0;
+        if (clientName !== void 0) {
+          this.registry.noteClient(newSessionId, clientName);
+        }
+        this.onInitialize(newSessionId, clientName);
+        const requested = message.params?.protocolVersion;
+        const protocolVersion = typeof requested === "string" && SUPPORTED_VERSIONS.includes(requested) ? requested : LATEST_VERSION;
+        return {
+          extraHeaders: { "Mcp-Session-Id": newSessionId },
+          result: {
+            protocolVersion,
+            capabilities: { tools: { listChanged: false } },
+            serverInfo: { name: this.info.name, version: this.info.version },
+            instructions: "You are already registered with the hub (auto-registered at connect). Use bridge_chat / bridge_task / bridge_wait / bridge_poll / bridge_status / bridge_peers / bridge_history / bridge_ack to talk to other agents; bridge_register(peerId) renames your identity."
+          }
+        };
+      }
+      case "tools/list":
+        return { result: { tools: this.tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          inputSchema: tool.inputSchema
+        })) } };
+      case "tools/call": {
+        const params = message.params ?? {};
+        if (typeof params.name !== "string") throw rpcError(-32602, "tools/call requires a string name");
+        const tool = this.tools.find((candidate) => candidate.name === params.name);
+        if (!tool) throw rpcError(-32602, `unknown tool: ${params.name}`);
+        const args = params.arguments ?? {};
+        if (typeof args !== "object" || args === null || Array.isArray(args)) {
+          throw rpcError(-32602, "tools/call arguments must be an object");
+        }
+        try {
+          const value = await tool.handler(args, sessionId);
+          return { result: { content: [{ type: "text", text: JSON.stringify(value) }], isError: false } };
+        } catch (error) {
+          return {
+            result: {
+              content: [{ type: "text", text: JSON.stringify({ error: error.message }) }],
+              isError: true
+            }
+          };
+        }
+      }
+      case "ping":
+        return { result: {} };
+      default:
+        throw rpcError(-32601, `method not found: ${method}`);
+    }
+  }
+  jsonRpcError(res, id, code, message, data, protocolVersion) {
+    res.writeHead(code === -32700 || code === -32600 ? 400 : 200, {
+      ...corsHeaders(),
+      "Content-Type": "application/json; charset=utf-8",
+      ...protocolVersion ? { "Mcp-Protocol-Version": protocolVersion } : {}
+    });
+    res.end(JSON.stringify({ jsonrpc: "2.0", id, error: { code, message, ...data !== void 0 ? { data } : {} } }));
+  }
+};
+function rpcError(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+function messageProtocolVersion(req) {
+  return req.headers["mcp-protocol-version"] ?? LATEST_VERSION;
+}
+function corsHeaders() {
+  return {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Headers": "*",
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS"
+  };
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_BODY_BYTES) {
+        reject(new Error("request body too large"));
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+
+// src/index.ts
+var SERVER_NAME = "agent-comm-hub";
+var SERVER_VERSION = "0.1.6";
+var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_PORT = 18764;
+var DEFAULT_PATH = "/mcp";
+var DEFAULT_CONFIG = {
+  host: DEFAULT_HOST,
+  port: DEFAULT_PORT,
+  path: DEFAULT_PATH,
+  maxQueue: 200,
+  historyLimit: 100,
+  waitTimeoutMs: 6e4,
+  defaultWaitMs: 3e4,
+  connectedWindowMs: 3e4,
+  peerIdleTimeoutMs: 6e5
+};
+function startHub(config = {}, log2 = console) {
+  const overrides = Object.fromEntries(Object.entries(config).filter(([, value]) => value !== void 0));
+  const resolved = { ...DEFAULT_CONFIG, ...overrides };
+  const hub = new AgentHub({
+    maxQueue: resolved.maxQueue,
+    historyLimit: resolved.historyLimit,
+    waitTimeoutMs: resolved.waitTimeoutMs,
+    connectedWindowMs: resolved.connectedWindowMs,
+    peerIdleTimeoutMs: resolved.peerIdleTimeoutMs,
+    onPeerGc: (peerId) => registry.unbindPeerId(peerId),
+    // The idle GC must never evict a peer whose session has a live SSE channel.
+    isPeerLive: (peerId) => livePeersFor(registry).has(peerId)
+  });
+  const registry = new SessionRegistry();
+  const mcp = new McpStreamableHttpServer(
+    hubTools(hub, registry, { defaultWaitMs: resolved.defaultWaitMs, waitTimeoutMs: resolved.waitTimeoutMs }),
+    { name: SERVER_NAME, version: SERVER_VERSION },
+    registry,
+    (message) => log2.warn(message),
+    (sessionId, clientName) => {
+      try {
+        const peer = autoRegisterPeer(hub, registry, sessionId, clientName);
+        if (peer !== void 0) log2.info(`peer joined: ${peer}`);
+      } catch (error) {
+        log2.warn(`auto-register failed: ${error.message}`);
+      }
+    }
+  );
+  const server = createServer();
+  mcp.attach(server, resolved.path);
+  server.on("error", (error) => log2.warn(`hub http server error: ${error.message}`));
+  server.listen(resolved.port, resolved.host, () => {
+    log2.info(`agent-comm-hub listening on http://${resolved.host}:${resolved.port}${resolved.path}`);
+  });
+  return {
+    hub,
+    registry,
+    server,
+    mcp,
+    close: () => {
+      hub.dispose();
+      mcp.close();
+      server.closeAllConnections?.();
+      server.close();
+    }
+  };
+}
+
+// src/setup.ts
+import { copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var DEFAULT_URL = "http://127.0.0.1:18764/mcp";
+var DEFAULT_SERVER = "agent-hub";
+function defaultSkillSrc() {
+  return join(dirname(fileURLToPath(import.meta.url)), "..", "agents", "SKILL.md");
+}
+function stamp() {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+}
+async function readJson(file) {
+  if (!existsSync(file)) return null;
+  try {
+    return JSON.parse(await readFile(file, "utf8"));
+  } catch (error) {
+    throw new Error(`cannot parse JSON ${file}: ${error.message}`);
+  }
+}
+async function writeJsonNoBom(file, doc) {
+  await mkdir(dirname(file), { recursive: true });
+  await writeFile(file, JSON.stringify(doc, null, 2) + "\n", "utf8");
+}
+async function backup(file) {
+  const bak = `${file}.bak-${stamp()}`;
+  await copyFile(file, bak);
+  return bak;
+}
+async function mergeJsonServer(file, section, entry, opts) {
+  if (!existsSync(file)) return "skipped";
+  const doc = await readJson(file);
+  if (doc === null) return "skipped";
+  let servers = doc[section];
+  if (servers === void 0 || typeof servers !== "object" || Array.isArray(servers)) {
+    servers = {};
+    doc[section] = servers;
+  }
+  const has = Object.prototype.hasOwnProperty.call(servers, opts.serverName);
+  if (opts.remove) {
+    if (!has) return "absent";
+    delete servers[opts.serverName];
+    await backup(file);
+    await writeJsonNoBom(file, doc);
+    return "removed";
+  }
+  if (has) {
+    const existing = servers[opts.serverName];
+    if (existing?.url === opts.url) return "unchanged";
+  }
+  servers[opts.serverName] = entry;
+  await backup(file);
+  await writeJsonNoBom(file, doc);
+  return "changed";
+}
+async function mergeTomlSection(file, opts) {
+  if (!existsSync(file)) return "skipped";
+  const text = await readFile(file, "utf8");
+  const marker = `[mcp_servers.${opts.serverName}]`;
+  const markerRe = new RegExp(`^\\[mcp_servers\\.${escapeRegExp(opts.serverName)}\\]`, "m");
+  if (opts.remove) {
+    if (!markerRe.test(text)) return "absent";
+    const cleaned = text.replace(new RegExp(`^\\[mcp_servers\\.${escapeRegExp(opts.serverName)}\\][^\\r\\n]*(\\r?\\n(?!\\[).*)*(\\r?\\n)?`, "m"), "");
+    await backup(file);
+    await writeFile(file, cleaned, "utf8");
+    return "removed";
+  }
+  if (markerRe.test(text)) return "unchanged";
+  const block = `
+${marker}
+type = "streamable-http"
+url = "${opts.url}"
+`;
+  await backup(file);
+  await writeFile(file, text.trimEnd() + block, "utf8");
+  return "changed";
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function syncSkill(skillDir, skillSrc, remove, log2) {
+  if (remove) {
+    if (existsSync(skillDir)) {
+      await mkdir(dirname(skillDir), { recursive: true });
+      await rmRecursive(skillDir);
+      log2(`  skill removed: ${skillDir}`);
+    }
+    return;
+  }
+  if (!existsSync(skillSrc)) {
+    log2(`  SKILL.md source missing: ${skillSrc} (skipped)`);
+    return;
+  }
+  await mkdir(skillDir, { recursive: true });
+  await copyFile(skillSrc, join(skillDir, "SKILL.md"));
+  log2(`  skill -> ${join(skillDir, "SKILL.md")}`);
+}
+async function rmRecursive(dir) {
+  const { rm } = await import("node:fs/promises");
+  await rm(dir, { recursive: true, force: true });
+}
+async function runSetup(options = {}) {
+  const url = options.url ?? DEFAULT_URL;
+  const serverName = options.serverName ?? DEFAULT_SERVER;
+  const home = options.homeDir ?? homedir();
+  const skillSrc = options.skillSrc ?? defaultSkillSrc();
+  const remove = options.remove === true;
+  const log2 = options.log ?? ((message) => console.log(message));
+  const summary = { done: [], unchanged: [], skipped: [], errors: [] };
+  const record = (status, label, file) => {
+    if (status === "changed" || status === "removed") summary.done.push(`${label}: ${file}`);
+    else if (status === "unchanged" || status === "absent") summary.unchanged.push(`${label}: ${file}`);
+    else if (status === "skipped") summary.skipped.push(`${label}: ${file}`);
+  };
+  const jsonTargets = [
+    { label: "mcode", file: join(home, ".minimax", "mcp.json"), section: "mcpServers", entry: { url, type: "streamable-http", enabled: true, configured: true, timeout: 12e4, description: "agent-comm-hub: talk to every other agent connected to the hub." } },
+    { label: "mcode", file: join(home, ".minimax", "mcp", "mcp.json"), section: "mcpServers", entry: { url, type: "streamable-http", enabled: true, configured: true, timeout: 12e4, description: "agent-comm-hub: talk to every other agent connected to the hub." } },
+    { label: "opencode", file: join(home, ".config", "opencode", "opencode.json"), section: "mcp", entry: { type: "remote", url, enabled: true } },
+    { label: "kimi-code", file: join(home, ".kimi-code", "mcp.json"), section: "mcpServers", entry: { transport: "http", url, startupTimeoutMs: 3e4, toolTimeoutMs: 12e4 } },
+    { label: "gemini-cli", file: join(home, ".gemini", "settings.json"), section: "mcpServers", entry: { type: "http", url } }
+  ];
+  for (const target of jsonTargets) {
+    try {
+      const status = await mergeJsonServer(target.file, target.section, target.entry, { serverName, url, remove });
+      record(status, target.label, target.file);
+    } catch (error) {
+      summary.errors.push(`${target.label}: ${target.file} \u2014 ${error.message}`);
+      log2(`  ${target.label}: SKIPPED \u2014 ${error.message}`);
+    }
+  }
+  const codexFile = join(home, ".codex", "config.toml");
+  try {
+    const status = await mergeTomlSection(codexFile, { serverName, url, remove });
+    record(status, "codex", codexFile);
+  } catch (error) {
+    summary.errors.push(`codex: ${codexFile} \u2014 ${error.message}`);
+    log2(`  codex: SKIPPED \u2014 ${error.message}`);
+  }
+  const skillDirs = [
+    join(home, ".agents", "skills", serverName),
+    // cross-agent standard
+    join(home, ".minimax", "skills", serverName),
+    join(home, ".config", "opencode", "skills", serverName),
+    join(home, ".kimi-code", "skills", serverName),
+    join(home, ".gemini", "skills", serverName),
+    join(home, ".codex", "skills", serverName),
+    join(home, ".claude", "skills", serverName)
+    // config is manual; skill still useful
+  ];
+  for (const dir of skillDirs) {
+    try {
+      await syncSkill(dir, skillSrc, remove, log2);
+    } catch (error) {
+      summary.errors.push(`skill ${dir} \u2014 ${error.message}`);
+      log2(`  skill ${dir}: SKIPPED \u2014 ${error.message}`);
+    }
+  }
+  if (remove) log2("done. Manual targets (see agents/README.md): Claude Code (.mcp.json), DSH (cordis.patch.yml).");
+  else log2("done. Manual targets (see agents/README.md): Claude Code (.mcp.json), DSH (cordis.patch.yml). Restart agent sessions to pick up the MCP server.");
+  return summary;
+}
+
+// src/ops.ts
+import { execFileSync } from "node:child_process";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+async function runStatus(options = {}) {
+  const host = options.host ?? "127.0.0.1";
+  const port = options.port ?? 18764;
+  const path = options.path ?? "/mcp";
+  const url = options.url ?? `http://${host}:${port}${path}`;
+  const probeName = "agent-comm-hub-cli";
+  const notRunning = { running: false, url, peers: [] };
+  try {
+    const headers = {};
+    let id = 0;
+    const rpc = async (method, params) => {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Accept: "application/json, text/event-stream", ...headers },
+        body: JSON.stringify({ jsonrpc: "2.0", id: ++id, method, ...params !== void 0 ? { params } : {} })
+      });
+      const session = res.headers.get("mcp-session-id");
+      if (session) headers["Mcp-Session-Id"] = session;
+      const json = await res.json();
+      return json;
+    };
+    const init = await rpc("initialize", { protocolVersion: "2025-06-18", capabilities: {}, clientInfo: { name: probeName, version: "cli" } });
+    if (init.error) return { ...notRunning, error: init.error.message };
+    const version = init.result?.serverInfo?.version ?? void 0;
+    const call = await rpc("tools/call", { name: "bridge_peers", arguments: {} });
+    const text = call.result?.content?.[0]?.text;
+    const parsed = text ? JSON.parse(text) : { peers: [] };
+    const peers = (parsed.peers ?? []).filter((peer) => peer.id !== probeName);
+    await rpc("tools/call", { name: "bridge_unregister", arguments: {} }).catch(() => void 0);
+    return { running: true, url, version, peers };
+  } catch (error) {
+    return { ...notRunning, error: error.message };
+  }
+}
+function cliPath() {
+  return fileURLToPath2(import.meta.url);
+}
+function nodeExe() {
+  return process.execPath;
+}
+function run(command, args, dryRun) {
+  if (dryRun) return `[dry-run] ${command} ${args.join(" ")}`;
+  return execFileSync(command, args, { encoding: "utf8", windowsHide: true }).trim();
+}
+function runService(options) {
+  const messages = [];
+  const port = options.port ?? 18764;
+  const host = options.host ?? "127.0.0.1";
+  const path = options.path ?? "/mcp";
+  const dryRun = options.dryRun === true;
+  try {
+    if (process.platform === "win32") {
+      const appData = process.env.APPDATA ?? join2(homedir2(), "AppData", "Roaming");
+      const launcherDir = join2(appData, "agent-comm-hub");
+      const vbs = join2(launcherDir, "agent-comm-hub.vbs");
+      const runKey = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run";
+      const valueName = "agent-comm-hub";
+      if (options.action === "install") {
+        const cmd = `"${nodeExe()}" "${cliPath()}" --host ${host} --port ${port} --path ${path}`;
+        const vbsContent = `CreateObject("WScript.Shell").Run "${cmd.replace(/"/g, '""')}", 0, False
+`;
+        if (dryRun) {
+          messages.push(`[dry-run] write ${vbs}`);
+          messages.push(`[dry-run] reg add "${runKey}" /v ${valueName} /t REG_SZ /d "wscript.exe \\"${vbs}\\"" /f`);
+        } else {
+          mkdirSync(launcherDir, { recursive: true });
+          writeFileSync(vbs, vbsContent);
+          execFileSync("reg", ["add", runKey, "/v", valueName, "/t", "REG_SZ", "/d", `wscript.exe "${vbs}"`, "/f"], { encoding: "utf8", windowsHide: true });
+          messages.push(`auto-start registered: HKCU Run '${valueName}' -> hidden wscript launcher "${vbs}"`);
+          messages.push(`start it now with: wscript.exe "${vbs}"`);
+        }
+      } else {
+        if (dryRun) {
+          messages.push(`[dry-run] reg delete "${runKey}" /v ${valueName} /f`);
+          messages.push(`[dry-run] del ${vbs}`);
+        } else {
+          try {
+            execFileSync("reg", ["delete", runKey, "/v", valueName, "/f"], { encoding: "utf8", windowsHide: true });
+          } catch {
+          }
+          rmSync(launcherDir, { recursive: true, force: true });
+          messages.push("auto-start removed (Run key + hidden launcher)");
+        }
+      }
+      return { ok: true, messages };
+    }
+    if (process.platform === "linux") {
+      const unitDir = join2(homedir2(), ".config", "systemd", "user");
+      const unitFile = join2(unitDir, "agent-comm-hub.service");
+      if (options.action === "install") {
+        const unit = `[Unit]
+Description=agent-comm-hub (multi-peer MCP hub)
+After=network.target
+
+[Service]
+ExecStart=${nodeExe()} ${cliPath()} --host ${host} --port ${port} --path ${path}
+Restart=on-failure
+
+[Install]
+WantedBy=default.target
+`;
+        if (dryRun) {
+          messages.push(`[dry-run] would write ${unitFile}`);
+          messages.push(`[dry-run] systemctl --user daemon-reload && systemctl --user enable --now agent-comm-hub`);
+        } else {
+          mkdirSync(unitDir, { recursive: true });
+          writeFileSync(unitFile, unit);
+          run("systemctl", ["--user", "daemon-reload"], false);
+          const out = run("systemctl", ["--user", "enable", "--now", "agent-comm-hub"], false);
+          messages.push(out || `systemd user unit installed and enabled: ${unitFile}`);
+        }
+      } else {
+        if (dryRun) {
+          messages.push(`[dry-run] systemctl --user disable --now agent-comm-hub && rm ${unitFile}`);
+        } else {
+          run("systemctl", ["--user", "disable", "--now", "agent-comm-hub"], false);
+          rmSync(unitFile, { force: true });
+          run("systemctl", ["--user", "daemon-reload"], false);
+          messages.push(`systemd user unit removed: ${unitFile}`);
+        }
+      }
+      return { ok: true, messages };
+    }
+    return { ok: false, messages: [`auto-start is not implemented for ${process.platform} \u2014 use pm2 or your platform's supervisor`] };
+  } catch (error) {
+    return { ok: false, messages: [`${error.message}`] };
+  }
+}
+
+// src/cli.ts
+function parseArgs(argv) {
+  const args = {};
+  const numeric = /* @__PURE__ */ new Set(["--port", "--max-queue", "--history-limit", "--wait-timeout-ms", "--default-wait-ms", "--connected-window-ms", "--peer-idle-timeout-ms"]);
+  const string = /* @__PURE__ */ new Set(["--host", "--path", "--url", "--server-name"]);
+  for (let i = 0; i < argv.length; i++) {
+    const flag = argv[i];
+    if (flag === "--help" || flag === "-h" || flag === "--version" || flag === "-V") {
+      args[flag] = true;
+      continue;
+    }
+    if (flag === "--remove" || flag === "--dry-run") {
+      args[flag] = true;
+      continue;
+    }
+    const value = argv[i + 1];
+    if (numeric.has(flag)) {
+      const parsed = Number(value);
+      if (!Number.isFinite(parsed) || parsed <= 0) throw new Error(`${flag} expects a positive number, got '${value}'`);
+      args[flag] = parsed;
+      i++;
+    } else if (string.has(flag)) {
+      if (value === void 0) throw new Error(`${flag} expects a value`);
+      args[flag] = value;
+      i++;
+    } else {
+      throw new Error(`unknown flag: ${flag}`);
+    }
+  }
+  return args;
+}
+function printHelp() {
+  console.log(`agent-comm-hub v${SERVER_VERSION} \u2014 generic multi-peer MCP hub
+
+Usage:
+  agent-comm-hub [options]                 start the hub
+  agent-comm-hub setup [options]           sync the MCP entry + skill into
+                                           every installed agent (incremental,
+                                           idempotent; --remove undoes)
+  agent-comm-hub status [options]          show hub health + online peers
+  agent-comm-hub service install|uninstall [options]
+                                           one-shot auto-start (Windows
+                                           Task Scheduler / Linux systemd;
+                                           --dry-run prints commands)
+
+Hub options:
+  --host <addr>            Bind address (default 127.0.0.1)
+  --port <n>               Listen port (default 18764)
+  --path <p>               MCP endpoint path (default /mcp)
+  --max-queue <n>          Queued messages per peer before dropping oldest (default 200)
+  --history-limit <n>      Retained history messages (default 100)
+  --wait-timeout-ms <n>    Long-poll ceiling for bridge_wait (default 60000)
+  --default-wait-ms <n>    bridge_wait default budget (default 30000)
+  --connected-window-ms <n>  Peer counts as active within this window (default 30000)
+  --peer-idle-timeout-ms <n> Auto-unregister idle peers after this; 0 disables (default 600000)
+
+Setup options:
+  --url <url>              Hub endpoint to register (default http://127.0.0.1:18764/mcp)
+  --server-name <name>     Config key (default agent-hub)
+  --remove                 Uninstall instead of install
+
+  -h, --help               Show this help
+  -V, --version            Show version
+
+Agents connect via MCP streamable-http at http://<host>:<port><path> and are
+auto-registered at connect (client name becomes the peer id).`);
+}
+var log = {
+  info: (message) => console.log(message),
+  warn: (message) => console.warn(message)
+};
+try {
+  const argv = process.argv.slice(2);
+  const [command, ...rest] = argv;
+  if (command === "setup" || command === "install") {
+    const args2 = parseArgs(rest);
+    if (args2["--help"] || args2["-h"]) {
+      printHelp();
+      process.exit(0);
+    }
+    await runSetup({
+      url: args2["--url"],
+      serverName: args2["--server-name"],
+      remove: args2["--remove"] === true,
+      log: (message) => log.info(message)
+    });
+    process.exit(0);
+  }
+  if (command === "status") {
+    const args2 = parseArgs(rest);
+    const result = await runStatus({
+      host: args2["--host"],
+      port: args2["--port"],
+      path: args2["--path"],
+      url: args2["--url"]
+    });
+    if (!result.running) {
+      console.error(`hub is not running at ${result.url}${result.error ? ` (${result.error})` : ""}`);
+      console.error("start it with: agent-comm-hub");
+      process.exit(1);
+    }
+    console.log(`agent-comm-hub${result.version ? ` v${result.version}` : ""} at ${result.url}`);
+    if (result.peers.length === 0) {
+      console.log("no peers online yet \u2014 start an agent session to see it appear");
+    } else {
+      for (const peer of result.peers) {
+        console.log(`  ${peer.id.padEnd(32)} ${peer.connected ? "connected" : "offline"}`);
+      }
+    }
+    process.exit(0);
+  }
+  if (command === "service") {
+    const [action, ...serviceRest] = rest;
+    if (action !== "install" && action !== "uninstall") {
+      console.error(`service: expected 'install' or 'uninstall', got '${action ?? ""}'`);
+      process.exit(1);
+    }
+    const args2 = parseArgs(serviceRest);
+    const result = runService({
+      action,
+      host: args2["--host"],
+      port: args2["--port"],
+      path: args2["--path"],
+      dryRun: args2["--dry-run"] === true
+    });
+    for (const message of result.messages) log.info(message);
+    if (!result.ok) {
+      console.error("service: failed \u2014 see messages above");
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+  const args = parseArgs(argv);
+  if (args["--help"] || args["-h"]) {
+    printHelp();
+    process.exit(0);
+  }
+  if (args["--version"] || args["-V"]) {
+    console.log(SERVER_VERSION);
+    process.exit(0);
+  }
+  const hub = startHub({
+    host: args["--host"],
+    port: args["--port"],
+    path: args["--path"],
+    maxQueue: args["--max-queue"],
+    historyLimit: args["--history-limit"],
+    waitTimeoutMs: args["--wait-timeout-ms"],
+    defaultWaitMs: args["--default-wait-ms"],
+    connectedWindowMs: args["--connected-window-ms"],
+    peerIdleTimeoutMs: args["--peer-idle-timeout-ms"]
+  }, log);
+  const shutdown = () => {
+    log.info("agent-comm-hub shutting down");
+    hub.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+} catch (error) {
+  console.error(`agent-comm-hub: ${error.message}`);
+  process.exit(1);
+}