vibedate 0.5.0 → 0.7.0

package/dist/cli.js

@@ -1,17 +1,20 @@
 #!/usr/bin/env node
 import {
   runMcp
-} from "./chunk-I5U3O4RH.js";
+} from "./chunk-ZD6JBWEW.js";
 import {
   CANDIDATES,
   DEFAULT_HANDLE,
   LIVE_NOTICE,
   MAX_HANDLE_LEN,
+  ROOM_TOPIC_PREFIX,
   TOPIC_PREFIX,
   addBlock,
   allLeagueNames,
   canShareLive,
   connectProfile,
+  createNostrPoolTransport,
+  createNostrRelayLink,
   defaultStateDir,
   grantLiveConsent,
   isBlocked,
@@ -22,6 +25,7 @@ import {
   loadBlocklist,
   loadHandle,
   loadOrCreateIdentity,
+  loadOrCreateNostrKey,
   loadPeers,
   loadProfile,
   matches,
@@ -34,8 +38,9 @@ import {
   sanitizePeerText,
   saveHandle,
   signHelloClaims,
-  startDiscovery
-} from "./chunk-KKWP4DLY.js";
+  startDiscovery,
+  startRoom
+} from "./chunk-HDHJLZZG.js";
 
 // src/cli.ts
 import readline from "readline";
@@ -1888,6 +1893,111 @@ function createLiveBridge() {
   };
   return bridge;
 }
