@zooid/transport-matrix 0.7.0

package/dist/index.js

@@ -0,0 +1,1076 @@
+// src/matrix-client.ts
+import { randomUUID } from "crypto";
+var MatrixClient = class {
+  homeserver;
+  asToken;
+  fetch;
+  constructor(opts) {
+    this.homeserver = opts.homeserver.replace(/\/$/, "");
+    this.asToken = opts.asToken;
+    this.fetch = opts.fetch ?? globalThis.fetch;
+  }
+  async registerBot(localpart2) {
+    const r = await this.fetch(`${this.homeserver}/_matrix/client/v3/register`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${this.asToken}` },
+      body: JSON.stringify({ type: "m.login.application_service", username: localpart2 })
+    });
+    if (r.status === 200) return await r.json();
+    if (r.status === 400) {
+      const body = await r.json();
+      if (body.errcode === "M_USER_IN_USE") return void 0;
+    }
+    throw new Error(`registerBot(${localpart2}) failed: ${r.status}`);
+  }
+  async resolveAlias(alias) {
+    const r = await this.fetch(
+      `${this.homeserver}/_matrix/client/v3/directory/room/${encodeURIComponent(alias)}`,
+      { headers: { Authorization: `Bearer ${this.asToken}` } }
+    );
+    if (r.status === 404) return null;
+    if (!r.ok) throw new Error(`resolveAlias(${alias}) failed: ${r.status}`);
+    const j = await r.json();
+    return j.room_id;
+  }
+  async createRoom(opts) {
+    const body = {
+      room_alias_name: opts.roomAliasName,
+      invite: opts.invite,
+      preset: opts.preset ?? "public_chat"
+    };
+    if (opts.name !== void 0) body.name = opts.name;
+    const r = await this.fetch(
+      `${this.homeserver}/_matrix/client/v3/createRoom?user_id=${encodeURIComponent(opts.senderUserId)}`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.asToken}`,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(body)
+      }
+    );
+    if (!r.ok) {
+      const body2 = await r.text();
+      throw new Error(`createRoom(${opts.roomAliasName}) failed: ${r.status} ${body2}`);
+    }
+    const j = await r.json();
+    return j.room_id;
+  }
+  async createRoomRaw(opts) {
+    const url = `${this.homeserver}/_matrix/client/v3/createRoom?user_id=${encodeURIComponent(opts.asUserId)}`;
+    const r = await this.fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.asToken}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(opts.body)
+    });
+    if (!r.ok) throw new Error(`createRoomRaw failed: ${r.status}`);
+    const j = await r.json();
+    return j.room_id;
+  }
+  async sendStateEvent(opts) {
+    const url = `${this.homeserver}/_matrix/client/v3/rooms/${encodeURIComponent(opts.roomId)}/state/${encodeURIComponent(opts.eventType)}/${encodeURIComponent(opts.stateKey ?? "")}?user_id=${encodeURIComponent(opts.asUserId)}`;
+    const r = await this.fetch(url, {
+      method: "PUT",
+      headers: {
+        Authorization: `Bearer ${this.asToken}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(opts.content)
+    });
+    if (!r.ok) throw new Error(`sendStateEvent ${opts.eventType} failed: ${r.status}`);
+    return await r.json();
+  }
+  async joinRoom(roomIdOrAlias, asUserId) {
+    const url = `${this.homeserver}/_matrix/client/v3/join/${encodeURIComponent(roomIdOrAlias)}?user_id=${encodeURIComponent(asUserId)}`;
+    const r = await this.fetch(url, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${this.asToken}` },
+      body: "{}"
+    });
+    if (!r.ok) throw new Error(`joinRoom(${roomIdOrAlias}) failed: ${r.status}`);
+  }
+  async sendMessage(input) {
+    const content = { ...input.content };
+    if (input.threadRoot) {
+      content["m.relates_to"] = { rel_type: "m.thread", event_id: input.threadRoot };
+    }
+    return this.sendEvent(input.roomId, input.asUserId, "m.room.message", content);
+  }
+  async sendCustomEvent(input) {
+    return this.sendEvent(input.roomId, input.asUserId, input.eventType, input.content);
+  }
+  async setTyping(input) {
+    const url = `${this.homeserver}/_matrix/client/v3/rooms/${encodeURIComponent(input.roomId)}/typing/${encodeURIComponent(input.asUserId)}?user_id=${encodeURIComponent(input.asUserId)}`;
+    const body = { typing: input.typing };
+    if (input.typing && input.timeoutMs !== void 0) body.timeout = input.timeoutMs;
+    const r = await this.fetch(url, {
+      method: "PUT",
+      headers: { Authorization: `Bearer ${this.asToken}` },
+      body: JSON.stringify(body)
+    });
+    if (!r.ok) throw new Error(`setTyping(${input.roomId}, ${input.asUserId}) failed: ${r.status}`);
+  }
+  async setDisplayName(asUserId, displayName) {
+    const url = `${this.homeserver}/_matrix/client/v3/profile/${encodeURIComponent(asUserId)}/displayname?user_id=${encodeURIComponent(asUserId)}`;
+    const r = await this.fetch(url, {
+      method: "PUT",
+      headers: {
+        Authorization: `Bearer ${this.asToken}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({ displayname: displayName })
+    });
+    if (!r.ok) throw new Error(`setDisplayName(${asUserId}) failed: ${r.status}`);
+  }
+  async setPresence(input) {
+    const url = `${this.homeserver}/_matrix/client/v3/presence/${encodeURIComponent(input.asUserId)}/status?user_id=${encodeURIComponent(input.asUserId)}`;
+    const body = { presence: input.presence };
+    if (input.statusMsg !== void 0) body.status_msg = input.statusMsg;
+    const r = await this.fetch(url, {
+      method: "PUT",
+      headers: { Authorization: `Bearer ${this.asToken}` },
+      body: JSON.stringify(body)
+    });
+    if (!r.ok) throw new Error(`setPresence(${input.asUserId}) failed: ${r.status}`);
+  }
+  /**
+   * Fetch a single event from a room. Used to recover thread-root context
+   * after a daemon restart wipes the in-memory threadStates cache.
+   */
+  async fetchEvent(roomId, eventId, asUserId) {
+    const url = `${this.homeserver}/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/event/${encodeURIComponent(eventId)}?user_id=${encodeURIComponent(asUserId)}`;
+    const r = await this.fetch(url, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${this.asToken}` }
+    });
+    if (r.status === 404) return null;
+    if (!r.ok) throw new Error(`fetchEvent(${eventId}) failed: ${r.status}`);
+    return await r.json();
+  }
+  /**
+   * Fetch replies to a thread root via the relations endpoint, oldest-first.
+   * Pass `limit` and `from` for pagination; `next_batch` echoes back when
+   * there are more replies. Returns `{ chunk: [] }` when the root is unknown.
+   */
+  async fetchThreadRelations(opts) {
+    const params = new URLSearchParams({
+      dir: "f",
+      limit: String(opts.limit ?? 100),
+      user_id: opts.asUserId
+    });
+    if (opts.from) params.set("from", opts.from);
+    const url = `${this.homeserver}/_matrix/client/v1/rooms/${encodeURIComponent(opts.roomId)}/relations/${encodeURIComponent(opts.rootEventId)}/m.thread?${params.toString()}`;
+    const r = await this.fetch(url, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${this.asToken}` }
+    });
+    if (r.status === 404) return { chunk: [] };
+    if (!r.ok) throw new Error(`fetchThreadRelations(${opts.rootEventId}) failed: ${r.status}`);
+    const body = await r.json();
+    return { chunk: body.chunk ?? [], next_batch: body.next_batch };
+  }
+  /**
+   * Paginate the room timeline. Returns events newest-first (dir=b) per Matrix
+   * spec. The caller is responsible for reversing if it wants oldest-first.
+   */
+  async fetchRoomMessages(opts) {
+    const params = new URLSearchParams({
+      dir: "b",
+      limit: String(opts.limit ?? 50),
+      user_id: opts.asUserId
+    });
+    if (opts.from) params.set("from", opts.from);
+    if (opts.filter) params.set("filter", JSON.stringify(opts.filter));
+    const url = `${this.homeserver}/_matrix/client/v3/rooms/${encodeURIComponent(opts.roomId)}/messages?${params.toString()}`;
+    const r = await this.fetch(url, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${this.asToken}` }
+    });
+    if (!r.ok) throw new Error(`fetchRoomMessages(${opts.roomId}) failed: ${r.status}`);
+    return await r.json();
+  }
+  async getJoinedMembers(roomId, asUserId) {
+    const url = `${this.homeserver}/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/joined_members?user_id=${encodeURIComponent(asUserId)}`;
+    const r = await this.fetch(url, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${this.asToken}` }
+    });
+    if (!r.ok) throw new Error(`getJoinedMembers(${roomId}) failed: ${r.status}`);
+    return await r.json();
+  }
+  async fetchRoomName(roomId, asUserId) {
+    const url = `${this.homeserver}/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/state/m.room.name/?user_id=${encodeURIComponent(asUserId)}`;
+    const r = await this.fetch(url, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${this.asToken}` }
+    });
+    if (r.status === 404) return null;
+    if (!r.ok) throw new Error(`fetchRoomName(${roomId}) failed: ${r.status}`);
+    const body = await r.json();
+    return body.name ?? null;
+  }
+  async sendEvent(roomId, asUserId, eventType, content) {
+    const txn = randomUUID();
+    const url = `${this.homeserver}/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/send/${eventType}/${txn}?user_id=${encodeURIComponent(asUserId)}`;
+    const r = await this.fetch(url, {
+      method: "PUT",
+      headers: { Authorization: `Bearer ${this.asToken}` },
+      body: JSON.stringify(content)
+    });
+    if (!r.ok) throw new Error(`sendEvent(${eventType}) failed: ${r.status}`);
+    return await r.json();
+  }
+};
+
+// src/context-provider.ts
+var MatrixContextProvider = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  async getRoomHistory(channelId, hopts) {
+    const { chunk, end } = await this.opts.client.fetchRoomMessages({
+      roomId: channelId,
+      asUserId: this.opts.asUserId,
+      limit: hopts.limit,
+      from: hopts.before,
+      filter: { types: ["m.room.message"] }
+    });
+    const messages = [];
+    for (let i = chunk.length - 1; i >= 0; i--) {
+      const ev = chunk[i];
+      const msg = this.toMessage(ev);
+      if (msg) messages.push(msg);
+    }
+    return {
+      messages,
+      next_before: end,
+      has_more: end !== void 0
+    };
+  }
+  async getRecentThreads(channelId, hopts) {
+    const { chunk, end } = await this.opts.client.fetchRoomMessages({
+      roomId: channelId,
+      asUserId: this.opts.asUserId,
+      limit: hopts.limit,
+      from: hopts.before,
+      filter: { types: ["m.room.message"], not_rel_types: ["m.thread"] }
+    });
+    const threads = [];
+    for (const ev of chunk) {
+      if (ev.type !== "m.room.message") continue;
+      if (ev.content?.msgtype !== "m.text" || typeof ev.content.body !== "string") continue;
+      const relatesTo = ev.content["m.relates_to"];
+      if (relatesTo?.rel_type === "m.thread") continue;
+      const agent = this.opts.agentBots.get(ev.sender);
+      const bundled = ev.unsigned?.["m.relations"]?.["m.thread"];
+      const replyCount = bundled?.count ?? 0;
+      const latestTs = bundled?.latest_event?.origin_server_ts ?? ev.origin_server_ts;
+      threads.push({
+        id: ev.event_id,
+        sender: ev.sender,
+        text: ev.content.body,
+        timestamp: new Date(ev.origin_server_ts).toISOString(),
+        is_agent: agent !== void 0,
+        ...agent !== void 0 ? { agent_name: agent } : {},
+        reply_count: replyCount,
+        last_activity_at: new Date(latestTs).toISOString()
+      });
+    }
+    return {
+      threads,
+      next_before: end,
+      has_more: end !== void 0
+    };
+  }
+  async getThreadHistory(channelId, threadId, hopts) {
+    const messages = [];
+    if (!hopts.before) {
+      const root = await this.opts.client.fetchEvent(
+        channelId,
+        threadId,
+        this.opts.asUserId
+      );
+      if (root) {
+        const rootMsg = this.toMessage(root);
+        if (rootMsg) messages.push({ ...rootMsg, thread_id: threadId });
+      }
+    }
+    const { chunk, next_batch } = await this.opts.client.fetchThreadRelations({
+      roomId: channelId,
+      rootEventId: threadId,
+      asUserId: this.opts.asUserId,
+      limit: hopts.limit,
+      from: hopts.before
+    });
+    for (const ev of chunk) {
+      const reply = this.toMessage(ev);
+      if (reply) messages.push({ ...reply, thread_id: threadId });
+    }
+    return {
+      messages,
+      next_before: next_batch,
+      has_more: next_batch !== void 0
+    };
+  }
+  toMessage(ev) {
+    if (ev.type !== "m.room.message") return null;
+    if (ev.content?.msgtype !== "m.text" || typeof ev.content.body !== "string") return null;
+    const agent = this.opts.agentBots.get(ev.sender);
+    const relatesTo = ev.content["m.relates_to"];
+    const threadId = relatesTo?.rel_type === "m.thread" && relatesTo.event_id ? relatesTo.event_id : void 0;
+    return {
+      id: ev.event_id,
+      sender: ev.sender,
+      text: ev.content.body,
+      timestamp: new Date(ev.origin_server_ts).toISOString(),
+      is_agent: agent !== void 0,
+      ...agent !== void 0 ? { agent_name: agent } : {},
+      ...threadId !== void 0 ? { thread_id: threadId } : {}
+    };
+  }
+  async getChannelMembers(channelId) {
+    const { joined } = await this.opts.client.getJoinedMembers(channelId, this.opts.asUserId);
+    return Object.entries(joined).map(([id, info]) => {
+      const agent = this.opts.agentBots.get(id);
+      return {
+        id,
+        name: info.display_name ?? id,
+        is_agent: agent !== void 0,
+        ...agent !== void 0 ? { agent_name: agent } : {}
+      };
+    });
+  }
+  async getChannelInfo(channelId) {
+    const name = await this.opts.client.fetchRoomName(channelId, this.opts.asUserId);
+    return {
+      id: channelId,
+      name: name ?? channelId,
+      transport: "matrix"
+    };
+  }
+};
+
+// src/registration.ts
+import { stringify } from "yaml";
+function renderRegistration(c) {
+  return stringify(
+    {
+      id: c.id,
+      url: c.url,
+      as_token: c.asToken,
+      hs_token: c.hsToken,
+      sender_localpart: c.senderLocalpart,
+      rate_limited: false,
+      namespaces: {
+        users: [{ exclusive: c.exclusive ?? true, regex: c.userNamespace }],
+        aliases: c.aliasNamespace ? [{ exclusive: c.exclusive ?? true, regex: c.aliasNamespace }] : [],
+        rooms: []
+      }
+    },
+    { defaultStringType: "PLAIN", defaultKeyType: "PLAIN", singleQuote: true }
+  );
+}
+
+// src/mentions.ts
+var MATRIX_TO_RE = /https:\/\/matrix\.to\/#\/(@[^"<>\s]+)/g;
+var RAW_USER_RE = /(@[A-Za-z0-9._\-=/+]+:[A-Za-z0-9.\-]+)/g;
+function extractMentions(event) {
+  const out = /* @__PURE__ */ new Set();
+  const c = event.content ?? {};
+  for (const id of c["m.mentions"]?.user_ids ?? []) out.add(id);
+  if (c.formatted_body) {
+    for (const m of c.formatted_body.matchAll(MATRIX_TO_RE)) {
+      out.add(decodeURIComponent(m[1]));
+    }
+  }
+  if (c.body && out.size === 0) {
+    for (const m of c.body.matchAll(RAW_USER_RE)) out.add(m[1]);
+  }
+  return [...out];
+}
+function stripMention(body, userId) {
+  const escaped = userId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const re = new RegExp(`\\s*${escaped}\\s*`, "g");
+  return body.replace(re, " ").replace(/\s+/g, " ").trim();
+}
+
+// src/router.ts
+function inboundThreadRoot(event) {
+  const r = event.content?.["m.relates_to"];
+  return r?.rel_type === "m.thread" && r.event_id ? r.event_id : void 0;
+}
+function route(event, agents, threadStates) {
+  if (event.type !== "m.room.message") return [];
+  if (!event.content?.msgtype) return [];
+  const mentions = new Set(extractMentions(event));
+  const matches = [];
+  const threadRoot = inboundThreadRoot(event);
+  const threadState = threadRoot ? threadStates?.get(threadRoot) : void 0;
+  for (const a of agents) {
+    if (event.sender === a.userId) continue;
+    if (!a.rooms.includes(event.room_id ?? "")) continue;
+    if (a.trigger === "any") {
+      matches.push(a);
+      continue;
+    }
+    if (mentions.has(a.userId)) {
+      matches.push(a);
+      continue;
+    }
+    if (threadState) {
+      const lastPoster = threadState.participants.at(-1);
+      if (lastPoster) {
+        if (lastPoster === a.name) matches.push(a);
+      } else if (threadState.rootMentions.includes(a.name)) {
+        matches.push(a);
+      }
+    }
+  }
+  return matches;
+}
+
+// src/space-provisioner.ts
+async function ensureWorkforceSpace(opts) {
+  const alias = `#${opts.spaceLocalpart}:${opts.serverName}`;
+  const existing = await opts.client.resolveAlias(alias);
+  if (existing) return existing;
+  const display = opts.spaceLocalpart.charAt(0).toUpperCase() + opts.spaceLocalpart.slice(1);
+  return opts.client.createRoomRaw({
+    asUserId: opts.asUserId,
+    body: {
+      room_alias_name: opts.spaceLocalpart,
+      name: display,
+      preset: opts.preset,
+      creation_content: { type: "m.space" }
+    }
+  });
+}
+function serverNameFromMxid(mxid) {
+  const colon = mxid.indexOf(":");
+  if (colon < 0) {
+    throw new Error(`mxid lacks server: ${mxid}`);
+  }
+  return mxid.slice(colon + 1);
+}
+
+// src/bot-pool.ts
+var BotPool = class {
+  constructor(client, agents) {
+    this.client = client;
+    this.agents = agents;
+  }
+  async bootstrap(opts = {}) {
+    const aliasToId = /* @__PURE__ */ new Map();
+    const attachedToSpace = /* @__PURE__ */ new Set();
+    for (const a of this.agents) {
+      const lp = localpart(a.userId);
+      try {
+        await this.client.registerBot(lp);
+      } catch (err) {
+        console.warn(`[matrix] register failed for ${a.userId}: ${err.message}`);
+      }
+      try {
+        await this.client.setDisplayName(a.userId, a.displayName ?? lp);
+      } catch (err) {
+        console.warn(`[matrix] setDisplayName(${a.userId}) failed: ${err.message}`);
+      }
+      for (let i = 0; i < a.rooms.length; i++) {
+        const room = a.rooms[i];
+        try {
+          let resolved = room;
+          if (room.startsWith("#")) {
+            const cached = aliasToId.get(room);
+            if (cached) {
+              resolved = cached;
+            } else {
+              const existing = await this.client.resolveAlias(room);
+              if (existing) {
+                resolved = existing;
+              } else {
+                const colon = room.indexOf(":");
+                const aliasLocalpart = colon > 1 ? room.slice(1, colon) : room.slice(1);
+                const sender = opts.adminUserId ?? a.userId;
+                resolved = await this.client.createRoom({
+                  roomAliasName: aliasLocalpart,
+                  invite: opts.adminUserId ? [opts.adminUserId] : [],
+                  senderUserId: sender,
+                  name: aliasLocalpart
+                });
+              }
+              aliasToId.set(room, resolved);
+            }
+          }
+          a.rooms[i] = resolved;
+          await this.client.joinRoom(resolved, a.userId);
+          if (opts.spaceRoomId && opts.asUserId && !attachedToSpace.has(resolved)) {
+            attachedToSpace.add(resolved);
+            const via = serverNameFromMxid(a.userId);
+            try {
+              await this.client.sendStateEvent({
+                roomId: opts.spaceRoomId,
+                asUserId: opts.asUserId,
+                eventType: "m.space.child",
+                stateKey: resolved,
+                content: { via: [via] }
+              });
+            } catch (err) {
+              console.warn(
+                `[matrix] m.space.child(${resolved}) failed: ${err.message}`
+              );
+            }
+          }
+        } catch (err) {
+          console.warn(
+            `[matrix] join failed (${a.userId} \u2192 ${room}): ${err.message}`
+          );
+        }
+      }
+    }
+  }
+  findByUserId(userId) {
+    return this.agents.find((a) => a.userId === userId);
+  }
+  findByName(name) {
+    return this.agents.find((a) => a.name === name);
+  }
+};
+function localpart(userId) {
+  const m = /^@([^:]+):/.exec(userId);
+  if (!m) throw new Error(`bad user id: ${userId}`);
+  return m[1];
+}
+
+// src/transport.ts
+import { Hono } from "hono";
+import { timingSafeEqual } from "crypto";
+
+// src/event-encoders.ts
+var RAW_INPUT_STR_MAX = 250;
+function toToolCallBody(evt) {
+  const out = {
+    session_id: evt.sessionId,
+    tool_call_id: evt.toolCallId,
+    title: evt.title
+  };
+  if (evt.kind !== void 0) out.kind = evt.kind;
+  if (evt.status !== void 0) out.status = evt.status;
+  if (evt.rawInput !== void 0) out.raw_input = truncateStrings(evt.rawInput, RAW_INPUT_STR_MAX);
+  if (evt.locations !== void 0) out.locations = evt.locations;
+  return out;
+}
+function truncateStrings(v, max) {
+  if (typeof v === "string") {
+    return v.length > max ? v.slice(0, max) + "\u2026 [truncated]" : v;
+  }
+  if (Array.isArray(v)) {
+    return v.map((item) => truncateStrings(item, max));
+  }
+  if (v && typeof v === "object") {
+    const out = {};
+    for (const [k, val] of Object.entries(v)) {
+      out[k] = truncateStrings(val, max);
+    }
+    return out;
+  }
+  return v;
+}
+function toUpdateBody(evt) {
+  const out = {
+    session_id: evt.sessionId,
+    tool_call_id: evt.toolCallId
+  };
+  if (evt.status !== void 0) out.status = evt.status;
+  if (evt.kind !== void 0) out.kind = evt.kind;
+  if (evt.content !== void 0) out.content = evt.content;
+  if (evt.rawInput !== void 0) out.raw_input = truncateStrings(evt.rawInput, RAW_INPUT_STR_MAX);
+  if (evt.locations !== void 0) out.locations = evt.locations;
+  return out;
+}
+function toPlanBody(evt) {
+  return {
+    session_id: evt.sessionId,
+    entries: evt.entries
+  };
+}
+
+// src/markdown-to-matrix-html.ts
+import { marked } from "marked";
+import sanitizeHtml from "sanitize-html";
+var ALLOWED_TAGS = [
+  "del",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "blockquote",
+  "p",
+  "a",
+  "ul",
+  "ol",
+  "sup",
+  "sub",
+  "li",
+  "b",
+  "i",
+  "u",
+  "strong",
+  "em",
+  "s",
+  "code",
+  "hr",
+  "br",
+  "div",
+  "table",
+  "thead",
+  "tbody",
+  "tr",
+  "th",
+  "td",
+  "caption",
+  "pre",
+  "span",
+  "img",
+  "details",
+  "summary"
+];
+var ALLOWED_ATTRIBUTES = {
+  a: ["href", "name", "target"],
+  img: ["width", "height", "alt", "title", "src"],
+  ol: ["start"],
+  code: ["class"],
+  span: ["data-mx-color", "data-mx-bg-color", "data-mx-spoiler"]
+};
+var ALLOWED_SCHEMES = ["https", "http", "ftp", "mailto", "magnet", "matrix"];
+marked.setOptions({ gfm: true, breaks: false, async: false });
+function toMatrixHtml(markdown) {
+  if (!markdown || !markdown.trim()) return "";
+  let rawHtml;
+  try {
+    const out = marked.parse(markdown);
+    if (typeof out !== "string") return "";
+    rawHtml = out;
+  } catch {
+    return "";
+  }
+  return sanitizeHtml(rawHtml, {
+    allowedTags: ALLOWED_TAGS,
+    allowedAttributes: ALLOWED_ATTRIBUTES,
+    allowedSchemes: ALLOWED_SCHEMES,
+    allowedSchemesByTag: { a: ALLOWED_SCHEMES }
+  });
+}
+
+// src/transport.ts
+var STARTUP_GRACE_MS = 5e3;
+var SEEN_EVENT_CAP = 5e3;
+function inboundThreadRoot2(evt) {
+  const r = evt.content?.["m.relates_to"];
+  return r?.rel_type === "m.thread" && r.event_id ? r.event_id : void 0;
+}
+function createMatrixTransport(opts) {
+  const { agents, approvals, client, bindings, hsToken, adminUserId } = opts;
+  const pool = new BotPool(client, bindings);
+  const sessions = /* @__PURE__ */ new Map();
+  const buffers = /* @__PURE__ */ new Map();
+  const sendQueue = /* @__PURE__ */ new Map();
+  const threadStates = /* @__PURE__ */ new Map();
+  const cutoffTs = Date.now() - STARTUP_GRACE_MS;
+  const seenEventIds = /* @__PURE__ */ new Set();
+  agents.onEvent = async (name, event) => {
+    const ctx = sessions.get(event.sessionId);
+    if (!ctx) {
+      console.warn(`[matrix:${name}] no session ctx for ${event.sessionId}`);
+      return;
+    }
+    if (event.type === "agent_message_chunk") {
+      const block = event.content;
+      if (block.type === "text" && typeof block.text === "string") {
+        buffers.set(event.sessionId, (buffers.get(event.sessionId) ?? "") + block.text);
+      } else {
+        console.warn(`[matrix:${name}] dropped chunk block type=${block.type}`, block);
+      }
+      return;
+    }
+    const eventType = event.type === "tool_call" ? "eco.zoon.tool_call" : event.type === "tool_call_update" ? "eco.zoon.tool_call_update" : "eco.zoon.plan";
+    const body = event.type === "tool_call" ? toToolCallBody(event) : event.type === "tool_call_update" ? toUpdateBody(event) : toPlanBody(event);
+    body["m.relates_to"] = { rel_type: "m.thread", event_id: ctx.threadRoot };
+    const tail = (sendQueue.get(event.sessionId) ?? Promise.resolve()).then(async () => {
+      try {
+        await client.sendCustomEvent({
+          roomId: ctx.roomId,
+          asUserId: ctx.agent.userId,
+          eventType,
+          content: body
+        });
+      } catch (err) {
+        console.warn(`[matrix:${name}] sendCustomEvent(${eventType}) failed:`, err);
+      }
+    });
+    sendQueue.set(event.sessionId, tail);
+    await tail;
+  };
+  agents.onApprovalRequest = async (name, req) => {
+    const handle = approvals.register(name, req.sessionId, req, {
+      timeoutMs: agents.getApprovalTimeoutMs(name)
+    });
+    return handle.decisionPromise;
+  };
+  approvals.on("registered", (handle) => {
+    const ctx = sessions.get(handle.sessionId);
+    if (!ctx) return;
+    const content = {
+      approval_id: handle.approvalId,
+      session_id: handle.sessionId,
+      tool_call_id: handle.toolCallId,
+      options: handle.options
+    };
+    content["m.relates_to"] = { rel_type: "m.thread", event_id: ctx.threadRoot };
+    if (handle.toolKind !== void 0) content.tool_kind = handle.toolKind;
+    if (handle.toolTitle !== void 0) content.tool_title = handle.toolTitle;
+    if (handle.toolInput !== void 0) content.tool_input = handle.toolInput;
+    void client.sendCustomEvent({
+      roomId: ctx.roomId,
+      asUserId: ctx.agent.userId,
+      eventType: "eco.zoon.approval_request",
+      content
+    });
+  });
+  const app = new Hono();
+  function authOk(authHeader) {
+    const h = authHeader ?? "";
+    if (!h.startsWith("Bearer ")) return false;
+    const got = h.slice(7);
+    if (got.length !== hsToken.length) return false;
+    return timingSafeEqual(Buffer.from(got), Buffer.from(hsToken));
+  }
+  app.put("/_matrix/app/v1/transactions/:txnId", async (c) => {
+    if (!authOk(c.req.header("authorization"))) {
+      return c.json({ errcode: "M_FORBIDDEN" }, 403);
+    }
+    const body = await c.req.json().catch(() => ({}));
+    for (const evt of body.events ?? []) {
+      if (evt.event_id) {
+        if (seenEventIds.has(evt.event_id)) {
+          continue;
+        }
+        seenEventIds.add(evt.event_id);
+        if (seenEventIds.size > SEEN_EVENT_CAP) {
+          const first = seenEventIds.values().next().value;
+          if (first !== void 0) seenEventIds.delete(first);
+        }
+      }
+      if (evt.origin_server_ts !== void 0 && evt.origin_server_ts < cutoffTs && evt.type === "m.room.message") {
+        console.log(
+          `[matrix] dropping stale message event ${evt.event_id} (ts=${evt.origin_server_ts}, daemon started at ${cutoffTs + STARTUP_GRACE_MS})`
+        );
+        continue;
+      }
+      if (evt.type === "eco.zoon.session_reset") {
+        const relates = evt.content?.["m.relates_to"];
+        const threadRoot = relates?.rel_type === "m.thread" && relates.event_id ? relates.event_id : void 0;
+        if (!threadRoot) {
+          console.log("[matrix] dropping eco.zoon.session_reset without thread relation");
+          continue;
+        }
+        console.log(`[matrix] inbound eco.zoon.session_reset in ${evt.room_id} thread=${threadRoot}`);
+        for (const a of bindings) {
+          agents.endSession(a.name, threadRoot);
+        }
+        continue;
+      }
+      if (evt.type === "eco.zoon.interrupt") {
+        const content = evt.content ?? {};
+        const relates = evt.content?.["m.relates_to"];
+        const threadRoot = relates?.rel_type === "m.thread" && relates.event_id ? relates.event_id : void 0;
+        if (threadRoot) {
+          const targets = [];
+          for (const [sessionId, ctx2] of sessions) {
+            if (ctx2.threadRoot === threadRoot) {
+              targets.push({ sessionId, agent: ctx2.agent.name });
+            }
+          }
+          for (const t of targets) {
+            console.log(
+              `[matrix] interrupt session=${t.sessionId} agent=${t.agent} thread=${threadRoot}` + (content.reason ? ` reason=${content.reason}` : "")
+            );
+            await agents.cancelSession(t.agent, t.sessionId).catch((err) => {
+              console.error(`[matrix] cancelSession(${t.agent}, ${t.sessionId}) failed:`, err);
+            });
+          }
+          continue;
+        }
+        if (!content.session_id) {
+          console.warn(`[matrix] eco.zoon.interrupt missing session_id (event_id=${evt.event_id})`);
+          continue;
+        }
+        const ctx = sessions.get(content.session_id);
+        if (!ctx) {
+          continue;
+        }
+        console.log(
+          `[matrix] interrupt session=${content.session_id} agent=${ctx.agent.name}` + (content.reason ? ` reason=${content.reason}` : "")
+        );
+        await agents.cancelSession(ctx.agent.name, content.session_id).catch((err) => {
+          console.error(`[matrix] cancelSession(${ctx.agent.name}, ${content.session_id}) failed:`, err);
+        });
+        continue;
+      }
+      if (evt.type === "eco.zoon.approval_response") {
+        const content = evt.content ?? {};
+        if (!content.session_id || !content.approval_id || !content.decision) continue;
+        const decision = content.option_id ? { decision: content.decision, optionId: content.option_id } : { decision: content.decision };
+        const ok = approvals.resolve(
+          content.session_id,
+          content.approval_id,
+          decision
+        );
+        if (!ok) console.warn(`[matrix] unknown approval ${content.approval_id}`);
+        continue;
+      }
+      logInbound(evt);
+      const promotedRoot = inboundThreadRoot2(evt) ?? evt.event_id;
+      const inboundRel = inboundThreadRoot2(evt);
+      if (evt.type === "m.room.message" && inboundRel && !threadStates.has(inboundRel) && evt.room_id) {
+        try {
+          const rebuilt = await rebuildThreadState(client, evt.room_id, inboundRel, bindings);
+          threadStates.set(inboundRel, rebuilt);
+          console.log(
+            `[matrix] rebuilt threadState for ${inboundRel}: participants=${rebuilt.participants.join(",")} rootMentions=${rebuilt.rootMentions.join(",")}`
+          );
+        } catch (err) {
+          console.warn(`[matrix] failed to rebuild threadState for ${inboundRel}:`, err);
+        }
+      }
+      const matches = route(evt, bindings, threadStates);
+      const senderIsBot = bindings.some((b) => b.userId === evt.sender);
+      if (evt.type === "m.room.message" && matches.length === 0 && !senderIsBot) {
+        console.warn(
+          `[matrix] no agent matched message in ${evt.room_id} from ${evt.sender} (bindings: ${bindings.map((b) => `${b.name}@${b.userId}[${b.trigger}]`).join(", ")})`
+        );
+      }
+      if (matches.length > 0 && promotedRoot) {
+        let st = threadStates.get(promotedRoot);
+        if (!st) {
+          st = { participants: [], rootMentions: [] };
+          threadStates.set(promotedRoot, st);
+        }
+        const msgMentions = new Set(extractMentions(evt));
+        for (const a of bindings) {
+          if (msgMentions.has(a.userId) && !st.rootMentions.includes(a.name)) {
+            st.rootMentions.push(a.name);
+          }
+        }
+      }
+      for (const a of matches) {
+        console.log(`[matrix] \u2192 ${a.name} (${a.userId})`);
+        void runTurn(a, evt).then(() => {
+          if (!promotedRoot) return;
+          let st = threadStates.get(promotedRoot);
+          if (!st) {
+            st = { participants: [], rootMentions: [] };
+            threadStates.set(promotedRoot, st);
+          }
+          if (st.participants.at(-1) !== a.name) st.participants.push(a.name);
+        }).catch((err) => {
+          console.error(`[matrix] runTurn failed for ${a.name}:`, err);
+        });
+      }
+    }
+    return c.json({});
+  });
+  app.get("/_matrix/app/v1/users/:userId", (c) => {
+    if (!authOk(c.req.header("authorization"))) {
+      return c.json({ errcode: "M_FORBIDDEN" }, 403);
+    }
+    return c.json({});
+  });
+  app.get("/_matrix/app/v1/rooms/:alias", (c) => {
+    if (!authOk(c.req.header("authorization"))) {
+      return c.json({ errcode: "M_FORBIDDEN" }, 403);
+    }
+    return c.json({ errcode: "M_NOT_FOUND" }, 404);
+  });
+  app.post("/_matrix/app/v1/ping", (c) => {
+    if (!authOk(c.req.header("authorization"))) {
+      return c.json({ errcode: "M_FORBIDDEN" }, 403);
+    }
+    return c.json({});
+  });
+  app.get("/healthz", (c) => c.text("ok"));
+  async function runTurn(agent, evt) {
+    if (!evt.room_id || !evt.event_id) return;
+    const inbound = inboundThreadRoot2(evt);
+    const threadRoot = inbound ?? evt.event_id;
+    const sessionKey = threadRoot;
+    const sessionId = await agents.ensureSession(agent.name, sessionKey, evt.room_id);
+    sessions.set(sessionId, { agent, roomId: evt.room_id, threadRoot });
+    buffers.set(sessionId, "");
+    const roomId = evt.room_id;
+    const TYPING_TTL_MS = 3e4;
+    const TYPING_REFRESH_MS = 25e3;
+    const safeTyping = (typing) => client.setTyping({ roomId, asUserId: agent.userId, typing, timeoutMs: TYPING_TTL_MS }).catch((err) => console.warn(`[matrix:${agent.name}] setTyping(${typing}) failed:`, err));
+    const safePresence = (presence) => client.setPresence({ asUserId: agent.userId, presence }).catch(
+      (err) => console.warn(`[matrix:${agent.name}] setPresence(${presence}) failed:`, err)
+    );
+    await safeTyping(true);
+    await safePresence("unavailable");
+    const refresh = setInterval(() => {
+      void safeTyping(true);
+    }, TYPING_REFRESH_MS);
+    try {
+      const rawBody = evt.content?.body ?? "";
+      const promptText = stripMention(rawBody, agent.userId);
+      await agents.prompt(agent.name, {
+        threadId: sessionKey,
+        channelId: evt.room_id,
+        content: [{ type: "text", text: promptText }]
+      });
+      const text = buffers.get(sessionId) ?? "";
+      if (text.length > 0) {
+        const html = toMatrixHtml(text);
+        const content = {
+          msgtype: "m.text",
+          body: text
+        };
+        if (html) {
+          const escapedPlain = "<p>" + text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;") + "</p>";
+          const norm = (s) => s.replace(/\s+/g, " ").trim();
+          if (norm(html) !== norm(escapedPlain)) {
+            content.format = "org.matrix.custom.html";
+            content.formatted_body = html;
+          }
+        }
+        await client.sendMessage({
+          roomId: evt.room_id,
+          asUserId: agent.userId,
+          content,
+          threadRoot
+          // every reply threads, full stop
+        });
+      } else {
+        console.warn(
+          `[matrix:${agent.name}] turn finished with empty buffer (session=${sessionId}); nothing sent to ${evt.room_id}`
+        );
+      }
+    } finally {
+      clearInterval(refresh);
+      await safeTyping(false);
+      await safePresence("online");
+      buffers.delete(sessionId);
+    }
+  }
+  return {
+    app,
+    bootstrap: async (bootstrapOpts = {}) => {
+      await pool.bootstrap({ adminUserId, ...bootstrapOpts });
+      await Promise.allSettled(
+        bindings.map(
+          (b) => client.setPresence({ asUserId: b.userId, presence: "online" }).catch((err) => {
+            console.warn(`[matrix:${b.name}] initial setPresence(online) failed:`, err);
+          })
+        )
+      );
+    },
+    pool
+  };
+}
+async function rebuildThreadState(client, roomId, rootEventId, bindings) {
+  const state = { participants: [], rootMentions: [] };
+  const asUser = (bindings.find((b) => b.rooms.includes(roomId)) ?? bindings[0])?.userId;
+  if (!asUser) return state;
+  const root = await client.fetchEvent(roomId, rootEventId, asUser);
+  if (root) {
+    const rootMentions = new Set(extractMentions(root));
+    for (const a of bindings) {
+      if (rootMentions.has(a.userId) && !state.rootMentions.includes(a.name)) {
+        state.rootMentions.push(a.name);
+      }
+    }
+  }
+  const { chunk: thread } = await client.fetchThreadRelations({
+    roomId,
+    rootEventId,
+    asUserId: asUser
+  });
+  for (const ev of thread) {
+    const mentions = new Set(extractMentions(ev));
+    for (const a of bindings) {
+      if (mentions.has(a.userId) && !state.rootMentions.includes(a.name)) {
+        state.rootMentions.push(a.name);
+      }
+    }
+    const sender = ev.sender;
+    const type = ev.type;
+    if (type === "m.room.message" && sender) {
+      const a = bindings.find((b) => b.userId === sender);
+      if (a && state.participants.at(-1) !== a.name) state.participants.push(a.name);
+    }
+  }
+  return state;
+}
+function logInbound(evt) {
+  const sender = evt.sender ?? "?";
+  const room = evt.room_id ?? "?";
+  const type = evt.type ?? "?";
+  if (type === "m.room.message") {
+    const body = evt.content?.body ?? "";
+    const mentions = evt.content?.["m.mentions"]?.user_ids;
+    const mentionsStr = mentions?.length ? ` mentions=${JSON.stringify(mentions)}` : "";
+    console.log(
+      `[matrix] inbound msg in ${room} from ${sender}${mentionsStr}: ${truncate(body, 200)}`
+    );
+  } else {
+    console.log(`[matrix] inbound ${type} in ${room} from ${sender}`);
+  }
+}
+function truncate(s, n) {
+  return s.length > n ? s.slice(0, n) + "\u2026" : s;
+}
+
+// src/workforce-publisher.ts
+function buildWorkforceRoster(agents) {
+  return {
+    version: 1,
+    agents: agents.map((a) => ({ user_id: a.userId, name: a.name, rooms: a.rooms }))
+  };
+}
+async function publishWorkforce(opts) {
+  await opts.client.sendStateEvent({
+    roomId: opts.spaceRoomId,
+    asUserId: opts.asUserId,
+    eventType: "eco.zoon.workforce",
+    stateKey: "",
+    content: buildWorkforceRoster(opts.agents)
+  });
+}
+async function startWorkforcePublisher(opts) {
+  await publishWorkforce({ ...opts, agents: opts.getAgents() });
+  return {
+    async reload() {
+      await publishWorkforce({ ...opts, agents: opts.getAgents() });
+    },
+    async stop() {
+    }
+  };
+}
+export {
+  BotPool,
+  MatrixClient,
+  MatrixContextProvider,
+  buildWorkforceRoster,
+  createMatrixTransport,
+  ensureWorkforceSpace,
+  extractMentions,
+  publishWorkforce,
+  renderRegistration,
+  route,
+  serverNameFromMxid,
+  startWorkforcePublisher
+};
+//# sourceMappingURL=index.js.map