app

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

commit 0de570c68567f16e175ca85ec416ed70216e0c67
parent e150d061ae96fd78cfaa119929d3b6ce444c689a
Author: triesap <tyson@radroots.org>
Date:   Fri,  9 Oct 2026 18:05:08 +0000

web: implement the memory-only reply composer (HCP-104)

- Capture replies from the original current private pair and direct parent
- Keep unsent text in memory with reviewed navigation and unload warnings
- Use original self-first durable preparation and honest paired publication
- Verify production expiry retry and retain exact source acceptance evidence

Diffstat:
Mweb/src/lib/components/ConversationThread.svelte | 33+++++++++++++++++++++++++++++++++
Aweb/src/lib/components/MessageComposer.svelte | 161+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/components/MessageItem.svelte | 18+++++++++++++++---
Mweb/src/lib/messaging/inbox-view.ts | 125+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
Aweb/src/lib/messaging/reply-controller.ts | 440+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/messaging/rumor-plan.ts | 84++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-----
Mweb/tests/e2e/harness/conversation-thread.ts | 32++++++++++++++++++++++++++++++--
Aweb/tests/e2e/harness/reply-composer-panel.svelte | 9+++++++++
Aweb/tests/e2e/harness/reply-composer.ts | 304+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/reply-composer.spec.ts | 635+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/provenance/output.test.mjs | 22++++++++++++++++++++--
Aweb/tests/unit/reply-controller.test.ts | 77+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tools/check-output.mjs | 16++++++++++++----
13 files changed, 1938 insertions(+), 18 deletions(-)

