app

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

commit b26cf65b35de5463ad9dfc177d332a2c150f2902
parent aae0805cc6c754219508c30fb93ec1468eface68
Author: triesap <tyson@radroots.org>
Date:   Wed,  7 Oct 2026 04:08:29 +0000

messages: create the identity-scoped private transport runtime (HCP-057)

- Share the reviewed Applesauce factory across separate public and private lifetimes.
- Bind explicit private activation and finite reads to the actual identity generation.
- Bound approved inbox candidates and retain unavailable state after cleanup failure.
- Verify SDK isolation, stale ownership, bounded reads and asynchronous cleanup recovery.

Diffstat:
Mweb/src/lib/config/budgets.ts | 11+++++++++++
Mweb/src/lib/nostr/extension.ts | 55+++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/src/lib/nostr/pool-factory.ts | 12++++++++++++
Aweb/src/lib/nostr/private-pool.ts | 302++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/nostr/public-pool.ts | 9++-------
Mweb/src/lib/runtime/identity-session.ts | 17+++++++++++++++++
Aweb/src/lib/runtime/private-session.ts | 135+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/integration/private-pool.test.ts | 861+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/unit/private-session.test.ts | 29+++++++++++++++++++++++++++++
9 files changed, 1424 insertions(+), 7 deletions(-)

