ciphermesh 2.3.0 → 2.5.0

package/src/client/ChatController.js

@@ -52,8 +52,15 @@ import { tipAt, TIPS } from '../shared/tips.js';
 import { setTheme, getThemeName, themeNames } from '../shared/themes.js';
 import { panicWipe } from '../shared/panic.js';
 import { farewellBanner } from '../shared/banner.js';
-import { parseDndWindow, shouldNotify, nowMinutes, mentionsMe } from '../shared/dnd.js';
+import {
+  parseDndWindow,
+  shouldNotify,
+  nowMinutes,
+  mentionsMe,
+  matchesKeyword,
+} from '../shared/dnd.js';
 import { saveLastSession } from '../shared/lastSession.js';
+import { diagnose, formatDiagnosis } from '../shared/doctor.js';
 import { COMMANDS } from './UI.js';
 
 const TYPING_SEND_INTERVAL = 2000; // debounce: max 1 typing event per 2s
@@ -111,8 +118,12 @@ export class ChatController {
   #autoAwayTimer = null;
   #autoAwaySet = false; // whether the current away was set automatically
   #mentions = []; // session mention log: { nickname, text, room, at }
+  #watchWords = new Set(); // /watch — keywords that alert like a mention does
   #awayUnread = 0; // messages received while away
   #awayMentions = 0; // …of which mentioned me
+  #messageLines = new Map(); // messageId → { lineIndex, nickname, text, opts, room }
+  #reactions = new Map(); // messageId → Map<emoji, count>
+  #reconnectAttempts = 0; // consecutive reconnects, for the /doctor nudge
   #autoLockMs = 0; // idle screen-lock timeout (0 = off)
   #autoLockTimer = null;
   // Multi-room buffers (IRC style): lines live in the UI; membership, unread
@@ -205,6 +216,7 @@ export class ChatController {
   // the initial JOIN would be lost — the 'connected' event fired before we
   // attached the listener).
   #onConnected() {
+    this.#reconnectAttempts = 0;
     this.#ui.setConnectionState('online');
     this.#connection.send(
       createJoin(this.#nickname, this.#keyManager.publicKeyB64, this.#keyManager.pqPublicKeyB64),
@@ -230,6 +242,18 @@ export class ChatController {
     this.#connection.on('reconnecting', (delay) => {
       this.#ui.setConnectionState('reconnecting');
       this.#ui.addSystemMessage(`Reconnecting in ${delay / 1000}s...`);
+      // After a few failures this is not a blip — point at the tool that can
+      // actually explain it, once, instead of looping silently forever.
+      this.#reconnectAttempts++;
+      if (this.#reconnectAttempts === 3) {
+        this.#ui.addInfoMessage('Still failing? Run /doctor to find out where it breaks.');
+      }
+    });
+
+    this.#connection.on('cert-ca-valid', ({ issuer }) => {
+      this.#ui.addSystemMessage(
+        `TLS verified against a public CA (${issuer}) — no trust-on-first-use window`,
+      );
     });
 
     this.#connection.on('cert-pinned', ({ fingerprint }) => {
@@ -466,6 +490,13 @@ export class ChatController {
           this.#ui.addErrorMessage(
             `${msg.message}. Use /nick <other> to pick a different nickname.`,
           );
+        } else if (typeof msg.message === 'string' && msg.message.startsWith('Protocol mismatch')) {
+          // Reconnecting cannot fix a version gap — say so instead of letting
+          // the user watch an endless retry loop.
+          this.#ui.addErrorMessage(msg.message);
+          this.#ui.addInfoMessage(
+            'Reconnecting will not help until both sides run the same version.',
+          );
         } else if (msg.code === ERR.ROOM_AUTH_FAILED || msg.code === ERR.ROOM_EXISTS) {
           // Join/create refused — drop the derived secrets for that attempt.
           freeRoomSecrets(this.#pendingRoomSecrets);
@@ -592,6 +623,7 @@ export class ChatController {
         owner,
         secrets,
         pins: [],
+        topic: null, // { text, by, at } — E2EE among members, never on the relay
       });
       this.#bufferOrder.push(room);
     }
