@gorlitzer-labs/apiary 1.13.8 → 1.14.0

package/dist/chunk-36WX2UAF.js

@@ -0,0 +1,663 @@
+import {
+  RemoteRoomDataSource,
+  buildCatchUpLines
+} from "./chunk-WJD5EKO6.js";
+import {
+  extractToken,
+  tmuxCapturePane,
+  tmuxCapturePaneStyled,
+  tmuxInjectText,
+  tmuxPaneIsShell,
+  tmuxSendEnter,
+  tmuxSendKey
+} from "./chunk-N2LPKMPO.js";
+import {
+  can,
+  contentPartsToString
+} from "./chunk-TMXQDGMN.js";
+
+// src/cli/composer.ts
+var PROMPT_MARKER = /^\s*[›❯>]\s?/;
+function composerBlock(lines) {
+  const tail = lines.slice(-25);
+  let start = -1;
+  for (let i = tail.length - 1; i >= 0; i--) {
+    if (PROMPT_MARKER.test(tail[i])) {
+      start = i;
+      break;
+    }
+  }
+  if (start === -1) return "";
+  return tail.slice(start).join(" ");
+}
+function submissionProbe(text) {
+  return text.replace(/\s+/g, " ").trim().slice(0, 40);
+}
+function composerStillHolds(lines, text) {
+  const probe = submissionProbe(text);
+  if (probe.length < 8) return false;
+  const composer = composerBlock(lines).replace(/\s+/g, " ");
+  return composer.includes(probe);
+}
+
+// src/cli/claude/tmux-bridge.ts
+var SPINNER_CHARS = "\u280B\u2819\u2839\u2838\u283C\u2834\u2826\u2827\u2807\u280F";
+var BUSY_PATTERNS = [
+  /[A-Za-zÀ-ÿ]+…\s*\(\d+(?:m\s*\d+)?s\b/
+];
+function composerHoldsOnlyGhost(styledLines) {
+  const SGR = /\x1b\[[0-9;]*m/g;
+  for (let i = styledLines.length - 1; i >= 0; i--) {
+    const plain = styledLines[i].replace(SGR, "").trimStart();
+    if (!/^[❯›](\s|$)/.test(plain)) continue;
+    const afterPrompt = styledLines[i].slice(styledLines[i].search(/[❯›]/) + 1);
+    const typed = afterPrompt.replace(/\x1b\[2m[\s\S]*?(?:\x1b\[(?:0|22)?m|$)/g, "").replace(SGR, "").trim();
+    return typed.length === 0;
+  }
+  return false;
+}
+var DIALOG_PATTERNS = [
+  "Enter to select",
+  "to navigate",
+  "Esc to cancel",
+  "Ready to code?",
+  "Review your answers",
+  "ctrl+g to edit in"
+];
+var PERMISSION_PATTERNS = [
+  "(Y)",
+  "Allow ",
+  "Deny ",
+  "approve",
+  "Yes / No",
+  // Current Claude Code wording, captured from a live prompt. Without these a
+  // permission dialog reads as idle and the bridge pastes a room event into
+  // it, answering on the agent's behalf.
+  "Do you want to proceed?",
+  "don't ask again",
+  // The folder-trust modal, which no flag skips.
+  "Yes, I trust this folder"
+];
+var BLOCKING_PATTERNS = [
+  "Do you want to proceed?",
+  "don't ask again",
+  "Yes, I trust this folder",
+  "Ready to code?",
+  "Enter to select",
+  /❯\s*1\.\s*Yes/,
+  /\(y\s*\/\s*n\)/i,
+  // The arrow glyphs claude renders beside it. Bare "to navigate" is prose.
+  /[↑↓⬆⬇]\s*(?:[↑↓⬆⬇]\s*)?to navigate/
+];
+function matchesAny(text, patterns) {
+  const haystack = text.toLowerCase();
+  for (const pattern of patterns) {
+    if (typeof pattern === "string") {
+      if (haystack.includes(pattern.toLowerCase())) return true;
+    } else if (pattern.test(text)) {
+      return true;
+    }
+  }
+  return false;
+}
+function defaultUndeliveredWarning(text) {
+  const preview = text.replace(/\s+/g, " ").slice(0, 80);
+  process.stderr.write(`apiary: message NOT delivered to the agent \u2014 still in its composer: ${preview}
+`);
+}
+var TmuxBridge = class _TmuxBridge {
+  session;
+  queue = [];
+  pollTimer = null;
+  pollIntervalMs;
+  keystrokeDelayMs;
+  onUndelivered;
+  attended;
+  stopped = false;
+  blockedCount = 0;
+  static BLOCKED_THRESHOLD = 150;
+  // ~30s at 200ms poll — force inject if stuck
+  constructor(session, opts) {
+    this.session = session;
+    this.pollIntervalMs = opts?.pollIntervalMs ?? 200;
+    this.keystrokeDelayMs = opts?.keystrokeDelayMs ?? 50;
+    this.onUndelivered = opts?.onUndelivered ?? defaultUndeliveredWarning;
+    this.attended = opts?.attended ?? false;
+  }
+  /**
+   * Delivery callback — drop-in replacement for the raw tmuxDeliver lambda.
+   * Pass `bridge.deliver.bind(bridge)` to EventProcessor.run().
+   */
+  async deliver(parts, opts) {
+    const text = contentPartsToString(parts);
+    if (!text.trim()) return;
+    this.inject(text, opts?.dedupe === true);
+  }
+  /**
+   * Detect the current TUI state by reading the screen.
+   * Exported for testing — the heuristic logic is in detectStateFromLines().
+   */
+  detectState() {
+    if (tmuxPaneIsShell(this.session)) return "absent";
+    const lines = this.captureScreen();
+    return detectStateFromLines(lines);
+  }
+  /**
+   * State to REPORT to the room, as opposed to the state used to decide
+   * whether it is safe to type. Same screen, stricter about claiming a human
+   * is needed — see detectReportedStateFromLines.
+   */
+  detectReportedState() {
+    if (tmuxPaneIsShell(this.session)) return "absent";
+    return detectReportedStateFromLines(this.captureScreen());
+  }
+  /**
+   * Extract claude's live status label from the pane (the "Sautéed for 12s",
+   * "Compacting conversation… 23%" lines under the prompt). Returns null when
+   * the agent is idle / no status visible.
+   *
+   * The room TUI calls this through the agent runtime's poll loop to surface
+   * "is the agent actually working or stuck?" without making the user attach
+   * to each tmux pane.
+   */
+  getActivityLabel() {
+    return extractActivityLabel(this.captureScreen());
+  }
+  /**
+   * Try to inject text, choosing strategy based on TUI state.
+   * If the state is unsafe, queues the text and starts polling.
+   *
+   * Text is flattened to a single line before injection to avoid triggering
+   * Claude Code's paste detection. When multi-line text arrives via
+   * `send-keys -l`, Claude Code detects it as a paste and collapses it into
+   * "[Pasted text #1 +N lines]" which may not reliably submit with Enter.
+   */
+  inject(text, dedupe) {
+    const flat = text.replace(/\n/g, " ");
+    const state = this.deliveryState();
+    switch (state) {
+      case "idle":
+        this.injectIdle(flat);
+        break;
+      case "typing":
+        this.injectWhileTyping(flat);
+        break;
+      default:
+        this.enqueue(flat, dedupe);
+        break;
+    }
+  }
+  /**
+   * The state delivery acts on. Unattended it is the screen state. Attended,
+   * "typing" splits in two: only placeholder text is idle; a real draft is the
+   * human's, so the event waits ("unknown" queues it).
+   */
+  deliveryState() {
+    const state = this.detectState();
+    if (!this.attended || state !== "typing") return state;
+    return composerHoldsOnlyGhost(tmuxCapturePaneStyled(this.session)) ? "idle" : "unknown";
+  }
+  /** Capture the screen via tmux capture-pane. */
+  captureScreen() {
+    return tmuxCapturePane(this.session);
+  }
+  /**
+   * Inject into an idle prompt: type text + Enter, then check it went.
+   *
+   * This used to fire a second Enter unconditionally as a "safety net" against
+   * Claude Code's paste detection swallowing the first. That is a guess in both
+   * directions: it cannot tell whether the first Enter worked, and it cannot
+   * tell whether the second one did either. Reading the composer back answers
+   * the question instead, and only sends the second Enter when it is needed.
+   */
+  injectIdle(text) {
+    tmuxInjectText(this.session, text);
+    tmuxSendEnter(this.session);
+    this.confirmSubmitted(text);
+  }
+  /**
+   * Check the message left the composer, and press Enter once more if it did not.
+   *
+   * A submitted message moves into the transcript; one still in the composer was
+   * never sent. If it is still there after the retry, the room is told rather
+   * than left to read the agent's silence as a choice.
+   */
+  confirmSubmitted(text) {
+    this.sleep(80);
+    if (!composerStillHolds(this.captureScreen(), text)) return;
+    tmuxSendEnter(this.session);
+    this.sleep(120);
+    if (!composerStillHolds(this.captureScreen(), text)) return;
+    this.onUndelivered(text);
+  }
+  /**
+   * Inject while the user is typing:
+   * 1. Ctrl+U — cut line to kill ring
+   * 2. Inject our text + Enter
+   * 3. Ctrl+Y — paste the user's text back
+   */
+  injectWhileTyping(text) {
+    tmuxSendKey(this.session, "C-u");
+    this.sleep(this.keystrokeDelayMs);
+    tmuxInjectText(this.session, text);
+    tmuxSendEnter(this.session);
+    this.confirmSubmitted(text);
+    this.sleep(this.keystrokeDelayMs);
+    tmuxSendKey(this.session, "C-y");
+  }
+  /** Add to queue and start polling if not already. */
+  enqueue(text, dedupe) {
+    if (dedupe && this.queue.includes(text)) return;
+    this.queue.push(text);
+    this.startPolling();
+  }
+  /** Start the polling timer to drain queued events. */
+  startPolling() {
+    if (this.pollTimer || this.stopped) return;
+    this.pollTimer = setInterval(() => this.drainQueue(), this.pollIntervalMs);
+  }
+  /** Stop the polling timer. */
+  stopPolling() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  /**
+   * Try to drain one queued event if the state is safe.
+   *
+   * Drains one event at a time rather than batching all into one multi-line
+   * string — multi-line text triggers Claude Code's paste detection which
+   * collapses it into "[Pasted text #1 +N lines]".
+   *
+   * After injecting one event, the poll continues. The next cycle re-checks
+   * state: if Claude is busy (streaming), remaining events wait. If idle,
+   * the next event is injected. Events are already flattened in inject().
+   */
+  drainQueue() {
+    if (this.queue.length === 0) {
+      this.stopPolling();
+      this.blockedCount = 0;
+      return;
+    }
+    const state = this.deliveryState();
+    if (state === "idle" || state === "typing") {
+      this.blockedCount = 0;
+      const text = this.queue.shift();
+      if (state === "idle") {
+        this.injectIdle(text);
+      } else {
+        this.injectWhileTyping(text);
+      }
+      if (this.queue.length === 0) {
+        this.stopPolling();
+      }
+    } else {
+      this.blockedCount++;
+      if (!this.attended && this.blockedCount >= _TmuxBridge.BLOCKED_THRESHOLD) {
+        this.blockedCount = 0;
+        const text = this.queue.shift();
+        this.injectIdle(text);
+        if (this.queue.length === 0) this.stopPolling();
+      }
+    }
+  }
+  /** Cleanup. */
+  stop() {
+    this.stopped = true;
+    this.stopPolling();
+    this.queue.length = 0;
+  }
+  /** Synchronous sleep — only used for tiny keystroke delays. */
+  sleep(ms) {
+    if (ms <= 0) return;
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  }
+};
+var ACTIVITY_LIVE = /([A-Za-zÀ-ÿ]+…\s*\([^)\n]*\))/;
+var ACTIVITY_COOK = /([A-Za-zÀ-ÿ]+ed\s+for\s+\d+s)/;
+var ACTIVITY_PROG = /((?:Compacting|Thinking|Loading|Connecting)[^()]*?(?:\s+\d+%)?)(?=\s*[(\n]|\s*$)/;
+function extractActivityLabel(lines) {
+  if (lines.length === 0) return null;
+  let best = null;
+  for (const line of lines.slice(-25)) {
+    const m = line.match(ACTIVITY_PROG) ?? line.match(ACTIVITY_COOK) ?? line.match(ACTIVITY_LIVE);
+    if (m) best = m[1].trim();
+  }
+  return best;
+}
+function detectStateFromLines(lines, opts) {
+  if (lines.length === 0) return "unknown";
+  const tail = lines.slice(-30);
+  const tailText = tail.join("\n");
+  if (opts?.ignorePrompts !== true) {
+    for (const pattern of DIALOG_PATTERNS) {
+      if (tailText.includes(pattern)) return "dialog";
+    }
+    for (const pattern of PERMISSION_PATTERNS) {
+      if (tailText.includes(pattern)) return "permission";
+    }
+  }
+  const lastFew = tail.slice(-5).join("");
+  for (const ch of SPINNER_CHARS) {
+    if (lastFew.includes(ch)) return "streaming";
+  }
+  const statusArea = tail.slice(-10).join("\n");
+  for (const pattern of BUSY_PATTERNS) {
+    if (pattern.test(statusArea)) return "streaming";
+  }
+  const promptChar = /^[❯›](\s|$)/;
+  const footerChar = /^[❯›]{2}\s/;
+  const separatorLine = /^[─━─\-]{10,}/;
+  for (let i = tail.length - 1; i >= 0; i--) {
+    const line = tail[i].trimStart();
+    if (footerChar.test(line)) {
+      for (let j = i - 1; j >= 0; j--) {
+        const above = tail[j].trimStart();
+        if (promptChar.test(above)) {
+          const content = above.replace(/^[❯›]\s*/, "").trim();
+          return content.length === 0 ? "idle" : "typing";
+        }
+      }
+      break;
+    }
+  }
+  for (let i = tail.length - 1; i >= 0; i--) {
+    const line = tail[i].trimStart();
+    if (promptChar.test(line)) {
+      const above = i > 0 ? tail[i - 1].trimStart() : "";
+      const below = i < tail.length - 1 ? tail[i + 1].trimStart() : "";
+      if (separatorLine.test(above) || separatorLine.test(below)) {
+        const content = line.replace(/^[❯›]\s*/, "").trim();
+        return content.length === 0 ? "idle" : "typing";
+      }
+    }
+  }
+  return "unknown";
+}
+function detectReportedStateFromLines(lines) {
+  const loose = detectStateFromLines(lines);
+  if (loose !== "dialog" && loose !== "permission") return loose;
+  if (matchesAny(lines.slice(-30).join("\n"), BLOCKING_PATTERNS)) return loose;
+  return detectStateFromLines(lines, { ignorePrompts: true });
+}
+
+// src/agent/wait-for-agent.ts
+var DEFAULT_WAIT_MS = 6e4;
+var MAX_WAIT_MS = 12e4;
+var DEFAULT_POLL_MS = 2e3;
+function resolveBudgetMs(timeoutMs, maxWaitMs = MAX_WAIT_MS) {
+  return Math.min(Math.max(timeoutMs ?? DEFAULT_WAIT_MS, 0), maxWaitMs);
+}
+function satisfies(state, until, initial) {
+  if (state === "unknown") return false;
+  if (until === "change") return state !== initial;
+  return state === until;
+}
+async function waitForAgent(opts) {
+  const {
+    readState,
+    until = "idle",
+    maxWaitMs = MAX_WAIT_MS,
+    pollIntervalMs = DEFAULT_POLL_MS,
+    sleep = (ms) => new Promise((r) => {
+      setTimeout(r, ms).unref?.();
+    }),
+    now = () => Date.now()
+  } = opts;
+  const budget = resolveBudgetMs(opts.timeoutMs, maxWaitMs);
+  const started = now();
+  const initial = await readState();
+  if (initial === "unknown") {
+    return { result: "not-reporting", state: "unknown", waitedMs: now() - started };
+  }
+  if (satisfies(initial, until, initial)) {
+    return { result: "satisfied", state: initial, waitedMs: now() - started };
+  }
+  let latest = initial;
+  const steps = Math.max(1, Math.ceil(budget / pollIntervalMs));
+  for (let step = 0; step < steps; step++) {
+    await sleep(pollIntervalMs);
+    latest = await readState();
+    if (satisfies(latest, until, initial)) {
+      return { result: "satisfied", state: latest, waitedMs: now() - started };
+    }
+  }
+  return { result: "timeout", state: latest, waitedMs: now() - started };
+}
+function describeOutcome(participant, until, outcome) {
+  const secs = Math.round(outcome.waitedMs / 1e3);
+  switch (outcome.result) {
+    case "satisfied":
+      return `${participant} is now ${outcome.state} (waited ${secs}s).`;
+    case "timeout":
+      return `${participant} is still ${outcome.state} after ${secs}s \u2014 not ${until} yet. Call again to keep waiting, or get on with something else.`;
+    case "not-reporting":
+      return `${participant} does not report its state, so there is nothing to wait for. Only agents started by apiary with a Claude Code or Codex runtime report it. Ask them directly instead.`;
+  }
+}
+
+// src/cli/runtime-handlers.ts
+function buildRuntimeMcpOptions(ctx) {
+  const { processor, sseMux, joinResults, agentName, authority, onRoomJoined } = ctx;
+  const adminAction = (build) => async (room, participant) => {
+    const conn = processor.resolve(room);
+    if (!conn) return { success: false, error: `Unknown room "${room}".` };
+    const ds = conn.dataSource;
+    const p = conn.dataSource.listParticipants().find((pp) => pp.name === participant);
+    if (!p) return { success: false, error: `Unknown participant "${participant}".` };
+    const { path, body } = build(p.id);
+    try {
+      const res = await fetch(`${ds.serverUrl}${path}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${ds.sessionToken}` },
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) return { success: false, error: await res.text() };
+      return { success: true };
+    } catch {
+      return { success: false, error: "Server unreachable." };
+    }
+  };
+  return {
+    resolver: processor,
+    toolOptions: {
+      isEventSeen: (id) => processor.isEventSeen(id),
+      markEventsSeen: (ids) => processor.markEventsSeen(ids),
+      assignRef: (id) => processor.assignRef(id),
+      resolveRef: (ref) => processor.resolveRef(ref)
+    },
+    authority,
+    onSetMode: async (room, mode) => {
+      const conn = processor.resolve(room);
+      if (!conn) return { success: false, error: `Unknown room "${room}".` };
+      processor.setModeForRoom(conn.dataSource.roomId, mode, false);
+      try {
+        const ds = conn.dataSource;
+        const res = await fetch(`${ds.serverUrl}/set-mode`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", Authorization: `Bearer ${ds.sessionToken}` },
+          body: JSON.stringify({ mode })
+        });
+        if (!res.ok) return { success: false, error: `Server rejected: ${await res.text()}` };
+      } catch {
+      }
+      return { success: true };
+    },
+    /**
+     * Wait for another agent to reach a state, by polling the room server's
+     * participant list. Two seconds of HTTP is far cheaper than the LLM turn
+     * the agent would otherwise spend re-reading the room to check.
+     */
+    onWaitForAgent: async (room, participant, until, timeoutSec) => {
+      const conn = processor.resolve(room);
+      if (!conn) return { success: false, error: `Unknown room "${room}".` };
+      const ds = conn.dataSource;
+      const target = conn.dataSource.listParticipants().find((pp) => pp.name === participant);
+      if (!target) return { success: false, error: `Unknown participant "${participant}".` };
+      if (target.id === conn.dataSource.selfId) {
+        return { success: false, error: "You cannot wait for yourself." };
+      }
+      const readState = async () => {
+        try {
+          const res = await fetch(`${ds.serverUrl}/participants`, {
+            headers: { Authorization: `Bearer ${ds.sessionToken}` },
+            signal: AbortSignal.timeout(1e4)
+          });
+          if (!res.ok) return "unknown";
+          const data = await res.json();
+          const found = data.participants?.find((pp) => pp.id === target.id);
+          const state = found?.agentState;
+          return state === "idle" || state === "working" || state === "blocked" ? state : "unknown";
+        } catch {
+          return "unknown";
+        }
+      };
+      const outcome = await waitForAgent({
+        readState,
+        until,
+        timeoutMs: timeoutSec === void 0 ? void 0 : timeoutSec * 1e3
+      });
+      return { success: true, message: describeOutcome(participant, until ?? "idle", outcome) };
+    },
+    onPing: async (room, participant) => {
+      const conn = processor.resolve(room);
+      if (!conn) return { success: false, error: `Unknown room "${room}".` };
+      const ds = conn.dataSource;
+      const p = conn.dataSource.listParticipants().find((pp) => pp.name === participant);
+      if (!p) return { success: false, error: `Unknown participant "${participant}".` };
+      try {
+        const res = await fetch(`${ds.serverUrl}/ping`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", Authorization: `Bearer ${ds.sessionToken}` },
+          body: JSON.stringify({ participantId: p.id })
+        });
+        if (!res.ok) return { success: false, error: await res.text() };
+        return { success: true };
+      } catch {
+        return { success: false, error: "Server unreachable." };
+      }
+    },
+    onJoinRoom: async (url, alias, nameOverride) => {
+      const token = extractToken(url);
+      let serverUrl;
+      try {
+        const parsed = new URL(url);
+        parsed.search = "";
+        serverUrl = parsed.toString().replace(/\/$/, "");
+      } catch {
+        serverUrl = url.replace(/\/$/, "");
+      }
+      try {
+        const joinName = nameOverride ?? agentName;
+        const joinBody = { type: "agent", name: joinName };
+        if (token) joinBody.token = token;
+        const res = await fetch(`${serverUrl}/join`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(joinBody),
+          signal: AbortSignal.timeout(15e3)
+        });
+        if (!res.ok) return { success: false, error: `Failed to join: ${await res.text()}` };
+        const data = await res.json();
+        const sessionToken = String(data.sessionToken ?? "");
+        const roomName = alias ?? String(data.roomName ?? "");
+        const roomId = String(data.roomId ?? "");
+        const roomAuthority = String(data.authority ?? "member");
+        const participants = data.participants ?? [];
+        const newParticipantId = String(data.participantId ?? "");
+        const dataSource = new RemoteRoomDataSource(serverUrl, sessionToken, roomId);
+        dataSource.setParticipants(participants);
+        dataSource.setSelf(newParticipantId, joinName);
+        if (joinResults.length === 0) {
+          processor.participantId = newParticipantId;
+        }
+        processor.setRoomParticipantId(roomId, newParticipantId);
+        const mode = processor.getModeForRoom(roomId) ?? "everyone";
+        processor.connectRemoteRoom(dataSource, roomName);
+        sseMux.addConnection(serverUrl, sessionToken, roomName, roomId);
+        const jr = {
+          serverUrl,
+          sessionToken,
+          participantId: newParticipantId,
+          roomName,
+          roomId,
+          authority: roomAuthority,
+          participants,
+          dataSource
+        };
+        joinResults.push(jr);
+        const conn = processor.resolve(roomName);
+        let recentLines = [];
+        if (conn) {
+          const catchUp = await buildCatchUpLines(conn, {
+            isEventSeen: (id) => processor.isEventSeen(id),
+            markEventsSeen: (ids) => processor.markEventsSeen(ids),
+            assignRef: (id) => processor.assignRef(id)
+          });
+          recentLines = catchUp.lines;
+        }
+        await onRoomJoined?.();
+        let rules;
+        try {
+          const rulesRes = await fetch(`${serverUrl}/rules`, {
+            headers: { Authorization: `Bearer ${sessionToken}` }
+          });
+          if (rulesRes.ok) {
+            const rulesData = await rulesRes.json();
+            if (Array.isArray(rulesData.rules) && rulesData.rules.length > 0) rules = rulesData.rules;
+          }
+        } catch {
+        }
+        return {
+          success: true,
+          roomName,
+          agentName: joinName,
+          authority: roomAuthority,
+          mode,
+          participants: participants.filter((p) => p.id !== newParticipantId).map((p) => ({ name: p.name, authority: p.authority ?? "member" })),
+          recentLines,
+          rules
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { success: false, error: `Unable to connect. Is the server running? (${serverUrl}) \u2014 ${msg}` };
+      }
+    },
+    onLeaveRoom: async (room) => {
+      const conn = processor.resolve(room);
+      if (!conn) return { success: false, error: `Unknown room "${room}".` };
+      const roomId = conn.dataSource.roomId;
+      const idx = joinResults.findIndex((jr) => jr.roomId === roomId);
+      if (idx >= 0) {
+        const jr = joinResults[idx];
+        sseMux.removeConnection(roomId);
+        processor.disconnectRemoteRoom(roomId);
+        try {
+          await fetch(`${jr.serverUrl}/disconnect`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Authorization: `Bearer ${jr.sessionToken}` },
+            body: JSON.stringify({})
+          });
+        } catch {
+        }
+        joinResults.splice(idx, 1);
+      }
+      return { success: true };
+    },
+    // Admin actions differ only by endpoint + target tier — one helper covers all.
+    onAdminSetModeFor: can(authority, "set_mode_for") ? (room, participant, mode) => adminAction((id) => ({ path: "/set-mode", body: { participantId: id, mode } }))(room, participant) : void 0,
+    onAdminMute: can(authority, "mute") ? adminAction((id) => ({ path: "/set-authority", body: { participantId: id, authority: "guest" } })) : void 0,
+    onAdminUnmute: can(authority, "unmute") ? adminAction((id) => ({ path: "/set-authority", body: { participantId: id, authority: "member" } })) : void 0,
+    onAdminKick: can(authority, "kick") ? adminAction((id) => ({ path: "/kick", body: { participantId: id } })) : void 0,
+    onAdminPromote: can(authority, "promote") ? adminAction((id) => ({ path: "/set-authority", body: { participantId: id, authority: "product_owner" } })) : void 0,
+    onAdminDemote: can(authority, "demote") ? adminAction((id) => ({ path: "/set-authority", body: { participantId: id, authority: "member" } })) : void 0
+  };
+}
+
+export {
+  composerStillHolds,
+  TmuxBridge,
+  buildRuntimeMcpOptions
+};
+//# sourceMappingURL=chunk-36WX2UAF.js.map