diff --git a/web/src/lib/config/budgets.ts b/web/src/lib/config/budgets.ts @@ -6,6 +6,17 @@ export const RELAY_BUDGETS = Object.freeze({ inbox: 3 }); +// Finite private transport page; duplicates and rejected ciphertext count. +// Full history/live coordination has separate owners. These are logical +// post-SDK-parse limits, not browser WebSocket allocation guarantees. +export const PRIVATE_TRANSPORT_BUDGETS = Object.freeze({ + requestedPerRelay: 200, + deliveries: 500, + processedBytes: 8388608, + pageMilliseconds: 15000, + envelopeBytes: 32768 +}); + // Approved public-run admission limits shared by all primary/auxiliary sources. // Logical post-parse work accounting; no WebSocket preallocation guarantee. const publicDeliveryLimit = 2000; diff --git a/web/src/lib/nostr/extension.ts b/web/src/lib/nostr/extension.ts @@ -81,6 +81,8 @@ type Controller = { recheck(): Promise<ExtensionSnapshot>; probe(review: unknown): Promise<ExtensionSnapshot>; capture(): PublicEffectCapture | undefined; + captureMessaging(): PublicEffectCapture | undefined; + subscribeInvalidation(listener: () => void): () => void; expire(approval: ApprovedPublicSigning, lease: PublicEffectLease): void; sign( approval: ApprovedPublicSigning, @@ -136,6 +138,16 @@ async function freshKey( // Lexically owned per-adapter state; no mutable opaque receiver, browser handle // or imported signer escapes through the WeakMap/controller boundary. export function createExtensionAdapter(): ExtensionAdapter { + const invalidations = new Map<symbol, () => void>(); + function notifyInvalidation() { + for (const listener of invalidations.values()) { + try { + listener(); + } catch { + /* Cleanup failure stays owned by its scope. */ + } + } + } let key: string | null = null, signingCandidate = false; let messaging: 'not_probed' | 'unsupported' | 'refused' | 'capable' = @@ -164,6 +176,7 @@ export function createExtensionAdapter(): ExtensionAdapter { signingCandidate = false; messaging = 'not_probed'; reason = nextReason; + notifyInvalidation(); } function disconnect() { generation = Symbol(); @@ -213,6 +226,7 @@ export function createExtensionAdapter(): ExtensionAdapter { guest(error instanceof ExtensionMissingError ? 'missing' : 'refused'); } finally { pending = null; + notifyInvalidation(); } return busy ? { ...snapshot(), admission: 'busy' } : snapshot(); } @@ -507,6 +521,36 @@ export function createExtensionAdapter(): ExtensionAdapter { current: () => generation === original && !cancelled && key === owner }; }, + captureMessaging() { + if ( + !key || + cancelled || + !signingCandidate || + messaging !== 'capable' || + pending || + signing + ) + return undefined; + const owner = key, + original = generation; + return { + owner, + session: original, + current: () => + generation === original && + !cancelled && + key === owner && + signingCandidate && + messaging === 'capable' + }; + }, + subscribeInvalidation(listener) { + const id = Symbol(); + invalidations.set(id, listener); + return () => { + invalidations.delete(id); + }; + }, sign, expire(approval, lease) { if (activeSigning?.approval === approval && activeSigning.lease === lease) @@ -573,6 +617,17 @@ export function extensionOwnershipCapture( ): PublicEffectCapture | undefined { return adapters.get(adapter)?.capture(); } +export function extensionMessagingOwnershipCapture( + adapter: ExtensionAdapter +): PublicEffectCapture | undefined { + return adapters.get(adapter)?.captureMessaging(); +} +export function subscribeExtensionInvalidation( + adapter: ExtensionAdapter, + listener: () => void +): () => void { + return adapters.get(adapter)?.subscribeInvalidation(listener) ?? (() => {}); +} // Internal exact original operation port. Expiry pauses the real scheduler; // neither this method nor a UI timeout pretends to cancel the SDK promise. export function markApprovedSigningWaitExpired( diff --git a/web/src/lib/nostr/pool-factory.ts b/web/src/lib/nostr/pool-factory.ts @@ -0,0 +1,12 @@ +import { RelayPool } from 'applesauce-relay/pool'; +// One implementation, distinct SDK instances and relay/AUTH stores. Only owned +// adapters call this factory; no SDK/options are exposed through UI capabilities. +export function createScopedRelayPool(): RelayPool { + if (typeof window === 'undefined') throw new Error('relay_pool_browser_only'); + return new RelayPool({ + keepAlive: 0, + enablePing: false, + requestReconnect: 0, + subscriptionReconnect: 0 + }); +} diff --git a/web/src/lib/nostr/private-pool.ts b/web/src/lib/nostr/private-pool.ts @@ -0,0 +1,302 @@ +import { createScopedRelayPool } from './pool-factory.ts'; +import { readRelayPolicy, type RelayPolicy } from '../config/relays.ts'; +import { PRIVATE_TRANSPORT_BUDGETS, RELAY_BUDGETS } from '../config/budgets.ts'; +import { + privateSessionOwnership, + subscribePrivateSessionClose, + recheckPrivateSession, + type PrivateSession +} from '../runtime/private-session.ts'; +import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts'; +declare const poolBrand: unique symbol; +export type PrivatePool = Readonly<{ [poolBrand]: true }>; +export type PrivatePageMessage = + | Readonly<{ type: 'candidate'; from: string; wire: string }> + | Readonly<{ + type: 'end'; + reason: + | 'complete' + | 'closed' + | 'stale' + | 'error' + | 'budget' + | 'elapsed' + | 'stopped'; + }>; +type Owner = { + session: PrivateSession; + policy: RelayPolicy; + origins: readonly string[]; + token: PrivatePool; + closed(): boolean; + cleaned(): boolean; + subscribe( + limit: number, + listener: (message: PrivatePageMessage) => void + ): () => void; + close(): void; +}; +const pools = new WeakMap<PrivatePool, Owner>(); +let lifetime: Owner | undefined; +// 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[] +): PrivatePool | undefined { + if (typeof window === 'undefined') return undefined; + const capture = privateSessionOwnership(session); + if (!capture) throw new Error('private_session_invalid'); + const manifest = readRelayPolicy(policy); + if (!manifest.messagingEnabled) throw new Error('private_pool_disabled'); + const length = Array.isArray(selected) ? selected.length : 0; + if (length < 1 || length > RELAY_BUDGETS.inbox) + throw new Error('private_pool_origins_invalid'); + const selectedOrigins = new Map<string, true>(); + for (let i = 0; i < length; i++) { + const origin = selected[i]; + if ( + typeof origin !== 'string' || + selectedOrigins.has(origin) || + !manifest.inbox.some((row) => row.origin === origin && row.read) + ) + throw new Error('private_pool_origins_invalid'); + selectedOrigins.set(origin, true); + } + const origins = [...selectedOrigins.keys()]; + // Untrusted selection access can run code. Recheck before factory admission. + 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]) + ) + throw new Error('private_pool_in_use'); + return lifetime.token; + } + } + const token = Object.freeze({}) as PrivatePool; + const sdk = createScopedRelayPool(); + let closed = false, + cleaned = false, + busy = false, + cleanupRequired = false; + let active = () => {}; + let off = () => {}; + const owner: Owner = { + session, + policy, + origins, + token, + closed: () => closed, + cleaned: () => cleaned, + subscribe(limit, listener) { + if (closed || !capture.current()) { + owner.close(); + throw new Error('private_pool_closed'); + } + if (cleanupRequired) throw new Error('private_page_cleanup_required'); + if (busy) throw new Error('private_page_busy'); + busy = true; + let ended = false, + deliveries = 0, + bytes = 0; + let release = () => {}; + let timer: ReturnType<typeof setTimeout> | undefined; + const completed = new Map<string, true>(); + let started = 0; + function emit(message: PrivatePageMessage) { + try { + listener(message); + } catch { + /* Consumer cannot interrupt cleanup. */ + } + } + function finish( + reason: Extract<PrivatePageMessage, { type: 'end' }>['reason'], + propagate = false + ) { + if (ended) { + if (cleanupRequired && propagate) { + release(); + cleanupRequired = false; + busy = false; + } + return; + } + ended = true; + if (timer !== undefined) clearTimeout(timer); + let failure: unknown; + try { + release(); + } catch (error) { + cleanupRequired = true; + failure = error; + } finally { + busy = cleanupRequired; + emit({ type: 'end', reason: cleanupRequired ? 'error' : reason }); + } + // SDK and timer callbacks report finite error state without leaking an + // exception. Explicit stop/close can report failure and retry release. + if (cleanupRequired && propagate) throw failure; + } + active = () => { + finish('closed', true); + release(); + }; + // 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()) { + finish('stale'); + return; + } + started = performance.now(); + if (ended || closed || !capture.current()) { + if (!ended) finish('stale'); + return; + } + const subscription = sdk + .req( + [...origins], + [{ kinds: [1059], '#p': [capture.owner], limit }], + { + waitForAuth: false, + reconnect: false, + resubscribe: false + } + ) + .subscribe({ + next(message) { + if (ended) return; + if (closed || !capture.current()) { + finish('stale'); + owner.close(); + return; + } + const elapsed = performance.now() - started; + if (ended || closed || !capture.current()) { + if (!ended) finish('stale'); + owner.close(); + return; + } + if (elapsed >= PRIVATE_TRANSPORT_BUDGETS.pageMilliseconds) { + finish('elapsed'); + return; + } + if (message.type === 'EOSE') { + completed.set(message.from, true); + if (completed.size === origins.length) finish('complete'); + } else if (message.type === 'EVENT') { + deliveries++; + if (deliveries > PRIVATE_TRANSPORT_BUDGETS.deliveries) { + finish('budget'); + return; + } + const wire = JSON.stringify(message.event); + // Charge actual encoded bytes, including rejected envelopes. An + // input beyond the remaining budget stops before encoding it. + if ( + typeof wire !== 'string' || + !boundedUtf8( + wire, + PRIVATE_TRANSPORT_BUDGETS.processedBytes - bytes + ) + ) { + finish('budget'); + return; + } + bytes += new TextEncoder().encode(wire).length; + const accepted = boundedUtf8( + wire, + PRIVATE_TRANSPORT_BUDGETS.envelopeBytes + ); + if (accepted) + emit({ type: 'candidate', from: message.from, wire }); + } else if (message.type === 'ERROR') finish('error'); + }, + complete: () => finish('complete'), + error: () => finish('error') + }); + release = () => { + subscription.unsubscribe(); + }; + if (ended || closed || !capture.current()) { + release(); + if (!ended) finish('stale'); + } else { + timer = setTimeout( + () => finish('elapsed'), + PRIVATE_TRANSPORT_BUDGETS.pageMilliseconds + ); + } + }) + .catch(() => { + if (!ended) finish('error'); + }); + return () => finish('stopped', true); + }, + close() { + if (cleaned) return; + closed = true; + let failed = false; + try { + active(); + } catch { + failed = true; + } + try { + sdk.close(); + } catch { + failed = true; + } + if (!failed) { + cleanupRequired = false; + cleaned = true; + off(); + } + if (failed) throw new Error('private_pool_close_failed'); + } + }; + // Install ownership before observer registration; reentry cannot allocate a + // second private SDK. A failed close retains this unavailable page lifetime. + pools.set(token, owner); + lifetime = owner; + off = subscribePrivateSessionClose(session, () => owner.close()); + if (!capture.current()) { + owner.close(); + throw new Error('private_session_invalid'); + } + return token; +} +function ownerOf(token: PrivatePool): Owner { + const owner = pools.get(token); + if (!owner) throw new Error('private_pool_invalid'); + return owner; +} +export function privatePoolOrigins(token: PrivatePool): readonly string[] { + return [...ownerOf(token).origins]; +} +export function subscribePrivatePage( + token: PrivatePool, + requested: number, + listener: (message: PrivatePageMessage) => void +): () => void { + if ( + !Number.isInteger(requested) || + requested < 1 || + requested > PRIVATE_TRANSPORT_BUDGETS.requestedPerRelay + ) + throw new Error('private_page_limit_invalid'); + return ownerOf(token).subscribe(requested, listener); +} +export function closePrivatePool(token: PrivatePool): void { + ownerOf(token).close(); +} diff --git a/web/src/lib/nostr/public-pool.ts b/web/src/lib/nostr/public-pool.ts @@ -1,4 +1,4 @@ -import { RelayPool } from 'applesauce-relay/pool'; +import { createScopedRelayPool } from './pool-factory.ts'; import { deploymentRelayPolicy } from '../config/deployment-relays.ts'; import { publicRelayTargets, @@ -40,12 +40,7 @@ export function getPublicPool( } const token = Object.freeze({}) as PublicPool; const origins = publicRelayTargets(policy, 'read'); - const sdk = new RelayPool({ - keepAlive: 0, - enablePing: false, - requestReconnect: 0, - subscriptionReconnect: 0 - }); + const sdk = createScopedRelayPool(); const active = new Map<() => void, true>(); let closed = false; let cleanupComplete = false; diff --git a/web/src/lib/runtime/identity-session.ts b/web/src/lib/runtime/identity-session.ts @@ -6,6 +6,8 @@ import { probeExtensionAdapter, disconnectExtensionAdapter, extensionOwnershipCapture, + extensionMessagingOwnershipCapture, + subscribeExtensionInvalidation, signApprovedExtensionAdapter, markApprovedSigningWaitExpired, type ApprovedSignResult, @@ -140,6 +142,21 @@ export function disconnectIdentity(session: IdentitySession): void { const adapter = sessions.get(session); if (adapter) disconnectExtensionAdapter(adapter); } +// Internal messaging lifecycle ports. Captured observation is not an inbox +// configuration, AUTH, private store or publication permission. +export function identityMessagingOwnership( + session: IdentitySession +): PublicEffectCapture | undefined { + const adapter = sessions.get(session); + return adapter && extensionMessagingOwnershipCapture(adapter); +} +export function subscribeIdentityInvalidation( + session: IdentitySession, + listener: () => void +): () => void { + const adapter = sessions.get(session); + return adapter ? subscribeExtensionInvalidation(adapter, listener) : () => {}; +} // Explicit route/input lifecycle event. No draft, DB, reconnect or SDK effect. export function invalidateIdentityOperations(session: IdentitySession): void { views.get(session)?.invalidate(); diff --git a/web/src/lib/runtime/private-session.ts b/web/src/lib/runtime/private-session.ts @@ -0,0 +1,135 @@ +import { + identityMessagingOwnership, + recheckIdentityOwner, + subscribeIdentityInvalidation, + type IdentitySession +} from './identity-session.ts'; +import type { PublicEffectCapture } from './effect-ownership.ts'; +declare const privateBrand: unique symbol; +export type PrivateSession = Readonly<{ [privateBrand]: true }>; +type Controller = { + identity: IdentitySession; + capture: PublicEffectCapture; + current(): boolean; + close(): void; + subscribe(listener: () => void): () => void; +}; +const sessions = new WeakMap<PrivateSession, Controller>(); +const currentSessions = new WeakMap<IdentitySession, PrivateSession>(); +// No sockets, decryption, stores or readiness on construction. Only an explicit +// capability action may perform the fresh owner recheck through the page SDK +// scheduler. The generation is the real adapter's, not a caller-supplied key. +export async function createPrivateSession( + identity: IdentitySession, + review: unknown +): Promise<PrivateSession | undefined> { + if (typeof window === 'undefined' || review !== 'reviewed_private_session') + return undefined; + const before = identityMessagingOwnership(identity); + if (!before) return undefined; + const checked = await recheckIdentityOwner(identity); + const capture = identityMessagingOwnership(identity); + if ( + !before.current() || + checked.state !== 'messaging_capable' || + checked.admission === 'busy' || + !capture || + capture.owner !== before.owner || + capture.session !== before.session + ) + return undefined; + const existing = currentSessions.get(identity); + if (existing && sessions.get(existing)?.current()) return existing; + const token = Object.freeze({}) as PrivateSession; + const listeners = new Map<symbol, () => void>(); + let closed = false; + let unsubscribe = () => {}; + const current = () => !closed && capture.current(); + function close() { + if (closed) return; + closed = true; + unsubscribe(); + for (const listener of listeners.values()) { + try { + listener(); + } catch { + /* Pool retains failed cleanup until retry. */ + } + } + listeners.clear(); + } + sessions.set(token, { + identity, + capture, + current, + close, + subscribe(listener) { + if (!current()) { + close(); + listener(); + return () => {}; + } + const id = Symbol(); + listeners.set(id, listener); + return () => { + listeners.delete(id); + }; + } + }); + unsubscribe = subscribeIdentityInvalidation(identity, () => { + if (!current()) close(); + }); + // Observe again after registering: no missed invalidation/acquisition seam. + if (!current()) { + close(); + return undefined; + } + currentSessions.set(identity, token); + return token; +} +export function privateSessionOwnership( + token: PrivateSession +): PublicEffectCapture | undefined { + const state = sessions.get(token); + if (!state?.current()) { + state?.close(); + return undefined; + } + return { + owner: state.capture.owner, + session: state.capture.session, + current: () => state.current() + }; +} +export function privateSessionSnapshot( + token: PrivateSession +): Readonly<{ owner: string; current: boolean }> | undefined { + const state = sessions.get(token); + return state && { owner: state.capture.owner, current: state.current() }; +} +export function subscribePrivateSessionClose( + token: PrivateSession, + listener: () => void +): () => void { + const state = sessions.get(token); + if (!state) throw new Error('private_session_invalid'); + return state.subscribe(listener); +} +export function closePrivateSession(token: PrivateSession): void { + sessions.get(token)?.close(); +} +// Every new finite network action gets a fresh SDK owner observation; neither +// a remembered key nor a still-current presentation snapshot substitutes. +export async function recheckPrivateSession( + token: PrivateSession +): Promise<boolean> { + const state = sessions.get(token); + if (!state?.current()) return false; + const checked = await recheckIdentityOwner(state.identity); + return ( + state.current() && + checked.state === 'messaging_capable' && + checked.publicKey === state.capture.owner && + checked.admission !== 'busy' + ); +} diff --git a/web/tests/integration/private-pool.test.ts b/web/tests/integration/private-pool.test.ts @@ -0,0 +1,861 @@ +import { test } from 'node:test'; +import assert from 'node:assert/strict'; +import { once } from 'node:events'; +import WebSocket, { WebSocketServer } from 'ws'; +import { RelayPool } from 'applesauce-relay/pool'; +import { createRequire } from 'node:module'; +import { validateRelayPolicy } from '../../src/lib/config/relays.ts'; +import { + createIdentitySession, + connectIdentity, + probeIdentityMessaging, + disconnectIdentity, + recheckIdentityOwner +} from '../../src/lib/runtime/identity-session.ts'; +import { + createPrivateSession, + privateSessionSnapshot, + closePrivateSession +} from '../../src/lib/runtime/private-session.ts'; +import { + getPrivatePool, + privatePoolOrigins, + subscribePrivatePage, + closePrivatePool, + type PrivatePageMessage +} from '../../src/lib/nostr/private-pool.ts'; +import { + getPublicPool, + subscribePublicPool, + closePublicPool +} from '../../src/lib/nostr/public-pool.ts'; + +// HC_TEST_ONLY_RELAY/provider: genuine pinned SDK, fixed logical origins mapped +// solely here to loopback. Echo cipher and AUTH-state instrumentation qualify +// transport/lifecycle isolation, never encryption, signatures or relay access. +await test('private page transport keeps actual SDK scopes and ownership separate', async (t) => { + // Resolve the SDK's actual pinned transitive RxJS for teardown fault injection; + // it is not a new application dependency or replacement Observable. + const sdkRxjs: unknown = createRequire( + import.meta.resolve('applesauce-relay/pool') + )('rxjs'); + const Subscription = ( + sdkRxjs as { + Subscription: { + prototype: ReturnType<ReturnType<RelayPool['req']>['subscribe']>; + }; + } + ).Subscription; + const owner = + '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'; + const other = + 'c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5'; + const origins = [ + 'wss://relay.example.org', + 'wss://relay-two.example.org', + 'wss://relay-three.example.org' + ]; + const policy = validateRelayPolicy( + JSON.stringify({ + schemaVersion: 1, + public: origins.map((origin) => ({ + origin, + read: true, + write: false, + nip50: false + })), + inbox: origins.map((origin) => ({ origin, read: true, write: true })), + postingEnabled: false, + messagingEnabled: true, + operatorDenylist: [] + }) + ); + assert.ok(policy); + assert.equal( + await createPrivateSession( + createIdentitySession(), + 'reviewed_private_session' + ), + undefined + ); + assert.equal(getPrivatePool({} as never, policy, origins), undefined); + const originalSocket = globalThis.WebSocket, + originalFetch = globalThis.fetch, + originalReq = Reflect.get(RelayPool.prototype, 'req'), + originalClose = Reflect.get(RelayPool.prototype, 'close'); + assert.equal( + Object.getOwnPropertyDescriptor(globalThis, 'window'), + undefined + ); + const server = new WebSocketServer({ + host: '127.0.0.1', + port: 0, + maxPayload: 65536 + }); + const sockets: WebSocket[] = []; + const frames: unknown[][] = []; + let delivery: + | 'normal' + | 'flood' + | 'oversize' + | 'hold' + | 'byte-flood' + | 'rejected-byte-flood' + | 'single' = 'normal'; + let eventWritten = false; + let heldReady = () => {}; + let heldRequests = 0; + const raw = { + id: '1'.repeat(64), + pubkey: other, + kind: 1059, + created_at: 1, + tags: [['p', owner]], + content: 'untrusted ciphertext', + sig: '0'.repeat(128) + }; + server.on('connection', (socket) => { + sockets.push(socket); + socket.send(JSON.stringify(['AUTH', 'unsolicited-challenge'])); + socket.on('message', (bytes) => { + const buffer = Array.isArray(bytes) + ? Buffer.concat(bytes) + : Buffer.isBuffer(bytes) + ? bytes + : Buffer.from(bytes); + const frame: unknown = JSON.parse(buffer.toString('utf8')); + assert.ok(Array.isArray(frame)); + frames.push(frame); + if (frame[0] !== 'REQ') return; + const filter = frame[2] as { kinds: number[] }; + if (filter.kinds[0] === 1059 && delivery === 'hold') { + heldRequests++; + if (heldRequests === 3) heldReady(); + } else if ( + filter.kinds[0] === 1059 && + (delivery === 'flood' || + delivery === 'byte-flood' || + delivery === 'rejected-byte-flood') + ) { + const candidate = + delivery === 'flood' + ? raw + : { + ...raw, + content: 'x'.repeat(delivery === 'byte-flood' ? 20000 : 40000) + }; + for (let i = 0; i < 501; i++) + socket.send(JSON.stringify(['EVENT', frame[1], candidate])); + } else if (filter.kinds[0] === 1059 && delivery === 'single') { + eventWritten = true; + socket.send(JSON.stringify(['EVENT', frame[1], raw])); + socket.send(JSON.stringify(['EOSE', frame[1]])); + } else if (filter.kinds[0] === 1059 && delivery === 'oversize') { + socket.send( + JSON.stringify([ + 'EVENT', + frame[1], + { ...raw, content: 'x'.repeat(32768) } + ]) + ); + socket.send(JSON.stringify(['EOSE', frame[1]])); + } else socket.send(JSON.stringify(['EOSE', frame[1]])); + }); + }); + await once(server, 'listening'); + const address = server.address(); + assert.ok(address && typeof address !== 'string'); + const fixturePort = address.port; + let key = owner, + calls = 0, + signs = 0, + constructed = 0; + class FixtureSocket extends WebSocket { + constructor(url: string | URL) { + assert.ok(origins.includes(new URL(String(url)).origin)); + constructed++; + super(`ws://127.0.0.1:${fixturePort}`); + } + } + Object.defineProperty(globalThis, 'window', { + configurable: true, + value: { + nostr: { + getPublicKey: () => { + calls++; + return Promise.resolve(key); + }, + signEvent: () => { + signs++; + return Promise.reject(new Error('Unexpected signer')); + }, + nip44: { + encrypt: (_peer: string, text: string) => + Promise.resolve('fixture:' + text), + decrypt: (_peer: string, text: string) => + Promise.resolve(text.slice(8)) + } + } + } + }); + globalThis.WebSocket = + FixtureSocket as unknown as typeof globalThis.WebSocket; + globalThis.fetch = () => + Promise.reject(new Error('Unexpected information fetch')); + const sdkScopes = new Map<'public' | 'private', RelayPool>(); + const allScopes = new Set<RelayPool>(); + let requestCalls = 0; + RelayPool.prototype.req = function (relays, filters, options) { + requestCalls++; + allScopes.add(this); + assert.ok(Array.isArray(filters)); + const filter = filters[0] as { kinds: number[] }; + sdkScopes.set(filter.kinds[0] === 1059 ? 'private' : 'public', this); + return originalReq.call(this, relays, filters, options); + }; + const identity = createIdentitySession(); + let privateSession: Awaited<ReturnType<typeof createPrivateSession>>; + let privatePool: ReturnType<typeof getPrivatePool>; + let publicPool: ReturnType<typeof getPublicPool>; + const stops: Array<() => void> = []; + function publicPage() { + return new Promise<void>((resolve) => { + const seen = new Set<string>(); + stops.push( + subscribePublicPool( + publicPool!, + [{ kinds: [30402], limit: 1 }], + (message) => { + if (message.type === 'EOSE') { + seen.add(message.from); + if (seen.size === 3) resolve(); + } + } + ) + ); + }); + } + async function heldPage() { + delivery = 'hold'; + heldRequests = 0; + const ready = new Promise<void>((resolve) => { + heldReady = resolve; + }); + stops.push(subscribePrivatePage(privatePool!, 200, () => {})); + await ready; + } + try { + await t.test( + 'guest, forged and unreviewed session cannot acquire sockets', + async () => { + assert.equal( + await createPrivateSession(identity, 'unreviewed'), + undefined + ); + assert.equal( + await createPrivateSession(identity, 'reviewed_private_session'), + undefined + ); + assert.throws( + () => getPrivatePool({} as never, policy, origins), + /private_session_invalid/ + ); + assert.equal(constructed, 0); + assert.equal(calls, 0); + } + ); + await connectIdentity(identity); + await probeIdentityMessaging(identity, 'reviewed_self_copy'); + await t.test( + 'explicit admission rechecks the genuine owner through the shared SDK', + async () => { + const before = calls; + privateSession = await createPrivateSession( + identity, + 'reviewed_private_session' + ); + assert.ok(privateSession); + assert.equal(calls, before + 1); + assert.deepEqual(Object.keys(privateSession), []); + assert.ok(Object.isFrozen(privateSession)); + assert.deepEqual(privateSessionSnapshot(privateSession), { + owner, + current: true + }); + assert.equal(constructed, 0); + } + ); + await t.test( + 'selection refuses hints, duplicates and oversized destination sets before egress', + () => { + assert.throws( + () => + getPrivatePool(privateSession!, policy, [ + ...origins, + 'wss://unapproved.example.org' + ]), + /private_pool_origins_invalid/ + ); + assert.throws( + () => + getPrivatePool(privateSession!, policy, [ + 'wss://unapproved.example.org' + ]), + /private_pool_origins_invalid/ + ); + assert.throws( + () => + getPrivatePool(privateSession!, policy, [origins[0], origins[0]]), + /private_pool_origins_invalid/ + ); + const selected = [...origins]; + let reentrant: ReturnType<typeof getPrivatePool>; + Object.defineProperty(selected, '0', { + configurable: true, + get: () => { + reentrant = getPrivatePool(privateSession!, policy, origins); + return origins[0]; + } + }); + privatePool = getPrivatePool(privateSession!, policy, selected); + assert.ok(privatePool); + assert.equal(privatePool, reentrant); + Object.defineProperty(selected, '0', { + configurable: true, + writable: true, + value: origins[0] + }); + selected[0] = 'wss://unapproved.example.org'; + const detached = privatePoolOrigins(privatePool) as string[]; + detached.push('wss://unapproved.example.org'); + assert.deepEqual(privatePoolOrigins(privatePool), origins); + assert.equal( + getPrivatePool(privateSession!, policy, origins), + privatePool + ); + assert.throws( + () => subscribePrivatePage(privatePool!, 201, () => {}), + /private_page_limit_invalid/ + ); + assert.equal(constructed, 0); + } + ); + await t.test( + 'three public and three private same-origin sockets have separate AUTH state', + async () => { + publicPool = getPublicPool(policy); + assert.ok(publicPool); + await publicPage(); + await heldPage(); + assert.equal(constructed, 6); + assert.equal(server.clients.size, 6); + const pub = sdkScopes.get('public'), + priv = sdkScopes.get('private'); + assert.ok(pub && priv); + assert.notEqual(pub, priv); + for (const origin of origins) { + const a = pub.relay(origin), + b = priv.relay(origin); + assert.notEqual(a, b); + assert.notEqual(a.authentication$, b.authentication$); + b.authentication$.next({ + ...raw, + kind: 22242, + pubkey: owner + } as never); + assert.equal(a.authentication, null); + } + assert.equal(signs, 0); + assert.ok( + frames.every((frame) => frame[0] !== 'AUTH' && frame[0] !== 'EVENT') + ); + const privateReq = frames.filter( + (frame) => (frame[2] as { kinds?: number[] })?.kinds?.[0] === 1059 + ); + assert.equal(privateReq.length, 3); + for (const frame of privateReq) + assert.deepEqual(frame[2], { + kinds: [1059], + '#p': [owner], + limit: 200 + }); + } + ); + await t.test( + 'logout closes actual private sockets and public discovery continues', + async () => { + const privateSockets = sockets.slice(3, 6); + const closed = privateSockets.map((socket) => once(socket, 'close')); + disconnectIdentity(identity); + await Promise.all(closed); + assert.equal(server.clients.size, 3); + assert.equal(privateSessionSnapshot(privateSession!)?.current, false); + assert.throws( + () => subscribePrivatePage(privatePool!, 1, () => {}), + /private_pool_closed/ + ); + await publicPage(); + assert.equal(constructed, 6); + } + ); + await t.test( + 'same-author reconnect cannot revive an old scope or consume stale callbacks', + async () => { + await connectIdentity(identity); + await probeIdentityMessaging(identity, 'reviewed_self_copy'); + assert.equal(privateSessionSnapshot(privateSession!)?.current, false); + const next = await createPrivateSession( + identity, + 'reviewed_private_session' + ); + assert.ok(next); + assert.notEqual(next, privateSession); + privateSession = next; + privatePool = getPrivatePool(next, policy, origins); + assert.ok(privatePool); + const before = constructed; + await heldPage(); + assert.equal(constructed, before + 3); + } + ); + await t.test( + 'failed SDK cleanup blocks replacement until exact cleanup retry succeeds', + () => { + const before = constructed; + const held = sdkScopes.get('private'); + assert.ok(held); + RelayPool.prototype.close = function () { + if (this === held) throw new Error('HC_TEST_ONLY_CLOSE_FAILURE'); + return originalClose.call(this); + }; + assert.throws( + () => closePrivatePool(privatePool!), + /private_pool_close_failed/ + ); + assert.throws( + () => getPrivatePool(privateSession!, policy, origins), + /private_pool_closed/ + ); + assert.equal(constructed, before); + RelayPool.prototype.close = originalClose; + closePrivatePool(privatePool!); + } + ); + await t.test( + 'observed account loss closes session generation without affecting public scope', + async () => { + privatePool = getPrivatePool(privateSession!, policy, origins); + assert.ok(privatePool); + await heldPage(); + const newest = [...server.clients].filter( + (socket) => !sockets.slice(0, 3).includes(socket) + ); + const closed = newest.map((socket) => once(socket, 'close')); + key = other; + await recheckIdentityOwner(identity); + await Promise.all(closed); + assert.equal(privateSessionSnapshot(privateSession!)?.current, false); + assert.equal( + await createPrivateSession(identity, 'reviewed_private_session'), + undefined + ); + await publicPage(); + assert.equal(signs, 0); + } + ); + key = owner; + await connectIdentity(identity); + await probeIdentityMessaging(identity, 'reviewed_self_copy'); + privateSession = await createPrivateSession( + identity, + 'reviewed_private_session' + ); + assert.ok(privateSession); + privatePool = getPrivatePool(privateSession, policy, origins); + assert.ok(privatePool); + await t.test( + 'oversized raw envelope is counted and rejected before consumer delivery', + async () => { + delivery = 'oversize'; + let candidates = 0; + await new Promise<void>((resolve) => { + stops.push( + subscribePrivatePage(privatePool!, 200, (message) => { + if (message.type === 'candidate') candidates++; + else resolve(); + }) + ); + }); + assert.equal(candidates, 0); + delivery = 'normal'; + } + ); + await t.test( + 'duplicate deliveries consume the finite 500-candidate budget', + async () => { + delivery = 'flood'; + let candidates = 0; + const end = await new Promise<PrivatePageMessage>((resolve) => { + stops.push( + subscribePrivatePage(privatePool!, 200, (message) => { + if (message.type === 'candidate') candidates++; + else resolve(message); + }) + ); + }); + assert.equal(candidates, 500); + assert.deepEqual(end, { type: 'end', reason: 'budget' }); + delivery = 'normal'; + } + ); + await t.test( + 'encoded bytes and rejected envelopes consume the exact finite 8MiB budget', + async () => { + delivery = 'byte-flood'; + let candidates = 0, + bytes = 0; + const end = await new Promise<PrivatePageMessage>((resolve) => { + stops.push( + subscribePrivatePage(privatePool!, 200, (message) => { + if (message.type === 'candidate') { + candidates++; + bytes += Buffer.byteLength(message.wire, 'utf8'); + } else resolve(message); + }) + ); + }); + const charge = Buffer.byteLength( + JSON.stringify({ ...raw, content: 'x'.repeat(20000) }), + 'utf8' + ); + assert.equal(candidates, Math.floor(8388608 / charge)); + assert.ok(bytes <= 8388608); + assert.deepEqual(end, { type: 'end', reason: 'budget' }); + delivery = 'rejected-byte-flood'; + let rejectedCandidates = 0; + const rejectedEnd = await new Promise<PrivatePageMessage>((resolve) => { + stops.push( + subscribePrivatePage(privatePool!, 200, (message) => { + if (message.type === 'candidate') rejectedCandidates++; + else resolve(message); + }) + ); + }); + assert.equal(rejectedCandidates, 0); + assert.deepEqual(rejectedEnd, { type: 'end', reason: 'budget' }); + delivery = 'normal'; + } + ); + await t.test( + 'finite network page enforces the original 15second elapsed boundary', + async () => { + delivery = 'hold'; + const original = performance.now.bind(performance), + descriptor = Object.getOwnPropertyDescriptor(performance, 'now'); + let observations = 0; + Object.defineProperty(performance, 'now', { + configurable: true, + value: () => { + observations++; + return original() + (observations > 1 ? 15000 : 0); + } + }); + try { + const end = await new Promise<PrivatePageMessage>((resolve) => { + stops.push( + subscribePrivatePage(privatePool!, 200, (message) => { + if (message.type === 'end') resolve(message); + }) + ); + }); + assert.ok(observations > 1); + assert.deepEqual(end, { type: 'end', reason: 'elapsed' }); + } finally { + if (descriptor) Object.defineProperty(performance, 'now', descriptor); + else Reflect.deleteProperty(performance, 'now'); + delivery = 'normal'; + } + } + ); + await t.test( + 'asynchronous EOSE cleanup failure emits error and retains unavailable page without escaping', + async () => { + delivery = 'normal'; + const original = Reflect.get(Subscription.prototype, 'unsubscribe'); + let failNext = true; + Subscription.prototype.unsubscribe = function () { + if (failNext && new Error().stack?.includes('at release (')) { + failNext = false; + throw new Error('HC_TEST_ONLY_ASYNC_UNSUBSCRIBE_FAILURE'); + } + return original.call(this); + }; + try { + const end = await new Promise<PrivatePageMessage>((resolve) => { + stops.push( + subscribePrivatePage(privatePool!, 200, (message) => { + if (message.type === 'end') resolve(message); + }) + ); + }); + assert.deepEqual(end, { type: 'end', reason: 'error' }); + assert.throws( + () => subscribePrivatePage(privatePool!, 1, () => {}), + /private_page_cleanup_required/ + ); + await new Promise<void>((resolve) => setImmediate(resolve)); + } finally { + Subscription.prototype.unsubscribe = original; + closePrivatePool(privatePool!); + privatePool = getPrivatePool(privateSession!, policy, origins); + assert.ok(privatePool); + } + } + ); + await t.test( + 'failed page unsubscribe keeps new SDK admission blocked until cleanup retry', + async () => { + await heldPage(); + const stop = stops[stops.length - 1]; + const original = Reflect.get(Subscription.prototype, 'unsubscribe'); + let failNext = true; + Subscription.prototype.unsubscribe = function () { + if (failNext) { + failNext = false; + throw new Error('HC_TEST_ONLY_UNSUBSCRIBE_FAILURE'); + } + return original.call(this); + }; + let unexpected: (() => void) | undefined; + const before = requestCalls; + try { + assert.throws(() => stop(), /HC_TEST_ONLY_UNSUBSCRIBE_FAILURE/); + assert.throws(() => { + unexpected = subscribePrivatePage(privatePool!, 1, () => {}); + }, /private_pool_closed|private_page_cleanup_required/); + assert.equal(requestCalls, before); + } finally { + unexpected?.(); + Subscription.prototype.unsubscribe = original; + closePrivatePool(privatePool!); + } + } + ); + await t.test( + 'clock reentry cannot admit an SDK request after owner logout', + async () => { + await new Promise<void>((resolve) => setImmediate(resolve)); + assert.equal( + (await recheckIdentityOwner(identity)).state, + 'messaging_capable' + ); + privatePool = getPrivatePool(privateSession!, policy, origins); + assert.ok(privatePool); + const original = performance.now.bind(performance); + const descriptor = Object.getOwnPropertyDescriptor(performance, 'now'); + const before = requestCalls; + let invalidations = 0; + Object.defineProperty(performance, 'now', { + configurable: true, + value: () => { + invalidations++; + disconnectIdentity(identity); + return original(); + } + }); + try { + await new Promise<void>((resolve) => { + stops.push( + subscribePrivatePage(privatePool!, 1, (message) => { + if (message.type === 'end') resolve(); + }) + ); + }); + assert.ok(invalidations > 0); + assert.equal(requestCalls, before); + } finally { + if (descriptor) Object.defineProperty(performance, 'now', descriptor); + else Reflect.deleteProperty(performance, 'now'); + } + } + ); + await t.test( + 'candidate clock reentry cannot disclose old-owner ciphertext after logout', + async () => { + await connectIdentity(identity); + await probeIdentityMessaging(identity, 'reviewed_self_copy'); + privateSession = await createPrivateSession( + identity, + 'reviewed_private_session' + ); + assert.ok(privateSession); + privatePool = getPrivatePool(privateSession, policy, [origins[0]]); + assert.ok(privatePool); + delivery = 'single'; + eventWritten = false; + let candidates = 0, + invalidations = 0; + const original = performance.now.bind(performance), + descriptor = Object.getOwnPropertyDescriptor(performance, 'now'); + Object.defineProperty(performance, 'now', { + configurable: true, + value: () => { + if (eventWritten) { + invalidations++; + disconnectIdentity(identity); + } + return original(); + } + }); + try { + await new Promise<void>((resolve) => { + stops.push( + subscribePrivatePage(privatePool!, 1, (message) => { + if (message.type === 'candidate') candidates++; + else resolve(); + }) + ); + }); + assert.ok(eventWritten && invalidations > 0); + assert.equal(candidates, 0); + assert.equal(privateSessionSnapshot(privateSession)?.current, false); + } finally { + if (descriptor) Object.defineProperty(performance, 'now', descriptor); + else Reflect.deleteProperty(performance, 'now'); + delivery = 'normal'; + } + } + ); + await t.test( + 'delayed genuine SDK owner response cannot open old-session sockets after logout', + async () => { + await connectIdentity(identity); + await probeIdentityMessaging(identity, 'reviewed_self_copy'); + privateSession = await createPrivateSession( + identity, + 'reviewed_private_session' + ); + assert.ok(privateSession); + privatePool = getPrivatePool(privateSession, policy, origins); + assert.ok(privatePool); + const browser = Reflect.get(globalThis, 'window'); + const provider: unknown = browser.nostr; + assert.ok(provider && typeof provider === 'object'); + const descriptor = Object.getOwnPropertyDescriptor( + provider, + 'getPublicKey' + ); + assert.ok(descriptor); + let release = (_key: string) => { + void _key; + }; + let entered = () => {}; + const observed = new Promise<void>((resolve) => { + entered = resolve; + }); + Object.defineProperty(provider, 'getPublicKey', { + configurable: true, + value: () => { + entered(); + return new Promise<string>((resolve) => { + release = resolve; + }); + } + }); + const before = requestCalls; + let candidates = 0; + const end = new Promise<PrivatePageMessage>((resolve) => { + stops.push( + subscribePrivatePage(privatePool!, 1, (message) => { + if (message.type === 'candidate') candidates++; + else resolve(message); + }) + ); + }); + try { + await observed; + disconnectIdentity(identity); + assert.deepEqual(await end, { type: 'end', reason: 'closed' }); + Object.defineProperty(provider, 'getPublicKey', descriptor); + release(owner); + await new Promise<void>((resolve) => setImmediate(resolve)); + assert.equal(requestCalls, before); + assert.equal(candidates, 0); + assert.equal(privateSessionSnapshot(privateSession)?.current, false); + key = other; + await connectIdentity(identity); + await probeIdentityMessaging(identity, 'reviewed_self_copy'); + const next = await createPrivateSession( + identity, + 'reviewed_private_session' + ); + assert.ok(next); + assert.deepEqual(privateSessionSnapshot(next), { + owner: other, + current: true + }); + assert.equal(privateSessionSnapshot(privateSession)?.current, false); + closePrivateSession(next); + disconnectIdentity(identity); + key = owner; + } finally { + Object.defineProperty(provider, 'getPublicKey', descriptor); + release(owner); + } + } + ); + await t.test( + 'capability loss closes actual private transport and signing alone cannot reopen it', + async () => { + await connectIdentity(identity); + await probeIdentityMessaging(identity, 'reviewed_self_copy'); + privateSession = await createPrivateSession( + identity, + 'reviewed_private_session' + ); + assert.ok(privateSession); + privatePool = getPrivatePool(privateSession, policy, origins); + assert.ok(privatePool); + await heldPage(); + const newest = [...server.clients].filter( + (socket) => !sockets.slice(0, 3).includes(socket) + ); + const closed = newest.map((socket) => once(socket, 'close')); + const browser = Reflect.get(globalThis, 'window'); + const provider: unknown = browser.nostr; + assert.ok(provider && typeof provider === 'object'); + Object.defineProperty(provider, 'nip44', { + configurable: true, + value: undefined + }); + const checked = await recheckIdentityOwner(identity); + await Promise.all(closed); + assert.equal(checked.state, 'signing_only'); + assert.equal(privateSessionSnapshot(privateSession)?.current, false); + const before = constructed; + assert.equal( + await createPrivateSession(identity, 'reviewed_private_session'), + undefined + ); + assert.equal(constructed, before); + await publicPage(); + } + ); + } finally { + RelayPool.prototype.close = originalClose; + if (privatePool) closePrivatePool(privatePool); + if (privateSession) closePrivateSession(privateSession); + disconnectIdentity(identity); + for (const stop of stops) stop(); + if (publicPool) closePublicPool(publicPool); + RelayPool.prototype.req = originalReq; + for (const scope of allScopes) scope.close(); + for (const socket of server.clients) socket.terminate(); + await new Promise<void>((resolve, reject) => + server.close((error) => (error ? reject(error) : resolve())) + ); + globalThis.WebSocket = originalSocket; + globalThis.fetch = originalFetch; + Reflect.deleteProperty(globalThis, 'window'); + } +}); diff --git a/web/tests/unit/private-session.test.ts b/web/tests/unit/private-session.test.ts @@ -0,0 +1,29 @@ +import { expect, it } from 'vitest'; +import { createIdentitySession } from '../../src/lib/runtime/identity-session.ts'; +import { + createPrivateSession, + privateSessionSnapshot, + privateSessionOwnership, + closePrivateSession, + type PrivateSession +} from '../../src/lib/runtime/private-session.ts'; +import { getPrivatePool } from '../../src/lib/nostr/private-pool.ts'; +it('SSR private import and explicit admission acquire no browser transport', async () => { + const identity = createIdentitySession(); + expect( + await createPrivateSession(identity, 'reviewed_private_session') + ).toBeUndefined(); + expect(getPrivatePool({} as PrivateSession, {} as never, [])).toBeUndefined(); +}); +it('guest observation and unreviewed admission do not create private authority', async () => { + const identity = createIdentitySession(); + expect(await createPrivateSession(identity, 'unreviewed')).toBeUndefined(); + expect( + await createPrivateSession({} as never, 'reviewed_private_session') + ).toBeUndefined(); +}); +it('forged private session cannot expose an owner or generation', () => { + expect(privateSessionSnapshot({} as PrivateSession)).toBeUndefined(); + expect(privateSessionOwnership({} as PrivateSession)).toBeUndefined(); + expect(() => closePrivateSession({} as PrivateSession)).not.toThrow(); +});