@@ -645,6 +677,7 @@ export class ChatController {
     this.#currentRoomOwner = buf.owner;
     this.#ui.switchBuffer(room);
     this.#rebuildActivePeers();
+    this.#applyTopicToUI();
     this.#updateBufferBar();
     this.#updatePrivateIndicator();
     this.#saveLastSession(buf.private);
@@ -663,6 +696,11 @@ export class ChatController {
     this.#ui.setPeerNames([...this.#peers.values()].map((p) => p.nickname));
   }
 
+  #applyTopicToUI() {
+    const topic = this.#buffers.get(this.#currentRoom)?.topic;
+    this.#ui.setTopic(topic?.text || null);
+  }
+
   #updateBufferBar() {
     this.#ui.setBufferBar(
       this.#bufferOrder.map((room) => {
@@ -761,6 +799,23 @@ export class ChatController {
     if (this.#away || this.#statusText) {
       this.#sendPayloadToPeer(peer.sessionId, this.#presencePayload());
     }
+
+    // …nor the room topic. Everyone who has it answers; the timestamp settles
+    // any disagreement, and `silent` keeps the sync out of the chat log.
+    const topic = this.#buffers.get(room)?.topic;
+    if (topic) {
+      this.#sendPayloadToPeer(
+        peer.sessionId,
+        JSON.stringify({
+          action: 'set_topic',
+          room,
+          text: topic.text,
+          at: topic.at,
+          silent: true,
+          sentAt: Date.now(),
+        }),
+      );
+    }
   }
 
   // One-time-per-session nudge to verify an unverified peer's identity.
@@ -1115,9 +1170,17 @@ export class ChatController {
       }
 
       if (data.action === 'reaction') {
-        this.#ui.toBuffer(msgRoom, () => {
-          this.#ui.addSystemMessage(`${data.emoji} ${peer.nickname} reacted to a message`);
-        });
+        // Hang the reaction off the message itself; only fall back to a log
+        // line when the target is not on screen (older or another room).
+        const applied =
+          roomActive && data.targetMessageId
+            ? this.#applyReaction(data.targetMessageId, data.emoji)
+            : false;
+        if (!applied) {
+          this.#ui.toBuffer(msgRoom, () => {
+            this.#ui.addSystemMessage(`${data.emoji} ${peer.nickname} reacted to a message`);
+          });
+        }
         if (roomActive) {
           this.#ui.playNotification();
         }
