ciphermesh 1.2.1 → 2.1.0

package/src/server/SessionManager.js

@@ -11,6 +11,7 @@ export class SessionManager {
   #roomOwners; // Map<roomName, sessionId>
   #muteState; // Map<sessionId, { until: timestamp }>
   #banList; // Map<roomName, Set<nickname_lower>>
+  #roomMeta; // Map<roomName, { authPk: base64 }> — private-room verifiers (memory only)
 
   constructor() {
     this.#sessions = new Map();
@@ -20,6 +21,7 @@ export class SessionManager {
     this.#roomOwners = new Map();
     this.#muteState = new Map();
     this.#banList = new Map();
+    this.#roomMeta = new Map();
     // Ensure default room exists
     this.#rooms.set('general', new Set());
   }
@@ -167,9 +169,12 @@ export class SessionManager {
       if (members.size === 0 && room !== 'general') {
         // Empty non-general room — drop it and all associated moderation state
         // (otherwise a recreated room stays owner-less and unmoderatable).
+        // The private-room verifier dies here too: the room and its password
+        // exist only while someone is inside.
         this.#rooms.delete(room);
         this.#roomOwners.delete(room);
         this.#banList.delete(room);
+        this.#roomMeta.delete(room);
       } else if (this.#roomOwners.get(room) === sessionId) {
         // Owner left but room still has members — transfer ownership so the
         // room keeps a moderator instead of becoming owner-less.
@@ -207,16 +212,35 @@ export class SessionManager {
     const rooms = [];
     for (const [name, members] of this.#rooms) {
       if (members.size > 0) {
-        rooms.push({ name, memberCount: members.size });
+        rooms.push({ name, memberCount: members.size, private: this.#roomMeta.has(name) });
       }
     }
     // Always include 'general' even if empty
     if (!rooms.some((r) => r.name === 'general')) {
-      rooms.unshift({ name: 'general', memberCount: 0 });
+      rooms.unshift({ name: 'general', memberCount: 0, private: false });
     }
     return rooms.sort((a, b) => a.name.localeCompare(b.name));
   }
 
+  // ── Private rooms ────────────────────────────────────────────
+
+  roomHasMembers(room) {
+    const members = this.#rooms.get(room);
+    return !!members && members.size > 0;
+  }
+
+  setRoomPrivate(room, authPkB64) {
+    this.#roomMeta.set(room, { authPk: authPkB64 });
+  }
+
+  isRoomPrivate(room) {
+    return this.#roomMeta.has(room);
+  }
+
+  getRoomAuthPk(room) {
+    return this.#roomMeta.get(room)?.authPk || null;
+  }
+
   getSessionRoom(sessionId) {
     const session = this.#sessions.get(sessionId);
     return session?.room || null;

package/src/server/WebSocketServer.js

@@ -1,4 +1,5 @@
 import { createServer as createHttpsServer } from 'node:https';
+import { randomBytes } from 'node:crypto';
 import { WebSocketServer as WSServer } from 'ws';
 import { createLogger } from '../shared/logger.js';
 import {
@@ -8,6 +9,10 @@ import {
   MAX_CONNECTIONS_PER_IP,
   JOIN_TIMEOUT_MS,
   MESSAGE_RATE_LIMIT_PER_SECOND,
+  ROOM_CHALLENGE_NONCE_SIZE,
+  ROOM_CHALLENGE_TTL_MS,
+  ROOM_AUTH_MAX_FAILS,
+  ROOM_AUTH_FAIL_WINDOW_MS,
 } from '../shared/constants.js';
 import {
   MSG,
@@ -16,6 +21,7 @@ import {
   createPeerLeft,
   createPeerKeyUpdated,
   createRoomChanged,
+  createRoomChallenge,
   createRoomList,
   createPeerKicked,
   createPeerMuted,
@@ -28,10 +34,12 @@ import {
   validateEncryptedMessage,
   validateKeyUpdate,
   validateChangeRoom,
+  validateRoomAuth,
   validateKickPeer,
   validateMutePeer,
   validateBanPeer,
 } from '../protocol/validators.js';
+import { verifyRoomChallenge } from '../crypto/RoomKey.js';
 
 const log = createLogger('ws-server');
 
@@ -188,6 +196,10 @@ export class SecureWSServer {
         this.#handleChangeRoom(ws, msg);
         break;
 
+      case MSG.ROOM_AUTH:
+        this.#handleRoomAuth(ws, msg);
+        break;
+
       case MSG.LIST_ROOMS:
         this.#handleListRooms(ws);
         break;
@@ -293,8 +305,11 @@ export class SecureWSServer {
       return;
     }
 
-    // Ensure the 'from' field matches the sender's actual session
-    msg.from = ws.sessionId;
+    // Sealed sender: the relay routes purely by `to`. It deliberately does NOT
+    // learn, stamp, store, or log who sent this — the sender's identity is
+    // sealed inside the envelope for the recipient only. Strip any stray `from`
+    // a client might set so it can never be forwarded.
+    delete msg.from;
 
     this.#messageRouter.route(ws.sessionId, msg);
   }
@@ -350,6 +365,41 @@ export class SecureWSServer {
       ws.send(JSON.stringify(createError(ERR.INVALID_MESSAGE, 'You are banned from this room')));
       return;
     }
+
+    // Creating a private room: register the password verifier, but only for
+    // a room that doesn't exist yet (rooms die when the last member leaves).
+    if (validation.roomAuthPk) {
+      if (validation.room === 'general' || this.#sessionManager.roomHasMembers(validation.room)) {
+        ws.send(
+          JSON.stringify(
+            createError(ERR.ROOM_EXISTS, 'Room already exists — join it with /join instead'),
+          ),
+        );
+        return;
+      }
+      const result = this.#sessionManager.switchRoom(ws.sessionId, validation.room);
+      if (!result) {
+        ws.send(JSON.stringify(createError(ERR.INVALID_MESSAGE, 'You are already in this room')));
+        return;
+      }
+      this.#sessionManager.setRoomPrivate(validation.room, validation.roomAuthPk);
+      this.#finishRoomSwitch(ws, session, result);
+      return;
+    }
+
+    // Joining a private room: don't switch yet — issue a challenge the client
+    // must sign with the password-derived key (see #handleRoomAuth).
+    if (this.#sessionManager.isRoomPrivate(validation.room)) {
+      const nonce = randomBytes(ROOM_CHALLENGE_NONCE_SIZE).toString('base64');
+      ws.roomChallenge = {
+        room: validation.room,
+        nonce,
+        expiresAt: Date.now() + ROOM_CHALLENGE_TTL_MS,
+      };
+      ws.send(JSON.stringify(createRoomChallenge(validation.room, nonce)));
+      return;
+    }
+
     const result = this.#sessionManager.switchRoom(ws.sessionId, validation.room);
     if (!result) {
       // Already in this room
@@ -357,6 +407,92 @@ export class SecureWSServer {
       return;
     }
 
+    this.#finishRoomSwitch(ws, session, result);
+  }
+
+  #handleRoomAuth(ws, msg) {
+    if (!ws.hasJoined || !ws.sessionId) {
+      ws.send(JSON.stringify(createError(ERR.INVALID_MESSAGE, 'JOIN first')));
+      return;
+    }
+
+    const validation = validateRoomAuth(msg);
+    if (!validation.valid) {
+      ws.send(JSON.stringify(createError(ERR.INVALID_MESSAGE, validation.error)));
+      return;
+    }
+
+    // Throttle wrong-password attempts per connection.
+    const now = Date.now();
+    if (
+      !ws.roomAuthFailWindowStart ||
+      now - ws.roomAuthFailWindowStart >= ROOM_AUTH_FAIL_WINDOW_MS
+    ) {
+      ws.roomAuthFailWindowStart = now;
+      ws.roomAuthFails = 0;
+    }
+    if (ws.roomAuthFails >= ROOM_AUTH_MAX_FAILS) {
+      ws.send(
+        JSON.stringify(createError(ERR.RATE_LIMITED, 'Too many failed attempts — wait a minute')),
+      );
+      return;
+    }
+
+    const challenge = ws.roomChallenge;
+    if (
+      !challenge ||
+      challenge.room !== validation.room ||
+      challenge.nonce !== validation.nonce ||
+      now > challenge.expiresAt
+    ) {
+      ws.send(JSON.stringify(createError(ERR.ROOM_AUTH_FAILED, 'Challenge expired — /join again')));
+      return;
+    }
+    ws.roomChallenge = null;
+
+    const authPkB64 = this.#sessionManager.getRoomAuthPk(validation.room);
+    if (!authPkB64) {
+      // Room emptied (and died) between challenge and answer.
+      ws.send(
+        JSON.stringify(
+          createError(ERR.ROOM_AUTH_FAILED, 'Room no longer exists — /join again to create it'),
+        ),
+      );
+      return;
+    }
+
+    const ok = verifyRoomChallenge(
+      Buffer.from(authPkB64, 'base64'),
+      Buffer.from(validation.signature, 'base64'),
+      validation.room,
+      validation.nonce,
+      ws.sessionId,
+    );
+    if (!ok) {
+      ws.roomAuthFails++;
+      ws.send(JSON.stringify(createError(ERR.ROOM_AUTH_FAILED, 'Wrong room password')));
+      log.warn(`Failed room auth for ${validation.room} (${ws.sessionId.slice(0, 8)})`);
+      return;
+    }
+
+    const session = this.#sessionManager.getSession(ws.sessionId);
+    if (this.#sessionManager.isBanned(validation.room, session.nickname)) {
+      ws.send(JSON.stringify(createError(ERR.INVALID_MESSAGE, 'You are banned from this room')));
+      return;
+    }
+
+    const result = this.#sessionManager.switchRoom(ws.sessionId, validation.room);
+    if (!result) {
+      ws.send(JSON.stringify(createError(ERR.INVALID_MESSAGE, 'You are already in this room')));
+      return;
+    }
+
+    this.#finishRoomSwitch(ws, session, result);
+  }
+
+  // Shared tail of a successful room switch: notify both rooms and send the
+  // ROOM_CHANGED (with the private flag) to the mover.
+  #finishRoomSwitch(ws, session, result) {
     // Notify old room that peer left
     this.#sessionManager.broadcastToRoom(
       result.oldRoom,
@@ -377,7 +513,11 @@ export class SecureWSServer {
 
     // Send new room info to the client
     const newPeers = this.#sessionManager.getRoomPeers(result.newRoom, ws.sessionId);
-    const roomChanged = createRoomChanged(result.newRoom, newPeers);
+    const roomChanged = createRoomChanged(
+      result.newRoom,
+      newPeers,
+      this.#sessionManager.isRoomPrivate(result.newRoom),
+    );
     const newOwnerSid = this.#sessionManager.getRoomOwner(result.newRoom);
     if (newOwnerSid) {
       const ownerSess = this.#sessionManager.getSession(newOwnerSid);

package/src/shared/AuditLog.js

@@ -26,6 +26,9 @@ export const AuditEvent = {
   ADMIN_KICK: 'ADMIN_KICK',
   ADMIN_MUTE: 'ADMIN_MUTE',
   ADMIN_BAN: 'ADMIN_BAN',
+  SCREEN_LOCKED: 'SCREEN_LOCKED',
+  SCREEN_UNLOCKED: 'SCREEN_UNLOCKED',
+  SCREEN_UNLOCK_FAILED: 'SCREEN_UNLOCK_FAILED',
 };
 
 export class AuditLog {

package/src/shared/PluginManager.js

@@ -4,7 +4,10 @@ import { homedir } from 'node:os';
 import { existsSync, mkdirSync } from 'node:fs';
 import { pathToFileURL } from 'node:url';
 
-const PLUGIN_DIR = join(homedir(), '.ciphermesh', 'plugins');
+// Resolved lazily so tests (and future flags) can point HOME elsewhere.
+export function pluginDir() {
+  return join(homedir(), '.ciphermesh', 'plugins');
+}
 
 export class PluginManager {
   #plugins; // Map<name, module>
@@ -15,15 +18,15 @@ export class PluginManager {
     this.#commands = new Map();
   }
 
-  async loadAll() {
-    if (!existsSync(PLUGIN_DIR)) {
-      mkdirSync(PLUGIN_DIR, { recursive: true });
+  async loadAll(dir = pluginDir()) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
       return;
     }
 
     let files;
     try {
-      files = await readdir(PLUGIN_DIR);
+      files = await readdir(dir);
     } catch {
       return;
     }
@@ -32,7 +35,7 @@ export class PluginManager {
 
     for (const file of jsFiles) {
       try {
-        const filePath = join(PLUGIN_DIR, file);
+        const filePath = join(dir, file);
         const fileUrl = pathToFileURL(filePath).href;
         const mod = await import(fileUrl);
         const plugin = mod.default || mod;

package/src/shared/config.js

@@ -1,6 +1,6 @@
-import { readFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 
 // Optional user config at ~/.ciphermesh/config.json. Everything is a default the
 // user can still override at the prompt or with a slash-command. Unknown keys
@@ -15,6 +15,7 @@ const ALLOWED = [
   'deniable',
   'theme',
   'autoAway',
+  'autoLock',
   'dnd',
 ];
 
@@ -51,6 +52,27 @@ export function loadConfig(path = configPath()) {
   }
 }
 
+/** True if a config file already exists (used to detect the first run). */
+export function hasConfigFile(path = configPath()) {
+  return existsSync(path);
+}
+
+/**
+ * Persist config (whitelisted keys only, merged over what's on disk so a
+ * partial save never wipes hand-edited settings). Returns what was written.
+ */
+export function saveConfig(cfg, path = configPath()) {
+  const merged = { ...loadConfig(path) };
+  for (const k of ALLOWED) {
+    if (cfg[k] !== undefined) {
+      merged[k] = cfg[k];
+    }
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(merged, null, 2)}\n`, { mode: 0o600 });
+  return merged;
+}
+
 /**
  * Translate config toggles into the slash-commands that apply them, so startup
  * reuses the exact command handlers (no duplicated logic). Pure — testable.
@@ -81,6 +103,9 @@ export function startupCommands(config) {
   if (Number.isInteger(config.autoAway) && config.autoAway > 0) {
     cmds.push(`/autoaway ${config.autoAway}`);
   }
+  if (Number.isInteger(config.autoLock) && config.autoLock > 0) {
+    cmds.push(`/autolock ${config.autoLock}`);
+  }
   if (config.dnd === 'on' || config.dnd === 'mentions') {
     cmds.push(`/dnd ${config.dnd}`);
   } else if (typeof config.dnd === 'string' && /^\d/.test(config.dnd)) {

package/src/shared/constants.js

@@ -1,4 +1,4 @@
-export const PROTOCOL_VERSION = 1;
+export const PROTOCOL_VERSION = 2; // v2: sealed sender (encrypted_message carries `sealed`, no `from`)
 
 // Network
 export const SERVER_PORT = 3600;
@@ -41,6 +41,14 @@ export const OFFLINE_QUEUE_MAX_PER_PEER = 100;
 export const OFFLINE_QUEUE_MAX_AGE_MS = 3_600_000; // 1h
 export const OFFLINE_QUEUE_MAX_TOTAL = 1000;
 
+// Private rooms (password-protected, zero-knowledge)
+export const ROOM_AUTH_PK_SIZE = 32; // Ed25519 verifier public key
+export const ROOM_AUTH_SIG_SIZE = 64; // Ed25519 detached signature
+export const ROOM_CHALLENGE_NONCE_SIZE = 24;
+export const ROOM_CHALLENGE_TTL_MS = 60_000; // challenge must be answered within this
+export const ROOM_AUTH_MAX_FAILS = 5; // wrong-password attempts per connection…
+export const ROOM_AUTH_FAIL_WINDOW_MS = 60_000; // …within this window
+
 // Message padding (anti-metadata): every ciphertext is padded up to one of
 // these bucket sizes so the relay can't read the true plaintext length.
 export const MESSAGE_PAD_BUCKETS = [128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768];

package/src/shared/lastSession.js

@@ -0,0 +1,55 @@
+// Remembers where the user was (server + room) so the next launch can offer to
+// reconnect. Deliberately tiny and best-effort: losing this file only costs a
+// couple of keystrokes. Privacy: callers must NOT pass the room of a private
+// room — its name never touches disk (see ChatController#saveLastSession).
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+export function lastSessionPath() {
+  return join(homedir(), '.ciphermesh', 'last-session.json');
+}
+
+/** Load { server, room?, at } or null when missing/corrupt. */
+export function loadLastSession(path = lastSessionPath()) {
+  try {
+    const obj = JSON.parse(readFileSync(path, 'utf-8'));
+    if (obj === null || typeof obj !== 'object' || typeof obj.server !== 'string') {
+      return null;
+    }
+    const out = { server: obj.server, at: Number(obj.at) || 0 };
+    if (typeof obj.room === 'string' && /^[a-zA-Z0-9_-]{1,30}$/.test(obj.room)) {
+      out.room = obj.room;
+    }
+    return out;
+  } catch {
+    return null;
+  }
+}
+
+/** Persist { server, room? }. Room is optional on purpose (private rooms). */
+export function saveLastSession({ server, room }, path = lastSessionPath()) {
+  if (typeof server !== 'string' || !server) {
+    return;
+  }
+  const data = { server, at: Date.now() };
+  if (typeof room === 'string' && room) {
+    data.room = room;
+  }
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(data)}\n`, { mode: 0o600 });
+  } catch {
+    // Best effort — never break the chat over this.
+  }
+}
+
+export function clearLastSession(path = lastSessionPath()) {
+  try {
+    if (existsSync(path)) {
+      unlinkSync(path);
+    }
+  } catch {
+    // Best effort.
+  }
+}

package/src/shared/onboarding.js

@@ -0,0 +1,111 @@
+// First-run setup wizard: ~30 seconds from `npx ciphermesh` to chatting, with
+// just enough context to use the security features. Runs when no config file
+// exists yet (or on demand via --setup) and persists the answers so it never
+// asks twice.
+import chalk from 'chalk';
+import { SERVER_PORT } from './constants.js';
+import { promptLabel, promptDim, promptError } from './banner.js';
+import { themeNames, setTheme, getThemeName, THEMES } from './themes.js';
+import { parseInvite } from './invite.js';
+import { configPath, saveConfig } from './config.js';
+
+/**
+ * Resolve a theme answer: a number from the printed list ("2"), a name
+ * ("matrix"), or empty → fallback. Pure — exported for testing.
+ */
+export function parseThemeChoice(input, names, fallback) {
+  const clean = (input || '').trim().toLowerCase();
+  if (!clean) {
+    return fallback;
+  }
+  if (/^\d+$/.test(clean)) {
+    const idx = Number(clean) - 1;
+    return names[idx] || fallback;
+  }
+  return names.includes(clean) ? clean : fallback;
+}
+
+/**
+ * Resolve the server answer into what to use this session and what to save
+ * as the default. Invites are used as-is for the session but saved as their
+ * host:port (a room invite is one-shot, the host is worth keeping).
+ * Pure — exported for testing.
+ */
+export function resolveServerAnswer(input, fallback = `localhost:${SERVER_PORT}`) {
+  const clean = (input || '').trim();
+  if (!clean) {
+    return { session: fallback, save: fallback };
+  }
+  const invite = parseInvite(clean);
+  if (invite) {
+    return { session: clean, save: invite.wsUrl.replace(/^wss?:\/\//, '') };
+  }
+  return { session: clean, save: clean };
+}
+
+/**
+ * Interactive first-run wizard. Uses the same readline interface as the rest
+ * of startup. Returns `{ nickname, server, theme }` — the caller uses them
+ * directly for this session (no duplicate prompts) — after persisting them
+ * to the config file.
+ */
+export async function runOnboarding(rl, { savePath = configPath() } = {}) {
+  const dim = (t) => console.log(promptDim(`  ${t}`));
+
+  console.log();
+  console.log(chalk.bold.white('  First time here? Quick setup — 30 seconds.'));
+  dim(`Everything is saved to ${savePath} (re-run anytime with: ciphermesh --setup)`);
+  console.log();
+  console.log(chalk.white('  How CipherMesh works, in three lines:'));
+  dim('• Everything is end-to-end encrypted — the relay only ever sees ciphertext.');
+  dim('• Your identity is a keypair; its short fingerprint is shown when you connect.');
+  dim('• Verify friends out-of-band with /verify — a green ✓ appears next to their name.');
+  console.log();
+
+  // 1. Nickname
+  let nickname = '';
+  while (!nickname) {
+    const raw = await rl.question(promptLabel(`Nickname ${promptDim('(a-z, 0-9, _, -)')}: `));
+    const clean = raw.trim().replace(/[^a-zA-Z0-9_-]/g, '');
+    if (clean.length >= 1 && clean.length <= 20) {
+      nickname = clean;
+    } else {
+      console.log(promptError('Invalid nickname. Use 1-20 alphanumeric characters.'));
+    }
+  }
+
+  // 2. Theme
+  const names = themeNames();
+  console.log();
+  console.log(chalk.white('  Colour theme for nicknames:'));
+  names.forEach((name, i) => {
+    const swatch = THEMES[name]
+      .slice(0, 5)
+      .map((c) => (c.startsWith('#') ? chalk.hex(c)('█') : chalk[c]?.('█') || '█'))
+      .join('');
+    console.log(promptDim(`    ${i + 1}. ${name.padEnd(8)} ${swatch}`));
+  });
+  const themeRaw = await rl.question(
+    promptLabel(`Theme ${promptDim(`(1-${names.length} or name, Enter = ${getThemeName()})`)}: `),
+  );
+  const theme = parseThemeChoice(themeRaw, names, getThemeName());
+  setTheme(theme);
+
+  // 3. Default server
+  console.log();
+  console.log(chalk.white('  Which server should be your default?'));
+  dim(`• Same machine as the relay → localhost:${SERVER_PORT}`);
+  dim(`• Someone else hosts it (LAN/Tailscale) → their IP, e.g. 100.64.0.9:${SERVER_PORT}`);
+  dim('• Got a ciphermesh:// invite? Paste it here.');
+  const serverRaw = await rl.question(
+    promptLabel(`Server ${promptDim(`(Enter = localhost:${SERVER_PORT})`)}: `),
+  );
+  const { session: server, save: serverToSave } = resolveServerAnswer(serverRaw);
+
+  saveConfig({ nickname, theme, server: serverToSave }, savePath);
+  console.log();
+  console.log(promptLabel('Setup saved — next time you go straight to the chat.'));
+  console.log();
+
+  return { nickname, server, theme };
+}