@rapidmx/web-client 0.35.0 → 0.37.0

package/apps/shared/search/zeroAccessSyncState.ts

@@ -0,0 +1,70 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+/**
+ * Where a zero-access sync pass (`zeroAccessIndexSync.ts`) remembers what it imported into a mailbox's local index - the segments it
+ * holds, the live tail's last read - and the forgetting of it when that index is destroyed (`localIndexRpcClient.ts`'s
+ * `destroyLocalIndex()`/`destroyAllLocalIndexes()`: a lock, sign-out; `pruneInaccessibleLocalIndexes()`; the Worker discarding a corrupted
+ * index). Apart from both so neither imports the other.
+ *
+ * What was remembered describes an index that is gone, so it must not outlive it - a new index the build fills first (decrypted
+ * end-to-end mail) would otherwise be taken for the old one, and the segments it never got skipped. A pass that started before the destroy
+ * must not write it back either: each pass reads `zeroAccessSyncEpoch()` when it starts and saves nothing once it changed.
+ */
+
+const PREFIX = "rapidmx:za-index-sync:";
+
+/** The localStorage key of `mailboxUid`'s sync state. */
+export const zeroAccessSyncStateKey = (mailboxUid: string): string => `${PREFIX}${mailboxUid}`;
+
+const epochs = new Map<string, number>();
+let allEpoch = 0;
+
+/** Changes whenever `mailboxUid`'s sync state is forgotten. */
+export function zeroAccessSyncEpoch(mailboxUid: string): string {
+    return `${allEpoch}:${epochs.get(mailboxUid) ?? 0}`;
+}
+
+/** Forgets what a pass remembered for `mailboxUid` (its local index is destroyed). */
+export function forgetZeroAccessSync(mailboxUid: string): void {
+    epochs.set(mailboxUid, (epochs.get(mailboxUid) ?? 0) + 1);
+    try {
+        localStorage.removeItem(zeroAccessSyncStateKey(mailboxUid));
+    } catch {
+        // Nothing to forget.
+    }
+}
+
+/** Forgets what passes remembered for every mailbox (every local index is destroyed). */
+export function forgetAllZeroAccessSync(): void {
+    allEpoch++;
+    try {
+        storedMailboxUids().forEach((mailboxUid) => localStorage.removeItem(zeroAccessSyncStateKey(mailboxUid)));
+    } catch {
+        // Nothing to forget.
+    }
+}
+
+/** Forgets what passes remembered for every mailbox not in `keep` (their local indexes are pruned). */
+export function forgetZeroAccessSyncExcept(keep: ReadonlySet<string>): void {
+    let stored: string[];
+    try {
+        stored = storedMailboxUids();
+    } catch {
+        return;
+    }
+    stored.filter((mailboxUid) => !keep.has(mailboxUid)).forEach(forgetZeroAccessSync);
+}
+
+/** The mailboxes some sync state is stored for. Throws when storage can't be read. */
+function storedMailboxUids(): string[] {
+    const uids: string[] = [];
+    for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (key?.startsWith(PREFIX)) {
+            uids.push(key.slice(PREFIX.length));
+        }
+    }
+    return uids;
+}

package/apps/shared/zeroAccess/ProtectedMark.tsx

@@ -0,0 +1,19 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import React from "react";
+import { isProtectedRecord, type SealedRecord } from "../../../lib/zeroAccess/sealedRecords.js";
+
+/** A small lock beside a calendar event, contact or task whose details zero-access encryption protects (`sealedFields`) - nothing for
+ * one it doesn't. Never says "end-to-end": the server sees what is saved while it saves it (restapi `specs/search.md` §3). */
+export default function ProtectedMark({ record }: { record: SealedRecord }) {
+    if (!isProtectedRecord(record)) {
+        return null;
+    }
+    return (
+        <span className="ml-1 text-text-muted text-xs" role="img" aria-label="Protected by zero-access encryption" title="Protected by zero-access encryption">
+            &#128274;
+        </span>
+    );
+}

package/apps/shared/zeroAccess/useKeysLocked.ts