@@ -1126,7 +1189,14 @@ export class ChatController {
 
       if (data.action === 'edit_message') {
         const author = this.#messageAuthors.get(data.messageId);
-        if (author && author === peer.nickname) {
+        if (!author || author !== peer.nickname) {
+          return; // only the author may rewrite their own message
+        }
+        const entry = this.#editableMessage(data.messageId);
+        if (entry) {
+          entry.text = data.newText;
+          this.#ui.replaceMessageText(entry.lineIndex, entry.nickname, data.newText, entry.opts);
+        } else {
           this.#ui.toBuffer(msgRoom, () => {
             this.#ui.addSystemMessage(`${peer.nickname} edited: ${data.newText} (edited)`);
           });
@@ -1136,7 +1206,14 @@ export class ChatController {
 
       if (data.action === 'delete_message') {
         const author = this.#messageAuthors.get(data.messageId);
-        if (author && author === peer.nickname) {
+        if (!author || author !== peer.nickname) {
+          return;
+        }
+        const entry = this.#editableMessage(data.messageId);
+        if (entry) {
+          this.#ui.tombstoneMessage(entry.lineIndex, peer.nickname);
+          this.#messageLines.delete(data.messageId);
+        } else {
           this.#ui.toBuffer(msgRoom, () => {
             this.#ui.addSystemMessage(`${peer.nickname} deleted a message`);
           });
@@ -1144,6 +1221,33 @@ export class ChatController {
         return;
       }
 
+      if (data.action === 'set_topic') {
+        const buf = this.#buffers.get(msgRoom);
+        if (buf && typeof data.text === 'string') {
+          const at = Number(data.at) || 0;
+          // Last write wins. On join everyone who knows the topic answers, so
+          // the timestamp is what keeps those replies from fighting.
+          if (!buf.topic || at >= buf.topic.at) {
+            const text = data.text.slice(0, 200);
+            const changed = buf.topic?.text !== text;
+            buf.topic = { text, by: peer.nickname, at };
+            if (msgRoom === this.#currentRoom) {
+              this.#applyTopicToUI();
+            }
+            if (changed && !data.silent) {
+              this.#ui.toBuffer(msgRoom, () => {
+                this.#ui.addSystemMessage(
+                  text
+                    ? `📋 ${peer.nickname} set the topic of #${msgRoom}: ${text}`
+                    : `📋 ${peer.nickname} cleared the topic of #${msgRoom}`,
+                );
+              });
+            }
+          }
+        }
+        return;
+      }
+
       if (data.action === 'pin_message') {
         const pins = roomActive ? this.#pinnedMessages : this.#buffers.get(msgRoom)?.pins;
         pins?.push({
@@ -1194,7 +1298,14 @@ export class ChatController {
         });
       }
 
-      const mentioned = this.#mentionsMe(data.text) && !data.isDM;
+      const watchHit = this.#matchedWatch(data.text);
+      // A watched keyword deserves the same attention a mention gets.
+      const mentioned = (this.#mentionsMe(data.text) || !!watchHit) && !data.isDM;
+      if (watchHit) {
+        this.#ui.toBuffer(msgRoom, () => {
+          this.#ui.addSystemMessage(`👁 "${watchHit}" mentioned by ${peer.nickname} in #${msgRoom}`);
+        });
+      }
       if (mentioned) {
         this.#mentions.push({
           nickname: peer.nickname,
@@ -1221,20 +1332,26 @@ export class ChatController {
       const trust = trustBadge(this.#trustStore.getPeerRecord(peer.nickname), peer.publicKey);
       // File the message into its buffer (live log when active, stored otherwise).
       let lineIndex = -1;
+      let renderInfo = null;
       this.#ui.toBuffer(msgRoom, () => {
         if (data.replyTo?.nickname && typeof data.replyTo.excerpt === 'string') {
           this.#ui.addQuoteLine(String(data.replyTo.nickname), data.replyTo.excerpt.slice(0, 80));
         }
-        ({ lineIndex } = this.#ui.addMessage(
-          peer.nickname,
-          data.text,
-          !!data.isDM,
-          ephLabel,
-          isDeniable || !!data.deniable,
-          mentioned,
-          trust,
-        ));
+        ({ lineIndex, render: renderInfo } = data.isAction
+          ? this.#ui.addActionMessage(peer.nickname, data.text)
+          : this.#ui.addMessage(
+              peer.nickname,
+              data.text,
+              !!data.isDM,
+              ephLabel,
+              isDeniable || !!data.deniable,
+              mentioned,
+              trust,
+            ));
       });
