bantou 0.1.0 → 0.2.0

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

@@ -0,0 +1,975 @@
+import { existsSync, statSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import * as crypto from 'node:crypto';
+
+const DEFAULT_HTTP_PORT = 7901;
+const DEFAULT_DISCOVERY_PORT = 7902;
+const DEFAULT_DISCOVERY_TIMEOUT_MS = 1e3;
+const HEARTBEAT_INTERVAL_MS = 15e3;
+const POLL_INTERVAL_MS = 1e3;
+const LOCAL_HOSTS = ["127.0.0.1", "localhost", "::1"];
+const ENV = {
+  HOST: "AGENT_MESSENGER_HOST",
+  PORT: "AGENT_MESSENGER_PORT",
+  BIND: "AGENT_MESSENGER_BIND",
+  TOKEN: "AGENT_MESSENGER_TOKEN",
+  NAME: "AGENT_MESSENGER_NAME",
+  BROKER_ID: "AGENT_MESSENGER_BROKER_ID",
+  STATE: "AGENT_MESSENGER_STATE",
+  CONFIG: "AGENT_MESSENGER_CONFIG",
+  DISCOVERY: "AGENT_MESSENGER_DISCOVERY",
+  DISCOVERY_PORT: "AGENT_MESSENGER_DISCOVERY_PORT",
+  DISCOVERY_ADDR: "AGENT_MESSENGER_DISCOVERY_ADDR",
+  DISCOVERY_TIMEOUT_MS: "AGENT_MESSENGER_DISCOVERY_TIMEOUT_MS",
+  HEARTBEAT_MS: "AGENT_MESSENGER_HEARTBEAT_MS",
+  DELIVERY: "AGENT_MESSENGER_DELIVERY"
+};
+const BROKER_CMD_ENV = "AGENT_MESSENGER_BROKER_CMD";
+const DEFAULT_BROKER_CMD = "npx -y @unagents/messenger broker";
+const FALLBACK_ENV = "AGENT_MESSENGER_FALLBACK";
+const GRACE_MS_ENV = "AGENT_MESSENGER_GRACE_MS";
+const DEFAULT_GRACE_MS = 3e4;
+const RESOLVE_RETRY_MS = 5e3;
+const SESSION_SOCKET_ENV = "CLAUDE_CODE_MESSAGING_SOCKET";
+const SESSION_TOKEN_ENV = "CLAUDE_CODE_MESSAGING_TOKEN";
+const HEALTH_ROUTE = "/health";
+const DISCOVERY_KEY = "agent-messenger";
+const DISCOVERY_PROBE_VALUE = "probe";
+const DISCOVERY_REPLY_VALUE = "broker";
+const DISCOVERY_BROADCAST_ADDR = "255.255.255.255";
+const PROTOCOL_MANIFEST_MAX_BYTES = 64 * 1024;
+const PROTOCOL_DOC_MAX_BYTES = 64 * 1024;
+const PROTOCOL_TOTAL_MAX_BYTES = 128 * 1024;
+const PROTOCOL_META_MAX_LENGTH = 128;
+const PROTOCOL_NAME_PATTERN = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+
+function protocolError(code, detail) {
+  const e = new Error(`${code}: ${detail}`);
+  e.code = code;
+  return e;
+}
+function protocolErrorCode(e) {
+  if (e instanceof Error) {
+    const c = e.code;
+    if (typeof c === "string" && e.message.startsWith(`${c}: `)) return c;
+  }
+  return null;
+}
+function errorMessage$1(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+
+function canonicalJSON(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value) ?? "null";
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((v) => canonicalJSON(v)).join(",")}]`;
+  }
+  const obj = value;
+  const parts = [];
+  for (const k of Object.keys(obj).sort()) {
+    const v = obj[k];
+    if (v === void 0 || typeof v === "function" || typeof v === "symbol") continue;
+    parts.push(`${JSON.stringify(k)}:${canonicalJSON(v)}`);
+  }
+  return `{${parts.join(",")}}`;
+}
+function protocolHash(manifest, doc) {
+  return crypto.createHash("sha256").update(canonicalJSON({ manifest, doc })).digest("hex");
+}
+
+function normalizeVersion(v) {
+  const t = v.trim();
+  return t.startsWith("v") ? t.slice(1) : t;
+}
+function isNumeric(s) {
+  return /^[0-9]+$/.test(s);
+}
+function noLeadingZero(s) {
+  return s.length === 1 || s.charAt(0) !== "0";
+}
+function parseSemver(v) {
+  let rest = v;
+  const plus = rest.indexOf("+");
+  if (plus !== -1) {
+    const build = rest.slice(plus + 1);
+    if (build === "") return null;
+    for (const id of build.split(".")) if (!/^[0-9A-Za-z-]+$/.test(id)) return null;
+    rest = rest.slice(0, plus);
+  }
+  let pre = [];
+  const dash = rest.indexOf("-");
+  if (dash !== -1) {
+    const p = rest.slice(dash + 1);
+    if (p === "") return null;
+    pre = p.split(".");
+    for (const id of pre) {
+      if (!/^[0-9A-Za-z-]+$/.test(id)) return null;
+      if (isNumeric(id) && !noLeadingZero(id)) return null;
+    }
+    rest = rest.slice(0, dash);
+  }
+  const nums = rest.split(".");
+  if (nums.length !== 3) return null;
+  for (const n of nums) if (!isNumeric(n) || !noLeadingZero(n)) return null;
+  return { major: nums[0], minor: nums[1], patch: nums[2], pre };
+}
+function cmpDigits(a, b) {
+  if (a.length !== b.length) return a.length < b.length ? -1 : 1;
+  return a === b ? 0 : a < b ? -1 : 1;
+}
+function compareSemver(a, b) {
+  let c = cmpDigits(a.major, b.major);
+  if (c !== 0) return c;
+  c = cmpDigits(a.minor, b.minor);
+  if (c !== 0) return c;
+  c = cmpDigits(a.patch, b.patch);
+  if (c !== 0) return c;
+  if (a.pre.length === 0 && b.pre.length === 0) return 0;
+  if (a.pre.length === 0) return 1;
+  if (b.pre.length === 0) return -1;
+  const n = Math.min(a.pre.length, b.pre.length);
+  for (let i = 0; i < n; i++) {
+    const x = a.pre[i];
+    const y = b.pre[i];
+    const nx = isNumeric(x);
+    const ny = isNumeric(y);
+    if (nx && ny) {
+      c = cmpDigits(x, y);
+      if (c !== 0) return c;
+    } else if (nx !== ny) {
+      return nx ? -1 : 1;
+    } else if (x !== y) {
+      return x < y ? -1 : 1;
+    }
+  }
+  return a.pre.length === b.pre.length ? 0 : a.pre.length < b.pre.length ? -1 : 1;
+}
+
+const FETCH_TIMEOUT_MS = 15e3;
+const defaultFetcher = (url) => new Promise((resolve, reject) => {
+  const timer = setTimeout(() => reject(new Error(`timeout after ${FETCH_TIMEOUT_MS}ms`)), FETCH_TIMEOUT_MS);
+  fetch(url).then(async (res) => {
+    const text = await res.text();
+    clearTimeout(timer);
+    resolve({ status: res.status, text });
+  }).catch((e) => {
+    clearTimeout(timer);
+    reject(e instanceof Error ? e : new Error(String(e)));
+  });
+});
+const ACCEPTED = "https://github.com/<owner>/<repo>, <owner>/<repo>, github:<owner>/<repo>, gitea:<base-url>/<owner>/<repo>, https://<gitea-host>/<owner>/<repo>, /abs/path, ./rel/path, file:///abs/path";
+function unsupported(arg, why = "") {
+  return protocolError("UNSUPPORTED_REPO", `cannot use "${arg}" as a protocol repo${why ? ` (${why})` : ""}. Accepted forms: ${ACCEPTED}`);
+}
+const NAME_PART = /^[A-Za-z0-9_.-]+$/;
+function normalizePath(p) {
+  const stack = [];
+  for (const seg of p.split("/")) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") stack.pop();
+    else stack.push(seg);
+  }
+  return "/" + stack.join("/");
+}
+function local(dir) {
+  const d = normalizePath(dir);
+  return { kind: "local", dir: d, source: `file:${d}` };
+}
+function cleanRepoName(r) {
+  return r.length > 4 && r.endsWith(".git") ? r.slice(0, r.length - 4) : r;
+}
+function github(owner, repo, arg) {
+  const r = cleanRepoName(repo);
+  if (!NAME_PART.test(owner) || !NAME_PART.test(r)) throw unsupported(arg, "owner / repo contain unsupported characters");
+  return { kind: "github", owner, repo: r, source: `github:${owner}/${r}` };
+}
+function parseHttp(s, allowHttp, arg) {
+  let u;
+  try {
+    u = new URL(s);
+  } catch {
+    throw unsupported(arg, "not a URL");
+  }
+  if (u.protocol !== "https:" && !(allowHttp && u.protocol === "http:")) throw unsupported(arg, "https is required");
+  return { host: u.host, protocol: u.protocol, segs: u.pathname.split("/").filter((x) => x !== "") };
+}
+function gitea(s, allowHttp, verified, arg) {
+  const { host, protocol, segs } = parseHttp(s, allowHttp, arg);
+  if (segs.length < 2) throw unsupported(arg, "expected <base-url>/<owner>/<repo>");
+  const owner = segs[segs.length - 2];
+  const repo = cleanRepoName(segs[segs.length - 1]);
+  if (!NAME_PART.test(owner) || !NAME_PART.test(repo)) throw unsupported(arg, "owner / repo contain unsupported characters");
+  const prefix = segs.length > 2 ? `/${segs.slice(0, segs.length - 2).join("/")}` : "";
+  const base = `${protocol}//${host}${prefix}`;
+  return { kind: "gitea", base, owner, repo, source: `gitea:${base}/${owner}/${repo}`, verified };
+}
+function parseRepoArg(arg, cwd) {
+  const s = arg.trim();
+  if (s === "") throw unsupported(arg, "empty");
+  if (s.startsWith("file://")) {
+    const p = s.slice(7);
+    if (!p.startsWith("/")) throw unsupported(arg, "file:// needs an absolute path (file:///abs/path)");
+    let dir;
+    try {
+      dir = decodeURIComponent(p);
+    } catch {
+      throw unsupported(arg, "bad escape in file URL");
+    }
+    return local(dir);
+  }
+  if (s.startsWith("/")) return local(s);
+  if (s === "." || s === ".." || s.startsWith("./") || s.startsWith("../")) return local(`${cwd}/${s}`);
+  if (s.startsWith("github:")) {
+    const parts2 = s.slice(7).split("/");
+    if (parts2.length !== 2) throw unsupported(arg, "expected github:<owner>/<repo>");
+    return github(parts2[0], parts2[1], arg);
+  }
+  if (s.startsWith("gitea:")) return gitea(s.slice(6), true, true, arg);
+  if (s.startsWith("https://") || s.startsWith("http://")) {
+    const { host, segs } = parseHttp(s, false, arg);
+    if (host === "github.com" || host === "www.github.com") {
+      if (segs.length !== 2) throw unsupported(arg, "expected https://github.com/<owner>/<repo>");
+      return github(segs[0], segs[1], arg);
+    }
+    return gitea(s, false, false, arg);
+  }
+  const parts = s.split("/");
+  if (parts.length === 2 && NAME_PART.test(parts[0]) && NAME_PART.test(parts[1])) return github(parts[0], parts[1], arg);
+  throw unsupported(arg);
+}
+function apiBase(r) {
+  return r.kind === "github" ? "https://api.github.com" : `${r.base}/api/v1`;
+}
+async function fetchText(fetcher, url) {
+  try {
+    return await fetcher(url);
+  } catch (e) {
+    throw protocolError("REPO_UNREACHABLE", `${url}: ${errorMessage$1(e)}`);
+  }
+}
+function httpFail(url, status) {
+  let hint = "";
+  if (status === 401 || status === 403 || status === 404) {
+    hint = ` (repository not found or private; private repositories are not supported${status === 403 ? ", or the API rate limit is reached" : ""})`;
+  }
+  return protocolError("REPO_UNREACHABLE", `${url} returned HTTP ${status}${hint}`);
+}
+async function getJson(fetcher, url) {
+  const r = await fetchText(fetcher, url);
+  if (r.status < 200 || r.status >= 300) throw httpFail(url, r.status);
+  try {
+    return JSON.parse(r.text);
+  } catch {
+    throw protocolError("REPO_UNREACHABLE", `${url} did not return JSON`);
+  }
+}
+async function verifyGitea(r, arg, fetcher) {
+  const url = `${r.base}/api/v1/version`;
+  let res;
+  try {
+    res = await fetcher(url);
+  } catch (e) {
+    throw unsupported(arg, `${url} is not reachable: ${errorMessage$1(e)}`);
+  }
+  let ok = false;
+  if (res.status === 200) {
+    try {
+      const v = JSON.parse(res.text);
+      ok = typeof v === "object" && v !== null && typeof v.version === "string";
+    } catch {
+      ok = false;
+    }
+  }
+  if (!ok) throw unsupported(arg, `${url} does not answer like Gitea (HTTP ${res.status}); use github:/gitea: or a local path`);
+}
+const MAX_TAG_PAGES = 20;
+async function listTags(r, fetcher) {
+  const names = [];
+  let prevFirst = "";
+  for (let page = 1; page <= MAX_TAG_PAGES; page++) {
+    const q = r.kind === "github" ? `per_page=100&page=${page}` : `limit=50&page=${page}`;
+    const arr = await getJson(fetcher, `${apiBase(r)}/repos/${r.owner}/${r.repo}/tags?${q}`);
+    if (!Array.isArray(arr) || arr.length === 0) break;
+    const first = String(arr[0]?.name ?? "");
+    if (first === prevFirst) break;
+    prevFirst = first;
+    for (const t of arr) {
+      const n = t?.name;
+      if (typeof n === "string") names.push(n);
+    }
+    if (r.kind === "github" && arr.length < 100) break;
+  }
+  return names;
+}
+async function headSha(r, fetcher) {
+  const api = apiBase(r);
+  const info = await getJson(fetcher, `${api}/repos/${r.owner}/${r.repo}`);
+  const branch = info?.default_branch;
+  if (typeof branch !== "string" || branch === "") {
+    throw protocolError("REPO_UNREACHABLE", `${r.source}: the repository info has no default_branch`);
+  }
+  const commit = await getJson(fetcher, `${api}/repos/${r.owner}/${r.repo}/commits/${encodeURIComponent(branch)}`);
+  const sha = commit?.sha;
+  if (typeof sha !== "string" || !/^[0-9a-f]{7,64}$/.test(sha)) {
+    throw protocolError("REPO_UNREACHABLE", `${r.source}: no commit sha for branch ${branch}`);
+  }
+  return sha;
+}
+function rawUrl(r, ref, file) {
+  if (r.kind === "github") return `https://raw.githubusercontent.com/${r.owner}/${r.repo}/${encodeURIComponent(ref)}/${file}`;
+  return `${r.base}/api/v1/repos/${r.owner}/${r.repo}/raw/${file}?ref=${encodeURIComponent(ref)}`;
+}
+async function fetchFile(r, ref, file, fetcher) {
+  const url = rawUrl(r, ref, file);
+  const res = await fetchText(fetcher, url);
+  if (res.status === 404) return null;
+  if (res.status < 200 || res.status >= 300) throw httpFail(url, res.status);
+  return res.text;
+}
+const RAW_MAX_CHARS = 1024 * 1024;
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function invalid(detail) {
+  return protocolError("INVALID_DEFINITION", detail);
+}
+function buildLoaded(manifestText, doc, source, ref, ver) {
+  if (manifestText.length > RAW_MAX_CHARS) {
+    throw protocolError("TOO_LARGE", `protocol.json is over ${RAW_MAX_CHARS} characters (limit ${PROTOCOL_MANIFEST_MAX_BYTES} bytes)`);
+  }
+  if (doc.length > RAW_MAX_CHARS) {
+    throw protocolError("TOO_LARGE", `PROTOCOL.md is over ${RAW_MAX_CHARS} characters (limit ${PROTOCOL_DOC_MAX_BYTES} bytes)`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(manifestText);
+  } catch (e) {
+    throw invalid(`protocol.json is not valid JSON (${errorMessage$1(e)})`);
+  }
+  if (!isPlainObject(parsed)) throw invalid("protocol.json must be a JSON object");
+  const manifest = parsed;
+  const name = manifest.name;
+  if (typeof name !== "string" || !PROTOCOL_NAME_PATTERN.test(name)) {
+    throw invalid(`protocol.json "name" is missing or does not match ${String(PROTOCOL_NAME_PATTERN)}`);
+  }
+  if (typeof manifest.description !== "string") throw invalid('protocol.json "description" is missing (a string is required)');
+  if (manifest.messages !== void 0) {
+    if (!isPlainObject(manifest.messages)) throw invalid('protocol.json "messages" must be an object');
+    for (const k of Object.keys(manifest.messages)) {
+      if (!isPlainObject(manifest.messages[k])) throw invalid(`protocol.json messages.${k} must be an object (JSON Schema)`);
+    }
+  }
+  let version;
+  if (ver.mode === "tagless") {
+    version = ver.version;
+  } else {
+    const mv = manifest.version;
+    if (typeof mv !== "string" || parseSemver(mv) === null) {
+      throw invalid('protocol.json "version" is missing or not a semver (e.g. 1.2.0)');
+    }
+    if (ver.mode === "tag") {
+      if (mv !== ver.version) throw protocolError("VERSION_MISMATCH", `protocol.json version is ${mv} but the tag is ${ver.version}`);
+      version = ver.version;
+    } else {
+      if (ver.requested !== void 0 && normalizeVersion(ver.requested) !== mv) {
+        throw protocolError("VERSION_MISMATCH", `version ${ver.requested} was requested but protocol.json (local path) says ${mv}`);
+      }
+      version = mv;
+    }
+  }
+  const manifestBytes = Buffer.byteLength(JSON.stringify(manifest));
+  const docBytes = Buffer.byteLength(doc);
+  if (manifestBytes > PROTOCOL_MANIFEST_MAX_BYTES) {
+    throw protocolError("TOO_LARGE", `protocol.json is ${manifestBytes} bytes (limit ${PROTOCOL_MANIFEST_MAX_BYTES})`);
+  }
+  if (docBytes > PROTOCOL_DOC_MAX_BYTES) {
+    throw protocolError("TOO_LARGE", `PROTOCOL.md is ${docBytes} bytes (limit ${PROTOCOL_DOC_MAX_BYTES})`);
+  }
+  if (manifestBytes + docBytes > PROTOCOL_TOTAL_MAX_BYTES) {
+    throw protocolError("TOO_LARGE", `the definition is ${manifestBytes + docBytes} bytes (limit ${PROTOCOL_TOTAL_MAX_BYTES})`);
+  }
+  return { name, version, hash: protocolHash(manifest, doc), definition: { manifest, doc, source, ref } };
+}
+function loadLocal(r, requested) {
+  let isDir = false;
+  try {
+    isDir = existsSync(r.dir) && statSync(r.dir).isDirectory();
+  } catch {
+    isDir = false;
+  }
+  if (!isDir) throw protocolError("REPO_UNREACHABLE", `${r.dir} is not a directory`);
+  const manifestPath = join(r.dir, "protocol.json");
+  if (!existsSync(manifestPath)) throw invalid(`protocol.json not found in ${r.dir}`);
+  const manifestText = readFileSync(manifestPath, "utf8");
+  const docPath = join(r.dir, "PROTOCOL.md");
+  const doc = existsSync(docPath) ? readFileSync(docPath, "utf8") : "";
+  return buildLoaded(manifestText, doc, r.source, "local", { mode: "local", requested });
+}
+async function loadRemote(r, requested, fetcher) {
+  const tags = [];
+  for (const name of await listTags(r, fetcher)) {
+    const version = normalizeVersion(name);
+    const sv = parseSemver(version);
+    if (sv !== null) tags.push({ name, version, sv });
+  }
+  const newestFirst = tags.slice().sort((a, b) => compareSemver(b.sv, a.sv));
+  let ref;
+  let ver;
+  if (requested === void 0) {
+    const stable = newestFirst.find((t) => t.sv.pre.length === 0);
+    if (stable !== void 0) {
+      ref = stable.name;
+      ver = { mode: "tag", version: stable.version };
+    } else {
+      const sha = await headSha(r, fetcher);
+      ref = sha;
+      ver = { mode: "tagless", version: `0.0.0+${sha.slice(0, 7)}` };
+    }
+  } else {
+    const want = normalizeVersion(requested);
+    const hit = tags.find((t) => t.version === want);
+    if (hit === void 0) {
+      const cand = newestFirst.slice(0, 5).map((t) => t.name);
+      throw protocolError(
+        "VERSION_NOT_FOUND",
+        `version "${requested}" has no tag in ${r.source}. ${cand.length > 0 ? `Candidates: ${cand.join(", ")}` : "The repository has no semver tags."}`
+      );
+    }
+    ref = hit.name;
+    ver = { mode: "tag", version: hit.version };
+  }
+  const manifestText = await fetchFile(r, ref, "protocol.json", fetcher);
+  if (manifestText === null) throw invalid(`protocol.json not found in ${r.source} at ${ref}`);
+  const doc = await fetchFile(r, ref, "PROTOCOL.md", fetcher) ?? "";
+  return buildLoaded(manifestText, doc, r.source, ref, ver);
+}
+async function loadProtocol(repoArg, requested, cwd, fetcher) {
+  const req = requested === void 0 || requested.trim() === "" ? void 0 : requested.trim();
+  const ref = parseRepoArg(repoArg, cwd);
+  if (ref.kind === "local") return loadLocal(ref, req);
+  if (ref.kind === "gitea" && !ref.verified) await verifyGitea(ref, repoArg, fetcher);
+  return loadRemote(ref, req, fetcher);
+}
+
+function createProtocolState(fetcher = defaultFetcher) {
+  return { declared: [], seen: [], fetcher, reregister: null };
+}
+const SEEN_MAX = 100;
+function requireId(env) {
+  if (!env.peer.id) throw new Error("Not registered with broker yet");
+  return env.peer.id;
+}
+async function brokerUnsupported(env, what) {
+  let version = "unknown";
+  try {
+    if (typeof env.broker.health === "function") {
+      const h = await env.broker.health();
+      if (h) version = h.version;
+    }
+  } catch {
+  }
+  return protocolError("BROKER_UNSUPPORTED", `the broker (version ${version}) does not support ${what}; use a broker of 0.10.0 or later`);
+}
+async function postRoute(env, path, body) {
+  try {
+    return await env.broker.post(path, body);
+  } catch (e) {
+    if (errorMessage$1(e).startsWith(`Broker error (${path}): 404`)) throw await brokerUnsupported(env, "protocols");
+    throw e;
+  }
+}
+function responseError(r) {
+  if (typeof r.code === "string") {
+    return protocolError(r.code, r.error);
+  }
+  return new Error(`Failed: ${r.error}`);
+}
+function isUnknownPeer(r) {
+  return r.code === void 0 && r.error.startsWith("unknown peer");
+}
+function declareLocally(state, d) {
+  const i = state.declared.findIndex((x) => x.decl.name === d.decl.name);
+  if (i === -1) state.declared.push(d);
+  else state.declared[i] = d;
+}
+async function setProtocol(env, repo, version) {
+  requireId(env);
+  const loaded = await loadProtocol(repo, version, env.peer.cwd, env.protocols.fetcher);
+  const body = () => ({
+    id: env.peer.id,
+    name: loaded.name,
+    version: loaded.version,
+    hash: loaded.hash,
+    definition: loaded.definition
+  });
+  let r = await postRoute(env, "/set-protocol", body());
+  if (!r.ok && isUnknownPeer(r) && env.protocols.reregister) {
+    await env.protocols.reregister();
+    requireId(env);
+    r = await postRoute(env, "/set-protocol", body());
+  }
+  if (!r.ok) throw responseError(r);
+  declareLocally(env.protocols, {
+    decl: { name: loaded.name, version: loaded.version, hash: loaded.hash },
+    definition: loaded.definition
+  });
+  return {
+    name: loaded.name,
+    version: loaded.version,
+    hash: loaded.hash,
+    source: loaded.definition.source,
+    ref: loaded.definition.ref
+  };
+}
+async function unsetProtocol(env, name) {
+  requireId(env);
+  const body = () => name === void 0 ? { id: env.peer.id } : { id: env.peer.id, name };
+  let r = await postRoute(env, "/unset-protocol", body());
+  if (!r.ok && isUnknownPeer(r) && env.protocols.reregister) {
+    await env.protocols.reregister();
+    requireId(env);
+    r = await postRoute(env, "/unset-protocol", body());
+  }
+  if (!r.ok) throw responseError(r);
+  const st = env.protocols;
+  st.declared = name === void 0 ? [] : st.declared.filter((d) => d.decl.name !== name);
+  return r.removed;
+}
+async function getProtocol(env, name, version) {
+  const v = version === void 0 || version.trim() === "" ? void 0 : normalizeVersion(version);
+  const r = await postRoute(env, "/get-protocol", v === void 0 ? { name } : { name, version: v });
+  if (!r.ok) throw responseError(r);
+  const p = r.protocol;
+  return {
+    name: p.name,
+    version: p.version,
+    hash: p.hash,
+    servers: r.servers,
+    manifest: p.definition.manifest,
+    doc: p.definition.doc,
+    source: p.definition.source,
+    ref: p.definition.ref
+  };
+}
+async function listPeers(env, scope, filter) {
+  const body = {
+    scope,
+    cwd: env.peer.cwd,
+    git_root: env.peer.gitRoot,
+    hostname: env.peer.hostname,
+    exclude_id: env.peer.id ?? void 0
+  };
+  const protocol = filter?.protocol === void 0 || filter.protocol === "" ? void 0 : filter.protocol;
+  if (protocol !== void 0) {
+    body.protocol = protocol;
+    if (filter?.version !== void 0 && filter.version.trim() !== "") body.version = normalizeVersion(filter.version);
+  }
+  const peers = await env.broker.post("/list-peers", body);
+  if (protocol !== void 0 && peers.some((p) => !Array.isArray(p.protocols))) {
+    throw await brokerUnsupported(env, "the protocol filter of list_peers");
+  }
+  return peers;
+}
+function parseMeta(raw) {
+  if (raw === void 0) return void 0;
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw protocolError("INVALID_META", "meta must be an object {protocol, version}");
+  }
+  const m = raw;
+  if (typeof m.protocol !== "string" || m.protocol === "" || typeof m.version !== "string" || m.version === "") {
+    throw protocolError("INVALID_META", "meta needs both protocol and version (non-empty strings)");
+  }
+  if (m.protocol.length > PROTOCOL_META_MAX_LENGTH || m.version.length > PROTOCOL_META_MAX_LENGTH) {
+    throw protocolError("INVALID_META", `meta.protocol and meta.version are at most ${PROTOCOL_META_MAX_LENGTH} characters`);
+  }
+  return { protocol: m.protocol, version: m.version };
+}
+function planOutgoing(state, to, text, meta) {
+  for (let i = state.seen.length - 1; i >= 0; i--) {
+    const s = state.seen[i];
+    if (s.peerId !== to && (s.peerName === "" || s.peerName !== to)) continue;
+    const mine = state.declared.find((d) => d.decl.name === s.meta.protocol);
+    if (mine === void 0) break;
+    if (normalizeVersion(s.meta.version) === mine.decl.version) break;
+    if (meta !== void 0 && meta.protocol !== s.meta.protocol) break;
+    const warning = `[agent-messenger warning] protocol version mismatch: you sent ${s.meta.protocol}@${s.meta.version}, this server serves ${s.meta.protocol}@${mine.decl.version}`;
+    return { text: `${warning}
+${text}`, meta: { protocol: s.meta.protocol, version: mine.decl.version }, warning };
+  }
+  return meta === void 0 ? { text } : { text, meta };
+}
+function recordSeen(state, peerId, peerName, meta) {
+  const i = state.seen.findIndex((s) => s.peerId === peerId);
+  if (i !== -1) state.seen.splice(i, 1);
+  state.seen.push({ peerId, peerName, meta });
+  while (state.seen.length > SEEN_MAX) state.seen.shift();
+}
+function describeMeta(state, meta) {
+  const base = `Protocol: ${meta.protocol}@${meta.version}`;
+  const mine = state.declared.find((d) => d.decl.name === meta.protocol);
+  if (mine === void 0) return `${base} (not served here)`;
+  if (normalizeVersion(meta.version) === mine.decl.version) return base;
+  return `${base} (this server: ${mine.decl.version}, mismatch)`;
+}
+function wireDecls(state) {
+  if (state.declared.length === 0) return void 0;
+  return state.declared.map((d) => ({ name: d.decl.name, version: d.decl.version, hash: d.decl.hash }));
+}
+async function resendDefinitions(env, log, keys) {
+  const id = env.peer.id;
+  if (!id) return;
+  for (const d of env.protocols.declared.slice()) {
+    const key = `${d.decl.name}@${d.decl.version}`;
+    if (keys !== void 0 && !keys.includes(key)) continue;
+    try {
+      const r = await postRoute(env, "/set-protocol", {
+        id,
+        name: d.decl.name,
+        version: d.decl.version,
+        hash: d.decl.hash,
+        definition: d.definition
+      });
+      if (r.ok) log(`Protocol ${key} re-sent to the broker`);
+      else log(`Protocol ${key} re-send rejected: ${r.error}`);
+    } catch (e) {
+      log(`Protocol ${key} re-send failed: ${errorMessage$1(e)}`);
+    }
+  }
+}
+
+const VERSION = "0.10.0";
+
+const INSTRUCTIONS = `agent-messenger v${VERSION}
+
+You are connected to agent-messenger. Other Claude Code sessions on this machine AND on remote hosts can find you and send you messages.
+
+Inbound traffic arrives in the conversation as one of:
+- "[agent-messenger] \u672A\u8AAD N \u4EF6\uFF08from <name>@<host>\uFF09\u2026" \u2014 an unread notice. Call check_messages to read the text, reply with send_message if needed, then resume your work.
+- "[agent-messenger] ping\uFF08from <name>@<host>\uFF09" or "\u2026\uFF09: <subject>" \u2014 the sender is alive and working (subject = what it is working on, if given). Nothing to read, no reply needed.
+- "[agent-messenger] message from <name>@<host>" followed by the text \u2014 sent with delivery "push". Reply with send_message if needed, then resume your work.
+
+Tools:
+- list_peers: discover sessions (scope: all / host / directory / repo)
+- send_message: send to a peer by name or id (cross-host). delivery "pull" (default) = the receiver sees only an unread notice; "push" = the text is shown directly
+- send_ping: send a liveness signal, optionally with a one-line subject such as the task id (e.g. periodically while working, so the orchestrator can tell progress from a stall)
+- set_name: give this session a stable name (e.g. "master-cap", "agent-messenger") so others can address it by name
+- set_summary: describe what you are working on (visible in list_peers)
+- check_messages: read unread message texts. Notices are delivered into the conversation automatically (via the session inbox socket, or via channel push when Claude Code was started with --dangerously-load-development-channels server:agent-messenger); call check_messages any time to read.
+- set_protocol: declare that this session serves a protocol (a public GitHub / Gitea repo or a local path holding protocol.json and PROTOCOL.md), so peers can find it with list_peers(protocol)
+- unset_protocol: stop serving a protocol (all of them when no name is given)
+- get_protocol: read a protocol definition held by the broker (protocol.json and PROTOCOL.md) to speak it
+- list_peers(protocol, version): only the sessions that serve that protocol (and version)
+- send_message(meta): meta = {protocol, version} tags the message with the protocol it follows; the receiver is warned when its served version differs
+
+On start, call set_name (if not already named) and set_summary.`;
+function text$1(t, isError = false) {
+  return isError ? { content: [{ type: "text", text: t }], isError: true } : { content: [{ type: "text", text: t }] };
+}
+async function guarded(fn) {
+  try {
+    return await fn();
+  } catch (e) {
+    if (protocolErrorCode(e) !== null) return text$1(errorMessage$1(e), true);
+    throw e;
+  }
+}
+function formatPeer(p) {
+  const parts = [`ID: ${p.id}`];
+  if (p.name) parts.push(`Name: ${p.name}`);
+  parts.push(`Host: ${p.hostname}`, `PID: ${p.pid}`, `CWD: ${p.cwd}`);
+  if (p.git_root) parts.push(`Repo: ${p.git_root}`);
+  if (p.tty) parts.push(`TTY: ${p.tty}`);
+  if (p.summary) parts.push(`Summary: ${p.summary}`);
+  for (const d of p.protocols ?? []) parts.push(`Protocol: ${d.name}@${d.version}`);
+  parts.push(`Last seen: ${p.last_seen}`);
+  return parts.join("\n  ");
+}
+function formatMessage(m) {
+  const who = m.from_name ? `${m.from_name} (${m.from_id})` : m.from_id;
+  const host = m.from_hostname ? `@${m.from_hostname}` : "";
+  return `From ${who}${host} at ${m.sent_at}:
+${m.protocol_line ? `${m.protocol_line}
+` : ""}${m.text}`;
+}
+const TOOL_DEFS = [
+  {
+    name: "list_peers",
+    description: "List other Claude Code sessions connected to the broker (id, name, hostname, cwd, repo, summary).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        scope: {
+          type: "string",
+          enum: ["all", "host", "directory", "repo"],
+          description: '"all" = every host (default). "host" = same hostname. "directory" = same cwd. "repo" = same git repository.'
+        },
+        protocol: {
+          type: "string",
+          description: "Only sessions that serve this protocol (set_protocol). Combines with scope."
+        },
+        version: {
+          type: "string",
+          description: "Only with protocol: only sessions that serve exactly this version (a leading v is ignored)."
+        }
+      }
+    },
+    requiresRegistration: false,
+    handler(args, ctx) {
+      return guarded(async () => {
+        const scope = typeof args.scope === "string" ? args.scope : "all";
+        const protocol = args.protocol === void 0 || args.protocol === "" ? void 0 : String(args.protocol);
+        const version = protocol === void 0 || args.version === void 0 || args.version === "" ? void 0 : normalizeVersion(String(args.version));
+        const peers = await listPeers(ctx, scope, { protocol, version });
+        if (protocol !== void 0) {
+          if (peers.length === 0) return text$1(`No server for protocol "${protocol}" (version: ${version ?? "any"}).`);
+          return text$1(
+            `Found ${peers.length} peer(s) (scope: ${scope}, protocol: ${protocol}, version: ${version ?? "any"}):
+
+${peers.map(formatPeer).join("\n\n")}`
+          );
+        }
+        if (peers.length === 0) return text$1(`No other sessions found (scope: ${scope}).`);
+        return text$1(`Found ${peers.length} peer(s) (scope: ${scope}):
+
+${peers.map(formatPeer).join("\n\n")}`);
+      });
+    }
+  },
+  {
+    name: "send_message",
+    description: "Send a message to another Claude Code session by peer name or id (from list_peers). Works across hosts.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        to: { type: "string", description: "Target peer name or id" },
+        message: { type: "string", description: "Message text" },
+        delivery: {
+          type: "string",
+          enum: ["pull", "push"],
+          description: `"pull" (default) = the receiver sees only an unread notice (sender shown) and reads the text with check_messages. "push" = the text is shown in the receiver's conversation directly.`
+        },
+        meta: {
+          type: "object",
+          description: "Optional protocol tag of this message: which protocol (see get_protocol) and version it follows. Both fields are required when meta is given.",
+          properties: {
+            protocol: { type: "string", description: "Protocol name" },
+            version: { type: "string", description: "Protocol version" }
+          },
+          required: ["protocol", "version"]
+        }
+      },
+      required: ["to", "message"]
+    },
+    requiresRegistration: true,
+    handler(args, ctx) {
+      return guarded(async () => {
+        const delivery = args.delivery === void 0 ? "pull" : String(args.delivery);
+        if (delivery !== "pull" && delivery !== "push") return text$1(`Invalid delivery: ${delivery} (use "pull" or "push")`, true);
+        const meta = parseMeta(args.meta);
+        const to = String(args.to);
+        const plan = planOutgoing(ctx.protocols, to, String(args.message), meta);
+        const r = await ctx.broker.post("/send-message", {
+          from_id: ctx.peer.id ?? void 0,
+          from_name: ctx.peer.name,
+          to,
+          text: plan.text,
+          mode: delivery,
+          ...plan.meta === void 0 ? {} : { meta: plan.meta }
+        });
+        if (!r.ok) return text$1(`Failed to send: ${r.error}`, true);
+        const label = r.to_name ? `${r.to_name} (${r.to_id})` : r.to_id;
+        return text$1(`Message sent to ${label} (delivery: ${delivery}).${plan.warning ? `
+${plan.warning}` : ""}`);
+      });
+    }
+  },
+  {
+    name: "send_ping",
+    description: "Send a liveness signal to a peer, optionally with a one-line subject (e.g. the task id or name being worked on). The receiver sees a one-line ping notice (sender and subject shown), nothing to read or reply to. Use it periodically during long work so the orchestrator can tell progress from a stall.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        to: { type: "string", description: "Target peer name or id" },
+        subject: {
+          type: "string",
+          description: "Optional one-line subject, e.g. the task id or name being worked on. Delivered as the message text."
+        }
+      },
+      required: ["to"]
+    },
+    requiresRegistration: true,
+    async handler(args, ctx) {
+      const r = await ctx.broker.post("/send-message", {
+        from_id: ctx.peer.id ?? void 0,
+        from_name: ctx.peer.name,
+        to: String(args.to),
+        text: args.subject === void 0 ? "" : String(args.subject),
+        mode: "ping"
+      });
+      if (!r.ok) return text$1(`Failed to send: ${r.error}`, true);
+      const label = r.to_name ? `${r.to_name} (${r.to_id})` : r.to_id;
+      return text$1(`Ping sent to ${label}.`);
+    }
+  },
+  {
+    name: "set_name",
+    description: "Set a stable name for this session so other peers can address it by name.",
+    inputSchema: {
+      type: "object",
+      properties: { name: { type: "string", description: "Name, e.g. the session name" } },
+      required: ["name"]
+    },
+    requiresRegistration: true,
+    async handler(args, ctx) {
+      const newName = String(args.name);
+      const r = await ctx.broker.post("/set-name", { id: ctx.peer.id, name: newName });
+      if (!r.ok) return text$1(`Failed: ${r.error}`, true);
+      ctx.peer.name = newName;
+      return text$1(`Name set: "${newName}"`);
+    }
+  },
+  {
+    name: "set_summary",
+    description: "Set a 1-2 sentence summary of what this session is working on (visible in list_peers).",
+    inputSchema: {
+      type: "object",
+      properties: { summary: { type: "string" } },
+      required: ["summary"]
+    },
+    requiresRegistration: true,
+    async handler(args, ctx) {
+      const summary = String(args.summary);
+      const r = await ctx.broker.post("/set-summary", { id: ctx.peer.id, summary });
+      if (!r.ok) return text$1(`Failed: ${r.error}`, true);
+      ctx.peer.summary = summary;
+      return text$1(`Summary updated: "${summary}"`);
+    }
+  },
+  {
+    name: "check_messages",
+    description: "Read and acknowledge unread messages from other sessions (the text behind an unread notice). Safe to call any time.",
+    inputSchema: { type: "object", properties: {} },
+    requiresRegistration: true,
+    async handler(_args, ctx) {
+      const list = await ctx.inbox.checkMessages();
+      if (list.length === 0) return text$1("No new messages.");
+      return text$1(`${list.length} message(s):
+
+${list.map(formatMessage).join("\n\n---\n\n")}`);
+    }
+  },
+  {
+    name: "set_protocol",
+    description: "Declare that this session serves a protocol: read protocol.json (and PROTOCOL.md) from a protocol repo, register the definition at the broker, and become findable with list_peers(protocol). Declaring a name again replaces its version. Public GitHub / Gitea repos and local paths only.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: {
+          type: "string",
+          description: "Protocol repo: https://github.com/<owner>/<repo>, <owner>/<repo>, github:<owner>/<repo>, gitea:<base-url>/<owner>/<repo>, https://<gitea-host>/<owner>/<repo>, or a local path (/abs/path, ./rel/path, file:///abs/path)."
+        },
+        version: {
+          type: "string",
+          description: 'Tag to use, e.g. "1.2.0" or "v1.2.0". Default: the latest release tag (or the default branch head for a repo without tags). Ignored for local paths except as a check.'
+        }
+      },
+      required: ["repo"]
+    },
+    requiresRegistration: true,
+    handler(args, ctx) {
+      return guarded(async () => {
+        const info = await setProtocol(ctx, String(args.repo), args.version === void 0 ? void 0 : String(args.version));
+        return text$1(`Protocol set: ${info.name}@${info.version} (sha256 ${info.hash.slice(0, 8)}\u2026, from ${info.source})`);
+      });
+    }
+  },
+  {
+    name: "unset_protocol",
+    description: "Stop serving a protocol declared with set_protocol. Without a name, all protocols of this session are unset.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Protocol name to unset (default: all)" }
+      }
+    },
+    requiresRegistration: true,
+    handler(args, ctx) {
+      return guarded(async () => {
+        const name = args.name === void 0 ? void 0 : String(args.name);
+        const removed = await unsetProtocol(ctx, name);
+        if (removed === 0) return text$1("No protocol set.");
+        return text$1(name === void 0 ? `Protocol unset: (all, ${removed})` : `Protocol unset: ${name}`);
+      });
+    }
+  },
+  {
+    name: "get_protocol",
+    description: "Show the definition of a protocol held by the broker (protocol.json and PROTOCOL.md) so you can speak it. Latest version when version is omitted.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Protocol name (see list_peers)" },
+        version: { type: "string", description: 'Version, e.g. "1.2.0" or "v1.2.0". Default: the latest the broker holds.' }
+      },
+      required: ["name"]
+    },
+    requiresRegistration: false,
+    handler(args, ctx) {
+      return guarded(async () => {
+        const p = await getProtocol(
+          ctx,
+          String(args.name),
+          args.version === void 0 ? void 0 : String(args.version)
+        );
+        const description = p.manifest.description;
+        const lines = [
+          `${p.name}@${p.version} (sha256 ${p.hash.slice(0, 8)}\u2026, servers: ${p.servers})`,
+          `Description: ${typeof description === "string" ? description : ""}`,
+          "",
+          "protocol.json:",
+          JSON.stringify(p.manifest, null, 2),
+          "",
+          "PROTOCOL.md:",
+          p.doc === "" ? "(none)" : p.doc
+        ];
+        return text$1(lines.join("\n"));
+      });
+    }
+  }
+];
+
+function text(t, isError = false) {
+  return isError ? { content: [{ type: "text", text: t }], isError: true } : { content: [{ type: "text", text: t }] };
+}
+function errorMessage(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+function toolDescriptors(defs = TOOL_DEFS) {
+  return defs.map((d) => ({
+    name: d.name,
+    description: `[agent-messenger v${VERSION}] ${d.description}`,
+    inputSchema: d.inputSchema,
+    annotations: { title: `${d.name} (v${VERSION})` }
+  }));
+}
+const TOOLS = toolDescriptors();
+function createToolRegistry(input, defs = TOOL_DEFS) {
+  const ctx = { ...input, protocols: input.protocols ?? createProtocolState() };
+  return {
+    list: () => toolDescriptors(defs),
+    async call(name, args) {
+      const def = defs.find((d) => d.name === name);
+      if (!ctx.peer.id && (def === void 0 || def.requiresRegistration)) return text("Not registered with broker yet", true);
+      if (def === void 0) return text(`Unknown tool: ${name}`, true);
+      try {
+        return await def.handler(args ?? {}, ctx);
+      } catch (e) {
+        return text(`Error (${name}): ${errorMessage(e)}`, true);
+      }
+    }
+  };
+}
+
+export { parseMeta as A, BROKER_CMD_ENV as B, createProtocolState as C, DEFAULT_BROKER_CMD as D, ENV as E, FALLBACK_ENV as F, GRACE_MS_ENV as G, HEALTH_ROUTE as H, INSTRUCTIONS as I, planOutgoing as J, wireDecls as K, LOCAL_HOSTS as L, resendDefinitions as M, POLL_INTERVAL_MS as P, RESOLVE_RETRY_MS as R, SESSION_SOCKET_ENV as S, TOOLS as T, VERSION as V, DEFAULT_DISCOVERY_PORT as a, DEFAULT_DISCOVERY_TIMEOUT_MS as b, DEFAULT_GRACE_MS as c, DEFAULT_HTTP_PORT as d, DISCOVERY_BROADCAST_ADDR as e, DISCOVERY_KEY as f, DISCOVERY_PROBE_VALUE as g, DISCOVERY_REPLY_VALUE as h, HEARTBEAT_INTERVAL_MS as i, PROTOCOL_DOC_MAX_BYTES as j, PROTOCOL_MANIFEST_MAX_BYTES as k, PROTOCOL_META_MAX_LENGTH as l, PROTOCOL_NAME_PATTERN as m, PROTOCOL_TOTAL_MAX_BYTES as n, SESSION_TOKEN_ENV as o, TOOL_DEFS as p, createToolRegistry as q, formatMessage as r, formatPeer as s, toolDescriptors as t, recordSeen as u, describeMeta as v, getProtocol as w, unsetProtocol as x, setProtocol as y, listPeers as z };