vibedate 0.6.0 → 0.7.1

package/dist/{chunk-VZXPYU2C.js → chunk-HDHJLZZG.js}

@@ -1145,6 +1145,103 @@ async function createNostrPoolTransport(urls = DEFAULT_RELAYS) {
   };
 }
 
+// src/room.ts
+import { createHash as createHash3 } from "crypto";
+var ROOM_TOPIC_PREFIX = "vibedate-room:";
+function roomTopic(name) {
+  return createHash3("sha256").update(`${ROOM_TOPIC_PREFIX}${name}`, "utf8").digest();
+}
+async function startRoom(opts) {
+  const topic = roomTopic(opts.room);
+  const entries = /* @__PURE__ */ new Map();
+  const memberHellos = /* @__PURE__ */ new Map();
+  const messageCbs = /* @__PURE__ */ new Set();
+  const rosterCbs = /* @__PURE__ */ new Set();
+  const signalCbs = /* @__PURE__ */ new Set();
+  const fireRoster = () => {
+    const snapshot = [...memberHellos.values()];
+    for (const cb of rosterCbs) cb(snapshot);
+  };
+  let discovery;
+  const ready = startDiscovery({
+    hello: opts.hello,
+    // ONE topic — the room's own. Rooms are intentionally cross-league, so
+    // every member of the room is accepted regardless of advertised league.
+    topics: [topic],
+    acceptLeague: () => true,
+    ...opts.isBlocked === void 0 ? {} : { isBlocked: opts.isBlocked },
+    ...opts.bootstrap === void 0 ? {} : { bootstrap: opts.bootstrap },
+    ...opts.stateDir === void 0 ? {} : { stateDir: opts.stateDir },
+    ...opts.notify === void 0 ? {} : { notify: opts.notify },
+    onLink: (link) => {
+      const handle = link.hello.handle;
+      entries.set(handle, { hello: link.hello, link });
+      memberHellos.set(handle, link.hello);
+      fireRoster();
+      link.onMessage((m) => {
+        for (const cb of messageCbs) cb({ from: handle, ...m });
+      });
+      link.onSignal((frame) => {
+        for (const cb of signalCbs) cb(handle, frame);
+      });
+      link.onClose(() => {
+        const cur = entries.get(handle);
+        if (cur && cur.link === link) {
+          entries.delete(handle);
+          memberHellos.delete(handle);
+          fireRoster();
+        }
+      });
+    }
+  }).then((s) => {
+    discovery = s;
+    return s.ready;
+  });
+  const session = {
+    room: opts.room,
+    topic,
+    hello: opts.hello,
+    members: memberHellos,
+    ready,
+    broadcast(text) {
+      const reached = [];
+      for (const [handle, entry] of entries) {
+        entry.link.send(text);
+        reached.push(handle);
+      }
+      return reached;
+    },
+    onMessage(cb) {
+      messageCbs.add(cb);
+    },
+    onRoster(cb) {
+      rosterCbs.add(cb);
+    },
+    onSignal(cb) {
+      signalCbs.add(cb);
+    },
+    sendSignal(handle, frame) {
+      entries.get(handle)?.link.sendSignal(frame);
+    },
+    linkFor(handle) {
+      return entries.get(handle)?.link;
+    },
+    async close() {
+      await ready.catch(() => void 0);
+      for (const entry of entries.values()) {
+        try {
+          entry.link.close();
+        } catch {
+        }
+      }
+      entries.clear();
+      memberHellos.clear();
+      if (discovery !== void 0) await discovery.close();
+    }
+  };
+  return session;
+}
+
 // src/index.ts
 var LEAGUES = [
   { name: "1M", min: 1e6, max: 4999999 },
@@ -1320,6 +1417,9 @@ export {
   conversationTag,
   createNostrRelayLink,
   createNostrPoolTransport,
+  ROOM_TOPIC_PREFIX,
+  roomTopic,
+  startRoom,
   LEAGUES,
   BELOW_LEAGUE,
   league,

package/dist/{chunk-JIBC3OHV.js → chunk-ZD6JBWEW.js}

@@ -2,7 +2,7 @@ import {
   CANDIDATES,
   loadProfile,
   matches
-} from "./chunk-VZXPYU2C.js";
+} from "./chunk-HDHJLZZG.js";
 
 // src/mcp.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

package/dist/cli.d.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /** Recognized top-level commands, plus the synthetic help/version. */
-type Command = 'connect' | 'matches' | 'discover' | 'open' | 'live' | 'find' | 'handle' | 'block' | 'unblock' | 'blocklist' | 'daemon' | 'mcp' | 'help' | 'version' | null;
+type Command = 'connect' | 'matches' | 'discover' | 'open' | 'live' | 'find' | 'handle' | 'block' | 'unblock' | 'blocklist' | 'daemon' | 'mcp' | 'room' | 'help' | 'version' | null;
 interface ParsedArgs {
     readonly command: Command;
     /** Port for `open --port`; undefined means "let the OS pick". */
@@ -23,6 +23,8 @@ interface ParsedArgs {
      * auto-fallback-on-timeout is a follow-up. Default false.
      */
     readonly viaRelay: boolean;
+    /** `room <name>` positional, or `--room <name>`: join/create a named room. */
+    readonly room: string | undefined;
 }
 /**
  * Parse argv (the slice AFTER the program name) into a command + options.

package/dist/cli.js

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 import {
   runMcp
-} from "./chunk-JIBC3OHV.js";
+} from "./chunk-ZD6JBWEW.js";
 import {
   CANDIDATES,
   DEFAULT_HANDLE,
   LIVE_NOTICE,
   MAX_HANDLE_LEN,
+  ROOM_TOPIC_PREFIX,
   TOPIC_PREFIX,
   addBlock,
   allLeagueNames,
@@ -37,8 +38,9 @@ import {
   sanitizePeerText,
   saveHandle,
   signHelloClaims,
-  startDiscovery
-} from "./chunk-VZXPYU2C.js";
+  startDiscovery,
+  startRoom
+} from "./chunk-HDHJLZZG.js";
 
 // src/cli.ts
 import readline from "readline";
@@ -912,6 +914,56 @@ var webAppHtml = `<!DOCTYPE html>
   .incoming-call p{ color: var(--muted); font-size: .85rem; margin: 0 0 18px; }
   .incoming-call .ic-actions{ display: flex; gap: 10px; }
 
+  /* ---- room full-mesh group video ---- */
+  .room-panel{
+    position: fixed; right: 18px; bottom: 18px; z-index: 45;
+    background: linear-gradient(180deg, var(--bg-card), var(--bg-card-2));
+    border: 1px solid var(--border-2); border-radius: 16px; box-shadow: var(--shadow-2);
+    padding: 12px 14px; min-width: 240px; max-width: 280px; display: none;
+  }
+  .room-panel.is-open{ display: block; animation: rise var(--dur-med) var(--ease-out); }
+  .room-panel .rp-title{ font-size: .78rem; font-weight: 800; margin-bottom: 6px; display:flex; align-items:center; gap:6px; }
+  .room-panel .rp-meta{ font-size: .7rem; color: var(--muted-2); margin-bottom: 10px; line-height: 1.4; word-break: break-all; }
+  .room-panel .rp-actions{ display:flex; gap: 8px; }
+  .room-panel .rp-btn{
+    border: 0; border-radius: 9px; padding: 8px 14px; font-weight: 700; font-size: .78rem;
+    background: linear-gradient(180deg, var(--coral), var(--coral-dim)); color: #2a1109;
+    flex: 1;
+  }
+  .room-panel .rp-btn:disabled{ opacity: .4; cursor: not-allowed; }
+  .room-panel .rp-btn.is-leave{ background: var(--danger); color: #2a0a0c; }
+  .room-video{
+    position: fixed; inset: 0; z-index: 68;
+    display: none; flex-direction: column; align-items: stretch; justify-content: flex-start;
+    background: rgba(12,7,15,.86); backdrop-filter: blur(8px); -webkit-backdrop-filter: blur(8px);
+    padding: 18px 18px 80px;
+  }
+  .room-video.is-open{ display: flex; }
+  .room-video .rv-head{
+    display:flex; align-items:center; justify-content: space-between; gap: 12px;
+    margin-bottom: 14px; color: var(--fg); font-weight: 800; font-size: .9rem;
+  }
+  .room-video .rv-grid{
+    flex: 1; display: grid; gap: 12px; min-height: 0;
+    grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+    align-content: start;
+  }
+  .room-video .rv-tile{
+    display:flex; flex-direction: column; gap: 6px; min-width: 0;
+  }
+  .room-video .rv-tile video{
+    width: 100%; aspect-ratio: 4 / 3; background: #000; border-radius: 14px;
+    border: 1px solid var(--border-2); object-fit: cover;
+  }
+  .room-video .rv-tile .rv-label{
+    font-size: .75rem; color: var(--muted); font-weight: 600; word-break: break-all;
+  }
+  .room-video .rv-leave{
+    position: absolute; bottom: 24px; left: 50%; transform: translateX(-50%);
+    border: 0; border-radius: 999px; padding: 12px 22px; font-weight: 800; font-size: .9rem;
+    background: var(--danger); color: #2a0a0c;
+  }
+
   /* ---- live text chat (browser <-> PeerLink over /live/message) ---- */
   .live-actions{ display: flex; gap: 6px; flex-shrink: 0; }
   .live-row .cbtn{
@@ -1149,6 +1201,24 @@ var webAppHtml = `<!DOCTYPE html>
   <button class="vhangup" id="hangupBtn" type="button">Hang up</button>
 </div>
 
+<aside class="room-panel" id="roomPanel" aria-label="Room">
+  <div class="rp-title"><span class="lp-dot" aria-hidden="true"></span> Room</div>
+  <div class="rp-meta" id="roomMeta">not in a room</div>
+  <div class="rp-actions">
+    <button class="rp-btn" id="roomJoinBtn" type="button">Join video</button>
+    <button class="rp-btn is-leave" id="roomLeaveBtn" type="button" disabled>Leave</button>
+  </div>
+</aside>
+
+<div class="room-video" id="roomVideo" role="dialog" aria-modal="true" aria-label="Room video">
+  <div class="rv-head">
+    <span id="roomVideoTitle">Room video</span>
+    <span id="roomVideoCount" style="font-weight:600;color:var(--muted);font-size:.78rem"></span>
+  </div>
+  <div class="rv-grid" id="roomVideoGrid"></div>
+  <button class="rv-leave" id="roomVideoLeaveBtn" type="button">Leave video</button>
+</div>
+
 <script>
 (function(){
   "use strict";
@@ -1814,6 +1884,252 @@ var webAppHtml = `<!DOCTYPE html>
   }
   refreshPeers();
   setInterval(refreshPeers, 4000);
+
+  /* ---- Room full-mesh group video ----------------------------------------
+   * When vibedate open --room <name> is attached, /api/room exposes the
+   * roster. Each browser grabs getUserMedia once and opens one
+   * RTCPeerConnection to every other member. Deterministic offerer election
+   * (self < other lexicographic) avoids glare. Signaling rides the local
+   * server's merged mailbox: GET /room/signal?handle=SELF returns
+   * { frame: { from, rtc } }, POST /room/signal { handle: TARGET, frame }
+   * relays one rtc-* frame to that member. */
+  var roomPanel = document.getElementById("roomPanel");
+  var roomMeta = document.getElementById("roomMeta");
+  var roomJoinBtn = document.getElementById("roomJoinBtn");
+  var roomLeaveBtn = document.getElementById("roomLeaveBtn");
+  var roomVideo = document.getElementById("roomVideo");
+  var roomVideoGrid = document.getElementById("roomVideoGrid");
+  var roomVideoTitle = document.getElementById("roomVideoTitle");
+  var roomVideoCount = document.getElementById("roomVideoCount");
+  var roomVideoLeaveBtn = document.getElementById("roomVideoLeaveBtn");
+
+  var roomVid = { localStream: null, peers: {}, self: null, room: null, joined: false, polling: false };
+  var roomLastRoster = [];
+
+  function roomPostSignal(handle, frame){
+    return fetch("/room/signal", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ handle: handle, frame: frame })
+    }).catch(function(){ /* best effort */ });
+  }
+
+  function roomFetchSignal(selfHandle, timeoutMs){
+    var ctrl = new AbortController();
+    var t = setTimeout(function(){ ctrl.abort(); }, timeoutMs);
+    return fetch("/room/signal?handle=" + encodeURIComponent(selfHandle), { signal: ctrl.signal })
+      .then(function(r){ clearTimeout(t); return r; })
+      .catch(function(e){ clearTimeout(t); throw e; });
+  }
+
+  function makeRoomTile(label, muted){
+    var tile = document.createElement("div");
+    tile.className = "rv-tile";
+    var vid = document.createElement("video");
+    vid.autoplay = true;
+    vid.playsInline = true;
+    if (muted) vid.muted = true;
+    var lab = document.createElement("div");
+    lab.className = "rv-label";
+    lab.textContent = label;
+    tile.appendChild(vid);
+    tile.appendChild(lab);
+    roomVideoGrid.appendChild(tile);
+    return vid;
+  }
+
+  function updateRoomCount(){
+    var n = 0;
+    if (roomVid.localStream) n++;
+    for (var k in roomVid.peers) if (Object.prototype.hasOwnProperty.call(roomVid.peers, k)) n++;
+    roomVideoCount.textContent = n ? (n + " tile" + (n === 1 ? "" : "s")) : "";
+  }
+
+  function connectPeer(handle, role){
+    if (!roomVid.localStream || !roomVid.self) return null;
+    if (roomVid.peers[handle]) return roomVid.peers[handle];
+    var pc = new RTCPeerConnection(rtcConfig());
+    var videoEl = makeRoomTile(handle, false);
+    var peer = { pc: pc, videoEl: videoEl, role: role };
+    roomVid.peers[handle] = peer;
+    updateRoomCount();
+
+    roomVid.localStream.getTracks().forEach(function(t){ pc.addTrack(t, roomVid.localStream); });
+    pc.onicecandidate = function(e){
+      // Trickle ICE to this peer. Empty candidate = end-of-candidates marker.
+      roomPostSignal(handle, {
+        t: "rtc-ice",
+        candidate: e.candidate && e.candidate.candidate ? e.candidate.candidate : ""
+      });
+    };
+    pc.ontrack = function(e){
+      if (e.streams && e.streams[0]) videoEl.srcObject = e.streams[0];
+    };
+    pc.onconnectionstatechange = function(){
+      // Quiet \u2014 closed peers stay in the grid until Leave clears everything.
+    };
+
+    if (role === "offerer") {
+      (async function(){
+        try {
+          var offer = await pc.createOffer();
+          await pc.setLocalDescription(offer);
+          await roomPostSignal(handle, { t: "rtc-offer", sdp: offer.sdp });
+        } catch(e){ /* offer failed \u2014 peer will retry on next roster refresh if still present */ }
+      })();
+    }
+    return peer;
+  }
+
+  async function handleRoomSignal(from, rtc){
+    if (!rtc || !from || from === roomVid.self) return;
+    if (rtc.t === "rtc-offer") {
+      var peer = roomVid.peers[from];
+      if (!peer) peer = connectPeer(from, "answerer");
+      if (!peer) return;
+      try {
+        await peer.pc.setRemoteDescription({ type: "offer", sdp: rtc.sdp });
+        var answer = await peer.pc.createAnswer();
+        await peer.pc.setLocalDescription(answer);
+        await roomPostSignal(from, { t: "rtc-answer", sdp: answer.sdp });
+      } catch(e){}
+      return;
+    }
+    if (rtc.t === "rtc-answer") {
+      var pAns = roomVid.peers[from];
+      if (!pAns) return;
+      try { await pAns.pc.setRemoteDescription({ type: "answer", sdp: rtc.sdp }); } catch(e){}
+      return;
+    }
+    if (rtc.t === "rtc-ice") {
+      var pIce = roomVid.peers[from];
+      if (!pIce) return;
+      // Skip empty candidate (end-of-candidates) \u2014 browsers tolerate either way.
+      if (!rtc.candidate) return;
+      try { await pIce.pc.addIceCandidate({ candidate: rtc.candidate }); } catch(e){}
+    }
+  }
+
+  async function roomSignalLoop(){
+    if (roomVid.polling) return;
+    roomVid.polling = true;
+    while (roomVid.joined && roomVid.self) {
+      var res;
+      try { res = await roomFetchSignal(roomVid.self, 5000); }
+      catch(e){ await sleep(400); continue; }
+      if (!res || res.status !== 200) { await sleep(400); continue; }
+      var data;
+      try { data = await res.json(); } catch(e){ continue; }
+      var f = data && data.frame;
+      if (!f) continue; // timeout empty
+      // Sender-routed shape: { from, rtc } (or a nested frame.frame fallback).
+      var from = f.from;
+      var rtc = f.rtc || f.frame || f;
+      if (from && rtc && rtc.t) await handleRoomSignal(from, rtc);
+    }
+    roomVid.polling = false;
+  }
+
+  function meshWithMembers(members){
+    if (!roomVid.joined || !roomVid.self || !roomVid.localStream) return;
+    var self = roomVid.self;
+    var seen = {};
+    (members || []).forEach(function(m){
+      var h = m && m.handle;
+      if (!h || h === self) return;
+      seen[h] = true;
+      if (roomVid.peers[h]) return;
+      // Deterministic glare avoidance: lower handle is the offerer.
+      if (self < h) connectPeer(h, "offerer");
+      // else wait for their offer via the long-poll loop
+    });
+  }
+
+  async function joinRoomVideo(){
+    if (roomVid.joined) return;
+    if (!roomVid.self || !roomVid.room) return;
+    roomJoinBtn.disabled = true;
+    try {
+      roomVid.localStream = await navigator.mediaDevices.getUserMedia({ video: true, audio: true });
+    } catch(e){
+      roomJoinBtn.disabled = false;
+      roomMeta.textContent = (roomVid.room || "room") + " \xB7 camera/mic blocked";
+      return;
+    }
+    roomVid.joined = true;
+    roomVid.peers = {};
+    roomVideoGrid.innerHTML = "";
+    var localEl = makeRoomTile((roomVid.self || "you") + " (you)", true);
+    localEl.srcObject = roomVid.localStream;
+    roomVideo.classList.add("is-open");
+    roomVideoTitle.textContent = "Room \xB7 " + roomVid.room;
+    roomLeaveBtn.disabled = false;
+    updateRoomCount();
+    roomSignalLoop();
+    // Seed mesh against the latest roster, then refresh once more for races.
+    meshWithMembers(roomLastRoster);
+    try {
+      var res = await fetch("/api/room");
+      if (res.status === 200) {
+        var data = await res.json();
+        var members = (data && data.members) || [];
+        roomLastRoster = members;
+        meshWithMembers(members);
+      }
+    } catch(e){}
+  }
+
+  function leaveRoomVideo(){
+    roomVid.joined = false;
+    for (var h in roomVid.peers) {
+      if (!Object.prototype.hasOwnProperty.call(roomVid.peers, h)) continue;
+      try { roomVid.peers[h].pc.close(); } catch(e){}
+    }
+    roomVid.peers = {};
+    if (roomVid.localStream) {
+      roomVid.localStream.getTracks().forEach(function(t){ try { t.stop(); } catch(e){} });
+      roomVid.localStream = null;
+    }
+    roomVideoGrid.innerHTML = "";
+    roomVideo.classList.remove("is-open");
+    roomLeaveBtn.disabled = true;
+    roomJoinBtn.disabled = !roomVid.room;
+    updateRoomCount();
+  }
+
+  roomJoinBtn.addEventListener("click", function(){ joinRoomVideo().catch(function(){ leaveRoomVideo(); }); });
+  roomLeaveBtn.addEventListener("click", leaveRoomVideo);
+  roomVideoLeaveBtn.addEventListener("click", leaveRoomVideo);
+
+  async function refreshRoom(){
+    try {
+      var res = await fetch("/api/room");
+      if (res.status !== 200) return;
+      var data = await res.json();
+      var roomName = data && data.room;
+      if (!roomName) {
+        if (roomVid.joined) leaveRoomVideo();
+        roomVid.room = null;
+        roomVid.self = null;
+        roomLastRoster = [];
+        roomPanel.classList.remove("is-open");
+        return;
+      }
+      roomVid.room = roomName;
+      roomVid.self = data.self || null;
+      roomLastRoster = (data.members) || [];
+      var n = roomLastRoster.length;
+      roomMeta.textContent = roomName +
+        (roomVid.self ? " \xB7 you " + roomVid.self : "") +
+        " \xB7 " + n + " other" + (n === 1 ? "" : "s");
+      roomPanel.classList.add("is-open");
+      roomJoinBtn.disabled = roomVid.joined || !roomVid.self;
+      roomLeaveBtn.disabled = !roomVid.joined;
+      if (roomVid.joined) meshWithMembers(roomLastRoster);
+    } catch(e){}
+  }
+  refreshRoom();
+  setInterval(refreshRoom, 4000);
 })();
 </script>
 </body>
