bantou 0.1.1 → 0.2.0

package/.output/server/node_modules/@unagents/messenger-client/dist/shared/messenger-client.CoDKzubj.mjs

@@ -0,0 +1,1000 @@
+import { homedir, hostname, networkInterfaces } from 'node:os';
+import { join } from 'node:path';
+import { E as ENV, D as DEFAULT_BROKER_CMD, P as POLL_INTERVAL_MS, B as BROKER_CMD_ENV, o as SESSION_TOKEN_ENV, S as SESSION_SOCKET_ENV, G as GRACE_MS_ENV, c as DEFAULT_GRACE_MS, i as HEARTBEAT_INTERVAL_MS, b as DEFAULT_DISCOVERY_TIMEOUT_MS, a as DEFAULT_DISCOVERY_PORT, d as DEFAULT_HTTP_PORT, L as LOCAL_HOSTS, I as INSTRUCTIONS, V as VERSION, H as HEALTH_ROUTE, u as recordSeen, v as describeMeta, f as DISCOVERY_KEY, h as DISCOVERY_REPLY_VALUE, g as DISCOVERY_PROBE_VALUE, e as DISCOVERY_BROADCAST_ADDR, q as createToolRegistry, w as getProtocol, x as unsetProtocol, y as setProtocol, z as listPeers, A as parseMeta, C as createProtocolState, J as planOutgoing, K as wireDecls, M as resendDefinitions, F as FALLBACK_ENV, R as RESOLVE_RETRY_MS } from './messenger-client.CfQVmH_Z.mjs';
+import { connect } from 'node:net';
+import { spawnSync, spawn } from 'node:child_process';
+import { readFileSync, mkdirSync, openSync } from 'node:fs';
+import { createSocket } from 'node:dgram';
+
+function loadConfig(env) {
+  const rawHost = (env[ENV.HOST] ?? "").trim();
+  const stateDir = join(homedir(), ".agent-messenger");
+  return {
+    host: rawHost && rawHost.toLowerCase() !== "auto" ? rawHost : "",
+    port: parseInt(env[ENV.PORT] ?? String(DEFAULT_HTTP_PORT), 10),
+    token: env[ENV.TOKEN] ?? "",
+    name: env[ENV.NAME] ?? "",
+    stateDir,
+    configFile: env[ENV.CONFIG] ?? join(stateDir, "config.json"),
+    discoveryEnabled: (env[ENV.DISCOVERY] ?? "on").toLowerCase() !== "off",
+    discoveryPort: parseInt(env[ENV.DISCOVERY_PORT] ?? String(DEFAULT_DISCOVERY_PORT), 10),
+    discoveryAddr: env[ENV.DISCOVERY_ADDR] ?? "",
+    discoveryTimeoutMs: parseInt(env[ENV.DISCOVERY_TIMEOUT_MS] ?? String(DEFAULT_DISCOVERY_TIMEOUT_MS), 10),
+    heartbeatIntervalMs: parseInt(env[ENV.HEARTBEAT_MS] ?? String(HEARTBEAT_INTERVAL_MS), 10),
+    graceMs: parseInt(env[GRACE_MS_ENV] ?? String(DEFAULT_GRACE_MS), 10),
+    pollIntervalMs: POLL_INTERVAL_MS,
+    sessionSocket: env[SESSION_SOCKET_ENV] ?? "",
+    sessionToken: env[SESSION_TOKEN_ENV] ?? "",
+    delivery: env[ENV.DELIVERY] ?? "auto",
+    brokerCmd: env[BROKER_CMD_ENV] ?? DEFAULT_BROKER_CMD
+  };
+}
+function isLocalHost(host) {
+  for (const h of LOCAL_HOSTS) if (h === host) return true;
+  return false;
+}
+
+const LATEST_PROTOCOL_VERSION = "2025-11-25";
+const SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05", "2024-10-07"];
+function createStdioServer(opts) {
+  const handlers = /* @__PURE__ */ new Map();
+  const onError = opts.onError ?? (() => {
+  });
+  const write = (msg) => new Promise((resolve) => {
+    const line = JSON.stringify(msg) + "\n";
+    const flushed = process.stdout.write(line, (err) => {
+      if (err) onError(err);
+    });
+    if (flushed) resolve();
+    else process.stdout.once("drain", () => resolve());
+  });
+  const sendResult = (id, result) => write({ jsonrpc: "2.0", id, result });
+  const sendError = (id, code, message, data) => write({ jsonrpc: "2.0", id, error: data === void 0 ? { code, message } : { code, message, data } });
+  handlers.set("initialize", (params) => {
+    const p = params ?? {};
+    const requested = typeof p.protocolVersion === "string" ? p.protocolVersion : "";
+    const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requested) ? requested : LATEST_PROTOCOL_VERSION;
+    if (opts.onInitialize) opts.onInitialize(params);
+    const result = {
+      protocolVersion,
+      capabilities: opts.capabilities,
+      serverInfo: opts.serverInfo
+    };
+    if (opts.instructions) result.instructions = opts.instructions;
+    return result;
+  });
+  handlers.set("ping", () => ({}));
+  const dispatchRequest = (req) => {
+    const handler = handlers.get(req.method);
+    if (!handler) {
+      sendError(req.id, -32601, "Method not found").catch(onError);
+      return;
+    }
+    Promise.resolve().then(() => handler(req.params)).then(
+      (result) => sendResult(req.id, result),
+      (err) => {
+        const e = err ?? {};
+        const code = typeof e.code === "number" && Number.isSafeInteger(e.code) ? e.code : -32603;
+        const message = typeof e.message === "string" ? e.message : "Internal error";
+        return sendError(req.id, code, message, e.data);
+      }
+    ).catch(onError);
+  };
+  const handleLine = (raw) => {
+    const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch (e) {
+      onError(e instanceof Error ? e : new Error(String(e)));
+      return;
+    }
+    if (typeof msg !== "object" || msg === null) {
+      onError(new Error("invalid JSON-RPC message"));
+      return;
+    }
+    const m = msg;
+    if (m.jsonrpc !== "2.0") {
+      onError(new Error("invalid JSON-RPC message"));
+      return;
+    }
+    const hasId = typeof m.id === "number" || typeof m.id === "string";
+    if (typeof m.method === "string") {
+      if (hasId) dispatchRequest(m);
+      return;
+    }
+  };
+  return {
+    setRequestHandler(method, handler) {
+      handlers.set(method, handler);
+    },
+    notification(method, params) {
+      const n = { jsonrpc: "2.0", method, params };
+      return write(n);
+    },
+    connect() {
+      let buf = "";
+      process.stdin.setEncoding("utf8");
+      const read = async () => {
+        try {
+          for await (const chunk of process.stdin) {
+            buf += chunk;
+            let i;
+            while ((i = buf.indexOf("\n")) !== -1) {
+              const line = buf.slice(0, i);
+              buf = buf.slice(i + 1);
+              handleLine(line);
+            }
+          }
+        } catch (e) {
+          onError(e instanceof Error ? e : new Error(String(e)));
+        }
+        if (opts.onClose) opts.onClose();
+      };
+      read().catch(onError);
+    }
+  };
+}
+
+function postToSession(socketPath, token, text) {
+  return new Promise((resolve, reject) => {
+    if (!socketPath) {
+      reject(new Error("CLAUDE_CODE_MESSAGING_SOCKET not set"));
+      return;
+    }
+    const sock = connect(socketPath);
+    const timer = setTimeout(() => {
+      sock.destroy();
+      reject(new Error("session socket timeout"));
+    }, 5e3);
+    sock.on("connect", () => {
+      if (token) {
+        const auth = { type: "auth", token };
+        sock.write(JSON.stringify(auth) + "\n");
+      }
+      const user = { type: "user", message: { role: "user", content: text } };
+      sock.write(JSON.stringify(user) + "\n");
+      sock.end();
+    });
+    sock.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+    sock.on("close", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+}
+
+const CAPABILITIES = {
+  experimental: { "claude/channel": {} },
+  tools: {}
+};
+function errorMessage$2(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+function senderLabel(entry) {
+  return `${entry.from_name || entry.from_id}${entry.from_hostname ? `@${entry.from_hostname}` : ""}`;
+}
+function channelMeta(entry) {
+  return {
+    from_id: entry.from_id,
+    from_name: entry.from_name,
+    from_hostname: entry.from_hostname,
+    from_summary: entry.from_summary,
+    from_cwd: entry.from_cwd,
+    sent_at: entry.sent_at
+  };
+}
+function createStdioHost(opts) {
+  const { cfg, log } = opts;
+  const mcp = createStdioServer({
+    serverInfo: { name: "agent-messenger", version: VERSION },
+    capabilities: CAPABILITIES,
+    instructions: INSTRUCTIONS,
+    onClose: opts.onClose
+  });
+  const notifier = {
+    /**
+     * body=pull: put one unread notice into the session (session socket → channel).
+     * The text stays unacknowledged at the broker until `check_messages`.
+     */
+    async unread(latest, count) {
+      const who = senderLabel(latest);
+      const notice = `[agent-messenger] \u672A\u8AAD ${count} \u4EF6\uFF08from ${who}\uFF09\u3002check_messages \u3067\u53D7\u4FE1\u3057\u3066\u304F\u3060\u3055\u3044${latest.protocol_line ? `
+${latest.protocol_line}` : ""}`;
+      let delivered = false;
+      const useSocket = cfg.delivery === "socket" || cfg.delivery === "auto" && cfg.sessionSocket;
+      if (useSocket) {
+        try {
+          await postToSession(cfg.sessionSocket, cfg.sessionToken, notice);
+          log(`Session socket unread notice OK (${count}) from ${who}`);
+          delivered = true;
+        } catch (e) {
+          log(`Session socket unread notice FAILED from ${latest.from_id}: ${errorMessage$2(e)} \u2014 trying channel`);
+        }
+      }
+      if (!delivered) {
+        try {
+          await mcp.notification("notifications/claude/channel", { content: notice, meta: channelMeta(latest) });
+          log(`Channel unread notice OK (${count}) from ${who}`);
+          delivered = true;
+        } catch (e) {
+          log(`Channel unread notice FAILED from ${latest.from_id}: ${errorMessage$2(e)}`);
+        }
+      }
+      return delivered;
+    },
+    /**
+     * mode=ping: put a one-line ping notice into the session (session socket →
+     * channel), with the subject (message text) when given.
+     */
+    async ping(entry) {
+      const who = senderLabel(entry);
+      const notice = `[agent-messenger] ping\uFF08from ${who}\uFF09${entry.text ? `: ${entry.text}` : ""}`;
+      const useSocket = cfg.delivery === "socket" || cfg.delivery === "auto" && cfg.sessionSocket;
+      if (useSocket) {
+        try {
+          await postToSession(cfg.sessionSocket, cfg.sessionToken, notice);
+          log(`Session socket ping notice OK from ${who}`);
+          return;
+        } catch (e) {
+          log(`Session socket ping notice FAILED from ${entry.from_id}: ${errorMessage$2(e)} \u2014 trying channel`);
+        }
+      }
+      try {
+        await mcp.notification("notifications/claude/channel", { content: notice, meta: channelMeta(entry) });
+        log(`Channel ping notice OK from ${who}`);
+      } catch (e) {
+        log(`Channel ping notice FAILED from ${entry.from_id}: ${errorMessage$2(e)}`);
+      }
+    },
+    /** mode=push: deliver the text (session socket → channel). true = delivered. */
+    async push(entry) {
+      const useSocket = cfg.delivery === "socket" || cfg.delivery === "auto" && cfg.sessionSocket;
+      if (useSocket) {
+        try {
+          const who = `${entry.from_name || entry.from_id}${entry.from_hostname ? `@${entry.from_hostname}` : ""}`;
+          const replyTo = entry.from_name || entry.from_id;
+          await postToSession(
+            cfg.sessionSocket,
+            cfg.sessionToken,
+            `[agent-messenger] message from ${who}
+${entry.protocol_line ? `${entry.protocol_line}
+` : ""}${entry.text}
+
+(reply with the agent-messenger send_message tool, to: "${replyTo}")`
+          );
+          log(`Session socket delivery OK from ${who}: ${entry.text.slice(0, 80)}`);
+          return true;
+        } catch (e) {
+          log(`Session socket delivery FAILED from ${entry.from_id}: ${errorMessage$2(e)} \u2014 trying channel`);
+        }
+      }
+      try {
+        await mcp.notification("notifications/claude/channel", {
+          content: entry.protocol_line ? `${entry.protocol_line}
+${entry.text}` : entry.text,
+          meta: {
+            from_id: entry.from_id,
+            from_name: entry.from_name,
+            from_hostname: entry.from_hostname,
+            from_summary: entry.from_summary,
+            from_cwd: entry.from_cwd,
+            sent_at: entry.sent_at
+          }
+        });
+        log(`Channel push OK from ${entry.from_name || entry.from_id}: ${entry.text.slice(0, 80)}`);
+        return true;
+      } catch (e) {
+        log(`Channel push FAILED from ${entry.from_id}: ${errorMessage$2(e)}`);
+      }
+      return false;
+    }
+  };
+  return {
+    notifier,
+    attach(registry) {
+      mcp.setRequestHandler("tools/list", () => ({ tools: registry.list() }));
+      mcp.setRequestHandler("tools/call", async (params) => {
+        const p = params ?? {};
+        return registry.call(p.name ?? "", p.arguments ?? {});
+      });
+    },
+    connect() {
+      mcp.connect();
+    }
+  };
+}
+
+function httpRequest(method, url, headers, body, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let u;
+    try {
+      u = new URL(url);
+    } catch (e) {
+      reject(e instanceof Error ? e : new Error(String(e)));
+      return;
+    }
+    if (u.protocol !== "http:") {
+      reject(new Error(`unsupported protocol: ${u.protocol}`));
+      return;
+    }
+    const host = u.hostname;
+    const port = u.port ? Number(u.port) : 80;
+    const path = `${u.pathname}${u.search}`;
+    const chunks = [];
+    let settled = false;
+    const sock = connect(port, host);
+    const finish = (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (err) {
+        sock.destroy();
+        reject(err);
+        return;
+      }
+      try {
+        resolve(parseResponse(Buffer.concat(chunks)));
+      } catch (e) {
+        reject(e instanceof Error ? e : new Error(String(e)));
+      }
+    };
+    const timer = setTimeout(() => finish(new Error(`request timeout after ${timeoutMs}ms`)), timeoutMs);
+    sock.on("connect", () => {
+      const lines = [
+        `${method} ${path} HTTP/1.1`,
+        `Host: ${host}:${port}`,
+        "Connection: close",
+        `Content-Length: ${Buffer.byteLength(body)}`
+      ];
+      for (const k of Object.keys(headers)) lines.push(`${k}: ${headers[k]}`);
+      sock.write(lines.join("\r\n") + "\r\n\r\n" + body);
+    });
+    sock.on("data", (d) => {
+      chunks.push(d);
+    });
+    sock.on("error", (e) => finish(e));
+    sock.on("close", () => finish(null));
+  });
+}
+function parseResponse(raw) {
+  const sep = raw.indexOf("\r\n\r\n");
+  if (sep === -1) throw new Error("malformed HTTP response (no header terminator)");
+  const head = raw.subarray(0, sep).toString("utf8");
+  const headLines = head.split("\r\n");
+  const status = Number(headLines[0].split(" ")[1]);
+  if (!Number.isFinite(status)) throw new Error(`malformed HTTP status line: ${headLines[0]}`);
+  const h = {};
+  for (let i = 1; i < headLines.length; i++) {
+    const c = headLines[i].indexOf(":");
+    if (c === -1) continue;
+    h[headLines[i].slice(0, c).trim().toLowerCase()] = headLines[i].slice(c + 1).trim();
+  }
+  let bodyBuf = raw.subarray(sep + 4);
+  if ((h["transfer-encoding"] ?? "").toLowerCase() === "chunked") {
+    bodyBuf = dechunk(bodyBuf);
+  } else if (h["content-length"] !== void 0) {
+    bodyBuf = bodyBuf.subarray(0, Number(h["content-length"]));
+  }
+  return { status, ok: status >= 200 && status < 300, body: bodyBuf.toString("utf8") };
+}
+function dechunk(buf) {
+  const out = [];
+  let pos = 0;
+  for (; ; ) {
+    const eol = buf.indexOf("\r\n", pos);
+    if (eol === -1) break;
+    const size = parseInt(buf.subarray(pos, eol).toString("ascii").split(";")[0], 16);
+    if (!Number.isFinite(size) || size === 0) break;
+    out.push(buf.subarray(eol + 2, eol + 2 + size));
+    pos = eol + 2 + size + 2;
+  }
+  return Buffer.concat(out);
+}
+function createBrokerClient(token) {
+  let brokerUrl = "";
+  return {
+    setUrl(url) {
+      brokerUrl = url.replace(/\/$/, "");
+    },
+    getUrl() {
+      return brokerUrl;
+    },
+    async post(path, body, opts = {}) {
+      if (!brokerUrl) throw new Error("broker not resolved");
+      const headers = { "Content-Type": "application/json" };
+      if (token) headers["Authorization"] = `Bearer ${token}`;
+      const res = await httpRequest("POST", `${brokerUrl}${path}`, headers, JSON.stringify(body ?? {}), opts.timeoutMs ?? 5e3);
+      if (!res.ok) {
+        throw new Error(`Broker error (${path}): ${res.status} ${res.body}`);
+      }
+      return JSON.parse(res.body);
+    },
+    async health(url = brokerUrl, timeoutMs = 2e3) {
+      if (!url) return null;
+      try {
+        const res = await httpRequest("GET", `${url}${HEALTH_ROUTE}`, {}, "", timeoutMs);
+        if (!res.ok) return null;
+        return JSON.parse(res.body);
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+
+const MAX_BUFFER = 200;
+function errorMessage$1(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+function createInbox(opts) {
+  const { broker, peer, log, notifier, protocols } = opts;
+  const localBuffer = [];
+  const notifiedIds = /* @__PURE__ */ new Set();
+  const handlers = [];
+  let dispatching = false;
+  let stopped = false;
+  async function lookupSender(fromId) {
+    try {
+      const peers = await broker.post("/list-peers", { scope: "all", cwd: peer.cwd, git_root: peer.gitRoot });
+      return peers.find((p) => p.id === fromId) ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async function acknowledge(messageId) {
+    await broker.post("/acknowledge-messages", { id: peer.id, message_ids: [messageId] }).catch(() => {
+    });
+    const i = localBuffer.findIndex((b) => b.id === messageId);
+    if (i !== -1) localBuffer.splice(i, 1);
+  }
+  function markProtocol(entry) {
+    if (!protocols || !entry.meta) return;
+    recordSeen(protocols, entry.from_id, entry.from_name, entry.meta);
+    entry.protocol_line = describeMeta(protocols, entry.meta);
+  }
+  function pushBuffer(entry) {
+    markProtocol(entry);
+    localBuffer.push(entry);
+    if (localBuffer.length > MAX_BUFFER) localBuffer.splice(0, localBuffer.length - MAX_BUFFER);
+  }
+  async function notifyUnread() {
+    if (!notifier) return;
+    if (localBuffer.length === 0) return;
+    if (!localBuffer.some((b) => !notifiedIds.has(b.id))) return;
+    const latest = localBuffer[localBuffer.length - 1];
+    const delivered = await notifier.unread(latest, localBuffer.length);
+    if (delivered) for (const b of localBuffer) notifiedIds.add(b.id);
+  }
+  async function dispatch() {
+    if (dispatching) return;
+    dispatching = true;
+    try {
+      for (const entry of localBuffer.slice()) {
+        if (stopped || handlers.length === 0) break;
+        try {
+          for (const h of handlers.slice()) await h(entry);
+        } catch (e) {
+          log(`Message handler failed for ${entry.id}: ${errorMessage$1(e)} \u2014 will retry`);
+          continue;
+        }
+        if (stopped) break;
+        await acknowledge(entry.id);
+      }
+    } finally {
+      dispatching = false;
+    }
+  }
+  async function poll(push) {
+    if (stopped || !peer.id) return;
+    const result = await broker.post("/poll-messages", { id: peer.id });
+    for (const msg of result.messages) {
+      if (stopped) return;
+      const sender = await lookupSender(msg.from_id);
+      const entry = {
+        ...msg,
+        from_name: msg.from_name || sender?.name || "",
+        from_hostname: sender?.hostname ?? "",
+        from_summary: sender?.summary ?? "",
+        from_cwd: sender?.cwd ?? ""
+      };
+      if (handlers.length > 0) {
+        pushBuffer(entry);
+        continue;
+      }
+      if (msg.mode === "ping") {
+        if (notifier) await notifier.ping(entry);
+        await acknowledge(msg.id);
+        continue;
+      }
+      pushBuffer(entry);
+      if (!push || msg.mode !== "push") continue;
+      if (notifier && await notifier.push(entry)) await acknowledge(msg.id);
+    }
+    if (handlers.length > 0) await dispatch();
+    else if (push) await notifyUnread();
+  }
+  async function checkMessages() {
+    await poll(false);
+    const buffered = await broker.post("/get-buffered-messages", { id: peer.id });
+    for (const m of buffered.messages) {
+      if (m.mode === "ping") {
+        await acknowledge(m.id);
+        continue;
+      }
+      if (!localBuffer.some((b) => b.id === m.id)) {
+        const entry = { ...m, from_hostname: "", from_summary: "", from_cwd: "" };
+        markProtocol(entry);
+        localBuffer.push(entry);
+      }
+    }
+    for (const b of localBuffer.slice()) {
+      if (b.mode === "ping") await acknowledge(b.id);
+    }
+    if (localBuffer.length === 0) return [];
+    const ids = localBuffer.map((m) => m.id);
+    await broker.post("/acknowledge-messages", { id: peer.id, message_ids: ids }).catch(() => {
+    });
+    const out = localBuffer.slice();
+    localBuffer.length = 0;
+    notifiedIds.clear();
+    return out;
+  }
+  function onMessage(handler) {
+    handlers.push(handler);
+    return () => {
+      const i = handlers.indexOf(handler);
+      if (i !== -1) handlers.splice(i, 1);
+    };
+  }
+  function stop() {
+    stopped = true;
+  }
+  return { poll, checkMessages, onMessage, stop };
+}
+
+function createPeerState(init) {
+  return {
+    id: null,
+    name: init.name,
+    summary: init.summary ?? "",
+    hostname: init.hostname ?? hostname(),
+    cwd: init.cwd ?? process.cwd(),
+    gitRoot: null,
+    tty: null
+  };
+}
+function git(args, cwd) {
+  const r = spawnSync("git", args, { cwd, stdio: ["ignore", "pipe", "ignore"] });
+  return r.status === 0 ? r.stdout.toString().trim() : null;
+}
+function detectGitRoot(cwd) {
+  return git(["rev-parse", "--show-toplevel"], cwd);
+}
+function detectTty() {
+  try {
+    const r = spawnSync("ps", ["-o", "tty=", "-p", String(process.ppid)]);
+    const tty = r.stdout.toString().trim();
+    if (tty && tty !== "?" && tty !== "??") return tty;
+  } catch {
+  }
+  return null;
+}
+async function registerPeer(broker, peer, log, protocols) {
+  const reg = await broker.post("/register", {
+    pid: process.pid,
+    hostname: peer.hostname,
+    cwd: peer.cwd,
+    git_root: peer.gitRoot,
+    tty: peer.tty,
+    summary: peer.summary,
+    name: peer.name,
+    ...protocols === void 0 ? {} : { protocols }
+  });
+  peer.id = reg.id;
+  log(`Registered as peer ${peer.id}`);
+}
+
+async function resolveBroker(cfg, broker, log, brokers) {
+  const done = (r) => {
+    broker.setUrl(r.url);
+    return r;
+  };
+  if (cfg.host) {
+    const url2 = `http://${cfg.host}:${cfg.port}`;
+    return done({ url: url2, host: cfg.host, source: "env", isLocal: isLocalHost(cfg.host) });
+  }
+  const configured = brokers === void 0 ? readConfigBrokers(cfg) : brokers.map((s) => normalizeUrl(s, cfg.port));
+  const configSource = brokers === void 0 ? `config ${cfg.configFile}` : "config (options)";
+  for (const url2 of configured) {
+    if (await broker.health(url2, 1500)) {
+      const host = hostOf(url2);
+      return done({ url: url2, host, source: configSource, isLocal: isLocalHost(host) });
+    }
+    log(`config broker not reachable: ${url2}`);
+  }
+  if (cfg.discoveryEnabled) {
+    const found = await discoverBrokers(cfg);
+    if (found.length) {
+      const b = found[0];
+      return done({ url: b.url, host: b.host, source: `discovery (${b.id})`, isLocal: isLocalHost(b.host) });
+    }
+    log("discovery: no broker answered");
+  }
+  const url = `http://127.0.0.1:${cfg.port}`;
+  return done({ url, host: "127.0.0.1", source: "local fallback", isLocal: true });
+}
+function hostOf(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return url;
+  }
+}
+function readConfigBrokers(cfg) {
+  try {
+    const parsed = JSON.parse(readFileSync(cfg.configFile, "utf8"));
+    const list = Array.isArray(parsed.brokers) ? parsed.brokers : parsed.broker ? [parsed.broker] : [];
+    const out = [];
+    for (const s of list) {
+      if (typeof s === "string" && s.trim()) out.push(normalizeUrl(s, cfg.port));
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+function normalizeUrl(s, defaultPort) {
+  s = s.trim();
+  if (!/^https?:\/\//.test(s)) s = `http://${s}`;
+  const u = new URL(s);
+  if (!u.port) u.port = String(defaultPort);
+  return u.origin;
+}
+function probeTargets(cfg) {
+  if (cfg.discoveryAddr) return [cfg.discoveryAddr];
+  const targets = /* @__PURE__ */ new Set([DISCOVERY_BROADCAST_ADDR]);
+  const ifaces = networkInterfaces();
+  for (const name of Object.keys(ifaces)) {
+    const list = ifaces[name] ?? [];
+    for (const i of list) {
+      if (i.family !== "IPv4" || i.internal || !i.netmask) continue;
+      const ip = i.address.split(".").map(Number);
+      const mask = i.netmask.split(".").map(Number);
+      const parts = [];
+      for (let k = 0; k < 4; k++) parts.push(String(ip[k] & mask[k] | ~mask[k] & 255));
+      targets.add(parts.join("."));
+    }
+  }
+  return [...targets];
+}
+function discoverBrokers(cfg, timeoutMs = cfg.discoveryTimeoutMs) {
+  return new Promise((resolve) => {
+    const sock = createSocket({ type: "udp4", reuseAddr: true });
+    const found = /* @__PURE__ */ new Map();
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        sock.close();
+      } catch {
+      }
+      resolve([...found.values()].sort((a, b) => Number(a.fallback) - Number(b.fallback)));
+    };
+    const timer = setTimeout(finish, timeoutMs);
+    sock.on("error", finish);
+    sock.on("message", (msg, rinfo) => {
+      try {
+        const m = JSON.parse(msg.toString());
+        if (m[DISCOVERY_KEY] !== DISCOVERY_REPLY_VALUE || !m.port) return;
+        const host = rinfo.address;
+        const url = `http://${host}:${m.port}`;
+        if (!found.has(url)) {
+          found.set(url, { url, host, port: m.port, id: m.id ?? host, version: m.version ?? "", fallback: m.fallback === true });
+        }
+      } catch {
+      }
+    });
+    sock.bind(0, () => {
+      try {
+        sock.setBroadcast(true);
+      } catch {
+      }
+      const probe = Buffer.from(JSON.stringify({ [DISCOVERY_KEY]: DISCOVERY_PROBE_VALUE }));
+      for (const t of probeTargets(cfg)) {
+        sock.send(probe, cfg.discoveryPort, t, () => {
+        });
+      }
+    });
+  });
+}
+
+function errorMessage(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+async function ensureBroker(cfg, env, broker, resolved, log, autoStart) {
+  if (await broker.health()) {
+    log("Broker already running");
+    return;
+  }
+  if (!resolved.isLocal) {
+    throw new Error(
+      `Remote broker at ${broker.getUrl()} is not reachable. Start it on the broker host: agent-messenger broker`
+    );
+  }
+  if (!autoStart) {
+    throw new Error(`Local broker at ${broker.getUrl()} is not reachable (autoStartBroker is off)`);
+  }
+  log("Starting local broker daemon...");
+  mkdirSync(cfg.stateDir, { recursive: true });
+  const out = openSync(`${cfg.stateDir}/broker.log`, "a");
+  const argv = cfg.brokerCmd.trim().split(/\s+/);
+  const cmd = argv[0];
+  const args = argv.slice(1);
+  const proc = spawn(cmd, args, {
+    stdio: ["ignore", out, out],
+    detached: true,
+    // FALLBACK_ENV: this broker is a stop-gap; it hands over to a real broker once one shows up and exits
+    env: { ...env, AGENT_MESSENGER_PORT: new URL(broker.getUrl()).port, [FALLBACK_ENV]: "1" }
+  });
+  proc.unref();
+  for (let i = 0; i < 30; i++) {
+    await new Promise((r) => setTimeout(r, 200));
+    if (await broker.health()) {
+      log("Broker started");
+      return;
+    }
+  }
+  throw new Error("Failed to start broker daemon after 6 seconds");
+}
+function createMessengerClient(options = {}) {
+  const env = options.env ?? process.env;
+  const log = options.log ?? ((msg) => console.error(`[agent-messenger] ${msg}`));
+  const cfg = options.config ?? loadConfig(env);
+  const autoStart = options.autoStartBroker === true;
+  const notifier = options.notifier;
+  const broker = createBrokerClient(cfg.token);
+  const peer = createPeerState({ name: options.name ?? cfg.name, summary: options.summary });
+  const protocols = createProtocolState();
+  const inbox = createInbox({ broker, peer, log, notifier, protocols });
+  const registry = createToolRegistry({ broker, peer, inbox, protocols });
+  const protocolEnv = { broker, peer, protocols };
+  let connectPromise = null;
+  let closePromise = null;
+  let closed = false;
+  let pollTimer = null;
+  let recoverTimer = null;
+  let heartbeatTimer = null;
+  let failSince = null;
+  let lastResolveAttempt = 0;
+  let resolving = false;
+  let inflightReresolve = null;
+  function noteFailure() {
+    if (failSince !== null) return;
+    failSince = Date.now();
+    log(`Broker ${broker.getUrl()} unreachable \u2014 retrying it for ${cfg.graceMs} ms before re-resolving`);
+  }
+  function noteOk() {
+    if (failSince === null) return;
+    failSince = null;
+    log(`Broker ${broker.getUrl()} reachable again`);
+  }
+  async function doReresolve(reason) {
+    resolving = true;
+    lastResolveAttempt = Date.now();
+    try {
+      const prev = broker.getUrl();
+      log(`Re-resolving broker (${reason})`);
+      const r = await resolveBroker(cfg, broker, log, options.brokers);
+      await ensureBroker(cfg, env, broker, r, log, autoStart);
+      if (closed) return;
+      await registerPeer(broker, peer, log, wireDecls(protocols));
+      await resendDefinitions(protocolEnv, log);
+      log(`broker=${broker.getUrl()} (${r.isLocal ? "local" : "remote"}, via ${r.source})${prev === broker.getUrl() ? "" : ` \u2014 was ${prev}`}`);
+      failSince = null;
+    } catch (e) {
+      log(`Re-resolve failed: ${errorMessage(e)}`);
+      noteFailure();
+    } finally {
+      resolving = false;
+    }
+  }
+  async function reresolve(reason) {
+    if (resolving || closed) return;
+    const p = doReresolve(reason);
+    inflightReresolve = p;
+    try {
+      await p;
+    } finally {
+      if (inflightReresolve === p) inflightReresolve = null;
+    }
+  }
+  async function pollLoop() {
+    if (resolving || closed) return;
+    try {
+      await inbox.poll(true);
+      noteOk();
+    } catch (e) {
+      log(`Poll error: ${errorMessage(e)}`);
+      noteFailure();
+    }
+  }
+  async function recoverLoop() {
+    if (failSince === null || resolving || closed) return;
+    const now = Date.now();
+    if (now - failSince < cfg.graceMs || now - lastResolveAttempt < RESOLVE_RETRY_MS) return;
+    await reresolve("connection failure");
+  }
+  async function heartbeat() {
+    if (resolving || closed) return;
+    try {
+      const decls = wireDecls(protocols);
+      const r = await broker.post("/heartbeat", decls === void 0 ? { id: peer.id } : { id: peer.id, protocols: decls });
+      if (r && r.ok === false) {
+        log(`Heartbeat rejected (${r.error}) \u2014 re-registering`);
+        await reresolve("heartbeat rejected");
+      } else {
+        noteOk();
+        if (r && r.ok && Array.isArray(r.resend) && r.resend.length > 0) await resendDefinitions(protocolEnv, log, r.resend);
+      }
+    } catch {
+      noteFailure();
+    }
+  }
+  async function doConnect() {
+    const resolved = await resolveBroker(cfg, broker, log, options.brokers);
+    await ensureBroker(cfg, env, broker, resolved, log, autoStart);
+    peer.gitRoot = detectGitRoot(peer.cwd);
+    peer.tty = detectTty();
+    log(`v${VERSION} host=${peer.hostname} broker=${broker.getUrl()} (${resolved.isLocal ? "local" : "remote"}, via ${resolved.source})`);
+    log(`cwd=${peer.cwd} git_root=${peer.gitRoot ?? "(none)"} tty=${peer.tty ?? "(unknown)"} name=${peer.name || "(unset)"}`);
+    if (notifier) log(`delivery=${cfg.delivery} session_socket=${cfg.sessionSocket || "(none)"}`);
+    await registerPeer(broker, peer, log, wireDecls(protocols));
+    if (closed) return;
+    pollTimer = setInterval(pollLoop, cfg.pollIntervalMs);
+    recoverTimer = setInterval(recoverLoop, cfg.pollIntervalMs);
+    heartbeatTimer = setInterval(heartbeat, cfg.heartbeatIntervalMs);
+  }
+  function connect() {
+    if (closed) return Promise.reject(new Error("client closed"));
+    if (connectPromise) return connectPromise;
+    const p = doConnect();
+    connectPromise = p;
+    p.catch(() => {
+      if (connectPromise === p) connectPromise = null;
+    });
+    return p;
+  }
+  async function doClose(cp) {
+    closed = true;
+    inbox.stop();
+    try {
+      await cp;
+    } catch {
+    }
+    if (pollTimer) clearInterval(pollTimer);
+    if (heartbeatTimer) clearInterval(heartbeatTimer);
+    if (recoverTimer) clearInterval(recoverTimer);
+    pollTimer = null;
+    heartbeatTimer = null;
+    recoverTimer = null;
+    if (inflightReresolve) await inflightReresolve.catch(() => {
+    });
+    if (!peer.id) return;
+    try {
+      await broker.post("/unregister", { id: peer.id });
+      log("Unregistered from broker");
+    } catch {
+    }
+  }
+  function close() {
+    if (closePromise) return closePromise;
+    if (!connectPromise) return Promise.resolve();
+    closePromise = doClose(connectPromise);
+    return closePromise;
+  }
+  function requireRegistered() {
+    if (!peer.id) throw new Error("Not registered with broker yet");
+    return peer.id;
+  }
+  async function sendMode(to, text, mode, meta) {
+    const id = requireRegistered();
+    const plan = mode === "ping" ? { text, meta, warning: void 0 } : planOutgoing(protocols, to, text, meta);
+    const r = await broker.post("/send-message", {
+      from_id: id,
+      from_name: peer.name,
+      to,
+      text: plan.text,
+      mode,
+      ...plan.meta === void 0 ? {} : { meta: plan.meta }
+    });
+    if (!r.ok) throw new Error(`Failed to send: ${r.error}`);
+    const out = { to_id: r.to_id, to_name: r.to_name ?? "", message_id: r.message_id };
+    if (plan.warning) out.warning = plan.warning;
+    return out;
+  }
+  protocols.reregister = () => reresolve("protocol call: unknown peer");
+  return {
+    peer,
+    registry,
+    connect,
+    close,
+    async send(to, text, delivery, meta) {
+      requireRegistered();
+      const d = delivery === void 0 ? "pull" : String(delivery);
+      if (d !== "pull" && d !== "push") throw new Error(`Invalid delivery: ${d} (use "pull" or "push")`);
+      return sendMode(to, text, d, parseMeta(meta));
+    },
+    ping(to, subject) {
+      return sendMode(to, subject ?? "", "ping");
+    },
+    async listPeers(scope = "all", filter) {
+      requireRegistered();
+      return listPeers(protocolEnv, scope, filter);
+    },
+    setProtocol(repo, version) {
+      return setProtocol(protocolEnv, repo, version);
+    },
+    async unsetProtocol(name) {
+      await unsetProtocol(protocolEnv, name);
+    },
+    getProtocol(name, version) {
+      return getProtocol(protocolEnv, name, version);
+    },
+    async setName(name) {
+      const id = requireRegistered();
+      const r = await broker.post("/set-name", { id, name });
+      if (!r.ok) throw new Error(`Failed: ${r.error}`);
+      peer.name = name;
+    },
+    async setSummary(summary) {
+      const id = requireRegistered();
+      const r = await broker.post("/set-summary", { id, summary });
+      if (!r.ok) throw new Error(`Failed: ${r.error}`);
+      peer.summary = summary;
+    },
+    checkMessages() {
+      requireRegistered();
+      return inbox.checkMessages();
+    },
+    onMessage: inbox.onMessage
+  };
+}
+
+async function startClient(options = {}) {
+  const env = options.env ?? process.env;
+  const log = options.log ?? ((msg) => console.error(`[agent-messenger] ${msg}`));
+  const cfg = loadConfig(env);
+  let cleaningUp = false;
+  const host = createStdioHost({
+    cfg,
+    log,
+    onClose: () => {
+      cleanup();
+    }
+  });
+  const client = createMessengerClient({ env, log, config: cfg, autoStartBroker: true, notifier: host.notifier });
+  await client.connect();
+  host.attach(client.registry);
+  host.connect();
+  log("MCP connected");
+  async function cleanup() {
+    if (cleaningUp) return;
+    cleaningUp = true;
+    await client.close();
+    process.exit(0);
+  }
+  process.on("SIGINT", () => {
+    cleanup();
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+  });
+}
+
+export { CAPABILITIES as C, LATEST_PROTOCOL_VERSION as L, SUPPORTED_PROTOCOL_VERSIONS as S, createMessengerClient as a, createStdioServer as b, createBrokerClient as c, discoverBrokers as d, resolveBroker as e, isLocalHost as i, loadConfig as l, postToSession as p, readConfigBrokers as r, startClient as s };