ciphermesh 2.1.0 → 2.2.0

package/src/client/UI.js

@@ -24,7 +24,8 @@ const COMMAND_INFO = [
   ['/away', 'Mark yourself as away'],
   ['/back', 'Clear away status'],
   ['/status', 'Set a status'],
-  ['/join', 'Join a room (password if private)'],
+  ['/join', 'Join a room as a new buffer (Alt+1..9 switches)'],
+  ['/leave', 'Leave a room — its buffer closes'],
   ['/create', 'Create a private room with a password'],
   ['/rooms', 'List rooms'],
   ['/room', 'Show the current room'],
@@ -97,6 +98,7 @@ export const COMMANDS = [
   '/notify',
   '/dnd',
   '/join',
+  '/leave',
   '/create',
   '/rooms',
   '/room',
@@ -498,6 +500,10 @@ export class UI extends EventEmitter {
   #lockInput;
   #lockError;
   #lockVerify;
+  #bufferLines; // Map<room, lines[]> — stored content of INACTIVE buffers
+  #activeBuffer; // name of the buffer currently on screen
+  #redirecting; // true while add* calls are being written to an inactive buffer
+  #bufferBar; // [{ room, active, unread, private }] for the status bar
 
   constructor(nickname) {
     super();
@@ -547,6 +553,10 @@ export class UI extends EventEmitter {
     this.#lockInput = '';
     this.#lockError = false;
     this.#lockVerify = null;
+    this.#bufferLines = new Map();
+    this.#activeBuffer = 'general';
+    this.#redirecting = false;
+    this.#bufferBar = [];
 
     // blessed's terminfo parser can't compile the modern Setulc (underline
     // colour) capability that terminals like ghostty ship, so it dumps a
@@ -772,6 +782,12 @@ export class UI extends EventEmitter {
     // Any non-tab key resets tab cycling
     this.#tabState = { suggestions: [], index: -1, original: '' };
 
+    // Alt+1..9 — switch chat buffer (multi-room)
+    if (key.meta && /^[1-9]$/.test(name)) {
+      this.emit('buffer-switch', Number(name) - 1);
+      return;
+    }
+
     // Alt+Enter / Ctrl+J — insert a newline (reliable across terminals, unlike
     // bare Shift+Enter which most terminals don't distinguish from Enter).
     if (((name === 'return' || name === 'enter') && key.meta) || (key.ctrl && name === 'j')) {
@@ -1384,12 +1400,29 @@ export class UI extends EventEmitter {
   }
 
   #statusContent() {
-    const room = `{cyan-fg}#${this.#statusRoom}{/cyan-fg}`;
+    // Several buffers → an IRC-style bar with unread badges; one → plain room.
+    let room;
+    if (this.#bufferBar.length > 1) {
+      room = this.#bufferBar
+        .map((b, i) => {
+          const lock = b.private ? '🔒' : '';
+          const unread = b.unread > 0 ? `{yellow-fg}•${b.unread}{/yellow-fg}` : '';
+          const label = `${i + 1}:${lock}${b.room}${unread}`;
+          return b.active
+            ? `{inverse}{cyan-fg}[${label}]{/cyan-fg}{/inverse}`
+            : `{cyan-fg}[${label}]{/cyan-fg}`;
+        })
+        .join(' ');
+    } else {
+      room = `{cyan-fg}#${this.#statusRoom}{/cyan-fg}`;
+    }
     const fp = this.#statusFingerprint
       ? `   {#8888aa-fg}🔑 ${this.#statusFingerprint}{/#8888aa-fg}`
       : '';
     const hint =
-      '{#7777aa-fg}Tab · Ctrl+K commands · Ctrl+E emoji · PgUp/PgDn scroll · /help · Ctrl+C quit{/#7777aa-fg}';
+      this.#bufferBar.length > 1
+        ? '{#7777aa-fg}Alt+1..9 buffers · Ctrl+K commands · /help{/#7777aa-fg}'
+        : '{#7777aa-fg}Tab · Ctrl+K commands · Ctrl+E emoji · PgUp/PgDn scroll · /help · Ctrl+C quit{/#7777aa-fg}';
     return `  ${room}${fp}      {|}  ${hint}  `;
   }
 
@@ -1411,6 +1444,102 @@ export class UI extends EventEmitter {
     this.#updateStatusBar();
   }
 
+  // ── Buffers (multi-room, IRC style) ──────────────────────────
+  // The active buffer lives in #lines + the chat log; inactive ones are plain
+  // line arrays in #bufferLines. All add*() methods target the active buffer —
+  // toBuffer() retargets them for one call without touching the screen.
+
+  get activeBuffer() {
+    return this.#activeBuffer;
+  }
+
+  /**
+   * Run `fn` with every add*() call landing in `room`'s stored buffer instead
+   * of the screen. Uses proxies so the formatting pipeline (widths, colors,
+   * grouping) is exactly the one the live log uses.
+   */
+  toBuffer(room, fn) {
+    if (!room || room === this.#activeBuffer) {
+      return fn();
+    }
+    if (!this.#bufferLines.has(room)) {
+      this.#bufferLines.set(room, []);
+    }
+    const liveLines = this.#lines;
+    const liveSender = this.#lastSender;
+    const liveLog = this.#chatLog;
+    const liveScreen = this.#screen;
+    this.#lines = this.#bufferLines.get(room);
+    this.#lastSender = null;
+    this.#redirecting = true;
+    this.#chatLog = new Proxy(liveLog, {
+      get: (t, p) => (p === 'log' ? () => {} : t[p]),
+    });
+    this.#screen = new Proxy(liveScreen, {
+      get: (t, p) => {
+        if (p === 'render') {
+          return () => {};
+        }
+        const v = t[p];
+        return typeof v === 'function' ? v.bind(t) : v;
+      },
+    });
+    try {
+      return fn();
+    } finally {
+      this.#lines = liveLines;
+      this.#lastSender = liveSender;
+      this.#chatLog = liveLog;
+      this.#screen = liveScreen;
+      this.#redirecting = false;
+    }
+  }
+
+  /** Bring `room`'s buffer on screen, storing the current one. */
+  switchBuffer(room) {
+    if (room === this.#activeBuffer) {
+      return;
+    }
+    this.#bufferLines.set(this.#activeBuffer, this.#lines);
+    this.#lines = this.#bufferLines.get(room) || [];
+    this.#bufferLines.delete(room);
+    this.#activeBuffer = room;
+    this.#lastSender = null;
+    this.#chatLog.setContent(this.#lines.join('\n'));
+    this.#chatLog.setScrollPerc(100);
+    this.setRoom(room);
+    this.#screen.render();
+  }
+
+  /** Forget every buffer and start fresh in `room` (reconnect / legacy switch). */
+  resetBuffers(room) {
+    this.#bufferLines.clear();
+    this.#activeBuffer = room;
+    this.#lines = [];
+    this.#lastSender = null;
+    this.#chatLog.setContent('');
+    this.setRoom(room);
+    this.#screen.render();
+  }
+
+  dropBuffer(room) {
+    this.#bufferLines.delete(room);
+  }
+
+  clearBuffer(room) {
+    if (room === this.#activeBuffer) {
+      this.clearChat();
+    } else if (this.#bufferLines.has(room)) {
+      this.#bufferLines.get(room).length = 0;
+    }
+  }
+
+  /** Status-bar buffer list: [{ room, active, unread, private }]. */
+  setBufferBar(items) {
+    this.#bufferBar = Array.isArray(items) ? items : [];
+    this.#updateStatusBar();
+  }
+
   // Render a real image inline by briefly leaving the TUI (kitty/iTerm2). Safe
   // best-effort: any keypress or a 30s timeout returns to the chat.
   showRealImage(escapeSeq) {
@@ -1647,6 +1776,9 @@ export class UI extends EventEmitter {
   // Count a fresh arrival while the user is reading history, and pulse the
   // "new messages" pill so they know to page down.
   #noteIncoming(important = false) {
+    if (this.#redirecting) {
+      return; // inactive buffer — its unread badge lives in the buffer bar
+    }
     if (this.#scrolledUp) {
       this.#unseenCount++;
       if (important) {

package/src/protocol/messages.js

@@ -12,6 +12,10 @@ export const MSG = {
   PEER_KEY_UPDATED: 'peer_key_updated',
   CHANGE_ROOM: 'change_room',
   ROOM_CHANGED: 'room_changed',
+  JOIN_ROOM: 'join_room',
+  ROOM_JOINED: 'room_joined',
+  LEAVE_ROOM: 'leave_room',
+  ROOM_LEFT: 'room_left',
   LIST_ROOMS: 'list_rooms',
   ROOM_LIST: 'room_list',
   ROOM_CHALLENGE: 'room_challenge',
@@ -53,12 +57,22 @@ export function createJoinAck(sessionId, peers, queuedCount = 0, room = 'general
   return ack;
 }
 
-export function createPeerJoined(peer) {
-  return { ...base(MSG.PEER_JOINED), peer };
+// `room` (multi-room, additive): which room this event refers to. A peer can
+// leave room X while still sharing room Y with you. Old clients ignore it.
+export function createPeerJoined(peer, room = null) {
+  const msg = { ...base(MSG.PEER_JOINED), peer };
+  if (room) {
+    msg.room = room;
+  }
+  return msg;
 }
 
-export function createPeerLeft(sessionId, nickname) {
-  return { ...base(MSG.PEER_LEFT), sessionId, nickname };
+export function createPeerLeft(sessionId, nickname, room = null) {
+  const msg = { ...base(MSG.PEER_LEFT), sessionId, nickname };
+  if (room) {
+    msg.room = room;
+  }
+  return msg;
 }
 
 export function createEncryptedMessage(from, to, ciphertextB64, nonceB64) {
@@ -131,6 +145,33 @@ export function createRoomChanged(room, peers, isPrivate = false) {
   return msg;
 }
 
+// ── Multi-room (IRC-style buffers) ─────────────────────────────
+// join_room ADDS a membership (unlike change_room, which replaces them all).
+// Same optional roomAuthPk as change_room for creating a private room.
+export function createJoinRoom(room, roomAuthPkB64 = null) {
+  const msg = { ...base(MSG.JOIN_ROOM), room };
+  if (roomAuthPkB64) {
+    msg.roomAuthPk = roomAuthPkB64;
+  }
+  return msg;
+}
+
+export function createRoomJoined(room, peers, isPrivate = false) {
+  const msg = { ...base(MSG.ROOM_JOINED), room, peers };
+  if (isPrivate) {
+    msg.private = true;
+  }
+  return msg;
+}
+
+export function createLeaveRoom(room) {
+  return { ...base(MSG.LEAVE_ROOM), room };
+}
+
+export function createRoomLeft(room) {
+  return { ...base(MSG.ROOM_LEFT), room };
+}
+
 // Server → client: the target room is private; prove password knowledge by
 // signing this nonce. The password itself never travels.
 export function createRoomChallenge(room, nonceB64) {

package/src/protocol/validators.js

@@ -126,6 +126,21 @@ export function validateChangeRoom(msg) {
   return { valid: true, room: msg.room.toLowerCase(), roomAuthPk: msg.roomAuthPk || null };
 }
 
+// join_room shares change_room's shape (room + optional verifier key).
+export function validateJoinRoom(msg) {
+  return validateChangeRoom(msg);
+}
+
+export function validateLeaveRoom(msg) {
+  if (!isString(msg.room) || msg.room.length === 0 || msg.room.length > 30) {
+    return { valid: false, error: 'Invalid room name (1-30 chars)' };
+  }
+  if (!/^[a-zA-Z0-9_-]+$/.test(msg.room)) {
+    return { valid: false, error: 'Room name must be alphanumeric, dash or underscore' };
+  }
+  return { valid: true, room: msg.room.toLowerCase() };
+}
+
 export function validateRoomAuth(msg) {
   if (!isString(msg.room) || msg.room.length === 0 || msg.room.length > 30) {
     return { valid: false, error: 'Invalid room name (1-30 chars)' };
@@ -143,15 +158,30 @@ export function validateListRooms() {
   return { valid: true };
 }
 
+// Optional multi-room context on moderation commands: which room the owner is
+// acting on. Absent → the server falls back to the session's only room.
+function optionalRoom(msg) {
+  if (msg.room === undefined) {
+    return { ok: true, room: null };
+  }
+  const v = validateLeaveRoom({ room: msg.room });
+  return v.valid ? { ok: true, room: v.room } : { ok: false, error: v.error };
+}
+
 export function validateKickPeer(msg) {
   const nick = sanitizeNickname(msg.targetNickname);
   if (!nick) {
     return { valid: false, error: 'Invalid target nickname' };
   }
+  const roomCheck = optionalRoom(msg);
+  if (!roomCheck.ok) {
+    return { valid: false, error: roomCheck.error };
+  }
   return {
     valid: true,
     targetNickname: nick,
     reason: isString(msg.reason) ? msg.reason.slice(0, 200) : '',
+    room: roomCheck.room,
   };
 }
 
@@ -163,7 +193,11 @@ export function validateMutePeer(msg) {
   if (!isNumber(msg.durationMs) || msg.durationMs <= 0) {
     return { valid: false, error: 'Invalid mute duration' };
   }
-  return { valid: true, targetNickname: nick, durationMs: msg.durationMs };
+  const roomCheck = optionalRoom(msg);
+  if (!roomCheck.ok) {
+    return { valid: false, error: roomCheck.error };
+  }
+  return { valid: true, targetNickname: nick, durationMs: msg.durationMs, room: roomCheck.room };
 }
 
 export function validateBanPeer(msg) {
@@ -171,10 +205,15 @@ export function validateBanPeer(msg) {
   if (!nick) {
     return { valid: false, error: 'Invalid target nickname' };
   }
+  const roomCheck = optionalRoom(msg);
+  if (!roomCheck.ok) {
+    return { valid: false, error: roomCheck.error };
+  }
   return {
     valid: true,
     targetNickname: nick,
     reason: isString(msg.reason) ? msg.reason.slice(0, 200) : '',
+    room: roomCheck.room,
   };
 }
 

package/src/server/SessionManager.js

@@ -4,7 +4,7 @@ import { createLogger } from '../shared/logger.js';
 const log = createLogger('session');
 
 export class SessionManager {
-  #sessions; // Map<sessionId, { ws, nickname, publicKey, connectedAt, room }>
+  #sessions; // Map<sessionId, { ws, nickname, publicKey, connectedAt, rooms: Set }>
   #nicknames; // Set<nickname> for quick dupe check
   #recentlyLeft; // Map<sessionId, { nickname, publicKey, leftAt }>
   #rooms; // Map<roomName, Set<sessionId>>
@@ -37,7 +37,7 @@ export class SessionManager {
       nickname,
       publicKey,
       connectedAt: Date.now(),
-      room,
+      rooms: new Set(),
     };
 
     this.#sessions.set(sessionId, session);
@@ -54,7 +54,9 @@ export class SessionManager {
       return null;
     }
 
-    this.#leaveRoom(sessionId);
+    for (const room of [...session.rooms]) {
+      this.#leaveRoom(sessionId, room);
+    }
     this.#nicknames.delete(session.nickname.toLowerCase());
     this.#sessions.delete(sessionId);
     this.#muteState.delete(sessionId);
@@ -93,7 +95,7 @@ export class SessionManager {
     const peers = [];
     for (const [id, session] of this.#sessions) {
       if (id !== excludeSessionId) {
-        if (room && session.room !== room) {
+        if (room && !session.rooms.has(room)) {
           continue;
         }
         peers.push({
@@ -106,6 +108,35 @@ export class SessionManager {
     return peers;
   }
 
+  /**
+   * Send a message once to every session that shares at least one room with
+   * the given session (deduplicated — a peer in two shared rooms gets one).
+   */
+  broadcastToPeersOf(sessionId, msg, excludeSessionId = sessionId) {
+    const session = this.#sessions.get(sessionId);
+    if (!session) {
+      return;
+    }
+    const data = JSON.stringify(msg);
+    const notified = new Set();
+    for (const room of session.rooms) {
+      const members = this.#rooms.get(room);
+      if (!members) {
+        continue;
+      }
+      for (const sid of members) {
+        if (sid === excludeSessionId || notified.has(sid)) {
+          continue;
+        }
+        notified.add(sid);
+        const peer = this.#sessions.get(sid);
+        if (peer && peer.ws.readyState === 1) {
+          peer.ws.send(data);
+        }
+      }
+    }
+  }
+
   /**
    * Send a JSON message to all sessions except one.
    */
@@ -147,6 +178,7 @@ export class SessionManager {
       this.#rooms.set(room, new Set());
     }
     this.#rooms.get(room).add(sessionId);
+    this.#sessions.get(sessionId)?.rooms.add(room);
 
     // First person to create/join an empty non-general room becomes owner
     if (isNew && room !== 'general' && !this.#roomOwners.has(room)) {
@@ -155,13 +187,13 @@ export class SessionManager {
     }
   }
 
-  #leaveRoom(sessionId) {
+  #leaveRoom(sessionId, room) {
     const session = this.#sessions.get(sessionId);
     if (!session) {
       return;
     }
 
-    const room = session.room;
+    session.rooms.delete(room);
     const members = this.#rooms.get(room);
     if (members) {
       members.delete(sessionId);
@@ -185,23 +217,68 @@ export class SessionManager {
     }
   }
 
+  /**
+   * Legacy single-room semantics (protocol `change_room`): leave every
+   * current room and end up only in `newRoom`.
+   */
   switchRoom(sessionId, newRoom) {
     const session = this.#sessions.get(sessionId);
     if (!session) {
       return null;
     }
 
-    const oldRoom = session.room;
-    if (oldRoom === newRoom) {
-      return null;
+    if (session.rooms.size === 1 && session.rooms.has(newRoom)) {
+      return null; // already exactly there
     }
 
-    this.#leaveRoom(sessionId);
-    session.room = newRoom;
+    const oldRooms = [...session.rooms].filter((r) => r !== newRoom);
+    for (const room of oldRooms) {
+      this.#leaveRoom(sessionId, room);
+    }
     this.#joinRoom(sessionId, newRoom);
 
-    log.info(`${session.nickname} switched room: ${oldRoom} → ${newRoom}`);
-    return { oldRoom, newRoom };
+    log.info(`${session.nickname} switched room: ${oldRooms.join(',') || '-'} → ${newRoom}`);
+    return { oldRoom: oldRooms[0] || null, oldRooms, newRoom };
+  }
+
+  /**
+   * Multi-room: join an ADDITIONAL room, keeping the current ones.
+   * Returns null when already a member.
+   */
+  joinAdditional(sessionId, room) {
+    const session = this.#sessions.get(sessionId);
+    if (!session || session.rooms.has(room)) {
+      return null;
+    }
+    this.#joinRoom(sessionId, room);
+    log.info(`${session.nickname} joined room ${room} (now in ${session.rooms.size})`);
+    return { room };
+  }
+
+  /**
+   * Multi-room: leave one room. Refuses to leave the last one (a session is
+   * always somewhere — that keeps peer visibility and moderation coherent).
+   */
+  leaveOneRoom(sessionId, room) {
+    const session = this.#sessions.get(sessionId);
+    if (!session || !session.rooms.has(room)) {
+      return null;
+    }
+    if (session.rooms.size === 1) {
+      return { lastRoom: true };
+    }
+    this.#leaveRoom(sessionId, room);
+    log.info(`${session.nickname} left room ${room} (now in ${session.rooms.size})`);
+    return { room };
+  }
+
+  getSessionRooms(sessionId) {
+    const session = this.#sessions.get(sessionId);
+    return session ? [...session.rooms] : [];
+  }
+
+  isInRoom(sessionId, room) {
+    return this.#sessions.get(sessionId)?.rooms.has(room) === true;
   }
 
   getRoomPeers(room, excludeSessionId) {
@@ -241,9 +318,16 @@ export class SessionManager {
     return this.#roomMeta.get(room)?.authPk || null;
   }
 
+  /**
+   * Legacy helper: a session's room when it has exactly one; null otherwise.
+   * Multi-room callers must pass the room explicitly instead.
+   */
   getSessionRoom(sessionId) {
     const session = this.#sessions.get(sessionId);
-    return session?.room || null;
+    if (!session) {
+      return null;
+    }
+    return session.rooms.size === 1 ? [...session.rooms][0] : null;
   }
 
   updatePublicKey(sessionId, newPublicKey) {