ciphermesh 2.3.0 → 2.4.0

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"