fix(calls): no "Missed call" in voice rooms or space channels

Joining a voice channel alone sends a call notification (m.rtc.notification)
to the room, and the timeline rendered every unanswered one as "Missed call
from X", so everyone in the channel saw a missed call from someone who had
just joined it. Ringing already excluded these rooms; the missed-call line
didn't.

utils/callRing.ts (unit-tested) holds the one rule for both: only DMs and
invite-only groups outside any space ring or show "Missed call"; voice
rooms, space channels, restricted and public rooms don't.

Verified headless with the same two notifications from Bob: the Voice
Lounge chat showed 2 "Missed call" lines before, 0 after; a small
invite-only group still shows its missed call.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017PCb59uY3UKqDqt7B6hzd5

src/app/components/CallEmbedProvider.tsx

@@ -20,7 +20,6 @@ import {
 import {
   EventTimelineSetHandlerMap,
   EventType,
-  JoinRule,
   RelationType,
   Room,
   RoomEvent,
@@ -72,7 +71,8 @@ import { useReducedMotion } from '../hooks/useReducedMotion';
 import { useSetting } from '../state/hooks/settings';
 import { useCallPreferences } from '../state/hooks/callPreferences';
 import { settingsAtom } from '../state/settings';
-import { getStateEvent, getStateEvents, getMemberName } from '../utils/room';
+import { getStateEvent, getMemberName } from '../utils/room';
+import { isRingableRoom } from '../utils/callRing';
 import { StateEvent } from '../../types/matrix/room';
 import { getPowersLevelFromMatrixEvent } from '../hooks/usePowerLevels';
 import { getRoomCreatorsForRoomId } from '../hooks/useRoomCreators';
@@ -581,12 +581,7 @@ function IncomingCallListener({ callEmbed, joined }: IncomingCallListenerProps)
       // Only ring in rooms where the call button is visible: DMs or invite-only rooms
       // with no space parent. Persistent voice rooms (call rooms), space channels,
       // restricted rooms, and public rooms must never trigger ringing.
-      if (room.isCallRoom()) return;
-      const isDirect = directs.has(room.roomId);
-      const isSpaceChild = getStateEvents(room, StateEvent.SpaceParent).length > 0;
-      const joinRule = room.getJoinRule();
-      const isPrivateInviteGroup = !isSpaceChild && joinRule === JoinRule.Invite;
-      if (!isDirect && !isPrivateInviteGroup) return;
+      if (!isRingableRoom(room, directs.has(room.roomId))) return;
 
       const info: IncomingCallInfo = {
         room,

src/app/features/room/RoomTimeline.tsx

@@ -138,6 +138,7 @@ import { useMediaAuthentication } from '../../hooks/useMediaAuthentication';
 import { useIgnoredUsers } from '../../hooks/useIgnoredUsers';
 import { useImagePackRooms } from '../../hooks/useImagePackRooms';
 import { useIsDirectRoom } from '../../hooks/useRoom';
+import { isRingableRoom } from '../../utils/callRing';
 import { useOpenUserRoomProfile } from '../../state/hooks/userRoomProfile';
 import { useSpaceOptionally } from '../../hooks/useSpace';
 import { useRoomCreators } from '../../hooks/useRoomCreators';
@@ -2030,6 +2031,9 @@ export function RoomTimeline({ room, eventId, roomInputRef, editor }: RoomTimeli
       [EventType.RTCNotification]: (mEventId, mEvent, item) => {
         const senderId = mEvent.getSender() ?? '';
         if (!senderId || senderId === mx.getUserId()) return null;
+        // Same rule as ringing: no "Missed call" in voice rooms or space
+        // channels, where starting a call is just joining the channel.
+        if (!isRingableRoom(room, direct)) return null;
         const content = mEvent.getContent();
         const mention =
           content['m.mentions']?.room ||

src/app/utils/callRing.test.ts

@@ -0,0 +1,29 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import type { Room } from 'matrix-js-sdk';
+import { isRingableRoom } from './callRing';
+
+const fakeRoom = (opts: { callRoom?: boolean; joinRule?: string; spaceParent?: boolean }): Room =>
+  ({
+    isCallRoom: () => !!opts.callRoom,
+    getJoinRule: () => opts.joinRule ?? 'invite',
+    getLiveTimeline: () => ({
+      getState: () => ({ getStateEvents: () => (opts.spaceParent ? [{}] : []) }),
+    }),
+  }) as unknown as Room;
+
+test('voice rooms never ring or show "missed call", even as DMs', () => {
+  assert.equal(isRingableRoom(fakeRoom({ callRoom: true }), false), false);
+  assert.equal(isRingableRoom(fakeRoom({ callRoom: true }), true), false);
+});
+
+test('DMs and invite-only groups outside a space ring', () => {
+  assert.equal(isRingableRoom(fakeRoom({ joinRule: 'public' }), true), true);
+  assert.equal(isRingableRoom(fakeRoom({ joinRule: 'invite' }), false), true);
+});
+
+test('space channels, public and restricted rooms do not ring', () => {
+  assert.equal(isRingableRoom(fakeRoom({ joinRule: 'invite', spaceParent: true }), false), false);
+  assert.equal(isRingableRoom(fakeRoom({ joinRule: 'public' }), false), false);
+  assert.equal(isRingableRoom(fakeRoom({ joinRule: 'restricted' }), false), false);
+});

src/app/utils/callRing.ts

@@ -0,0 +1,18 @@
+import { JoinRule, Room } from 'matrix-js-sdk';
+import { StateEvent } from '../../types/matrix/room';
+import { getStateEvents } from './room';
+
+/**
+ * Whether a call notification in this room may ring — and, by the same rule,
+ * whether an unanswered one may show as "Missed call" (Gitea #162 follow-up).
+ * Only DMs and invite-only groups outside any space ring, i.e. rooms where the
+ * call button is shown. Persistent voice rooms, space channels, restricted and
+ * public rooms never do: joining a voice channel alone is normal and isn't a
+ * "call" anyone missed.
+ */
+export const isRingableRoom = (room: Room, isDirect: boolean): boolean => {
+  if (room.isCallRoom()) return false;
+  if (isDirect) return true;
+  const isSpaceChild = getStateEvents(room, StateEvent.SpaceParent).length > 0;
+  return !isSpaceChild && room.getJoinRule() === JoinRule.Invite;
+};

src/app/utils/linkSafety.test.ts

@@ -38,3 +38,38 @@ test('hostFromText only accepts URL/host-shaped text; IDN becomes punycode', ()
   assert.equal(analyzeLink('paypal.com', 'https://xn--pypal-4ve.com/')?.punycode, true);
   assert.equal(analyzeLink('paypal.com', 'https://xn--pypal-4ve.com/')?.mismatch, true);
 });
+
+test('a trusted name inside a sentence still exposes a different destination (#335)', () => {
+  const a = analyzeLink('Log in at chat.lotusguild.org', 'https://evil.example/');
+  assert.equal(a?.mismatch, true);
+  assert.equal(a?.shownHost, 'chat.lotusguild.org');
+  assert.equal(
+    analyzeLink('chat.lotusguild.org (official)', 'https://evil.example/')?.mismatch,
+    true,
+  );
+  assert.equal(
+    analyzeLink('Open https://paypal.com/login now', 'https://evil.example/')?.mismatch,
+    true,
+  );
+  // honest sentences are not flagged
+  assert.equal(
+    analyzeLink('Log in at chat.lotusguild.org', 'https://chat.lotusguild.org/login')?.mismatch,
+    false,
+  );
+  assert.equal(analyzeLink('read the docs', 'https://evil.example/')?.mismatch, false);
+  assert.equal(analyzeLink('see main.py and report.pdf', 'https://github.com/x')?.mismatch, false);
+  assert.equal(analyzeLink('release v1.2.3 notes', 'https://github.com/x')?.mismatch, false);
+});
+
+test('shared hosting suffixes are separate sites (#335)', () => {
+  assert.equal(registrableDomain('alice.github.io'), 'alice.github.io');
+  assert.equal(registrableDomain('www.alice.github.io'), 'alice.github.io');
+  assert.equal(registrableDomain('bucket.s3.amazonaws.com'), 'bucket.s3.amazonaws.com');
+  assert.equal(analyzeLink('alice.github.io', 'https://evil.github.io/')?.mismatch, true);
+  assert.equal(analyzeLink('lotusguild.pages.dev', 'https://evil.pages.dev/')?.mismatch, true);
+  assert.equal(
+    analyzeLink('alice.github.io/blog', 'https://alice.github.io/blog/1')?.mismatch,
+    false,
+  );
+  assert.equal(registrableDomain('news.bbc.co.uk'), 'bbc.co.uk');
+});

src/app/utils/linkSafety.ts

@@ -48,11 +48,53 @@ const TWO_LABEL_SUFFIXES = new Set([
   'com.tw',
 ]);
 
+// [Gitea #335] Shared-hosting suffixes (the Public Suffix List's "private"
+// section, the ones phishing actually uses): every customer gets their own
+// subdomain, so `alice.github.io` and `evil.github.io` are different sites.
+// A curated list rather than the full PSL keeps this out of the bundle budget.
+const SHARED_HOSTING_SUFFIXES = new Set([
+  'github.io',
+  'gitlab.io',
+  'codeberg.page',
+  'pages.dev',
+  'workers.dev',
+  'trycloudflare.com',
+  'netlify.app',
+  'vercel.app',
+  'web.app',
+  'firebaseapp.com',
+  'appspot.com',
+  'herokuapp.com',
+  'onrender.com',
+  'fly.dev',
+  'glitch.me',
+  'replit.app',
+  'repl.co',
+  'surge.sh',
+  'blogspot.com',
+  'wordpress.com',
+  'wixsite.com',
+  'weebly.com',
+  'azurewebsites.net',
+  'cloudfront.net',
+  'ngrok.io',
+  'ngrok-free.app',
+  'duckdns.org',
+  's3.amazonaws.com',
+]);
+
+const isPublicSuffix = (suffix: string): boolean =>
+  TWO_LABEL_SUFFIXES.has(suffix) || SHARED_HOSTING_SUFFIXES.has(suffix);
+
 export const registrableDomain = (host: string): string => {
   const labels = host.toLowerCase().replace(/\.$/, '').split('.');
-  if (labels.length <= 2) return labels.join('.');
-  const lastTwo = labels.slice(-2).join('.');
-  return TWO_LABEL_SUFFIXES.has(lastTwo) ? labels.slice(-3).join('.') : lastTwo;
+  // Longest matching public suffix wins (3 labels, e.g. s3.amazonaws.com, then 2).
+  for (const n of [3, 2]) {
+    if (labels.length > n && isPublicSuffix(labels.slice(-n).join('.'))) {
+      return labels.slice(-(n + 1)).join('.');
+    }
+  }
+  return labels.slice(-2).join('.');
 };
 
 const HOST_LIKE =
@@ -72,6 +114,85 @@ export const hostFromText = (text: string): string | null => {
   }
 };
 
+// Words that look like hosts but are usually files or versions in chat
+// ("see main.py", "report.pdf", "v1.2.3"): skipped inside sentences unless
+// written as a URL (scheme, www., or a path) so ordinary links aren't flagged.
+const FILE_EXTENSIONS = new Set([
+  'py',
+  'sh',
+  'md',
+  'rs',
+  'js',
+  'ts',
+  'tsx',
+  'jsx',
+  'json',
+  'yaml',
+  'yml',
+  'toml',
+  'txt',
+  'log',
+  'csv',
+  'pdf',
+  'zip',
+  'gz',
+  'tar',
+  'png',
+  'jpg',
+  'jpeg',
+  'gif',
+  'webp',
+  'svg',
+  'mp3',
+  'mp4',
+  'mov',
+  'html',
+  'htm',
+  'css',
+  'exe',
+  'dll',
+  'lock',
+  'cfg',
+  'conf',
+  'ini',
+  'xml',
+  'doc',
+  'docx',
+  'xls',
+  'xlsx',
+  'ppt',
+  'pptx',
+  'apk',
+  'iso',
+  'jar',
+  'java',
+  'go',
+  'rb',
+  'php',
+  'c',
+  'h',
+  'cpp',
+]);
+const TRIM_PUNCT = /^[\s"'“”‘’«»([{<]+|[\s"'“”‘’«»)\]}>.,;:!?]+$/g;
+
+/** Every host a sentence names (Gitea #335), e.g. "Log in at chat.lotusguild.org". */
+export const hostsFromText = (text: string): string[] => {
+  const hosts: string[] = [];
+  text.split(/\s+/).forEach((raw) => {
+    const word = raw.replace(TRIM_PUNCT, '');
+    const host = word && hostFromText(word);
+    if (!host) return;
+    const tld = host.split('.').pop() ?? '';
+    if (!/[a-z]/i.test(tld)) return; // version numbers, IPs-as-words
+    const urlShaped =
+      /^[a-z][a-z0-9+.-]*:\/\//i.test(word) || /^www\./i.test(word) || word.includes('/');
+    if (!urlShaped && host.split('.').length === 2 && FILE_EXTENSIONS.has(tld.toLowerCase()))
+      return;
+    if (!hosts.includes(host)) hosts.push(host);
+  });
+  return hosts;
+};
+
 export type LinkSafety = {
   /** The visible text names a different site than the destination. */
   mismatch: boolean;
@@ -92,8 +213,11 @@ export const analyzeLink = (text: string, href: string): LinkSafety | null => {
   if (url.hostname === 'matrix.to') return null;
   const realHost = url.hostname;
   const punycode = realHost.split('.').some((l) => l.startsWith('xn--'));
-  const shownHost = hostFromText(text) ?? undefined;
-  const mismatch =
-    shownHost !== undefined && registrableDomain(shownHost) !== registrableDomain(realHost);
-  return { mismatch, shownHost, realHost, punycode };
+  // A single URL/host-shaped text, or (Gitea #335) host-shaped words inside a
+  // sentence: "Log in at chat.lotusguild.org" must not hide a different site.
+  const single = hostFromText(text);
+  const shown = single ? [single] : hostsFromText(text);
+  const realSite = registrableDomain(realHost);
+  const other = shown.find((h) => registrableDomain(h) !== realSite);
+  return { mismatch: other !== undefined, shownHost: other ?? shown[0], realHost, punycode };
 };