app

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

commit 0c1d9f424b32953869eed96da19ce4cf1f809088
parent f405253b5775c21d1d7aea766e3b6ef028783690
Author: triesap <tyson@radroots.org>
Date:   Wed, 14 Oct 2026 04:48:58 +0000

harvestcircle_web: Own scoped private AUTH and connection cleanup

- Bind explicit AUTH to genuine current sessions, inbox heads, targets and guarded responses.
- Share bounded role scopes and original connection leases with physical closure barriers.
- Preserve attempt accounting and exact cleanup retry across receive and delivery owners.
- Verify hostile source guards, lifecycle races and 204 affected browser workflows.

Diffstat:
Aweb/src/lib/messaging/inbox-access-controller.ts | 314+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/messaging/inbox-sync.ts | 17++++++++++++++---
Mweb/src/lib/messaging/product-request-controller.ts | 58+++++++++++++++++++++++++++++++++++++++++++++++++++-------
Mweb/src/lib/messaging/reply-controller.ts | 55++++++++++++++++++++++++++++++++++++++++++++++++-------
Mweb/src/lib/nostr/inbox-ingress.ts | 11+++++++++--
Mweb/src/lib/nostr/private-pool.ts | 1103++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-----------------
Mweb/tests/e2e/harness/history-cursor.ts | 38++++++++++++++++++++++++++++++--------
Mweb/tests/e2e/harness/history-pagination.ts | 38++++++++++++++++++++++++++++++--------
Aweb/tests/e2e/harness/inbox-access-controller.ts | 151++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/e2e/harness/inbox-auth.ts | 63++++++++++++++++++++++++++++++++++++++++++++++++---------------
Mweb/tests/e2e/harness/inbox-sync.ts | 38++++++++++++++++++++++++++++++--------
Mweb/tests/e2e/harness/paired-delivery.ts | 15++++++++++++---
Mweb/tests/e2e/harness/private-publisher.ts | 82++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-----------
Aweb/tests/e2e/inbox-access-controller.spec.ts | 788+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/e2e/inbox-auth.spec.ts | 6+++---
Mweb/tests/e2e/private-publisher.spec.ts | 192+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
Mweb/tests/e2e/product-request.spec.ts | 57+++++++++++++++++++++++++++++++++++++++++++++++++++++----
Mweb/tests/e2e/reply-composer.spec.ts | 51++++++++++++++++++++++++++++++++++++++++++++++++++-
Mweb/tests/integration/private-pool.test.ts | 51++++++++++++++++++++++++++++++++++++++++++++++-----
Mweb/tests/provenance/output.test.mjs | 4++++
Mweb/tests/provenance/source-boundaries.test.mjs | 36++++++++++++++++++++++++++++++++++++
Mweb/tools/check-output.mjs | 32++++++++++++++++++++++----------
Mweb/tools/source-boundaries.mjs | 67++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---
23 files changed, 2933 insertions(+), 334 deletions(-)