@@ -1891,6 +2207,93 @@ function createLiveBridge() {
   };
   return bridge;
 }
+var MAX_QUEUED_ROOM_SIGNALS = 200;
+function createRoomBridge(name) {
+  let session;
+  const messageQueue = [];
+  const messageWaiters = [];
+  const signalQueue = [];
+  const signalWaiters = [];
+  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 tagged = { from, rtc: frame };
+    const waiter = signalWaiters.shift();
+    if (waiter !== void 0) {
+      waiter(tagged);
+      return;
+    }
+    signalQueue.push(tagged);
+    if (signalQueue.length > MAX_QUEUED_ROOM_SIGNALS) {
+      signalQueue.splice(0, signalQueue.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(_handle, timeoutMs) {
+      if (signalQueue.length > 0) return signalQueue.shift() ?? null;
+      return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+          const idx = signalWaiters.indexOf(resolve);
+          if (idx >= 0) signalWaiters.splice(idx, 1);
+          resolve(null);
+        }, timeoutMs);
+        signalWaiters.push((s) => {
+          clearTimeout(timer);
+          resolve(s);
+        });
+      });
+    }
+  };
+}
 function currentState(dir) {
   const p = loadProfile(dir);
   if (!p) return { connected: false, candidates: [] };
@@ -2111,11 +2514,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.6.0";
+var VERSION = "0.7.1";
 function parsePort(raw) {
   const n = Number(raw);
   if (!Number.isInteger(n) || n < 1 || n > 65535) return void 0;
@@ -2131,7 +2624,8 @@ function parseArgs(argv) {
     arg: void 0,
     to: void 0,
     keepAlive: false,
-    viaRelay: false
+    viaRelay: false,
+    room: void 0
   };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
@@ -2145,7 +2639,8 @@ function parseArgs(argv) {
         arg: void 0,
         to: void 0,
         keepAlive: false,
-        viaRelay: false
+        viaRelay: false,
+        room: void 0
       };
     }
     if (a === "--help" || a === "-h") {
@@ -2158,7 +2653,8 @@ function parseArgs(argv) {
         arg: void 0,
         to: void 0,
         keepAlive: false,
-        viaRelay: false
+        viaRelay: false,
+        room: void 0
       };
     }
     if (a === "--live") {
@@ -2173,6 +2669,18 @@ function parseArgs(argv) {
       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;
@@ -2208,7 +2716,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) {
@@ -2452,36 +2960,59 @@ async function cmdDiscover(live, any, viaRelay) {
   );
   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"
     );
@@ -2495,6 +3026,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;
@@ -2717,6 +3249,104 @@ async function cmdLive(dating, any, to, keepAlive, viaRelay) {
   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");
@@ -2968,9 +3598,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
@@ -3022,11 +3658,13 @@ async function main(argv) {
     case "discover":
       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, 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;

package/dist/index.d.ts

@@ -351,6 +351,87 @@ declare function createNostrRelayLink(opts: CreateNostrRelayLinkOptions): Promis
  */
 declare function createNostrPoolTransport(urls?: readonly string[]): Promise<RelayTransport>;
 
+/** Namespace prefix so room topics never collide with league topics (or anything
+ *  else on the DHT). Mirrors {@link p2p.TOPIC_PREFIX} for the 1:1 path. */
+declare const ROOM_TOPIC_PREFIX = "vibedate-room:";
+/**
+ * Derive the 32-byte DHT topic for a named room. Deterministic: everyone who
+ * joins the same room name anywhere in the world hashes to the same topic,
+ * which is the entire discovery mechanism. Pure (mirrors {@link p2p.leagueTopic}).
+ */
+declare function roomTopic(name: string): Buffer;
+/** A room member = a connected, handshaken peer. Same shape as a live peer. */
+type RoomMember = PeerHello;
+/** One group chat message: a `msg` frame's payload tagged with the sender. */
+interface RoomMessage {
+    /** Sender's handle (from the validated hello — UNTRUSTED display data). */
+    readonly from: string;
+    readonly id: string;
+    readonly text: string;
+    readonly at: number;
+}
+interface RoomOptions {
+    /** What we broadcast. Must already be consent-gated by the caller. */
+    readonly hello: PeerHello;
+    /** Room name → its own DHT topic (see {@link roomTopic}). */
+    readonly room: string;
+    /** DHT bootstrap nodes; omit for the public DHT. Tests pass a local testnet. */
+    readonly bootstrap?: ReadonlyArray<{
+        readonly host: string;
+        readonly port: number;
+    }>;
+    /** Where peers.json lives. Defaults to ~/.vibedating. */
+    readonly stateDir?: string;
+    /** Predicate over a blocked handle — a blocked peer's hello is dropped exactly
+     *  like in 1:1 discovery. Default: nothing blocked. */
+    readonly isBlocked?: (handle: string) => boolean;
+    /** Match-notification sink (tests capture with a fake). Best-effort. */
+    readonly notify?: NotifySink;
+}
+interface RoomSession {
+    /** The room name. */
+    readonly room: string;
+    /** The joined DHT topic (see {@link roomTopic}). */
+    readonly topic: Buffer;
+    /** What we broadcast. */
+    readonly hello: PeerHello;
+    /** Live member set, keyed by handle (excludes self). Mirrors the live view
+     *  semantics of {@link p2p.DiscoverySession.peers}. */
+    readonly members: ReadonlyMap<string, RoomMember>;
+    /** Resolves when the first DHT announce/lookup round completes. */
+    readonly ready: Promise<unknown>;
+    /**
+     * Broadcast a text message to ALL room members (fan-out: one `msg` frame per
+     * member's {@link PeerLink}). Returns the handles the message was sent to.
+     * Best-effort: a member whose link has just closed is skipped silently.
+     */
+    broadcast(text: string): readonly string[];
+    /** Register a callback fired for each incoming group message (with sender). */
+    onMessage(cb: (m: RoomMessage) => void): void;
+    /** Register a callback fired whenever the member roster changes (join/leave). */
+    onRoster(cb: (members: readonly RoomMember[]) => void): void;
+    /** Register a callback fired for each incoming `rtc-*` signaling frame,
+     *  tagged with the sender's handle (full-mesh video signaling). */
+    onSignal(cb: (from: string, frame: RtcFrame) => void): void;
+    /** Relay one `rtc-*` signaling frame to one member (by handle). */
+    sendSignal(handle: string, frame: RtcFrame): void;
+    /** The underlying {@link PeerLink} to a member (by handle), or undefined. */
+    linkFor(handle: string): PeerLink | undefined;
+    /** Leave the room and destroy the node. Idempotent. */
+    close(): Promise<void>;
+}
+/**
+ * Join (or create) a named room on the DHT and discover ALL members. CONSENT
+ * GATE LIVES WITH THE CALLER — never call this without the `share:live` grant
+ * (or an explicit opt-in in the same breath), exactly like
+ * {@link p2p.startDiscovery}.
+ *
+ * Resolves once the first DHT announce/lookup round completes; the returned
+ * session's {@link RoomSession.members} map + {@link RoomSession.onRoster}
+ * callback track every member that joins or leaves thereafter.
+ */
+declare function startRoom(opts: RoomOptions): Promise<RoomSession>;
+
 /**
  * Persistent ed25519 identity — binds a handle to a keypair so a peer cannot
  * impersonate it.
@@ -558,4 +639,4 @@ declare const CANDIDATES: readonly Candidate[];
  */
 declare function matches(myLeague: string, candidates?: readonly Candidate[]): Candidate[];
 
-export { BELOW_LEAGUE, CANDIDATES, type Candidate, type CreateNostrRelayLinkOptions, DEFAULT_RELAYS, DEMO_TOTAL_TOKENS, type DiscoveryOptions, type DiscoverySession, type HelloClaims, type Identity, type IdentityProof, type IdentityVerdict, LEAGUES, LIVE_NOTICE, type League, type LocalUsageSnapshot, type NostrKey, type NostrRelayLink, type PeerHello, type RelayEvent, type RelayFilter, type RelayTransport, type StoredPeer, TOKENS_ENV, TOPIC_PREFIX, VIBEDATE_MESSAGE_KIND, VIBEDATE_PRESENCE_KIND, allLeagueNames, canonicalHelloClaims, classifyHelloIdentity, conversationTag, createNostrPoolTransport, createNostrRelayLink, league, leagueIndex, leagueTopic, leaguesWithin, loadOrCreateIdentity, loadOrCreateNostrKey, loadPeers, matches, parseHandshake, parseTokensEnv, readUsage, recordPeer, recordPeerMessage, serializeHandshake, signHelloClaims, startDiscovery, verifyHelloClaims };
+export { BELOW_LEAGUE, CANDIDATES, type Candidate, type CreateNostrRelayLinkOptions, DEFAULT_RELAYS, DEMO_TOTAL_TOKENS, type DiscoveryOptions, type DiscoverySession, type HelloClaims, type Identity, type IdentityProof, type IdentityVerdict, LEAGUES, LIVE_NOTICE, type League, type LocalUsageSnapshot, type NostrKey, type NostrRelayLink, type PeerHello, ROOM_TOPIC_PREFIX, type RelayEvent, type RelayFilter, type RelayTransport, type RoomMember, type RoomMessage, type RoomOptions, type RoomSession, type StoredPeer, TOKENS_ENV, TOPIC_PREFIX, VIBEDATE_MESSAGE_KIND, VIBEDATE_PRESENCE_KIND, allLeagueNames, canonicalHelloClaims, classifyHelloIdentity, conversationTag, createNostrPoolTransport, createNostrRelayLink, league, leagueIndex, leagueTopic, leaguesWithin, loadOrCreateIdentity, loadOrCreateNostrKey, loadPeers, matches, parseHandshake, parseTokensEnv, readUsage, recordPeer, recordPeerMessage, roomTopic, serializeHandshake, signHelloClaims, startDiscovery, startRoom, verifyHelloClaims };

package/dist/index.js

@@ -5,6 +5,7 @@ import {
   DEMO_TOTAL_TOKENS,
   LEAGUES,
   LIVE_NOTICE,
+  ROOM_TOPIC_PREFIX,
   TOKENS_ENV,
   TOPIC_PREFIX,
   VIBEDATE_MESSAGE_KIND,
@@ -29,11 +30,13 @@ import {
   readUsage,
   recordPeer,
   recordPeerMessage,
+  roomTopic,
   serializeHandshake,
   signHelloClaims,
   startDiscovery,
+  startRoom,
   verifyHelloClaims
-} from "./chunk-VZXPYU2C.js";
+} from "./chunk-HDHJLZZG.js";
 export {
   BELOW_LEAGUE,
   CANDIDATES,
@@ -41,6 +44,7 @@ export {
   DEMO_TOTAL_TOKENS,
   LEAGUES,
   LIVE_NOTICE,
+  ROOM_TOPIC_PREFIX,
   TOKENS_ENV,
   TOPIC_PREFIX,
   VIBEDATE_MESSAGE_KIND,
@@ -65,8 +69,10 @@ export {
   readUsage,
   recordPeer,
   recordPeerMessage,
+  roomTopic,
   serializeHandshake,
   signHelloClaims,
   startDiscovery,
+  startRoom,
   verifyHelloClaims
 };

package/dist/mcp.js

@@ -1,7 +1,7 @@
 import {
   runMcp
-} from "./chunk-JIBC3OHV.js";
-import "./chunk-VZXPYU2C.js";
+} from "./chunk-ZD6JBWEW.js";
+import "./chunk-HDHJLZZG.js";
 export {
   runMcp
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibedate",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Dating by tokens — matched by usage league across agentic CLIs. Raw usage stays local; only your league is shared. CLI + local web app + MCP. Local-first.",
   "type": "module",
   "license": "MIT",