ciphermesh 2.2.0 → 2.4.0

package/src/client/Connection.js

@@ -11,6 +11,7 @@ export class Connection extends EventEmitter {
   #connected;
   #pinStore;
   #host;
+  #caValidated = false;
 
   constructor(url) {
     super();
@@ -28,6 +29,12 @@ export class Connection extends EventEmitter {
 
   // Trust-on-first-use pin of the server TLS certificate. Emits 'cert-pinned'
   // on first sight and 'cert-mismatch' if it later changes (possible MITM).
+  //
+  // A publicly hosted relay presents a cert signed by a real CA (Let's Encrypt
+  // et al). Node still runs the full chain + hostname check even with
+  // rejectUnauthorized:false, so `socket.authorized` tells us which world we
+  // are in: CA-valid needs no TOFU window at all (strictly stronger), while a
+  // self-signed LAN cert keeps the pin-on-first-use behaviour.
   #checkCertPin() {
     if (!this.#url.startsWith('wss://')) {
       return;
@@ -35,6 +42,18 @@ export class Connection extends EventEmitter {
     const socket = this.#ws?._socket;
     const cert = socket?.getPeerCertificate?.();
     const fingerprint = cert?.fingerprint256 || null;
+
+    if (socket?.authorized === true) {
+      this.#caValidated = true;
+      // Remember it: from now on this host is verified strictly, and a
+      // legitimate CA cert renewal no longer trips the TOFU alarm.
+      this.#pinStore.markCAValidated(this.#host);
+      this.#pinStore.repin(this.#host, fingerprint);
+      this.emit('cert-ca-valid', { host: this.#host, issuer: cert?.issuer?.O || 'CA' });
+      return;
+    }
+
+    this.#caValidated = false;
     const result = this.#pinStore.check(this.#host, fingerprint);
     if (result === PinResult.PINNED) {
       this.emit('cert-pinned', { host: this.#host, fingerprint });
@@ -53,7 +72,13 @@ export class Connection extends EventEmitter {
   }
 
   #createSocket() {
-    const opts = this.#url.startsWith('wss://') ? { rejectUnauthorized: false } : {};
+    // Hosts that already proved they have a CA-signed certificate are verified
+    // strictly from then on — an attacker cannot downgrade a hosted relay to a
+    // self-signed cert. Everything else (LAN/Tailscale self-signed) connects
+    // with verification relaxed and is protected by TOFU pinning instead.
+    const opts = this.#url.startsWith('wss://')
+      ? { rejectUnauthorized: this.#pinStore.requiresStrictTLS(this.#host) }
+      : {};
     this.#ws = new WebSocket(this.#url, opts);
 
     this.#ws.on('open', () => {
@@ -104,6 +129,11 @@ export class Connection extends EventEmitter {
     }, this.#reconnectDelay);
   }
 
+  /** True when the server's TLS cert validated against a public CA. */
+  get isCAValidated() {
+    return this.#caValidated;
+  }
+
   send(msg) {
     if (this.#connected && this.#ws.readyState === WebSocket.OPEN) {
       this.#ws.send(JSON.stringify(msg));

package/src/client/FileTransfer.js

@@ -71,7 +71,38 @@ export class FileTransfer {
     // Compute SHA-256
     const sha256 = await this.#computeSHA256(absPath);
 
-    // Send file_offer
+    // Register the transfer BEFORE announcing it. The peer can accept the
+    // instant the offer lands — on a fast LAN that easily beats reading a
+    // large file off disk — and an accept that finds no transfer would be
+    // dropped silently, killing the transfer at the accept timeout.
+    let resolveP;
+    const done = new Promise((r) => {
+      resolveP = r;
+    });
+
+    const acceptTimer = setTimeout(() => {
+      this.#outgoing.delete(transferId);
+      callbacks.onError(`${fileName}: offer was not accepted in time`);
+      resolveP();
+    }, this.#acceptTimeoutMs);
+    if (acceptTimer.unref) {
+      acceptTimer.unref();
+    }
+
+    this.#outgoing.set(transferId, {
+      interval: null,
+      resolve: resolveP,
+      chunks: null, // filled in once the file is read
+      skip: new Set(),
+      pending: true,
+      acceptedEarly: false, // accepted while we were still reading
+      acceptTimer,
+      broadcastFn,
+      callbacks,
+      fileName,
+      totalChunks,
+    });
+
     broadcastFn({
       action: 'file_offer',
       transferId,
@@ -87,29 +118,19 @@ export class FileTransfer {
     // (so files are never pushed without consent).
     const chunks = await this.#readChunks(absPath);
 
-    return new Promise((resolveP) => {
-      const acceptTimer = setTimeout(() => {
-        this.#outgoing.delete(transferId);
-        callbacks.onError(`${fileName}: offer was not accepted in time`);
-        resolveP();
-      }, this.#acceptTimeoutMs);
-      if (acceptTimer.unref) {
-        acceptTimer.unref();
-      }
+    const transfer = this.#outgoing.get(transferId);
+    if (!transfer) {
+      return done; // rejected or timed out while we were reading
+    }
+    transfer.chunks = chunks;
 
-      this.#outgoing.set(transferId, {
-        interval: null,
-        resolve: resolveP,
-        chunks,
-        skip: new Set(),
-        pending: true,
-        acceptTimer,
-        broadcastFn,
-        callbacks,
-        fileName,
-        totalChunks,
-      });
-    });
+    // The peer already said yes — start now that the bytes are ready.
+    if (transfer.acceptedEarly) {
+      transfer.pending = false;
+      this.#beginStreaming(transferId);
+    }
+
+    return done;
   }
 
   /** Receiver accepted the offer — start streaming (honouring resume `have`). */
@@ -118,7 +139,6 @@ export class FileTransfer {
     if (!transfer || !transfer.pending) {
       return;
     }
-    transfer.pending = false;
     clearTimeout(transfer.acceptTimer);
     if (Array.isArray(data.have)) {
       for (const i of data.have) {
@@ -127,6 +147,15 @@ export class FileTransfer {
         }
       }
     }
+
+    // Accepted before the file finished being read: remember the consent and
+    // let initSend start streaming as soon as the chunks are ready.
+    if (!transfer.chunks) {
+      transfer.acceptedEarly = true;
+      return;
+    }
+
+    transfer.pending = false;
     this.#beginStreaming(data.transferId);
   }
 

package/src/client/UI.js

@@ -19,7 +19,10 @@ const COMMAND_INFO = [
   ['/users', 'List online users'],
   ['/msg', 'Private message (DM)'],
   ['/reply', 'Reply to the last message'],
+  ['/me', 'Third-person action message'],
+  ['/topic', 'Show or set the room topic'],
   ['/mentions', 'Recent mentions of you'],
+  ['/watch', 'Alert on a keyword in any room'],
   ['/contacts', 'Contact book — aliases for peers'],
   ['/away', 'Mark yourself as away'],
   ['/back', 'Clear away status'],
@@ -41,7 +44,8 @@ const COMMAND_INFO = [
   ['/img', 'Render a high-resolution image'],
   ['/sound', 'Sound notifications'],
   ['/notify', 'Desktop notifications'],
-  ['/search', 'Search history'],
+  ['/search', 'Search history (on disk)'],
+  ['/find', 'Find in this room and jump to it'],
   ['/history', 'Recent messages from history'],
   ['/export', 'Export history'],
   ['/backup', 'Back up identity + trust'],
@@ -89,7 +93,9 @@ export const COMMANDS = [
   '/sound',
   '/msg',
   '/reply',
+  '/me',
   '/mentions',
+  '/watch',
   '/contacts',
   '/away',
   '/back',
@@ -99,11 +105,13 @@ export const COMMANDS = [
   '/dnd',
   '/join',
   '/leave',
+  '/topic',
   '/create',
   '/rooms',
   '/room',
   '/invite',
   '/search',
+  '/find',
   '/history',
   '/export',
   '/backup',
@@ -314,6 +322,39 @@ export function renderMarkdown(text) {
   return out.join('\n');
 }
 
+/**
+ * Find `query` in rendered chat lines, returning where each hit is plus a
+ * readable preview. Blessed tags are stripped before matching so a search for
+ * "fg" never matches colour markup, and the preview is centred on the hit
+ * instead of always showing the start of a long line. Pure — exported for
+ * testing.
+ *
+ * @returns {Array<{ lineIndex: number, preview: string }>} newest last
+ */
+export function findInLines(lines, query, maxHits = 200) {
+  const needle = String(query || '')
+    .trim()
+    .toLowerCase();
+  if (!needle || !Array.isArray(lines)) {
+    return [];
+  }
+  const hits = [];
+  for (let i = 0; i < lines.length && hits.length < maxHits; i++) {
+    const plain = String(lines[i]).replace(/\{[^{}]*\}/g, '');
+    const at = plain.toLowerCase().indexOf(needle);
+    if (at === -1) {
+      continue;
+    }
+    const start = Math.max(0, at - 24);
+    const slice = plain.slice(start, start + 76).trim();
+    hits.push({
+      lineIndex: i,
+      preview: `${start > 0 ? '…' : ''}${blessed.escape(slice)}`,
+    });
+  }
+  return hits;
+}
+
 // Sanitizes pasted text while PRESERVING its line structure — the input box is
 // multi-line and fenced code blocks render in markdown, so pasted code must
 // keep its newlines. Normalizes CRLF/CR, turns tabs into spaces and strips the
@@ -504,6 +545,12 @@ export class UI extends EventEmitter {
   #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
+  #topic; // current room topic, shown in the status bar
+  #finder; // Ctrl+F scrollback search overlay
+  #finderOpen;
+  #finderQuery;
+  #finderHits; // [{ lineIndex, preview }]
+  #finderMark; // line index currently highlighted by a jump
 
   constructor(nickname) {
     super();
@@ -557,6 +604,11 @@ export class UI extends EventEmitter {
     this.#activeBuffer = 'general';
     this.#redirecting = false;
     this.#bufferBar = [];
+    this.#topic = null;
+    this.#finderOpen = false;
+    this.#finderQuery = '';
+    this.#finderHits = [];
+    this.#finderMark = null;
 
     // blessed's terminfo parser can't compile the modern Setulc (underline
     // colour) capability that terminals like ghostty ship, so it dumps a
@@ -658,6 +710,24 @@ export class UI extends EventEmitter {
       },
     });
 
+    // ── Scrollback finder (Ctrl+F) ───────────────────────
+    this.#finder = blessed.list({
+      parent: this.#screen,
+      hidden: true,
+      top: 'center',
+      left: 'center',
+      width: '80%',
+      height: '55%',
+      tags: true,
+      border: { type: 'line' },
+      label: ' Find in this room (Ctrl+F) ',
+      style: {
+        border: { fg: 'cyan' },
+        selected: { bg: 'cyan', fg: 'black' },
+        item: { fg: 'white' },
+      },
+    });
+
     // ── Emoji picker (Ctrl+E) ────────────────────────────
     this.#emojiPicker = blessed.list({
       parent: this.#screen,
@@ -732,6 +802,11 @@ export class UI extends EventEmitter {
         return;
       }
 
+      if (this.#finderOpen) {
+        this.#handleFinderKey(ch, key);
+        return;
+      }
+
       this.#handleKey(ch, key);
     });
 
@@ -773,6 +848,12 @@ export class UI extends EventEmitter {
       return;
     }
 
+    // Ctrl+F — find in the current room's scrollback
+    if (key.ctrl && name === 'f') {
+      this.openFinder();
+      return;
+    }
+
     // Tab — autocomplete
     if (name === 'tab') {
       this.#handleTab();
@@ -1142,6 +1223,104 @@ export class UI extends EventEmitter {
     }
   }
 
+  // ── Scrollback finder (Ctrl+F) ───────────────────────
+  // Search what is on screen in THIS room and jump to the hit. Unlike
+  // /search (which queries the encrypted history on disk, possibly from other
+  // sessions), every result here has a real line to scroll to.
+
+  /** Open the finder, optionally pre-filled (used by /search results). */
+  openFinder(query = '') {
+    this.#finderOpen = true;
+    this.#finderQuery = query;
+    this.#refreshFinder();
+    this.#finder.show();
+    this.#finder.setFront();
+    this.#screen.render();
+  }
+
+  #closeFinder() {
+    this.#finderOpen = false;
+    this.#finder.hide();
+    this.#screen.render();
+  }
+
+  #refreshFinder() {
+    this.#finderHits = findInLines(this.#lines, this.#finderQuery);
+    this.#finder.setItems(
+      this.#finderHits.length > 0
+        ? this.#finderHits.map((h) => ` {#8888aa-fg}${h.lineIndex + 1}{/#8888aa-fg}  ${h.preview}`)
+        : [
+            this.#finderQuery
+              ? ' {#8888aa-fg}no match in this room{/#8888aa-fg}'
+              : ' {#8888aa-fg}type to search…{/#8888aa-fg}',
+          ],
+    );
+    this.#finder.select(0);
+    const q = this.#finderQuery ? ` › ${this.#finderQuery}` : '';
+    const n = this.#finderHits.length ? ` — ${this.#finderHits.length} hit(s)` : '';
+    this.#finder.setLabel(` Find in this room (Ctrl+F)${q}${n} `);
+    this.#screen.render();
+  }
+
+  /** Scroll the chat to `lineIndex` and mark it so the eye finds it. */
+  jumpToLine(lineIndex) {
+    if (lineIndex < 0 || lineIndex >= this.#lines.length) {
+      return false;
+    }
+    this.#clearJumpMark();
+    const original = this.#lines[lineIndex];
+    this.#finderMark = { lineIndex, original };
+    this.#lines[lineIndex] = `{yellow-fg}▶{/yellow-fg}${original}`;
+    this.#chatLog.setContent(this.#lines.join('\n'));
+    // Put the hit a few lines from the top so its context stays visible.
+    this.#chatLog.scrollTo(Math.max(0, lineIndex - 3));
+    this.#screen.render();
+    this.#syncScrollState();
+    return true;
+  }
+
+  #clearJumpMark() {
+    if (!this.#finderMark) {
+      return;
+    }
+    const { lineIndex, original } = this.#finderMark;
+    if (this.#lines[lineIndex] !== undefined) {
+      this.#lines[lineIndex] = original;
+    }
+    this.#finderMark = null;
+  }
+
+  #handleFinderKey(ch, key) {
+    const name = key.name || '';
+    if (name === 'escape' || (key.ctrl && name === 'c')) {
+      this.#closeFinder();
+      return;
+    }
+    if (name === 'up' || name === 'down') {
+      this.#finder[name === 'up' ? 'up' : 'down'](1);
+      this.#screen.render();
+      return;
+    }
+    if (name === 'return' || name === 'enter') {
+      const hit = this.#finderHits[this.#finder.selected];
+      this.#closeFinder();
+      if (hit) {
+        this.jumpToLine(hit.lineIndex);
+      }
+      return;
+    }
+    if (name === 'backspace') {
+      this.#finderQuery = this.#finderQuery.slice(0, -1);
+      this.#refreshFinder();
+      return;
+    }
+    const code = ch ? ch.charCodeAt(0) : 0;
+    if (ch && ch.length === 1 && !key.ctrl && !key.meta && code > 0x1f && code !== 0x7f) {
+      this.#finderQuery += ch;
+      this.#refreshFinder();
+    }
+  }
+
   // ── Emoji picker (Ctrl+E, fuzzy) ─────────────────────
   #openEmoji() {
     this.#emojiOpen = true;
@@ -1416,14 +1595,22 @@ export class UI extends EventEmitter {
     } else {
       room = `{cyan-fg}#${this.#statusRoom}{/cyan-fg}`;
     }
-    const fp = this.#statusFingerprint
-      ? `   {#8888aa-fg}🔑 ${this.#statusFingerprint}{/#8888aa-fg}`
+    // The topic earns its place next to the room name; it is what tells you
+    // what a room is FOR. Truncated so it can never push the hints off-screen.
+    const topic = this.#topic
+      ? `  {#9a9ad0-fg}📋 ${blessed.escape(
+          this.#topic.length > 60 ? `${this.#topic.slice(0, 57)}…` : this.#topic,
+        )}{/#9a9ad0-fg}`
       : '';
+    const fp =
+      this.#statusFingerprint && !this.#topic
+        ? `   {#8888aa-fg}🔑 ${this.#statusFingerprint}{/#8888aa-fg}`
+        : '';
     const hint =
       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}  `;
+    return `  ${room}${topic}${fp}      {|}  ${hint}  `;
   }
 
   #updateStatusBar() {
@@ -1433,6 +1620,12 @@ export class UI extends EventEmitter {
     }
   }
 
+  /** Set (or clear with null) the topic shown in the status bar. */
+  setTopic(text) {
+    this.#topic = text || null;
+    this.#updateStatusBar();
+  }
+
   setFingerprint(fingerprint) {
     // short prefix of the fingerprint as a persistent identity anchor
     this.#statusFingerprint = (fingerprint || '').slice(0, 17);
@@ -1673,6 +1866,20 @@ export class UI extends EventEmitter {
     this.updateLine(lineIndex, line);
   }
 
+  // Third-person action (/me). Rendered as a distinct italic line so it never
+  // reads like someone quoting themselves.
+  addActionMessage(nickname, text) {
+    this.#lastSender = null; // an action breaks message grouping
+    const line = ` {white-fg}[${time()}]{/white-fg} {magenta-fg}✦ {bold}${blessed.escape(
+      nickname,
+    )}{/bold} ${renderMarkdown(text)}{/magenta-fg}`;
+    this.#lines.push(line);
+    this.#chatLog.log(line);
+    this.#screen.render();
+    this.#noteIncoming();
+    return { lineIndex: this.#lines.length - 1 };
+  }
+
   addSystemMessage(text) {
     this.#lastSender = null; // interrupts message grouping
     const line = ` {white-fg}[${time()}] * ${blessed.escape(text)}{/white-fg}`;

package/src/crypto/CertPinStore.js

@@ -17,6 +17,7 @@ export const PinResult = {
 export class CertPinStore {
   #path;
   #store; // Map<host, sha256Fingerprint>
+  #caHosts; // Set<host> — hosts that already presented a CA-valid certificate
 
   constructor(baseDir = process.cwd()) {
     const dir = join(baseDir, PIN_DIR);
@@ -25,6 +26,7 @@ export class CertPinStore {
     }
     this.#path = join(dir, PIN_FILE);
     this.#store = new Map();
+    this.#caHosts = new Set();
     this.#load();
   }
 
@@ -32,22 +34,56 @@ export class CertPinStore {
     try {
       if (existsSync(this.#path)) {
         const data = JSON.parse(readFileSync(this.#path, 'utf-8'));
-        for (const [host, fp] of Object.entries(data)) {
-          this.#store.set(host, fp);
+        for (const [host, entry] of Object.entries(data)) {
+          // v1 stored a bare fingerprint string; v2 stores { fp, ca }.
+          if (typeof entry === 'string') {
+            this.#store.set(host, entry);
+          } else if (entry && typeof entry === 'object') {
+            if (typeof entry.fp === 'string') {
+              this.#store.set(host, entry.fp);
+            }
+            if (entry.ca) {
+              this.#caHosts.add(host);
+            }
+          }
         }
       }
     } catch {
       this.#store = new Map();
+      this.#caHosts = new Set();
     }
   }
 
   #save() {
-    writeFileSync(this.#path, JSON.stringify(Object.fromEntries(this.#store), null, 2), {
+    const obj = {};
+    // Union of both maps: a host can be CA-validated before (or without) ever
+    // having a pinned fingerprint, and that flag must survive a restart.
+    for (const host of new Set([...this.#store.keys(), ...this.#caHosts])) {
+      obj[host] = { fp: this.#store.get(host) || null, ca: this.#caHosts.has(host) };
+    }
+    writeFileSync(this.#path, JSON.stringify(obj, null, 2), {
       encoding: 'utf-8',
       mode: 0o600,
     });
   }
 
+  /**
+   * Remember that a host served a certificate that chains to a public CA.
+   * Subsequent connections to it demand full TLS verification, so a hosted
+   * relay can never be silently downgraded to a self-signed (attacker) cert.
+   */
+  markCAValidated(host) {
+    if (!this.#caHosts.has(host)) {
+      this.#caHosts.add(host);
+      this.#save();
+    }
+  }
+
+  /** True if this host must be verified strictly (it was CA-valid before). */
+  requiresStrictTLS(host) {
+    return this.#caHosts.has(host);
+  }
+
   /**
    * Check a server's cert fingerprint against the pinned one (pinning on first use).
    * @param {string} host - e.g. "100.73.206.23:3600"