app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

commit f5799cc957d3b205696b1c4c2de01419e18103ed
parent bd1348e67dd0618eb29f0f30f50d2379a342fdc7
Author: triesap <tyson@radroots.org>
Date:   Fri,  9 Oct 2026 15:21:25 +0000

web: render message requests and conversations as simple lists (HCP-102)

Diffstat:
Aweb/src/lib/components/ConversationRow.svelte | 53+++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/components/InboxStatus.svelte | 76++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
Aweb/src/lib/messaging/inbox-list.ts | 110+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/messaging/inbox-view.ts | 323+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
Aweb/tests/e2e/harness/inbox-list-panel.svelte | 7+++++++
Aweb/tests/e2e/harness/inbox-list.ts | 228+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/e2e/harness/inbox-view.ts | 6++++++
Aweb/tests/e2e/inbox-list.spec.ts | 452+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/e2e/inbox-view.spec.ts | 9++++++++-
Mweb/tests/provenance/output.test.mjs | 43+++++++++++++++++++++++++++++++++++++++----
Aweb/tests/unit/inbox-list.test.ts | 117+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/unit/route-inventory.test.ts | 5+++++
Mweb/tools/check-output.mjs | 21++++++++++++---------
13 files changed, 1429 insertions(+), 21 deletions(-)

