ciphermesh 2.3.0 → 2.5.0

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,9 @@ 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'],
+  ['/doctor', 'Diagnose why a connection fails'],
   ['/history', 'Recent messages from history'],
   ['/export', 'Export history'],
   ['/backup', 'Back up identity + trust'],
@@ -89,7 +94,9 @@ export const COMMANDS = [
   '/sound',
   '/msg',
   '/reply',
+  '/me',
   '/mentions',
+  '/watch',
   '/contacts',
   '/away',
   '/back',
@@ -99,11 +106,14 @@ export const COMMANDS = [
   '/dnd',
   '/join',
   '/leave',
+  '/topic',
   '/create',
   '/rooms',
   '/room',
   '/invite',
   '/search',
+  '/find',
+  '/doctor',
   '/history',
   '/export',
   '/backup',
@@ -314,6 +324,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 +547,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 +606,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 +712,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 +804,11 @@ export class UI extends EventEmitter {
         return;
       }
 
+      if (this.#finderOpen) {
+        this.#handleFinderKey(ch, key);
+        return;
+      }
+
       this.#handleKey(ch, key);
     });
 
@@ -773,6 +850,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 +1225,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 +1597,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 +1622,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);
@@ -1588,6 +1783,64 @@ export class UI extends EventEmitter {
     trust = 'none',
   ) {
     this.#daySeparator();
+    const isSelfNow = nickname === this.#nickname || nickname.includes('\u2192');
+    const opts = {
+      isDM,
+      ephemeralLabel,
+      deniable,
+      mentioned,
+      trust,
+      grouped: !isSelfNow && !isDM && this.#lastSender === nickname,
+      stamp: time(),
+    };
+    const line = this.#composeMessageLine(nickname, text, opts);
+
+    this.#lines.push(line);
+    this.#chatLog.log(line);
+    this.#screen.render();
+    this.#lastSender = isSelfNow ? 'self' : nickname;
+    if (!isSelfNow) {
+      this.#noteIncoming(mentioned || isDM);
+    }
+    return { lineIndex: this.#lines.length - 1, render: { nickname, opts } };
+  }
+
+  /**
+   * Rewrite an existing message line with new text — used by /edit, so an
+   * edited message changes IN PLACE instead of arriving as a separate line the
+   * reader has to mentally staple to the original.
+   */
+  replaceMessageText(lineIndex, nickname, newText, opts) {
+    this.updateLine(
+      lineIndex,
+      this.#composeMessageLine(nickname, newText, { ...opts, edited: true }),
+    );
+  }
+
+  /** Replace a message with a tombstone (used by /delete). */
+  tombstoneMessage(lineIndex, nickname) {
+    this.updateLine(
+      lineIndex,
+      ` {white-fg}[${time()}]{/white-fg} {#666666-fg}\ud83d\udeab ${blessed.escape(
+        nickname,
+      )} deleted a message{/#666666-fg}`,
+    );
+  }
+
+  // Builds a message line. Shared by addMessage and replaceMessageText so an
+  // edited message keeps exactly the layout it had (alignment, grouping,
+  // badges) instead of drifting into a different shape.
+  #composeMessageLine(nickname, text, opts) {
+    const {
+      isDM = false,
+      ephemeralLabel = null,
+      deniable = false,
+      mentioned = false,
+      trust = 'none',
+      grouped = false,
+      edited = false,
+      stamp = time(),
+    } = opts || {};
 
     const color = nickColor(nickname);
     const isSelf = nickname === this.#nickname || nickname.includes('\u2192');
@@ -1609,24 +1862,15 @@ export class UI extends EventEmitter {
 
     // Consecutive messages from the same peer collapse the avatar/name into a
     // compact continuation bullet (cleaner layout).
-    const grouped = !isSelf && !isDM && this.#lastSender === nickname;
+    const editedMark = edited ? ' {#8888aa-fg}(edited){/#8888aa-fg}' : '';
     const core = grouped
-      ? `{${tag}}\u00b7{/${tag}} ${renderMarkdown(text)}`
-      : `${avatar} {${tag}}${nickname}{/${tag}}${trustGlyph}${dmLabel}: ${renderMarkdown(text)}`;
+      ? `{${tag}}\u00b7{/${tag}} ${renderMarkdown(text)}${editedMark}`
+      : `${avatar} {${tag}}${nickname}{/${tag}}${trustGlyph}${dmLabel}: ${renderMarkdown(text)}${editedMark}`;
 
     // My own messages on the right (timestamp at the end), others on the left
-    const line = isSelf
-      ? this.#alignRight(`${core}${ephLabel}${denLabel} {white-fg}[${time()}]{/white-fg}`)
-      : `${bar}{white-fg}[${time()}]{/white-fg}${ephLabel}${denLabel} ${mentionMark}${core}`;
-
-    this.#lines.push(line);
-    this.#chatLog.log(line);
-    this.#screen.render();
-    this.#lastSender = isSelf ? 'self' : nickname;
-    if (!isSelf) {
-      this.#noteIncoming(mentioned || isDM);
-    }
-    return { lineIndex: this.#lines.length - 1 };
+    return isSelf
+      ? this.#alignRight(`${core}${ephLabel}${denLabel} {white-fg}[${stamp}]{/white-fg}`)
+      : `${bar}{white-fg}[${stamp}]{/white-fg}${ephLabel}${denLabel} ${mentionMark}${core}`;
   }
 
   #daySeparator() {
@@ -1673,6 +1917,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"