diff --git a/web/src/lib/messaging/inbox-access-controller.ts b/web/src/lib/messaging/inbox-access-controller.ts @@ -0,0 +1,314 @@ +import { + inboxRelayTargets, + publicRelayTargets, + readRelayPolicy, + type RelayPolicy +} from '../config/relays.ts'; +import { inboxPreferenceSnapshot } from '../nostr/inbox-preferences.ts'; +import { + beginInboxAuthentication, + respondInboxAuthentication, + closeInboxAuthentication, + inboxAuthSnapshot, + type InboxAuthAction +} from '../nostr/inbox-auth.ts'; +import { + getPrivatePool, + closePrivatePool, + privatePoolCleanupRequired, + type PrivatePool +} from '../nostr/private-pool.ts'; +import { + privateSessionOwnership, + subscribePrivateSessionClose, + type PrivateSession +} from '../runtime/private-session.ts'; +import { + inboxResolutionSnapshot, + inboxResolverCurrentAfterSample, + type InboxResolver +} from './resolve-inbox.ts'; + +declare const accessBrand: unique symbol; +export type InboxAccessController = Readonly<{ [accessBrand]: true }>; +type Binding = Readonly<{ + owner: string; + preferenceId: string; + readTargets: string[]; + archiveTargets: string[]; +}>; +export type InboxAccessSnapshot = Readonly< + Binding & { + state: string; + busy: boolean; + cleanupRequired: boolean; + readiness: 'unavailable'; + auth: { origin: string; state: string; responses: number }[]; + } +>; +type Control = { + policy: RelayPolicy; + binding: string; + current(): boolean; + closed(): boolean; + cleanupRequired(): boolean; + snapshot(): InboxAccessSnapshot; + authenticate(origin: unknown, review: unknown): Promise<string>; + respond(origin: unknown, review: unknown): Promise<string>; + close(): boolean; +}; +const controllers = new WeakMap<InboxAccessController, Control>(); +const currentControllers = new WeakMap<PrivateSession, InboxAccessController>(); +function binding( + session: PrivateSession, + policy: RelayPolicy, + own: InboxResolver +): Binding | undefined { + try { + const capture = privateSessionOwnership(session), + head = inboxResolutionSnapshot(own); + const sources = publicRelayTargets(policy, 'read'); + const preference = head.head && inboxPreferenceSnapshot(head.head); + if ( + !capture?.current() || + !readRelayPolicy(policy).messagingEnabled || + head.author !== capture.owner || + head.status !== 'ready' || + head.coverage !== 'bounded-eose' || + !preference || + preference.status !== 'supported' || + preference.author !== capture.owner || + preference.id !== head.knownBase?.id || + preference.createdAt !== head.knownBase.createdAt || + !sources.length || + head.sources.length !== sources.length || + !sources.every((origin) => + head.sources.some( + (source) => source.source === origin && source.state === 'eose' + ) + ) + ) + return undefined; + const readTargets = inboxRelayTargets( + policy, + preference.relays, + 'read' + ).slice(); + const archiveTargets = inboxRelayTargets( + policy, + preference.relays, + 'write' + ).slice(); + if ( + !readTargets.length || + !archiveTargets.length || + !capture.current() || + !inboxResolverCurrentAfterSample(own) + ) + return undefined; + return { + owner: capture.owner, + preferenceId: preference.id, + readTargets, + archiveTargets + }; + } catch { + return undefined; + } +} +// Capture only genuine current discovery/session metadata. No socket, provider, +// AUTH, probe or publication occurs here. AUTH alone never grants readiness; +// the separate qualified access probe must supply that later capability. +export function createInboxAccessController( + session: PrivateSession, + policy: RelayPolicy, + own: InboxResolver +): InboxAccessController | undefined { + if (typeof window === 'undefined') return undefined; + const captured = binding(session, policy, own); + if (!captured) return undefined; + const initial = captured; + const wire = JSON.stringify(initial), + previous = currentControllers.get(session); + const prior = previous && controllers.get(previous); + if ( + prior && + !prior.closed() && + prior.current() && + prior.policy === policy && + prior.binding === wire + ) + return previous; + // Stale or failed disposal cannot be silently replaced by another capture. + if (prior && (!prior.closed() || prior.cleanupRequired())) return undefined; + const token = Object.freeze({}) as InboxAccessController; + const auth = new Map<string, InboxAuthAction>(); + let pool: PrivatePool | undefined, + closed = false, + cleaned = false, + busy = false, + epoch = 0, + phase = 'not_checked'; + let off = () => {}; + const current = () => + !closed && JSON.stringify(binding(session, policy, own)) === wire; + function close(): boolean { + closed = true; + epoch++; + phase = 'stopped'; + let failed = false; + for (const [origin, action] of auth) { + try { + closeInboxAuthentication(action); + auth.delete(origin); + } catch { + failed = true; + } + } + if (pool) { + try { + closePrivatePool(pool); + } catch { + failed = true; + } + if (privatePoolCleanupRequired(pool)) failed = true; + } + cleaned = !failed; + if (cleaned) off(); + return cleaned; + } + async function authenticate( + origin: unknown, + review: unknown + ): Promise<string> { + if ( + review !== 'reviewed_inbox_connection_auth' || + typeof origin !== 'string' || + !current() || + (!initial.readTargets.includes(origin) && + !initial.archiveTargets.includes(origin)) + ) + return 'unavailable'; + if (busy) return 'busy'; + const existing = auth.get(origin); + if (existing) return inboxAuthSnapshot(existing)?.state ?? 'stopped'; + busy = true; + const generation = epoch; + try { + pool ??= getPrivatePool( + session, + policy, + Array.from( + new Set([...initial.readTargets, ...initial.archiveTargets]) + ), + token, + 'access', + current + ); + if (!pool || !current()) return 'unavailable'; + const action = await beginInboxAuthentication( + pool, + origin, + 'reviewed_connection_auth' + ); + if (!action) return (phase = 'unavailable'); + if (!current() || generation !== epoch) { + closeInboxAuthentication(action); + return 'stopped'; + } + auth.set(origin, action); + phase = 'authenticating'; + return inboxAuthSnapshot(action)?.state ?? 'unavailable'; + } catch { + return (phase = closed ? 'stopped' : 'unavailable'); + } finally { + busy = false; + } + } + async function respond(origin: unknown, review: unknown): Promise<string> { + const action = typeof origin === 'string' && auth.get(origin); + if (!action || review !== 'reviewed_inbox_auth_response' || !current()) + return 'unavailable'; + if (busy) return 'busy'; + busy = true; + const generation = epoch; + try { + const result = await respondInboxAuthentication(action); + if (!current() || generation !== epoch) { + closeInboxAuthentication(action); + return 'stopped'; + } + phase = result.status; + return result.status; + } catch { + return (phase = closed ? 'stopped' : 'unavailable'); + } finally { + busy = false; + } + } + controllers.set(token, { + policy, + binding: wire, + current, + closed: () => closed, + cleanupRequired: () => + closed && (!cleaned || (!!pool && privatePoolCleanupRequired(pool))), + authenticate, + respond, + close, + snapshot: () => ({ + ...initial, + readTargets: [...initial.readTargets], + archiveTargets: [...initial.archiveTargets], + state: closed ? 'stopped' : current() ? phase : 'stale', + busy, + cleanupRequired: + closed && (!cleaned || (!!pool && privatePoolCleanupRequired(pool))), + readiness: 'unavailable', + auth: [...auth].map(([origin, action]) => ({ + origin, + state: inboxAuthSnapshot(action)?.state ?? 'stopped', + responses: inboxAuthSnapshot(action)?.responses ?? 0 + })) + }) + }); + off = subscribePrivateSessionClose(session, () => { + if (!close()) throw Error('inbox_access_cleanup_required'); + }); + if (!current()) { + close(); + return undefined; + } + currentControllers.set(session, token); + return token; +} +export function inboxAccessControllerSnapshot( + token: InboxAccessController +): InboxAccessSnapshot | undefined { + return controllers.get(token)?.snapshot(); +} +export function authenticateInboxAccess( + token: InboxAccessController, + origin: unknown, + review: unknown +): Promise<string> { + return ( + controllers.get(token)?.authenticate(origin, review) ?? + Promise.resolve('unavailable') + ); +} +export function respondInboxAccessAuthentication( + token: InboxAccessController, + origin: unknown, + review: unknown +): Promise<string> { + return ( + controllers.get(token)?.respond(origin, review) ?? + Promise.resolve('unavailable') + ); +} +export function closeInboxAccessController( + token: InboxAccessController +): boolean { + return controllers.get(token)?.close() ?? false; +} diff --git a/web/src/lib/messaging/inbox-sync.ts b/web/src/lib/messaging/inbox-sync.ts @@ -181,9 +181,16 @@ export function captureInboxSync( ); }; if (!current()) return undefined; - const pool = getPrivatePool(session, policy, targets); - if (!pool) return undefined; const token = Object.freeze({}) as InboxSync; + const pool = getPrivatePool( + session, + policy, + targets, + token, + 'receive', + current + ); + if (!pool) return undefined; let state: State = 'ready', candidates = 0, bytes = 0, @@ -398,7 +405,11 @@ export function captureInboxSync( queueMicrotask(() => { if (stopped || failed) return; if (!current()) { - stop(); + try { + stop(); + } catch { + /* Original incomplete cleanup remains retryable. */ + } return; } state = 'live'; diff --git a/web/src/lib/messaging/product-request-controller.ts b/web/src/lib/messaging/product-request-controller.ts @@ -67,7 +67,12 @@ import { selfRecoveryPreparationSnapshot, type SelfRecoveryPreparation } from './prepare-send.ts'; -import { getPrivatePool } from '../nostr/private-pool.ts'; +import { + getPrivatePool, + closePrivatePool, + privatePoolCleanupRequired, + type PrivatePool +} from '../nostr/private-pool.ts'; import { capturePrivateRetry, runPrivateRetry, @@ -75,7 +80,10 @@ import { type PrivateRetry } from './retry-send.ts'; import { newLocalId } from '../private-handles.ts'; -import { privateSessionOwnership } from '../runtime/private-session.ts'; +import { + privateSessionOwnership, + subscribePrivateSessionClose +} from '../runtime/private-session.ts'; declare const requestBrand: unique symbol; export type ProductRequestController = Readonly<{ [requestBrand]: true }>; @@ -142,6 +150,7 @@ export function createProductRequestController( let plan: RumorPlan | undefined, preparation: SelfRecoveryPreparation | undefined, retry: PrivateRetry | undefined; + let privateOff = () => {}; let identityOff = () => {}, generation = 0; const source = runtime && createPublicView(runtime); @@ -151,13 +160,29 @@ export function createProductRequestController( if (preserveComposer && composer) privateComposerSnapshot(composer); if (retry) stopPrivateRetry(retry); if (plan) stopRumorPlan(plan); + releasePool(); if (!preserveComposer) { if (composer) closePrivateComposer(composer); composer = undefined; } } - function close() { - if (!active) return; + let pool: PrivatePool | undefined; + let poolCleanupFailed = false; + function releasePool() { + if (!pool) return true; + try { + poolCleanupFailed = false; + closePrivatePool(pool); + if (privatePoolCleanupRequired(pool)) return false; + pool = undefined; + return true; + } catch { + poolCleanupFailed = true; + return false; + } + } + function close(sessionCleanup = false) { + if (!active && !pool) return; active = false; stopWork(); identityOff(); @@ -165,10 +190,20 @@ export function createProductRequestController( if (resolver) closeInboxResolver(resolver); if (source) disposePublicView(source); if (database) closeBrowserDatabase(database); + if (!releasePool()) { + if (poolCleanupFailed || sessionCleanup) + throw Error('private_delivery_cleanup_required'); + return; + } + privateOff(); } function current() { if (!active || !productEnquirySnapshot(enquiry)) { - close(); + try { + close(); + } catch { + /* Exact original disposal stays retryable. */ + } return false; } return true; @@ -483,14 +518,22 @@ export function createProductRequestController( !receipt ) return needsAction(); - const pool = getPrivatePool( + if (!releasePool()) return needsAction(); + pool = getPrivatePool( captured.own.session!, captured.own.policy, Array.from( new Set([...routeData.peer.targets, ...routeData.archive.targets]) - ) + ), + token, + 'delivery', + admitted ); if (!pool || !admitted()) return needsAction(); + privateOff(); + privateOff = subscribePrivateSessionClose(captured.own.session!, () => + close(true) + ); retry = capturePrivateRetry( repository, captured.own.session!, @@ -512,6 +555,7 @@ export function createProductRequestController( return admitted() ? needsAction() : { status: 'stopped' }; } finally { busy = false; + releasePool(); } } const token = Object.freeze({}) as ProductRequestController; diff --git a/web/src/lib/messaging/reply-controller.ts b/web/src/lib/messaging/reply-controller.ts @@ -50,7 +50,12 @@ import { selfRecoveryPreparationSnapshot, type SelfRecoveryPreparation } from './prepare-send.ts'; -import { getPrivatePool } from '../nostr/private-pool.ts'; +import { + getPrivatePool, + closePrivatePool, + privatePoolCleanupRequired, + type PrivatePool +} from '../nostr/private-pool.ts'; import { capturePrivateRetry, runPrivateRetry, @@ -132,19 +137,44 @@ export function createReplyController( retry: PrivateRetry | undefined; let identityOff = () => {}, privateOff = () => {}; - function close() { - if (!active) return; + let pool: PrivatePool | undefined; + let poolCleanupFailed = false; + function releasePool() { + if (!pool) return true; + try { + poolCleanupFailed = false; + closePrivatePool(pool); + if (privatePoolCleanupRequired(pool)) return false; + pool = undefined; + return true; + } catch { + poolCleanupFailed = true; + return false; + } + } + function close(sessionCleanup = false) { + if (!active && !pool) return; active = false; if (retry) stopPrivateRetry(retry); closePrivateComposer(composer!); if (plan) stopRumorPlan(plan); + const clean = releasePool(); + options.close?.(); + if (!clean) { + if (poolCleanupFailed || sessionCleanup) + throw Error('private_delivery_cleanup_required'); + return; + } identityOff(); privateOff(); - options.close?.(); } function current() { if (!active || !scope?.current() || !privateComposerSnapshot(composer!)) { - close(); + try { + close(); + } catch { + /* Exact original disposal stays retryable. */ + } return false; } return true; @@ -327,7 +357,15 @@ export function createReplyController( const origins = Array.from( new Set([...routeData.peer.targets, ...routeData.archive.targets]) ); - const pool = getPrivatePool(captured.session, setup.policy, origins); + if (!releasePool()) return needsAction(); + pool = getPrivatePool( + captured.session, + setup.policy, + origins, + token, + 'delivery', + admitted + ); if (!pool || !admitted()) return needsAction(); retry = capturePrivateRetry( captured.repository, @@ -350,6 +388,7 @@ export function createReplyController( return current() ? needsAction() : { status: 'stopped' }; } finally { busy = false; + releasePool(); } } const token = Object.freeze({}) as ReplyController; @@ -388,7 +427,9 @@ export function createReplyController( identityOff = subscribeIdentityInvalidation(original.identity, () => { if (!original.current()) close(); }); - privateOff = subscribePrivateSessionClose(original.session, close); + privateOff = subscribePrivateSessionClose(original.session, () => + close(true) + ); return current() ? token : undefined; } diff --git a/web/src/lib/nostr/inbox-ingress.ts b/web/src/lib/nostr/inbox-ingress.ts @@ -130,9 +130,16 @@ export function captureInboxIngress( ); }; if (!current()) return undefined; - const pool = getPrivatePool(session, policy, targets); - if (!pool) return undefined; const token = Object.freeze({}) as InboxIngress; + const pool = getPrivatePool( + session, + policy, + targets, + token, + 'receive', + current + ); + if (!pool) return undefined; let state: State = 'ready', candidates = 0, bytes = 0, diff --git a/web/src/lib/nostr/private-pool.ts b/web/src/lib/nostr/private-pool.ts @@ -108,6 +108,10 @@ function finiteBudget(): FiniteBudget { } }; } +type ScopedConnectionCleanup = Readonly<{ + current(): boolean; + close(): void; +}>; type Owner = { session: PrivateSession; policy: RelayPolicy; @@ -116,13 +120,22 @@ type Owner = { token: PrivatePool; closed(): boolean; cleaned(): boolean; + unavailable(): boolean; publish( permission: PrivatePublication, - signal: AbortSignal + signal: AbortSignal, + scopeCurrent?: () => boolean, + retainConnection?: ( + origin: string, + cleanup: ScopedConnectionCleanup + ) => boolean ): Promise<PrivateGiftWrapAttemptResult>; auth( origin: string, - admission: InboxAuthAdmission + admission: InboxAuthAdmission, + admittedPool?: PrivatePool, + scopeCurrent?: () => boolean, + retainCleanup?: (cleanup: () => void) => void ): Promise<PrivateAuthConnection | undefined>; subscribe( limit: number, @@ -130,9 +143,23 @@ type Owner = { since?: number, budget?: FiniteBudget, until?: number, - source?: string + source?: string, + reads?: readonly string[], + scopeCurrent?: () => boolean, + retainConnection?: ( + origin: string, + cleanup: ScopedConnectionCleanup + ) => boolean + ): () => void; + subscribeLive( + listener: (message: PrivateLiveMessage) => void, + reads?: readonly string[], + scopeCurrent?: () => boolean, + retainConnection?: ( + origin: string, + cleanup: ScopedConnectionCleanup + ) => boolean ): () => void; - subscribeLive(listener: (message: PrivateLiveMessage) => void): () => void; close(): void; }; declare const connectionBrand: unique symbol; @@ -159,17 +186,203 @@ type AuthControl = { const authConnections = new WeakMap<PrivateAuthConnection, AuthControl>(); const pools = new WeakMap<PrivatePool, Owner>(); let lifetime: Owner | undefined; +type ScopeRole = 'receive' | 'delivery' | 'access'; +const scopes = new WeakMap<Owner, WeakMap<object, Map<string, PrivatePool>>>(); +// Consumer identity is lexical workflow ownership, never a relay/access proof. +// Weak ownership retains at most45 bounded selections per live consumer. All +// selections share the one session SDK; ciphertext/plaintext is absent here. +function scopedPool( + base: Owner, + consumer: object, + selected: readonly string[], + role: ScopeRole, + authorized: () => boolean +): PrivatePool { + const consumers = + scopes.get(base) ?? new WeakMap<object, Map<string, PrivatePool>>(); + scopes.set(base, consumers); + const owned = consumers.get(consumer) ?? new Map<string, PrivatePool>(); + consumers.set(consumer, owned); + const key = JSON.stringify([role, selected]); + const previous = owned.get(key); + const prior = previous && pools.get(previous); + if (previous && prior && !prior.closed()) return previous; + if (prior && !prior.cleaned()) throw Error('private_pool_close_failed'); + const token = Object.freeze({}) as PrivatePool; + const origins = [...selected]; + const readOrigins = + role === 'delivery' + ? [] + : origins.filter((origin) => base.readOrigins.includes(origin)); + const life = new AbortController(); + const stops = new Map<symbol, () => void>(); + const authStops = new Map<string, () => void>(); + const connections = new Map<string, ScopedConnectionCleanup>(); + let closed = false, + cleaned = false; + const current = () => + !closed && + !base.closed() && + authorized() && + !!privateSessionOwnership(base.session)?.current() && + !closed && + !base.closed(); + function track(start: (ended: () => void) => () => void): () => void { + if (!current()) throw Error('private_pool_closed'); + const id = Symbol(); + let release = () => {}, + ended = false; + const stop = () => { + release(); + stops.delete(id); + }; + stops.set(id, stop); + try { + release = start(() => { + ended = true; + if (!base.unavailable()) stops.delete(id); + }); + if (ended && !base.unavailable()) stops.delete(id); + return stop; + } catch (error) { + stops.delete(id); + throw error; + } + } + function retainConnection(origin: string, cleanup: ScopedConnectionCleanup) { + const previous = connections.get(origin); + if (previous?.current()) return false; + previous?.close(); + connections.set(origin, cleanup); + return true; + } + const scope: Owner = { + session: base.session, + policy: base.policy, + origins, + readOrigins, + token, + closed: () => closed || base.closed(), + cleaned: () => (cleaned && !base.unavailable()) || base.cleaned(), + unavailable: () => base.unavailable() || (closed && !cleaned), + publish(permission, signal) { + const view = privatePublicationSnapshot(permission); + return current() && view && origins.includes(view.origin) + ? base.publish( + permission, + AbortSignal.any([signal, life.signal]), + current, + retainConnection + ) + : Promise.resolve({ status: 'stopped' }); + }, + async auth(origin, admission) { + if (!current() || !origins.includes(origin)) return undefined; + const connection = await base.auth( + origin, + admission, + token, + current, + (cleanup) => { + authStops.set(origin, cleanup); + } + ); + if (!connection) return undefined; + if (!current()) { + closePrivateAuthConnection(connection); + return undefined; + } + authStops.set(origin, () => closePrivateAuthConnection(connection)); + return connection; + }, + subscribe(limit, listener, since, budget, until, source) { + return track((ended) => + base.subscribe( + limit, + (message) => { + if (message.type === 'end') ended(); + listener(message); + }, + since, + budget, + until, + source, + readOrigins, + current, + retainConnection + ) + ); + }, + subscribeLive(listener) { + return track((ended) => + base.subscribeLive( + (message) => { + if (message.type === 'end') ended(); + listener(message); + }, + readOrigins, + current, + retainConnection + ) + ); + }, + close() { + closed = true; + life.abort(); + let failed = false; + for (const [id, stop] of stops) { + try { + stop(); + stops.delete(id); + } catch { + failed = true; + } + } + for (const [origin, stop] of authStops) { + try { + stop(); + authStops.delete(origin); + } catch { + failed = true; + } + } + for (const [origin, connection] of connections) { + try { + connection.close(); + connections.delete(origin); + } catch { + failed = true; + } + } + cleaned = !failed; + if (failed) throw Error('private_pool_close_failed'); + } + }; + pools.set(token, scope); + owned.set(key, token); + return token; +} // Fixed scope selection is not authenticated owner10050 membership/readiness. // No production receive workflow calls this until its later inbox owner exists. export function getPrivatePool( session: PrivateSession, policy: RelayPolicy, - selected: readonly string[] + selected: readonly string[], + consumer: object = session, + role: ScopeRole = 'receive', + authorized: () => boolean = () => true ): PrivatePool | undefined { if (typeof window === 'undefined') return undefined; const captured = privateSessionOwnership(session); if (!captured) throw new Error('private_session_invalid'); const capture = captured; + if ( + !consumer || + typeof consumer !== 'object' || + !['receive', 'delivery', 'access'].includes(role) || + typeof authorized !== 'function' + ) + throw Error('private_pool_scope_invalid'); const manifest = readRelayPolicy(policy); if (!manifest.messagingEnabled) throw new Error('private_pool_disabled'); const length = Array.isArray(selected) ? selected.length : 0; @@ -189,7 +402,10 @@ export function getPrivatePool( throw new Error('private_pool_origins_invalid'); selectedOrigins.set(origin, true); } - const origins = [...selectedOrigins.keys()]; + const selectedTargets = [...selectedOrigins.keys()]; + // SDK identity is fixed by the entire bounded manifest, while each consumer + // retains only its reviewed role/targets. No connection opens on acquisition. + const origins = manifest.inbox.map((row) => row.origin); const readOrigins = origins.filter((origin) => manifest.inbox.some((row) => row.origin === origin && row.read) ); @@ -197,15 +413,11 @@ export function getPrivatePool( if (!capture.current()) throw new Error('private_session_invalid'); if (lifetime) { if (!lifetime.cleaned()) { - if (lifetime.closed()) throw new Error('private_pool_closed'); - if ( - lifetime.session !== session || - lifetime.policy !== policy || - lifetime.origins.length !== origins.length || - lifetime.origins.some((origin, i) => origin !== origins[i]) - ) + if (lifetime.closed() || lifetime.unavailable()) + throw new Error('private_pool_closed'); + if (lifetime.session !== session || lifetime.policy !== policy) throw new Error('private_pool_in_use'); - return lifetime.token; + return scopedPool(lifetime, consumer, selectedTargets, role, authorized); } } const token = Object.freeze({}) as PrivatePool; @@ -220,9 +432,146 @@ export function getPrivatePool( liveCleanupRequired = false; let off = () => {}; const authCleanup = new Map<string, () => void>(); + const authFailed = new Map<string, true>(); + const authRetiring = new Map<string, true>(); const publicationStops = new Map<() => void, true>(); let publishing = false, publicationCleanupRequired = false; + type Connection = Readonly<{ + retiring(): boolean; + retire(): void; + reserve(): Readonly<{ + relay: ReturnType<typeof sdk.relay>; + start(): void; + close(): void; + retire(): void; + pending(): boolean; + current(): boolean; + }>; + }>; + const connections = new Map<string, Connection>(); + function leaseConnection(origin: string) { + const previous = connections.get(origin); + if (previous) { + if (previous.retiring()) throw Error('private_connection_close_pending'); + return previous.reserve(); + } + const relay = sdk.relay(origin); + let references = 0, + started = false, + physicallyClosed = false, + retiring = false, + disposed = false, + releaseBridge = () => {}, + unwatch = () => {}; + function retire() { + if (disposed) return; + retiring = true; + releaseBridge(); + sdk.remove(relay); + if (started && !physicallyClosed) return; + unwatch(); + disposed = true; + if (connections.get(origin) === original) connections.delete(origin); + } + const original: Connection = { + retiring: () => retiring, + retire, + reserve() { + references++; + let released = false; + return { + relay, + start() { + if ( + released || + closed || + retiring || + disposed || + !capture.current() + ) + throw Error('private_connection_closed'); + if (started) return; + started = true; + let starting = true, + opened = false, + noSocket = false; + const open = relay.open$.subscribe(() => { + opened = true; + }); + function startupFailure() { + if (!starting || opened || noSocket) return; + noSocket = true; + started = false; + retiring = true; + queueMicrotask(() => { + try { + retire(); + } catch { + /* Retry retained. */ + } + }); + } + const error = relay.error$.subscribe((failure) => { + // Original NEVER/no filters cannot receive a remote callback + // before this synchronous subscribe returns. Only a native + // constructor failure proves no physical socket in that stack. + if (failure) startupFailure(); + }); + const bridge = relay + .req(NEVER, { + waitForAuth: false, + reconnect: false, + resubscribe: false + }) + .subscribe({ + error() { + startupFailure(); + if (!noSocket) { + retiring = true; + queueMicrotask(() => { + try { + retire(); + } catch { + /* Actual closure still required. */ + } + }); + } + } + }); + starting = false; + open.unsubscribe(); + error.unsubscribe(); + releaseBridge = () => bridge.unsubscribe(); + if (noSocket) throw Error('private_connection_start_failed'); + }, + close() { + if (!released) { + released = true; + references--; + } + // Cancel keepAlive's zero timer before a closing socket can reopen. + if (references === 0) retire(); + }, + retire, + pending: () => started && !physicallyClosed && !disposed, + current: () => !retiring && !disposed + }; + } + }; + connections.set(origin, original); + const lost = relay.close$.subscribe(() => { + physicallyClosed = true; + try { + retire(); + if (closed) owner.close(); + } catch { + /* Original physical retirement remains retryable. */ + } + }); + unwatch = () => lost.unsubscribe(); + return original.reserve(); + } const owner: Owner = { session, policy, @@ -231,18 +580,36 @@ export function getPrivatePool( token, closed: () => closed, cleaned: () => cleaned, - async publish(permission, signal) { - const view = privatePublicationSnapshot(permission); + unavailable: () => + cleanupRequired || + liveCleanupRequired || + publicationCleanupRequired || + authFailed.size !== 0 || + authRetiring.size !== 0 || + [...connections.values()].some((connection) => connection.retiring()), + async publish( + permission, + signal, + scopeCurrent = () => true, + retainConnection + ) { + const observed = privatePublicationSnapshot(permission); + if (!observed) return { status: 'stopped' }; + const view = observed; if ( - !view || publishing || closed || cleanupRequired || publicationCleanupRequired || signal.aborted || + !scopeCurrent() || !capture.current() || + authRetiring.has(view.origin) || + authFailed.has(view.origin) || view.owner !== capture.owner || !origins.includes(view.origin) || + authRetiring.has(view.origin) || + authFailed.has(view.origin) || !manifest.inbox.some( ({ origin: allowed, write }) => allowed === view.origin && write ) || @@ -257,14 +624,25 @@ export function getPrivatePool( !(await recheckPrivateSession(session)) || closed || signal.aborted || - !capture.current() + !scopeCurrent() || + !capture.current() || + authRetiring.has(view.origin) || + authFailed.has(view.origin) ) return { status: 'stopped' }; return await navigator.locks.request( 'harvestcircle:owner:' + capture.owner, { mode: 'exclusive', ifAvailable: true }, async (lock) => { - if (!lock || closed || signal.aborted || !capture.current()) + if ( + !lock || + closed || + signal.aborted || + !scopeCurrent() || + !capture.current() || + authRetiring.has(view.origin) || + authFailed.has(view.origin) + ) return { status: 'stopped' as const }; const admitted = await takePrivatePublication( permission, @@ -276,41 +654,63 @@ export function getPrivatePool( !admitted || closed || signal.aborted || + !scopeCurrent() || !capture.current() || + authRetiring.has(view.origin) || + authFailed.has(view.origin) || !admitted.current() ) return { status: 'stopped' as const }; + const connection = leaseConnection(view.origin); const network = admitted.beginNetwork(); - if (admitted.networkMetered && !network) + if (admitted.networkMetered && !network) { + connection.close(); return { status: 'stopped' as const }; + } + if ( + !scopeCurrent() || + !capture.current() || + closed || + signal.aborted || + authRetiring.has(view.origin) || + authFailed.has(view.origin) + ) { + network?.finish(); + connection.close(); + return { status: 'stopped' as const }; + } return await new Promise<PrivateGiftWrapAttemptResult>( (resolve) => { let ended = false, attempted = false, release = () => {}, - fenceTimer: ReturnType<typeof setTimeout> | undefined; + fenceTimer: ReturnType<typeof setTimeout> | undefined, + timer: ReturnType<typeof setTimeout> | undefined, + retainedConnection = false; function finish( status: PrivateGiftWrapAttemptResult['status'] ) { if (ended) return; ended = true; network?.finish(); - clearTimeout(timer); + if (timer !== undefined) clearTimeout(timer); if (fenceTimer !== undefined) clearTimeout(fenceTimer); signal.removeEventListener('abort', stop); try { release(); + if (!retainedConnection) connection.close(); publicationStops.delete(stop); } catch { publicationCleanupRequired = true; status = 'unknown'; } + if (!attempted) status = 'stopped'; const result: PrivateGiftWrapAttemptResult = { status, role: admitted!.role, origin: admitted!.origin, eventId: admitted!.eventId, - ...(network + ...(attempted && network ? { actionId: network.actionId, attempt: network.attempt } : {}) }; @@ -337,6 +737,7 @@ export function getPrivatePool( function stop() { if (ended) { release(); + if (!retainedConnection) connection.close(); publicationStops.delete(stop); return; } @@ -351,7 +752,10 @@ export function getPrivatePool( if ( closed || signal.aborted || + !scopeCurrent() || !capture.current() || + authRetiring.has(view.origin) || + authFailed.has(view.origin) || !admitted!.current() ) { finish('stopped'); @@ -359,22 +763,26 @@ export function getPrivatePool( } fenceTimer = setTimeout(() => fence(), 50); } - const relay = sdk.relay(view.origin); - const allowance = - network?.remaining() ?? - PRIVATE_PUBLICATION_BUDGETS.networkActionMilliseconds; - const timeout = - Number.isFinite(relay.eventTimeout) && relay.eventTimeout > 0 - ? Math.min(allowance, relay.eventTimeout) - : allowance; - const timer = setTimeout(() => finish('timed_out'), timeout); - signal.addEventListener('abort', stop, { once: true }); - publicationStops.set(stop, true); try { + const relay = connection.relay; + const allowance = + network?.remaining() ?? + PRIVATE_PUBLICATION_BUDGETS.networkActionMilliseconds; + const timeout = + Number.isFinite(relay.eventTimeout) && + relay.eventTimeout > 0 + ? Math.min(allowance, relay.eventTimeout) + : allowance; + timer = setTimeout(() => finish('timed_out'), timeout); + signal.addEventListener('abort', stop, { once: true }); + publicationStops.set(stop, true); if ( closed || signal.aborted || + !scopeCurrent() || !capture.current() || + authRetiring.has(view.origin) || + authFailed.has(view.origin) || !admitted.current() ) { finish('stopped'); @@ -382,6 +790,12 @@ export function getPrivatePool( } // The only private EVENT port accepts the freshly read-back1059; // no caller event, key, relay template or SDK option crosses it. + connection.start(); + retainedConnection = + retainConnection?.(view.origin, { + current: connection.current, + close: connection.close + }) ?? false; attempted = true; const subscription = relay .event(admitted.event, 'EVENT') @@ -430,17 +844,25 @@ export function getPrivatePool( publishing = false; } }, - async auth(origin, admission) { + async auth( + origin, + admission, + admittedPool = token, + scopeCurrent = () => true, + retainCleanup = () => {} + ) { if ( closed || cleanupRequired || !origins.includes(origin) || - !readOrigins.includes(origin) || + !scopeCurrent() || + authFailed.size !== 0 || authCleanup.has(origin) || + authRetiring.has(origin) || !capture.current() ) return undefined; - if (!takeInboxAuthAdmission(admission, owner.token, origin)) + if (!takeInboxAuthAdmission(admission, admittedPool, origin)) return undefined; // Reserve before any provider job. No duplicate reviewed action may reset // a live connection's response admission counter. @@ -453,26 +875,50 @@ export function getPrivatePool( let reservation: PrivateAuthChallenge | undefined; let sent = false; const releases = new Map<symbol, () => void>(); + let retireRelay = () => {}; + let disposed = false; + let pendingClose = () => false; + let closeWatch = () => {}; function cleanup() { + if (disposed) return; stopped = true; challenge = undefined; generation = undefined; let failed = false; - for (const release of releases.values()) { + for (const [id, release] of releases) { try { release(); + releases.delete(id); } catch { failed = true; } } - if (failed) throw new Error('private_auth_cleanup_required'); + try { + retireRelay(); + } catch { + failed = true; + } + if (failed) { + authFailed.set(origin, true); + throw new Error('private_auth_cleanup_required'); + } + if (pendingClose()) { + authRetiring.set(origin, true); + return; + } + closeWatch(); + disposed = true; + authCleanup.delete(origin); + authFailed.delete(origin); + authRetiring.delete(origin); } authCleanup.set(origin, cleanup); + retainCleanup(cleanup); const halt = () => { if (stopped) return; stopped = true; try { - owner.close(); + cleanup(); } catch { /* Actual control retained for retry. */ } @@ -481,177 +927,223 @@ export function getPrivatePool( !(await recheckPrivateSession(session)) || closed || stopped || + !scopeCurrent() || !capture.current() ) { halt(); return undefined; } - const relay = sdk.relay(origin); - const token = Object.freeze({}) as PrivateAuthConnection; - // A private page may already own this actual SDK connection. Its open$ - // Subject does not replay; initialize from its genuine connected state. - if (relay.connected$.value) generation = Symbol(); - function current() { - return ( - !stopped && !closed && capture.current() && generation !== undefined - ); - } - const control: AuthControl = { - invalidate(proof) { - if ( - !proofs.has(proof) || - !proof.current() || - !current() || - proof.connection !== generation || - proof.challenge !== challenge - ) - return false; - return invalidatePrivateSessionGeneration(session); - }, - stopped: () => !current(), - challenge() { - if (!current() || challenge === undefined || responded) - return undefined; - const exact = challenge, - stamp = generation!; - const proof: PrivateAuthChallenge = { - owner: capture.owner, - session: capture.session, - connection: stamp, - relay: relay.url, - challenge: exact, - current: () => - current() && generation === stamp && challenge === exact - }; - proofs.set(proof, true); - return proof; - }, - reserve(proof) { - if ( - !proofs.has(proof) || - reservation !== undefined || - !proof.current() || - !current() || - responded || - proof.connection !== generation || - proof.challenge !== challenge || - responses >= PRIVATE_AUTH_BUDGETS.responsesPerConnectionAction - ) - return false; - responses++; - reservation = proof; - sent = false; - return true; - }, - async send(proof, approved) { - const wire = takeGuardedInboxAuthResponse(approved, proof); - const verified = verifyEnvelope(wire); - const event = verified.ok - ? verifiedEnvelopeSnapshot(verified.value) - : undefined; - if ( - !proofs.has(proof) || - reservation !== proof || - sent || - !event || - event.kind !== 22242 || - event.pubkey !== capture.owner || - event.content !== '' || - JSON.stringify(event.tags) !== - JSON.stringify([ - ['relay', relay.url], - ['challenge', proof.challenge] - ]) || - !proof.current() || - !current() || - proof.connection !== generation || - proof.challenge !== challenge - ) - return 'stopped'; - try { - sent = true; - const response = await relay.auth(event); - if (!proof.current() || !current()) return 'stopped'; - if (response.ok) { - responded = true; - return 'accepted'; + try { + const connection = leaseConnection(origin); + retireRelay = () => { + connection.close(); + connection.retire(); + }; + const actualRelay = connection.relay; + pendingClose = connection.pending; + const token = Object.freeze({}) as PrivateAuthConnection; + // A private page may already own this actual SDK connection. Its open$ + // Subject does not replay; initialize from its genuine connected state. + if (actualRelay.connected$.value) generation = Symbol(); + function current() { + return ( + !stopped && + !closed && + scopeCurrent() && + capture.current() && + generation !== undefined + ); + } + const control: AuthControl = { + invalidate(proof) { + if ( + !proofs.has(proof) || + !proof.current() || + !current() || + proof.connection !== generation || + proof.challenge !== challenge + ) + return false; + return invalidatePrivateSessionGeneration(session); + }, + stopped: () => !current(), + challenge() { + if (!current() || challenge === undefined || responded) + return undefined; + const exact = challenge, + stamp = generation!; + const proof: PrivateAuthChallenge = { + owner: capture.owner, + session: capture.session, + connection: stamp, + relay: actualRelay.url, + challenge: exact, + current: () => + current() && generation === stamp && challenge === exact + }; + proofs.set(proof, true); + return proof; + }, + reserve(proof) { + if ( + !proofs.has(proof) || + reservation !== undefined || + !proof.current() || + !current() || + responded || + proof.connection !== generation || + proof.challenge !== challenge || + responses >= PRIVATE_AUTH_BUDGETS.responsesPerConnectionAction + ) + return false; + responses++; + reservation = proof; + sent = false; + return true; + }, + async send(proof, approved) { + const wire = takeGuardedInboxAuthResponse(approved, proof); + const verified = verifyEnvelope(wire); + const event = verified.ok + ? verifiedEnvelopeSnapshot(verified.value) + : undefined; + if ( + !proofs.has(proof) || + reservation !== proof || + sent || + !event || + event.kind !== 22242 || + event.pubkey !== capture.owner || + event.content !== '' || + JSON.stringify(event.tags) !== + JSON.stringify([ + ['relay', actualRelay.url], + ['challenge', proof.challenge] + ]) || + !proof.current() || + !current() || + proof.connection !== generation || + proof.challenge !== challenge + ) + return 'stopped'; + try { + sent = true; + const response = await actualRelay.auth(event); + if (!proof.current() || !current()) return 'stopped'; + if (response.ok) { + responded = true; + return 'accepted'; + } + const outcome = + response.message === 'Timeout' ? 'unknown' : 'refused'; + halt(); + return outcome; + } catch { + halt(); + return 'unknown'; } - const outcome = - response.message === 'Timeout' ? 'unknown' : 'refused'; - halt(); - return outcome; + }, + close: cleanup + }; + authConnections.set(token, control); + const opened = actualRelay.open$.subscribe(() => { + if (!stopped && !closed && capture.current()) generation = Symbol(); + }); + releases.set(Symbol(), () => opened.unsubscribe()); + const lost = actualRelay.close$.subscribe(() => { + halt(); + try { + cleanup(); + if (closed) owner.close(); } catch { + /* Keep owned disposal retryable. */ + } + }); + closeWatch = () => lost.unsubscribe(); + const closing = actualRelay.closing$.subscribe(halt); + releases.set(Symbol(), () => closing.unsubscribe()); + const challenges = actualRelay.challenge$.subscribe((next: unknown) => { + if (stopped || closed || !capture.current()) { halt(); - return 'unknown'; + return; } - }, - close: () => owner.close() - }; - authConnections.set(token, control); - const opened = relay.open$.subscribe(() => { - if (!stopped && !closed && capture.current()) generation = Symbol(); - }); - releases.set(Symbol(), () => opened.unsubscribe()); - const lost = relay.close$.subscribe(halt); - releases.set(Symbol(), () => lost.unsubscribe()); - const closing = relay.closing$.subscribe(halt); - releases.set(Symbol(), () => closing.unsubscribe()); - const challenges = relay.challenge$.subscribe((next: unknown) => { - if (stopped || closed || !capture.current()) { - halt(); - return; + if (next === null) return; + if ( + typeof next !== 'string' || + !next || + !boundedEnvelopeTags([ + ['relay', actualRelay.url], + ['challenge', next] + ]) || + !generation + ) { + halt(); + return; + } + if (next === challenge) return; + if ( + responses >= PRIVATE_AUTH_BUDGETS.responsesPerConnectionAction || + (challenge !== undefined && !responded) + ) { + halt(); + return; + } + challenge = next; + responded = false; + reservation = undefined; + }); + releases.set(Symbol(), () => challenges.unsubscribe()); + if (closed || stopped || !capture.current()) { + cleanup(); + return undefined; } - if (next === null) return; - if ( - typeof next !== 'string' || - !next || - !boundedEnvelopeTags([ - ['relay', relay.url], - ['challenge', next] - ]) || - !generation - ) { - halt(); - return; + // Official Observable filter input holds the watchTower without emitting + // a filter/REQ. Its own CLOSE at teardown is ordinary SDK control cleanup. + connection.start(); + const hold = actualRelay + .req(NEVER, { + waitForAuth: false, + reconnect: false, + resubscribe: false + }) + .subscribe({ error: halt, complete: halt }); + releases.set(Symbol(), () => hold.unsubscribe()); + if (closed || stopped || !capture.current()) { + cleanup(); + return undefined; } - if (next === challenge) return; - if ( - responses >= PRIVATE_AUTH_BUDGETS.responsesPerConnectionAction || - (challenge !== undefined && !responded) - ) { - halt(); - return; + return token; + } catch { + try { + cleanup(); + } catch { + /* Original failed cleanup retained. */ } - challenge = next; - responded = false; - reservation = undefined; - }); - releases.set(Symbol(), () => challenges.unsubscribe()); - if (closed || stopped || !capture.current()) { - cleanup(); - owner.close(); - return undefined; - } - // Official Observable filter input holds the watchTower without emitting - // a filter/REQ. Its own CLOSE at teardown is ordinary SDK control cleanup. - const hold = relay - .req(NEVER, { - waitForAuth: false, - reconnect: false, - resubscribe: false - }) - .subscribe({ error: halt, complete: halt }); - releases.set(Symbol(), () => hold.unsubscribe()); - if (closed || stopped || !capture.current()) { - cleanup(); - owner.close(); return undefined; } - return token; }, - subscribeLive(listener) { - if (!readOrigins.length) throw Error('private_read_origins_unavailable'); - if (closed || !capture.current()) throw Error('private_pool_closed'); + subscribeLive( + listener, + reads = readOrigins, + scopeCurrent = () => true, + retainConnection + ) { + if (!reads.length) throw Error('private_read_origins_unavailable'); + if ( + reads.some( + (origin) => authRetiring.has(origin) || authFailed.has(origin) + ) + ) + throw Error('private_auth_cleanup_required'); + if ( + closed || + !scopeCurrent() || + !capture.current() || + reads.some( + (origin) => authRetiring.has(origin) || authFailed.has(origin) + ) + ) + throw Error('private_pool_closed'); if (liveBusy || liveCleanupRequired) throw Error('private_live_busy'); liveBusy = true; let ended = false, @@ -659,6 +1151,14 @@ export function getPrivatePool( serial = 0; const opened = new Map<string, true>(), meters = new Map<string, Map<number, { at: number; bytes: number }>>(); + const leased = new Map<string, ReturnType<typeof leaseConnection>>(); + function releaseAll() { + release(); + for (const [origin, connection] of leased) { + connection.close(); + leased.delete(origin); + } + } function emit(message: PrivateLiveMessage) { try { listener(message); @@ -672,7 +1172,7 @@ export function getPrivatePool( ) { if (ended) { if (liveCleanupRequired && propagate) { - release(); + releaseAll(); liveCleanupRequired = false; liveBusy = false; } @@ -681,7 +1181,7 @@ export function getPrivatePool( ended = true; let failure: unknown; try { - release(); + releaseAll(); liveCleanupRequired = false; liveBusy = false; } catch (error) { @@ -695,43 +1195,66 @@ export function getPrivatePool( } liveActive = () => { finish('closed', true); - release(); + releaseAll(); }; void recheckPrivateSession(session) .then((fresh) => { if (ended) return; - if (!fresh || closed || !capture.current()) { + if ( + !fresh || + closed || + !scopeCurrent() || + !capture.current() || + reads.some( + (origin) => authRetiring.has(origin) || authFailed.has(origin) + ) + ) { finish('stale'); return; } - const subscription = sdk - .req( - [...readOrigins], - [...privateInboxQueries(capture.owner, 'live')], - { - waitForAuth: false, - reconnect: false, - resubscribe: false - } + for (const origin of reads) { + const connection = leaseConnection(origin); + leased.set(origin, connection); + connection.start(); + if ( + retainConnection?.(origin, { + current: connection.current, + close: connection.close + }) ) + leased.delete(origin); + } + const subscription = sdk + .req([...reads], [...privateInboxQueries(capture.owner, 'live')], { + waitForAuth: false, + reconnect: false, + resubscribe: false + }) .subscribe({ next(message) { if (ended) return; - if (closed || !capture.current()) { + if ( + closed || + !scopeCurrent() || + !capture.current() || + reads.some( + (origin) => + authRetiring.has(origin) || authFailed.has(origin) + ) + ) { finish('stale'); return; } const origin = message.from.endsWith('/') ? message.from.slice(0, -1) : message.from; - if (!readOrigins.includes(origin)) { + if (!reads.includes(origin)) { finish('error'); return; } if (message.type === 'OPEN') { opened.set(origin, true); - if (opened.size === readOrigins.length) - emit({ type: 'open' }); + if (opened.size === reads.length) emit({ type: 'open' }); } else if (message.type === 'EVENT') { const now = performance.now(); let meter = meters.get(origin); @@ -780,8 +1303,16 @@ export function getPrivatePool( complete: () => finish('closed') }); release = () => subscription.unsubscribe(); - if (ended || closed || !capture.current()) { - release(); + if ( + ended || + closed || + !scopeCurrent() || + !capture.current() || + reads.some( + (origin) => authRetiring.has(origin) || authFailed.has(origin) + ) + ) { + releaseAll(); if (!ended) finish('stale'); } }) @@ -790,15 +1321,38 @@ export function getPrivatePool( }); return () => finish('stopped', true); }, - subscribe(limit, listener, since, sharedBudget, until, source) { + subscribe( + limit, + listener, + since, + sharedBudget, + until, + source, + reads = readOrigins, + scopeCurrent = () => true, + retainConnection + ) { const targets = source === undefined - ? readOrigins - : readOrigins.filter((origin) => origin === source); + ? reads + : reads.filter((origin) => origin === source); if (targets.length === 0) throw new Error('private_read_origins_unavailable'); - if (closed || !capture.current()) { - owner.close(); + if ( + targets.some( + (origin) => authRetiring.has(origin) || authFailed.has(origin) + ) + ) + throw Error('private_auth_cleanup_required'); + if ( + closed || + !scopeCurrent() || + !capture.current() || + targets.some( + (origin) => authRetiring.has(origin) || authFailed.has(origin) + ) + ) { + if (closed || !capture.current()) owner.close(); throw new Error('private_pool_closed'); } if (cleanupRequired) throw new Error('private_page_cleanup_required'); @@ -811,6 +1365,14 @@ export function getPrivatePool( let timer: ReturnType<typeof setTimeout> | undefined; const completed = new Map<string, true>(); let started = 0; + const leased = new Map<string, ReturnType<typeof leaseConnection>>(); + function releaseAll() { + release(); + for (const [origin, connection] of leased) { + connection.close(); + leased.delete(origin); + } + } function emit(message: PrivatePageMessage) { try { listener(message); @@ -824,7 +1386,7 @@ export function getPrivatePool( ) { if (ended) { if (cleanupRequired && propagate) { - release(); + releaseAll(); cleanupRequired = false; busy = false; } @@ -835,7 +1397,7 @@ export function getPrivatePool( if (timer !== undefined) clearTimeout(timer); let failure: unknown; try { - release(); + releaseAll(); } catch (error) { cleanupRequired = true; failure = error; @@ -855,14 +1417,22 @@ export function getPrivatePool( } active = () => { finish('closed', true); - release(); + releaseAll(); }; // Reserve the page before awaiting fresh extension ownership. Stop/logout // fence the continuation and no socket may open from a stale key result. void recheckPrivateSession(session) .then((fresh) => { if (ended) return; - if (!fresh || closed || !capture.current()) { + if ( + !fresh || + closed || + !scopeCurrent() || + !capture.current() || + targets.some( + (origin) => authRetiring.has(origin) || authFailed.has(origin) + ) + ) { finish('stale'); return; } @@ -871,10 +1441,30 @@ export function getPrivatePool( return; } started = performance.now(); - if (ended || closed || !capture.current()) { + if ( + ended || + closed || + !scopeCurrent() || + !capture.current() || + targets.some( + (origin) => authRetiring.has(origin) || authFailed.has(origin) + ) + ) { if (!ended) finish('stale'); return; } + for (const origin of targets) { + const connection = leaseConnection(origin); + leased.set(origin, connection); + connection.start(); + if ( + retainConnection?.(origin, { + current: connection.current, + close: connection.close + }) + ) + leased.delete(origin); + } const subscription = sdk .req( [...targets], @@ -893,15 +1483,44 @@ export function getPrivatePool( .subscribe({ next(message) { if (ended) return; - if (closed || !capture.current()) { + if ( + closed || + !scopeCurrent() || + !capture.current() || + targets.some( + (origin) => + authRetiring.has(origin) || authFailed.has(origin) + ) + ) { finish('stale'); - owner.close(); + if (closed || !capture.current()) { + try { + owner.close(); + } catch { + /* Original session cleanup retains pending/failure. */ + } + } return; } const elapsed = budget.elapsed() + performance.now() - started; - if (ended || closed || !capture.current()) { + if ( + ended || + closed || + !scopeCurrent() || + !capture.current() || + targets.some( + (origin) => + authRetiring.has(origin) || authFailed.has(origin) + ) + ) { if (!ended) finish('stale'); - owner.close(); + if (closed || !capture.current()) { + try { + owner.close(); + } catch { + /* Original session cleanup retains pending/failure. */ + } + } return; } if (elapsed >= PRIVATE_TRANSPORT_BUDGETS.pageMilliseconds) { @@ -941,8 +1560,16 @@ export function getPrivatePool( release = () => { subscription.unsubscribe(); }; - if (ended || closed || !capture.current()) { - release(); + if ( + ended || + closed || + !scopeCurrent() || + !capture.current() || + targets.some( + (origin) => authRetiring.has(origin) || authFailed.has(origin) + ) + ) { + releaseAll(); if (!ended) finish('stale'); } else { timer = setTimeout( @@ -987,11 +1614,20 @@ export function getPrivatePool( failed = true; } } + for (const connection of connections.values()) { + try { + connection.retire(); + } catch { + failed = true; + } + } try { sdk.close(); } catch { failed = true; } + if (!failed && (authRetiring.size !== 0 || connections.size !== 0)) + throw Error('private_pool_close_pending'); if (!failed) { cleanupRequired = false; cleaned = true; @@ -1009,7 +1645,7 @@ export function getPrivatePool( owner.close(); throw new Error('private_session_invalid'); } - return token; + return scopedPool(owner, consumer, selectedTargets, role, authorized); } function ownerOf(token: PrivatePool): Owner { const owner = pools.get(token); @@ -1019,6 +1655,9 @@ function ownerOf(token: PrivatePool): Owner { export function privatePoolOrigins(token: PrivatePool): readonly string[] { return [...ownerOf(token).origins]; } +export function privatePoolCleanupRequired(token: PrivatePool): boolean { + return ownerOf(token).unavailable(); +} export function subscribePrivatePage( token: PrivatePool, requested: number, diff --git a/web/tests/e2e/harness/history-cursor.ts b/web/tests/e2e/harness/history-cursor.ts @@ -62,12 +62,38 @@ export async function makeFixture( 'reviewed_private_session' ); if (!session) throw Error('missing genuine session'); + const capturedSession = session; const capture = privateSessionOwnership(session)!; const unlocked = captureUnlockedSession(session, 'reviewed_messages_unlock'); if (!unlocked) throw Error('missing genuine unlock'); const publicStore = getPublicStore()!; const self = (await f.row())!.record.self; let ingress: InboxSync | undefined; + async function retireOriginalSync() { + for (;;) { + let incomplete = false; + try { + if (ingress) stopInboxSync(ingress); + } catch (error) { + if ( + !(error instanceof Error) || + error.message !== 'private_inbox_cleanup_required' + ) + throw error; + incomplete = true; + } + const sessionClean = closePrivateSession(capturedSession); + if (!incomplete && sessionClean) { + if (ingress && inboxSyncSnapshot(ingress)?.cleanupRequired) + throw Error('actual original sync cleanup remains incomplete'); + return; + } + // Retry exact original disposal after its actual SDK close observers; + // this wait starts no retrieval, permission or replacement session. + await new Promise<void>((resolve) => setTimeout(resolve, 0)); + } + } + let authorized = true; let restoreFault = () => {}; let releaseKey: (() => void) | undefined; @@ -135,9 +161,7 @@ export async function makeFixture( if (!ingress) return false; return startInboxSync(ingress, review); }, - stop() { - if (ingress) stopInboxSync(ingress); - }, + stop: retireOriginalSync, snapshot: () => ingress && inboxSyncSnapshot(ingress), async stored(id = self.eventId) { const row = await loadPrivateRecord( @@ -153,9 +177,7 @@ export async function makeFixture( closeUnlock() { closeUnlockedSession(unlocked); }, - navigateAway() { - if (ingress) stopInboxSync(ingress); - }, + navigateAway: retireOriginalSync, changeKey() { f.mode('changed_key'); }, @@ -237,13 +259,13 @@ export async function makeFixture( IDBIndex.prototype.openCursor = cursor; }; }, - close() { + async close() { const release = releaseKey; releaseKey = undefined; restoreKey(); release?.(); restoreFault(); - if (ingress) stopInboxSync(ingress); + await retireOriginalSync(); closePrivateSession(session); f.close(); } diff --git a/web/tests/e2e/harness/history-pagination.ts b/web/tests/e2e/harness/history-pagination.ts @@ -90,6 +90,7 @@ export async function makeFixture( 'reviewed_private_session' ); if (!session) throw Error('missing genuine session'); + const capturedSession = session; const capture = privateSessionOwnership(session)!; const unlocked = captureUnlockedSession(session, 'reviewed_messages_unlock'); if (!unlocked) throw Error('missing genuine unlock'); @@ -144,6 +145,31 @@ export async function makeFixture( const publicStore = getPublicStore()!; const self = (await f.row())!.record.self; let ingress: InboxSync | undefined; + async function retireOriginalSync() { + for (;;) { + let incomplete = false; + try { + if (ingress) stopInboxSync(ingress); + } catch (error) { + if ( + !(error instanceof Error) || + error.message !== 'private_inbox_cleanup_required' + ) + throw error; + incomplete = true; + } + const sessionClean = closePrivateSession(capturedSession); + if (!incomplete && sessionClean) { + if (ingress && inboxSyncSnapshot(ingress)?.cleanupRequired) + throw Error('actual original sync cleanup remains incomplete'); + return; + } + // Retry exact original disposal after its actual SDK close observers; + // this wait starts no retrieval, permission or replacement session. + await new Promise<void>((resolve) => setTimeout(resolve, 0)); + } + } + let older: OlderInbox | undefined; let capacityWires: string[] = [], capacityWrites = 0; @@ -214,9 +240,7 @@ export async function makeFixture( if (!ingress) return false; return startInboxSync(ingress, review); }, - stop() { - if (ingress) stopInboxSync(ingress); - }, + stop: retireOriginalSync, snapshot: () => ingress && inboxSyncSnapshot(ingress), captureOlder(review: unknown = 'reviewed_load_older') { if (!ingress) return false; @@ -347,9 +371,7 @@ export async function makeFixture( closeUnlock() { closeUnlockedSession(unlocked); }, - navigateAway() { - if (ingress) stopInboxSync(ingress); - }, + navigateAway: retireOriginalSync, changeKey() { f.mode('changed_key'); }, @@ -431,7 +453,7 @@ export async function makeFixture( IDBIndex.prototype.openCursor = cursor; }; }, - close() { + async close() { const release = releaseKey; releaseKey = undefined; restoreKey(); @@ -439,7 +461,7 @@ export async function makeFixture( restoreFault(); if (older) stopOlderInbox(older); closePublicScheduler(scheduler); - if (ingress) stopInboxSync(ingress); + await retireOriginalSync(); closePrivateSession(session); f.close(); } diff --git a/web/tests/e2e/harness/inbox-access-controller.ts b/web/tests/e2e/harness/inbox-access-controller.ts @@ -0,0 +1,151 @@ +import { makeAuthFixture } from './inbox-auth.ts'; +import { validateRelayPolicy } from '../../../src/lib/config/relays.ts'; +import { + createPublicRuntimeContext, + mountPublicRuntime, + closePublicRuntime, + createPublicView, + beginPublicViewRun, + disposePublicView +} from '../../../src/lib/runtime/public-runtime.ts'; +import { + resolveInboxPreference, + settleInboxResolver, + inboxResolverCurrentAfterSample, + type InboxResolver +} from '../../../src/lib/messaging/resolve-inbox.ts'; +import { + createInboxAccessController, + closeInboxAccessController +} from '../../../src/lib/messaging/inbox-access-controller.ts'; +import { + getPrivatePool, + subscribePrivatePage, + subscribePrivateLive, + closePrivatePool, + type PrivatePool +} from '../../../src/lib/nostr/private-pool.ts'; +export * from '../../../src/lib/messaging/inbox-access-controller.ts'; +export { installCloseFailure } from './inbox-auth.ts'; +import { + createPrivateSession, + closePrivateSession, + type PrivateSession +} from '../../../src/lib/runtime/private-session.ts'; +export const origins = [ + 'wss://inbox.example.org', + 'wss://peer.example.org', + 'wss://archive.example.org' +]; +// Genuine actors/SDK discovery/AUTH with controlled loopback/provided identity; +// no installed extension, access probe, operator or full qualification claim. +export async function makeControllerFixture() { + const capturedPolicy = validateRelayPolicy( + JSON.stringify({ + schemaVersion: 1, + public: [ + { + origin: 'wss://discovery.example.org', + read: true, + write: true, + nip50: false + } + ], + inbox: origins.map((origin) => ({ origin, read: true, write: true })), + postingEnabled: true, + messagingEnabled: true, + operatorDenylist: [] + }) + ); + if (!capturedPolicy) throw Error('fixture policy'); + const policy = capturedPolicy; + const fixture = await makeAuthFixture(policy); + const context = createPublicRuntimeContext(), + runtime = mountPublicRuntime(context, policy); + if (!runtime) throw Error('actual public runtime'); + const view = createPublicView(runtime); + let controller: ReturnType<typeof createInboxAccessController>, + own: InboxResolver | undefined, + successor: PrivateSession | undefined; + const pools = new Map<PrivatePool, true>(); + function scope( + selected: string[], + role: 'receive' | 'delivery', + bindHead = false + ) { + const pool = getPrivatePool( + fixture.session, + policy, + selected, + Object.freeze({}), + role, + bindHead + ? () => !!own && inboxResolverCurrentAfterSample(own) + : () => true + ); + if (!pool) throw Error('actual scoped private pool'); + pools.set(pool, true); + return pool; + } + return { + ...fixture, + async capture() { + const run = beginPublicViewRun(view); + own = resolveInboxPreference(view, run, fixture.owner); + await settleInboxResolver(own); + controller = createInboxAccessController(fixture.session, policy, own); + if (!controller) throw Error('actual access controller'); + return controller; + }, + churnHead() { + beginPublicViewRun(view); + }, + scope, + page(pool: PrivatePool, ended: (reason: string) => void = () => {}) { + return subscribePrivatePage(pool, 1, (message) => { + if (message.type === 'end') ended(message.reason); + }); + }, + live( + pool: PrivatePool, + onOpen: () => void, + candidate: () => void = () => {} + ) { + return subscribePrivateLive(pool, (message) => { + if (message.type === 'open') onOpen(); + if (message.type === 'candidate') candidate(); + }); + }, + closeSession() { + return closePrivateSession(fixture.session); + }, + async successorScope() { + successor ??= await createPrivateSession( + fixture.identity, + 'reviewed_private_session' + ); + if (!successor) throw Error('genuine successor session unavailable'); + const pool = getPrivatePool( + successor, + policy, + origins, + Object.freeze({}), + 'receive' + ); + if (!pool) throw Error('genuine successor pool unavailable'); + pools.set(pool, true); + return pool; + }, + stopScope(pool: PrivatePool) { + closePrivatePool(pool); + }, + close() { + if (controller) closeInboxAccessController(controller); + for (const pool of pools.keys()) closePrivatePool(pool); + if (successor) closePrivateSession(successor); + disposePublicView(view); + closePublicRuntime(context); + fixture.close(); + } + }; +} diff --git a/web/tests/e2e/harness/inbox-auth.ts b/web/tests/e2e/harness/inbox-auth.ts @@ -28,6 +28,7 @@ import { subscribePrivatePage } from '../../../src/lib/nostr/private-pool.ts'; import { RelayPool } from 'applesauce-relay'; +import type { RelayPolicy } from '../../../src/lib/config/relays.ts'; export { beginInboxAuthentication, respondInboxAuthentication, @@ -44,7 +45,7 @@ export { closePublicPool } from '../../../src/lib/nostr/public-pool.ts'; export { inbox, fixturePolicy }; -export async function makeAuthFixture() { +export async function makeAuthFixture(selectedPolicy?: RelayPolicy) { const fixture = makeFixture(10050), identity = createIdentitySession(); let mode: 'exact' | 'author' | 'relay' | 'challenge' | 'cached' | 'denied' = @@ -53,17 +54,18 @@ export async function makeAuthFixture() { changed = false, invalidKey = false; let before = () => Promise.resolve(); + let beforeKey = () => Promise.resolve(); Object.defineProperty(window, 'nostr', { configurable: true, value: { - getPublicKey: () => - Promise.resolve( - invalidKey - ? 'not-a-public-key' - : changed - ? 'f'.repeat(64) - : fixture.owner - ), + getPublicKey: async () => { + await beforeKey(); + return invalidKey + ? 'not-a-public-key' + : changed + ? 'f'.repeat(64) + : fixture.owner; + }, signEvent: async (input: Parameters<typeof fixture.sign>[0]) => { signs++; await before(); @@ -89,7 +91,7 @@ export async function makeAuthFixture() { 'reviewed_private_session' ); if (!session) throw new Error('missing genuine private session'); - const policy = fixturePolicy(), + const policy = selectedPolicy ?? fixturePolicy(), pool = getPrivatePool(session, policy, [inbox]); if (!pool) throw new Error('missing private pool'); const store = getPrivateStore(session); @@ -109,6 +111,24 @@ export async function makeAuthFixture() { return { pool, policy, + identity, + session, + preferenceWire( + relays: readonly string[], + seconds = Math.floor(Date.now() / 1000) + ) { + return JSON.stringify( + fixture.sign({ + kind: 10050, + created_at: seconds, + tags: relays.map((origin) => ['relay', origin]), + content: '' + }) + ); + }, + beforeKey(next: typeof beforeKey) { + beforeKey = next; + }, owner: fixture.owner, signs: () => signs, mode: (next: typeof mode) => { @@ -143,6 +163,10 @@ export async function makeAuthFixture() { }), async staleGenerationInvalidation() { disconnectIdentity(identity); + while (ActualPrivateSession.privateSessionCleanupRequired(session)) { + closePrivateSession(session); + await new Promise<void>((resolve) => setTimeout(resolve, 0)); + } await connectIdentity(identity); await probeIdentityMessaging(identity, 'reviewed_self_copy'); const successor = await createPrivateSession( @@ -196,6 +220,15 @@ export async function makeAuthFixture() { } throw new Error('missing real challenge for bypass test'); }, + async closeAndWait() { + closePrivateSession(session); + disconnectIdentity(identity); + fixture.close(); + while (ActualPrivateSession.privateSessionCleanupRequired(session)) { + closePrivateSession(session); + await new Promise<void>((resolve) => setTimeout(resolve, 0)); + } + }, close: () => { closePrivateSession(session); disconnectIdentity(identity); @@ -204,13 +237,13 @@ export async function makeAuthFixture() { }; } export function installCloseFailure() { - const original = Reflect.get<RelayPool, 'close'>( + const original = Reflect.get<RelayPool, 'remove'>( RelayPool.prototype, - 'close' + 'remove' ); let failing = true; - RelayPool.prototype.close = function ( - ...args: Parameters<RelayPool['close']> + RelayPool.prototype.remove = function ( + ...args: Parameters<RelayPool['remove']> ) { if (failing) throw new Error('controlled physical cleanup fault'); return original.apply(this, args); @@ -220,7 +253,7 @@ export function installCloseFailure() { failing = false; }, restore: () => { - RelayPool.prototype.close = original; + RelayPool.prototype.remove = original; } }; } diff --git a/web/tests/e2e/harness/inbox-sync.ts b/web/tests/e2e/harness/inbox-sync.ts @@ -44,12 +44,38 @@ export async function makeFixture() { 'reviewed_private_session' ); if (!session) throw Error('missing genuine session'); + const capturedSession = session; const capture = privateSessionOwnership(session)!; const unlocked = captureUnlockedSession(session, 'reviewed_messages_unlock'); if (!unlocked) throw Error('missing genuine unlock'); const publicStore = getPublicStore()!; const self = (await f.row())!.record.self; let ingress: InboxSync | undefined; + async function retireOriginalSync() { + for (;;) { + let incomplete = false; + try { + if (ingress) stopInboxSync(ingress); + } catch (error) { + if ( + !(error instanceof Error) || + error.message !== 'private_inbox_cleanup_required' + ) + throw error; + incomplete = true; + } + const sessionClean = closePrivateSession(capturedSession); + if (!incomplete && sessionClean) { + if (ingress && inboxSyncSnapshot(ingress)?.cleanupRequired) + throw Error('actual original sync cleanup remains incomplete'); + return; + } + // Retry exact original disposal after its actual SDK close observers; + // this wait starts no retrieval, permission or replacement session. + await new Promise<void>((resolve) => setTimeout(resolve, 0)); + } + } + let authorized = true; let restoreFault = () => {}; let releaseKey: (() => void) | undefined; @@ -82,9 +108,7 @@ export async function makeFixture() { if (!ingress) return false; return startInboxSync(ingress, review); }, - stop() { - if (ingress) stopInboxSync(ingress); - }, + stop: retireOriginalSync, snapshot: () => ingress && inboxSyncSnapshot(ingress), async stored(id = self.eventId) { const row = await loadPrivateRecord( @@ -100,9 +124,7 @@ export async function makeFixture() { closeUnlock() { closeUnlockedSession(unlocked); }, - navigateAway() { - if (ingress) stopInboxSync(ingress); - }, + navigateAway: retireOriginalSync, changeKey() { f.mode('changed_key'); }, @@ -184,13 +206,13 @@ export async function makeFixture() { IDBIndex.prototype.openCursor = cursor; }; }, - close() { + async close() { const release = releaseKey; releaseKey = undefined; restoreKey(); release?.(); restoreFault(); - if (ingress) stopInboxSync(ingress); + await retireOriginalSync(); closePrivateSession(session); f.close(); } diff --git a/web/tests/e2e/harness/paired-delivery.ts b/web/tests/e2e/harness/paired-delivery.ts @@ -54,14 +54,21 @@ const discovery = 'wss://discovery.example.org', // Disposable existing source fixture provider signs actual public10050 facts; // local discovery observations qualify route semantics only, never relay Q. export async function makeFixture( - options: Readonly<{ messaging?: boolean; peerRead?: boolean }> = {} + options: Readonly<{ + messaging?: boolean; + peerRead?: boolean; + sharedOrigin?: boolean; + }> = {} ) { const f = await makeSelfFixture(), policy = validateRelayPolicy( JSON.stringify({ schemaVersion: 1, public: [{ origin: discovery, read: true, write: false, nip50: false }], - inbox: [peerOrigin, archiveOrigin].map((origin) => ({ + inbox: (options.sharedOrigin + ? [peerOrigin] + : [peerOrigin, archiveOrigin] + ).map((origin) => ({ origin, read: origin === peerOrigin ? options.peerRead !== false : true, write: true @@ -84,7 +91,9 @@ export async function makeFixture( const signed = await provider.signEvent({ kind: 10050, created_at: 100, - tags: [['relay', peer ? peerOrigin : archiveOrigin]], + tags: [ + ['relay', peer || options.sharedOrigin ? peerOrigin : archiveOrigin] + ], content: '' }); f.mode('normal'); diff --git a/web/tests/e2e/harness/private-publisher.ts b/web/tests/e2e/harness/private-publisher.ts @@ -16,6 +16,8 @@ import { } from '../../../src/lib/nostr/private-pool.ts'; import { capturePrivatePublication, + capturePrivatePublicationAction, + type PrivatePublicationAction, privatePublicationSnapshot, type PrivatePublication } from '../../../src/lib/nostr/private-publisher.ts'; @@ -36,19 +38,25 @@ import { } from '../../../src/lib/messaging/composer-state.ts'; import { disconnectIdentity } from '../../../src/lib/runtime/identity-session.ts'; export { privatePublicationSnapshot, publishPrivateGiftWrapAttempt }; -export async function makeFixture(writeOnly = false) { - const f = await makePairFixture({ messaging: true, peerRead: !writeOnly }); +import { RelayPool } from 'applesauce-relay/pool'; +export async function makeFixture(writeOnly = false, sharedOrigin = false) { + const f = await makePairFixture({ + messaging: true, + peerRead: !writeOnly, + sharedOrigin + }); const session = await createPrivateSession( f.identity, 'reviewed_private_session' ); if (!session) throw Error('missing genuine private session'); const peerOrigin = 'wss://peer.example.org', - archiveOrigin = 'wss://archive.example.org'; - const pool = getPrivatePool(session, f.context.policy, [ - peerOrigin, - archiveOrigin - ]); + archiveOrigin = sharedOrigin ? peerOrigin : 'wss://archive.example.org'; + const pool = getPrivatePool( + session, + f.context.policy, + Array.from(new Set([peerOrigin, archiveOrigin])) + ); if (!pool) throw Error('missing actual private pool'); const controller = new AbortController(); let composer: PrivateComposer | undefined; @@ -108,7 +116,8 @@ export async function makeFixture(writeOnly = false) { function permission( role: 'peer' | 'self_archive', origin = role === 'peer' ? peerOrigin : archiveOrigin, - review: unknown = 'reviewed_private_delivery' + review: unknown = 'reviewed_private_delivery', + action?: PrivatePublicationAction ) { const receipt = preparedPairedDelivery(f.preparation); return receipt @@ -119,12 +128,60 @@ export async function makeFixture(writeOnly = false) { f.context, role, origin, - review + review, + action ) : undefined; } - async function publish(token: PrivatePublication) { - return publishPrivateGiftWrapAttempt(pool!, token, controller.signal); + async function publish( + token: PrivatePublication, + signal = controller.signal + ) { + return publishPrivateGiftWrapAttempt(pool!, token, signal); + } + function action() { + const receipt = preparedPairedDelivery(f.preparation); + return receipt + ? capturePrivatePublicationAction( + f.repository, + session!, + receipt, + f.context, + 'reviewed_private_retry' + ) + : undefined; + } + function failAcquisition() { + const original = Reflect.get<RelayPool, 'relay'>( + RelayPool.prototype, + 'relay' + ); + RelayPool.prototype.relay = function (origin) { + if (new URL(origin).origin === peerOrigin) + throw Error('controlled original SDK acquisition failure'); + return original.call(this, origin); + }; + return () => { + RelayPool.prototype.relay = original; + }; + } + function abortOnActualNetworkClock(abort: AbortController) { + const original = performance.now.bind(performance); + let observed = false; + performance.now = () => { + const value = original(); + if (!observed && /at clock \(/.test(new Error().stack ?? '')) { + observed = true; + abort.abort(); + } + return value; + }; + return { + observed: () => observed, + restore: () => { + performance.now = original; + } + }; } async function deliver( role: 'peer' | 'self_archive', @@ -204,6 +261,9 @@ export async function makeFixture(writeOnly = false) { prepareSelfOnly: () => prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'), permission, + action, + failAcquisition, + abortOnActualNetworkClock, publish, deliver, remove, diff --git a/web/tests/e2e/inbox-access-controller.spec.ts b/web/tests/e2e/inbox-access-controller.spec.ts @@ -0,0 +1,788 @@ +import { test, expect, type Page } from '@playwright/test'; +import { build } from 'vite'; +import { fileURLToPath } from 'node:url'; +import { once } from 'node:events'; +import { WebSocketServer, type WebSocket } from 'ws'; +import { createStaticHarness } from '../integration/harness/static.ts'; +import type * as Fixture from './harness/inbox-access-controller.ts'; +declare global { + interface Window { + cr007: typeof Fixture; + cr007Fixture: Awaited<ReturnType<typeof Fixture.makeControllerFixture>>; + cr007Controller: NonNullable< + Awaited<ReturnType<Window['cr007Fixture']['capture']>> + >; + cr007Pending?: Promise<string>; + cr007Release?: () => void; + cr007Waiting?: boolean; + cr007Open?: boolean; + cr007StopLive?: () => void; + cr007StopPage?: () => void; + cr007PageEnd?: string; + cr007LiveEvents?: number; + cr007DelayClose?: boolean; + cr007HeldClose?: (() => void)[]; + cr007ThrowConstructor?: string; + cr007Reconnected?: boolean; + cr007Fault?: ReturnType<typeof Fixture.installCloseFailure>; + } +} +let server: Awaited<ReturnType<typeof createStaticHarness>>, + sockets: WebSocketServer, + endpoint: string, + bundle: string; +let head = '', + accept = true; +const frames: { origin: string; frame: unknown[] }[] = []; +const connections = new Map<WebSocket, string>(); +let peakPrivateConnections = 0, + constructedPrivateConnections = 0; +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('owned loopback'); + endpoint = 'ws://127.0.0.1:' + address.port; + sockets.on('connection', (socket, request) => { + const origin = + new URL(request.url ?? '/', endpoint).searchParams.get('origin') ?? ''; + connections.set(socket, origin); + if (origin !== 'wss://discovery.example.org') { + constructedPrivateConnections++; + peakPrivateConnections = Math.max( + peakPrivateConnections, + [...connections.values()].filter( + (from) => from !== 'wss://discovery.example.org' + ).length + ); + } + socket.on('close', () => connections.delete(socket)); + socket.send(JSON.stringify(['AUTH', 'cr007-controlled-challenge'])); + 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[]; + frames.push({ origin, frame }); + if (frame[0] === 'AUTH') + socket.send( + JSON.stringify([ + 'OK', + (frame[1] as { id: string }).id, + accept, + accept ? '' : 'blocked: controlled refusal' + ]) + ); + if (frame[0] === 'REQ' && origin === 'wss://discovery.example.org') { + const filter = frame[2] as { kinds?: number[] }; + if (filter.kinds?.includes(10050) && head) + socket.send(JSON.stringify(['EVENT', frame[1], JSON.parse(head)])); + socket.send(JSON.stringify(['EOSE', frame[1]])); + } + }); + }); + const result = await build({ + configFile: false, + logLevel: 'silent', + build: { + write: false, + minify: false, + lib: { + entry: fileURLToPath( + new URL('./harness/inbox-access-controller.ts', import.meta.url) + ), + name: 'cr007', + formats: ['iife'] + } + } + }); + const output = Array.isArray(result) ? result[0] : result; + if (!('output' in output)) throw Error('actual fixture bundle'); + const chunks = output.output.filter((chunk) => chunk.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 }) => { + await expect.poll(() => connections.size).toBe(0); + peakPrivateConnections = 0; + constructedPrivateConnections = 0; + head = ''; + accept = true; + frames.length = 0; + await page.addInitScript( + ({ endpoint }) => { + const Native = window.WebSocket; + window.WebSocket = class extends Native { + constructor(url: string | URL, protocols?: string | string[]) { + const origin = new URL(String(url)).origin; + if ( + ![ + 'wss://discovery.example.org', + 'wss://inbox.example.org', + 'wss://peer.example.org', + 'wss://archive.example.org' + ].includes(origin) + ) + throw Error('unexpected fixture egress'); + if (window.cr007ThrowConstructor === origin) { + window.cr007ThrowConstructor = undefined; + throw Error('controlled native constructor failure before super'); + } + super(endpoint + '/?origin=' + encodeURIComponent(origin), protocols); + } + override close(code?: number, reason?: string) { + if ( + window.cr007DelayClose && + !this.url.includes( + encodeURIComponent('wss://discovery.example.org') + ) + ) { + (window.cr007HeldClose ??= []).push(() => + super.close(code, reason) + ); + } else super.close(code, reason); + } + }; + }, + { endpoint } + ); + await page.goto(server.url + '/search'); + await page.addScriptTag({ content: bundle }); + head = await page.evaluate(async () => { + window.cr007Fixture = await window.cr007.makeControllerFixture(); + return window.cr007Fixture.preferenceWire([window.cr007.origins[0]]); + }); + await page.evaluate(async () => { + window.cr007Controller = await window.cr007Fixture.capture(); + }); +}); +test.afterEach(async ({ page }) => { + if (!page.isClosed()) + await page.evaluate(() => { + window.cr007Fault?.restore(); + window.cr007Release?.(); + window.cr007StopPage?.(); + window.cr007StopLive?.(); + window.cr007DelayClose = false; + for (const release of window.cr007HeldClose ?? []) release(); + window.cr007Fixture.close(); + }); +}); +async function challenge(page: Page) { + await page.evaluate(() => + window.cr007.authenticateInboxAccess( + window.cr007Controller, + window.cr007.origins[0], + 'reviewed_inbox_connection_auth' + ) + ); + await expect + .poll(() => + page.evaluate( + () => + window.cr007.inboxAccessControllerSnapshot(window.cr007Controller) + ?.auth[0]?.state + ) + ) + .toBe('challenge'); +} +test('genuine controller capture has no private connection or sign and never claims readiness', async ({ + page +}) => { + expect( + [...connections.values()].filter( + (origin) => origin !== 'wss://discovery.example.org' + ) + ).toHaveLength(0); + const result = await page.evaluate(async () => ({ + snapshot: window.cr007.inboxAccessControllerSnapshot( + window.cr007Controller + ), + signs: window.cr007Fixture.signs(), + wrong: await window.cr007.authenticateInboxAccess( + window.cr007Controller, + window.cr007.origins[0], + 'wrong-review' + ) + })); + expect(result.signs).toBe(0); + expect(result.wrong).toBe('unavailable'); + expect(result.snapshot?.readiness).toBe('unavailable'); + expect( + frames.some(({ frame }) => ['AUTH', 'EVENT'].includes(String(frame[0]))) + ).toBe(false); +}); +test('explicit current owner AUTH sends real signed22242 only and duplicate initiation cannot reset it', async ({ + page +}) => { + await challenge(page); + expect( + await page.evaluate(() => + window.cr007.respondInboxAccessAuthentication( + window.cr007Controller, + window.cr007.origins[0], + 'reviewed_inbox_auth_response' + ) + ) + ).toBe('accepted'); + expect( + await page.evaluate(() => + window.cr007.authenticateInboxAccess( + window.cr007Controller, + window.cr007.origins[0], + 'reviewed_inbox_connection_auth' + ) + ) + ).toBe('accepted'); + const sent = frames.filter(({ frame }) => frame[0] === 'AUTH'); + expect(sent).toHaveLength(1); + expect(sent[0].frame[1]).toMatchObject({ + kind: 22242, + pubkey: await page.evaluate(() => window.cr007Fixture.owner), + tags: [ + ['relay', 'wss://inbox.example.org/'], + ['challenge', 'cr007-controlled-challenge'] + ] + }); + expect(frames.some(({ frame }) => frame[0] === 'EVENT')).toBe(false); + expect( + await page.evaluate( + () => + window.cr007.inboxAccessControllerSnapshot(window.cr007Controller) + ?.readiness + ) + ).toBe('unavailable'); +}); +test('actual discovery generation churn during pending signing cannot emit late AUTH', async ({ + page +}) => { + await challenge(page); + await page.evaluate(() => { + window.cr007Fixture.beforeSign( + () => + new Promise<void>((resolve) => { + window.cr007Waiting = true; + window.cr007Release = resolve; + }) + ); + window.cr007Pending = window.cr007.respondInboxAccessAuthentication( + window.cr007Controller, + window.cr007.origins[0], + 'reviewed_inbox_auth_response' + ); + }); + await expect.poll(() => page.evaluate(() => window.cr007Waiting)).toBe(true); + await page.evaluate(() => { + window.cr007Fixture.churnHead(); + window.cr007Release?.(); + }); + expect(await page.evaluate(() => window.cr007Pending)).toBe('stopped'); + expect(frames.filter(({ frame }) => frame[0] === 'AUTH')).toHaveLength(0); +}); +test('actual discovery churn during pending fresh key cannot open an AUTH socket', async ({ + page +}) => { + await page.evaluate(() => { + window.cr007Fixture.beforeKey( + () => + new Promise<void>((resolve) => { + window.cr007Waiting = true; + window.cr007Release = resolve; + }) + ); + window.cr007Pending = window.cr007.authenticateInboxAccess( + window.cr007Controller, + window.cr007.origins[0], + 'reviewed_inbox_connection_auth' + ); + }); + await expect.poll(() => page.evaluate(() => window.cr007Waiting)).toBe(true); + await page.evaluate(() => { + window.cr007Fixture.churnHead(); + window.cr007Release?.(); + }); + expect(await page.evaluate(() => window.cr007Pending)).not.toBe('accepted'); + expect( + [...connections.values()].filter( + (origin) => origin !== 'wss://discovery.example.org' + ) + ).toHaveLength(0); + expect(frames.filter(({ frame }) => frame[0] === 'AUTH')).toHaveLength(0); +}); +test('selected live receive scope reaches OPEN while a delivery scope cannot borrow reads', async ({ + page +}) => { + const result = await page.evaluate(() => { + const receive = window.cr007Fixture.scope( + [window.cr007.origins[2]], + 'receive' + ); + window.cr007StopLive = window.cr007Fixture.live(receive, () => { + window.cr007Open = true; + }); + const delivery = window.cr007Fixture.scope( + [window.cr007.origins[1]], + 'delivery' + ); + let refused = false; + try { + window.cr007Fixture.page(delivery); + } catch { + refused = true; + } + return refused; + }); + expect(result).toBe(true); + await expect.poll(() => page.evaluate(() => window.cr007Open)).toBe(true); + expect( + frames.filter( + ({ origin, frame }) => + origin === 'wss://peer.example.org' && frame[0] === 'REQ' + ) + ).toHaveLength(0); +}); +test('closing AUTH controller leaves independent other-origin receive and anonymous discovery intact', async ({ + page +}) => { + await challenge(page); + await page.evaluate(() => { + const receive = window.cr007Fixture.scope( + [window.cr007.origins[2]], + 'receive' + ); + window.cr007StopLive = window.cr007Fixture.live(receive, () => { + window.cr007Open = true; + }); + }); + await expect.poll(() => page.evaluate(() => window.cr007Open)).toBe(true); + await expect + .poll( + () => + [...connections.values()].filter( + (origin) => origin === 'wss://archive.example.org' + ).length + ) + .toBe(1); + await page.evaluate(() => + window.cr007.closeInboxAccessController(window.cr007Controller) + ); + await expect + .poll( + () => + [...connections.values()].filter( + (origin) => origin === 'wss://inbox.example.org' + ).length + ) + .toBe(0); + expect( + [...connections.values()].filter( + (origin) => origin === 'wss://archive.example.org' + ) + ).toHaveLength(1); + expect(await page.evaluate(() => window.cr007Open)).toBe(true); +}); + +test('scope-only current-head page invalidation leaves another origin live', async ({ + page +}) => { + await page.evaluate(() => { + const receive = window.cr007Fixture.scope( + [window.cr007.origins[2]], + 'receive' + ); + window.cr007LiveEvents = 0; + window.cr007StopLive = window.cr007Fixture.live( + receive, + () => { + window.cr007Open = true; + }, + () => { + window.cr007LiveEvents = (window.cr007LiveEvents ?? 0) + 1; + } + ); + }); + await expect.poll(() => page.evaluate(() => window.cr007Open)).toBe(true); + await expect + .poll( + () => + [...connections.values()].filter( + (origin) => origin === 'wss://archive.example.org' + ).length + ) + .toBe(1); + await page.evaluate(() => { + const pageScope = window.cr007Fixture.scope( + [window.cr007.origins[0]], + 'receive', + true + ); + window.cr007StopPage = window.cr007Fixture.page(pageScope, (reason) => { + window.cr007PageEnd = reason; + }); + }); + await expect + .poll( + () => + frames.filter( + ({ origin, frame }) => + origin === 'wss://inbox.example.org' && frame[0] === 'REQ' + ).length + ) + .toBe(1); + await page.evaluate(() => window.cr007Fixture.churnHead()); + const request = frames.find( + ({ origin, frame }) => + origin === 'wss://inbox.example.org' && frame[0] === 'REQ' + ); + expect(request).toBeDefined(); + for (const [socket, origin] of connections) { + if (origin === 'wss://inbox.example.org') + socket.send(JSON.stringify(['EOSE', request!.frame[1]])); + if (origin === 'wss://archive.example.org') { + const live = frames.find( + ({ origin: from, frame }) => from === origin && frame[0] === 'REQ' + ); + socket.send( + JSON.stringify([ + 'EVENT', + live!.frame[1], + { + id: '1'.repeat(64), + pubkey: '2'.repeat(64), + kind: 1059, + created_at: 1, + tags: [], + content: '', + sig: '3'.repeat(128) + } + ]) + ); + } + } + await expect + .poll(() => page.evaluate(() => window.cr007PageEnd)) + .toBe('stale'); + await expect.poll(() => page.evaluate(() => window.cr007LiveEvents)).toBe(1); + expect( + [...connections.values()].filter( + (origin) => origin === 'wss://archive.example.org' + ) + ).toHaveLength(1); +}); +test('pending receive fresh-key wait is fenced by genuine discovery-head churn', async ({ + page +}) => { + await page.evaluate(() => { + window.cr007Fixture.beforeKey( + () => + new Promise<void>((resolve) => { + window.cr007Waiting = true; + window.cr007Release = resolve; + }) + ); + const receive = window.cr007Fixture.scope( + [window.cr007.origins[0]], + 'receive', + true + ); + window.cr007StopPage = window.cr007Fixture.page(receive, (reason) => { + window.cr007PageEnd = reason; + }); + }); + await expect.poll(() => page.evaluate(() => window.cr007Waiting)).toBe(true); + await page.evaluate(() => { + window.cr007Fixture.churnHead(); + window.cr007Release?.(); + }); + await expect + .poll(() => page.evaluate(() => window.cr007PageEnd)) + .toBe('stale'); + expect( + frames.filter( + ({ origin, frame }) => + origin === 'wss://inbox.example.org' && frame[0] === 'REQ' + ) + ).toHaveLength(0); + expect( + [...connections.values()].filter( + (origin) => origin !== 'wss://discovery.example.org' + ) + ).toHaveLength(0); +}); +test('AUTH retirement blocks a pending same-origin receive until actual physical close', async ({ + page +}) => { + await challenge(page); + await page.evaluate(() => { + window.cr007DelayClose = true; + window.cr007Fixture.beforeKey( + () => + new Promise<void>((resolve) => { + window.cr007Waiting = true; + window.cr007Release = resolve; + }) + ); + const receive = window.cr007Fixture.scope( + [window.cr007.origins[0]], + 'receive' + ); + window.cr007StopPage = window.cr007Fixture.page(receive, (reason) => { + window.cr007PageEnd = reason; + }); + }); + await expect.poll(() => page.evaluate(() => window.cr007Waiting)).toBe(true); + await page.evaluate(() => { + window.cr007.closeInboxAccessController(window.cr007Controller); + window.cr007Release?.(); + }); + await expect + .poll(() => page.evaluate(() => window.cr007PageEnd)) + .toBe('stale'); + expect( + frames.filter( + ({ origin, frame }) => + origin === 'wss://inbox.example.org' && frame[0] === 'REQ' + ) + ).toHaveLength(0); + expect( + [...connections.values()].filter( + (origin) => origin === 'wss://inbox.example.org' + ) + ).toHaveLength(1); + expect( + await page.evaluate(() => { + try { + window.cr007Fixture.scope([window.cr007.origins[0]], 'receive'); + return false; + } catch { + return true; + } + }) + ).toBe(true); + await page.evaluate(() => { + window.cr007DelayClose = false; + for (const release of window.cr007HeldClose ?? []) release(); + }); + await expect + .poll( + () => + [...connections.values()].filter( + (origin) => origin === 'wss://inbox.example.org' + ).length + ) + .toBe(0); +}); +test('ordinary three-socket session teardown blocks replacement until actual close', async ({ + page +}) => { + await page.evaluate(() => { + const receive = window.cr007Fixture.scope(window.cr007.origins, 'receive'); + window.cr007StopLive = window.cr007Fixture.live(receive, () => { + window.cr007Open = true; + }); + }); + await expect.poll(() => page.evaluate(() => window.cr007Open)).toBe(true); + await expect + .poll( + () => + [...connections.values()].filter( + (origin) => origin !== 'wss://discovery.example.org' + ).length + ) + .toBe(3); + expect( + [...connections.values()].filter( + (origin) => origin !== 'wss://discovery.example.org' + ) + ).toHaveLength(3); + const originalSockets = [...connections.keys()].filter( + (socket) => connections.get(socket) !== 'wss://discovery.example.org' + ); + const result = await page.evaluate(async () => { + window.cr007DelayClose = true; + const closed = window.cr007Fixture.closeSession(); + try { + await window.cr007Fixture.successorScope(); + return { closed, blocked: false }; + } catch { + return { closed, blocked: true }; + } + }); + expect(result).toEqual({ closed: false, blocked: true }); + expect( + [...connections.keys()].filter( + (socket) => connections.get(socket) !== 'wss://discovery.example.org' + ) + ).toEqual(originalSockets); + expect(constructedPrivateConnections).toBe(3); + expect(peakPrivateConnections).toBe(3); + expect( + [...connections.values()].filter( + (origin) => origin !== 'wss://discovery.example.org' + ) + ).toHaveLength(3); + await page.evaluate(() => { + window.cr007DelayClose = false; + for (const release of window.cr007HeldClose ?? []) release(); + }); + await expect + .poll( + () => + [...connections.values()].filter( + (origin) => origin !== 'wss://discovery.example.org' + ).length + ) + .toBe(0); + await page.evaluate(async () => { + const receive = await window.cr007Fixture.successorScope(); + window.cr007StopLive = window.cr007Fixture.live(receive, () => { + window.cr007Reconnected = true; + }); + }); + await expect + .poll(() => page.evaluate(() => window.cr007Reconnected)) + .toBe(true); + await expect + .poll( + () => + [...connections.values()].filter( + (origin) => origin !== 'wss://discovery.example.org' + ).length + ) + .toBe(3); + expect( + [...connections.values()].filter( + (origin) => origin !== 'wss://discovery.example.org' + ) + ).toHaveLength(3); + await expect.poll(() => constructedPrivateConnections).toBe(6); + expect(peakPrivateConnections).toBe(3); +}); +test('synchronous native constructor failure retires the original metadata and permits actual retry', async ({ + page +}) => { + await page.evaluate(() => { + window.cr007ThrowConstructor = window.cr007.origins[0]; + const receive = window.cr007Fixture.scope( + [window.cr007.origins[0]], + 'receive' + ); + window.cr007StopPage = window.cr007Fixture.page(receive, (reason) => { + window.cr007PageEnd = reason; + }); + }); + await expect + .poll(() => page.evaluate(() => window.cr007PageEnd)) + .toBe('error'); + expect( + [...connections.values()].filter( + (origin) => origin !== 'wss://discovery.example.org' + ) + ).toHaveLength(0); + await page.evaluate(() => { + const receive = window.cr007Fixture.scope( + [window.cr007.origins[0]], + 'receive' + ); + window.cr007StopLive = window.cr007Fixture.live(receive, () => { + window.cr007Open = true; + }); + }); + await expect.poll(() => page.evaluate(() => window.cr007Open)).toBe(true); + await expect + .poll( + () => + [...connections.values()].filter( + (origin) => origin !== 'wss://discovery.example.org' + ).length + ) + .toBe(1); + expect( + [...connections.values()].filter( + (origin) => origin !== 'wss://discovery.example.org' + ) + ).toHaveLength(1); +}); + +test('AUTH startup native constructor failure releases the exact origin before explicit retry', async ({ + page +}) => { + const first = await page.evaluate(async () => { + window.cr007ThrowConstructor = window.cr007.origins[0]; + return window.cr007.authenticateInboxAccess( + window.cr007Controller, + window.cr007.origins[0], + 'reviewed_inbox_connection_auth' + ); + }); + expect(first).toBe('unavailable'); + expect( + [...connections.values()].filter( + (origin) => origin !== 'wss://discovery.example.org' + ) + ).toHaveLength(0); + await challenge(page); + expect( + await page.evaluate(() => + window.cr007.respondInboxAccessAuthentication( + window.cr007Controller, + window.cr007.origins[0], + 'reviewed_inbox_auth_response' + ) + ) + ).toBe('accepted'); + expect(frames.filter(({ frame }) => frame[0] === 'AUTH')).toHaveLength(1); +}); + +test('failed AUTH startup cleanup stays with its original scope and retries after removal recovers', async ({ + page +}) => { + const first = await page.evaluate(async () => { + window.cr007ThrowConstructor = window.cr007.origins[0]; + window.cr007Fault = window.cr007.installCloseFailure(); + return window.cr007.authenticateInboxAccess( + window.cr007Controller, + window.cr007.origins[0], + 'reviewed_inbox_connection_auth' + ); + }); + expect(first).toBe('unavailable'); + expect( + await page.evaluate(() => + window.cr007.closeInboxAccessController(window.cr007Controller) + ) + ).toBe(false); + await page.evaluate(() => window.cr007Fault?.allow()); + expect( + await page.evaluate(() => + window.cr007.closeInboxAccessController(window.cr007Controller) + ) + ).toBe(true); + await page.evaluate(async () => { + window.cr007Fault?.restore(); + window.cr007Controller = await window.cr007Fixture.capture(); + }); + await challenge(page); + expect( + await page.evaluate(() => + window.cr007.respondInboxAccessAuthentication( + window.cr007Controller, + window.cr007.origins[0], + 'reviewed_inbox_auth_response' + ) + ) + ).toBe('accepted'); + expect(frames.filter(({ frame }) => frame[0] === 'AUTH')).toHaveLength(1); +}); diff --git a/web/tests/e2e/inbox-auth.spec.ts b/web/tests/e2e/inbox-auth.spec.ts @@ -364,7 +364,7 @@ test('new physical connection and explicit action do not inherit accepted scope' window.hcp068.respondInboxAuthentication(window.hcp068Action) ); await page.evaluate(async () => { - window.hcp068Fixture.close(); + await window.hcp068Fixture.closeAndWait(); window.hcp068Fixture = await window.hcp068.makeAuthFixture(); const action = await window.hcp068.beginInboxAuthentication( window.hcp068Fixture.pool, @@ -424,7 +424,7 @@ test('raw private AUTH ports cannot bypass explicit review and guarded signing', page }) => { const status = await page.evaluate(async () => { - window.hcp068Fixture.close(); + await window.hcp068Fixture.closeAndWait(); window.hcp068Fixture = await window.hcp068.makeAuthFixture(); return window.hcp068Fixture.rawPortBypass(); }); @@ -449,7 +449,7 @@ test('reviewed AUTH uses the same genuine already-open private page connection', }) => { holdPage = true; await page.evaluate(async () => { - window.hcp068Fixture.close(); + await window.hcp068Fixture.closeAndWait(); window.hcp068Fixture = await window.hcp068.makeAuthFixture(); window.hcp068Fixture.startPage(); }); diff --git a/web/tests/e2e/private-publisher.spec.ts b/web/tests/e2e/private-publisher.spec.ts @@ -2,13 +2,18 @@ import { test, expect } from '@playwright/test'; import { build } from 'vite'; import { fileURLToPath } from 'node:url'; import { once } from 'node:events'; -import { WebSocketServer } from 'ws'; +import { WebSocketServer, type WebSocket } from 'ws'; import { createStaticHarness } from '../integration/harness/static.ts'; import type * as Fixture from './harness/private-publisher.ts'; declare global { interface Window { hcp085: typeof Fixture; hcp085Fixture: Awaited<ReturnType<typeof Fixture.makeFixture>>; + hcp085DelayClose?: boolean; + hcp085HeldClose?: (() => void)[]; + hcp085SharedAction?: NonNullable< + ReturnType<Window['hcp085Fixture']['action']> + >; } } let server: Awaited<ReturnType<typeof createStaticHarness>>, @@ -16,7 +21,10 @@ let server: Awaited<ReturnType<typeof createStaticHarness>>, endpoint: string, bundle: string; let frames: { origin: string; frame: unknown[] }[] = [], - response: 'accepted' | 'refused' = 'accepted'; + response: 'accepted' | 'refused' | 'unknown' = 'accepted'; +const physical = new Set<WebSocket>(); +let constructed = 0, + peak = 0; test.beforeAll(async () => { server = await createStaticHarness(); sockets = new WebSocketServer({ @@ -30,6 +38,10 @@ test.beforeAll(async () => { throw Error('loopback unavailable'); endpoint = 'ws://127.0.0.1:' + address.port; sockets.on('connection', (socket, request) => { + physical.add(socket); + constructed++; + peak = Math.max(peak, physical.size); + socket.on('close', () => physical.delete(socket)); const origin = new URL(request.url!, 'http://127.0.0.1').searchParams.get( 'origin' )!; @@ -41,7 +53,7 @@ test.beforeAll(async () => { : Buffer.from(bytes); const frame = JSON.parse(raw.toString()) as unknown[]; frames.push({ origin, frame }); - if (frame[0] === 'EVENT') { + if (frame[0] === 'EVENT' && response !== 'unknown') { const event = frame[1] as { id: string }; socket.send( JSON.stringify([ @@ -83,6 +95,9 @@ test.afterAll(async () => { await server.close(); }); test.beforeEach(async ({ page }) => { + await expect.poll(() => physical.size).toBe(0); + constructed = 0; + peak = 0; frames = []; response = 'accepted'; await page.addInitScript( @@ -102,6 +117,13 @@ test.beforeEach(async ({ page }) => { protocols ); } + override close(code?: number, reason?: string) { + if (window.hcp085DelayClose) + (window.hcp085HeldClose ??= []).push(() => + super.close(code, reason) + ); + else super.close(code, reason); + } }; }, { endpoint } @@ -111,7 +133,11 @@ test.beforeEach(async ({ page }) => { }); test.afterEach(async ({ page }) => { if (!page.isClosed()) - await page.evaluate(() => window.hcp085Fixture?.close()); + await page.evaluate(() => { + window.hcp085DelayClose = false; + for (const release of window.hcp085HeldClose ?? []) release(); + window.hcp085Fixture?.close(); + }); }); async function fixture( page: import('@playwright/test').Page, @@ -369,3 +395,161 @@ test('actual owner loss still clears the bound private composer and prevents pub expect(result.attempt.status).toBe('stopped'); expect(frames).toEqual([]); }); + +for (const fault of ['SDK acquisition', 'actual network clock abort'] as const) + test( + 'original metered action releases reservation after ' + + fault + + ' and permits reviewed retry', + async ({ page }) => { + await fixture(page); + const result = await page.evaluate(async (fault) => { + const f = window.hcp085Fixture; + await f.prepare(); + const action = f.action(); + if (!action) throw Error('genuine metered action missing'); + const firstPermission = f.permission( + 'peer', + f.peerOrigin, + 'reviewed_private_delivery', + action + ); + if (!firstPermission) throw Error('genuine first permission missing'); + const abort = new AbortController(); + let restore: () => void, + observed = () => true; + if (fault === 'SDK acquisition') restore = f.failAcquisition(); + else { + const clock = f.abortOnActualNetworkClock(abort); + restore = clock.restore; + observed = clock.observed; + } + let first; + try { + first = await f.publish(firstPermission, abort.signal); + } finally { + restore(); + } + const retryPermission = f.permission( + 'peer', + f.peerOrigin, + 'reviewed_private_delivery', + action + ); + if (!retryPermission) + throw Error('genuine original action retry permission missing'); + const retry = await f.publish( + retryPermission, + new AbortController().signal + ); + return { first, retry, observed: observed() }; + }, fault); + expect(result.observed).toBe(true); + expect(result.first.status).toBe('stopped'); + expect(result.first.actionId).toBeUndefined(); + expect(result.first.attempt).toBeUndefined(); + expect(result.retry.status).toBe('accepted'); + expect(result.retry.attempt).toBe(fault === 'SDK acquisition' ? 1 : 2); + expect(frames.filter(({ frame }) => frame[0] === 'EVENT')).toHaveLength( + 1 + ); + } + ); + +test('genuine shared-origin peer and archive roles reuse one original connection and distinct exact artifacts', async ({ + page +}) => { + const result = await page.evaluate(async () => { + window.hcp085Fixture = await window.hcp085.makeFixture(false, true); + const f = window.hcp085Fixture; + window.hcp085DelayClose = true; + await f.prepare(); + const action = f.action(); + if (!action) throw Error('genuine metered action'); + const peer = f.permission( + 'peer', + f.peerOrigin, + 'reviewed_private_delivery', + action + ); + const archive = f.permission( + 'self_archive', + f.archiveOrigin, + 'reviewed_private_delivery', + action + ); + if (!peer || !archive) throw Error('genuine original two-role permissions'); + const first = await f.publish(peer); + const second = await f.publish(archive); + const retry = f.permission( + 'peer', + f.peerOrigin, + 'reviewed_private_delivery', + action + ); + if (!retry) throw Error('genuine reviewed original retry'); + const third = await f.publish(retry); + return { first, second, third }; + }); + expect(constructed).toBe(1); + expect(peak).toBe(1); + expect(physical.size).toBe(1); + expect(await page.evaluate(() => window.hcp085HeldClose?.length ?? 0)).toBe( + 0 + ); + expect(result.first.status).toBe('accepted'); + expect(result.second.status).toBe('accepted'); + expect(result.third.status).toBe('accepted'); + expect(result.first.eventId).not.toBe(result.second.eventId); + expect(result.third.eventId).toBe(result.first.eventId); + expect(result.third.attempt).toBe(2); + const events = frames.filter(({ frame }) => frame[0] === 'EVENT'); + expect(events).toHaveLength(3); + expect( + events.every(({ origin }) => origin === 'wss://peer.example.org') + ).toBe(true); +}); + +test('original shared-origin unknown EVENT retries the exact artifact on the same actual connection', async ({ + page +}) => { + response = 'unknown'; + const first = await page.evaluate(async () => { + window.hcp085Fixture = await window.hcp085.makeFixture(false, true); + const f = window.hcp085Fixture; + window.hcp085DelayClose = true; + await f.prepare(); + window.hcp085SharedAction = f.action(); + if (!window.hcp085SharedAction) throw Error('genuine action'); + const permission = f.permission( + 'peer', + f.peerOrigin, + 'reviewed_private_delivery', + window.hcp085SharedAction + ); + if (!permission) throw Error('genuine permission'); + return f.publish(permission); + }); + expect(['unknown', 'timed_out']).toContain(first.status); + expect(constructed).toBe(1); + response = 'accepted'; + const retry = await page.evaluate(async () => { + const f = window.hcp085Fixture; + const permission = f.permission( + 'peer', + f.peerOrigin, + 'reviewed_private_delivery', + window.hcp085SharedAction + ); + if (!permission) throw Error('genuine original explicit retry permission'); + return f.publish(permission); + }); + expect(retry.status).toBe('accepted'); + expect(retry.eventId).toBe(first.eventId); + expect(retry.attempt).toBe(2); + expect(constructed).toBe(1); + expect(peak).toBe(1); + const events = frames.filter(({ frame }) => frame[0] === 'EVENT'); + expect(events).toHaveLength(2); + expect(events[1].frame[1]).toEqual(events[0].frame[1]); +}); diff --git a/web/tests/e2e/product-request.spec.ts b/web/tests/e2e/product-request.spec.ts @@ -10,6 +10,9 @@ import type * as Fixture from './harness/product-request.ts'; declare global { interface Window { + cr007PendingSend?: Promise<unknown>; + cr007DelayPrivateClose?: boolean; + cr007DelayedCloses?: (() => void)[]; hcp107: typeof Fixture; hcp107Fixture: Awaited<ReturnType<typeof Fixture.renderFixture>>; hcp108SendClock: { @@ -31,6 +34,7 @@ declare global { let server: Awaited<ReturnType<typeof createStaticHarness>>; let sockets: WebSocketServer, endpoint: string, bundle: string; let missingOwn = false; +let holdPrivateAck = false; let listingStatus: 'active' | 'sold' | 'withdrawn' = 'active'; let sellerInbox: | 'normal' @@ -98,9 +102,10 @@ test.beforeAll(async () => { events.push({ origin, event }); if (event.kind === 10050) ownPreference = event as ReturnType<typeof finalizeEvent>; - socket.send( - JSON.stringify(['OK', event.id, true, 'controlled acceptance']) - ); + if (!holdPrivateAck || event.kind !== 1059) + socket.send( + JSON.stringify(['OK', event.id, true, 'controlled acceptance']) + ); return; } if (frame[0] !== 'REQ') return; @@ -282,6 +287,7 @@ test.afterAll(async () => { test.beforeEach(async ({ page }) => { events = []; missingOwn = false; + holdPrivateAck = false; listingStatus = 'active'; sellerInbox = 'normal'; incompleteListing = false; @@ -307,6 +313,15 @@ test.beforeEach(async ({ page }) => { ) throw Error('unapproved destination'); super(endpoint + '/?source=' + encodeURIComponent(origin), protocols); + this.cr007Private = origin !== 'wss://discovery.example.org'; + } + readonly cr007Private: boolean; + override close(code?: number, reason?: string) { + if (this.cr007Private && window.cr007DelayPrivateClose) + (window.cr007DelayedCloses ??= []).push(() => + super.close(code, reason) + ); + else super.close(code, reason); } }; }, @@ -317,7 +332,11 @@ test.beforeEach(async ({ page }) => { }); test.afterEach(async ({ page }) => { if (!page.isClosed()) - await page.evaluate(() => window.hcp107Fixture?.close()); + await page.evaluate(() => { + window.cr007DelayPrivateClose = false; + for (const release of window.cr007DelayedCloses ?? []) release(); + return window.hcp107Fixture?.close(); + }); }); const panel = (page: Page) => page.locator('[data-request-fixture]'); const editor = (page: Page) => @@ -1672,3 +1691,33 @@ for (const outcome of [ expect(events.filter((row) => row.event.kind === 1059)).toEqual([]); } }); + +test('CR007 pending actual product request EVENT plus route close settles stopped and preserves cleanup', async ({ + page +}) => { + await ready(page); + await unlock(page); + holdPrivateAck = true; + await page.evaluate(() => { + window.cr007DelayPrivateClose = true; + window.cr007PendingSend = window.hcp107Fixture.beginHeadless(); + }); + await expect + .poll(() => events.filter(({ event }) => event.kind === 1059).length) + .toBe(1); + await page.evaluate(() => window.hcp107Fixture.closeView()); + expect(await page.evaluate(() => window.cr007PendingSend)).toEqual({ + status: 'stopped' + }); + expect( + await page.evaluate(() => window.hcp107Fixture.headlessSnapshot()) + ).toBeUndefined(); + expect(events.filter(({ event }) => event.kind === 1059)).toHaveLength(1); + expect( + await page.evaluate(() => window.cr007DelayedCloses?.length ?? 0) + ).toBeGreaterThan(0); + await page.evaluate(() => { + window.cr007DelayPrivateClose = false; + for (const release of window.cr007DelayedCloses ?? []) release(); + }); +}); diff --git a/web/tests/e2e/reply-composer.spec.ts b/web/tests/e2e/reply-composer.spec.ts @@ -9,6 +9,9 @@ import type * as Fixture from './harness/reply-composer.ts'; import { finalizeEvent } from 'applesauce-core/helpers'; declare global { interface Window { + cr007PendingSend?: Promise<unknown>; + cr007DelayPrivateClose?: boolean; + cr007DelayedCloses?: (() => void)[]; hcp104: typeof Fixture; hcp104Fixture: Awaited<ReturnType<typeof Fixture.renderReplyFixture>>; hcp104Pending?: Promise<unknown>; @@ -22,6 +25,7 @@ let events: unknown[][] = [], requests: unknown[][] = []; let servePeerPreference = false; let holdPeerEose = false; +let holdPrivateAck = false; let heldPeerRequest: | { socket: WebSocket; @@ -77,7 +81,8 @@ test.beforeAll(async () => { if (frame[0] === 'EVENT') { events.push(frame); const event = frame[1] as { id: string }; - socket.send(JSON.stringify(['OK', event.id, true, ''])); + if (!holdPrivateAck) + socket.send(JSON.stringify(['OK', event.id, true, ''])); } if (frame[0] === 'REQ') { requests.push(frame); @@ -157,6 +162,16 @@ async function load(page: import('@playwright/test').Page) { ) throw Error('unapproved destination'); super(endpoint, protocols); + this.cr007Private = + new URL(String(url)).origin !== 'wss://discovery.example.org'; + } + readonly cr007Private: boolean; + override close(code?: number, reason?: string) { + if (this.cr007Private && window.cr007DelayPrivateClose) + (window.cr007DelayedCloses ??= []).push(() => + super.close(code, reason) + ); + else super.close(code, reason); } }; }, @@ -170,6 +185,7 @@ test.beforeEach(async ({ page }) => { requests = []; servePeerPreference = false; holdPeerEose = false; + holdPrivateAck = false; heldPeerRequest = undefined; await load(page); }); @@ -178,6 +194,8 @@ test.afterEach(async ({ page }) => { await page.evaluate(async () => { window.hcp104Fixture?.settle(); await window.hcp104Pending; + window.cr007DelayPrivateClose = false; + for (const release of window.cr007DelayedCloses ?? []) release(); await window.hcp104Fixture?.close(); }); }); @@ -917,3 +935,34 @@ test('later edit after opening dirty warning invalidates the reviewed discard re expect(events).toEqual([]); expect(requests).toEqual([]); }); + +test('CR007 pending actual reply EVENT plus route close settles stopped and preserves physical cleanup', async ({ + page +}) => { + await ready(page); + await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel); + holdPrivateAck = true; + await page.evaluate(() => { + window.cr007DelayPrivateClose = true; + window.cr007PendingSend = window.hcp104Fixture.send(); + }); + await expect.poll(() => events.length).toBe(1); + await page.evaluate(() => window.hcp104Fixture.closeComposer()); + expect(await page.evaluate(() => window.cr007PendingSend)).toEqual({ + status: 'stopped' + }); + expect( + await page.evaluate(() => window.hcp104Fixture.snapshot()) + ).toBeUndefined(); + expect( + await page.evaluate(() => window.hcp104Fixture.text()) + ).toBeUndefined(); + expect(events).toHaveLength(1); + expect( + await page.evaluate(() => window.cr007DelayedCloses?.length ?? 0) + ).toBeGreaterThan(0); + await page.evaluate(() => { + window.cr007DelayPrivateClose = false; + for (const release of window.cr007DelayedCloses ?? []) release(); + }); +}); diff --git a/web/tests/integration/private-pool.test.ts b/web/tests/integration/private-pool.test.ts @@ -22,6 +22,7 @@ import { privatePoolOrigins, subscribePrivatePage, closePrivatePool, + privatePoolCleanupRequired, type PrivatePageMessage } from '../../src/lib/nostr/private-pool.ts'; import { @@ -235,6 +236,13 @@ await test('private page transport keeps actual SDK scopes and ownership separat ); }); } + async function awaitRetirement() { + while (privatePool && privatePoolCleanupRequired(privatePool)) { + if (privateSessionSnapshot(privateSession!)?.current === false) + closePrivateSession(privateSession!); + await new Promise<void>((resolve) => setImmediate(resolve)); + } + } async function heldPage() { delivery = 'hold'; heldRequests = 0; @@ -401,6 +409,7 @@ await test('private page transport keeps actual SDK scopes and ownership separat await t.test( 'same-author reconnect cannot revive an old scope or consume stale callbacks', async () => { + await awaitRetirement(); await connectIdentity(identity); await probeIdentityMessaging(identity, 'reviewed_self_copy'); assert.equal(privateSessionSnapshot(privateSession!)?.current, false); @@ -420,7 +429,7 @@ await test('private page transport keeps actual SDK scopes and ownership separat ); await t.test( 'failed SDK cleanup blocks replacement until exact cleanup retry succeeds', - () => { + async () => { const before = constructed; const held = sdkScopes.get('private'); assert.ok(held); @@ -428,17 +437,44 @@ await test('private page transport keeps actual SDK scopes and ownership separat if (this === held) throw new Error('HC_TEST_ONLY_CLOSE_FAILURE'); return originalClose.call(this); }; + // Actual session teardown owns whole-SDK disposal; an operation scope + // may close only its own work and cannot exercise this failure port. + assert.equal(closePrivateSession(privateSession!), false); assert.throws( - () => closePrivatePool(privatePool!), - /private_pool_close_failed/ + () => getPrivatePool(privateSession!, policy, origins), + /private_session_invalid/ + ); + assert.equal( + await createPrivateSession(identity, 'reviewed_private_session'), + undefined + ); + const successorIdentity = createIdentitySession(); + await connectIdentity(successorIdentity); + await probeIdentityMessaging(successorIdentity, 'reviewed_self_copy'); + const blockedSuccessor = await createPrivateSession( + successorIdentity, + 'reviewed_private_session' ); + assert.ok(blockedSuccessor); assert.throws( - () => getPrivatePool(privateSession!, policy, origins), + () => getPrivatePool(blockedSuccessor, policy, origins), /private_pool_closed/ ); + closePrivateSession(blockedSuccessor); + disconnectIdentity(successorIdentity); assert.equal(constructed, before); RelayPool.prototype.close = originalClose; - closePrivatePool(privatePool!); + while (!closePrivateSession(privateSession!)) + await new Promise<void>((resolve) => setImmediate(resolve)); + assert.equal(closePrivateSession(privateSession!), true); + const next = await createPrivateSession( + identity, + 'reviewed_private_session' + ); + assert.ok(next); + privateSession = next; + privatePool = getPrivatePool(next, policy, origins); + assert.ok(privatePool); } ); await t.test( @@ -607,6 +643,7 @@ await test('private page transport keeps actual SDK scopes and ownership separat } finally { Subscription.prototype.unsubscribe = original; closePrivatePool(privatePool!); + await awaitRetirement(); privatePool = getPrivatePool(privateSession!, policy, origins); assert.ok(privatePool); } @@ -638,6 +675,7 @@ await test('private page transport keeps actual SDK scopes and ownership separat unexpected?.(); Subscription.prototype.unsubscribe = original; closePrivatePool(privatePool!); + await awaitRetirement(); } } ); @@ -682,6 +720,7 @@ await test('private page transport keeps actual SDK scopes and ownership separat await t.test( 'candidate clock reentry cannot disclose old-owner ciphertext after logout', async () => { + await awaitRetirement(); await connectIdentity(identity); await probeIdentityMessaging(identity, 'reviewed_self_copy'); privateSession = await createPrivateSession( @@ -729,6 +768,7 @@ await test('private page transport keeps actual SDK scopes and ownership separat await t.test( 'delayed genuine SDK owner response cannot open old-session sockets after logout', async () => { + await awaitRetirement(); await connectIdentity(identity); await probeIdentityMessaging(identity, 'reviewed_self_copy'); privateSession = await createPrivateSession( @@ -807,6 +847,7 @@ await test('private page transport keeps actual SDK scopes and ownership separat await t.test( 'capability loss closes actual private transport and signing alone cannot reopen it', async () => { + await awaitRetirement(); await connectIdentity(identity); await probeIdentityMessaging(identity, 'reviewed_self_copy'); privateSession = await createPrivateSession( diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs @@ -1938,6 +1938,10 @@ import { auditOutput } from '../../tools/check-output.mjs'; } for (const producer of [ 'src/lib/config/operation-flags.ts', + 'src/lib/nostr/private-pool.ts', + 'src/lib/messaging/inbox-access-controller.ts', + 'src/lib/messaging/inbox-sync.ts', + 'src/lib/nostr/inbox-ingress.ts', 'src/lib/config/relays.ts', 'src/lib/runtime/capabilities.ts', 'src/lib/components/AppShell.svelte', diff --git a/web/tests/provenance/source-boundaries.test.mjs b/web/tests/provenance/source-boundaries.test.mjs @@ -18,6 +18,42 @@ import path from 'node:path'; import { fileURLToPath } from 'node:url'; import { test } from 'node:test'; +test('CR007 exact private SDK removal cannot become an arbitrary remove capability', async () => { + await fixture(async ({ directory, put, execute }) => { + await isolateScriptDependencies(directory); + await cp(path.join(root, 'src'), path.join(directory, 'src'), { + recursive: true + }); + assert.equal(execute().status, 0); + const file = 'src/lib/nostr/private-pool.ts'; + const source = await readFile(path.join(root, file), 'utf8'); + assert.ok(source.includes('sdk.remove(relay)')); + for (const mutation of [ + source + '\n export const unreviewedChange=1;\n', + source.replace('sdk.remove(relay)', 'sdk["remove"](relay)'), + source.replace('sdk.remove(relay)', 'sdk.remove(document.body)'), + source.replace('sdk.remove(relay)', '(sdk.remove)(relay)') + ]) { + await put(file, mutation); + const result = execute(); + assert.notEqual(result.status, 0); + assert.match(result.stderr, /private relay removal source identity/); + } + await put(file, source); + await put('src/lib/nostr/copied-private-pool.ts', source); + assert.notEqual(execute().status, 0); + await rm(path.join(directory, 'src/lib/nostr/copied-private-pool.ts')); + await rm(path.join(directory, file)); + assert.notEqual(execute().status, 0); + await put(file, source); + await put( + 'src/routes/+page.ts', + 'const receiver=document.body;receiver.remove();' + ); + assert.notEqual(execute().status, 0); + }); +}); + test('HCP060 document visibility access is confined to the exact disposal producer', async () => { await fixture(async ({ directory, put, execute }) => { await confineSvelte(directory); diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs @@ -314,18 +314,24 @@ async function operationalFlagsAdmission(web) { '9cc82877bfa8dbb2a7fa41bceb842793349416271f19569f49fdd5cfc1de07e5', 'src/lib/messaging/inbox-setup-operation.ts': '245c6ce88b146dc731e7ace4f16dc9b5002a87a997f5568e4811b0c4a2daf035', + 'src/lib/nostr/private-pool.ts': + 'b4c718364625b3caacbc5cc5f98bd79a575a5d66dddb2d7f59f03351a1308a6d', + 'src/lib/nostr/inbox-ingress.ts': + 'f860a094a8ba767585124c795d44b7620064f73a5b3a0170041c581c0fc64ecb', + 'src/lib/messaging/inbox-access-controller.ts': + 'c3093fe329575aba43333675c28352a6c0ddf24bcbc380c27f3a1ebab6252c5b', 'src/lib/messaging/inbox-setup-view.ts': 'e85238d20f1bbcb23599b36e67910f3df784efa43f0fa0b0b7f3da7e7fd33c79', 'src/lib/messaging/inbox-setup.ts': '7a935d8542ff8f64287d2b441a8a458d299dea4ed88beecda39cb1637dd4a9ac', 'src/lib/messaging/inbox-sync.ts': - '84f9b3bb165a81878bb281c51d245aff7eb06a0fa55b857a49b13d0cb1cff8ae', + '0d91f5895e7eb054b036a5cb80897a3d60a212d470029a82d11124c8536b3d2c', 'src/lib/messaging/inbox-view.ts': '6871707ae7395d3679856a01e87c7d8f273848e0b9ef0dc7b94f450d8417528c', 'src/lib/messaging/product-request-controller.ts': - '0255f1d160f4f5f9d6a66d836a9473fbf4c03f9b569568a84bb4ec65c52b9c7e', + 'e1fab3a2bfb910c1d8b798628cf4799cd1f7e72f1d80ebc2a67e73730b6f3940', 'src/lib/messaging/reply-controller.ts': - '60225bff6229c1f288a7f7eed55a7fdb780f853cd8b82d4f3995259a26d58eb1', + '8d2612b4788211b35ee8d56caa389bb88a53268bbba71407ee787c9dc23ee8a6', 'src/lib/messaging/rumor-plan.ts': 'b622889e96f911501524cd86f9fca9f2207ce853767494fb30799b00ae8275ed', 'src/lib/persistence/private-send-reservations.ts': @@ -570,14 +576,20 @@ async function privacyDataAdmission(web) { 'be704e6cbe777722c3eb80ec9843f00afd7bac8c52af0c2af7294f2437414553', 'src/lib/messaging/inbox-list.ts': '9cc82877bfa8dbb2a7fa41bceb842793349416271f19569f49fdd5cfc1de07e5', + 'src/lib/nostr/private-pool.ts': + 'b4c718364625b3caacbc5cc5f98bd79a575a5d66dddb2d7f59f03351a1308a6d', + 'src/lib/nostr/inbox-ingress.ts': + 'f860a094a8ba767585124c795d44b7620064f73a5b3a0170041c581c0fc64ecb', + 'src/lib/messaging/inbox-access-controller.ts': + 'c3093fe329575aba43333675c28352a6c0ddf24bcbc380c27f3a1ebab6252c5b', 'src/lib/messaging/inbox-setup-view.ts': '4ec9025232bb1355fef1ba039b46ce0a2be10e02e348e1b4eaadc3d1f3c2fd84', 'src/lib/messaging/inbox-sync.ts': - '84f9b3bb165a81878bb281c51d245aff7eb06a0fa55b857a49b13d0cb1cff8ae', + '0d91f5895e7eb054b036a5cb80897a3d60a212d470029a82d11124c8536b3d2c', 'src/lib/messaging/inbox-view.ts': '6871707ae7395d3679856a01e87c7d8f273848e0b9ef0dc7b94f450d8417528c', 'src/lib/messaging/reply-controller.ts': - '60225bff6229c1f288a7f7eed55a7fdb780f853cd8b82d4f3995259a26d58eb1', + '8d2612b4788211b35ee8d56caa389bb88a53268bbba71407ee787c9dc23ee8a6', 'src/lib/messaging/rumor-plan.ts': 'b622889e96f911501524cd86f9fca9f2207ce853767494fb30799b00ae8275ed', 'src/lib/persistence/private-send-reservations.ts': @@ -792,11 +804,11 @@ async function supportReportingAdmission(web) { 'src/lib/messaging/inbox-setup-view.ts': '4ec9025232bb1355fef1ba039b46ce0a2be10e02e348e1b4eaadc3d1f3c2fd84', 'src/lib/messaging/inbox-sync.ts': - '84f9b3bb165a81878bb281c51d245aff7eb06a0fa55b857a49b13d0cb1cff8ae', + '0d91f5895e7eb054b036a5cb80897a3d60a212d470029a82d11124c8536b3d2c', 'src/lib/messaging/inbox-view.ts': '6871707ae7395d3679856a01e87c7d8f273848e0b9ef0dc7b94f450d8417528c', 'src/lib/messaging/reply-controller.ts': - '60225bff6229c1f288a7f7eed55a7fdb780f853cd8b82d4f3995259a26d58eb1', + '8d2612b4788211b35ee8d56caa389bb88a53268bbba71407ee787c9dc23ee8a6', 'src/lib/messaging/rumor-plan.ts': 'b622889e96f911501524cd86f9fca9f2207ce853767494fb30799b00ae8275ed', 'src/lib/persistence/private-send-reservations.ts': @@ -981,11 +993,11 @@ async function privateBlockingAdmission(web) { 'src/lib/messaging/inbox-setup-view.ts': '4ec9025232bb1355fef1ba039b46ce0a2be10e02e348e1b4eaadc3d1f3c2fd84', 'src/lib/messaging/inbox-sync.ts': - '84f9b3bb165a81878bb281c51d245aff7eb06a0fa55b857a49b13d0cb1cff8ae', + '0d91f5895e7eb054b036a5cb80897a3d60a212d470029a82d11124c8536b3d2c', 'src/lib/messaging/inbox-view.ts': '6871707ae7395d3679856a01e87c7d8f273848e0b9ef0dc7b94f450d8417528c', 'src/lib/messaging/reply-controller.ts': - '60225bff6229c1f288a7f7eed55a7fdb780f853cd8b82d4f3995259a26d58eb1', + '8d2612b4788211b35ee8d56caa389bb88a53268bbba71407ee787c9dc23ee8a6', 'src/lib/messaging/rumor-plan.ts': 'b622889e96f911501524cd86f9fca9f2207ce853767494fb30799b00ae8275ed', 'src/lib/persistence/private-send-reservations.ts': @@ -2130,7 +2142,7 @@ async function inboxPresentationAdmission(web) { 'src/lib/messaging/inbox-view.ts': 'f725d1e122550232efa52b26139d3047d3bbfd6d3d11b1ef0a110b5e4b4410dc', 'src/lib/messaging/inbox-sync.ts': - '84f9b3bb165a81878bb281c51d245aff7eb06a0fa55b857a49b13d0cb1cff8ae', + '0d91f5895e7eb054b036a5cb80897a3d60a212d470029a82d11124c8536b3d2c', 'src/lib/messaging/inbox-setup-view.ts': '4ec9025232bb1355fef1ba039b46ce0a2be10e02e348e1b4eaadc3d1f3c2fd84', 'src/lib/messaging/decryption-queue.ts': diff --git a/web/tools/source-boundaries.mjs b/web/tools/source-boundaries.mjs @@ -120,7 +120,8 @@ function mutationAdmission( reviewedScroll = false, reviewedCopy = false, reviewedVisibility = false, - reviewedReport = false + reviewedReport = false, + reviewedRelayRemoval = false ) { // Bind this admitted AST only, without libs, module resolution, file reads, // config loading or evaluation. Symbols distinguish aliases and shadowing. @@ -159,6 +160,51 @@ function mutationAdmission( ts.isStringLiteralLike(node.argumentExpression) ? node.argumentExpression.text : null; + function relayRemoval(node) { + if ( + !reviewedRelayRemoval || + !ts.isPropertyAccessExpression(node) || + node.name.text !== 'remove' || + !ts.isIdentifier(node.expression) || + !ts.isCallExpression(node.parent) || + node.parent.expression !== node || + node.parent.arguments.length !== 1 || + !ts.isIdentifier(node.parent.arguments[0]) + ) + return false; + const declaration = checker.getSymbolAtLocation( + node.expression + )?.valueDeclaration; + if ( + !declaration || + !ts.isVariableDeclaration(declaration) || + !(declaration.parent.flags & ts.NodeFlags.Const) + ) + return false; + const call = declaration.initializer && unwrap(declaration.initializer); + if ( + !call || + !ts.isCallExpression(call) || + call.arguments.length !== 0 || + !ts.isIdentifier(call.expression) + ) + return false; + const factory = checker.getSymbolAtLocation(call.expression) + ?.declarations?.[0]; + if ( + !factory || + !ts.isImportSpecifier(factory) || + (factory.propertyName?.text ?? factory.name.text) !== + 'createScopedRelayPool' + ) + return false; + const imported = factory.parent.parent.parent; + return ( + ts.isImportDeclaration(imported) && + ts.isStringLiteral(imported.moduleSpecifier) && + imported.moduleSpecifier.text === './pool-factory.ts' + ); + } function uiLeaf(node) { let top = node; while ( @@ -973,7 +1019,8 @@ function mutationAdmission( !owned(node.expression) || !node.parent.arguments.every((argument) => pure(argument)) ) - report('opaque or indirect DOM mutation/setter APIs are forbidden'); + if (!relayRemoval(node)) + report('opaque or indirect DOM mutation/setter APIs are forbidden'); } } if (ts.isIdentifier(node)) { @@ -1610,6 +1657,19 @@ export async function auditSource(root) { reportFile, 'report copy source identity does not match reviewed pin' ); + // One reviewed transport producer may retire its own original SDK Relay. + // Complete bytes, original imported factory receiver and a direct call are + // required; no arbitrary DOM remove/alias/reflection exception is granted. + const relayRemovalFile = path.join(root, 'src/lib/nostr/private-pool.ts'); + const relayRemovalTrusted = + files.has(relayRemovalFile) && + createHash('sha256').update(files.get(relayRemovalFile)).digest('hex') === + 'b4c718364625b3caacbc5cc5f98bd79a575a5d66dddb2d7f59f03351a1308a6d'; + if (files.has(relayRemovalFile) && !relayRemovalTrusted) + complain( + relayRemovalFile, + 'private relay removal source identity does not match reviewed pin' + ); const scrollFile = path.join(root, 'src/lib/navigation-scroll.ts'); const scrollTrusted = files.has(scrollFile) && @@ -2116,7 +2176,8 @@ export async function auditSource(root) { file === scrollFile && scrollTrusted, file === copyFile && copyTrusted, file === visibilityFile && visibilityTrusted, - file === reportFile && reportTrusted + file === reportFile && reportTrusted, + file === relayRemovalFile && relayRemovalTrusted ); if (ast.referencedFiles.length || ast.typeReferenceDirectives.length) complain(file, 'source reference directives are forbidden');