fix(status): any Lotus device clears an auto-expiring status, not just the one that set it (#300)

"Clear after 1 hour" lived in that device's localStorage, so a status
set on a laptop that was then closed stayed on the server until the
laptop opened Lotus again. The expiry is now also kept in account data
(io.lotus.status_expiry: { status_msg, expires_at }). Every device's
StatusExpiryMonitor clears the status when due, but only if it is still
the one that was set to expire (otherwise it just forgets the expiry).

Fixes #300

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

src/app/features/message-search/useMessageSearch.test.ts

@@ -1,7 +1,6 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import {
-  foldEdits,
   filterGroupsByDateRange,
   filterGroupsByMsgType,
   filterGroupsByPinned,
@@ -110,47 +109,3 @@ test('filterGroupsByPinned: keeps pinned items and drops empty groups', () => {
     ['$2'],
   );
 });
-
-const sr = (eventId: string, ts: number, content: Record<string, unknown>) =>
-  ({
-    rank: 1,
-    result: {
-      event_id: eventId,
-      room_id: '!r:x',
-      origin_server_ts: ts,
-      type: 'm.room.message',
-      content,
-    },
-  }) as unknown as Parameters<typeof foldEdits>[0][number];
-
-test('foldEdits: one row per message, showing the latest edit (#288)', () => {
-  const edit = (id: string, ts: number, body: string) =>
-    sr(id, ts, {
-      body: `* ${body}`,
-      'm.new_content': { body },
-      'm.relates_to': { rel_type: 'm.replace', event_id: '$orig' },
-    });
-  const out = foldEdits([
-    edit('$e2', 30, 'Tuesday 11am room B'),
-    sr('$orig', 10, { body: 'Monday 10am room A' }),
-    edit('$e1', 20, 'Tuesday 10am room A'),
-    sr('$other', 5, { body: 'meeting notes' }),
-  ]);
-  assert.deepEqual(
-    out.map((r) => r.result.event_id),
-    ['$orig', '$other'],
-  );
-  assert.deepEqual(out[0].result.content['m.new_content'], { body: 'Tuesday 11am room B' });
-  assert.equal(out[0].result.content.body, 'Monday 10am room A');
-});
-
-test('foldEdits: an edit whose original did not match stands in for it', () => {
-  const out = foldEdits([
-    sr('$e1', 20, {
-      'm.new_content': { body: 'x' },
-      'm.relates_to': { rel_type: 'm.replace', event_id: '$orig' },
-    }),
-  ]);
-  assert.equal(out.length, 1);
-  assert.equal(out[0].result.event_id, '$orig');
-});

src/app/features/message-search/useMessageSearch.ts

@@ -96,58 +96,10 @@ export const filterGroupsByDateRange = (
     .filter((group) => group.items.length > 0);
 };
 
-/**
- * [Gitea #288] Server search also returns `m.replace` events, so an edited
- * message showed once per version. Fold each edit into its message: one row,
- * at the first position any version ranked, showing the latest text and
- * pointing at the original event (so "jump" lands on the real message).
- */
-export const foldEdits = (results: ISearchResult[]): ISearchResult[] => {
-  const targetOf = (r: ISearchResult): string => {
-    const rel = r.result.content?.['m.relates_to'];
-    return rel?.rel_type === 'm.replace' && typeof rel.event_id === 'string'
-      ? rel.event_id
-      : r.result.event_id;
-  };
-  const isEdit = (r: ISearchResult) => targetOf(r) !== r.result.event_id;
-  const order: string[] = [];
-  const originals = new Map<string, ISearchResult>();
-  const latestEdit = new Map<string, ISearchResult>();
-  results.forEach((r) => {
-    const target = targetOf(r);
-    if (!originals.has(target) && !latestEdit.has(target)) order.push(target);
-    if (!isEdit(r)) {
-      originals.set(target, r);
-      return;
-    }
-    const prev = latestEdit.get(target);
-    if (!prev || r.result.origin_server_ts > prev.result.origin_server_ts)
-      latestEdit.set(target, r);
-  });
-  return order.map((target) => {
-    const original = originals.get(target);
-    const edit = latestEdit.get(target);
-    const newContent = edit?.result.content?.['m.new_content'];
-    if (original && !newContent) return original;
-    if (original) {
-      return {
-        ...original,
-        result: {
-          ...original.result,
-          content: { ...original.result.content, 'm.new_content': newContent },
-        },
-      };
-    }
-    // Only an edit matched: show it as its message.
-    const only = edit as ISearchResult;
-    return { ...only, result: { ...only.result, event_id: target } };
-  });
-};
-
 const groupSearchResult = (results: ISearchResult[]): ResultGroup[] => {
   const groups: ResultGroup[] = [];
 
-  foldEdits(results).forEach((item) => {
+  results.forEach((item) => {
     const roomId = item.result.room_id;
     const resultItem: ResultItem = {
       rank: item.rank,

src/app/features/settings/account/Profile.tsx

@@ -67,6 +67,7 @@ import {
   makePresetId,
   normalizeLabel,
 } from '../../../utils/statusPresets';
+import { writeStatusExpiry } from '../../../utils/statusExpiry';
 
 type ProfileProps = {
   profile: UserProfile;
@@ -508,12 +509,16 @@ function ProfileStatus() {
       if (msg && delayMs > 0) {
         // Persist the expiry timestamp; the always-mounted StatusExpiryMonitor
         // (ClientNonUIFeatures) fires the auto-clear even when Settings is closed.
-        localStorage.setItem(STATUS_EXPIRY_KEY(userId), String(Date.now() + delayMs));
+        const expiresAt = Date.now() + delayMs;
+        localStorage.setItem(STATUS_EXPIRY_KEY(userId), String(expiresAt));
+        // [Gitea #300] …and on every other Lotus device, via account data.
+        writeStatusExpiry(mx, msg, expiresAt).catch(() => undefined);
       } else {
         localStorage.removeItem(STATUS_EXPIRY_KEY(userId));
+        writeStatusExpiry(mx, msg).catch(() => undefined);
       }
     },
-    [saveStatus, userId],
+    [saveStatus, userId, mx],
   );
 
   const handleSubmit: FormEventHandler<HTMLFormElement> = (evt) => {
@@ -553,6 +558,7 @@ function ProfileStatus() {
     setStatusMsg('');
     localStorage.removeItem(STATUS_MSG_KEY(userId));
     localStorage.removeItem(STATUS_EXPIRY_KEY(userId));
+    writeStatusExpiry(mx, '').catch(() => undefined);
     // Preserve the user's chosen presence when clearing the status message.
     mx.setPresence({
       presence: presenceStateFromSetting(presenceStatus, hidePresence),

src/app/pages/client/ClientNonUIFeatures.tsx

@@ -91,6 +91,7 @@ import {
   shouldNotifyThreadReply,
   THREAD_NOTIFICATIONS_FALLBACK_BEHAVIOR,
 } from '../../utils/threadNotifications';
+import { readStatusExpiry, statusExpiryAction, writeStatusExpiry } from '../../utils/statusExpiry';
 
 // Grace period after the initial sync settles before invite notifications arm, so
 // the async invite-atom population lands first and isn't mistaken for new invites.
@@ -427,12 +428,7 @@ function StatusExpiryMonitor() {
     // permanently and the status stayed set forever. Retry the write (honouring
     // Retry-After), and only forget the status once the server has taken it.
     let clearing = false;
-    const check = () => {
-      if (clearing) return;
-      const stored = localStorage.getItem(expiryKey);
-      if (!stored) return;
-      const ts = parseInt(stored, 10);
-      if (!ts || Date.now() < ts) return;
+    const clearStatus = () => {
       clearing = true;
       setPresenceWithRetry(mx, {
         presence: presenceStateFromSetting(presenceStatusRef.current, hidePresenceRef.current),
@@ -442,12 +438,31 @@ function StatusExpiryMonitor() {
           noteLocalStatusWrite();
           localStorage.removeItem(msgKey);
           localStorage.removeItem(expiryKey);
+          writeStatusExpiry(mx, '').catch(() => undefined);
         })
         .catch(() => undefined)
         .finally(() => {
           clearing = false;
         });
     };
+    const check = () => {
+      if (clearing) return;
+      const stored = localStorage.getItem(expiryKey);
+      const ts = stored ? parseInt(stored, 10) : 0;
+      if (ts && Date.now() >= ts) {
+        clearStatus();
+        return;
+      }
+      // [Gitea #300] An expiry set on another device (account data): clear the
+      // status if it is still that one, otherwise just forget the expiry.
+      const action = statusExpiryAction(
+        readStatusExpiry(mx),
+        mx.getUser(userId)?.presenceStatusMsg,
+        Date.now(),
+      );
+      if (action === 'clear') clearStatus();
+      else if (action === 'forget') writeStatusExpiry(mx, '').catch(() => undefined);
+    };
 
     check();
     // Poll often enough that a rate-limited retry lands promptly, but not so

src/app/utils/statusExpiry.test.ts

@@ -0,0 +1,22 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { parseStatusExpiry, statusExpiryAction } from './statusExpiry';
+
+test('parseStatusExpiry (#300)', () => {
+  assert.deepEqual(parseStatusExpiry({ status_msg: '🍔 Lunch', expires_at: 5 }), {
+    statusMsg: '🍔 Lunch',
+    expiresAt: 5,
+  });
+  assert.equal(parseStatusExpiry({}), undefined);
+  assert.equal(parseStatusExpiry({ status_msg: '', expires_at: 5 }), undefined);
+  assert.equal(parseStatusExpiry({ status_msg: 'x', expires_at: '5' }), undefined);
+});
+
+test('statusExpiryAction: clears only the status that was set to expire (#300)', () => {
+  const e = { statusMsg: '🍔 Lunch', expiresAt: 1000 };
+  assert.equal(statusExpiryAction(e, '🍔 Lunch', 999), 'none');
+  assert.equal(statusExpiryAction(e, '🍔 Lunch', 1000), 'clear');
+  assert.equal(statusExpiryAction(e, '🎮 Gaming', 2000), 'forget');
+  assert.equal(statusExpiryAction(e, '', 2000), 'forget');
+  assert.equal(statusExpiryAction(undefined, 'x', 2000), 'none');
+});

src/app/utils/statusExpiry.ts

@@ -0,0 +1,46 @@
+import { MatrixClient } from 'matrix-js-sdk';
+import { AccountDataEvent } from '../../types/matrix/accountData';
+import { getAccountData } from './room';
+
+/**
+ * [Gitea #300] The status message's auto-clear time, in account data so every
+ * Lotus device knows it. Before, only the device that set "clear after 1 hour"
+ * (localStorage) ever cleared it, and only while it was open.
+ */
+export type StatusExpiry = { statusMsg: string; expiresAt: number };
+
+/** Pure: parse `io.lotus.status_expiry` content. */
+export function parseStatusExpiry(content: unknown): StatusExpiry | undefined {
+  const c = content as { status_msg?: unknown; expires_at?: unknown } | undefined;
+  if (!c || typeof c.status_msg !== 'string' || typeof c.expires_at !== 'number') return undefined;
+  if (!c.status_msg || !Number.isFinite(c.expires_at)) return undefined;
+  return { statusMsg: c.status_msg, expiresAt: c.expires_at };
+}
+
+/**
+ * Pure: what to do with a due expiry. Clear the server status only if it is
+ * still the one that was set to expire; if it has since changed (e.g. on
+ * another device), just forget the expiry.
+ */
+export function statusExpiryAction(
+  entry: StatusExpiry | undefined,
+  currentStatusMsg: string | undefined,
+  now: number,
+): 'none' | 'clear' | 'forget' {
+  if (!entry || now < entry.expiresAt) return 'none';
+  return (currentStatusMsg ?? '') === entry.statusMsg ? 'clear' : 'forget';
+}
+
+export const readStatusExpiry = (mx: MatrixClient): StatusExpiry | undefined =>
+  parseStatusExpiry(getAccountData(mx, AccountDataEvent.LotusStatusExpiry)?.getContent());
+
+/** Record (or with no `expiresAt`, remove) the shared auto-clear time. */
+export async function writeStatusExpiry(
+  mx: MatrixClient,
+  statusMsg: string,
+  expiresAt?: number,
+): Promise<void> {
+  const content =
+    statusMsg && expiresAt !== undefined ? { status_msg: statusMsg, expires_at: expiresAt } : {};
+  await mx.setAccountData(AccountDataEvent.LotusStatusExpiry as never, content as never);
+}

src/types/matrix/accountData.ts

@@ -26,6 +26,10 @@ export enum AccountDataEvent {
   // [Gitea #104] Synced subset of the Lotus Settings object (utils/settingsSync).
   LotusSettings = 'io.lotus.settings',
 
+  // [Gitea #300] When the status message auto-clears: { status_msg, expires_at },
+  // so any Lotus device can clear it (not only the one that set it).
+  LotusStatusExpiry = 'io.lotus.status_expiry',
+
   SecretStorageDefaultKey = 'm.secret_storage.default_key',
 
   CrossSigningMaster = 'm.cross_signing.master',