diff --git a/web/src/lib/components/ConversationThread.svelte b/web/src/lib/components/ConversationThread.svelte @@ -3,6 +3,15 @@ import InboxStatus from './InboxStatus.svelte'; import Button from './primitives/Button.svelte'; import MessageItem from './MessageItem.svelte'; + import MessageComposer from './MessageComposer.svelte'; + import { + createReplyController, + createRuntimeReplyController, + selectReplyParent, + replySnapshot, + closeReplyController, + type ReplyController + } from '../messaging/reply-controller.ts'; import { IDENTITY_VIEW_CONTEXT, identityViewSession, @@ -37,6 +46,7 @@ const identity = getContext<IdentityViewContext>(IDENTITY_VIEW_CONTEXT), publicContext = getContext<PublicRuntimeContext>(PUBLIC_RUNTIME_CONTEXT); let owned = $state.raw<InboxView | undefined>(), + reply = $state.raw<ReplyController | undefined>(), model = $state(inboxThreadSnapshot(undefined, '')), announcement = $state(''), readProblem = $state(false), @@ -48,6 +58,20 @@ previous = Array.from<string>([]), attempted = Array.from<string>([]), disposed = false; + function captureReply(parent: string) { + if (!owned) return; + return runtime + ? createRuntimeReplyController(owned, conversationId, parent, runtime) + : createReplyController(owned, conversationId, parent); + } + function replyTo(parent: string) { + if (reply && replySnapshot(reply)?.dirty) { + selectReplyParent(reply, parent, 'reviewed_reply_parent'); + return; + } + if (reply) closeReplyController(reply); + reply = captureReply(parent); + } onMount(() => { let observedRevision = -2, observedMode = ''; @@ -74,6 +98,8 @@ observedMode = mode; const next = inboxThreadSnapshot(owned, conversationId); if (next.status !== 'ready') { + if (reply) closeReplyController(reply); + reply = undefined; model = next; announcement = ''; readProblem = false; @@ -90,6 +116,7 @@ if (ids.length > 0) initialized = true; previous = ids; model = next; + if (!reply && ids.length) reply = captureReply(ids[ids.length - 1]); }); } const identityOff = identity @@ -109,6 +136,7 @@ disposed = true; identityOff(); off(); + if (reply) closeReplyController(reply); if (owned && !controller) { const setup = inboxViewSetup(owned); closeInboxView(owned); @@ -167,7 +195,12 @@ controller={owned} {conversationId} {message} + onreply={replyTo} />{/each} + {#if reply}{#key reply}<MessageComposer + controller={reply} + focusScope="conversation" + />{/key}{/if} {:else}<p> This conversation is unavailable until it is unlocked in the matching browser and account. diff --git a/web/src/lib/components/MessageComposer.svelte b/web/src/lib/components/MessageComposer.svelte @@ -0,0 +1,161 @@ +<script lang="ts"> + /* global document, setInterval, clearInterval */ + import { onMount, tick } from 'svelte'; + import { beforeNavigate, goto } from '$app/navigation'; + import { internalHref } from '../navigation-url.ts'; + import { + replySnapshot, + replyText, + updateReplyText, + sendReply, + requestReplyNavigation, + keepReplyEditing, + discardReplyNavigation, + replyBeforeUnload, + closeReplyController, + type ReplyController + } from '../messaging/reply-controller.ts'; + let { + controller, + focusScope = 'enquiry' + }: { controller: ReplyController; focusScope?: 'conversation' | 'enquiry' } = + $props(); + let model = $state<ReturnType<typeof replySnapshot>>(), + text = $state(''); + let destination: string | undefined, + disposed = false; + const fieldId = $derived( + focusScope === 'conversation' ? 'conversation-reply' : 'enquiry-reply' + ); + function focusEditor() { + if (disposed) return; + if (focusScope === 'conversation') + document.getElementById('conversation-reply')?.focus(); + else document.getElementById('enquiry-reply')?.focus(); + } + function focusKeep() { + if (disposed) return; + if (focusScope === 'conversation') + document.getElementById('conversation-keep-reply')?.focus(); + else document.getElementById('enquiry-keep-reply')?.focus(); + } + function refresh() { + if (disposed) return; + model = replySnapshot(controller); + text = replyText(controller) ?? ''; + } + beforeNavigate((event) => { + if ( + disposed || + requestReplyNavigation(controller) !== 'confirmation_required' + ) + return; + event.cancel(); + const url = event.to?.url; + destination = + url && !event.willUnload + ? internalHref(url.pathname + url.search + url.hash) + : undefined; + refresh(); + void tick().then(focusKeep); + }); + onMount(() => { + refresh(); + const timer = setInterval(refresh, 200); + return () => { + disposed = true; + clearInterval(timer); + closeReplyController(controller); + text = ''; + model = undefined; + destination = undefined; + }; + }); + async function send() { + const work = sendReply(controller, 'reviewed_reply_send'); + refresh(); + await work; + refresh(); + } + function warnUnload(event: BeforeUnloadEvent) { + replyBeforeUnload(controller, event); + } +</script> + +<svelte:window onbeforeunload={warnUnload} /> + +{#if model} + <div class="stack"> + <label for={fieldId}>Reply</label> + <textarea + id={fieldId} + value={text} + disabled={model.busy || model.state === 'completed'} + aria-describedby={fieldId + '-save'} + oninput={(event) => { + updateReplyText( + controller, + event.currentTarget.value, + 'reviewed_private_text' + ); + refresh(); + }}></textarea> + <p id={fieldId + '-save'}> + {model.saveCopy} Unsent text is lost when this page closes. + </p> + <p>{model.pairCopy}</p> + <p> + Replying moves this conversation to your inbox in this view. It does not + accept an order. + </p> + <p>Messages do not reserve products or record payment.</p> + <button + type="button" + class="button button--primary" + disabled={model.busy || model.state === 'completed' || !text.trim()} + onclick={() => { + void send(); + }}>Send reply</button + > + <p role="status" aria-live="polite">{model.copy}</p> + {#if model.navigation === 'confirmation_required'} + <div class="notice stack" role="group" aria-label="Unsaved private reply"> + <p> + Discard unsaved private text? Keep editing to preserve it. An + outstanding extension call remains pending until it settles. + </p> + <div class="cluster"> + <button + type="button" + class="button button--secondary" + id={focusScope === 'conversation' + ? 'conversation-keep-reply' + : 'enquiry-keep-reply'} + onclick={() => { + keepReplyEditing(controller); + destination = undefined; + refresh(); + void tick().then(focusEditor); + }}>Keep editing</button + > + <button + type="button" + class="button button--secondary" + onclick={() => { + const target = internalHref(destination); + const result = discardReplyNavigation( + controller, + 'reviewed_discard_private_text' + ); + destination = undefined; + refresh(); + if (result === 'allowed') { + if (target) void goto(target); + } else void tick().then(focusEditor); + }}>Discard draft</button + > + </div> + </div> + {/if} + </div> +{/if} diff --git a/web/src/lib/components/MessageItem.svelte b/web/src/lib/components/MessageItem.svelte @@ -8,9 +8,14 @@ let { controller, conversationId, - message - }: { controller: InboxView; conversationId: string; message: ThreadMessage } = - $props(); + message, + onreply + }: { + controller: InboxView; + conversationId: string; + message: ThreadMessage; + onreply?: (parent: string) => void; + } = $props(); // Copied rows select only a hash. Render fresh current original room bytes. const current = $derived( inboxMessageSnapshot(controller, conversationId, message.data.rumorId) @@ -53,5 +58,12 @@ {#each current.delivery ?? [] as label (label)}<p class="text-small"> {label} </p>{/each} + {#if onreply}<button + type="button" + class="button button--secondary" + onclick={() => { + if (current) onreply?.(current.data.rumorId); + }}>Reply to this message</button + >{/if} </article> {/if} diff --git a/web/src/lib/messaging/inbox-view.ts b/web/src/lib/messaging/inbox-view.ts @@ -93,6 +93,11 @@ import { type InboxSync } from './inbox-sync.ts'; import { messagingReadinessSnapshot } from './readiness.ts'; +import { + selfRecoveryAcknowledgementSnapshot, + verifySelfRecoveryAcknowledgement, + type SelfRecoveryAcknowledgement +} from '../persistence/private-sends.ts'; declare const inboxViewBrand: unique symbol; export type InboxView = Readonly<{ [inboxViewBrand]: true }>; export type InboxViewSnapshot = Readonly<{ @@ -112,7 +117,25 @@ type Inputs = Readonly<{ setup: InboxSetupView; conversationId?: string; }>; +export type InboxReplyOwnership = Readonly<{ + owner: string; + identity: IdentitySession; + session: PrivateSession; + database: BrowserDatabase; + repository: PrivateStorageRepository; + unlocked: UnlockedSession; + room: AdmittedConversation; + setup: InboxSetupView; + peer: string; + parent: string; + current(): boolean; + acceptLocalReply( + receipt: SelfRecoveryAcknowledgement, + review: unknown + ): Promise<boolean>; +}>; type Controller = { + reply(id: unknown, rumor: unknown): InboxReplyOwnership | undefined; snapshot(): InboxViewSnapshot; thread(id: unknown): ThreadSnapshot; threadRevision(): number; @@ -192,6 +215,7 @@ export function createInboxView(input: Inputs): InboxView | undefined { let sendRecords: readonly PrivateRecordHandle[] = Array.from<PrivateRecordHandle>([]); let listReason: string | null = null; + let repliedPeers = Array.from<string>([]); let listRevision = 0; const rowProofs = new Map< string, @@ -306,6 +330,79 @@ export function createInboxView(input: Inputs): InboxView | undefined { messages: messages.filter((row) => row !== undefined) }; } + function replyOwnership( + id: unknown, + rumor: unknown + ): InboxReplyOwnership | undefined { + if ( + typeof rumor !== 'string' || + !messageSnapshot(id, rumor) || + !session || + !database || + !repository || + !unlocked + ) + return; + const proof = threadProofs.get(rumor); + if (!proof) return; + const data = conversationSnapshot(proof.room); + if (!data) return; + const generation = epoch, + selection = threadEpoch, + originalSession = session, + originalRepository = repository, + originalCache = unlocked, + originalDatabase = database; + const admitted = () => + current(generation) && + privateCurrent() && + selection === threadEpoch && + id === threadId && + threadPeer === data.peer && + session === originalSession && + repository === originalRepository && + unlocked === originalCache && + !!messageSnapshot(id, rumor) && + unlockedConversationCurrent(originalCache, proof.room); + if (!admitted()) return; + return { + owner: capture.owner, + identity: input.identity, + session: originalSession, + database: originalDatabase, + repository: originalRepository, + unlocked: originalCache, + room: proof.room, + setup: input.setup, + peer: data.peer, + parent: data.rumorId, + current: admitted, + async acceptLocalReply(receipt, review) { + const saved = selfRecoveryAcknowledgementSnapshot(receipt); + if ( + review !== 'reviewed_local_reply' || + !admitted() || + saved?.owner !== capture.owner || + saved.peer !== data.peer || + !(await verifySelfRecoveryAcknowledgement( + originalRepository, + receipt + )) || + !admitted() + ) + return false; + // Presentation in this unlocked view only, backed by the actual native + // self receipt. No order/notification or persistent acceptance field. + if (!repliedPeers.includes(data.peer)) + repliedPeers = repliedPeers.concat(data.peer); + listRevision++; + await refreshList(generation); + if (!admitted()) return false; + notify(); + return true; + } + }; + } async function resolve(id: unknown, review: unknown) { if (review !== 'reviewed_conversation_navigation') return false; const selection = ++threadEpoch, @@ -404,8 +501,22 @@ export function createInboxView(input: Inputs): InboxView | undefined { return { status: 'unavailable', requests: [], conversations: [] }; return { status: 'ready', - requests: requests.filter((row) => row !== undefined), - conversations: conversations.filter((row) => row !== undefined) + requests: requests + .filter((row) => row !== undefined) + .filter((row) => !repliedPeers.includes(row.peer)), + conversations: conversations + .filter((row) => row !== undefined) + .concat( + requests + .filter((row) => row !== undefined) + .filter((row) => repliedPeers.includes(row.peer)) + ) + .sort( + (a, b) => + b.latest.createdAt - a.latest.createdAt || + b.latest.rumorId.localeCompare(a.latest.rumorId) || + a.peer.localeCompare(b.peer) + ) }; } async function refreshList(generation = epoch) { @@ -687,6 +798,7 @@ export function createInboxView(input: Inputs): InboxView | undefined { threadId = undefined; threadPeer = undefined; sendRecords = []; + repliedPeers = []; metadata = undefined; directory = undefined; older = undefined; @@ -962,6 +1074,7 @@ export function createInboxView(input: Inputs): InboxView | undefined { return current(generation) && privateCurrent(); } views.set(token, { + reply: replyOwnership, snapshot, thread: threadSnapshot, threadRevision: () => (privateCurrent() ? listRevision + threadEpoch : -1), @@ -1143,3 +1256,11 @@ export function markInboxConversationDisplayed( export function inboxThreadRevision(token: InboxView | undefined): number { return token ? (views.get(token)?.threadRevision() ?? -1) : -1; } + +export function inboxReplyOwnership( + token: InboxView, + id: unknown, + rumor: unknown +): InboxReplyOwnership | undefined { + return views.get(token)?.reply(id, rumor); +} diff --git a/web/src/lib/messaging/reply-controller.ts b/web/src/lib/messaging/reply-controller.ts @@ -0,0 +1,440 @@ +import { inboxReplyOwnership, type InboxView } from './inbox-view.ts'; +import { inboxSetupViewOwnership } from './inbox-setup-view.ts'; +import { messagingReadinessSnapshot } from './readiness.ts'; +import { + createInboxRoutePlan, + inboxRoutePlanSnapshot +} from './inbox-routing.ts'; +import { + resolveInboxPreference, + closeInboxResolver, + type InboxResolver +} from './resolve-inbox.ts'; +import { + createPublicView, + beginPublicViewRun, + publicViewRunCurrent, + disposePublicView, + type PublicRuntime +} from '../runtime/public-runtime.ts'; +import { + createPrivateComposer, + privateComposerText, + privateComposerSnapshot, + updatePrivateComposerText, + bindPrivateComposerPreparation, + closePrivateComposer +} from './composer-state.ts'; +import { + captureDirtyNavigation, + requestPrivateNavigation, + confirmDiscardNavigation, + keepPrivateEditing, + dirtyNavigationSnapshot, + privateNavigationBeforeUnload +} from '../runtime/dirty-navigation.ts'; +import { + captureAuthenticatedReplyRumor, + stopRumorPlan, + type RumorPlan +} from './rumor-plan.ts'; +import { createPrivateSendReservationRepository } from '../persistence/private-send-reservations.ts'; +import { reserveSendIdentity } from './send-identity.ts'; +import { + captureSelfRecoveryPreparation, + prepareSelfRecovery, + preparedSelfRecovery, + preparePairedDelivery, + preparedPairedDelivery, + selfRecoveryPreparationSnapshot, + type SelfRecoveryPreparation +} from './prepare-send.ts'; +import { getPrivatePool } from '../nostr/private-pool.ts'; +import { + capturePrivateRetry, + runPrivateRetry, + stopPrivateRetry, + type PrivateRetry +} from './retry-send.ts'; +import { newLocalId } from '../private-handles.ts'; +import { subscribeIdentityInvalidation } from '../runtime/identity-session.ts'; +import { subscribePrivateSessionClose } from '../runtime/private-session.ts'; + +declare const replyBrand: unique symbol; +export type ReplyController = Readonly<{ [replyBrand]: true }>; +type Result = Readonly<{ + status: 'invalid' | 'busy' | 'stopped' | 'needs_action' | 'completed'; +}>; +type Options = Readonly<{ + lookupPeer?(peer: string): Promise<InboxResolver>; + close?(): void; +}>; +type State = + | 'idle' + | 'checking' + | 'preparing' + | 'publishing' + | 'needs_action' + | 'completed'; +type Snapshot = Readonly<{ + state: State; + busy: boolean; + dirty: boolean; + copy: string; + saveCopy: string; + pairCopy: string; + navigation: 'idle' | 'confirmation_required'; +}>; +type Controller = { + snapshot(): Snapshot | undefined; + text(): string | undefined; + update(text: unknown, review: unknown): boolean; + select(parent: unknown, review: unknown): boolean; + send(review: unknown): Promise<Result>; + request(): ReturnType<typeof requestPrivateNavigation>; + keep(): boolean; + discard(review: unknown): ReturnType<typeof confirmDiscardNavigation>; + unload(event: BeforeUnloadEvent): boolean; + close(): void; +}; +const controllers = new WeakMap<ReplyController, Controller>(); + +// Allocating or typing a draft performs no SDK, native write or discovery. +// Caller hints are resolved through the original selected view's Room/cache. +export function createReplyController( + view: InboxView, + conversationId: unknown, + parent: unknown, + options: Options = {} +): ReplyController | undefined { + if (typeof window === 'undefined') return; + let scope = inboxReplyOwnership(view, conversationId, parent); + if (!scope?.current()) return; + const original = scope, + composer = createPrivateComposer( + original.identity, + 'reviewed_private_composer' + ); + const navigation = composer && captureDirtyNavigation(composer); + if (!composer || !navigation) { + if (composer) closePrivateComposer(composer); + return; + } + let active = true, + busy = false, + state: State = 'idle', + copy = '', + attempted = false; + let plan: RumorPlan | undefined, + preparation: SelfRecoveryPreparation | undefined, + retry: PrivateRetry | undefined; + let identityOff = () => {}, + privateOff = () => {}; + function close() { + if (!active) return; + active = false; + if (retry) stopPrivateRetry(retry); + closePrivateComposer(composer!); + if (plan) stopRumorPlan(plan); + identityOff(); + privateOff(); + options.close?.(); + } + function current() { + if (!active || !scope?.current() || !privateComposerSnapshot(composer!)) { + close(); + return false; + } + return true; + } + function snapshot(): Snapshot | undefined { + if (!current()) return; + const draft = privateComposerSnapshot(composer!), + workflow = preparation && selfRecoveryPreparationSnapshot(preparation); + if (!draft) return; + return { + state, + busy, + dirty: draft.dirty, + copy: + copy || + (state === 'preparing' + ? 'Preparing encryption. The extension may ask for several approvals.' + : state === 'publishing' + ? 'Publishing encrypted copies to the reviewed inbox relays.' + : ''), + saveCopy: draft.copy, + pairCopy: workflow?.pairCopy ?? draft.pairCopy, + navigation: dirtyNavigationSnapshot(navigation!)?.state ?? 'idle' + }; + } + async function send(review: unknown): Promise<Result> { + if (review !== 'reviewed_reply_send') return { status: 'invalid' }; + if (!current()) return { status: 'stopped' }; + if (busy) return { status: 'busy' }; + const text = privateComposerText(composer!); + if (!text?.trim()) return { status: 'invalid' }; + if (attempted) return { status: 'needs_action' }; + busy = true; + state = 'checking'; + copy = + 'Checking the authenticated peer inbox. Your text remains in memory.'; + const captured = scope!; + const admitted = () => current() && scope === captured; + function needsAction(): Result { + state = 'needs_action'; + copy = + 'Send needs review. Keep this draft; check inbox setup or connection, then explicitly send again. Existing encrypted work needs its own recovery review.'; + return { status: 'needs_action' }; + } + try { + const setup = inboxSetupViewOwnership(captured.setup); + if (!setup?.current() || !setup.resolver || !options.lookupPeer) + return needsAction(); + const other = await options.lookupPeer(captured.peer); + if (!admitted()) return { status: 'stopped' }; + if ( + !messagingReadinessSnapshot( + captured.identity, + captured.session, + setup.policy, + setup.resolver, + { author: captured.peer, resolver: other }, + setup.observeAccess + ).sendReady || + !admitted() + ) + return needsAction(); + const routes = createInboxRoutePlan( + setup.policy, + captured.owner, + captured.peer, + setup.resolver, + other + ); + const routeData = routes && inboxRoutePlanSnapshot(routes); + const reservations = createPrivateSendReservationRepository( + captured.database, + captured.owner + ); + if (!routes || !routeData || !reservations || !admitted()) + return needsAction(); + plan = captureAuthenticatedReplyRumor( + captured.identity, + captured.session, + captured.unlocked, + captured.room, + text, + Math.floor(Date.now() / 1000) + ); + const command = newLocalId(); + if (!plan || !command || !admitted()) return needsAction(); + // After a native intent may exist, repeated Send never creates another + // rumor or silently replays this command. Recovery has its own owner. + attempted = true; + const reserved = await reserveSendIdentity( + reservations, + captured.identity, + command, + plan, + 'reviewed_private_intent' + ); + if (!admitted()) return { status: 'stopped' }; + if (!('identity' in reserved)) return needsAction(); + preparation = captureSelfRecoveryPreparation( + captured.repository, + captured.identity, + reserved.identity, + 'reviewed_self_recovery' + ); + if ( + !preparation || + !bindPrivateComposerPreparation( + composer!, + reserved.identity, + preparation, + undefined, + 'reviewed_composer_preparation' + ) + ) + return needsAction(); + state = 'preparing'; + copy = ''; + const self = await prepareSelfRecovery( + preparation, + 'reviewed_self_recovery' + ); + if (!admitted()) return { status: 'stopped' }; + const saved = preparedSelfRecovery(preparation); + if ( + !['saved', 'existing', 'reconciled'].includes(self.status) || + !saved || + !(await captured.acceptLocalReply(saved, 'reviewed_local_reply')) || + !admitted() + ) + return needsAction(); + const context = { + plan: routes, + policy: setup.policy, + own: setup.resolver, + other + }; + const paired = await preparePairedDelivery( + preparation, + context, + 'reviewed_pair_preparation' + ); + if (!admitted()) return { status: 'stopped' }; + const receipt = preparedPairedDelivery(preparation); + if ( + !['prepared', 'existing', 'reconciled'].includes(paired.status) || + !receipt + ) + return needsAction(); + const origins = Array.from( + new Set([...routeData.peer.targets, ...routeData.archive.targets]) + ); + const pool = getPrivatePool(captured.session, setup.policy, origins); + if (!pool || !admitted()) return needsAction(); + retry = capturePrivateRetry( + captured.repository, + captured.session, + receipt, + context, + pool, + 'reviewed_private_retry' + ); + if (!retry || !admitted()) return needsAction(); + state = 'publishing'; + const delivered = await runPrivateRetry(retry, 'reviewed_private_retry'); + if (!admitted()) return { status: 'stopped' }; + if (delivered.status !== 'completed') return needsAction(); + state = 'completed'; + copy = + 'Accepted by recipient inbox relay. This does not confirm that the person read the message.'; + return { status: 'completed' }; + } catch { + return current() ? needsAction() : { status: 'stopped' }; + } finally { + busy = false; + } + } + const token = Object.freeze({}) as ReplyController; + controllers.set(token, { + snapshot, + text: () => (current() ? privateComposerText(composer) : undefined), + update: (text, review) => + current() && + !busy && + !attempted && + updatePrivateComposerText(composer, text, review), + select(parent, review) { + if (review !== 'reviewed_reply_parent' || !current() || busy || attempted) + return false; + const selected = inboxReplyOwnership(view, conversationId, parent); + if ( + !selected?.current() || + selected.identity !== original.identity || + selected.session !== original.session || + selected.peer !== original.peer + ) + return false; + scope = selected; + return true; + }, + send, + request: () => + current() ? requestPrivateNavigation(navigation) : 'invalid', + keep: () => current() && keepPrivateEditing(navigation), + discard: (review) => + current() ? confirmDiscardNavigation(navigation, review) : 'invalid', + unload: (event) => + current() && privateNavigationBeforeUnload(navigation, event), + close + }); + identityOff = subscribeIdentityInvalidation(original.identity, () => { + if (!original.current()) close(); + }); + privateOff = subscribePrivateSessionClose(original.session, close); + return current() ? token : undefined; +} + +export function createRuntimeReplyController( + view: InboxView, + id: unknown, + parent: unknown, + runtime: PublicRuntime +): ReplyController | undefined { + const publicView = createPublicView(runtime); + let resolver: InboxResolver | undefined, + run: ReturnType<typeof beginPublicViewRun> | undefined; + const token = createReplyController(view, id, parent, { + lookupPeer: (peer) => { + // Only this explicit Send lookup may renew an expired run. An active + // lookup retains its original bounded work, including pending results. + if (!resolver || !run || !publicViewRunCurrent(publicView, run)) { + if (resolver) closeInboxResolver(resolver); + resolver = undefined; + run = beginPublicViewRun(publicView); + resolver = resolveInboxPreference(publicView, run, peer); + } + return Promise.resolve(resolver); + }, + close: () => { + if (resolver) closeInboxResolver(resolver); + disposePublicView(publicView); + } + }); + if (!token) disposePublicView(publicView); + return token; +} +export function replySnapshot(token: ReplyController) { + return controllers.get(token)?.snapshot(); +} +export function replyText(token: ReplyController) { + return controllers.get(token)?.text(); +} +export function updateReplyText( + token: ReplyController, + text: unknown, + review: unknown +) { + return controllers.get(token)?.update(text, review) ?? false; +} +export function selectReplyParent( + token: ReplyController, + parent: unknown, + review: unknown +) { + return controllers.get(token)?.select(parent, review) ?? false; +} +export function sendReply( + token: ReplyController, + review: unknown +): Promise<Result> { + return ( + controllers.get(token)?.send(review) ?? + Promise.resolve({ status: 'invalid' }) + ); +} +export function requestReplyNavigation(token: ReplyController) { + return controllers.get(token)?.request() ?? 'invalid'; +} +export function keepReplyEditing(token: ReplyController) { + return controllers.get(token)?.keep() ?? false; +} +export function discardReplyNavigation( + token: ReplyController, + review: unknown +) { + return controllers.get(token)?.discard(review) ?? 'invalid'; +} +export function replyBeforeUnload( + token: ReplyController, + event: BeforeUnloadEvent +) { + return controllers.get(token)?.unload(event) ?? false; +} +export function closeReplyController(token: ReplyController) { + controllers.get(token)?.close(); +} diff --git a/web/src/lib/messaging/rumor-plan.ts b/web/src/lib/messaging/rumor-plan.ts @@ -10,6 +10,20 @@ import { recoveredSelfEnvelopeSnapshot, type RecoveredSelfEnvelope } from '../nostr/self-recovery-reader.ts'; +import { + privateSessionOwnership, + type PrivateSession +} from '../runtime/private-session.ts'; +import { + unlockedSessionOwnership, + unlockedConversationCurrent, + type UnlockedSession +} from './unlocked-session.ts'; +import { + conversationSnapshot, + conversationOwnership, + type AdmittedConversation +} from './admit-conversation.ts'; declare const rumorBrand: unique symbol; export type RumorPlan = Readonly<{ readonly [rumorBrand]: true }>; export type RumorPlanSnapshot = Readonly<{ @@ -30,21 +44,23 @@ const plans = new WeakMap<RumorPlan, Controller>(); function capture( session: IdentitySession, rawMessage: string, - observedTime: unknown + observedTime: unknown, + additionalCurrent: () => boolean = () => true ): RumorPlan | undefined { const ownership = identityMessagingOwnership(session); - if (!ownership || !ownership.current()) return undefined; + if (!ownership || !ownership.current() || !additionalCurrent()) + return undefined; const rumor = buildCanonicalPairRumor( rawMessage, ownership.owner, observedTime ); - if (!rumor || !ownership.current()) return undefined; + if (!rumor || !ownership.current() || !additionalCurrent()) return undefined; const peer = rumor.tags.find((row) => row[0] === 'p')?.[1]; if (!peer) return undefined; const token = Object.freeze({}) as RumorPlan; const unsubscribe = subscribeIdentityInvalidation(session, () => { - if (!ownership.current()) stopRumorPlan(token); + if (!ownership.current() || !additionalCurrent()) stopRumorPlan(token); }); plans.set(token, { owner: ownership.owner, @@ -52,11 +68,69 @@ function capture( id: rumor.id, createdAt: rumor.created_at, wire: JSON.stringify(rumor), - current: ownership.current, + current: () => ownership.current() && additionalCurrent(), unsubscribe }); return token; } +// Reply authority comes from the original authenticated room and its exact +// private/cache generation. A detached snapshot, parent hash or outer author +// cannot select the peer or borrow a same-owner session. +export function captureAuthenticatedReplyRumor( + identity: IdentitySession, + session: PrivateSession, + unlocked: UnlockedSession, + room: AdmittedConversation, + text: unknown, + observedTime: unknown +): RumorPlan | undefined { + const owner = identityMessagingOwnership(identity), + privateOwner = privateSessionOwnership(session), + cache = unlockedSessionOwnership(unlocked), + admitted = conversationOwnership(room), + data = conversationSnapshot(room); + if ( + !owner || + !privateOwner || + !cache || + !admitted || + !data || + typeof text !== 'string' + ) + return; + const current = () => { + const actual = conversationSnapshot(room); + return ( + owner.current() && + privateOwner.current() && + cache.current() && + admitted.current() && + owner.owner === data.owner && + privateOwner.owner === owner.owner && + privateOwner.session === owner.session && + cache.owner === owner.owner && + cache.session === owner.session && + admitted.owner === owner.owner && + admitted.session === owner.session && + actual?.owner === data.owner && + actual.peer === data.peer && + actual.rumorId === data.rumorId && + unlockedConversationCurrent(unlocked, room) + ); + }; + if (!current()) return; + return capture( + identity, + JSON.stringify({ + recipients: [{ public_key: data.peer, relay_url: null }], + content: text, + reply_to: { id: data.rumorId, relays: null }, + subject: null + }), + observedTime, + current + ); +} export function captureEnquiryRumor( session: IdentitySession, context: EnquiryContext, diff --git a/web/tests/e2e/harness/conversation-thread.ts b/web/tests/e2e/harness/conversation-thread.ts @@ -58,6 +58,13 @@ import { stopInboxView, closeInboxView } from '../../../src/lib/messaging/inbox-view.ts'; +import { identityMessagingOwnership } from '../../../src/lib/runtime/identity-session.ts'; +import type { RelayPolicy } from '../../../src/lib/config/relays.ts'; +import type { InboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts'; + +// HCP103 does not navigate; HCP104's separate harness exercises actual mounted +// beforeNavigate callbacks and unload/disposal. This alias owns fixture scope. +export function beforeNavigate(): void {} export function goto(): never { throw Error('Thread fixture must not navigate'); @@ -72,7 +79,12 @@ export type Scenario = | 'hostile'; export async function renderFixture( kind: Scenario = 'inbound', - selectedId?: string + selectedId?: string, + qualifiedReplyFixture = false, + freshOwnLookup?: ( + owner: string, + policy: RelayPolicy + ) => Promise<InboxResolver> ) { // Receipt scenario performs actual original SDK retry and receives loopback // OKs before mounting the readonly thread. The UI itself never publishes. @@ -276,7 +288,19 @@ export async function renderFixture( const setup = createInboxSetupView({ identity: f.identity, policy, - lookup: () => Promise.resolve(f.context.own) + lookup: () => + freshOwnLookup + ? freshOwnLookup(f.owner, policy) + : Promise.resolve(f.context.own), + // Controlled qualification projection only, never production relay evidence. + observeAccess: qualifiedReplyFixture + ? (context) => ({ + ...context, + receive: 'qualified_exercised', + archive: 'qualified_exercised', + current: () => !!identityMessagingOwnership(f.identity)?.current() + }) + : undefined }); if (!setup) throw Error('no original setup'); const controller = createInboxView({ @@ -342,6 +366,10 @@ export async function renderFixture( holdReadLock, releaseRead, controller, + replyLookup(peer: string) { + if (peer !== f.peer) throw Error('wrong authenticated fixture peer'); + return f.context.other; + }, owner: f.owner, peer: f.peer, conversationId, diff --git a/web/tests/e2e/harness/reply-composer-panel.svelte b/web/tests/e2e/harness/reply-composer-panel.svelte @@ -0,0 +1,9 @@ +<script lang="ts"> + import MessageComposer from '../../../src/lib/components/MessageComposer.svelte'; + import type { ReplyController } from '../../../src/lib/messaging/reply-controller.ts'; + let { controller }: { controller: ReplyController } = $props(); +</script> + +<section data-reply-fixture> + <MessageComposer {controller} /> +</section> diff --git a/web/tests/e2e/harness/reply-composer.ts b/web/tests/e2e/harness/reply-composer.ts @@ -0,0 +1,304 @@ +import { mount, unmount } from 'svelte'; +import type { beforeNavigate as KitBeforeNavigate } from '$app/navigation'; +type BeforeNavigate = Parameters<Parameters<typeof KitBeforeNavigate>[0]>[0]; +import { + finalizeEvent, + type UnsignedEvent, + type NostrEvent +} from 'applesauce-core/helpers'; +import { renderFixture as renderThread } from './conversation-thread.ts'; +import Panel from './reply-composer-panel.svelte'; +import { + createReplyController, + createRuntimeReplyController, + replySnapshot, + replyText, + updateReplyText, + sendReply, + closeReplyController, + requestReplyNavigation, + keepReplyEditing, + discardReplyNavigation, + selectReplyParent +} from '../../../src/lib/messaging/reply-controller.ts'; +import { + inboxListSnapshot, + inboxReplyOwnership +} from '../../../src/lib/messaging/inbox-view.ts'; +import { + captureAuthenticatedReplyRumor, + rumorPlanSnapshot, + stopRumorPlan +} from '../../../src/lib/messaging/rumor-plan.ts'; +import { + createIdentitySession, + connectIdentity, + probeIdentityMessaging, + disconnectIdentity +} from '../../../src/lib/runtime/identity-session.ts'; +import { inboxSetupViewOwnership } from '../../../src/lib/messaging/inbox-setup-view.ts'; +import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts'; +import { + createPublicScheduler, + createPublicRun, + openInboxRequest, + closePublicScheduler, + type RequestClock +} from '../../../src/lib/nostr/request-scope.ts'; +import { + createPublicRuntimeContext, + mountPublicRuntime, + closePublicRuntime +} from '../../../src/lib/runtime/public-runtime.ts'; + +const navigation: ((event: BeforeNavigate) => void)[] = []; +let destinations = Array.from<string>([]); +export function beforeNavigate(callback: (event: BeforeNavigate) => void) { + navigation.push(callback); +} +export function goto(destination: string | URL) { + destinations = destinations.concat(String(destination)); + return Promise.resolve(); +} +export async function renderReplyFixture(qualified = true, production = false) { + navigation.length = 0; + destinations = []; + let clockOffset = 0, + alive = true; + const ownSchedulers: ReturnType<typeof createPublicScheduler>[] = []; + const clock: RequestClock = { + now: () => performance.now() + clockOffset, + schedule(callback, delay) { + const timer = setTimeout(callback, delay); + return () => clearTimeout(timer); + } + }; + const freshOwn: NonNullable<Parameters<typeof renderThread>[3]> = ( + owner, + policy + ) => { + const event = finalizeEvent( + { + kind: 10050, + created_at: 100, + tags: [['relay', 'wss://archive.example.org']], + content: '' + }, + new Uint8Array(32).fill(83) + ); + if (event.pubkey !== owner) throw Error('wrong genuine owner'); + const scheduler = createPublicScheduler({ + now: () => 0, + schedule: () => () => {} + }); + ownSchedulers.push(scheduler); + const run = createPublicRun(scheduler, policy); + return Promise.resolve( + createInboxResolver( + run, + owner, + (next) => + openInboxRequest( + run, + owner, + (sink) => { + sink({ + type: 'EVENT', + from: 'wss://discovery.example.org', + id: 'fixture', + event + }); + sink({ + type: 'EOSE', + from: 'wss://discovery.example.org', + id: 'fixture' + }); + return () => {}; + }, + next + ), + () => alive + ) + ); + }; + const thread = await renderThread( + 'inbound', + undefined, + qualified, + production ? freshOwn : undefined + ); + await thread.checkSetup(); + if (!(await thread.unlock())) throw Error('no genuine unlocked thread'); + let gate = false, + lookups = 0; + const scope = inboxReplyOwnership( + thread.controller, + thread.conversationId, + thread.firstRumor + ); + const setup = scope && inboxSetupViewOwnership(scope.setup); + const publicContext = production ? createPublicRuntimeContext() : undefined; + const runtime = + publicContext && + setup && + mountPublicRuntime(publicContext, setup.policy, clock); + if (production && !runtime) throw Error('no genuine public runtime'); + const candidate = runtime + ? createRuntimeReplyController( + thread.controller, + thread.conversationId, + thread.firstRumor, + runtime + ) + : createReplyController( + thread.controller, + thread.conversationId, + thread.firstRumor, + { + lookupPeer: (peer) => { + lookups++; + if (gate) throw Error('controlled same-page setup cancellation'); + return Promise.resolve(thread.replyLookup(peer)); + } + } + ); + if (!candidate) throw Error('no original reply controller'); + const controller = candidate; + const target = document.createElement('div'); + document.body.append(target); + const mounted = mount(Panel, { target, props: { controller } }); + let unmounted = false, + held = false, + release: (() => void) | undefined; + const provider = window.nostr as + { signEvent(event: UnsignedEvent): Promise<NostrEvent> } | undefined; + if (!provider) throw Error('no actual fixture provider'); + const nativeSign = provider.signEvent.bind(provider); + provider.signEvent = (event: UnsignedEvent) => + held + ? new Promise<NostrEvent>((resolve, reject) => { + release = () => { + held = false; + nativeSign(event).then(resolve, reject); + }; + }) + : nativeSign(event); + async function closeComposer() { + if (unmounted) return; + unmounted = true; + await unmount(mounted); + closeReplyController(controller); + target.remove(); + } + return { + owner: thread.owner, + peer: thread.peer, + parent: thread.firstRumor, + conversationId: thread.conversationId, + snapshot: () => replySnapshot(controller), + text: () => replyText(controller), + native: thread.native, + delta: thread.delta, + list: () => inboxListSnapshot(thread.controller), + lookups: () => lookups, + advance: () => { + clockOffset += 15_001; + }, + refreshSetup: thread.checkSetup, + gate: (value: boolean) => { + gate = value; + }, + send: (review: unknown = 'reviewed_reply_send') => + sendReply(controller, review), + update: (text: string, review: unknown = 'reviewed_private_text') => + updateReplyText(controller, text, review), + selectParent: (parent: string) => + selectReplyParent(controller, parent, 'reviewed_reply_parent'), + copied: async () => ({ + snapshot: replySnapshot({ ...controller }), + text: replyText({ ...controller }), + update: updateReplyText( + { ...controller }, + 'copied sentinel', + 'reviewed_private_text' + ), + send: await sendReply({ ...controller }, 'reviewed_reply_send'), + navigation: requestReplyNavigation({ ...controller }), + keep: keepReplyEditing({ ...controller }), + discard: discardReplyNavigation( + { ...controller }, + 'reviewed_discard_private_text' + ) + }), + async admission() { + const scope = inboxReplyOwnership( + thread.controller, + thread.conversationId, + thread.firstRumor + ); + if (!scope) throw Error('missing actual original room'); + const capture = ( + identity = scope.identity, + session = scope.session, + unlocked = scope.unlocked, + room = scope.room + ) => + captureAuthenticatedReplyRumor( + identity, + session, + unlocked, + room, + 'Local admission fixture only', + Math.floor(Date.now() / 1000) + ); + const genuine = capture(); + if (!genuine) throw Error('missing genuine plan'); + const wire = rumorPlanSnapshot(genuine)?.wire; + stopRumorPlan(genuine); + const copied = [ + capture({ ...scope.identity }), + capture(scope.identity, { ...scope.session }), + capture(scope.identity, scope.session, { ...scope.unlocked }), + capture(scope.identity, scope.session, scope.unlocked, { + ...scope.room + }) + ].map((plan) => !!plan); + const other = createIdentitySession(); + await connectIdentity(other); + await probeIdentityMessaging(other, 'reviewed_self_copy'); + const foreign = capture(other); + if (foreign) stopRumorPlan(foreign); + disconnectIdentity(other); + return { wire, copied, foreign: !!foreign }; + }, + navigate() { + let cancelled = false; + const event = { + cancel: () => { + cancelled = true; + }, + to: { url: new URL('/messages', window.location.origin) }, + willUnload: false + } as unknown as BeforeNavigate; + for (const callback of navigation) callback(event); + return cancelled; + }, + destinations: () => destinations.slice(), + holdSigner: () => { + held = true; + }, + pending: () => !!release, + settle: () => release?.(), + closeComposer, + logout: thread.logout, + async close() { + release?.(); + provider.signEvent = nativeSign; + await closeComposer(); + if (publicContext) closePublicRuntime(publicContext); + await thread.close(); + alive = false; + for (const scheduler of ownSchedulers) closePublicScheduler(scheduler); + } + }; +} diff --git a/web/tests/e2e/reply-composer.spec.ts b/web/tests/e2e/reply-composer.spec.ts @@ -0,0 +1,635 @@ +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/reply-composer.ts'; +import { finalizeEvent } from 'applesauce-core/helpers'; +declare global { + interface Window { + hcp104: typeof Fixture; + hcp104Fixture: Awaited<ReturnType<typeof Fixture.renderReplyFixture>>; + hcp104Pending?: Promise<unknown>; + } +} +let server: Awaited<ReturnType<typeof createStaticHarness>>, + sockets: WebSocketServer, + endpoint: string, + bundle: string; +let events: unknown[][] = [], + requests: unknown[][] = []; +let servePeerPreference = false; +const peerPreference = finalizeEvent( + { + kind: 10050, + created_at: 100, + tags: [['relay', 'wss://peer.example.org']], + content: '' + }, + new Uint8Array(32).fill(84) +); +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), + frame = JSON.parse(raw.toString()) as unknown[]; + if (frame[0] === 'EVENT') { + events.push(frame); + const event = frame[1] as { id: string }; + socket.send(JSON.stringify(['OK', event.id, true, ''])); + } + if (frame[0] === 'REQ') { + requests.push(frame); + const filter = frame[2] as { kinds?: number[]; authors?: string[] }; + if ( + servePeerPreference && + filter.kinds?.includes(10050) && + filter.authors?.includes(peerPreference.pubkey) + ) + socket.send(JSON.stringify(['EVENT', frame[1], peerPreference])); + 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/reply-composer.ts', import.meta.url) + ) + } + }, + build: { + write: false, + minify: false, + lib: { + entry: fileURLToPath( + new URL('./harness/reply-composer.ts', import.meta.url) + ), + name: 'hcp104', + 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(); +}); +async function load(page: import('@playwright/test').Page) { + await page.addInitScript( + ({ endpoint }) => { + const Native = window.WebSocket; + window.WebSocket = class extends Native { + constructor(url: string | URL, protocols?: string | string[]) { + if ( + ![ + 'wss://peer.example.org', + '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.beforeEach(async ({ page }) => { + events = []; + requests = []; + servePeerPreference = false; + await load(page); +}); +test.afterEach(async ({ page }) => { + if (!page.isClosed()) + await page.evaluate(async () => { + window.hcp104Fixture?.settle(); + await window.hcp104Pending; + await window.hcp104Fixture?.close(); + }); +}); +async function ready( + page: import('@playwright/test').Page, + qualified = true, + production = false +) { + await page.evaluate( + async ({ qualified, production }) => { + window.hcp104Fixture = await window.hcp104.renderReplyFixture( + qualified, + production + ); + }, + { qualified, production } + ); + await expect( + page.locator('[data-reply-fixture]').getByLabel('Reply', { exact: true }) + ).toBeVisible(); + await expect + .poll(() => + page.evaluate(async () => { + const native = await window.hcp104Fixture.native(); + return native.received.every((row) => { + const record = JSON.parse((row as { wire: string }).wire) as { + read: unknown; + }; + return record.read !== null; + }); + }) + ) + .toBe(true); +} +const composer = (page: import('@playwright/test').Page) => + page.locator('[data-reply-fixture]'); +const sentinel = 'HCP104_UNSENT_MEMORY_ONLY & <private>\nThursday pickup?'; + +test('production explicit Send renews an expired peer lookup without losing the draft or automatically sending', async ({ + page +}) => { + await ready(page, true, true); + await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel); + const before = await page.evaluate(async () => ({ + native: await window.hcp104Fixture.native(), + delta: window.hcp104Fixture.delta() + })); + expect(requests).toEqual([]); + expect(await page.evaluate(() => window.hcp104Fixture.send())).toEqual({ + status: 'needs_action' + }); + await expect.poll(() => requests.length).toBe(1); + expect(requests[0][2]).toMatchObject({ + kinds: [10050], + authors: [peerPreference.pubkey], + limit: 200 + }); + // An active missing-peer run is reused. Neither its EOSE nor another Send + // silently resets the bounded lookup or invents private readiness. + expect(await page.evaluate(() => window.hcp104Fixture.send())).toEqual({ + status: 'needs_action' + }); + expect(requests).toHaveLength(1); + expect(events).toEqual([]); + await page.evaluate(async () => { + window.hcp104Fixture.advance(); + await window.hcp104Fixture.refreshSetup(); + }); + expect(requests).toHaveLength(1); + expect(await page.evaluate(() => window.hcp104Fixture.text())).toBe(sentinel); + expect( + await page.evaluate(async () => ({ + native: await window.hcp104Fixture.native(), + delta: window.hcp104Fixture.delta() + })) + ).toEqual(before); + servePeerPreference = true; + expect(await page.evaluate(() => window.hcp104Fixture.send())).toEqual({ + status: 'needs_action' + }); + // The unchanged producer never issues this second original runtime query. + await expect.poll(() => requests.length).toBe(2); + expect(requests[1][2]).toEqual(requests[0][2]); + expect(events).toEqual([]); + expect(await page.evaluate(() => window.hcp104Fixture.text())).toBe(sentinel); + await composer(page) + .getByRole('button', { name: 'Send reply', exact: true }) + .click(); + await expect + .poll(() => page.evaluate(() => window.hcp104Fixture.snapshot()?.state)) + .toBe('completed'); + expect(requests).toHaveLength(2); + expect(events).toHaveLength(2); + expect(await page.evaluate(() => window.hcp104Fixture.delta())).toMatchObject( + { encrypts: before.delta.encrypts + 2, signs: before.delta.signs + 2 } + ); +}); + +test('typing is memory only with no autosave SDK discovery publication or order transition', async ({ + page +}) => { + await ready(page); + const before = await page.evaluate(async () => ({ + native: await window.hcp104Fixture.native(), + delta: window.hcp104Fixture.delta() + })); + await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel); + await expect(composer(page)).toContainText('unsaved memory'); + await expect(composer(page)).toContainText('does not accept an order'); + expect(await page.evaluate(() => window.hcp104Fixture.text())).toBe(sentinel); + expect(await page.evaluate(() => window.hcp104Fixture.lookups())).toBe(0); + expect( + await page.evaluate(async () => ({ + native: await window.hcp104Fixture.native(), + delta: window.hcp104Fixture.delta() + })) + ).toEqual(before); + expect(events).toEqual([]); + expect(requests).toEqual([]); + expect( + await composer(page) + .getByRole('button', { name: /Accept order/i }) + .count() + ).toBe(0); + expect( + await page.evaluate( + (text) => + JSON.stringify({ + local: { ...localStorage }, + session: { ...sessionStorage } + }).includes(text), + sentinel + ) + ).toBe(false); +}); + +test('explicit Send creates an actual self-first paired reply with the authenticated peer and direct inner parent', async ({ + page +}) => { + await ready(page); + await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel); + const before = await page.evaluate(() => window.hcp104Fixture.delta()); + await composer(page) + .getByRole('button', { name: 'Send reply', exact: true }) + .click(); + await expect + .poll(() => page.evaluate(() => window.hcp104Fixture.snapshot()?.state)) + .toBe('completed'); + expect(events).toHaveLength(2); + expect( + events.every((frame) => (frame[1] as { kind: number }).kind === 1059) + ).toBe(true); + expect(await page.evaluate(() => window.hcp104Fixture.delta())).toMatchObject( + { encrypts: before.encrypts + 2, signs: before.signs + 2 } + ); + await expect(composer(page)).toContainText('Saved encrypted in this browser'); + await expect(composer(page)).toContainText( + 'Accepted by recipient inbox relay' + ); + expect( + await page.evaluate(() => window.hcp104Fixture.list().requests) + ).toEqual([]); + expect( + await page.evaluate(() => + window.hcp104Fixture.list().conversations.map((row) => row.peer) + ) + ).toEqual([await page.evaluate(() => window.hcp104Fixture.peer)]); + const { nip44 } = await import('applesauce-core/helpers/encryption'); + const { getEventHash } = await import('applesauce-core/helpers'); + const owner = await page.evaluate(() => window.hcp104Fixture.owner), + peer = await page.evaluate(() => window.hcp104Fixture.peer), + parent = await page.evaluate(() => window.hcp104Fixture.parent); + const rumors = events.map((frame) => { + const outer = frame[1] as { + pubkey: string; + content: string; + tags: string[][]; + }; + const key = new Uint8Array(32).fill(outer.tags[0][1] === owner ? 83 : 84); + const seal = JSON.parse( + nip44.v2.decrypt( + outer.content, + nip44.v2.utils.getConversationKey(key, outer.pubkey) + ) + ) as { pubkey: string; content: string; kind: number; tags: string[][] }; + expect(seal.kind).toBe(13); + expect(seal.tags).toEqual([]); + expect(seal.pubkey).toBe(owner); + const rumor = JSON.parse( + nip44.v2.decrypt( + seal.content, + nip44.v2.utils.getConversationKey(key, seal.pubkey) + ) + ) as { + id: string; + kind: number; + pubkey: string; + tags: string[][]; + content: string; + created_at: number; + }; + expect(rumor.kind).toBe(14); + expect(rumor.pubkey).toBe(owner); + expect(rumor.content).toBe(sentinel); + expect(rumor.tags).toEqual([ + ['p', peer], + ['e', parent] + ]); + expect(getEventHash(rumor)).toBe(rumor.id); + key.fill(0); + return rumor; + }); + expect(rumors[0]).toEqual(rumors[1]); + expect(requests).toEqual([]); +}); + +test('cancelled same-page setup retains the exact draft and clearing the gate never auto-sends', async ({ + page +}) => { + await ready(page); + await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel); + const before = await page.evaluate(async () => ({ + native: await window.hcp104Fixture.native(), + delta: window.hcp104Fixture.delta() + })); + await page.evaluate(() => window.hcp104Fixture.gate(true)); + expect(await page.evaluate(() => window.hcp104Fixture.send())).toEqual({ + status: 'needs_action' + }); + await expect(composer(page).getByLabel('Reply', { exact: true })).toHaveValue( + sentinel + ); + await page.evaluate(() => window.hcp104Fixture.gate(false)); + expect( + await page.evaluate(async () => ({ + native: await window.hcp104Fixture.native(), + delta: window.hcp104Fixture.delta() + })) + ).toEqual(before); + expect(events).toEqual([]); + expect(requests).toEqual([]); +}); + +test('unexercised original inbox access leaves the memory draft honest and cannot send', async ({ + page +}) => { + await ready(page, false); + await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel); + const before = await page.evaluate(async () => ({ + native: await window.hcp104Fixture.native(), + delta: window.hcp104Fixture.delta() + })); + expect(await page.evaluate(() => window.hcp104Fixture.send())).toEqual({ + status: 'needs_action' + }); + expect(await page.evaluate(() => window.hcp104Fixture.text())).toBe(sentinel); + expect( + await page.evaluate(async () => ({ + native: await window.hcp104Fixture.native(), + delta: window.hcp104Fixture.delta() + })) + ).toEqual(before); + expect(events).toEqual([]); +}); + +test('unreviewed Send and oversized edits retain the previous memory revision without effects', async ({ + page +}) => { + await ready(page); + await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel); + expect( + await page.evaluate(() => window.hcp104Fixture.update('x'.repeat(4097))) + ).toBe(false); + expect( + await page.evaluate(() => window.hcp104Fixture.send('unreviewed')) + ).toEqual({ status: 'invalid' }); + expect(await page.evaluate(() => window.hcp104Fixture.text())).toBe(sentinel); + expect(await page.evaluate(() => window.hcp104Fixture.lookups())).toBe(0); + expect(events).toEqual([]); +}); + +test('dirty route navigation defaults to Keep editing and preserves the draft and focus', async ({ + page +}) => { + await ready(page); + await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel); + expect(await page.evaluate(() => window.hcp104Fixture.navigate())).toBe(true); + await expect( + composer(page).getByRole('button', { name: 'Keep editing', exact: true }) + ).toBeFocused(); + await composer(page) + .getByRole('button', { name: 'Keep editing', exact: true }) + .click(); + await expect(composer(page).getByLabel('Reply', { exact: true })).toHaveValue( + sentinel + ); + await expect( + composer(page).getByLabel('Reply', { exact: true }) + ).toBeFocused(); + expect( + await page.evaluate(() => window.hcp104Fixture.destinations()) + ).toEqual([]); + expect(events).toEqual([]); +}); + +test('reviewed navigation discard clears only the same draft and returns to the safe inbox', async ({ + page +}) => { + await ready(page); + await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel); + const before = await page.evaluate(() => window.hcp104Fixture.native()); + expect(await page.evaluate(() => window.hcp104Fixture.navigate())).toBe(true); + await composer(page) + .getByRole('button', { name: 'Discard draft', exact: true }) + .click(); + expect(await page.evaluate(() => window.hcp104Fixture.text())).toBe(''); + expect( + await page.evaluate(() => window.hcp104Fixture.destinations()) + ).toEqual(['/messages']); + expect(await page.evaluate(() => window.hcp104Fixture.native())).toEqual( + before + ); + expect(events).toEqual([]); +}); + +test('actual native unload event warns for unsaved text without attempting a save', async ({ + page +}) => { + await ready(page); + await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel); + const before = await page.evaluate(() => window.hcp104Fixture.delta()); + expect( + await page.evaluate(() => { + const event = new Event('beforeunload', { cancelable: true }); + return window.dispatchEvent(event); + }) + ).toBe(false); + expect(await page.evaluate(() => window.hcp104Fixture.delta())).toEqual( + before + ); + expect(events).toEqual([]); +}); + +test('unmount during the actual held seal signature retires continuations and never auto-publishes a late result', async ({ + page +}) => { + await ready(page); + await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel); + await page.evaluate(() => { + window.hcp104Fixture.holdSigner(); + window.hcp104Pending = window.hcp104Fixture.send(); + }); + await expect + .poll(() => page.evaluate(() => window.hcp104Fixture.pending())) + .toBe(true); + await expect(composer(page)).toContainText('Preparing'); + expect(events).toEqual([]); + await page.evaluate(() => window.hcp104Fixture.closeComposer()); + await page.evaluate(async () => { + window.hcp104Fixture.settle(); + await window.hcp104Pending; + }); + expect( + await page.evaluate(() => window.hcp104Fixture.text()) + ).toBeUndefined(); + expect(events).toEqual([]); + expect(requests).toEqual([]); + expect(await page.evaluate(() => window.hcp104Fixture.delta())).toMatchObject( + { encrypts: 1, signs: 1 } + ); +}); + +test('logout during actual held signer work hides the draft and refuses late peer crypto or publication', async ({ + page +}) => { + await ready(page); + await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel); + await page.evaluate(() => { + window.hcp104Fixture.holdSigner(); + window.hcp104Pending = window.hcp104Fixture.send(); + }); + await expect + .poll(() => page.evaluate(() => window.hcp104Fixture.pending())) + .toBe(true); + await page.evaluate(() => window.hcp104Fixture.logout()); + await page.evaluate(async () => { + window.hcp104Fixture.settle(); + await window.hcp104Pending; + }); + expect( + await page.evaluate(() => window.hcp104Fixture.text()) + ).toBeUndefined(); + expect(events).toEqual([]); + await expect(composer(page).getByLabel('Reply', { exact: true })).toHaveCount( + 0 + ); +}); + +test('copied controllers and arbitrary private or product hashes cannot borrow reply custody', async ({ + page +}) => { + await ready(page); + await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel); + expect(await page.evaluate(() => window.hcp104Fixture.copied())).toEqual({ + update: false, + send: { status: 'invalid' }, + navigation: 'invalid', + keep: false, + discard: 'invalid' + }); + expect( + await page.evaluate(() => window.hcp104Fixture.selectParent('f'.repeat(64))) + ).toBe(false); + expect( + await page.evaluate(() => + window.hcp104Fixture.selectParent('nostr:naddr1invalid') + ) + ).toBe(false); + expect(await page.evaluate(() => window.hcp104Fixture.text())).toBe(sentinel); + expect(events).toEqual([]); + expect(requests).toEqual([]); +}); + +test('explicitly leaving and reloading loses the unsaved memory draft while ciphertext remains intact', async ({ + page +}) => { + await ready(page); + await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel); + const before = await page.evaluate(() => window.hcp104Fixture.native()); + await page.evaluate(() => window.hcp104Fixture.close()); + await page.reload(); + expect( + await page.evaluate(() => + document.body.textContent?.includes('HCP104_UNSENT_MEMORY_ONLY') + ) + ).toBe(false); + expect( + await page.evaluate( + (rows) => JSON.stringify(rows).includes('HCP104_UNSENT_MEMORY_ONLY'), + before + ) + ).toBe(false); + expect(events).toEqual([]); + expect(requests).toEqual([]); +}); + +test('later actual admitted Room replies reject every copied custody token and a genuine different same-owner identity generation', async ({ + page +}) => { + await ready(page); + const before = await page.evaluate(() => window.hcp104Fixture.native()); + const admission = await page.evaluate(() => window.hcp104Fixture.admission()); + expect(admission.copied).toEqual([false, false, false, false]); + expect(admission.foreign).toBe(false); + const rumor = JSON.parse(admission.wire!) as { + pubkey: string; + tags: string[][]; + content: string; + kind: number; + }; + expect(rumor.pubkey).toBe( + await page.evaluate(() => window.hcp104Fixture.owner) + ); + expect(rumor.tags).toEqual([ + ['p', await page.evaluate(() => window.hcp104Fixture.peer)], + ['e', await page.evaluate(() => window.hcp104Fixture.parent)] + ]); + expect(rumor.kind).toBe(14); + expect(rumor.content).toBe('Local admission fixture only'); + expect(await page.evaluate(() => window.hcp104Fixture.native())).toEqual( + before + ); + expect(events).toEqual([]); + expect(requests).toEqual([]); +}); + +test('later edit after opening dirty warning invalidates the reviewed discard revision without erasing the new draft or navigating', async ({ + page +}) => { + await ready(page); + await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel); + expect(await page.evaluate(() => window.hcp104Fixture.navigate())).toBe(true); + await composer(page) + .getByLabel('Reply', { exact: true }) + .fill(sentinel + '\nKeep this newer text'); + await composer(page) + .getByRole('button', { name: 'Discard draft', exact: true }) + .click(); + expect(await page.evaluate(() => window.hcp104Fixture.text())).toBe( + sentinel + '\nKeep this newer text' + ); + expect( + await page.evaluate(() => window.hcp104Fixture.destinations()) + ).toEqual([]); + expect(events).toEqual([]); + expect(requests).toEqual([]); +}); diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs @@ -350,6 +350,9 @@ import { auditOutput } from '../../tools/check-output.mjs'; 'src/lib/messaging/inbox-list.ts', 'src/lib/components/ConversationThread.svelte', 'src/lib/components/MessageItem.svelte', + 'src/lib/components/MessageComposer.svelte', + 'src/lib/messaging/reply-controller.ts', + 'src/lib/messaging/rumor-plan.ts', 'src/lib/messaging/conversation-thread.ts', 'src/lib/persistence/private-storage.ts', 'src/routes/messages/[conversationId=local_id]/+page.svelte' @@ -418,7 +421,9 @@ import { auditOutput } from '../../tools/check-output.mjs'; 'directory-duplicate-role', 'thread-missing-edge', 'thread-dynamic', - 'thread-entry-role' + 'thread-entry-role', + 'reply-missing-navigation', + 'reply-missing-handles' ]) await check( 'actual inbox list compiler rejects ' + mutation, @@ -432,7 +437,10 @@ import { auditOutput } from '../../tools/check-output.mjs'; const entry = Object.entries(manifest).find( ([, row]) => row.name === - (mutation.startsWith('thread-') ? 'nodes/5' : 'InboxStatus') + (mutation.startsWith('thread-') || + mutation.startsWith('reply-') + ? 'nodes/5' + : 'InboxStatus') ); assert.ok(entry); const [, row] = entry; @@ -453,6 +461,16 @@ import { auditOutput } from '../../tools/check-output.mjs'; ) ]; if (mutation === 'thread-entry-role') row.isEntry = false; + if (mutation === 'reply-missing-navigation') + row.imports = row.imports.filter( + (/** @type {string} */ value) => + manifest[value].name !== 'navigation' + ); + if (mutation === 'reply-missing-handles') + row.imports = row.imports.filter( + (/** @type {string} */ value) => + manifest[value].name !== 'private-handles' + ); await writeFile(file, JSON.stringify(manifest)); await assert.rejects(f.audit, /compiler|duplicate|inventory/); } diff --git a/web/tests/unit/reply-controller.test.ts b/web/tests/unit/reply-controller.test.ts @@ -0,0 +1,77 @@ +import { describe, expect, it } from 'vitest'; +import { + createReplyController, + replySnapshot, + replyText, + updateReplyText, + sendReply, + requestReplyNavigation, + keepReplyEditing, + discardReplyNavigation, + closeReplyController, + type ReplyController +} from '../../src/lib/messaging/reply-controller.ts'; +import { captureAuthenticatedReplyRumor } from '../../src/lib/messaging/rumor-plan.ts'; +import type { InboxView } from '../../src/lib/messaging/inbox-view.ts'; +import type { IdentitySession } from '../../src/lib/runtime/identity-session.ts'; +import type { PrivateSession } from '../../src/lib/runtime/private-session.ts'; +import type { UnlockedSession } from '../../src/lib/messaging/unlocked-session.ts'; +import type { AdmittedConversation } from '../../src/lib/messaging/admit-conversation.ts'; + +const id = '12345678-1234-4234-8234-123456789abc'; +describe('reply entry points reject detached custody and SSR effects', () => { + it('SSR cannot allocate an effect-capable reply controller or run discovery', () => { + let lookups = 0; + expect( + createReplyController({} as InboxView, id, 'a'.repeat(64), { + lookupPeer: () => { + lookups++; + throw Error('must not query'); + } + }) + ).toBeUndefined(); + expect(lookups).toBe(0); + }); + it('plain copied reply tokens expose no private body or lifecycle state', () => { + const fake = Object.freeze({}) as ReplyController; + expect(replySnapshot(fake)).toBeUndefined(); + expect(replyText(fake)).toBeUndefined(); + expect( + updateReplyText(fake, 'Private sentinel', 'reviewed_private_text') + ).toBe(false); + closeReplyController(fake); + expect(replyText(fake)).toBeUndefined(); + }); + it('fake Send cannot manufacture native reservation or remote success', async () => { + expect( + await sendReply({} as ReplyController, 'reviewed_reply_send') + ).toEqual({ status: 'invalid' }); + expect(await sendReply({} as ReplyController, undefined)).toEqual({ + status: 'invalid' + }); + }); + it('fake dirty-navigation tokens cannot discard a genuine draft', () => { + const fake = {} as ReplyController; + expect(requestReplyNavigation(fake)).toBe('invalid'); + expect(keepReplyEditing(fake)).toBe(false); + expect(discardReplyNavigation(fake, 'reviewed_discard_private_text')).toBe( + 'invalid' + ); + }); + it('same-owner strings and copied rooms cannot issue an authenticated reply rumor', () => { + expect( + captureAuthenticatedReplyRumor( + {} as IdentitySession, + {} as PrivateSession, + {} as UnlockedSession, + { + owner: 'a'.repeat(64), + peer: 'b'.repeat(64), + rumorId: 'c'.repeat(64) + } as unknown as AdmittedConversation, + 'Reply must not redirect to a body contact', + 1700000000 + ) + ).toBeUndefined(); + }); +}); diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs @@ -511,7 +511,7 @@ async function inboxPresentationAdmission(web) { 'src/lib/components/InboxStatus.svelte': '29f17df1ccece671ea2ba57578dc028fa541ce924e1cdc4b3e7753da500da53f', 'src/lib/messaging/inbox-view.ts': - '7a66afb2a1dad62f6c8c8a4753f8129d4a1fcd2b00116edbab6ac422f489d83f', + 'ba082b95304ef931dde530b846a986cbf492f82d16a4fb04ffc9448f5b21ee81', 'src/lib/messaging/inbox-sync.ts': '84f9b3bb165a81878bb281c51d245aff7eb06a0fa55b857a49b13d0cb1cff8ae', 'src/lib/messaging/inbox-setup-view.ts': @@ -523,15 +523,21 @@ async function inboxPresentationAdmission(web) { 'src/lib/messaging/inbox-list.ts': '9cc82877bfa8dbb2a7fa41bceb842793349416271f19569f49fdd5cfc1de07e5', 'src/lib/components/ConversationThread.svelte': - 'accd91eb5b5ada0f07158dbe7ddfccdd3af65f92536427d0a717a7c18aad7aca', + 'beb2fa152de393ffd6edf2fa42f4eb14376983e05e7624292f3f8c60eea57dc0', 'src/lib/components/MessageItem.svelte': - '7a33a603f806686c29f5b9faec2758f8b78339593d7a7aefa1a3ec1c7ce6f01e', + '50c7f7b2f41c46c45ac59013daeed915d116375b45b9f846e06051695aa3c6a8', 'src/lib/messaging/conversation-thread.ts': '7367f0e6d96a9f249514f66c2459274e856eb83462523e37264d4cd97d2e36d1', 'src/lib/persistence/private-storage.ts': 'e45a95c9b12e8534a6ab0a4ec8ee1c86e730bba2f252dc1947954439720f2bfc', 'src/routes/messages/[conversationId=local_id]/+page.svelte': - 'b06c6189adee80b68bc6657fa0e8504551fe9a8b1655a6d81807ebee9930a5e7' + 'b06c6189adee80b68bc6657fa0e8504551fe9a8b1655a6d81807ebee9930a5e7', + 'src/lib/components/MessageComposer.svelte': + '9fd8221ab7c9c2d2d0e6626dc8d37b7c95de82b65804dc8766a7f756363c68ae', + 'src/lib/messaging/reply-controller.ts': + 'c13f1395b5317febcd23396babbcc116065ff96e8cbeb29c8eadfdfc14e45c2d', + 'src/lib/messaging/rumor-plan.ts': + '11a672d05a1eaf680b8039bd4c0986754b64f7103034c698843dc24d0560e0f5' }; for (const [name, pin] of Object.entries(producers)) { const bytes = await readOwned(web, name); @@ -1048,10 +1054,12 @@ export async function auditOutput(webDirectory) { 'nodes/5', [ 'public-key', + 'private-handles', 'public-runtime', 'client', 'Button', 'client.svelte', + 'navigation', 'state', 'view-context', 'legacy',