diff --git a/web/src/lib/components/ConversationRow.svelte b/web/src/lib/components/ConversationRow.svelte @@ -0,0 +1,53 @@ +<script lang="ts"> + import Button from './primitives/Button.svelte'; + import { + inboxConversationRow, + type InboxView + } from '../messaging/inbox-view.ts'; + import type { InboxListRow } from '../messaging/inbox-list.ts'; + let { + controller, + row, + onopen + }: { + controller: InboxView; + row: InboxListRow; + onopen?: (peer: string) => void; + } = $props(); + // A detached row is only an invalidation/peer selection hint. Its body, unread + // and role are never rendered without the same current genuine controller. + const current = $derived( + row ? inboxConversationRow(controller, row.peer) : undefined + ); + const preview = $derived( + current + ? Array.from(current.latest.content).slice(0, 160).join('') + + (Array.from(current.latest.content).length > 160 ? '…' : '') + : '' + ); + const time = $derived( + current ? new Date(current.latest.createdAt * 1000) : undefined + ); +</script> + +{#if current} + <article class="stack" aria-label="Local conversation"> + <div class="cluster"> + <span class="key" + >Peer {current.peer.slice(0, 8)}…{current.peer.slice(-8)}</span + >{#if current.unread > 0}<span>New</span>{/if}<span class="text-small" + >{time && !Number.isNaN(time.getTime()) + ? time.toLocaleString() + : 'Time unavailable'}</span + > + </div> + <p>{current.latest.role === 'self_archive' ? 'You: ' : ''}{preview}</p> + <Button + label={'Open conversation with ' + current.peer} + disabled={!onopen} + onclick={() => { + if (current) onopen?.(current.peer); + }} + /> + </article> +{/if} diff --git a/web/src/lib/components/InboxStatus.svelte b/web/src/lib/components/InboxStatus.svelte @@ -1,5 +1,8 @@ <script lang="ts"> import { getContext, onMount } from 'svelte'; + import { goto } from '$app/navigation'; + import { internalHref } from '../navigation-url.ts'; + import ConversationRow from './ConversationRow.svelte'; import CapabilityGate from './CapabilityGate.svelte'; import InboxSetup from './InboxSetup.svelte'; import Button from './primitives/Button.svelte'; @@ -26,6 +29,11 @@ import { createInboxView, inboxViewSnapshot, + inboxListSnapshot, + inboxListRevision, + openInboxConversation, + loadOlderInboxView, + inboxViewOlderAvailable, inboxViewSetup, subscribeInboxView, unlockInboxView, @@ -42,11 +50,24 @@ publicContext = getContext<PublicRuntimeContext>(PUBLIC_RUNTIME_CONTEXT); let identity = $state(identityViewSnapshot(identityContext)), panel = $state(inboxViewSnapshot(undefined)), + list = $state(inboxListSnapshot(undefined)), + olderAvailable = $state(false), owned = $state.raw<InboxView | undefined>(); let runtime: PublicRuntime | undefined, off = () => {}; const setup = $derived(inboxViewSetup(owned)); onMount(() => { + let observedRevision = -2, + observedMode = ''; + function updateList() { + const revision = inboxListRevision(owned), + mode = panel.state + ':' + panel.count + ':' + (panel.reason ?? ''); + if (revision !== observedRevision || mode !== observedMode) { + list = inboxListSnapshot(owned); + observedRevision = revision; + observedMode = mode; + } + } let disposed = false; function acquire() { if (disposed) return; @@ -72,8 +93,13 @@ } } panel = inboxViewSnapshot(owned); + observedRevision = -2; + updateList(); + olderAvailable = inboxViewOlderAvailable(owned); off = subscribeInboxView(owned, (next) => { panel = next; + updateList(); + olderAvailable = inboxViewOlderAvailable(owned); }); } const identityOff = identityContext @@ -101,6 +127,19 @@ } }; }); + async function openConversation(peer: string) { + const original = owned; + if (!original) return; + const result = await openInboxConversation( + original, + peer, + 'reviewed_admitted_conversation_navigation' + ); + const href = internalHref(result); + if (owned !== original || inboxListSnapshot(original).status !== 'ready') + return; + if (href) void goto(href); + } const effectiveIdentity = $derived( panel.owner ? panel.identity : identity.identity ); @@ -213,8 +252,41 @@ }} /> {/if} - <h2>Message requests</h2> - <h2>Conversations</h2> + {#if owned && list.status === 'ready'} + {#if list.requests.length > 0}<section + class="stack" + aria-label="Message requests" + > + <h2>Message requests</h2> + {#each list.requests as row (row.peer)}<ConversationRow + controller={owned} + {row} + onopen={openConversation} + />{/each} + </section>{/if} + {#if list.conversations.length > 0}<section + class="stack" + aria-label="Conversations" + > + <h2>Conversations</h2> + {#each list.conversations as row (row.peer)}<ConversationRow + controller={owned} + {row} + onopen={openConversation} + />{/each} + </section>{/if} + <p class="text-small"> + New means locally unread in this browser. No remote read receipt or + background message awareness is implied. + </p> + {/if} + <Button + label="Load older messages" + disabled={!owned || panel.busy || !olderAvailable} + onclick={() => { + if (owned) void loadOlderInboxView(owned, 'reviewed_load_older'); + }} + /> <Button label="Lock messages" disabled={!owned} diff --git a/web/src/lib/messaging/inbox-list.ts b/web/src/lib/messaging/inbox-list.ts @@ -0,0 +1,110 @@ +import { canonicalPublicKey } from '../contracts/public-key.ts'; +import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts'; +import { LOCAL_PERSISTENCE_BUDGETS } from '../config/budgets.ts'; +import { localUnreadRumors } from './unread.ts'; +import type { ConversationData } from './admit-conversation.ts'; +export type InboxListRow = Readonly<{ + peer: string; + count: number; + unread: number; + latest: ConversationData; +}>; +export type InboxListSnapshot = Readonly<{ + status: 'ready' | 'locked' | 'unavailable'; + requests: readonly InboxListRow[]; + conversations: readonly InboxListRow[]; +}>; +const unavailable = (): InboxListSnapshot => ({ + status: 'unavailable', + requests: [], + conversations: [] +}); +function arrayValue(value: unknown): boolean { + return Array.isArray(value); +} +// Pure detached presentation. These values never authenticate a sender or grant +// storage, navigation, decryption, query or reply permission. +export function groupInboxMessages( + owner: unknown, + messages: readonly ConversationData[], + read: readonly string[] +): InboxListSnapshot { + if ( + !canonicalPublicKey(owner) || + !arrayValue(messages) || + !arrayValue(read) || + messages.length > LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes + ) + return unavailable(); + const rows = new Map<string, ConversationData>(), + wires = new Map<string, string>(); + for (const row of messages) { + if ( + !row || + row.owner !== owner || + !canonicalPublicKey(row.peer) || + row.peer === owner || + !['inbound', 'self_archive'].includes(row.role) || + row.sender !== (row.role === 'inbound' ? row.peer : owner) || + row.recipient !== (row.role === 'inbound' ? owner : row.peer) || + typeof row.rumorId !== 'string' || + !/^[0-9a-f]{64}$/.test(row.rumorId) || + !Number.isSafeInteger(row.createdAt) || + row.createdAt < 0 || + typeof row.content !== 'string' || + !boundedUtf8(row.content, 4096) || + (row.subject !== null && typeof row.subject !== 'string') || + (row.replyTo !== null && + (typeof row.replyTo !== 'string' || + !/^[0-9a-f]{64}$/.test(row.replyTo))) + ) + return unavailable(); + const wire = JSON.stringify([ + row.owner, + row.peer, + row.sender, + row.recipient, + row.role, + row.rumorId, + row.createdAt, + row.content, + row.subject, + row.replyTo + ]), + old = wires.get(row.rumorId); + if (old !== undefined && old !== wire) return unavailable(); + wires.set(row.rumorId, wire); + rows.set(row.rumorId, { ...row }); + } + const grouped = new Map<string, ConversationData[]>(); + for (const row of rows.values()) + grouped.set(row.peer, (grouped.get(row.peer) ?? []).concat(row)); + let requests = Array.from<InboxListRow>([]), + conversations = Array.from<InboxListRow>([]); + for (const [peer, group] of grouped) { + const ordered = group + .slice() + .sort( + (a, b) => + b.createdAt - a.createdAt || b.rumorId.localeCompare(a.rumorId) + ), + row = { + peer, + count: group.length, + unread: localUnreadRumors(group, owner as string, read).length, + latest: { ...ordered[0] } + }; + if (group.some((value) => value.role === 'self_archive')) + conversations = conversations.concat(row); + else requests = requests.concat(row); + } + const order = (a: InboxListRow, b: InboxListRow) => + b.latest.createdAt - a.latest.createdAt || + b.latest.rumorId.localeCompare(a.latest.rumorId) || + a.peer.localeCompare(b.peer); + return { + status: 'ready', + requests: requests.sort(order), + conversations: conversations.sort(order) + }; +} diff --git a/web/src/lib/messaging/inbox-view.ts b/web/src/lib/messaging/inbox-view.ts @@ -1,3 +1,32 @@ +import { canonicalPublicKey } from '../contracts/public-key.ts'; +import { + groupInboxMessages, + type InboxListSnapshot, + type InboxListRow +} from './inbox-list.ts'; +import { + captureMessageMetadata, + messageMetadataSnapshot, + type MessageMetadata +} from '../persistence/message-metadata.ts'; +import { + captureConversationDirectory, + rememberAdmittedConversation, + closeConversationDirectory, + type ConversationDirectory +} from './conversation-directory.ts'; +import { + conversationSnapshot, + type AdmittedConversation +} from './admit-conversation.ts'; +import { decryptionQueueConversations } from './decryption-queue.ts'; +import { + captureOlderInbox, + loadOlderInbox, + stopOlderInbox, + olderInboxSnapshot, + type OlderInbox +} from './history-pagination.ts'; import { identityMessagingOwnership, identitySessionSnapshot, @@ -33,6 +62,7 @@ import { captureUnlockedSession, closeUnlockedSession, readUnlockedMessages, + unlockedConversationCurrent, type UnlockedSession } from './unlocked-session.ts'; import { @@ -71,6 +101,12 @@ type Inputs = Readonly<{ identity: IdentitySession; setup: InboxSetupView }>; type Controller = { snapshot(): InboxViewSnapshot; setup(): InboxSetupView | undefined; + list(): InboxListSnapshot; + row(peer: unknown): InboxListRow | undefined; + revision(): number; + open(peer: unknown, review: unknown): Promise<string | undefined>; + older(review: unknown): Promise<boolean>; + olderAvailable(): boolean; subscribe(listener: (view: InboxViewSnapshot) => void): () => void; unlock(review: unknown): Promise<boolean>; check(review: unknown): Promise<boolean>; @@ -118,6 +154,16 @@ export function createInboxView(input: Inputs): InboxView | undefined { unlocked: UnlockedSession | undefined, queue: DecryptionQueue | undefined, sync: InboxSync | undefined; + let metadata: MessageMetadata | undefined, + directory: ConversationDirectory | undefined, + older: OlderInbox | undefined; + let list: InboxListSnapshot = groupInboxMessages('', [], []); + let listReason: string | null = null; + let listRevision = 0; + const rowProofs = new Map< + string, + Readonly<{ data: InboxListRow; room: AdmittedConversation }> + >(); let off = () => {}, privateOff = () => {}, setupOff = () => {}, @@ -142,6 +188,186 @@ export function createInboxView(input: Inputs): InboxView | undefined { current() ); } + function rowSnapshot(peer: unknown): InboxListRow | undefined { + if ( + typeof peer !== 'string' || + !privateCurrent() || + !unlocked || + !queue || + list.status !== 'ready' + ) + return; + const proof = rowProofs.get(peer); + if (!proof || !unlockedConversationCurrent(unlocked, proof.room)) return; + const actual = conversationSnapshot(proof.room); + if ( + !actual || + actual.owner !== capture.owner || + actual.peer !== peer || + actual.rumorId !== proof.data.latest.rumorId + ) + return; + return { ...proof.data, latest: { ...actual } }; + } + function listSnapshot(): InboxListSnapshot { + if (!privateCurrent() || !unlocked || !queue) + return { status: 'locked', requests: [], conversations: [] }; + if (list.status !== 'ready') + return { status: list.status, requests: [], conversations: [] }; + const requests = list.requests.map((row) => rowSnapshot(row.peer)), + conversations = list.conversations.map((row) => rowSnapshot(row.peer)); + if (requests.some((row) => !row) || conversations.some((row) => !row)) + return { status: 'unavailable', requests: [], conversations: [] }; + return { + status: 'ready', + requests: requests.filter((row) => row !== undefined), + conversations: conversations.filter((row) => row !== undefined) + }; + } + async function refreshList(generation = epoch) { + if (!privateCurrent() || !unlocked || !metadata) return false; + try { + const local = await messageMetadataSnapshot(metadata); + if (!current(generation) || !privateCurrent() || !unlocked) return false; + const cached = readUnlockedMessages(unlocked); + if ( + local.status !== 'ready' || + local.owner !== capture.owner || + cached.status !== 'ready' + ) { + list = { status: 'unavailable', requests: [], conversations: [] }; + rowProofs.clear(); + listRevision++; + listReason = 'storage_unavailable'; + return false; + } + list = groupInboxMessages( + capture.owner, + cached.messages, + local.readRumors + ); + rowProofs.clear(); + const rooms = queue && decryptionQueueConversations(queue), + byRumor = new Map<string, AdmittedConversation>(); + for (const room of rooms ?? []) { + const observed = conversationSnapshot(room); + if (observed) byRumor.set(observed.rumorId, room); + } + for (const row of list.requests.concat(list.conversations)) { + const room = byRumor.get(row.latest.rumorId); + if (room) rowProofs.set(row.peer, { data: row, room }); + } + listRevision++; + listReason = list.status === 'ready' ? null : 'unavailable'; + return list.status === 'ready'; + } catch { + if (current(generation) && privateCurrent()) { + list = { status: 'unavailable', requests: [], conversations: [] }; + rowProofs.clear(); + listRevision++; + listReason = 'storage_unavailable'; + } + return false; + } + } + function olderAvailable() { + if (busy || !privateCurrent() || !unlocked || !repository || !sync) + return false; + const transport = inboxSyncSnapshot(sync), + ownership = inboxSyncHistoryOwnership(sync), + own = inboxSetupViewOwnership(input.setup), + original = session && privateSessionOwnership(session); + if ( + !own?.current() || + !own.resolver || + !original?.current() || + !ownership?.current() || + transport?.backfill !== 'complete' || + transport.pending !== 0 + ) + return false; + return ( + messagingReadinessSnapshot( + input.identity, + session, + own.policy, + own.resolver, + undefined, + own.observeAccess + ).ownAccess === 'qualified_exercised' + ); + } + async function open(peer: unknown, review: unknown) { + if ( + review !== 'reviewed_admitted_conversation_navigation' || + busy || + !privateCurrent() || + !queue || + !directory || + !canonicalPublicKey(peer) + ) + return; + const room = decryptionQueueConversations(queue).find( + (value) => conversationSnapshot(value)?.peer === peer + ); + if (!room) return; + const generation = epoch; + busy = true; + notify(); + try { + const result = await rememberAdmittedConversation( + directory, + room, + review + ); + if (!current(generation) || !privateCurrent()) return; + if (result.status !== 'saved' && result.status !== 'existing') { + reason = 'unavailable'; + return; + } + await refreshList(generation); + if (!current(generation) || !privateCurrent()) return; + return '/messages/' + result.conversationId; + } catch { + if (current(generation)) reason = 'unavailable'; + return; + } finally { + if (current(generation)) { + busy = false; + notify(); + } + } + } + async function loadOlder(review: unknown) { + if ( + review !== 'reviewed_load_older' || + !olderAvailable() || + !sync || + !queue + ) + return false; + older ??= captureOlderInbox(sync, review); + if (!older) return false; + const generation = epoch; + busy = true; + notify(); + try { + const result = await loadOlderInbox(older, review); + if (!current(generation) || !privateCurrent() || !queue) return false; + await refreshDecryptionQueue(queue); + if (!current(generation) || !privateCurrent()) return false; + await refreshList(generation); + return current(generation) && privateCurrent() && result; + } catch { + if (current(generation)) reason = 'unavailable'; + return false; + } finally { + if (current(generation)) { + busy = false; + notify(); + } + } + } function snapshot(): InboxViewSnapshot { if (!current()) return { ...unavailable(), cleanupRequired: pendingCleanup.length > 0 }; @@ -167,6 +393,7 @@ export function createInboxView(input: Inputs): InboxView | undefined { }; const cached = readUnlockedMessages(unlocked), decrypt = decryptionQueueSnapshot(queue), + paging = older && olderInboxSnapshot(older), transport = sync && inboxSyncSnapshot(sync); const scope = inboxSetupViewOwnership(input.setup); const exercised = @@ -184,6 +411,8 @@ export function createInboxView(input: Inputs): InboxView | undefined { reason !== null || !exercised || cached.status !== 'ready' || + list.status === 'unavailable' || + !!paging?.reason || decrypt.state === 'paused' || transport?.state === 'needs_action' || transport?.state === 'stopped'; @@ -200,6 +429,8 @@ export function createInboxView(input: Inputs): InboxView | undefined { : 'ready', reason: reason ?? + listReason ?? + paging?.reason ?? decrypt.reason ?? transport?.reason ?? (!exercised ? 'access_unavailable' : null), @@ -228,9 +459,17 @@ export function createInboxView(input: Inputs): InboxView | undefined { originalSync = sync, originalUnlocked = unlocked, originalSession = session, - originalDatabase = database; + originalDatabase = database, + originalDirectory = directory, + originalOlder = older; const tasks = pendingCleanup.concat([ () => { + if (originalOlder) stopOlderInbox(originalOlder); + }, + () => { + if (originalDirectory) closeConversationDirectory(originalDirectory); + }, + () => { if (originalQueue) stopDecryptionQueue(originalQueue); }, () => { @@ -255,6 +494,13 @@ export function createInboxView(input: Inputs): InboxView | undefined { pendingCleanup = pendingCleanup.concat(cleanup); } if (pendingCleanup.length > 0) reason = 'cleanup_required'; + metadata = undefined; + directory = undefined; + older = undefined; + list = { status: 'locked', requests: [], conversations: [] }; + listReason = null; + rowProofs.clear(); + listRevision++; queue = undefined; sync = undefined; unlocked = undefined; @@ -346,7 +592,8 @@ export function createInboxView(input: Inputs): InboxView | undefined { try { const result = await runDecryptionBatch(queue, reviewed); if (!current(generation) || !privateCurrent()) return false; - return result; + await refreshList(generation); + return current(generation) && privateCurrent() && result; } finally { if (current(generation)) { busy = false; @@ -410,10 +657,27 @@ export function createInboxView(input: Inputs): InboxView | undefined { unlocked, 'reviewed_inbox_unlock' ); - if (!queue) { + if (!queue || !unlocked) { reason = 'unavailable'; return false; } + metadata = captureMessageMetadata( + database, + session, + unlocked, + 'reviewed_local_message_metadata' + ); + directory = + metadata && + captureConversationDirectory( + session, + metadata, + 'reviewed_conversation_directory' + ); + if (!metadata || !directory) { + reason = 'storage_unavailable'; + return false; + } privateOff = subscribePrivateSessionClose(session, () => { epoch++; releasePrivate(); @@ -428,7 +692,8 @@ export function createInboxView(input: Inputs): InboxView | undefined { if (!privateCurrent()) return false; const result = await runDecryptionBatch(queue, 'reviewed_decrypt_batch'); if (!current(generation) || !privateCurrent()) return false; - return result; + await refreshList(generation); + return current(generation) && privateCurrent() && result; } catch { if (current(generation)) reason = 'unavailable'; return false; @@ -455,6 +720,7 @@ export function createInboxView(input: Inputs): InboxView | undefined { notify(); return false; } + const generation = epoch; reason = null; if (sync) { if ( @@ -487,10 +753,17 @@ export function createInboxView(input: Inputs): InboxView | undefined { checkPending = true; notify(); await sample(); - return privateCurrent(); + if (current(generation) && privateCurrent()) await refreshList(generation); + return current(generation) && privateCurrent(); } views.set(token, { snapshot, + list: listSnapshot, + row: rowSnapshot, + revision: () => (privateCurrent() ? listRevision : -1), + open, + older: loadOlder, + olderAvailable, setup: () => (current() ? input.setup : undefined), subscribe(listener) { const key = Symbol(); @@ -585,3 +858,43 @@ export function stopInboxView(token: InboxView): void { export function closeInboxView(token: InboxView): boolean { return views.get(token)?.close() ?? true; } + +// Fresh genuine original cache observation. Returned rows are detached and +// never replace the original room/native authority used by explicit Open. +export function inboxListSnapshot( + token: InboxView | undefined +): InboxListSnapshot { + return ( + (token && views.get(token)?.list()) || { + status: 'unavailable', + requests: [], + conversations: [] + } + ); +} +export function openInboxConversation( + token: InboxView, + peer: unknown, + review: unknown +): Promise<string | undefined> { + return views.get(token)?.open(peer, review) ?? Promise.resolve(undefined); +} +export function loadOlderInboxView( + token: InboxView, + review: unknown +): Promise<boolean> { + return views.get(token)?.older(review) ?? Promise.resolve(false); +} +export function inboxViewOlderAvailable(token: InboxView | undefined): boolean { + return !!token && !!views.get(token)?.olderAvailable(); +} + +export function inboxConversationRow( + token: InboxView | undefined, + peer: unknown +): InboxListRow | undefined { + return token ? views.get(token)?.row(peer) : undefined; +} +export function inboxListRevision(token: InboxView | undefined): number { + return token ? (views.get(token)?.revision() ?? -1) : -1; +} diff --git a/web/tests/e2e/harness/inbox-list-panel.svelte b/web/tests/e2e/harness/inbox-list-panel.svelte @@ -0,0 +1,7 @@ +<script lang="ts"> + import InboxStatus from '../../../src/lib/components/InboxStatus.svelte'; + import type { InboxView } from '../../../src/lib/messaging/inbox-view.ts'; + let { controller }: { controller: InboxView } = $props(); +</script> + +<InboxStatus {controller} /> diff --git a/web/tests/e2e/harness/inbox-list.ts b/web/tests/e2e/harness/inbox-list.ts @@ -0,0 +1,228 @@ +import { mount, unmount } from 'svelte'; +import Panel from './inbox-list-panel.svelte'; +import { makeFixture as makeMetadataFixture } from './message-metadata.ts'; +import { + createInboxSetupView, + checkInboxSetupView, + closeInboxSetupView +} from '../../../src/lib/messaging/inbox-setup-view.ts'; +import { + createInboxView, + inboxViewSnapshot, + inboxListSnapshot, + unlockInboxView, + readNewInboxView, + checkInboxView, + loadOlderInboxView, + openInboxConversation, + stopInboxView, + closeInboxView +} from '../../../src/lib/messaging/inbox-view.ts'; +import { identityMessagingOwnership } from '../../../src/lib/runtime/identity-session.ts'; +import { + readRelayPolicy, + validateRelayPolicy +} from '../../../src/lib/config/relays.ts'; +import { + openBrowserDatabase, + closeBrowserDatabase, + browserDatabaseTransaction +} from '../../../src/lib/persistence/database.ts'; +import { + admitInboxEnvelope, + retainInboxEnvelope +} from '../../../src/lib/persistence/inbox-envelope-repository.ts'; +import { finalizeEvent } from 'applesauce-core/helpers'; +import { nip44 } from 'applesauce-core/helpers/encryption'; +let navigations = Array.from<string>([]); +// Harness-only alias for Kit navigation. Production retains actual Kit goto. +export function goto(href: string) { + navigations.push(href); + return Promise.resolve(); +} +export async function renderFixture( + kind: 'inbound' | 'self_archive' | 'hostile_text' = 'inbound', + qualified = false, + variant: 'single' | 'duplicate' | 'mixed' = 'single' +) { + const f = await makeMetadataFixture(kind); + const original = identityMessagingOwnership(f.identity); + if (!original) throw Error('no original identity'); + if (variant === 'duplicate') await f.anotherWrap(false); + if (variant === 'mixed') { + const record = (await f.row())!.record; + const envelope = admitInboxEnvelope( + record.self.wire, + f.owner, + 'wss://archive.example.org', + 102 + ); + const session = f.navigationInputs().privateSession; + if ( + !envelope || + (await retainInboxEnvelope(f.repository, session, envelope)).status !== + 'retained' + ) + throw Error('no actual self archive'); + } + async function native() { + const opened = await openBrowserDatabase(); + if (opened.state !== 'ready') throw Error('no actual DB'); + try { + const tx = browserDatabaseTransaction( + opened.owner, + ['received_envelopes', 'conversations'], + 'readonly' + ), + received = tx.objectStore('received_envelopes').getAll(), + pairs = tx.objectStore('conversations').getAll(); + return await new Promise<{ received: unknown[]; pairs: unknown[] }>( + (resolve, reject) => { + tx.addEventListener('complete', () => + resolve({ received: received.result, pairs: pairs.result }) + ); + tx.addEventListener('abort', () => reject(Error('scan aborted'))); + } + ); + } finally { + closeBrowserDatabase(opened.owner); + } + } + const initial = await native(), + raw = initial.received[0] as { wire: string }, + record = JSON.parse(raw.wire) as { outer: string }; + // Produce a relay-only valid old outer with the same authenticated signed seal. + // Both timestamps are set before signing. Nothing signed is edited afterward. + const outer = JSON.parse(record.outer) as { + pubkey: string; + content: string; + created_at: number; + }; + const ownerSecret = new Uint8Array(32).fill(83), + outerSecret = new Uint8Array(32).fill(86); + let olderWire: string; + try { + const decryptKey = nip44.v2.utils.getConversationKey( + ownerSecret, + outer.pubkey + ); + let seal: string; + try { + seal = nip44.v2.decrypt(outer.content, decryptKey); + } finally { + decryptKey.fill(0); + } + const encryptKey = nip44.v2.utils.getConversationKey(outerSecret, f.owner); + let content: string; + try { + content = nip44.v2.encrypt(seal, encryptKey); + } finally { + encryptKey.fill(0); + } + olderWire = JSON.stringify( + finalizeEvent( + { + kind: 1059, + created_at: outer.created_at - 120, + tags: [['p', f.owner]], + content + }, + outerSecret + ) + ); + } finally { + ownerSecret.fill(0); + outerSecret.fill(0); + } + const policy = validateRelayPolicy( + JSON.stringify({ + ...readRelayPolicy(f.context.policy), + messagingEnabled: true + }) + ); + if (!policy) throw Error('no policy'); + let access = true; + const setup = createInboxSetupView({ + identity: f.identity, + policy, + lookup: () => Promise.resolve(f.context.own), + observeAccess: qualified + ? (context) => ({ + ...context, + receive: 'qualified_exercised', + archive: 'qualified_exercised', + current: () => access && original.current() + }) + : undefined + }); + if (!setup) throw Error('no setup'); + const controller = createInboxView({ identity: f.identity, setup }); + if (!controller) throw Error('no original page'); + const target = document.createElement('div'); + document.body.append(target); + const mounted = mount(Panel, { target, props: { controller } }); + navigations = []; + const baseline = f.counts(); + return { + controller, + owner: f.owner, + peer: f.peer, + rumorId: f.rumorId, + olderWire, + native, + snapshot: () => inboxViewSnapshot(controller), + list: () => inboxListSnapshot(controller), + navigations: () => navigations.slice(), + checkSetup: () => checkInboxSetupView(setup), + unlock: () => unlockInboxView(controller, 'reviewed_messages_unlock'), + next: () => readNewInboxView(controller, 'reviewed_decrypt_batch'), + check: () => checkInboxView(controller, 'reviewed_foreground_inbox'), + older: (review: unknown = 'reviewed_load_older') => + loadOlderInboxView(controller, review), + open: ( + peer: unknown = f.peer, + review: unknown = 'reviewed_admitted_conversation_navigation' + ) => openInboxConversation(controller, peer, review), + delta: () => ({ + decrypts: f.counts().decrypts - baseline.decrypts, + signs: f.counts().signs - baseline.signs, + encrypts: f.counts().encrypts - baseline.encrypts + }), + copied: async () => ({ + list: inboxListSnapshot({ ...controller }), + open: await openInboxConversation( + { ...controller }, + f.peer, + 'reviewed_admitted_conversation_navigation' + ), + older: await loadOlderInboxView({ ...controller }, 'reviewed_load_older') + }), + async markRead() { + if ( + (await f.unlock()) !== 'authenticated' || + !f.admit(kind === 'self_archive' ? 'self_archive' : 'inbound') || + !f.captureCache() + ) + throw Error('no genuine explicit read proof'); + f.cache(); + if (!(await f.captureMetadata())) throw Error('no original metadata'); + return await f.display(); + }, + stop: () => stopInboxView(controller), + logout: () => f.disconnect(), + mode: f.mode, + settle: () => f.settle(), + pending: () => f.pending(), + revokeAccess: () => { + access = false; + }, + async close() { + f.settle(); + closeInboxView(controller); + closeInboxSetupView(setup); + await unmount(mounted); + f.close(); + target.remove(); + } + }; +} diff --git a/web/tests/e2e/harness/inbox-view.ts b/web/tests/e2e/harness/inbox-view.ts @@ -172,3 +172,9 @@ export async function renderSetupFixture( } }; } + +// This original standalone fixture does not exercise navigation. Any SSR or +// mounted regression action that attempts it must fail rather than succeed. +export function goto(): never { + throw new Error('HCP101 standalone harness must not navigate'); +} diff --git a/web/tests/e2e/inbox-list.spec.ts b/web/tests/e2e/inbox-list.spec.ts @@ -0,0 +1,452 @@ +import { test, expect } from '@playwright/test'; +import { build } from 'vite'; +import { svelte } from '@sveltejs/vite-plugin-svelte'; +import { fileURLToPath } from 'node:url'; +import { once } from 'node:events'; +import { WebSocketServer } from 'ws'; +import { createStaticHarness } from '../integration/harness/static.ts'; +import type * as Fixture from './harness/inbox-list.ts'; +declare global { + interface Window { + hcp102: typeof Fixture; + hcp102Fixture: Awaited<ReturnType<typeof Fixture.renderFixture>>; + hcp102Pending?: Promise<boolean>; + } +} +let server: Awaited<ReturnType<typeof createStaticHarness>>, + sockets: WebSocketServer, + endpoint: string, + bundle: string; +let requests: unknown[][] = [], + events: unknown[][] = [], + closes: unknown[][] = [], + olderEvent: unknown; +test.beforeAll(async () => { + server = await createStaticHarness(); + sockets = new WebSocketServer({ + host: '127.0.0.1', + port: 0, + maxPayload: 65536 + }); + await once(sockets, 'listening'); + const address = sockets.address(); + if (!address || typeof address === 'string') throw Error('no loopback'); + endpoint = 'ws://127.0.0.1:' + address.port; + sockets.on('connection', (socket) => + socket.on('message', (bytes) => { + const raw = Buffer.isBuffer(bytes) + ? bytes + : Array.isArray(bytes) + ? Buffer.concat(bytes) + : Buffer.from(bytes); + const frame = JSON.parse(raw.toString()) as unknown[]; + if (frame[0] === 'EVENT') events.push(frame); + if (frame[0] === 'CLOSE') closes.push(frame); + if (frame[0] === 'REQ') { + requests.push(frame); + const filter = frame[2] as Record<string, unknown>; + if (filter.limit !== 0) { + if (filter.until !== undefined && olderEvent) + socket.send(JSON.stringify(['EVENT', frame[1], olderEvent])); + socket.send(JSON.stringify(['EOSE', frame[1]])); + } + } + }) + ); + const result = await build({ + configFile: false, + logLevel: 'silent', + plugins: [svelte({ configFile: false })], + resolve: { + conditions: ['browser'], + alias: { + '$app/navigation': fileURLToPath( + new URL('./harness/inbox-list.ts', import.meta.url) + ) + } + }, + build: { + write: false, + minify: false, + lib: { + entry: fileURLToPath( + new URL('./harness/inbox-list.ts', import.meta.url) + ), + name: 'hcp102', + formats: ['iife'] + } + } + }); + const output = Array.isArray(result) ? result[0] : result; + if (!('output' in output)) throw Error('no bundle'); + const chunks = output.output.filter((row) => row.type === 'chunk'); + expect(chunks).toHaveLength(1); + bundle = chunks[0].code; +}); +test.afterAll(async () => { + for (const socket of sockets.clients) socket.terminate(); + await new Promise<void>((resolve) => sockets.close(() => resolve())); + await server.close(); +}); +test.beforeEach(async ({ page }) => { + requests = []; + events = []; + closes = []; + olderEvent = undefined; + await page.addInitScript( + ({ endpoint }) => { + const Native = window.WebSocket; + window.WebSocket = class extends Native { + constructor(url: string | URL, protocols?: string | string[]) { + if ( + ![ + 'wss://archive.example.org', + 'wss://discovery.example.org' + ].includes(new URL(String(url)).origin) + ) + throw Error('unapproved destination'); + super(endpoint, protocols); + } + }; + }, + { endpoint } + ); + await page.goto(server.url + '/search'); + await page.addScriptTag({ content: bundle }); +}); +test.afterEach(async ({ page }) => { + if (!page.isClosed()) + await page.evaluate(async () => { + window.hcp102Fixture?.settle(); + await window.hcp102Pending; + await window.hcp102Fixture?.close(); + }); +}); +async function ready( + page: import('@playwright/test').Page, + kind: 'inbound' | 'self_archive' | 'hostile_text' = 'inbound', + qualified = false, + variant: 'single' | 'duplicate' | 'mixed' = 'single' +) { + await page.evaluate( + async ({ kind, qualified, variant }) => { + window.hcp102Fixture = await window.hcp102.renderFixture( + kind, + qualified, + variant + ); + }, + { kind, qualified, variant } + ); + await page.getByRole('button', { name: 'Check current preference' }).click(); +} +async function unlock(page: import('@playwright/test').Page) { + await page + .getByRole('button', { name: 'Unlock messages', exact: true }) + .click(); + await expect + .poll(() => page.evaluate(() => window.hcp102Fixture.list().status)) + .toBe('ready'); +} +test('production guest never renders request previews or background notification fiction', async ({ + page +}) => { + await page.goto(server.url + '/messages'); + await expect( + page.getByRole('heading', { name: 'Connect or unlock' }) + ).toBeVisible(); + await expect( + page.getByRole('heading', { name: 'Message requests' }) + ).toHaveCount(0); + await expect(page.getByText('Actual encrypted room fixture')).toHaveCount(0); + expect(requests).toEqual([]); + expect(events).toEqual([]); +}); +test('actual stored incoming ciphertext remains unpreviewed while original page is locked', async ({ + page +}) => { + await ready(page); + await expect( + page.getByRole('button', { name: 'Unlock messages', exact: true }) + ).toBeVisible(); + await expect(page.getByText('Actual encrypted room fixture')).toHaveCount(0); + await expect( + page.getByRole('heading', { name: 'Message requests' }) + ).toHaveCount(0); + expect(await page.evaluate(() => window.hcp102Fixture.delta())).toMatchObject( + { decrypts: 0, signs: 0, encrypts: 0 } + ); + expect(requests).toEqual([]); +}); +test('genuine authenticated incoming peer is one locally New request after explicit SDK decrypt', async ({ + page +}) => { + await ready(page); + await unlock(page); + await expect( + page.getByRole('heading', { name: 'Message requests', exact: true }) + ).toBeVisible(); + await expect( + page.getByRole('heading', { name: 'Conversations', exact: true }) + ).toHaveCount(0); + await expect( + page.getByText('Actual encrypted room fixture', { exact: true }) + ).toBeVisible(); + await expect(page.getByText('New', { exact: true })).toHaveCount(1); + const view = await page.evaluate(() => window.hcp102Fixture.list()); + expect(view.requests).toHaveLength(1); + expect(view.requests[0].peer).toBe( + await page.evaluate(() => window.hcp102Fixture.peer) + ); + expect(await page.evaluate(() => window.hcp102Fixture.delta())).toMatchObject( + { decrypts: 2, signs: 0, encrypts: 0 } + ); + expect(requests).toEqual([]); +}); +test('genuine self archive is a local conversation without outgoing New or empty request clutter', async ({ + page +}) => { + await ready(page, 'self_archive'); + await unlock(page); + await expect( + page.getByRole('heading', { name: 'Conversations', exact: true }) + ).toBeVisible(); + await expect( + page.getByRole('heading', { name: 'Message requests', exact: true }) + ).toHaveCount(0); + await expect(page.getByText('New', { exact: true })).toHaveCount(0); + await expect( + page.getByText('You: Actual encrypted room fixture', { exact: true }) + ).toBeVisible(); + expect( + (await page.evaluate(() => window.hcp102Fixture.list())).conversations + ).toHaveLength(1); + expect(events).toEqual([]); +}); +test('one authenticated pair with incoming and self archive stays one local conversation', async ({ + page +}) => { + await ready(page, 'inbound', false, 'mixed'); + await unlock(page); + const view = await page.evaluate(() => window.hcp102Fixture.list()); + expect(view.requests).toEqual([]); + expect(view.conversations).toHaveLength(1); + expect(view.conversations[0]).toMatchObject({ count: 2, unread: 1 }); + await expect(page.getByText('New', { exact: true })).toHaveCount(1); + expect(events).toEqual([]); + expect(requests).toEqual([]); +}); +test('two actual different outer wraps of one rumor produce one request and one local New', async ({ + page +}) => { + await ready(page, 'inbound', false, 'duplicate'); + await unlock(page); + const view = await page.evaluate(() => window.hcp102Fixture.list()); + expect(view.requests).toHaveLength(1); + expect(view.requests[0]).toMatchObject({ count: 1, unread: 1 }); + expect( + (await page.evaluate(() => window.hcp102Fixture.native())).received + ).toHaveLength(2); + expect(await page.evaluate(() => window.hcp102Fixture.delta())).toMatchObject( + { decrypts: 4 } + ); + await expect(page.getByText('New', { exact: true })).toHaveCount(1); +}); +test('actual original local read flag suppresses New without changing request acceptance or notifying a peer', async ({ + page +}) => { + await ready(page); + await unlock(page); + await expect(page.getByText('New', { exact: true })).toHaveCount(1); + const saved = await page.evaluate(() => window.hcp102Fixture.markRead()); + expect(saved?.status).toBe('saved'); + await page.evaluate(() => window.hcp102Fixture.next()); + await expect(page.getByText('New', { exact: true })).toHaveCount(0); + expect( + (await page.evaluate(() => window.hcp102Fixture.list())).requests + ).toHaveLength(1); + expect(events).toEqual([]); + expect(requests).toEqual([]); +}); +test('explicit original row mapping returns opaque local UUID and does not mark read or persist plaintext', async ({ + page +}) => { + await ready(page); + await unlock(page); + const before = await page.evaluate(() => window.hcp102Fixture.native()); + expect(before.pairs).toEqual([]); + await page.getByRole('button', { name: /Open conversation/ }).click(); + await expect + .poll(() => page.evaluate(() => window.hcp102Fixture.navigations().length)) + .toBe(1); + const href = await page.evaluate(() => window.hcp102Fixture.navigations()[0]); + expect(href).toMatch( + /^\/messages\/[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/ + ); + const after = await page.evaluate(() => window.hcp102Fixture.native()); + expect(after.pairs).toHaveLength(1); + expect(after.received).toEqual(before.received); + expect(JSON.stringify(after)).not.toContain('Actual encrypted room fixture'); + await expect(page.getByText('New', { exact: true })).toHaveCount(1); + expect(events).toEqual([]); + expect(requests).toEqual([]); +}); +test('copied page and scalar peer arguments cannot import rows or native mapping/history effects', async ({ + page +}) => { + await ready(page); + await unlock(page); + const before = await page.evaluate(() => window.hcp102Fixture.native()), + delta = await page.evaluate(() => window.hcp102Fixture.delta()), + copied = await page.evaluate(() => window.hcp102Fixture.copied()); + expect(copied).toMatchObject({ + list: { status: 'unavailable', requests: [], conversations: [] }, + older: false + }); + expect(copied.open).toBeUndefined(); + expect(await page.evaluate(() => window.hcp102Fixture.native())).toEqual( + before + ); + expect(await page.evaluate(() => window.hcp102Fixture.delta())).toEqual( + delta + ); + expect(requests).toEqual([]); + expect(events).toEqual([]); +}); +test('Stop removes decrypted rows and denies stale original row action before any native change', async ({ + page +}) => { + await ready(page); + await unlock(page); + const before = await page.evaluate(() => window.hcp102Fixture.native()); + await page + .getByRole('button', { name: 'Lock messages', exact: true }) + .click(); + await expect(page.getByText('Actual encrypted room fixture')).toHaveCount(0); + await expect(page.getByText('New', { exact: true })).toHaveCount(0); + expect( + await page.evaluate(() => window.hcp102Fixture.open()) + ).toBeUndefined(); + expect(await page.evaluate(() => window.hcp102Fixture.native())).toEqual( + before + ); + expect(requests).toEqual([]); + expect(events).toEqual([]); +}); +test('logout during actual held decrypt cannot render old-generation previews after SDK settlement', async ({ + page +}) => { + await ready(page); + await page.evaluate(() => { + window.hcp102Fixture.mode('hold_decrypt'); + window.hcp102Pending = window.hcp102Fixture.unlock(); + }); + await expect + .poll(() => page.evaluate(() => window.hcp102Fixture.pending())) + .toBe(true); + await page.evaluate(() => window.hcp102Fixture.logout()); + await expect(page.getByText('Actual encrypted room fixture')).toHaveCount(0); + await page.evaluate(async () => { + window.hcp102Fixture.settle(); + await window.hcp102Pending; + }); + await expect(page.getByText('Actual encrypted room fixture')).toHaveCount(0); + expect( + (await page.evaluate(() => window.hcp102Fixture.list())).requests + ).toEqual([]); + expect(events).toEqual([]); + expect(requests).toEqual([]); +}); +test('partial unlocked local list has visible limitations and never remote Seen or a live badge', async ({ + page +}) => { + await ready(page, 'hostile_text'); + await unlock(page); + await expect( + page.getByText( + 'Inbox access has not been qualified and exercised. Unlocked local copies do not prove a successful relay check.', + { exact: true } + ) + ).toBeVisible(); + await expect(page.getByText(/https:\/\/untrusted.example.org/)).toBeVisible(); + await expect(page.locator('a[href*="untrusted.example.org"]')).toHaveCount(0); + await expect( + page.getByText(/^(Live|Seen|Read by|Order accepted)$/) + ).toHaveCount(0); + await expect( + page.getByRole('heading', { name: 'Conversations', exact: true }) + ).toHaveCount(0); + expect(events).toEqual([]); + expect(requests).toEqual([]); +}); +test('unqualified original Load older stays unavailable without private REQ or SDK work', async ({ + page +}) => { + await ready(page); + await unlock(page); + const before = await page.evaluate(() => window.hcp102Fixture.delta()); + expect(await page.evaluate(() => window.hcp102Fixture.older())).toBe(false); + expect(await page.evaluate(() => window.hcp102Fixture.delta())).toEqual( + before + ); + expect(events).toEqual([]); + expect(requests).toEqual([]); +}); +test('qualified explicit Load older uses original outer cursor and retains a real relay-only cipher without automatic decrypt', async ({ + page +}) => { + await ready(page, 'inbound', true); + await unlock(page); + await page + .getByRole('button', { name: 'Check for messages', exact: true }) + .click(); + await expect.poll(() => requests.length).toBe(3); + await expect + .poll(() => + page.evaluate(() => window.hcp102Fixture.snapshot().lastCheckedAt) + ) + .not.toBeNull(); + const before = await page.evaluate(() => window.hcp102Fixture.native()), + delta = await page.evaluate(() => window.hcp102Fixture.delta()); + olderEvent = JSON.parse( + await page.evaluate(() => window.hcp102Fixture.olderWire) + ); + await page + .getByRole('button', { name: 'Load older messages', exact: true }) + .click(); + await expect.poll(() => requests.length).toBe(4); + const filter = requests[3][2] as Record<string, unknown>; + expect(filter.limit).toBe(200); + expect(filter.until).toBe(1699999800); + await expect + .poll(() => + page.evaluate( + async () => (await window.hcp102Fixture.native()).received.length + ) + ) + .toBe(before.received.length + 1); + expect(await page.evaluate(() => window.hcp102Fixture.delta())).toEqual( + delta + ); + await expect( + page.getByRole('button', { name: 'Read new messages (1)', exact: true }) + ).toBeVisible(); + expect( + (await page.evaluate(() => window.hcp102Fixture.list())).requests + ).toHaveLength(1); + await page + .getByRole('button', { name: 'Read new messages (1)', exact: true }) + .click(); + await expect + .poll(() => page.evaluate(() => window.hcp102Fixture.delta().decrypts)) + .toBe(delta.decrypts + 2); + expect( + (await page.evaluate(() => window.hcp102Fixture.list())).requests[0].count + ).toBe(1); + expect(events).toEqual([]); + expect( + requests.filter( + (frame) => (frame[2] as Record<string, unknown>).limit === 0 + ) + ).toHaveLength(1); +}); diff --git a/web/tests/e2e/inbox-view.spec.ts b/web/tests/e2e/inbox-view.spec.ts @@ -54,7 +54,14 @@ test.beforeAll(async () => { configFile: false, logLevel: 'silent', plugins: [svelte({ configFile: false })], - resolve: { conditions: ['browser'] }, + resolve: { + conditions: ['browser'], + alias: { + '$app/navigation': fileURLToPath( + new URL('./harness/inbox-view.ts', import.meta.url) + ) + } + }, build: { write: false, minify: false, diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs @@ -345,7 +345,9 @@ import { auditOutput } from '../../tools/check-output.mjs'; 'src/lib/components/InboxStatus.svelte', 'src/lib/messaging/inbox-view.ts', 'src/lib/messaging/inbox-sync.ts', - 'src/lib/messaging/decryption-queue.ts' + 'src/lib/messaging/decryption-queue.ts', + 'src/lib/components/ConversationRow.svelte', + 'src/lib/messaging/inbox-list.ts' ]) await check( 'linked inbox presentation requires exact owned source ' + @@ -365,7 +367,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; } ); for (const mutation of [ - 'missing-unlocked', + 'missing-private-cache-directory', 'extra-private-edge', 'missing-private-edge', 'private-dynamic', @@ -387,8 +389,9 @@ import { auditOutput } from '../../tools/check-output.mjs'; assert.ok(row); return row; }; - const [key, row] = find('unlocked-session'); - if (mutation === 'missing-unlocked') delete manifest[key]; + const [key, row] = find('conversation-directory'); + if (mutation === 'missing-private-cache-directory') + delete manifest[key]; if (mutation === 'extra-private-edge') row.imports = row.imports.concat(find('references')[0]); if (mutation === 'missing-private-edge') @@ -404,6 +407,38 @@ import { auditOutput } from '../../tools/check-output.mjs'; } ); + for (const mutation of [ + 'directory-missing-context', + 'directory-entry-role', + 'directory-duplicate-role' + ]) + await check( + 'actual inbox list compiler rejects ' + mutation, + async (t) => { + const f = await fixture(t), + file = path.join( + f.web, + '.svelte-kit/output/client/.vite/manifest.json' + ), + manifest = JSON.parse(await readFile(file, 'utf8')); + const entry = Object.entries(manifest).find( + ([, row]) => row.name === 'conversation-directory' + ); + assert.ok(entry); + const [, row] = entry; + if (mutation === 'directory-missing-context') + row.imports = row.imports.filter( + (/** @type {string} */ value) => + manifest[value].name !== 'AccountGate' + ); + if (mutation === 'directory-entry-role') row.isEntry = true; + if (mutation === 'directory-duplicate-role') + manifest['_forged_directory.js'] = { ...row }; + await writeFile(file, JSON.stringify(manifest)); + await assert.rejects(f.audit, /compiler|duplicate|inventory/); + } + ); + for (const name of [ 'components/InboxSetup.svelte', 'messaging/inbox-setup-view.ts', diff --git a/web/tests/unit/inbox-list.test.ts b/web/tests/unit/inbox-list.test.ts @@ -0,0 +1,117 @@ +import { test, expect } from 'vitest'; +import { getPublicKey } from 'applesauce-core/helpers'; +import { groupInboxMessages } from '../../src/lib/messaging/inbox-list.ts'; +import { + inboxListSnapshot, + openInboxConversation, + loadOlderInboxView, + type InboxView +} from '../../src/lib/messaging/inbox-view.ts'; +import type { ConversationData } from '../../src/lib/messaging/admit-conversation.ts'; +const owner = getPublicKey(new Uint8Array(32).fill(83)), + peer = getPublicKey(new Uint8Array(32).fill(84)), + other = getPublicKey(new Uint8Array(32).fill(85)); +const message = ( + id = '1'.repeat(64), + role: 'inbound' | 'self_archive' = 'inbound', + time = 1700000000, + content = 'Plain private fixture' +): ConversationData => ({ + owner, + peer, + sender: role === 'inbound' ? peer : owner, + recipient: role === 'inbound' ? owner : peer, + role, + rumorId: id, + createdAt: time, + content, + subject: null, + replyTo: null +}); +test('authenticated incoming projection groups a new peer under local requests', () => { + const view = groupInboxMessages(owner, [message()], []); + expect(view.status).toBe('ready'); + expect(view.requests).toHaveLength(1); + expect(view.conversations).toEqual([]); + expect(view.requests[0]).toMatchObject({ peer, count: 1, unread: 1 }); +}); +test('actual self-archive history makes one known pair without a required acceptance task', () => { + const view = groupInboxMessages( + owner, + [message(), message('2'.repeat(64), 'self_archive', 1700000001)], + [] + ); + expect(view.requests).toEqual([]); + expect(view.conversations).toHaveLength(1); + expect(view.conversations[0]).toMatchObject({ peer, count: 2, unread: 1 }); + expect(view.conversations[0].latest.role).toBe('self_archive'); +}); +test('repeated wraps of the same verified rumor do not duplicate local New or rows', () => { + const view = groupInboxMessages(owner, [message(), message()], []); + expect(view.requests).toHaveLength(1); + expect(view.requests[0]).toMatchObject({ count: 1, unread: 1 }); +}); +test('read state is by verified rumor rather than signed timestamp or outgoing archive', () => { + const view = groupInboxMessages( + owner, + [ + message('1'.repeat(64), 'inbound', 1), + message('2'.repeat(64), 'self_archive', 1700000002) + ], + ['1'.repeat(64)] + ); + expect(view.conversations[0].unread).toBe(0); + expect( + groupInboxMessages(owner, [message('3'.repeat(64), 'inbound', 1)], []) + .requests[0].unread + ).toBe(1); +}); +test('latest sender-time-text selection is deterministic and does not parse a body link', () => { + const body = '<script>private</script> https://untrusted.example.org'; + const input = [ + message('2'.repeat(64), 'inbound', 1700000000, body), + message('1'.repeat(64)) + ]; + const a = groupInboxMessages(owner, input, []), + b = groupInboxMessages(owner, input.slice().reverse(), []); + expect(a).toEqual(b); + expect(a.requests[0].latest.content).toBe(body); + expect(a.requests[0].latest.rumorId).toBe('2'.repeat(64)); +}); +test('invalid or foreign detached rows cannot enter an owner projection', () => { + for (const row of [ + { ...message(), owner: other }, + { ...message(), peer: 'invalid' }, + { ...message(), createdAt: NaN }, + { ...message(), role: 'group' } + ]) + expect(groupInboxMessages(owner, [row as ConversationData], [])).toEqual({ + status: 'unavailable', + requests: [], + conversations: [] + }); +}); +test('conflicting bytes of one rumor fail closed instead of substituting a preview', () => + expect( + groupInboxMessages( + owner, + [message(), message('1'.repeat(64), 'inbound', 1700000000, 'different')], + [] + ) + ).toEqual({ status: 'unavailable', requests: [], conversations: [] })); +test('SSR/copied scalar page tokens cannot inspect rows, map peers or request older history', async () => { + const fake = { owner, unlocked: true, ready: true } as unknown as InboxView; + expect(inboxListSnapshot(fake)).toEqual({ + status: 'unavailable', + requests: [], + conversations: [] + }); + expect( + await openInboxConversation( + fake, + peer, + 'reviewed_admitted_conversation_navigation' + ) + ).toBeUndefined(); + expect(await loadOlderInboxView(fake, 'reviewed_load_older')).toBe(false); +}); diff --git a/web/tests/unit/route-inventory.test.ts b/web/tests/unit/route-inventory.test.ts @@ -26,6 +26,11 @@ const errorState = vi.hoisted(() => ({ params: { naddr: 'invalid-reference' } })); vi.mock('$app/state', () => ({ page: errorState })); +vi.mock('$app/navigation', () => ({ + goto: () => { + throw new Error('SSR must not navigate'); + } +})); const routeRoot = fileURLToPath(new URL('../../src/routes/', import.meta.url)); const expectedPages = [ diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs @@ -509,15 +509,19 @@ async function inboxPresentationAdmission(web) { 'src/routes/messages/+page.svelte': '8279a92770f38858e197e790839bc98b4d7889214ebecdf47e542d632afbc84f', 'src/lib/components/InboxStatus.svelte': - '605b92b9f8bb45ffb01ea4682869a37ec5b673a20a0deb7d9385ab659673f27f', + '519d13dad65d3d57db57329ee693cd6a2ea3e14bb1b51f334d8d58c3b677bf92', 'src/lib/messaging/inbox-view.ts': - '008feb690302c8d9bf563581bd7eb071e619da7da1e56a12108d6560888e3c2c', + '9fb55cd5a227d4a23f56a5ff6d30902cdf7c8bfb16cb313e36f55d78cce9a7ec', 'src/lib/messaging/inbox-sync.ts': '84f9b3bb165a81878bb281c51d245aff7eb06a0fa55b857a49b13d0cb1cff8ae', 'src/lib/messaging/inbox-setup-view.ts': '7559ec04394624a8275280027c031b90d0a62b78f94aec3933df6f3b50077450', 'src/lib/messaging/decryption-queue.ts': - '07661a883ee360e9fd7bd411893d637fd6b4b70aecb20101b826fe41b7ca4810' + '07661a883ee360e9fd7bd411893d637fd6b4b70aecb20101b826fe41b7ca4810', + 'src/lib/components/ConversationRow.svelte': + 'c5d0926ac9cdda18a6befe365227dfe62405f71598f59964ff36af9a0e85d743', + 'src/lib/messaging/inbox-list.ts': + '9cc82877bfa8dbb2a7fa41bceb842793349416271f19569f49fdd5cfc1de07e5' }; for (const [name, pin] of Object.entries(producers)) { const bytes = await readOwned(web, name); @@ -685,7 +689,7 @@ export async function auditOutput(webDirectory) { if (hasProductPresentation) names.add('publishers'); if (hasInboxSetup) names.add('private-handles'); if (hasInboxPresentation) - for (const name of ['unlocked-session', 'read']) names.add(name); + for (const name of ['conversation-directory', 'read']) names.add(name); const admitted = new Map([['build-info.json', expectedMetadata]]); const seen = new Set(); for (const [key, record] of Object.entries(manifest)) { @@ -1000,7 +1004,7 @@ export async function auditOutput(webDirectory) { /** @type {[string,string[]][]} */ const dependencies = [ [ - 'unlocked-session', + 'conversation-directory', [ 'public-key', 'private-handles', @@ -1018,9 +1022,10 @@ export async function auditOutput(webDirectory) { 'references', 'client', 'Button', + 'navigation', 'view-context', 'AccountGate', - 'unlocked-session', + 'conversation-directory', 'read' ] ], @@ -1028,14 +1033,12 @@ export async function auditOutput(webDirectory) { 'nodes/5', [ 'public-key', - 'public-runtime', 'client', - 'Button', 'client.svelte', 'state', 'view-context', 'AccountGate', - 'unlocked-session' + 'conversation-directory' ] ] ];