@@ -0,0 +1,25 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import { useEffect, useRef } from "react";
+import { subscribeKeySession } from "../../../lib/crypto/keySession.js";
+
+/**
+ * Calls `onLocked` with the mailbox whenever a mailbox's keys lock (the idle timeout, a lock from settings, signing out) - for a page that
+ * holds records it opened with them in its state: the opened-value caches are cleared on a lock, but a page's state is not, so it reloads
+ * (the reloaded records keep their placeholders) and closes what shows opened content. The latest `onLocked` is called; subscribed once.
+ */
+export function useKeysLocked(onLocked: (mailboxUid: string) => void): void {
+    const latest = useRef(onLocked);
+    latest.current = onLocked;
+    useEffect(
+        () =>
+            subscribeKeySession(({ mailboxUid, state }) => {
+                if (state === "locked") {
+                    latest.current(mailboxUid);
+                }
+            }),
+        [],
+    );
+}

package/apps/shared/zeroAccess/useOpenedRecord.ts

@@ -0,0 +1,71 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import { useEffect, useState } from "react";
+import { subscribeKeySession } from "../../../lib/crypto/keySession.js";
+import { isProtectedRecord, openSealedRecord, type SealedRecord } from "../../../lib/zeroAccess/sealedRecords.js";
+
+/** The record's `uid`, when it has one - a new object for the same record (a live update, the page's own reload) is the same record. */
+function uidOf(record: SealedRecord | undefined): string | undefined {
+    return (record as { uid?: unknown } | undefined)?.uid as string | undefined;
+}
+
+/**
+ * `record` with all its protected fields opened (`openSealedRecord()`), for a view that shows or edits every field - a list opens only
+ * what it shows. `ready` is false while a protected record is first being opened; `record` is the one given meanwhile, and the given one
+ * again when it can't be opened (the mailbox is locked).
+ *
+ * A new object for the same record (same `uid`) keeps the opened one ready while it is opened in turn, so a form over it isn't unmounted by
+ * a live update (its in-progress edits kept); the new one - its new `version` - takes over once opened. The record's mailbox locking drops
+ * what was opened at once (nothing opened outlives its key session) and opens it again, which gives the placeholders; its unlocking opens it
+ * again too.
+ *
+ * `open` opens it, `openSealedRecord()` unless a kind of record has its own full open (a calendar event's `fullyOpenedEvent()`, which keeps
+ * the title opened from its sealed content) - a function defined once, not per render, so the record isn't opened again on every render.
+ */
+export function useOpenedRecord<T extends SealedRecord>(
+    record: T | undefined,
+    open: (record: T) => Promise<T> = openSealedRecord,
+): { record: T | undefined; ready: boolean } {
+    const [opened, setOpened] = useState<{ from: T; record: T } | undefined>(undefined);
+    const [generation, setGeneration] = useState(0);
+    const protectedRecord = isProtectedRecord(record);
+    const mailboxUid = record?.mailboxUid;
+    useEffect(() => {
+        if (!mailboxUid || !protectedRecord) {
+            return;
+        }
+        return subscribeKeySession((event) => {
+            if (event.mailboxUid !== mailboxUid) {
+                return;
+            }
+            if (event.state === "locked") {
+                setOpened(undefined);
+            }
+            setGeneration((current) => current + 1);
+        });
+    }, [mailboxUid, protectedRecord]);
+    useEffect(() => {
+        if (!record || !protectedRecord) {
+            return;
+        }
+        let cancelled = false;
+        void open(record).then((result) => {
+            if (!cancelled) {
+                setOpened({ from: record, record: result });
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [record, protectedRecord, generation, open]);
+    if (!record || !protectedRecord) {
+        return { record, ready: true };
+    }
+    if (opened?.from === record) {
+        return { record: opened.record, ready: true };
+    }
+    const uid = uidOf(record);
+    return opened && uid !== undefined && uidOf(opened.from) === uid ? { record: opened.record, ready: true } : { record, ready: false };
+}

package/apps/www/_shell.tsx

@@ -47,6 +47,7 @@ export default function WwwShell({
     pluginNav,
     branding,
     appearance,
+    signOutHost,
 }: WwwShellProps) {
     const { route, pending } = useRouter();
     const [takeovers, setTakeovers] = useState(0);
@@ -74,6 +75,7 @@ export default function WwwShell({
                 pluginNav={pluginNav}
                 branding={branding}
                 appearance={appearance}
+                signOutHost={signOutHost}
             >
                 {children}
             </AppChrome>