+var MAX_QUEUED_ROOM_SIGNALS = 200;
+function createRoomBridge(name) {
+  let session;
+  const messageQueue = [];
+  const messageWaiters = [];
+  const signalBoxes = /* @__PURE__ */ new Map();
+  const signalWaiters = /* @__PURE__ */ new Map();
+  const drainMessage = (m) => {
+    const safe = { ...m, text: sanitizePeerText(m.text) };
+    const waiter = messageWaiters.shift();
+    if (waiter !== void 0) {
+      waiter(safe);
+      return;
+    }
+    messageQueue.push(safe);
+    if (messageQueue.length > MAX_QUEUED_MESSAGES) {
+      messageQueue.splice(0, messageQueue.length - MAX_QUEUED_MESSAGES);
+    }
+  };
+  const drainSignal = (from, frame) => {
+    const waiters = signalWaiters.get(from);
+    if (waiters !== void 0 && waiters.length > 0) {
+      const w = waiters.shift();
+      if (w !== void 0) {
+        if (waiters.length === 0) signalWaiters.delete(from);
+        w(frame);
+        return;
+      }
+    }
+    let box = signalBoxes.get(from);
+    if (box === void 0) {
+      box = [];
+      signalBoxes.set(from, box);
+    }
+    box.push(frame);
+    if (box.length > MAX_QUEUED_ROOM_SIGNALS) {
+      box.splice(0, box.length - MAX_QUEUED_ROOM_SIGNALS);
+    }
+  };
+  return {
+    name,
+    get self() {
+      return session?.hello.handle;
+    },
+    get members() {
+      if (session === void 0) return [];
+      return [...session.members.values()].map((h) => ({
+        handle: h.handle,
+        league: h.league,
+        harness: h.harness,
+        ...h.verified !== void 0 ? { verified: h.verified } : {},
+        ...h.identityVerified !== void 0 ? { identityVerified: h.identityVerified } : {}
+      }));
+    },
+    attach(s) {
+      session = s;
+      s.onMessage(drainMessage);
+      s.onSignal((from, frame) => drainSignal(from, frame));
+    },
+    broadcast(text) {
+      session?.broadcast(text);
+    },
+    async pollMessage(timeoutMs) {
+      if (messageQueue.length > 0) return messageQueue.shift() ?? null;
+      return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+          const idx = messageWaiters.indexOf(resolve);
+          if (idx >= 0) messageWaiters.splice(idx, 1);
+          resolve(null);
+        }, timeoutMs);
+        messageWaiters.push((m) => {
+          clearTimeout(timer);
+          resolve(m);
+        });
+      });
+    },
+    sendSignal(handle2, frame) {
+      session?.sendSignal(handle2, frame);
+    },
+    async pollSignal(handle2, timeoutMs) {
+      const box = signalBoxes.get(handle2);
+      if (box !== void 0 && box.length > 0) return box.shift() ?? null;
+      return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+          const waiters2 = signalWaiters.get(handle2);
+          if (waiters2 !== void 0) {
+            const idx = waiters2.indexOf(resolve);
+            if (idx >= 0) waiters2.splice(idx, 1);
+            if (waiters2.length === 0) signalWaiters.delete(handle2);
+          }
+          resolve(null);
+        }, timeoutMs);
+        let waiters = signalWaiters.get(handle2);
+        if (waiters === void 0) {
+          waiters = [];
+          signalWaiters.set(handle2, waiters);
+        }
+        waiters.push((f) => {
+          clearTimeout(timer);
+          resolve(f);
+        });
+      });
+    }
+  };
+}
 function currentState(dir) {
   const p = loadProfile(dir);
   if (!p) return { connected: false, candidates: [] };
@@ -2108,11 +2218,101 @@ async function handle(req, res, opts) {
     sendJson(res, 200, { ok: true });
     return;
   }
+  if (req.method === "GET" && pathname === "/api/room") {
+    const room = opts.room;
+    sendJson(res, 200, room ? { room: room.name, self: room.self ?? null, members: room.members } : { room: null, self: null, members: [] });
+    return;
+  }
+  if (req.method === "GET" && pathname === "/room/message") {
+    const room = opts.room;
+    if (!room) {
+      sendJson(res, 200, { message: null, reason: "room-not-attached" });
+      return;
+    }
+    const message = await room.pollMessage(25e3);
+    if (req.destroyed || res.writableEnded) return;
+    sendJson(res, 200, { message });
+    return;
+  }
+  if (req.method === "POST" && pathname === "/room/message") {
+    const room = opts.room;
+    if (!room) {
+      sendJson(res, 400, { error: "room-not-attached" });
+      return;
+    }
+    const body = await readBody(req);
+    let parsed = {};
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      sendJson(res, 400, { error: "invalid JSON body" });
+      return;
+    }
+    const text = parsed["text"];
+    if (typeof text !== "string") {
+      sendJson(res, 400, { error: "missing text" });
+      return;
+    }
+    const reParsed = parseFrame(
+      JSON.stringify({ t: "msg", id: randomUUID(), text, at: Date.now() })
+    );
+    if (reParsed === null || reParsed.t !== "msg") {
+      sendJson(res, 400, { error: "invalid message text" });
+      return;
+    }
+    room.broadcast(reParsed.text);
+    sendJson(res, 200, { ok: true });
+    return;
+  }
+  if (req.method === "GET" && pathname === "/room/signal") {
+    const room = opts.room;
+    if (!room) {
+      sendJson(res, 200, { frame: null, reason: "room-not-attached" });
+      return;
+    }
+    const handle2 = url.searchParams.get("handle") ?? "";
+    if (handle2 === "") {
+      sendJson(res, 400, { error: "missing handle" });
+      return;
+    }
+    const frame = await room.pollSignal(handle2, 25e3);
+    if (req.destroyed || res.writableEnded) return;
+    sendJson(res, 200, { frame });
+    return;
+  }
+  if (req.method === "POST" && pathname === "/room/signal") {
+    const room = opts.room;
+    if (!room) {
+      sendJson(res, 400, { error: "room-not-attached" });
+      return;
+    }
+    const body = await readBody(req);
+    let parsed = {};
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      sendJson(res, 400, { error: "invalid JSON body" });
+      return;
+    }
+    const handle2 = typeof parsed["handle"] === "string" ? parsed["handle"] : "";
+    if (handle2 === "") {
+      sendJson(res, 400, { error: "missing handle" });
+      return;
+    }
+    const reParsed = parseFrame(JSON.stringify(parsed["frame"]));
+    if (reParsed === null || reParsed.t !== "rtc-offer" && reParsed.t !== "rtc-answer" && reParsed.t !== "rtc-ice") {
+      sendJson(res, 400, { error: "invalid rtc frame" });
+      return;
+    }
+    room.sendSignal(handle2, reParsed);
+    sendJson(res, 200, { ok: true });
+    return;
+  }
   sendJson(res, 404, { error: "not found" });
 }
 
 // src/cli.ts
