@gorlitzer-labs/apiary 1.13.9 → 1.15.0

package/dist/chunk-OEAHTZCA.js

@@ -0,0 +1,994 @@
+import {
+  RemoteRoomDataSource,
+  RoomConnectionError,
+  buildCatchUpLines
+} from "./chunk-Z4J6TRJY.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/rejoin.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function readLocalRoomSession(roomName) {
+  if (!/^[A-Za-z0-9._-]+$/.test(roomName) || roomName.includes("..")) return null;
+  const path = join(homedir(), ".apiary", "sessions", `room_${roomName}.json`);
+  if (!existsSync(path)) return null;
+  try {
+    const data = JSON.parse(readFileSync(path, "utf-8"));
+    const str = (v) => typeof v === "string" && v ? v : void 0;
+    return {
+      serverUrl: str(data.serverUrl),
+      publicUrl: str(data.publicUrl),
+      adminToken: str(data.adminToken),
+      memberToken: str(data.memberToken)
+    };
+  } catch {
+    return null;
+  }
+}
+function isLoopbackUrl(url) {
+  try {
+    const host = new URL(url).hostname;
+    return host === "127.0.0.1" || host === "localhost";
+  } catch {
+    return false;
+  }
+}
+function sameOrigin(a, b) {
+  try {
+    return new URL(a).origin === new URL(b).origin;
+  } catch {
+    return a === b;
+  }
+}
+function localTierOf(shareToken, session) {
+  if (!shareToken || !session) return void 0;
+  if (session.adminToken === shareToken) return "admin";
+  if (session.memberToken === shareToken) return "member";
+  return void 0;
+}
+var RoomRejoiner = class {
+  constructor(room, deps) {
+    this.room = room;
+    this.deps = deps;
+    this.fetchFn = deps.fetch ?? ((...args) => fetch(...args));
+    this.now = deps.now ?? Date.now;
+    this.sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    this.readSession = deps.readRoomSession ?? readLocalRoomSession;
+  }
+  inflight = null;
+  lost = null;
+  failures = 0;
+  cooldownUntil = 0;
+  lastRejoinAt = Number.NEGATIVE_INFINITY;
+  lastProbeAt = Number.NEGATIVE_INFINITY;
+  fetchFn;
+  now;
+  sleep;
+  readSession;
+  /** Why the room is lost for good, if it is. */
+  get lostError() {
+    return this.lost;
+  }
+  // ── SessionRecovery (RemoteRoomDataSource) ─────────────────────────────
+  async sessionInvalid(usedToken) {
+    if (usedToken !== void 0 && usedToken !== this.room.sessionToken) return;
+    await this.rejoin("session token rejected (401)");
+  }
+  async unreachable() {
+    if (this.lost || this.room.removedBy) return false;
+    const now = this.now();
+    if (now - this.lastProbeAt < (this.deps.probeIntervalMs ?? 5e3)) return false;
+    this.lastProbeAt = now;
+    const local = this.readSession(this.room.rejoin.serverRoomName)?.serverUrl;
+    if (!local || !isLoopbackUrl(local) || sameOrigin(local, this.room.serverUrl)) return false;
+    const base = local.replace(/\/$/, "");
+    let res;
+    try {
+      res = await this.fetchFn(`${base}/participants`, {
+        headers: { Authorization: `Bearer ${this.room.sessionToken}` },
+        signal: AbortSignal.timeout(5e3)
+      });
+    } catch {
+      return false;
+    }
+    await res.body?.cancel().catch(() => {
+    });
+    if (res.ok) {
+      const from = this.room.serverUrl;
+      this.swapSession(base, this.room.sessionToken);
+      this.log(`room "${this.room.roomName}": ${from} unreachable, moved to ${base} (same session)`);
+      return true;
+    }
+    if (res.status === 401) {
+      try {
+        await this.rejoin(`${this.room.serverUrl} unreachable`);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+  // ── SseRecoveryHandler (per room) ──────────────────────────────────────
+  async authRejected(status, usedToken) {
+    if (usedToken !== void 0 && usedToken !== this.room.sessionToken) return true;
+    try {
+      await this.rejoin(`event stream rejected (${status})`);
+      return true;
+    } catch (err) {
+      if (err instanceof RoomConnectionError && err.permanent) throw err;
+      return false;
+    }
+  }
+  // ── Re-join ────────────────────────────────────────────────────────────
+  /**
+   * Join the room again and swap the new session in everywhere. Concurrent
+   * callers share one attempt. Throws RoomConnectionError: `permanent` when
+   * retrying cannot help, otherwise after bounded retries.
+   */
+  rejoin(reason) {
+    if (this.lost) return Promise.reject(this.lost);
+    const roomLabel = `"${this.room.roomName}"`;
+    if (this.room.removedBy) return Promise.reject(this.removed());
+    if (this.inflight) return this.inflight;
+    const now = this.now();
+    if (now - this.lastRejoinAt < (this.deps.replacedWindowMs ?? 3e4)) {
+      return Promise.reject(this.loseFor(
+        `Your seat in room ${roomLabel} was taken over again right after apiary re-joined it \u2014 another session is probably using the name "${this.room.rejoin.name}". Not re-joining automatically, so the two do not keep evicting each other. Call join_room to take the seat back.`
+      ));
+    }
+    if (now < this.cooldownUntil) {
+      const secs = Math.ceil((this.cooldownUntil - now) / 1e3);
+      return Promise.reject(new RoomConnectionError(
+        `Lost the session in room ${roomLabel} and the last re-join failed; apiary retries in ${secs}s. If this persists, call join_room again with the room's share URL.`,
+        false
+      ));
+    }
+    this.inflight = this.runRejoin(reason).finally(() => {
+      this.inflight = null;
+    });
+    return this.inflight;
+  }
+  async runRejoin(reason) {
+    const roomLabel = `"${this.room.roomName}"`;
+    this.log(`room ${roomLabel}: ${reason}; re-joining as "${this.room.rejoin.name}"`);
+    const delays = [0, ...this.deps.retryDelaysMs ?? [500, 1500]];
+    let lastError = "";
+    for (const delay of delays) {
+      if (delay > 0) await this.sleep(delay);
+      if (this.room.removedBy) break;
+      const outcome = await this.attemptOnce();
+      if (outcome.permanent) {
+        throw this.loseFor(
+          `Room ${roomLabel} no longer accepts the share link this agent joined with (${outcome.error}). The room was recreated or the link revoked \u2014 ask for a new share URL and call join_room with it.`
+        );
+      }
+      if (outcome.done) {
+        this.failures = 0;
+        this.cooldownUntil = 0;
+        this.lastRejoinAt = this.now();
+        return;
+      }
+      lastError = outcome.error;
+    }
+    if (this.room.removedBy) throw this.removed();
+    this.failures += 1;
+    const cooldown = Math.min(1e3 * 2 ** (this.failures - 1), this.deps.maxCooldownMs ?? 3e4);
+    this.cooldownUntil = this.now() + cooldown;
+    this.log(`room ${roomLabel}: re-join failed (${lastError}); next try in ${Math.ceil(cooldown / 1e3)}s`);
+    throw new RoomConnectionError(
+      `Lost the session in room ${roomLabel} (${reason}) and could not re-join yet: ${lastError}. apiary keeps retrying; if this persists, call join_room again with the room's share URL.`,
+      false
+    );
+  }
+  /** One pass over the candidate addresses and tokens. */
+  async attemptOnce() {
+    const info = this.room.rejoin;
+    const candidates = [
+      { url: this.room.serverUrl, shareToken: info.shareToken }
+    ];
+    const session = this.readSession(info.serverRoomName);
+    const local = session?.serverUrl && isLoopbackUrl(session.serverUrl) ? session.serverUrl.replace(/\/$/, "") : void 0;
+    if (local && !sameOrigin(local, this.room.serverUrl)) {
+      candidates.push({ url: local, shareToken: info.shareToken });
+    }
+    const fresh = info.localTier === "admin" ? session?.adminToken : info.localTier === "member" ? session?.memberToken : void 0;
+    if (local && fresh && fresh !== info.shareToken) {
+      candidates.push({ url: local, shareToken: fresh });
+    }
+    let shareRejected = "";
+    let transient = "";
+    let unreachable = "";
+    for (const c of candidates) {
+      const r = await this.joinAt(c.url, c.shareToken);
+      if (r.ok) {
+        this.apply(r.url, r.shareToken, r.data);
+        return { done: true, permanent: false, error: "" };
+      }
+      if (r.kind === "share-rejected") shareRejected = r.error;
+      else if (r.kind === "unreachable") unreachable ||= r.error;
+      else transient ||= r.error;
+    }
+    if (shareRejected && !transient) return { done: false, permanent: true, error: shareRejected };
+    return { done: false, permanent: false, error: transient || unreachable || shareRejected || "no address answered" };
+  }
+  async joinAt(url, shareToken) {
+    const body = { type: this.room.rejoin.type, name: this.room.rejoin.name };
+    if (shareToken) body.token = shareToken;
+    let res;
+    try {
+      res = await this.fetchFn(`${url}/join`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(1e4)
+      });
+    } catch (err) {
+      return { ok: false, kind: "unreachable", error: `${url} unreachable (${err instanceof Error ? err.message : String(err)})` };
+    }
+    if (!res.ok) {
+      const text = (await res.text().catch(() => "")).slice(0, 200);
+      if (res.status === 403 && /invalid share token/i.test(text)) {
+        return { ok: false, kind: "share-rejected", error: `403 Invalid share token at ${url}` };
+      }
+      return { ok: false, kind: "transient", error: `${res.status} from ${url}/join${text ? `: ${text}` : ""}` };
+    }
+    const data = await res.json().catch(() => ({}));
+    if (String(data.roomName ?? "") !== this.room.rejoin.serverRoomName || String(data.roomId ?? "") !== this.room.roomId) {
+      await this.fetchFn(`${url}/disconnect`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${String(data.sessionToken ?? "")}` },
+        body: "{}"
+      }).catch(() => {
+      });
+      return { ok: false, kind: "wrong-room", error: `${url} serves a different room (${String(data.roomName ?? "?")})` };
+    }
+    return { ok: true, url, shareToken, data };
+  }
+  /** Swap the new session into the JoinResult, data source, processor and SSE stream. */
+  apply(url, shareToken, data) {
+    const room = this.room;
+    const oldId = room.participantId;
+    const token = String(data.sessionToken ?? "");
+    const newId = String(data.participantId ?? "");
+    const participants = data.participants ?? [];
+    room.participantId = newId;
+    room.authority = String(data.authority ?? room.authority);
+    room.participants = participants;
+    if (shareToken !== void 0) room.rejoin.shareToken = shareToken;
+    room.dataSource.setParticipants(participants);
+    room.dataSource.setSelf(newId, room.rejoin.name);
+    const { processor } = this.deps;
+    processor.setRoomParticipantId(room.roomId, newId);
+    if (processor.participantId === oldId) processor.participantId = newId;
+    this.swapSession(url, token);
+    this.log(`room "${room.roomName}": re-joined as "${room.rejoin.name}" at ${url}`);
+    const mode = processor.getModeForRoom(room.roomId);
+    if (mode !== "everyone") {
+      this.fetchFn(`${url}/set-mode`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+        body: JSON.stringify({ mode })
+      }).catch(() => {
+      });
+    }
+  }
+  swapSession(url, token) {
+    this.room.serverUrl = url;
+    this.room.sessionToken = token;
+    this.room.dataSource.setSession(url, token);
+    this.deps.sseMux.updateConnection(this.room.roomId, url, token);
+  }
+  removed() {
+    return this.loseFor(
+      `You were removed from room "${this.room.roomName}" by ${this.room.removedBy}, so apiary will not re-join it. Call join_room again only if you are invited back.`
+    );
+  }
+  loseFor(message) {
+    if (!this.lost) {
+      this.lost = new RoomConnectionError(message, true);
+      this.log(`room "${this.room.roomName}": giving up \u2014 ${message}`);
+      try {
+        this.deps.onLost?.(this.room, this.lost);
+      } catch {
+      }
+    }
+    return this.lost;
+  }
+  log(line) {
+    this.deps.log?.(line);
+  }
+};
+
+// src/cli/runtime-handlers.ts
+function trackRoomEvent(jr, event) {
+  if (event.type === "ParticipantJoined") {
+    jr.dataSource.addParticipant(event.participant);
+  } else if (event.type === "ParticipantLeft") {
+    jr.dataSource.removeParticipant(event.participant_id);
+  } else if (event.type === "ParticipantKicked") {
+    if (event.participant_id === jr.participantId) jr.removedBy = safeName(event.kicked_by);
+    jr.dataSource.removeParticipant(event.participant_id);
+  }
+}
+function safeName(name) {
+  return String(name ?? "").replace(/[^A-Za-z0-9 _.-]/g, "").trim().slice(0, 40) || "an admin";
+}
+function buildRuntimeMcpOptions(ctx) {
+  const { processor, sseMux, joinResults, agentName, authority, onRoomJoined } = ctx;
+  const rejoinerFor = (roomId) => joinResults.find((j) => j.roomId === roomId)?.rejoiner;
+  sseMux.setRecoveryHandler({
+    authRejected: async (roomId, status, usedToken) => {
+      const r = rejoinerFor(roomId);
+      return r ? r.authRejected(status, usedToken) : false;
+    },
+    unreachable: async (roomId) => await rejoinerFor(roomId)?.unreachable() ?? false
+  });
+  const post = async (ds, path, body) => {
+    try {
+      const res = await ds.request(path, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) return { success: false, error: await res.text() };
+      return { success: true };
+    } catch (err) {
+      const msg = err instanceof Error && err.name === "RoomConnectionError" ? err.message : "Server unreachable.";
+      return { success: false, error: msg };
+    }
+  };
+  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);
+    return post(ds, path, body);
+  };
+  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);
+      const result = await post(conn.dataSource, "/set-mode", { mode });
+      if (!result.success && result.error !== "Server unreachable.") {
+        return { success: false, error: `Server rejected: ${result.error}` };
+      }
+      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 ds.request("/participants", { 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}".` };
+      return post(ds, "/ping", { participantId: p.id });
+    },
+    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 existingIdx = joinResults.findIndex((j) => j.roomId === roomId);
+        if (existingIdx >= 0) {
+          sseMux.removeConnection(roomId);
+          processor.disconnectRemoteRoom(roomId);
+          joinResults.splice(existingIdx, 1);
+        }
+        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 serverRoomName = String(data.roomName ?? "");
+        const jr = {
+          serverUrl,
+          sessionToken,
+          participantId: newParticipantId,
+          roomName,
+          roomId,
+          authority: roomAuthority,
+          participants,
+          dataSource,
+          rejoin: {
+            joinUrl: url,
+            shareToken: token ?? void 0,
+            name: joinName,
+            type: "agent",
+            serverRoomName,
+            localTier: localTierOf(
+              token ?? void 0,
+              (ctx.rejoinOverrides?.readRoomSession ?? readLocalRoomSession)(serverRoomName)
+            )
+          }
+        };
+        jr.rejoiner = new RoomRejoiner(jr, {
+          ...ctx.rejoinOverrides,
+          sseMux,
+          processor,
+          log: ctx.log,
+          onLost: ctx.onRoomLost ? (_room, err) => ctx.onRoomLost(jr, err) : void 0
+        });
+        dataSource.setRecovery(jr.rejoiner);
+        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];
+        jr.dataSource.setRecovery(null);
+        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,
+  trackRoomEvent,
+  buildRuntimeMcpOptions
+};
+//# sourceMappingURL=chunk-OEAHTZCA.js.map