+      if (roomActive && data.messageId) {
+        this.#rememberMessage(data.messageId, lineIndex, peer.nickname, data.text, renderInfo);
+      }
       this.#noteBufferUnread(msgRoom, mentioned);
       const notify = shouldNotify(this.#dndMode, this.#dndWindow, nowMinutes(), mentioned);
       if (notify) {
@@ -1288,6 +1405,16 @@ export class ChatController {
     return mentionsMe(text, this.#nickname);
   }
 
+  // The first /watch keyword present in the text, or null.
+  #matchedWatch(text) {
+    for (const word of this.#watchWords) {
+      if (matchesKeyword(text, word)) {
+        return word;
+      }
+    }
+    return null;
+  }
+
   // ── User input handling ───────────────────────────────────────
   #handleUserInput(text) {
     this.#noteActive();
@@ -1311,7 +1438,9 @@ export class ChatController {
         this.#ui.addInfoMessage('  /users               - List online users');
         this.#ui.addInfoMessage('  /msg <nick> <text>   - Send a private message (DM)');
         this.#ui.addInfoMessage('  /reply <text>        - Reply to the last received message');
+        this.#ui.addInfoMessage('  /me <action>         - Third-person action message');
         this.#ui.addInfoMessage('  /mentions [n]        - Recent mentions of you (this session)');
+        this.#ui.addInfoMessage('  /watch [add|remove|clear] - Alert on a keyword in any room');
         this.#ui.addInfoMessage('  /contacts [add|remove|all] - Contact book (aliases for peers)');
         this.#ui.addInfoMessage(
           '  /away [reason]       - Mark yourself as away (unreads are counted)',
@@ -1323,6 +1452,7 @@ export class ChatController {
         this.#ui.addInfoMessage('  /status <text|off>   - Set a status (accepts :emoji:)');
         this.#ui.addInfoMessage('  /join <room> [pass]  - Join a room as a new buffer (Alt+1..9)');
         this.#ui.addInfoMessage('  /leave [room]        - Leave a room (its buffer closes)');
+        this.#ui.addInfoMessage('  /topic [text|clear]  - Show or set the room topic');
         this.#ui.addInfoMessage('  /create <room> <pass> - Create a private room 🔒');
         this.#ui.addInfoMessage('  /invite [host:port]  - Generate an invite with QR code');
         this.#ui.addInfoMessage('  /rooms               - List available rooms');
@@ -1346,6 +1476,8 @@ export class ChatController {
           '  /dnd [on|off|mentions|HH:MM-HH:MM] - Do not disturb / mentions only',
         );
         this.#ui.addInfoMessage('  /search <term>       - Search the encrypted local history');
+        this.#ui.addInfoMessage('  /find [term]         - Find in this room and jump (Ctrl+F)');
+        this.#ui.addInfoMessage('  /doctor [host:port]  - Diagnose why a connection fails');
         this.#ui.addInfoMessage('  /history [n]         - Last n messages from history');
         this.#ui.addInfoMessage('  /export [path]       - Export the history (.txt or .json)');
         this.#ui.addInfoMessage('  /audit [N]           - Show the last N audit events');
@@ -1818,6 +1950,83 @@ export class ChatController {
         break;
       }
 
+      case '/topic': {
+        const buf = this.#buffers.get(this.#currentRoom);
+        const newTopic = parts.slice(1).join(' ').trim();
+
+        if (!newTopic) {
+          const t = buf?.topic;
+          this.#ui.addInfoMessage(
+            t?.text
+              ? `Topic of #${this.#currentRoom}: ${t.text}  (set by ${t.by})`
+              : `#${this.#currentRoom} has no topic. Set one with /topic <text>`,
+          );
+          break;
+        }
+
+        const text = newTopic === 'clear' ? '' : applyShortcodes(newTopic).slice(0, 200);
+        const at = Date.now();
+        if (buf) {
+          buf.topic = { text, by: this.#nickname, at };
+        }
+        this.#applyTopicToUI();
+        this.#paceOrSend(
+          JSON.stringify({ action: 'set_topic', room: this.#currentRoom, text, at, sentAt: at }),
+        );
+        this.#ui.addSystemMessage(
+          text ? `📋 You set the topic: ${text}` : '📋 You cleared the topic',
+        );
+        break;
+      }
+
+      case '/me': {
+        const actionText = parts.slice(1).join(' ').trim();
+        if (!actionText) {
+          this.#ui.addErrorMessage('Usage: /me <action>  — e.g. /me is compiling');
+          break;
+        }
+        this.#sendMessageToAll(actionText, null, true);
+        break;
+      }
+
+      case '/watch': {
+        const sub = (parts[1] || 'list').toLowerCase();
+        if (sub === 'add') {
+          const word = parts.slice(2).join(' ').trim();
+          if (!word) {
+            this.#ui.addErrorMessage('Usage: /watch add <keyword>');
+            break;
+          }
+          this.#watchWords.add(word.toLowerCase());
+          this.#ui.addInfoMessage(`Watching for "${word.toLowerCase()}" in every room`);
+          break;
+        }
+        if (sub === 'remove' || sub === 'rm') {
+          const word = parts.slice(2).join(' ').trim().toLowerCase();
+          if (this.#watchWords.delete(word)) {
+            this.#ui.addInfoMessage(`No longer watching "${word}"`);
+          } else {
+            this.#ui.addErrorMessage(`"${word}" is not being watched`);
+          }
+          break;
+        }
+        if (sub === 'clear') {
+          this.#watchWords.clear();
+          this.#ui.addInfoMessage('Watch list cleared');
+          break;
+        }
+        if (sub !== 'list') {
+          this.#ui.addErrorMessage('Usage: /watch [add <word> | remove <word> | clear]');
+          break;
+        }
+        if (this.#watchWords.size === 0) {
+          this.#ui.addInfoMessage('Not watching any keyword. Use /watch add <word>');
+          break;
+        }
+        this.#ui.addInfoMessage(`Watching: ${[...this.#watchWords].join(', ')}`);
+        break;
+      }
+
       case '/mentions': {
         if (this.#mentions.length === 0) {
           this.#ui.addInfoMessage('No mentions in this session yet.');
@@ -2000,6 +2209,28 @@ export class ChatController {
         break;
       }
 
+      case '/doctor': {
+        const target = parts.slice(1).join(' ').trim() || this.#connection.url || '';
+        this.#ui.addInfoMessage(`Diagnosing ${target} …`);
+        diagnose(target)
+          .then((steps) => {
+            for (const line of formatDiagnosis(steps)) {
+              this.#ui.addInfoMessage(line);
+            }
+          })
+          .catch((err) => {
+            this.#ui.addErrorMessage(`Diagnostics failed to run: ${err.message}`);
+          });
+        break;
+      }
+
+      case '/find': {
+        const term = parts.slice(1).join(' ').trim();
+        // Opens the same overlay as Ctrl+F, pre-filled when a term is given.
+        this.#ui.openFinder(term);
+        break;
+      }
+
       case '/search': {
         if (!this.#historyStore?.isOpen) {
           this.#ui.addErrorMessage('History disabled — start the client with a passphrase');
@@ -2019,6 +2250,11 @@ export class ChatController {
         for (const e of results) {
           this.#ui.addInfoMessage(`  ${this.#formatHistoryEntry(e)}`);
         }
+        // /search reads the on-disk history (possibly from other sessions);
+        // point at the navigable finder for what is actually on screen.
+        this.#ui.addInfoMessage(
+          `Tip: /find ${term} (or Ctrl+F) searches this room's scrollback and jumps to the message.`,
+        );
         break;
       }
 
@@ -2100,9 +2336,12 @@ export class ChatController {
           sentAt: Date.now(),
         });
         this.#broadcastPayload(reactionPayload);
-        this.#ui.addSystemMessage(
-          `${emoji} You reacted to ${this.#lastReceivedNickname}'s message`,
-        );
+        // Show it on the message right away instead of announcing it.
+        if (!this.#applyReaction(this.#lastReceivedMessageId, emoji)) {
+          this.#ui.addSystemMessage(
+            `${emoji} You reacted to ${this.#lastReceivedNickname}'s message`,
+          );
+        }
         break;
       }
 
@@ -2123,7 +2362,19 @@ export class ChatController {
           sentAt: Date.now(),
         });
         this.#broadcastPayload(editPayload);
-        this.#ui.addSystemMessage(`You edited: ${editText} (edited)`);
+        // Rewrite our own line in place, like the peers will.
+        const editEntry = this.#editableMessage(this.#lastSentMessageId);
+        if (editEntry) {
+          editEntry.text = editText;
+          this.#ui.replaceMessageText(
+            editEntry.lineIndex,
+            editEntry.nickname,
+            editText,
+            editEntry.opts,
+          );
+        } else {
+          this.#ui.addSystemMessage(`You edited: ${editText} (edited)`);
+        }
         break;
       }
 