-var VERSION = "0.5.0";
+var VERSION = "0.7.0";
 function parsePort(raw) {
   const n = Number(raw);
   if (!Number.isInteger(n) || n < 1 || n > 65535) return void 0;
@@ -2127,7 +2327,9 @@ function parseArgs(argv) {
     any: false,
     arg: void 0,
     to: void 0,
-    keepAlive: false
+    keepAlive: false,
+    viaRelay: false,
+    room: void 0
   };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
@@ -2140,7 +2342,9 @@ function parseArgs(argv) {
         any: false,
         arg: void 0,
         to: void 0,
-        keepAlive: false
+        keepAlive: false,
+        viaRelay: false,
+        room: void 0
       };
     }
     if (a === "--help" || a === "-h") {
@@ -2152,7 +2356,9 @@ function parseArgs(argv) {
         any: false,
         arg: void 0,
         to: void 0,
-        keepAlive: false
+        keepAlive: false,
+        viaRelay: false,
+        room: void 0
       };
     }
     if (a === "--live") {
@@ -2163,6 +2369,22 @@ function parseArgs(argv) {
       out = { ...out, keepAlive: true };
       continue;
     }
+    if (a === "--via-relay") {
+      out = { ...out, viaRelay: true };
+      continue;
+    }
+    if (a === "--room") {
+      const next = argv[i + 1];
+      if (next !== void 0) {
+        out = { ...out, room: next };
+        i++;
+      }
+      continue;
+    }
+    if (a.startsWith("--room=")) {
+      out = { ...out, room: a.slice("--room=".length) };
+      continue;
+    }
     if (a === "--any") {
       out = { ...out, any: true };
       continue;
@@ -2198,7 +2420,7 @@ function parseArgs(argv) {
       continue;
     }
     if (a.startsWith("-")) continue;
-    const known = a === "connect" || a === "matches" || a === "discover" || a === "open" || a === "live" || a === "find" || a === "handle" || a === "block" || a === "unblock" || a === "blocklist" || a === "daemon" || a === "mcp" || a === "help" ? a : null;
+    const known = a === "connect" || a === "matches" || a === "discover" || a === "open" || a === "live" || a === "find" || a === "handle" || a === "block" || a === "unblock" || a === "blocklist" || a === "daemon" || a === "mcp" || a === "room" || a === "help" ? a : null;
     if (known !== null && out.command === null) {
       out = { ...out, command: known };
     } else if (out.arg === void 0) {
@@ -2381,7 +2603,7 @@ async function cmdMatches(live) {
   process2.stdout.write("\n");
   return 0;
 }
-async function cmdDiscover(live, any) {
+async function cmdDiscover(live, any, viaRelay) {
   const profile = loadProfile();
   if (!profile) {
     process2.stderr.write("Not connected yet. Run `vibedating connect` first.\n");
@@ -2400,6 +2622,9 @@ async function cmdDiscover(live, any) {
 `);
   process2.stdout.write(`  ${MARKS_LEGEND}
 `);
+  if (viaRelay) {
+    process2.stdout.write("  \u2022 --via-relay: the relay fallback reaches a KNOWN peer over Nostr \u2014 use `live --via-relay --to @handle`\n");
+  }
   const { topics, acceptLeague } = discoveryScope(profile.league, any);
   const session = await startDiscovery({
     hello,
@@ -2439,36 +2664,59 @@ async function cmdDiscover(live, any) {
   );
   return 0;
 }
-async function cmdOpen(port, any) {
+async function cmdOpen(port, any, room) {
   const profile = loadProfile();
   let live;
+  let roomBridge;
   let session;
+  let roomSession;
   if (profile) {
     if (!canShareLive()) grantLiveConsent();
-    live = createLiveBridge();
+    if (room !== void 0) {
+      roomBridge = createRoomBridge(room);
+    } else {
+      live = createLiveBridge();
+    }
   }
-  const started = await startServer({ port, live });
-  if (profile && live) {
+  const started = await startServer({
+    port,
+    live,
+    ...roomBridge === void 0 ? {} : { room: roomBridge }
+  });
+  if (profile) {
     process2.stdout.write(`
   ${LIVE_NOTICE}
 `);
     const hello = buildHello(profile);
-    const { topics, acceptLeague } = discoveryScope(profile.league, any);
-    void startDiscovery({
-      hello,
-      topics,
-      acceptLeague,
-      isBlocked: blockedChecker(),
-      onLink: (link) => live.addLink(link)
-    }).then((s) => {
-      session = s;
-    }).catch(() => {
-    });
+    if (room !== void 0 && roomBridge !== void 0) {
+      void startRoom({ hello, room, isBlocked: blockedChecker() }).then((s) => {
+        roomSession = s;
+        roomBridge.attach(s);
+      }).catch(() => {
+      });
+    } else if (live) {
+      const { topics, acceptLeague } = discoveryScope(profile.league, any);
+      void startDiscovery({
+        hello,
+        topics,
+        acceptLeague,
+        isBlocked: blockedChecker(),
+        onLink: (link) => live.addLink(link)
+      }).then((s) => {
+        session = s;
+      }).catch(() => {
+      });
+    }
   }
   process2.stdout.write(`
   vibedating local web app \u2192 ${started.url}
 `);
-  if (live) {
+  if (room !== void 0) {
+    process2.stdout.write(
+      `  \u2022 room: ${room} \u2014 roster + group chat + full-mesh group video (~6 people; an SFU is the upgrade path for bigger rooms)
+`
+    );
+  } else if (live) {
     process2.stdout.write(
       any ? "  \u2022 live video + chat available for connected peers (ANY league \u2014 --any)\n" : "  \u2022 live video + chat available for connected peers (your league + adjacent; --any = everyone)\n"
     );
@@ -2482,6 +2730,7 @@ async function cmdOpen(port, any) {
     process2.once("SIGTERM", () => resolve());
   });
   process2.stdout.write("\n  shutting down\u2026\n");
+  if (roomSession) await roomSession.close();
   if (session) await session.close();
   await new Promise((resolve) => started.server.close(() => resolve()));
   return 0;
@@ -2489,7 +2738,100 @@ async function cmdOpen(port, any) {
 function shouldKeepAlive(flag, stdinIsTTY) {
   return flag || stdinIsTTY !== true;
 }
-async function cmdLive(dating, any, to, keepAlive) {
+async function cmdLiveViaRelay(profile, to) {
+  const target = to !== void 0 ? normalizeHandle(to) : null;
+  if (to !== void 0 && target === null) {
+    process2.stderr.write(`invalid target handle: ${to}
+`);
+    return 1;
+  }
+  if (target === null) {
+    process2.stderr.write(
+      "relay mode (v0) targets one known peer \u2014 use: vibedating live --via-relay --to <@handle>\n(discover the peer first with `vibedating discover --live`, then reach them over the relay).\n"
+    );
+    return 1;
+  }
+  const peer = loadPeers().find((p) => sameHandle(p.handle, target) && typeof p.pubkey === "string");
+  if (peer === void 0 || peer.pubkey === void 0) {
+    process2.stderr.write(
+      `${target} is not a known peer with an identity pubkey. Run \`vibedating discover --live\` first to meet them over the DHT, then retry --via-relay.
+`
+    );
+    return 1;
+  }
+  const identity = loadOrCreateIdentity();
+  process2.stdout.write("\n");
+  process2.stdout.write(`  ${LIVE_NOTICE}
+`);
+  process2.stdout.write(
+    `  routing e2e chat to ${sanitizePeerText(peer.handle)} through public Nostr relays (direct hole-punch fallback)
+`
+  );
+  process2.stdout.write("  \u2022 the relay stores only ciphertext \u2014 it cannot read your chat\n");
+  const myNostr = await loadOrCreateNostrKey();
+  const transport = await createNostrPoolTransport();
+  const link = await createNostrRelayLink({
+    myNostr,
+    myEd25519Hex: identity.publicKeyHex,
+    peerEd25519Hex: peer.pubkey,
+    hello: peer,
+    transport
+  });
+  const pairing = createPairing();
+  pairing.onMatch((l) => {
+    if (l === void 0) {
+      process2.stdout.write("  \xB7 relay peer gone\n");
+      return;
+    }
+    const { qual } = peerDirection(profile.league, l.hello.league);
+    process2.stdout.write(
+      `  \xB7 relayed to ${sanitizePeerText(l.hello.handle)} (${l.hello.league}${qual} \xB7 ${l.hello.harness}) ${usageMark(l.hello)}${idMark(l.hello)}
+`
+    );
+    l.onMessage((m) => {
+      process2.stdout.write(`  <${sanitizePeerText(l.hello.handle)}> ${sanitizePeerText(m.text)}
+`);
+    });
+  });
+  pairing.add(link);
+  process2.stdout.write("  type to chat \xB7 /quit\n");
+  process2.stdout.write("  (Ctrl+C to stop)\n\n");
+  const rl = readline.createInterface({ input: process2.stdin, terminal: false });
+  const stop = () => {
+    rl.close();
+  };
+  process2.once("SIGINT", stop);
+  process2.once("SIGTERM", stop);
+  let quitRequested = false;
+  for await (const line of rl) {
+    const text = line.trim();
+    if (text === "/quit") {
+      quitRequested = true;
+      break;
+    }
+    if (text === "/next") {
+      process2.stdout.write("  \xB7 relay mode targets one peer \u2014 /next re-announces presence\n");
+      continue;
+    }
+    if (text === "") continue;
+    const cur2 = pairing.current();
+    if (cur2 !== void 0) {
+      cur2.send(text);
+    } else {
+      process2.stdout.write("  \xB7 no relay peer yet \u2014 waiting for the presence exchange\u2026\n");
+    }
+  }
+  process2.removeListener("SIGINT", stop);
+  process2.removeListener("SIGTERM", stop);
+  void quitRequested;
+  const cur = pairing.current();
+  if (cur !== void 0) cur.close();
+  process2.stdout.write("\n  closing relay link\u2026\n");
+  link.close();
+  process2.stdout.write("\n");
+  return 0;
+}
+async function cmdLive(dating, any, to, keepAlive, viaRelay) {
   const profile = loadProfile();
   if (!profile) {
     process2.stderr.write("Not connected yet. Run `vibedating connect` first.\n");
@@ -2506,6 +2848,7 @@ async function cmdLive(dating, any, to, keepAlive) {
     process2.stderr.write("Could not enable live discovery. Try `vibedating discover --live`.\n");
     return 1;
   }
+  if (viaRelay) return cmdLiveViaRelay(profile, to);
   const hello = buildHello(profile);
   process2.stdout.write("\n");
   process2.stdout.write(`  ${LIVE_NOTICE}
@@ -2610,6 +2953,104 @@ async function cmdLive(dating, any, to, keepAlive) {
   process2.stdout.write("\n");
   return 0;
 }
+async function cmdRoom(name, keepAlive) {
+  if (name === void 0 || name.trim() === "") {
+    process2.stderr.write("usage: vibedating room <name>\n");
+    return 1;
+  }
+  const profile = loadProfile();
+  if (!profile) {
+    process2.stderr.write("Not connected yet. Run `vibedating connect` first.\n");
+    return 1;
+  }
+  if (!canShareLive()) grantLiveConsent();
+  if (!canShareLive()) {
+    process2.stderr.write("Could not enable live discovery. Try `vibedating discover --live`.\n");
+    return 1;
+  }
+  const hello = buildHello(profile);
+  process2.stdout.write("\n");
+  process2.stdout.write(`  ${LIVE_NOTICE}
+`);
+  process2.stdout.write(`  ${MARKS_LEGEND}
+`);
+  process2.stdout.write(`  room: ${name}  (cross-league \u2014 everyone in the room is a member)
+`);
+  const session = await startRoom({
+    hello,
+    room: name,
+    isBlocked: blockedChecker()
+  });
+  session.onRoster((members) => {
+    if (members.length === 0) {
+      process2.stdout.write("  \xB7 room empty \u2014 waiting for members\u2026\n");
+      return;
+    }
+    const list = members.map(
+      (m) => `${sanitizePeerText(m.handle)} (${m.league} \xB7 ${m.harness}) ${usageMark(m)}${idMark(m)}`
+    ).join(", ");
+    process2.stdout.write(`  \xB7 room (${members.length}): ${list}
+`);
+  });
+  session.onMessage((m) => {
+    process2.stdout.write(`  <${sanitizePeerText(m.from)}> ${sanitizePeerText(m.text)}
+`);
+  });
+  process2.stdout.write(
+    `  topic: ${ROOM_TOPIC_PREFIX}${name} \u2192 ${session.topic.toString("hex").slice(0, 12)}\u2026
+`
+  );
+  process2.stdout.write("  type to broadcast to the whole room \xB7 /who \xB7 /quit\n");
+  process2.stdout.write(`  group video: run \`vibedating open --room ${name}\`
+
+`);
+  const rl = readline.createInterface({ input: process2.stdin, terminal: false });
+  const stop = () => {
+    rl.close();
+  };
+  process2.once("SIGINT", stop);
+  process2.once("SIGTERM", stop);
+  let quitRequested = false;
+  for await (const line of rl) {
+    const text = line.trim();
+    if (text === "/quit") {
+      quitRequested = true;
+      break;
+    }
+    if (text === "/who") {
+      const members = [...session.members.values()];
+      if (members.length === 0) {
+        process2.stdout.write("  \xB7 room empty\n");
+      } else {
+        for (const m of members) {
+          process2.stdout.write(
+            `  \xB7 ${sanitizePeerText(m.handle)} (${m.league} \xB7 ${m.harness}) ${usageMark(m)}${idMark(m)}
+`
+          );
+        }
+      }
+      continue;
+    }
+    if (text === "") continue;
+    const reached = session.broadcast(text);
+    if (reached.length === 0) {
+      process2.stdout.write("  \xB7 room empty \u2014 no one to hear you yet\n");
+    }
+  }
+  if (!quitRequested && shouldKeepAlive(keepAlive, process2.stdin.isTTY)) {
+    process2.stdout.write("  stdin closed \u2014 staying in the room (Ctrl+C / SIGTERM to leave)\n");
+    await new Promise((resolve) => {
+      process2.once("SIGINT", () => resolve());
+      process2.once("SIGTERM", () => resolve());
+    });
+  }
+  process2.removeListener("SIGINT", stop);
+  process2.removeListener("SIGTERM", stop);
+  process2.stdout.write("\n  leaving the room\u2026\n");
+  await session.close();
+  process2.stdout.write("\n");
+  return 0;
+}
 async function cmdFind(targetArg, any) {
   if (targetArg === void 0 || targetArg.trim() === "") {
     process2.stderr.write("usage: vibedating find <@handle> [--any]\n");
@@ -2846,10 +3287,11 @@ Usage:
   vibedating connect            Read your usage, compute + print your league
   vibedating matches [--live]   List candidates in your league (live peers if any)
   vibedating discover [--live] [--any]  Find live peers over the DHT (your league + adjacent; --any = everyone)
-  vibedating live [--dating] [--any] [--to @handle] [--keep-alive]  Live chat (your league
+  vibedating live [--dating] [--any] [--to @handle] [--keep-alive] [--via-relay]  Live chat (your league
                                 + adjacent; --any = everyone; /next or --dating pick;
                                 --to targets one peer; --keep-alive survives stdin EOF \u2014
-                                automatic when stdin is not a TTY)
+                                automatic when stdin is not a TTY; --via-relay routes e2e chat
+                                through public Nostr relays when direct hole-punching fails)
   vibedating find <@handle> [--any]  Search the DHT for one specific handle (\u2605 highlights a match)
   vibedating handle [@name]     Print or set your handle (persisted; a leading '@' is optional)
   vibedating block <@handle>    Block a handle \u2014 their hello is dropped (never recorded/paired)
@@ -2860,9 +3302,15 @@ Usage:
                                 NEW matches, never opens chat/video. install adds a
                                 login service (launchd on macOS, systemd on Linux);
                                 uninstall removes it.
-  vibedating open [--port N] [--any]  Serve the local web app (default: random port)
-                                + live video + chat with connected peers
-                                (your league + adjacent; --any = every league)
+  vibedating room <name>        Join/create a named room (multi-peer): live roster
+                                + group text chat broadcast to all members.
+                                Consent-gated like live. /who lists members, /quit leaves.
+  vibedating open [--port N] [--any] [--room <name>]  Serve the local web app (default:
+                                random port) + live video + chat with connected peers
+                                (your league + adjacent; --any = every league).
+                                --room <name> opens the room view instead: roster +
+                                group chat + full-mesh group video (~6 people; an SFU
+                                is the upgrade path for bigger rooms).
   vibedating mcp                Run the stdio MCP server (profile, matches)
   vibedating --version
   vibedating --help
@@ -2912,13 +3360,15 @@ async function main(argv) {
     case "matches":
       return cmdMatches(parsed.live);
     case "discover":
-      return cmdDiscover(parsed.live, parsed.any);
+      return cmdDiscover(parsed.live, parsed.any, parsed.viaRelay);
     case "open":
-      return cmdOpen(parsed.port, parsed.any);
+      return cmdOpen(parsed.port, parsed.any, parsed.room);
     case "live":
-      return cmdLive(parsed.dating, parsed.any, parsed.to, parsed.keepAlive);
+      return cmdLive(parsed.dating, parsed.any, parsed.to, parsed.keepAlive, parsed.viaRelay);
     case "find":
       return cmdFind(parsed.arg, parsed.any);
+    case "room":
+      return cmdRoom(parsed.arg ?? parsed.room, parsed.keepAlive);
     case "mcp":
       await runMcp();
       return 0;