stoops 0.1.0 → 0.2.0

package/dist/cli/index.js

@@ -0,0 +1,2468 @@
+#!/usr/bin/env node
+import {
+  InMemoryStorage,
+  Room,
+  randomName,
+  randomRoomName
+} from "../chunk-LC5WPWR2.js";
+import {
+  EventProcessor,
+  RemoteRoomDataSource,
+  SseMultiplexer
+} from "../chunk-SS5NGUJM.js";
+import "../chunk-5ADJGMXQ.js";
+import {
+  buildCatchUpLines,
+  contentPartsToString,
+  createRuntimeMcpServer,
+  formatTimestamp
+} from "../chunk-BLGV3QN4.js";
+import {
+  createEvent
+} from "../chunk-HQS7HBZR.js";
+
+// src/cli/serve.ts
+import { createServer } from "http";
+import { spawn, execFileSync } from "child_process";
+import { randomUUID } from "crypto";
+import { createRequire } from "module";
+
+// src/cli/auth.ts
+import { randomBytes } from "crypto";
+var TokenManager = class {
+  /** share token hash → authority level */
+  _shareTokens = /* @__PURE__ */ new Map();
+  /** session token → participant data */
+  _sessionTokens = /* @__PURE__ */ new Map();
+  /**
+   * Generate a share token at the given authority tier.
+   * Callers can only generate tokens at their own tier or below.
+   */
+  generateShareToken(callerAuthority, targetAuthority) {
+    if (!canGrant(callerAuthority, targetAuthority)) return null;
+    const token = randomBytes(16).toString("hex");
+    this._shareTokens.set(token, targetAuthority);
+    return token;
+  }
+  /** Validate a share token and return its authority level. */
+  validateShareToken(token) {
+    return this._shareTokens.get(token) ?? null;
+  }
+  /** Create a session token for a participant. */
+  createSessionToken(participantId, authority) {
+    const token = randomBytes(16).toString("hex");
+    this._sessionTokens.set(token, { participantId, authority });
+    return token;
+  }
+  /** Validate a session token and return participant data. */
+  validateSessionToken(token) {
+    return this._sessionTokens.get(token) ?? null;
+  }
+  /** Revoke a session token (on disconnect). */
+  revokeSessionToken(token) {
+    this._sessionTokens.delete(token);
+  }
+  /** Update the authority level for an existing session. */
+  updateSessionAuthority(token, newAuthority) {
+    const data = this._sessionTokens.get(token);
+    if (!data) return false;
+    data.authority = newAuthority;
+    return true;
+  }
+  /** Find a session token by participant ID (for cleanup). */
+  findSessionByParticipant(participantId) {
+    for (const [token, data] of this._sessionTokens) {
+      if (data.participantId === participantId) return token;
+    }
+    return null;
+  }
+};
+var TIER_ORDER = {
+  admin: 2,
+  participant: 1,
+  observer: 0
+};
+function canGrant(callerLevel, targetLevel) {
+  return TIER_ORDER[callerLevel] >= TIER_ORDER[targetLevel];
+}
+function buildShareUrl(baseUrl, token) {
+  const url = new URL(baseUrl);
+  url.searchParams.set("token", token);
+  return url.toString();
+}
+function extractToken(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.searchParams.get("token");
+  } catch {
+    return null;
+  }
+}
+
+// src/cli/serve.ts
+async function enrichAndSend(res, event, room) {
+  if (event.type === "MessageSent" && event.message.reply_to_id) {
+    const replyMsg = await room.getMessage(event.message.reply_to_id);
+    const enriched = {
+      ...event,
+      _replyToName: replyMsg?.sender_name ?? null
+    };
+    res.write(`data: ${JSON.stringify(enriched)}
+
+`);
+    return;
+  }
+  res.write(`data: ${JSON.stringify(event)}
+
+`);
+}
+async function serve(options) {
+  const roomName = options.room ?? randomRoomName();
+  const port = options.port ?? 7890;
+  const serverUrl = `http://127.0.0.1:${port}`;
+  const log = options.headless ? () => {
+  } : logServer;
+  let publicUrl = serverUrl;
+  let tunnelProcess = null;
+  const storage = new InMemoryStorage();
+  const room = new Room(roomName, storage);
+  const tokens = new TokenManager();
+  const participants = /* @__PURE__ */ new Map();
+  const observers = /* @__PURE__ */ new Map();
+  const idToSession = /* @__PURE__ */ new Map();
+  const sseConnections = /* @__PURE__ */ new Map();
+  async function parseBody(req) {
+    const chunks = [];
+    for await (const chunk of req) chunks.push(chunk);
+    try {
+      return JSON.parse(Buffer.concat(chunks).toString());
+    } catch {
+      return {};
+    }
+  }
+  function getSession(token) {
+    if (!token) return null;
+    const p = participants.get(token);
+    if (p) return { ...p, kind: "participant" };
+    const o = observers.get(token);
+    if (o) return { ...o, kind: "observer" };
+    return null;
+  }
+  function jsonError(res, status, error) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error }));
+  }
+  function jsonOk(res, data = {}) {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: true, ...data }));
+  }
+  const httpServer = createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+    if (url.pathname === "/events" && (req.method === "GET" || req.method === "POST")) {
+      const authHeader = req.headers.authorization;
+      const sessionToken = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null;
+      const session = getSession(sessionToken);
+      if (!session) {
+        jsonError(res, 401, "Invalid session token");
+        return;
+      }
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+        "Access-Control-Allow-Origin": "*"
+      });
+      res.flushHeaders();
+      sseConnections.set(session.id, res);
+      const history = await room.listEvents(void 0, 50);
+      for (const event of [...history.items].reverse()) {
+        await enrichAndSend(res, event, room);
+      }
+      const streamEvents = async () => {
+        try {
+          for await (const event of session.channel) {
+            await enrichAndSend(res, event, room);
+          }
+        } catch {
+        }
+      };
+      streamEvents();
+      req.on("close", () => {
+        sseConnections.delete(session.id);
+      });
+      return;
+    }
+    if (req.method === "GET") {
+      const sessionToken = url.searchParams.get("token");
+      const session = getSession(sessionToken);
+      if (url.pathname === "/participants") {
+        if (!session) return jsonError(res, 401, "Invalid session token");
+        const list = room.listParticipants().map((p) => ({
+          id: p.id,
+          name: p.name,
+          type: p.type,
+          authority: p.authority ?? "participant"
+        }));
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ participants: list }));
+        return;
+      }
+      if (url.pathname.startsWith("/message/")) {
+        if (!session) return jsonError(res, 401, "Invalid session token");
+        const messageId = url.pathname.slice("/message/".length);
+        const msg = await room.getMessage(messageId);
+        if (!msg) return jsonError(res, 404, "Message not found");
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ message: msg }));
+        return;
+      }
+      if (url.pathname === "/messages") {
+        if (!session) return jsonError(res, 401, "Invalid session token");
+        const count = parseInt(url.searchParams.get("count") ?? "30", 10);
+        const cursor = url.searchParams.get("cursor") ?? null;
+        const result = await room.listMessages(count, cursor);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(result));
+        return;
+      }
+      if (url.pathname === "/events/history") {
+        if (!session) return jsonError(res, 401, "Invalid session token");
+        const category = url.searchParams.get("category") ?? null;
+        const count = parseInt(url.searchParams.get("count") ?? "50", 10);
+        const cursor = url.searchParams.get("cursor") ?? null;
+        const result = await room.listEvents(category, count, cursor);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(result));
+        return;
+      }
+      if (url.pathname === "/search") {
+        if (!session) return jsonError(res, 401, "Invalid session token");
+        const query = url.searchParams.get("query") ?? "";
+        if (!query) return jsonError(res, 400, "Missing query parameter");
+        const count = parseInt(url.searchParams.get("count") ?? "10", 10);
+        const cursor = url.searchParams.get("cursor") ?? null;
+        const result = await room.searchMessages(query, count, cursor);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(result));
+        return;
+      }
+    }
+    if (req.method === "POST") {
+      const body = await parseBody(req);
+      if (url.pathname === "/join") {
+        const shareToken = String(body.token ?? "");
+        const legacyType = String(body.type ?? "");
+        let authority;
+        if (shareToken) {
+          const tokenAuthority = tokens.validateShareToken(shareToken);
+          if (!tokenAuthority) return jsonError(res, 403, "Invalid share token");
+          authority = tokenAuthority;
+        } else if (legacyType === "guest") {
+          authority = "observer";
+        } else if (legacyType === "human") {
+          authority = "participant";
+        } else {
+          authority = "participant";
+        }
+        const participantType = String(body.type ?? "human");
+        const name = String(body.name ?? randomName());
+        if (authority === "observer") {
+          const id2 = `obs_${randomUUID().slice(0, 8)}`;
+          const channel2 = room.observe();
+          const sessionToken3 = tokens.createSessionToken(id2, "observer");
+          observers.set(sessionToken3, { id: id2, authority: "observer", channel: channel2, sessionToken: sessionToken3 });
+          idToSession.set(id2, sessionToken3);
+          const participantList2 = room.listParticipants().map((p) => ({
+            id: p.id,
+            name: p.name,
+            type: p.type,
+            authority: p.authority ?? "participant"
+          }));
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            sessionToken: sessionToken3,
+            participantId: id2,
+            roomName,
+            roomId: room.roomId,
+            participants: participantList2,
+            authority: "observer"
+          }));
+          return;
+        }
+        const id = `${participantType}_${randomUUID().slice(0, 8)}`;
+        const channel = await room.connect(id, name, { type: participantType, authority });
+        const sessionToken2 = tokens.createSessionToken(id, authority);
+        participants.set(sessionToken2, { id, name, authority, channel, sessionToken: sessionToken2 });
+        idToSession.set(id, sessionToken2);
+        const participantList = room.listParticipants().map((p) => ({
+          id: p.id,
+          name: p.name,
+          type: p.type,
+          authority: p.authority ?? "participant"
+        }));
+        log(`${name} joined (${authority})`);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          sessionToken: sessionToken2,
+          participantId: id,
+          roomName,
+          roomId: room.roomId,
+          participants: participantList,
+          authority
+        }));
+        return;
+      }
+      const sessionToken = String(body.token ?? "");
+      const session = getSession(sessionToken);
+      if (url.pathname === "/message") {
+        if (!session) return jsonError(res, 401, "Invalid session token");
+        if (session.authority === "observer") return jsonError(res, 403, "Observers cannot send messages");
+        const content = String(body.content ?? "");
+        const replyTo = body.replyTo ? String(body.replyTo) : void 0;
+        if (!content) return jsonError(res, 400, "Empty message");
+        const p = participants.get(sessionToken);
+        if (!p) return jsonError(res, 403, "Not a participant");
+        const msg = await p.channel.sendMessage(content, replyTo);
+        jsonOk(res, { messageId: msg.id });
+        return;
+      }
+      if (url.pathname === "/event") {
+        if (!session) return jsonError(res, 401, "Invalid session token");
+        if (session.authority === "observer") return jsonError(res, 403, "Observers cannot emit events");
+        const event = body.event;
+        if (!event) return jsonError(res, 400, "Missing event");
+        const p = participants.get(sessionToken);
+        if (!p) return jsonError(res, 403, "Not a participant");
+        await p.channel.emit(event);
+        jsonOk(res);
+        return;
+      }
+      if (url.pathname === "/set-mode") {
+        if (!session) return jsonError(res, 401, "Invalid session token");
+        const targetId = body.participantId ? String(body.participantId) : session.id;
+        const mode = String(body.mode ?? "");
+        if (!mode) return jsonError(res, 400, "Missing mode");
+        if (targetId !== session.id && session.authority !== "admin") {
+          return jsonError(res, 403, "Only admins can change other participants' modes");
+        }
+        const p = participants.get(sessionToken);
+        if (!p) return jsonError(res, 403, "Not a participant");
+        await p.channel.emit(createEvent({
+          type: "Activity",
+          category: "ACTIVITY",
+          room_id: room.roomId,
+          participant_id: targetId,
+          action: "mode_changed",
+          detail: { mode }
+        }));
+        jsonOk(res);
+        return;
+      }
+      if (url.pathname === "/set-authority") {
+        if (!session) return jsonError(res, 401, "Invalid session token");
+        if (session.authority !== "admin") return jsonError(res, 403, "Only admins can change authority");
+        const targetId = String(body.participantId ?? "");
+        const newAuthority = String(body.authority ?? "");
+        if (!targetId) return jsonError(res, 400, "Missing participantId");
+        if (!["admin", "participant", "observer"].includes(newAuthority)) {
+          return jsonError(res, 400, "Invalid authority. Must be admin, participant, or observer.");
+        }
+        if (targetId === session.id) return jsonError(res, 400, "Cannot change own authority");
+        const targetSession = idToSession.get(targetId);
+        if (!targetSession) return jsonError(res, 404, "Participant not found");
+        const target = participants.get(targetSession);
+        if (!target) return jsonError(res, 404, "Participant not found");
+        target.authority = newAuthority;
+        tokens.updateSessionAuthority(targetSession, newAuthority);
+        room.setParticipantAuthority(targetId, newAuthority);
+        const p = participants.get(sessionToken);
+        if (p) {
+          await p.channel.emit(createEvent({
+            type: "Activity",
+            category: "ACTIVITY",
+            room_id: room.roomId,
+            participant_id: targetId,
+            action: "authority_changed",
+            detail: { authority: newAuthority }
+          }));
+        }
+        log(`${target.name} authority \u2192 ${newAuthority}`);
+        jsonOk(res);
+        return;
+      }
+      if (url.pathname === "/kick") {
+        if (!session) return jsonError(res, 401, "Invalid session token");
+        if (session.authority !== "admin") return jsonError(res, 403, "Only admins can kick");
+        const targetId = String(body.participantId ?? "");
+        if (!targetId) return jsonError(res, 400, "Missing participantId");
+        const targetSession = idToSession.get(targetId);
+        if (targetSession) {
+          const target = participants.get(targetSession) ?? observers.get(targetSession);
+          if (target) {
+            await target.channel.disconnect();
+            participants.delete(targetSession);
+            observers.delete(targetSession);
+            idToSession.delete(targetId);
+            tokens.revokeSessionToken(targetSession);
+            const sse = sseConnections.get(targetId);
+            if (sse) {
+              sse.end();
+              sseConnections.delete(targetId);
+            }
+            log(`kicked ${targetId}`);
+          }
+        }
+        jsonOk(res);
+        return;
+      }
+      if (url.pathname === "/share") {
+        if (!session) return jsonError(res, 401, "Invalid session token");
+        if (session.authority === "observer") return jsonError(res, 403, "Observers cannot create share links");
+        const targetAuthority = body.authority ?? void 0;
+        const links = {};
+        if (targetAuthority) {
+          const token = tokens.generateShareToken(session.authority, targetAuthority);
+          if (!token) return jsonError(res, 403, `Cannot generate ${targetAuthority} link`);
+          links[targetAuthority] = buildShareUrl(publicUrl, token);
+        } else {
+          const tiers = ["admin", "participant", "observer"];
+          for (const tier of tiers) {
+            const token = tokens.generateShareToken(session.authority, tier);
+            if (token) links[tier] = buildShareUrl(publicUrl, token);
+          }
+        }
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ links }));
+        return;
+      }
+      if (url.pathname === "/disconnect") {
+        const token = String(body.token ?? "");
+        const legacyId = String(body.participantId ?? body.agentId ?? "");
+        let targetToken = token;
+        if (!targetToken && legacyId) {
+          targetToken = idToSession.get(legacyId) ?? "";
+        }
+        if (targetToken) {
+          const p = participants.get(targetToken);
+          if (p) {
+            await p.channel.disconnect();
+            participants.delete(targetToken);
+            idToSession.delete(p.id);
+            tokens.revokeSessionToken(targetToken);
+            const sse = sseConnections.get(p.id);
+            if (sse) {
+              sse.end();
+              sseConnections.delete(p.id);
+            }
+            log(`${p.name} disconnected`);
+          }
+          const o = observers.get(targetToken);
+          if (o) {
+            await o.channel.disconnect();
+            observers.delete(targetToken);
+            idToSession.delete(o.id);
+            tokens.revokeSessionToken(targetToken);
+            const sse = sseConnections.get(o.id);
+            if (sse) {
+              sse.end();
+              sseConnections.delete(o.id);
+            }
+          }
+        }
+        jsonOk(res);
+        return;
+      }
+    }
+    res.writeHead(404).end("Not found");
+  });
+  httpServer.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.error(`
+Port ${port} is already in use. Another stoops instance may be running.`);
+      console.error(`  Kill it:   lsof -ti :${port} | xargs kill`);
+      console.error(`  Or use:    stoops --port ${port + 1}
+`);
+      process.exit(1);
+    }
+    throw err;
+  });
+  await new Promise((resolve) => {
+    httpServer.listen(port, "0.0.0.0", () => resolve());
+  });
+  if (options.share) {
+    tunnelProcess = await startTunnel(port);
+    if (tunnelProcess) {
+      const tunnelUrl = await waitForTunnelUrl(tunnelProcess);
+      if (tunnelUrl) publicUrl = tunnelUrl;
+    }
+  }
+  const adminToken = tokens.generateShareToken("admin", "admin");
+  const participantToken = tokens.generateShareToken("admin", "participant");
+  if (options.headless) {
+    process.stdout.write(JSON.stringify({ serverUrl, publicUrl, roomName, adminToken, participantToken }) + "\n");
+  } else if (!options.quiet) {
+    let version = process.env.npm_package_version ?? "";
+    if (!version) {
+      try {
+        const require2 = createRequire(import.meta.url);
+        const pkg = require2("../../package.json");
+        version = pkg.version ?? "unknown";
+      } catch {
+        version = "unknown";
+      }
+    }
+    const adminUrl = buildShareUrl(publicUrl, adminToken);
+    const joinUrl = buildShareUrl(publicUrl, participantToken);
+    console.log(`
+  stoops v${version}
+
+  Room:    ${roomName}
+  Server:  ${serverUrl}${publicUrl !== serverUrl ? `
+  Tunnel:  ${publicUrl}` : ""}
+
+  Join:      stoops join ${joinUrl}
+  Admin:     stoops join ${adminUrl}
+  Claude:    stoops run claude  \u2192  then tell agent to join: ${joinUrl}
+`);
+  }
+  const shutdown = async () => {
+    log("shutting down...");
+    if (tunnelProcess) {
+      tunnelProcess.kill();
+      tunnelProcess = null;
+    }
+    for (const [id, sse] of sseConnections) {
+      sse.end();
+      sseConnections.delete(id);
+    }
+    for (const p of participants.values()) {
+      await p.channel.disconnect().catch(() => {
+      });
+    }
+    for (const o of observers.values()) {
+      await o.channel.disconnect().catch(() => {
+      });
+    }
+    await new Promise((resolve, reject) => {
+      httpServer.close((err) => err ? reject(err) : resolve());
+    });
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  return { serverUrl, publicUrl, roomName, adminToken, participantToken };
+}
+function logServer(message) {
+  console.log(`  [${formatTimestamp(/* @__PURE__ */ new Date())}] ${message}`);
+}
+function cloudflaredAvailable() {
+  try {
+    execFileSync("which", ["cloudflared"], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function startTunnel(port) {
+  if (!cloudflaredAvailable()) {
+    console.error("  --share requires cloudflared. Install: brew install cloudflared");
+    return null;
+  }
+  const child = spawn("cloudflared", ["tunnel", "--url", `http://localhost:${port}`], {
+    stdio: ["ignore", "ignore", "pipe"]
+  });
+  child.on("error", () => {
+  });
+  return child;
+}
+function waitForTunnelUrl(child, timeoutMs = 15e3) {
+  return new Promise((resolve) => {
+    let resolved = false;
+    let buffer = "";
+    const timer = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        resolve(null);
+      }
+    }, timeoutMs);
+    child.stderr?.on("data", (chunk) => {
+      buffer += chunk.toString();
+      const match = buffer.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/);
+      if (match && !resolved) {
+        resolved = true;
+        clearTimeout(timer);
+        resolve(match[0]);
+      }
+    });
+    child.on("exit", () => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timer);
+        resolve(null);
+      }
+    });
+  });
+}
+
+// src/cli/join.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { createInterface } from "readline";
+
+// src/cli/tui.tsx
+import React, { useState, useEffect, useCallback, useMemo } from "react";
+import { render, Box, Text, Static, useStdout, useInput } from "ink";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var C = {
+  cyan: "#00d4ff",
+  purple: "#8b5cf6",
+  orange: "#ff8c42",
+  pink: "#f472b6",
+  green: "#34d399",
+  yellow: "#fbbf24",
+  danger: "#f87171",
+  text: "#eceff4",
+  secondary: "#b0b7c4",
+  dim: "#7e8798",
+  muted: "#5b6679",
+  border: "#475264"
+};
+var AGENT_COLORS = [C.cyan, C.purple, C.orange, C.pink, C.green, C.yellow];
+var SIGILS = ["\u25C6", "\u25B2", "\u25CF", "\u25A0", "\u2605", "\u25C9", "\u25C8", "\u25B8"];
+var BANNER_LINES = [
+  "         __                        ",
+  "   _____/ /_____  ____  ____  _____",
+  "  / ___/ __/ __ \\/ __ \\/ __ \\/ ___/",
+  " (__  ) /_/ /_/ / /_/ / /_/ (__  ) ",
+  "/____/\\__/\\____/\\____/ .___/____/  ",
+  "                    /_/            "
+];
+var GRADIENT = ["#9b6dff", "#7c8bff", "#5da8ff", "#3dc4ff", "#1ddcff", "#00e8ff"];
+var ENGAGEMENT_MODES = [
+  "everyone",
+  "people",
+  "agents",
+  "me",
+  "standby-everyone",
+  "standby-people",
+  "standby-agents",
+  "standby-me"
+];
+var SLASH_COMMANDS = [
+  { name: "/who", description: "List participants" },
+  { name: "/leave", description: "Disconnect and exit" },
+  { name: "/share", description: "Generate share links" },
+  { name: "/kick", description: "Remove a participant", adminOnly: true, params: [
+    { label: "name", completions: "participants" }
+  ] },
+  { name: "/mute", description: "Make read-only (observer)", adminOnly: true, params: [
+    { label: "name", completions: "participants" }
+  ] },
+  { name: "/unmute", description: "Restore to participant", adminOnly: true, params: [
+    { label: "name", completions: "participants" }
+  ] },
+  { name: "/setmode", description: "Set engagement mode", adminOnly: true, params: [
+    { label: "name", completions: "participants" },
+    { label: "mode", completions: ENGAGEMENT_MODES }
+  ] }
+];
+var CMD_DISPLAY_COL = 26;
+function seedHash(s) {
+  let h = 0;
+  for (let i = 0; i < s.length; i++) h = (h << 5) - h + s.charCodeAt(i) | 0;
+  return Math.abs(h);
+}
+function makeIdentityAssigner() {
+  const map = /* @__PURE__ */ new Map();
+  let colorIdx = 0;
+  return (name) => {
+    if (!map.has(name)) {
+      const h = seedHash(name);
+      map.set(name, {
+        color: AGENT_COLORS[colorIdx++ % AGENT_COLORS.length],
+        sigil: SIGILS[h % SIGILS.length]
+      });
+    }
+    return map.get(name);
+  };
+}
+var NAME_COL = 12;
+function EventLine({
+  event,
+  identify
+}) {
+  const ts = /* @__PURE__ */ jsxs(Text, { color: C.muted, children: [
+    event.ts,
+    "  "
+  ] });
+  if (event.kind === "message") {
+    const { color, sigil } = identify(event.senderName);
+    const isSelf = event.isSelf;
+    const nameColor = isSelf ? C.text : event.senderType === "agent" ? color : C.secondary;
+    const sigilColor = isSelf ? C.dim : event.senderType === "agent" ? color : C.dim;
+    const sigilChar = isSelf ? "\u203A" : event.senderType === "agent" ? sigil : "\xB7";
+    const contentColor = isSelf ? C.text : C.secondary;
+    return /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+      /* @__PURE__ */ jsxs(Box, { flexShrink: 0, children: [
+        ts,
+        /* @__PURE__ */ jsxs(Text, { color: sigilColor, children: [
+          sigilChar,
+          " "
+        ] }),
+        /* @__PURE__ */ jsx(Text, { color: nameColor, bold: isSelf, children: event.senderName.slice(0, NAME_COL).padEnd(NAME_COL) }),
+        /* @__PURE__ */ jsx(Text, { children: "  " })
+      ] }),
+      /* @__PURE__ */ jsx(Box, { flexGrow: 1, flexShrink: 1, children: /* @__PURE__ */ jsxs(Text, { wrap: "wrap", children: [
+        event.replyToName && /* @__PURE__ */ jsxs(Text, { color: C.dim, children: [
+          "\u2192 ",
+          event.replyToName,
+          " "
+        ] }),
+        /* @__PURE__ */ jsx(Text, { color: contentColor, children: event.content })
+      ] }) })
+    ] });
+  }
+  if (event.kind === "join") {
+    const isAgent = event.participantType === "agent";
+    const { color, sigil } = isAgent ? identify(event.name) : { color: C.dim, sigil: "\xB7" };
+    return /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+      ts,
+      /* @__PURE__ */ jsxs(Text, { color: isAgent ? color : C.dim, children: [
+        sigil,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx(Text, { color: isAgent ? color : C.dim, children: event.name }),
+      /* @__PURE__ */ jsx(Text, { color: C.green, children: " joined" })
+    ] });
+  }
+  if (event.kind === "leave") {
+    const isAgent = event.participantType === "agent";
+    const { color: nameColor } = isAgent ? identify(event.name) : { color: C.muted };
+    return /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+      ts,
+      /* @__PURE__ */ jsx(Text, { color: C.muted, children: "\xB7 " }),
+      /* @__PURE__ */ jsx(Text, { color: nameColor, children: event.name }),
+      /* @__PURE__ */ jsx(Text, { color: C.danger, children: " left" })
+    ] });
+  }
+  if (event.kind === "mode") {
+    return /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+      ts,
+      /* @__PURE__ */ jsx(Text, { color: C.dim, children: "mode \u2192 " }),
+      /* @__PURE__ */ jsx(Text, { color: C.yellow, bold: true, children: event.mode })
+    ] });
+  }
+  if (event.kind === "system") {
+    return /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+      ts,
+      /* @__PURE__ */ jsx(Text, { color: C.dim, children: "  " }),
+      /* @__PURE__ */ jsx(Text, { color: C.secondary, children: event.content })
+    ] });
+  }
+  return null;
+}
+function App({
+  roomName,
+  onSend,
+  onCtrlC,
+  onReady,
+  readOnly,
+  isAdmin
+}) {
+  const [events, setEvents] = useState([]);
+  const [agentNames, setAgentNames] = useState([]);
+  const [participants, setParticipants] = useState([]);
+  const [input, setInput] = useState("");
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const { stdout } = useStdout();
+  const identify = useMemo(makeIdentityAssigner, []);
+  const push = useCallback((event) => {
+    setEvents((prev) => [...prev, event]);
+  }, []);
+  useEffect(() => {
+    onReady({ push, setAgentNames, setParticipants });
+  }, []);
+  const suggestionState = useMemo(() => {
+    const mentionMatch = input.match(/@([a-zA-Z0-9_-]*)$/);
+    if (mentionMatch && participants.length > 0) {
+      const prefix = mentionMatch[1].toLowerCase();
+      const filtered2 = participants.filter((p) => p.toLowerCase().startsWith(prefix));
+      if (filtered2.length > 0) {
+        const before = input.slice(0, mentionMatch.index);
+        const items2 = filtered2.map((p) => ({
+          kind: "mention",
+          value: p,
+          insert: before + "@" + p + " "
+        }));
+        const ghostHint2 = prefix.length === 0 ? "" : filtered2[0].slice(prefix.length);
+        return { items: items2, ghostHint: ghostHint2 };
+      }
+    }
+    if (!input.startsWith("/")) return { items: [], ghostHint: "" };
+    const spaceIdx = input.indexOf(" ");
+    if (spaceIdx === -1) {
+      const prefix = input.toLowerCase();
+      const items2 = SLASH_COMMANDS.filter((cmd2) => {
+        if (cmd2.adminOnly && !isAdmin) return false;
+        return cmd2.name.startsWith(prefix);
+      }).map((cmd2) => ({
+        kind: "command",
+        cmd: cmd2,
+        insert: cmd2.name + " "
+      }));
+      return { items: items2, ghostHint: "" };
+    }
+    const cmdName = input.slice(0, spaceIdx).toLowerCase();
+    const cmd = SLASH_COMMANDS.find((c) => c.name === cmdName && (!c.adminOnly || isAdmin));
+    if (!cmd?.params) return { items: [], ghostHint: "" };
+    const rest = input.slice(spaceIdx + 1);
+    const words = rest.split(/\s+/);
+    const hasTrailingSpace = rest.endsWith(" ") || rest === "";
+    const completedCount = hasTrailingSpace ? words.filter(Boolean).length : Math.max(0, words.length - 1);
+    const currentPrefix = hasTrailingSpace ? "" : (words[words.length - 1] ?? "").toLowerCase();
+    const paramIdx = completedCount;
+    if (paramIdx >= cmd.params.length) return { items: [], ghostHint: "" };
+    const param = cmd.params[paramIdx];
+    const ghostStart = currentPrefix ? paramIdx + 1 : paramIdx;
+    const ghostHint = cmd.params.slice(ghostStart).map((p) => `<${p.label}>`).join(" ");
+    if (!param.completions) return { items: [], ghostHint };
+    const values = param.completions === "participants" ? participants : param.completions;
+    const filtered = currentPrefix ? values.filter((v) => v.toLowerCase().startsWith(currentPrefix)) : values;
+    const completedWords = words.slice(0, completedCount).filter(Boolean);
+    const base = cmdName + (completedWords.length ? " " + completedWords.join(" ") : "") + " ";
+    const items = filtered.map((v) => ({
+      kind: "param",
+      value: v,
+      insert: base + v + " "
+    }));
+    return { items, ghostHint };
+  }, [input, isAdmin, participants]);
+  const suggestions = suggestionState.items;
+  useEffect(() => {
+    setSelectedIndex(0);
+  }, [input]);
+  useInput((char, key) => {
+    if (key.ctrl && char === "c") {
+      onCtrlC?.();
+      return;
+    }
+    if (readOnly || !onSend) return;
+    if (suggestions.length > 0) {
+      if (key.downArrow) {
+        setSelectedIndex((i) => Math.min(i + 1, suggestions.length - 1));
+        return;
+      }
+      if (key.upArrow) {
+        setSelectedIndex((i) => Math.max(i - 1, 0));
+        return;
+      }
+      if (key.return || key.tab) {
+        const picked = suggestions[selectedIndex];
+        if (!picked) return;
+        if (key.return && picked.kind === "command" && !picked.cmd.params) {
+          onSend(picked.cmd.name);
+          setInput("");
+          return;
+        }
+        setInput(picked.insert);
+        return;
+      }
+      if (key.escape) {
+        setInput("");
+        return;
+      }
+    }
+    if (key.return && key.meta) {
+      setInput((prev) => prev + "\n");
+      return;
+    }
+    if (key.return) {
+      const content = input.trim();
+      if (content) onSend(content);
+      setInput("");
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setInput((prev) => prev.slice(0, -1));
+      return;
+    }
+    if (key.ctrl || key.meta || key.escape || key.tab || key.upArrow || key.downArrow || key.leftArrow || key.rightArrow) {
+      return;
+    }
+    if (char) {
+      setInput((prev) => prev + char);
+    }
+  });
+  const cols = stdout.columns ?? 80;
+  const entries = useMemo(
+    () => [{ id: "__banner__" }, ...events.map((e) => ({ id: e.id, event: e }))],
+    [events]
+  );
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Static, { items: entries, children: (entry) => {
+      if (!entry.event) {
+        return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 2, paddingTop: 1, paddingBottom: 1, children: [
+          BANNER_LINES.map((line, i) => /* @__PURE__ */ jsx(Text, { color: GRADIENT[i], children: line }, i)),
+          /* @__PURE__ */ jsx(Text, { children: " " }),
+          /* @__PURE__ */ jsxs(Text, { children: [
+            /* @__PURE__ */ jsx(Text, { color: C.dim, children: "  room  " }),
+            /* @__PURE__ */ jsx(Text, { color: C.cyan, bold: true, children: roomName })
+          ] })
+        ] }, entry.id);
+      }
+      return /* @__PURE__ */ jsx(EventLine, { event: entry.event, identify }, entry.id);
+    } }),
+    /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+      /* @__PURE__ */ jsx(Text, { color: C.purple, children: "\u2500" }),
+      /* @__PURE__ */ jsx(Text, { color: C.border, children: "\u2500".repeat(Math.max(0, cols - 4)) }),
+      /* @__PURE__ */ jsx(Text, { color: C.cyan, children: "\u2500" })
+    ] }),
+    agentNames.length > 0 && /* @__PURE__ */ jsx(Box, { paddingX: 1, children: agentNames.map((name, i) => {
+      const { color, sigil } = identify(name);
+      return /* @__PURE__ */ jsxs(React.Fragment, { children: [
+        i > 0 && /* @__PURE__ */ jsx(Text, { color: C.border, children: "  \xB7  " }),
+        /* @__PURE__ */ jsxs(Text, { color, children: [
+          sigil,
+          " ",
+          name
+        ] })
+      ] }, name);
+    }) }),
+    readOnly || !onSend ? /* @__PURE__ */ jsx(Box, { paddingX: 1, children: /* @__PURE__ */ jsx(Text, { color: C.muted, children: "  watching as guest" }) }) : /* @__PURE__ */ jsx(Box, { paddingX: 1, flexDirection: "column", children: (input || "").split("\n").map((line, i, arr) => /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { color: C.cyan, bold: true, children: i === 0 ? "\u203A " : "  " }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        line,
+        i === arr.length - 1 && /* @__PURE__ */ jsx(Text, { inverse: true, children: " " }),
+        i === arr.length - 1 && suggestionState.ghostHint !== "" && /* @__PURE__ */ jsx(Text, { color: C.muted, children: suggestionState.ghostHint })
+      ] })
+    ] }, i)) }),
+    suggestions.length > 0 && /* @__PURE__ */ jsx(Box, { flexDirection: "column", paddingX: 1, children: suggestions.map((s, i) => {
+      const selected = i === selectedIndex;
+      if (s.kind === "command") {
+        const paramHint = s.cmd.params ? " " + s.cmd.params.map((p) => `<${p.label}>`).join(" ") : "";
+        const display = s.cmd.name + paramHint;
+        return /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsx(Text, { color: selected ? C.cyan : C.muted, children: selected ? "\u203A " : "  " }),
+          /* @__PURE__ */ jsxs(Text, { children: [
+            /* @__PURE__ */ jsx(Text, { color: selected ? C.cyan : C.secondary, bold: selected, children: s.cmd.name }),
+            /* @__PURE__ */ jsx(Text, { color: C.muted, children: paramHint.padEnd(CMD_DISPLAY_COL - display.length + paramHint.length) })
+          ] }),
+          /* @__PURE__ */ jsx(Text, { color: C.dim, children: s.cmd.description })
+        ] }, s.cmd.name);
+      }
+      return /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Text, { color: selected ? C.cyan : C.muted, children: selected ? "\u203A " : "  " }),
+        s.kind === "mention" && /* @__PURE__ */ jsx(Text, { color: C.dim, children: "@" }),
+        /* @__PURE__ */ jsx(Text, { color: selected ? C.cyan : C.secondary, bold: selected, children: s.value })
+      ] }, s.value);
+    }) })
+  ] });
+}
+function startTUI(opts) {
+  let handle = null;
+  const queue = [];
+  const onReady = (h) => {
+    handle = h;
+    for (const event of queue.splice(0)) h.push(event);
+  };
+  const { unmount } = render(
+    /* @__PURE__ */ jsx(
+      App,
+      {
+        roomName: opts.roomName,
+        onSend: opts.onSend,
+        onCtrlC: opts.onCtrlC,
+        onReady,
+        readOnly: opts.readOnly,
+        isAdmin: opts.isAdmin
+      }
+    ),
+    { exitOnCtrlC: false }
+  );
+  return {
+    push(event) {
+      if (handle) handle.push(event);
+      else queue.push(event);
+    },
+    setAgentNames(names) {
+      handle?.setAgentNames(names);
+    },
+    setParticipants(names) {
+      handle?.setParticipants(names);
+    },
+    stop() {
+      unmount();
+    }
+  };
+}
+
+// src/cli/join.ts
+async function join(options) {
+  const token = extractToken(options.server);
+  let serverUrl;
+  try {
+    const parsed = new URL(options.server);
+    parsed.search = "";
+    serverUrl = parsed.toString().replace(/\/$/, "");
+  } catch {
+    serverUrl = options.server.replace(/\/$/, "");
+  }
+  const name = options.name ?? randomName();
+  const isGuest = options.guest ?? false;
+  let sessionToken;
+  let participantId;
+  let roomName;
+  let authority;
+  let participants;
+  try {
+    const joinBody = {};
+    if (token) {
+      joinBody.token = token;
+      joinBody.type = "human";
+      joinBody.name = name;
+    } else if (isGuest) {
+      joinBody.type = "guest";
+    } else {
+      joinBody.type = "human";
+      joinBody.name = name;
+    }
+    const res = await fetch(`${serverUrl}/join`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(joinBody)
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      console.error(`Failed to join: ${err}`);
+      process.exit(1);
+    }
+    const data = await res.json();
+    sessionToken = String(data.sessionToken ?? "");
+    participantId = String(data.participantId);
+    roomName = String(data.roomName);
+    authority = data.authority ?? "participant";
+    participants = data.participants ?? [];
+  } catch {
+    console.error(`Cannot reach stoops server at ${serverUrl}. Is it running?`);
+    process.exit(1);
+  }
+  let disconnected = false;
+  let cleanupStream = null;
+  const disconnect = async () => {
+    if (disconnected) return;
+    disconnected = true;
+    cleanupStream?.();
+    try {
+      await fetch(`${serverUrl}/disconnect`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ token: sessionToken })
+      });
+    } catch {
+    }
+  };
+  if (options.headless) {
+    const sseController = new AbortController();
+    const cleanup = async () => {
+      sseController.abort();
+      await disconnect();
+    };
+    process.on("SIGINT", async () => {
+      await cleanup();
+      process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+      await cleanup();
+      process.exit(0);
+    });
+    const rl = createInterface({ input: process.stdin, terminal: false });
+    rl.on("line", async (line) => {
+      const content = line.trim();
+      if (!content || authority === "observer") return;
+      try {
+        await fetch(`${serverUrl}/message`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ token: sessionToken, content })
+        });
+      } catch {
+      }
+    });
+    try {
+      const res = await fetch(`${serverUrl}/events`, {
+        method: "POST",
+        headers: { Accept: "text/event-stream", Authorization: `Bearer ${sessionToken}` },
+        signal: sseController.signal
+      });
+      if (!res.ok || !res.body) {
+        process.stderr.write("Failed to connect event stream\n");
+        await cleanup();
+        process.exit(1);
+      }
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buf = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buf += decoder.decode(value, { stream: true });
+        const parts = buf.split("\n\n");
+        buf = parts.pop();
+        for (const part of parts) {
+          const dataLine = part.split("\n").find((l) => l.startsWith("data: "));
+          if (!dataLine) continue;
+          try {
+            const event = JSON.parse(dataLine.slice(6));
+            process.stdout.write(JSON.stringify(event) + "\n");
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+    if (!disconnected) {
+      await cleanup();
+    }
+    process.exit(0);
+  }
+  const isReadOnly = authority === "observer" || isGuest;
+  function systemEvent(content) {
+    tui.push({
+      id: randomUUID2(),
+      ts: formatTimestamp(/* @__PURE__ */ new Date()),
+      kind: "system",
+      content
+    });
+  }
+  async function handleSlashCommand(input) {
+    const parts = input.slice(1).split(/\s+/);
+    const cmd = parts[0]?.toLowerCase();
+    const args2 = parts.slice(1);
+    switch (cmd) {
+      // ── /who ──────────────────────────────────────────────────────
+      case "who": {
+        try {
+          const res = await fetch(`${serverUrl}/participants?token=${sessionToken}`);
+          if (!res.ok) {
+            systemEvent("Failed to get participant list.");
+            return;
+          }
+          const data = await res.json();
+          const lines = data.participants.map((p) => {
+            const auth = p.authority ?? "participant";
+            return `  ${p.type === "agent" ? "agent" : "human"} ${p.name} (${auth})`;
+          });
+          systemEvent(`Participants:
+${lines.join("\n")}`);
+        } catch {
+          systemEvent("Failed to reach server.");
+        }
+        return;
+      }
+      // ── /leave ────────────────────────────────────────────────────
+      case "leave": {
+        await disconnect();
+        tui.stop();
+        process.exit(0);
+        return;
+      }
+      // ── /kick <name> (admin only) ─────────────────────────────────
+      case "kick": {
+        if (authority !== "admin") {
+          systemEvent("Only admins can kick.");
+          return;
+        }
+        const targetName = args2[0];
+        if (!targetName) {
+          systemEvent("Usage: /kick <name>");
+          return;
+        }
+        try {
+          const res = await fetch(`${serverUrl}/participants?token=${sessionToken}`);
+          if (!res.ok) {
+            systemEvent("Failed to get participant list.");
+            return;
+          }
+          const data = await res.json();
+          const target = data.participants.find((p) => p.name.toLowerCase() === targetName.toLowerCase());
+          if (!target) {
+            systemEvent(`Participant "${targetName}" not found.`);
+            return;
+          }
+          const kickRes = await fetch(`${serverUrl}/kick`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ token: sessionToken, participantId: target.id })
+          });
+          if (!kickRes.ok) {
+            systemEvent(`Failed to kick: ${await kickRes.text()}`);
+            return;
+          }
+          systemEvent(`Kicked ${targetName}.`);
+        } catch {
+          systemEvent("Failed to reach server.");
+        }
+        return;
+      }
+      // ── /mute <name> (admin only) — demote to observer ────────────
+      case "mute": {
+        if (authority !== "admin") {
+          systemEvent("Only admins can mute.");
+          return;
+        }
+        const targetName = args2[0];
+        if (!targetName) {
+          systemEvent("Usage: /mute <name>");
+          return;
+        }
+        try {
+          const res = await fetch(`${serverUrl}/participants?token=${sessionToken}`);
+          if (!res.ok) {
+            systemEvent("Failed to get participant list.");
+            return;
+          }
+          const data = await res.json();
+          const target = data.participants.find((p) => p.name.toLowerCase() === targetName.toLowerCase());
+          if (!target) {
+            systemEvent(`Participant "${targetName}" not found.`);
+            return;
+          }
+          const authRes = await fetch(`${serverUrl}/set-authority`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ token: sessionToken, participantId: target.id, authority: "observer" })
+          });
+          if (!authRes.ok) {
+            systemEvent(`Failed to mute: ${await authRes.text()}`);
+            return;
+          }
+          systemEvent(`Muted ${targetName} (observer).`);
+        } catch {
+          systemEvent("Failed to reach server.");
+        }
+        return;
+      }
+      // ── /unmute <name> (admin only) — restore to participant ──────
+      case "unmute": {
+        if (authority !== "admin") {
+          systemEvent("Only admins can unmute.");
+          return;
+        }
+        const targetName = args2[0];
+        if (!targetName) {
+          systemEvent("Usage: /unmute <name>");
+          return;
+        }
+        try {
+          const res = await fetch(`${serverUrl}/participants?token=${sessionToken}`);
+          if (!res.ok) {
+            systemEvent("Failed to get participant list.");
+            return;
+          }
+          const data = await res.json();
+          const target = data.participants.find((p) => p.name.toLowerCase() === targetName.toLowerCase());
+          if (!target) {
+            systemEvent(`Participant "${targetName}" not found.`);
+            return;
+          }
+          const authRes = await fetch(`${serverUrl}/set-authority`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ token: sessionToken, participantId: target.id, authority: "participant" })
+          });
+          if (!authRes.ok) {
+            systemEvent(`Failed to unmute: ${await authRes.text()}`);
+            return;
+          }
+          systemEvent(`Unmuted ${targetName} (participant).`);
+        } catch {
+          systemEvent("Failed to reach server.");
+        }
+        return;
+      }
+      // ── /setmode <name> <mode> (admin only) ───────────────────────
+      case "setmode": {
+        if (authority !== "admin") {
+          systemEvent("Only admins can set modes.");
+          return;
+        }
+        const targetName = args2[0];
+        const mode = args2[1];
+        if (!targetName || !mode) {
+          systemEvent("Usage: /setmode <name> <mode>");
+          return;
+        }
+        try {
+          const res = await fetch(`${serverUrl}/participants?token=${sessionToken}`);
+          if (!res.ok) {
+            systemEvent("Failed to get participant list.");
+            return;
+          }
+          const data = await res.json();
+          const target = data.participants.find((p) => p.name.toLowerCase() === targetName.toLowerCase());
+          if (!target) {
+            systemEvent(`Participant "${targetName}" not found.`);
+            return;
+          }
+          const modeRes = await fetch(`${serverUrl}/set-mode`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ token: sessionToken, participantId: target.id, mode })
+          });
+          if (!modeRes.ok) {
+            systemEvent(`Failed to set mode: ${await modeRes.text()}`);
+            return;
+          }
+          systemEvent(`Set ${targetName} to ${mode}.`);
+        } catch {
+          systemEvent("Failed to reach server.");
+        }
+        return;
+      }
+      // ── /share [--as <tier>] ──────────────────────────────────────
+      case "share": {
+        if (authority === "observer") {
+          systemEvent("Observers cannot create share links.");
+          return;
+        }
+        let targetAuthority;
+        if (args2[0] === "--as" && args2[1]) {
+          targetAuthority = args2[1];
+        }
+        try {
+          const body = { token: sessionToken };
+          if (targetAuthority) body.authority = targetAuthority;
+          const res = await fetch(`${serverUrl}/share`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body)
+          });
+          if (!res.ok) {
+            systemEvent(`Failed: ${await res.text()}`);
+            return;
+          }
+          const data = await res.json();
+          const lines = Object.entries(data.links).map(
+            ([tier, url]) => `  ${tier}: stoops join ${url}`
+          );
+          systemEvent(`Share links:
+${lines.join("\n")}`);
+        } catch {
+          systemEvent("Failed to reach server.");
+        }
+        return;
+      }
+      default:
+        systemEvent(`Unknown command: /${cmd}`);
+    }
+  }
+  if (options.shareUrl) {
+    console.log();
+    console.log(`  Invite a friend:       npx stoops join "${options.shareUrl}"`);
+    console.log(`  Connect Claude Code:   npx stoops run claude  \u2192  then tell agent to join: ${options.shareUrl}`);
+    console.log();
+  }
+  const tui = startTUI({
+    roomName,
+    readOnly: isReadOnly,
+    isAdmin: authority === "admin",
+    onSend: isReadOnly ? void 0 : async (content) => {
+      if (content.startsWith("/")) {
+        await handleSlashCommand(content);
+        return;
+      }
+      try {
+        await fetch(`${serverUrl}/message`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ token: sessionToken, content })
+        });
+      } catch {
+      }
+    },
+    onCtrlC: async () => {
+      await disconnect();
+      tui.stop();
+      process.exit(0);
+    }
+  });
+  const agentNames = participants.filter((p) => p.type === "agent").map((p) => p.name);
+  if (agentNames.length > 0) {
+    tui.setAgentNames(agentNames);
+  }
+  const participantNames = new Set(
+    participants.filter((p) => p.id !== participantId).map((p) => p.name)
+  );
+  tui.setParticipants([...participantNames]);
+  {
+    const participantTypes = /* @__PURE__ */ new Map();
+    for (const p of participants) {
+      participantTypes.set(p.id, p.type);
+    }
+    const currentAgents = new Set(agentNames);
+    let sseController = null;
+    cleanupStream = () => {
+      if (sseController) {
+        sseController.abort();
+        sseController = null;
+      }
+    };
+    const connectSSE = async () => {
+      sseController = new AbortController();
+      try {
+        const res = await fetch(`${serverUrl}/events`, {
+          method: "POST",
+          headers: {
+            Accept: "text/event-stream",
+            Authorization: `Bearer ${sessionToken}`
+          },
+          signal: sseController.signal
+        });
+        if (!res.ok || !res.body) {
+          console.error("Failed to connect event stream");
+          await disconnect();
+          process.exit(1);
+        }
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const parts = buffer.split("\n\n");
+          buffer = parts.pop();
+          for (const part of parts) {
+            const dataLine = part.split("\n").find((l) => l.startsWith("data: "));
+            if (!dataLine) continue;
+            try {
+              const event = JSON.parse(dataLine.slice(6));
+              if (event.type === "ParticipantJoined") {
+                participantTypes.set(event.participant.id, event.participant.type);
+              }
+              const displayEvent = toDisplayEvent(event, participantId, participantTypes);
+              if (displayEvent) {
+                tui.push(displayEvent);
+              }
+              if (event.type === "ParticipantJoined") {
+                if (event.participant.type === "agent") {
+                  currentAgents.add(event.participant.name);
+                  tui.setAgentNames([...currentAgents]);
+                }
+                if (event.participant.id !== participantId) {
+                  participantNames.add(event.participant.name);
+                  tui.setParticipants([...participantNames]);
+                }
+              }
+              if (event.type === "ParticipantLeft") {
+                if (event.participant.type === "agent") {
+                  currentAgents.delete(event.participant.name);
+                  tui.setAgentNames([...currentAgents]);
+                }
+                participantTypes.delete(event.participant.id);
+                participantNames.delete(event.participant.name);
+                tui.setParticipants([...participantNames]);
+              }
+            } catch {
+            }
+          }
+        }
+        if (!disconnected) {
+          tui.stop();
+          console.log("\nServer disconnected.");
+          process.exit(0);
+        }
+      } catch {
+        if (!disconnected) {
+          tui.stop();
+          console.log("\nServer disconnected.");
+          process.exit(0);
+        }
+      }
+    };
+    connectSSE();
+  }
+  process.on("SIGINT", async () => {
+    await disconnect();
+    tui.stop();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    await disconnect();
+    tui.stop();
+    process.exit(0);
+  });
+}
+function toDisplayEvent(event, selfId, participantTypes) {
+  const ts = formatTimestamp(new Date(event.timestamp));
+  switch (event.type) {
+    case "MessageSent": {
+      const msg = event.message;
+      const senderType = participantTypes.get(msg.sender_id) ?? "human";
+      return {
+        id: msg.id,
+        ts,
+        kind: "message",
+        senderName: msg.sender_name,
+        senderType,
+        isSelf: msg.sender_id === selfId,
+        content: msg.content,
+        replyToName: event._replyToName ?? void 0
+      };
+    }
+    case "ParticipantJoined":
+      return {
+        id: randomUUID2(),
+        ts,
+        kind: "join",
+        name: event.participant.name,
+        participantType: event.participant.type
+      };
+    case "ParticipantLeft":
+      return {
+        id: randomUUID2(),
+        ts,
+        kind: "leave",
+        name: event.participant.name,
+        participantType: event.participant.type
+      };
+    case "Activity":
+      if (event.action === "mode_changed") {
+        return {
+          id: randomUUID2(),
+          ts,
+          kind: "mode",
+          mode: String(event.detail?.mode ?? "")
+        };
+      }
+      if (event.action === "authority_changed") {
+        const newAuth = String(event.detail?.authority ?? "");
+        return {
+          id: randomUUID2(),
+          ts,
+          kind: "system",
+          content: `authority \u2192 ${newAuth}`
+        };
+      }
+      return null;
+    default:
+      return null;
+  }
+}
+
+// src/cli/claude/run.ts
+import { writeFileSync, mkdtempSync, rmSync, chmodSync } from "fs";
+import { join as join2 } from "path";
+import { tmpdir } from "os";
+
+// src/cli/tmux.ts
+import { execFileSync as execFileSync2, spawn as spawn2 } from "child_process";
+function sanitizeSessionName(name) {
+  return name.replace(/[.:$%]/g, "_");
+}
+function tmuxAvailable() {
+  try {
+    execFileSync2("tmux", ["-V"], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function tmuxSessionExists(session) {
+  try {
+    const name = sanitizeSessionName(session);
+    execFileSync2("tmux", ["has-session", "-t", name], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function tmuxCreateSession(session) {
+  const name = sanitizeSessionName(session);
+  execFileSync2("tmux", ["new-session", "-d", "-s", name]);
+  execFileSync2("tmux", ["set", "-t", name, "status", "off"]);
+}
+function tmuxSendCommand(session, command) {
+  const name = sanitizeSessionName(session);
+  execFileSync2("tmux", ["send-keys", "-t", name, "-l", command]);
+  execFileSync2("tmux", ["send-keys", "-t", name, "Enter"]);
+}
+function tmuxInjectText(session, text) {
+  const name = sanitizeSessionName(session);
+  execFileSync2("tmux", ["send-keys", "-t", name, "-l", text]);
+}
+function tmuxSendEnter(session) {
+  const name = sanitizeSessionName(session);
+  execFileSync2("tmux", ["send-keys", "-t", name, "Enter"]);
+}
+function tmuxAttach(session) {
+  const name = sanitizeSessionName(session);
+  if (process.env.TMUX) {
+    try {
+      execFileSync2("tmux", ["switch-client", "-t", name], { stdio: "ignore" });
+    } catch {
+    }
+    return new Promise((resolve) => {
+      const poll = setInterval(() => {
+        try {
+          execFileSync2("tmux", ["has-session", "-t", name], { stdio: "ignore" });
+        } catch {
+          clearInterval(poll);
+          resolve();
+        }
+      }, 500);
+    });
+  }
+  return new Promise((resolve) => {
+    const child = spawn2("tmux", ["attach", "-t", name], { stdio: "inherit" });
+    child.on("exit", () => resolve());
+    child.on("error", () => resolve());
+  });
+}
+function tmuxCapturePane(session) {
+  try {
+    const name = sanitizeSessionName(session);
+    const output = execFileSync2("tmux", ["capture-pane", "-t", name, "-p"], {
+      encoding: "utf-8"
+    });
+    return output.split("\n");
+  } catch {
+    return [];
+  }
+}
+function tmuxSendKey(session, key) {
+  const name = sanitizeSessionName(session);
+  execFileSync2("tmux", ["send-keys", "-t", name, key]);
+}
+function tmuxKillSession(session) {
+  try {
+    const name = sanitizeSessionName(session);
+    execFileSync2("tmux", ["kill-session", "-t", name], { stdio: "ignore" });
+  } catch {
+  }
+}
+
+// src/cli/claude/tmux-bridge.ts
+var SPINNER_CHARS = "\u280B\u2819\u2839\u2838\u283C\u2834\u2826\u2827\u2807\u280F";
+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"
+];
+var TmuxBridge = class {
+  session;
+  queue = [];
+  pollTimer = null;
+  pollIntervalMs;
+  keystrokeDelayMs;
+  stopped = false;
+  constructor(session, opts) {
+    this.session = session;
+    this.pollIntervalMs = opts?.pollIntervalMs ?? 200;
+    this.keystrokeDelayMs = opts?.keystrokeDelayMs ?? 50;
+  }
+  /**
+   * Delivery callback — drop-in replacement for the raw tmuxDeliver lambda.
+   * Pass `bridge.deliver.bind(bridge)` to EventProcessor.run().
+   */
+  async deliver(parts) {
+    const text = contentPartsToString(parts);
+    if (!text.trim()) return;
+    this.inject(text);
+  }
+  /**
+   * Detect the current TUI state by reading the screen.
+   * Exported for testing — the heuristic logic is in detectStateFromLines().
+   */
+  detectState() {
+    const lines = this.captureScreen();
+    return detectStateFromLines(lines);
+  }
+  /**
+   * 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) {
+    const flat = text.replace(/\n/g, " ");
+    const state = this.detectState();
+    switch (state) {
+      case "idle":
+        this.injectIdle(flat);
+        break;
+      case "typing":
+        this.injectWhileTyping(flat);
+        break;
+      default:
+        this.enqueue(flat);
+        break;
+    }
+  }
+  /** Capture the screen via tmux capture-pane. */
+  captureScreen() {
+    return tmuxCapturePane(this.session);
+  }
+  /**
+   * Inject into an idle prompt: type text + Enter.
+   * Sends a second Enter after a short delay as a safety net — if Claude Code's
+   * paste detection swallowed the first Enter, the second one submits. If the
+   * first Enter worked, Claude is streaming and the second Enter is a no-op.
+   */
+  injectIdle(text) {
+    tmuxInjectText(this.session, text);
+    tmuxSendEnter(this.session);
+    this.sleep(80);
+    tmuxSendEnter(this.session);
+  }
+  /**
+   * 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.sleep(80);
+    tmuxSendEnter(this.session);
+    this.sleep(this.keystrokeDelayMs);
+    tmuxSendKey(this.session, "C-y");
+  }
+  /** Add to queue and start polling if not already. */
+  enqueue(text) {
+    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();
+      return;
+    }
+    const state = this.detectState();
+    if (state === "idle" || state === "typing") {
+      const text = this.queue.shift();
+      if (state === "idle") {
+        this.injectIdle(text);
+      } else {
+        this.injectWhileTyping(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);
+  }
+};
+function detectStateFromLines(lines) {
+  if (lines.length === 0) return "unknown";
+  const tail = lines.slice(-15);
+  const tailText = tail.join("\n");
+  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 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";
+}
+
+// src/cli/runtime-setup.ts
+async function setupAgentRuntime(options) {
+  const agentName = options.name ?? randomName();
+  const pendingUrls = options.joinUrls ?? [];
+  const joinResults = [];
+  const sseMux = new SseMultiplexer();
+  const processor = new EventProcessor("", agentName, {
+    defaultMode: "everyone"
+  });
+  const mcpServer = await createRuntimeMcpServer({
+    resolver: processor,
+    toolOptions: {
+      isEventSeen: (id) => processor.isEventSeen(id),
+      markEventsSeen: (ids) => processor.markEventsSeen(ids),
+      assignRef: (id) => processor.assignRef(id),
+      resolveRef: (ref) => processor.resolveRef(ref)
+    },
+    admin: options.admin,
+    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" },
+          body: JSON.stringify({ token: ds.sessionToken, mode })
+        });
+        if (!res.ok) return { success: false, error: `Server rejected: ${await res.text()}` };
+      } catch {
+      }
+      return { success: true };
+    },
+    onJoinRoom: async (url, alias) => {
+      const token = extractToken(url);
+      let serverUrl;
+      try {
+        const parsed = new URL(url);
+        parsed.search = "";
+        serverUrl = parsed.toString().replace(/\/$/, "");
+      } catch {
+        serverUrl = url.replace(/\/$/, "");
+      }
+      try {
+        const joinBody = { type: "agent", name: agentName };
+        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 authority = String(data.authority ?? "participant");
+        const participants = data.participants ?? [];
+        const newParticipantId = String(data.participantId ?? "");
+        const dataSource = new RemoteRoomDataSource(serverUrl, sessionToken, roomId);
+        dataSource.setParticipants(participants);
+        dataSource.setSelf(newParticipantId, agentName);
+        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,
+          participants,
+          dataSource
+        };
+        joinResults.push(jr);
+        const conn = processor.resolve(roomName);
+        let recentLines = [];
+        if (conn) {
+          recentLines = await buildCatchUpLines(conn, {
+            isEventSeen: (id) => processor.isEventSeen(id),
+            markEventsSeen: (ids) => processor.markEventsSeen(ids),
+            assignRef: (id) => processor.assignRef(id)
+          });
+        }
+        await options.onRoomJoined?.();
+        return {
+          success: true,
+          roomName,
+          agentName,
+          authority,
+          mode,
+          participants: participants.filter((p) => p.id !== newParticipantId).map((p) => ({ name: p.name, authority: p.authority ?? "participant" })),
+          recentLines
+        };
+      } 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" },
+            body: JSON.stringify({ token: jr.sessionToken })
+          });
+        } catch {
+        }
+        joinResults.splice(idx, 1);
+      }
+      return { success: true };
+    },
+    onAdminSetModeFor: options.admin ? async (room, participant, mode) => {
+      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}/set-mode`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ token: ds.sessionToken, participantId: p.id, mode })
+        });
+        if (!res.ok) return { success: false, error: await res.text() };
+        return { success: true };
+      } catch {
+        return { success: false, error: "Server unreachable." };
+      }
+    } : void 0,
+    onAdminMute: options.admin ? 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}/set-authority`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ token: ds.sessionToken, participantId: p.id, authority: "observer" })
+        });
+        if (!res.ok) return { success: false, error: await res.text() };
+        return { success: true };
+      } catch {
+        return { success: false, error: "Server unreachable." };
+      }
+    } : void 0,
+    onAdminUnmute: options.admin ? 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}/set-authority`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ token: ds.sessionToken, participantId: p.id, authority: "participant" })
+        });
+        if (!res.ok) return { success: false, error: await res.text() };
+        return { success: true };
+      } catch {
+        return { success: false, error: "Server unreachable." };
+      }
+    } : void 0,
+    onAdminKick: options.admin ? 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}/kick`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ token: ds.sessionToken, participantId: p.id })
+        });
+        if (!res.ok) return { success: false, error: await res.text() };
+        return { success: true };
+      } catch {
+        return { success: false, error: "Server unreachable." };
+      }
+    } : void 0
+  });
+  const wrappedSource = {
+    [Symbol.asyncIterator]() {
+      const inner = sseMux[Symbol.asyncIterator]();
+      return {
+        async next() {
+          const result = await inner.next();
+          if (!result.done) {
+            const { roomId, event } = result.value;
+            const jr = joinResults.find((j) => j.roomId === roomId);
+            if (jr) {
+              if (event.type === "ParticipantJoined") {
+                jr.dataSource.addParticipant(event.participant);
+              } else if (event.type === "ParticipantLeft") {
+                jr.dataSource.removeParticipant(event.participant_id);
+              }
+            }
+          }
+          return result;
+        }
+      };
+    }
+  };
+  async function cleanup() {
+    await processor.stop();
+    sseMux.close();
+    await mcpServer.stop();
+    for (const jr of joinResults) {
+      try {
+        await fetch(`${jr.serverUrl}/disconnect`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ token: jr.sessionToken })
+        });
+      } catch {
+      }
+    }
+  }
+  let initialParts;
+  if (pendingUrls.length > 0) {
+    if (pendingUrls.length === 1) {
+      initialParts = [{ type: "text", text: `Use join_room("${pendingUrls[0]}") to connect.` }];
+    } else {
+      const lines = pendingUrls.map((u) => `  join_room("${u}")`);
+      initialParts = [{ type: "text", text: `Rooms to join:
+${lines.join("\n")}` }];
+    }
+  }
+  return {
+    agentName,
+    joinResults,
+    initialParts,
+    processor,
+    sseMux,
+    mcpServer,
+    wrappedSource,
+    cleanup
+  };
+}
+
+// src/cli/claude/run.ts
+var MCP_STDIO_BRIDGE = [
+  "#!/usr/bin/env node",
+  '"use strict";',
+  'const { createInterface } = require("readline");',
+  "const url = `http://127.0.0.1:${process.argv[2]}/mcp`;",
+  "const rl = createInterface({ input: process.stdin });",
+  "(async () => {",
+  "  for await (const line of rl) {",
+  "    if (!line.trim()) continue;",
+  "    try {",
+  "      const res = await fetch(url, {",
+  '        method: "POST",',
+  '        headers: { "Content-Type": "application/json", Accept: "application/json, text/event-stream" },',
+  "        body: line,",
+  "      });",
+  "      if (res.status === 202) continue;",
+  "      const body = await res.text();",
+  '      for (const bl of body.split("\\n")) {',
+  "        const m = bl.match(/^data: (.+)/);",
+  '        if (m) process.stdout.write(m[1] + "\\n");',
+  "      }",
+  "    } catch {",
+  "      process.exit(1);",
+  "    }",
+  "  }",
+  "})();"
+].join("\n");
+async function runClaude(options) {
+  if (options.headless) {
+    const setup2 = await setupAgentRuntime(options);
+    const deliver = async (parts) => {
+      const text = contentPartsToString(parts);
+      if (text.trim()) process.stdout.write(text + "\n");
+    };
+    const eventLoopPromise2 = setup2.processor.run(deliver, setup2.wrappedSource, setup2.initialParts).catch(() => {
+    });
+    process.stderr.write(`MCP server: ${setup2.mcpServer.url}
+`);
+    await new Promise((resolve) => {
+      process.on("SIGINT", resolve);
+      process.on("SIGTERM", resolve);
+    });
+    await setup2.cleanup();
+    await eventLoopPromise2;
+    return;
+  }
+  if (!tmuxAvailable()) {
+    console.error("Error: tmux is required but not found. Install it with: brew install tmux");
+    process.exit(1);
+  }
+  const setup = await setupAgentRuntime({ ...options, joinUrls: void 0 });
+  const tmpDir = mkdtempSync(join2(tmpdir(), "stoops_agent_"));
+  const bridgePath = join2(tmpDir, "mcp-bridge.cjs");
+  writeFileSync(bridgePath, MCP_STDIO_BRIDGE);
+  chmodSync(bridgePath, 493);
+  const mcpPort = new URL(setup.mcpServer.url).port;
+  const mcpConfigPath = join2(tmpDir, "mcp.json");
+  const mcpConfig = {
+    mcpServers: {
+      stoops: {
+        type: "stdio",
+        command: process.execPath,
+        args: [bridgePath, mcpPort]
+      }
+    }
+  };
+  writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
+  const tmuxSession = `stoops_${setup.agentName}`;
+  if (tmuxSessionExists(tmuxSession)) {
+    tmuxKillSession(tmuxSession);
+  }
+  console.log("Launching Claude Code...");
+  tmuxCreateSession(tmuxSession);
+  const extraArgs = options.extraArgs ?? [];
+  const claudeCmd = [`claude --mcp-config ${mcpConfigPath}`, ...extraArgs].join(" ");
+  tmuxSendCommand(tmuxSession, claudeCmd);
+  const bridge = new TmuxBridge(tmuxSession);
+  const eventLoopPromise = setup.processor.run(bridge.deliver.bind(bridge), setup.wrappedSource).catch(() => {
+  });
+  for (let i = 0; i < 10; i++) {
+    await new Promise((r) => setTimeout(r, 500));
+    if (!tmuxSessionExists(tmuxSession)) {
+      console.error("Error: Claude Code exited during startup. Try running again.");
+      bridge.stop();
+      await setup.cleanup();
+      try {
+        rmSync(tmpDir, { recursive: true });
+      } catch {
+      }
+      return;
+    }
+  }
+  console.log("Attaching to Claude Code session...\n");
+  try {
+    await tmuxAttach(tmuxSession);
+  } catch {
+  }
+  bridge.stop();
+  await setup.cleanup();
+  tmuxKillSession(tmuxSession);
+  try {
+    rmSync(tmpDir, { recursive: true });
+  } catch {
+  }
+  console.log("Disconnected.");
+}
+
+// src/cli/opencode/run.ts
+import { spawn as spawn3 } from "child_process";
+async function runOpencode(options) {
+  const opencodePort = 14096 + Math.floor(Math.random() * 1e3);
+  const opencodeUrl = `http://127.0.0.1:${opencodePort}`;
+  const roomSessions = /* @__PURE__ */ new Map();
+  async function findStoopsSession() {
+    try {
+      const res = await fetch(`${opencodeUrl}/session`);
+      if (!res.ok) return null;
+      const sessions = await res.json();
+      for (const sess of sessions.slice(0, 3)) {
+        const msgRes = await fetch(`${opencodeUrl}/session/${sess.id}/message`);
+        if (!msgRes.ok) continue;
+        const messages = await msgRes.json();
+        for (const msg of messages) {
+          for (const part of msg.parts ?? []) {
+            if (part.type === "tool" && part.tool?.includes("stoops__")) {
+              return sess.id;
+            }
+          }
+        }
+      }
+      return sessions.length > 0 ? sessions[0].id : null;
+    } catch {
+      return null;
+    }
+  }
+  const setup = await setupAgentRuntime({
+    ...options,
+    joinUrls: void 0
+  });
+  const opencodeConfig = {
+    mcp: {
+      stoops: {
+        type: "remote",
+        url: setup.mcpServer.url,
+        oauth: false
+      }
+    }
+  };
+  const extraArgs = options.extraArgs ?? [];
+  const opencodeArgs = ["serve", "--port", String(opencodePort), ...extraArgs];
+  console.log("Launching OpenCode...");
+  let child;
+  try {
+    child = spawn3("opencode", opencodeArgs, {
+      env: {
+        ...process.env,
+        OPENCODE_CONFIG_CONTENT: JSON.stringify(opencodeConfig)
+      },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch {
+    console.error("Error: opencode is required but not found. Install it from https://opencode.ai");
+    await setup.cleanup();
+    process.exit(1);
+  }
+  child.stderr?.on("data", (chunk) => {
+    process.stderr.write(chunk);
+  });
+  let childExited = false;
+  child.on("exit", () => {
+    childExited = true;
+  });
+  child.on("error", async () => {
+    console.error("Error: failed to start opencode. Is it installed?");
+    await setup.cleanup();
+    process.exit(1);
+  });
+  const ready = await pollForReady(opencodeUrl, 3e4);
+  if (!ready) {
+    console.error("OpenCode did not become ready within 30 seconds.");
+    child.kill();
+    await setup.cleanup();
+    process.exit(1);
+  }
+  console.log(`  OpenCode running on ${opencodeUrl}`);
+  async function deliver(parts) {
+    const roomId = setup.processor.currentContextRoomId;
+    if (!roomId) return;
+    if (!roomSessions.has(roomId)) {
+      const sid = await findStoopsSession();
+      if (!sid) return;
+      roomSessions.set(roomId, sid);
+      console.log(`  Linked room ${roomId} \u2192 session ${sid}`);
+    }
+    const targetSession = roomSessions.get(roomId);
+    const text = contentPartsToString(parts);
+    if (!text.trim()) return;
+    try {
+      const res = await fetch(`${opencodeUrl}/session/${targetSession}/message`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          parts: [{ type: "text", text }]
+        })
+      });
+      await res.text();
+    } catch {
+    }
+  }
+  const eventLoopPromise = setup.processor.run(deliver, setup.wrappedSource);
+  console.log(`
+  OpenCode agent running.`);
+  console.log(`  To watch: opencode attach ${opencodeUrl}
+`);
+  const exitPromise = new Promise((resolve) => {
+    child.on("exit", resolve);
+  });
+  const signalPromise = new Promise((resolve) => {
+    const handler = () => {
+      resolve();
+    };
+    process.on("SIGINT", handler);
+    process.on("SIGTERM", handler);
+  });
+  await Promise.race([exitPromise, signalPromise]);
+  if (!childExited) {
+    child.kill();
+  }
+  await setup.cleanup();
+  console.log("Disconnected.");
+}
+async function pollForReady(url, timeoutMs) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const res = await fetch(`${url}/session/status`);
+      if (res.ok) return true;
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  return false;
+}
+
+// src/cli/index.ts
+var args = process.argv.slice(2);
+function getFlag(name, arr = args) {
+  const idx = arr.indexOf(`--${name}`);
+  if (idx === -1) return void 0;
+  const value = arr[idx + 1];
+  if (value === void 0 || value.startsWith("--")) return void 0;
+  return value;
+}
+function getAllFlags(name, arr = args) {
+  const results = [];
+  const flag = `--${name}`;
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] === flag && arr[i + 1] && !arr[i + 1].startsWith("--")) {
+      results.push(arr[i + 1]);
+    }
+  }
+  return results;
+}
+function printUsage(stream = console.log) {
+  stream("Usage:");
+  stream("  stoops [--room <name>] [--port <port>] [--share]                         Host + join");
+  stream("  stoops serve [--room <name>] [--port <port>] [--share]                   Headless server");
+  stream("  stoops join <url> [--name <name>] [--guest]                              Join a room");
+  stream("  stoops run claude [--name <name>] [--admin] [-- <args>]                  Connect Claude Code");
+  stream("  stoops run opencode [--name <name>] [--admin] [-- <args>]                Connect OpenCode");
+}
+async function main() {
+  if (args.includes("--help") || args.includes("-h")) {
+    printUsage();
+    return;
+  }
+  if (args[0] === "run" && (args[1] === "claude" || args[1] === "opencode")) {
+    const runtime = args[1];
+    const restArgs = args.slice(2);
+    const ddIndex = restArgs.indexOf("--");
+    const stoopsArgs = ddIndex >= 0 ? restArgs.slice(0, ddIndex) : restArgs;
+    const extraArgs = ddIndex >= 0 ? restArgs.slice(ddIndex + 1) : [];
+    const joinUrls = getAllFlags("join", stoopsArgs);
+    const runtimeOptions = {
+      joinUrls: joinUrls.length > 0 ? joinUrls : void 0,
+      name: getFlag("name", stoopsArgs),
+      admin: stoopsArgs.includes("--admin"),
+      headless: stoopsArgs.includes("--headless"),
+      extraArgs
+    };
+    if (runtime === "claude") {
+      await runClaude(runtimeOptions);
+    } else {
+      await runOpencode(runtimeOptions);
+    }
+    return;
+  }
+  if (args[0] === "join") {
+    const server = args[1];
+    if (!server || server.startsWith("--")) {
+      console.error("Usage: stoops join <url> [--name <name>] [--guest] [--headless]");
+      process.exit(1);
+    }
+    await join({
+      server,
+      name: getFlag("name"),
+      guest: args.includes("--guest"),
+      headless: args.includes("--headless")
+    });
+    return;
+  }
+  if (args[0] === "serve") {
+    const portStr = getFlag("port");
+    const port = portStr ? parseInt(portStr, 10) : void 0;
+    if (port !== void 0 && (isNaN(port) || port < 0 || port > 65535)) {
+      console.error(`Invalid port: ${portStr}`);
+      process.exit(1);
+    }
+    await serve({
+      room: getFlag("room"),
+      port,
+      share: args.includes("--share"),
+      headless: args.includes("--headless")
+    });
+    return;
+  }
+  if (args.length === 0 || args[0]?.startsWith("--")) {
+    const portStr = getFlag("port");
+    const port = portStr ? parseInt(portStr, 10) : void 0;
+    if (port !== void 0 && (isNaN(port) || port < 0 || port > 65535)) {
+      console.error(`Invalid port: ${portStr}`);
+      process.exit(1);
+    }
+    const result = await serve({
+      room: getFlag("room"),
+      port,
+      share: args.includes("--share"),
+      quiet: true
+    });
+    const adminJoinUrl = buildShareUrl(result.serverUrl, result.adminToken);
+    const participantShareUrl = buildShareUrl(
+      result.publicUrl !== result.serverUrl ? result.publicUrl : result.serverUrl,
+      result.participantToken
+    );
+    await join({
+      server: adminJoinUrl,
+      name: getFlag("name"),
+      shareUrl: participantShareUrl
+    });
+    return;
+  }
+  console.error(`Unknown command: ${args[0]}
+`);
+  printUsage(console.error);
+  process.exit(1);
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map