@@ -2138,8 +2389,14 @@ export class ChatController {
           sentAt: Date.now(),
         });
         this.#broadcastPayload(deletePayload);
+        const delEntry = this.#editableMessage(this.#lastSentMessageId);
+        if (delEntry) {
+          this.#ui.tombstoneMessage(delEntry.lineIndex, this.#nickname);
+          this.#messageLines.delete(this.#lastSentMessageId);
+        } else {
+          this.#ui.addSystemMessage('You deleted a message');
+        }
         this.#lastSentMessageId = null;
-        this.#ui.addSystemMessage('You deleted a message');
         break;
       }
 
@@ -2836,6 +3093,55 @@ export class ChatController {
     this.#ui.appendBadge(tracked.lineIndex, tracked.baseLine, `{green-fg}${marker}{/green-fg}`);
   }
 
+  // Remember where a message was drawn so reactions/edits/deletes can change
+  // it in place. Bounded like the receipt tracker.
+  #rememberMessage(messageId, lineIndex, nickname, text, render) {
+    if (!messageId || lineIndex === undefined || lineIndex < 0) {
+      return;
+    }
+    this.#messageLines.set(messageId, {
+      lineIndex,
+      nickname,
+      text,
+      opts: render?.opts || {},
+      room: this.#currentRoom,
+    });
+    if (this.#messageLines.size > 200) {
+      const oldest = this.#messageLines.keys().next().value;
+      this.#messageLines.delete(oldest);
+      this.#reactions.delete(oldest);
+    }
+  }
+
+  // A message can only be redrawn while its room is the one on screen.
+  #editableMessage(messageId) {
+    const entry = this.#messageLines.get(messageId);
+    if (!entry || entry.room !== this.#currentRoom) {
+      return null;
+    }
+    return entry;
+  }
+
+  #applyReaction(messageId, emoji) {
+    const entry = this.#editableMessage(messageId);
+    if (!entry) {
+      return false;
+    }
+    const counts = this.#reactions.get(messageId) || new Map();
+    counts.set(emoji, (counts.get(emoji) || 0) + 1);
+    this.#reactions.set(messageId, counts);
+
+    // Re-render the line, then hang the reactions off the end of it.
+    const badge = [...counts.entries()].map(([e, n]) => (n > 1 ? `${e}${n}` : e)).join(' ');
+    this.#ui.replaceMessageText(entry.lineIndex, entry.nickname, entry.text, {
+      ...entry.opts,
+      edited: entry.opts?.edited,
+    });
+    const rebuilt = this.#ui.getLine(entry.lineIndex);
+    this.#ui.appendBadge(entry.lineIndex, rebuilt, badge);
+    return true;
+  }
+
   #trackSentMessage(messageId, lineIndex) {
     const baseLine = this.#ui.getLine(lineIndex);
     if (baseLine === null || baseLine === undefined) {
@@ -3090,7 +3396,7 @@ export class ChatController {
   }
 
   // ── Send encrypted message to all peers ───────────────────────
-  #sendMessageToAll(text, replyTo = null) {
+  #sendMessageToAll(text, replyTo = null, isAction = false) {
     if (!this.#connection.connected) {
       this.#ui.addErrorMessage('No connection to the server — message not sent');
       return;
@@ -3107,6 +3413,9 @@ export class ChatController {
       sentAt: Date.now(),
       messageId,
     };
+    if (isAction) {
+      msgObj.isAction = true;
+    }
     if (replyTo) {
       msgObj.replyTo = replyTo;
     }
@@ -3135,13 +3444,10 @@ export class ChatController {
       this.#ui.addQuoteLine(replyTo.nickname, replyTo.excerpt, true);
     }
     const ephLabel = this.#ephemeralMode ? this.#formatDuration(this.#ephemeralDurationMs) : null;
-    const { lineIndex } = this.#ui.addMessage(
-      this.#nickname,
-      text,
-      false,
-      ephLabel,
-      this.#deniableMode,
-    );
+    const { lineIndex, render } = isAction
+      ? this.#ui.addActionMessage(this.#nickname, text)
+      : this.#ui.addMessage(this.#nickname, text, false, ephLabel, this.#deniableMode);
+    this.#rememberMessage(messageId, lineIndex, this.#nickname, text, render);
 
     if (this.#ephemeralMode) {
       this.#scheduleEphemeralRemoval(lineIndex, this.#ephemeralDurationMs, this.#nickname);

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));