app

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

commit ec67c7988d0745af37183f65a6a786aa819d5caa
parent 8eae342fb993bce86c9188f012214aadbd054c57
Author: triesap <tyson@radroots.org>
Date:   Fri,  9 Oct 2026 00:56:10 +0000

messages: implement a typed gift-wrap delivery capability (HCP-085)

- Admit only acknowledged persisted gift-wraps to frozen role targets
- Recheck the current owner and full ciphertext before each private EVENT
- Preserve preparation and composer state across successful owner checks
- Extend host verification allowances and retain actual browser evidence

Diffstat:
Mweb/playwright.config.ts | 4++--
Mweb/src/lib/config/budgets.ts | 7+++++++
Mweb/src/lib/messaging/composer-state.ts | 4+++-
Aweb/src/lib/messaging/deliver-send.ts | 40++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/messaging/envelope-preparation.ts | 6+++++-
Mweb/src/lib/messaging/prepare-send.ts | 4+++-
Mweb/src/lib/nostr/private-pool.ts | 216+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
Aweb/src/lib/nostr/private-publisher.ts | 210+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/e2e/capability-gate.spec.ts | 6+++---
Mweb/tests/e2e/harness/paired-delivery.ts | 8+++++---
Aweb/tests/e2e/harness/private-publisher.ts | 225+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/e2e/inbox-preference-publisher.spec.ts | 2+-
Mweb/tests/e2e/notices.spec.ts | 6+++---
Mweb/tests/e2e/primitives.spec.ts | 6+++---
Aweb/tests/e2e/private-publisher.spec.ts | 371+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/e2e/private-storage.spec.ts | 6+++---
Mweb/tests/e2e/product-details.spec.ts | 6+++---
Mweb/tests/e2e/search-form.spec.ts | 6+++---
Mweb/tests/e2e/search-results.spec.ts | 6+++---
Mweb/tests/e2e/shell.spec.ts | 6+++---
Mweb/tests/provenance/commands.test.mjs | 14+++++++-------
Mweb/tests/provenance/message-interop.test.mjs | 2+-
Mweb/tests/provenance/output.test.mjs | 16++++++++--------
Mweb/tests/provenance/source-boundaries.test.mjs | 16++++++++--------
Aweb/tests/unit/private-publisher.test.ts | 89+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/unit/relay-config.test.ts | 2+-
Mweb/tools/check-food-interop.mjs | 2+-
Mweb/tools/check-message-interop.mjs | 2+-
Mweb/tools/doctor.mjs | 2+-
Mweb/vitest.config.ts | 2+-
30 files changed, 1227 insertions(+), 65 deletions(-)

diff --git a/web/playwright.config.ts b/web/playwright.config.ts @@ -6,8 +6,8 @@ export default defineConfig({ fullyParallel: false, workers: 1, retries: 0, - timeout: 120_000, - expect: { timeout: 120_000 }, + timeout: 1_800_000, + expect: { timeout: 300_000 }, use: { browserName: 'chromium', headless: true, serviceWorkers: 'block' }, reporter: 'list' }); diff --git a/web/src/lib/config/budgets.ts b/web/src/lib/config/budgets.ts @@ -26,6 +26,13 @@ export const PRIVATE_AUTH_BUDGETS = Object.freeze({ responsesPerConnectionAction: 2 }); +// The private explicit-action network budget begins after preparation and +// provider permission waiting. Later retry scheduling shares this same cap. +export const PRIVATE_PUBLICATION_BUDGETS = Object.freeze({ + attemptsPerTargetAction: 3, + networkActionMilliseconds: 45000 +}); + // 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/messaging/composer-state.ts b/web/src/lib/messaging/composer-state.ts @@ -288,7 +288,9 @@ export function createPrivateComposer( discard, close }); - unsubscribe = subscribeIdentityInvalidation(session, close); + unsubscribe = subscribeIdentityInvalidation(session, () => { + if (!ownership.current()) close(); + }); return current() ? token : undefined; } export function updatePrivateComposerText( diff --git a/web/src/lib/messaging/deliver-send.ts b/web/src/lib/messaging/deliver-send.ts @@ -0,0 +1,40 @@ +import { + capturePrivatePublication, + type PrivateDeliveryRole +} from '../nostr/private-publisher.ts'; +import { + publishPrivateGiftWrapAttempt, + type PrivatePool, + type PrivateGiftWrapAttemptResult +} from '../nostr/private-pool.ts'; +import type { PrivateStorageRepository } from '../persistence/private-storage.ts'; +import type { PairedDeliveryAcknowledgement } from '../persistence/private-sends.ts'; +import type { PrivateSession } from '../runtime/private-session.ts'; +import type { PairedDeliveryContext } from './prepare-send.ts'; +// One explicitly reviewed persisted role/target effect only. Named durable +// receipts, bounded stored retries and approved routing changes have later +// owners. An accepted relay attempt is never a person-delivered result. +export async function deliverPrivateSend( + repository: PrivateStorageRepository, + session: PrivateSession, + receipt: PairedDeliveryAcknowledgement, + context: PairedDeliveryContext, + pool: PrivatePool, + role: PrivateDeliveryRole, + origin: string, + review: unknown, + signal: AbortSignal +): Promise<PrivateGiftWrapAttemptResult | Readonly<{ status: 'invalid' }>> { + const permission = capturePrivatePublication( + repository, + session, + receipt, + context, + role, + origin, + review + ); + return permission + ? publishPrivateGiftWrapAttempt(pool, permission, signal) + : { status: 'invalid' }; +} diff --git a/web/src/lib/messaging/envelope-preparation.ts b/web/src/lib/messaging/envelope-preparation.ts @@ -232,7 +232,11 @@ export function captureEnvelopePreparation( } const token = Object.freeze({}) as EnvelopePreparation; pairs.set(token, { run, snapshot, proof, stop, close }); - unsubscribe = subscribeIdentityInvalidation(session, close); + unsubscribe = subscribeIdentityInvalidation(session, () => { + // Successful fresh same-owner checks notify observers without revoking + // this captured generation. Only actual owner/capability loss retires it. + if (!ownership.current()) close(); + }); return current() ? token : undefined; } export function prepareEnvelopeRole( diff --git a/web/src/lib/messaging/prepare-send.ts b/web/src/lib/messaging/prepare-send.ts @@ -484,7 +484,9 @@ export function captureSelfRecoveryPreparation( peer, stop }); - unsubscribe = subscribeIdentityInvalidation(session, stop); + unsubscribe = subscribeIdentityInvalidation(session, () => { + if (!ownership.current()) stop(); + }); return current() ? token : undefined; } export function prepareSelfRecovery( diff --git a/web/src/lib/nostr/private-pool.ts b/web/src/lib/nostr/private-pool.ts @@ -1,6 +1,12 @@ import { createScopedRelayPool } from './pool-factory.ts'; import { NEVER } from 'rxjs'; import { + privatePublicationSnapshot, + takePrivatePublication, + type PrivatePublication, + type PrivateDeliveryRole +} from './private-publisher.ts'; +import { takeInboxAuthAdmission, takeGuardedInboxAuthResponse, type InboxAuthAdmission, @@ -15,6 +21,7 @@ import { readRelayPolicy, type RelayPolicy } from '../config/relays.ts'; import { PRIVATE_TRANSPORT_BUDGETS, PRIVATE_AUTH_BUDGETS, + PRIVATE_PUBLICATION_BUDGETS, RELAY_BUDGETS } from '../config/budgets.ts'; import { @@ -27,6 +34,12 @@ import { import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts'; declare const poolBrand: unique symbol; export type PrivatePool = Readonly<{ [poolBrand]: true }>; +export type PrivateGiftWrapAttemptResult = Readonly<{ + status: 'accepted' | 'refused' | 'unknown' | 'timed_out' | 'stopped'; + role?: PrivateDeliveryRole; + origin?: string; + eventId?: string; +}>; export type PrivatePageMessage = | Readonly<{ type: 'candidate'; from: string; wire: string }> | Readonly<{ @@ -47,6 +60,10 @@ type Owner = { token: PrivatePool; closed(): boolean; cleaned(): boolean; + publish( + permission: PrivatePublication, + signal: AbortSignal + ): Promise<PrivateGiftWrapAttemptResult>; auth( origin: string, admission: InboxAuthAdmission @@ -103,12 +120,18 @@ export function getPrivatePool( if ( typeof origin !== 'string' || selectedOrigins.has(origin) || - !manifest.inbox.some((row) => row.origin === origin && row.read) + !manifest.inbox.some( + ({ origin: allowed, read, write }) => + allowed === origin && (read || write) + ) ) throw new Error('private_pool_origins_invalid'); selectedOrigins.set(origin, true); } const origins = [...selectedOrigins.keys()]; + const readOrigins = origins.filter((origin) => + manifest.inbox.some((row) => row.origin === origin && row.read) + ); // Untrusted selection access can run code. Recheck before factory admission. if (!capture.current()) throw new Error('private_session_invalid'); if (lifetime) { @@ -133,6 +156,9 @@ export function getPrivatePool( let active = () => {}; let off = () => {}; const authCleanup = new Map<string, () => void>(); + const publicationStops = new Map<() => void, true>(); + let publishing = false, + publicationCleanupRequired = false; const owner: Owner = { session, policy, @@ -140,11 +166,175 @@ export function getPrivatePool( token, closed: () => closed, cleaned: () => cleaned, + async publish(permission, signal) { + const view = privatePublicationSnapshot(permission); + if ( + !view || + publishing || + closed || + cleanupRequired || + publicationCleanupRequired || + signal.aborted || + !capture.current() || + view.owner !== capture.owner || + !origins.includes(view.origin) || + !manifest.inbox.some( + ({ origin: allowed, write }) => allowed === view.origin && write + ) || + typeof window === 'undefined' || + !navigator.locks?.request + ) + return { status: 'stopped' }; + publishing = true; + try { + // No owner lock is held across the serialized fresh extension job. + if ( + !(await recheckPrivateSession(session)) || + closed || + signal.aborted || + !capture.current() + ) + 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()) + return { status: 'stopped' as const }; + const admitted = await takePrivatePublication( + permission, + session, + policy, + view.origin + ); + if ( + !admitted || + closed || + signal.aborted || + !capture.current() || + !admitted.current() + ) + return { status: 'stopped' as const }; + return await new Promise<PrivateGiftWrapAttemptResult>( + (resolve) => { + let ended = false, + release = () => {}, + fenceTimer: ReturnType<typeof setTimeout> | undefined; + function finish( + status: PrivateGiftWrapAttemptResult['status'] + ) { + if (ended) return; + ended = true; + clearTimeout(timer); + if (fenceTimer !== undefined) clearTimeout(fenceTimer); + signal.removeEventListener('abort', stop); + try { + release(); + publicationStops.delete(stop); + } catch { + publicationCleanupRequired = true; + status = 'unknown'; + } + resolve({ + status, + role: admitted!.role, + origin: admitted!.origin, + eventId: admitted!.eventId + }); + } + function stop() { + if (ended) { + release(); + publicationStops.delete(stop); + return; + } + finish('stopped'); + } + function fence() { + if (ended) return; + if ( + closed || + signal.aborted || + !capture.current() || + !admitted!.current() + ) { + finish('stopped'); + return; + } + fenceTimer = setTimeout(() => fence(), 50); + } + const relay = sdk.relay(view.origin); + const timeout = + Number.isFinite(relay.eventTimeout) && relay.eventTimeout > 0 + ? Math.min( + PRIVATE_PUBLICATION_BUDGETS.networkActionMilliseconds, + relay.eventTimeout + ) + : PRIVATE_PUBLICATION_BUDGETS.networkActionMilliseconds; + const timer = setTimeout(() => finish('timed_out'), timeout); + signal.addEventListener('abort', stop, { once: true }); + publicationStops.set(stop, true); + try { + if ( + closed || + signal.aborted || + !capture.current() || + !admitted.current() + ) { + finish('stopped'); + return; + } + // The only private EVENT port accepts the freshly read-back1059; + // no caller event, key, relay template or SDK option crosses it. + const subscription = relay + .event(admitted.event, 'EVENT') + .subscribe({ + next(response) { + if (ended) return; + if ( + (response.from !== view.origin && + response.from !== view.origin + '/') || + typeof response.ok !== 'boolean' + ) + finish('unknown'); + else if (response.ok) finish('accepted'); + else if (response.message === 'Timeout') + finish('unknown'); + else finish('refused'); + }, + error: () => finish('unknown'), + complete: () => { + if (!ended) finish('unknown'); + } + }); + release = () => subscription.unsubscribe(); + if (ended) { + try { + release(); + publicationStops.delete(stop); + } catch { + publicationCleanupRequired = true; + } + } else fence(); + } catch { + finish('unknown'); + } + } + ); + } + ); + } catch { + return { status: 'stopped' }; + } finally { + publishing = false; + } + }, async auth(origin, admission) { if ( closed || cleanupRequired || !origins.includes(origin) || + !readOrigins.includes(origin) || authCleanup.has(origin) || !capture.current() ) @@ -359,6 +549,8 @@ export function getPrivatePool( return token; }, subscribe(limit, listener) { + if (readOrigins.length === 0) + throw new Error('private_read_origins_unavailable'); if (closed || !capture.current()) { owner.close(); throw new Error('private_pool_closed'); @@ -428,7 +620,7 @@ export function getPrivatePool( } const subscription = sdk .req( - [...origins], + [...readOrigins], [{ kinds: [1059], '#p': [capture.owner], limit }], { waitForAuth: false, @@ -456,7 +648,7 @@ export function getPrivatePool( } if (message.type === 'EOSE') { completed.set(message.from, true); - if (completed.size === origins.length) finish('complete'); + if (completed.size === readOrigins.length) finish('complete'); } else if (message.type === 'EVENT') { deliveries++; if (deliveries > PRIVATE_TRANSPORT_BUDGETS.deliveries) { @@ -522,6 +714,13 @@ export function getPrivatePool( failed = true; } } + for (const stop of publicationStops.keys()) { + try { + stop(); + } catch { + failed = true; + } + } try { sdk.close(); } catch { @@ -570,6 +769,17 @@ export function subscribePrivatePage( export function closePrivatePool(token: PrivatePool): void { ownerOf(token).close(); } +export function publishPrivateGiftWrapAttempt( + pool: PrivatePool, + permission: PrivatePublication, + signal: AbortSignal +): Promise<PrivateGiftWrapAttemptResult> { + try { + return ownerOf(pool).publish(permission, signal); + } catch { + return Promise.resolve({ status: 'stopped' }); + } +} export function beginPrivateAuthConnection( pool: PrivatePool, origin: string, diff --git a/web/src/lib/nostr/private-publisher.ts b/web/src/lib/nostr/private-publisher.ts @@ -0,0 +1,210 @@ +import { + privateSessionOwnership, + type PrivateSession +} from '../runtime/private-session.ts'; +import { + pairedDeliveryAcknowledgementSnapshot, + verifyPairedDeliveryAcknowledgement, + type PairedDeliveryAcknowledgement +} from '../persistence/private-sends.ts'; +import type { PrivateStorageRepository } from '../persistence/private-storage.ts'; +import type { PairedDeliveryContext } from '../messaging/prepare-send.ts'; +import { + inboxRoutePlanSnapshot, + recheckInboxRoutePlan +} from '../messaging/inbox-routing.ts'; +import { readRelayPolicy, type RelayPolicy } from '../config/relays.ts'; +import { PRIVATE_TRANSPORT_BUDGETS } from '../config/budgets.ts'; +import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts'; +import { + verifyEnvelope, + verifiedEnvelopeSnapshot +} from './verified-envelope.ts'; +declare const publicationBrand: unique symbol; +export type PrivatePublication = Readonly<{ [publicationBrand]: true }>; +export type PrivateDeliveryRole = 'peer' | 'self_archive'; +type Admission = { + session: PrivateSession; + policy: RelayPolicy; + owner: string; + command: string; + role: PrivateDeliveryRole; + origin: string; + eventId: string; + repository: PrivateStorageRepository; + receipt: PairedDeliveryAcknowledgement; + wire: string; + destination: string; + current(): boolean; + take(): boolean; +}; +const permissions = new WeakMap<PrivatePublication, Admission>(); +// Genuine current local pair custody plus its frozen routes is necessary, but +// this capture opens no socket and does not claim recipient delivery. Each +// permission is one effect, not arbitrary bytes, retry or rerouting authority. +export function capturePrivatePublication( + repository: PrivateStorageRepository, + session: PrivateSession, + receipt: PairedDeliveryAcknowledgement, + context: PairedDeliveryContext, + role: PrivateDeliveryRole, + origin: string, + review: unknown +): PrivatePublication | undefined { + if ( + typeof window === 'undefined' || + review !== 'reviewed_private_delivery' || + (role !== 'peer' && role !== 'self_archive') || + typeof origin !== 'string' + ) + return undefined; + try { + const ownership = privateSessionOwnership(session), + saved = pairedDeliveryAcknowledgementSnapshot(receipt); + if (!ownership || !saved || ownership.owner !== saved.owner) + return undefined; + const policy = context.policy, + plan = context.plan, + own = context.own, + other = context.other; + const routes = inboxRoutePlanSnapshot(plan), + manifest = readRelayPolicy(policy); + if ( + !routes || + !manifest.messagingEnabled || + saved.deliveryPlan.state !== 'prepared' || + JSON.stringify(routes) !== JSON.stringify(saved.deliveryPlan.routes) || + recheckInboxRoutePlan(plan, policy, own, other) !== 'unchanged' + ) + return undefined; + const route = role === 'peer' ? routes.peer : routes.archive; + const artifact = role === 'peer' ? saved.peerArtifact : saved.self; + const destination = role === 'peer' ? saved.peer : saved.owner; + if ( + route.role !== role || + route.author !== destination || + !route.targets.includes(origin) || + !manifest.inbox.some( + ({ origin: allowed, write }) => allowed === origin && write + ) || + !boundedUtf8(artifact.wire, PRIVATE_TRANSPORT_BUDGETS.envelopeBytes) + ) + return undefined; + const verified = verifyEnvelope(artifact.wire), + event = verified.ok && verifiedEnvelopeSnapshot(verified.value); + if ( + !event || + event.kind !== 1059 || + event.id !== artifact.eventId || + event.tags.length !== 1 || + event.tags[0].length !== 2 || + event.tags[0][0] !== 'p' || + event.tags[0][1] !== destination + ) + return undefined; + const original = JSON.stringify(saved); + let consumed = false; + function current() { + const fresh = pairedDeliveryAcknowledgementSnapshot(receipt), + captured = privateSessionOwnership(session); + return ( + ownership!.current() && + captured?.session === ownership!.session && + captured.owner === ownership!.owner && + !!fresh && + JSON.stringify(fresh) === original && + recheckInboxRoutePlan(plan, policy, own, other) === 'unchanged' + ); + } + if (!current()) return undefined; + const token = Object.freeze({}) as PrivatePublication; + permissions.set(token, { + session, + policy, + owner: saved.owner, + command: saved.id, + role, + origin, + eventId: event.id, + repository, + receipt, + wire: artifact.wire, + destination, + current, + take() { + if (consumed) return false; + consumed = true; + return true; + } + }); + return token; + } catch { + return undefined; + } +} +export function privatePublicationSnapshot(token: PrivatePublication) { + const saved = permissions.get(token); + return saved?.current() + ? { + owner: saved.owner, + command: saved.command, + role: saved.role, + origin: saved.origin, + eventId: saved.eventId + } + : undefined; +} +// The owned private pool consumes this after fresh SDK identity observation and +// under the owner lock. Actual full persisted record readback precedes every +// EVENT. A detached valid signature or guessed local ID cannot mint permission. +export async function takePrivatePublication( + token: PrivatePublication, + session: PrivateSession, + policy: RelayPolicy, + origin: string +) { + const saved = permissions.get(token); + if ( + !saved || + saved.session !== session || + saved.policy !== policy || + saved.origin !== origin || + !saved.current() || + !saved.take() + ) + return undefined; + try { + if ( + !(await verifyPairedDeliveryAcknowledgement( + saved.repository, + saved.receipt + )) || + !saved.current() + ) + return undefined; + const verified = verifyEnvelope(saved.wire), + event = verified.ok && verifiedEnvelopeSnapshot(verified.value); + if ( + !event || + event.kind !== 1059 || + event.id !== saved.eventId || + event.tags.length !== 1 || + event.tags[0].length !== 2 || + event.tags[0][0] !== 'p' || + event.tags[0][1] !== saved.destination || + !saved.current() + ) + return undefined; + return { + event, + current: () => saved.current(), + owner: saved.owner, + command: saved.command, + role: saved.role, + origin: saved.origin, + eventId: saved.eventId + }; + } catch { + return undefined; + } +} diff --git a/web/tests/e2e/capability-gate.spec.ts b/web/tests/e2e/capability-gate.spec.ts @@ -290,7 +290,7 @@ test.describe('actual shared inline capability component', () => { let fixtureServer: Awaited<ReturnType<typeof createStaticHarness>>, directory: string; test.beforeAll(async () => { - test.setTimeout(120_000); + test.setTimeout(1_800_000); directory = await mkdtemp(path.join(tmpdir(), 'hcp056-gates-')); const capsule = fileURLToPath(new URL('../../../', import.meta.url)), checkout = path.join(directory, 'checkout'); @@ -338,7 +338,7 @@ test.describe('actual shared inline capability component', () => { '--store-dir', path.dirname(store) ], - { cwd: path.join(checkout, 'web'), timeout: 90_000, stdio: 'pipe' } + { cwd: path.join(checkout, 'web'), timeout: 1800000, stdio: 'pipe' } ); const audit = execFileSync(process.execPath, ['tools/check-source.mjs'], { cwd: path.join(checkout, 'web') @@ -348,7 +348,7 @@ test.describe('actual shared inline capability component', () => { }); execFileSync(process.execPath, ['node_modules/vite/bin/vite.js', 'build'], { cwd: path.join(checkout, 'web'), - timeout: 90_000, + timeout: 1800000, stdio: 'pipe' }); console.log( diff --git a/web/tests/e2e/harness/paired-delivery.ts b/web/tests/e2e/harness/paired-delivery.ts @@ -53,7 +53,9 @@ const discovery = 'wss://discovery.example.org', archiveOrigin = 'wss://archive.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() { +export async function makeFixture( + options: Readonly<{ messaging?: boolean; peerRead?: boolean }> = {} +) { const f = await makeSelfFixture(), policy = validateRelayPolicy( JSON.stringify({ @@ -61,11 +63,11 @@ export async function makeFixture() { public: [{ origin: discovery, read: true, write: false, nip50: false }], inbox: [peerOrigin, archiveOrigin].map((origin) => ({ origin, - read: true, + read: origin === peerOrigin ? options.peerRead !== false : true, write: true })), postingEnabled: false, - messagingEnabled: false, + messagingEnabled: options.messaging === true, operatorDenylist: [] }) ); diff --git a/web/tests/e2e/harness/private-publisher.ts b/web/tests/e2e/harness/private-publisher.ts @@ -0,0 +1,225 @@ +import { + makeFixture as makePairFixture, + prepareSelfRecovery, + preparePairedDelivery, + preparedPairedDelivery +} from './paired-delivery.ts'; +import { + createPrivateSession, + closePrivateSession +} from '../../../src/lib/runtime/private-session.ts'; +import { + getPrivatePool, + publishPrivateGiftWrapAttempt, + subscribePrivatePage, + closePrivatePool +} from '../../../src/lib/nostr/private-pool.ts'; +import { + capturePrivatePublication, + privatePublicationSnapshot, + type PrivatePublication +} from '../../../src/lib/nostr/private-publisher.ts'; +import { deliverPrivateSend } from '../../../src/lib/messaging/deliver-send.ts'; +import { browserDatabaseTransaction } from '../../../src/lib/persistence/database.ts'; +import { + reservedSendSnapshot, + reservedSendRumorWire +} from '../../../src/lib/messaging/send-identity.ts'; +import { + createPrivateComposer, + updatePrivateComposerText, + bindPrivateComposerPreparation, + privateComposerText, + privateComposerSnapshot, + closePrivateComposer, + type PrivateComposer +} 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 }); + 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 + ]); + if (!pool) throw Error('missing actual private pool'); + const controller = new AbortController(); + let composer: PrivateComposer | undefined; + function bindComposer(newer = false) { + const wire = reservedSendRumorWire(f.reserved); + if (!wire) throw Error('missing genuine captured rumor'); + const content = (JSON.parse(wire) as { content: unknown }).content; + composer = createPrivateComposer(f.identity, 'reviewed_private_composer'); + if ( + !composer || + !updatePrivateComposerText(composer, content, 'reviewed_private_text') || + !bindPrivateComposerPreparation( + composer, + f.reserved, + f.preparation, + undefined, + 'reviewed_composer_preparation' + ) + ) + throw Error('missing genuine composer binding'); + if ( + newer && + !updatePrivateComposerText( + composer, + 'HCP085_NEWER_PRIVATE_TEXT_MEMORY_ONLY', + 'reviewed_private_text' + ) + ) + throw Error('newer text update failed'); + return { + text: privateComposerText(composer), + snapshot: privateComposerSnapshot(composer) + }; + } + function composerState() { + return composer + ? { + text: privateComposerText(composer), + snapshot: privateComposerSnapshot(composer) + } + : undefined; + } + async function prepare() { + const self = await prepareSelfRecovery( + f.preparation, + 'reviewed_self_recovery' + ); + if (self.status !== 'saved') throw Error('missing self: ' + self.status); + const pair = await preparePairedDelivery( + f.preparation, + f.context, + 'reviewed_pair_preparation' + ); + if (pair.status !== 'prepared') throw Error('missing pair: ' + pair.status); + return f.storedPair(); + } + function permission( + role: 'peer' | 'self_archive', + origin = role === 'peer' ? peerOrigin : archiveOrigin, + review: unknown = 'reviewed_private_delivery' + ) { + const receipt = preparedPairedDelivery(f.preparation); + return receipt + ? capturePrivatePublication( + f.repository, + session!, + receipt, + f.context, + role, + origin, + review + ) + : undefined; + } + async function publish(token: PrivatePublication) { + return publishPrivateGiftWrapAttempt(pool!, token, controller.signal); + } + async function deliver( + role: 'peer' | 'self_archive', + origin = role === 'peer' ? peerOrigin : archiveOrigin + ) { + const receipt = preparedPairedDelivery(f.preparation); + return receipt + ? deliverPrivateSend( + f.repository, + session!, + receipt, + f.context, + pool!, + role, + origin, + 'reviewed_private_delivery', + controller.signal + ) + : { status: 'invalid' as const }; + } + async function remove() { + const record = reservedSendSnapshot(f.reserved); + if (!record) throw Error('missing command'); + const tx = browserDatabaseTransaction( + f.database, + ['private_sends'], + 'readwrite' + ); + tx.objectStore('private_sends').delete([f.owner, record.id]); + await new Promise<void>((resolve, reject) => { + tx.addEventListener('complete', () => resolve()); + tx.addEventListener('abort', () => + reject(Error('fixture deletion aborted')) + ); + }); + } + let restore = () => {}; + function failReadback() { + const cursor = Reflect.get<IDBIndex, 'openCursor'>( + IDBIndex.prototype, + 'openCursor' + ); + IDBIndex.prototype.openCursor = function ( + ...args: Parameters<IDBIndex['openCursor']> + ) { + if (this.objectStore.name === 'private_sends') + throw Error('controlled actual private readback failure'); + return cursor.apply(this, args); + }; + restore = () => { + IDBIndex.prototype.openCursor = cursor; + }; + } + function readOrigins() { + return new Promise<string[]>((resolve, reject) => { + const seen = new Set<string>(); + try { + subscribePrivatePage(pool!, 1, (message) => { + if (message.type === 'candidate') seen.add(message.from); + else if (message.reason === 'complete') resolve([...seen]); + else reject(Error(message.reason)); + }); + } catch (error) { + reject( + error instanceof Error ? error : Error('fixture private read failed') + ); + } + }); + } + return { + ...f, + session, + pool, + peerOrigin, + archiveOrigin, + prepare, + prepareSelfOnly: () => + prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'), + permission, + publish, + deliver, + remove, + failReadback, + readOrigins, + bindComposer, + composerState, + stop: () => controller.abort(), + disconnect: () => disconnectIdentity(f.identity), + close() { + if (composer) closePrivateComposer(composer); + restore(); + controller.abort(); + closePrivatePool(pool); + closePrivateSession(session); + f.close(); + } + }; +} diff --git a/web/tests/e2e/inbox-preference-publisher.spec.ts b/web/tests/e2e/inbox-preference-publisher.spec.ts @@ -391,7 +391,7 @@ test('competing and incomplete preference observations block explicit stored res test('actual SDK timeouts allow only three explicit same-artifact attempts and retain each named fact', async ({ page }) => { - test.setTimeout(45000); + test.setTimeout(1_800_000); response = 'silent'; const result = await page.evaluate(async () => { const s = window.hcp066, diff --git a/web/tests/e2e/notices.spec.ts b/web/tests/e2e/notices.spec.ts @@ -21,7 +21,7 @@ const capsule = fileURLToPath(new URL('../../../', import.meta.url)); let directory: string; let server: Awaited<ReturnType<typeof createStaticHarness>>; test.beforeAll(async () => { - test.setTimeout(120_000); + test.setTimeout(1_800_000); directory = await mkdtemp(path.join(tmpdir(), 'hcp016-notices-')); try { const checkout = path.join(directory, 'checkout'); @@ -73,7 +73,7 @@ test.beforeAll(async () => { '--store-dir', path.dirname(sourceStore) ], - { cwd: path.join(checkout, 'web'), stdio: 'pipe', timeout: 90_000 } + { cwd: path.join(checkout, 'web'), stdio: 'pipe', timeout: 1800000 } ); const sourceAudit = execFileSync( process.execPath, @@ -109,7 +109,7 @@ test.beforeAll(async () => { { cwd: path.join(checkout, 'web'), stdio: 'pipe', - timeout: 90_000 + timeout: 1800000 } ); async function payload( diff --git a/web/tests/e2e/primitives.spec.ts b/web/tests/e2e/primitives.spec.ts @@ -20,7 +20,7 @@ const capsule = fileURLToPath(new URL('../../../', import.meta.url)); let directory: string; let server: Awaited<ReturnType<typeof createStaticHarness>>; test.beforeAll(async () => { - test.setTimeout(120_000); + test.setTimeout(1_800_000); directory = await mkdtemp(path.join(tmpdir(), 'hcp013-components-')); try { const checkout = path.join(directory, 'checkout'); @@ -66,7 +66,7 @@ test.beforeAll(async () => { '--store-dir', path.dirname(sourceStore) ], - { cwd: path.join(checkout, 'web'), stdio: 'pipe', timeout: 90_000 } + { cwd: path.join(checkout, 'web'), stdio: 'pipe', timeout: 1800000 } ); const sourceAudit = execFileSync( process.execPath, @@ -104,7 +104,7 @@ test.beforeAll(async () => { { cwd: path.join(checkout, 'web'), stdio: 'pipe', - timeout: 90_000 + timeout: 1800000 } ); async function payload( diff --git a/web/tests/e2e/private-publisher.spec.ts b/web/tests/e2e/private-publisher.spec.ts @@ -0,0 +1,371 @@ +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 { 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>>; + } +} +let server: Awaited<ReturnType<typeof createStaticHarness>>, + sockets: WebSocketServer, + endpoint: string, + bundle: string; +let frames: { origin: string; frame: unknown[] }[] = [], + response: 'accepted' | 'refused' = 'accepted'; +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('loopback unavailable'); + endpoint = 'ws://127.0.0.1:' + address.port; + sockets.on('connection', (socket, request) => { + const origin = new URL(request.url!, 'http://127.0.0.1').searchParams.get( + 'origin' + )!; + 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] === 'EVENT') { + const event = frame[1] as { id: string }; + socket.send( + JSON.stringify([ + 'OK', + event.id, + response === 'accepted', + response === 'accepted' ? '' : 'blocked: fixture refusal' + ]) + ); + } else if (frame[0] === 'REQ') { + 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/private-publisher.ts', import.meta.url) + ), + name: 'hcp085', + formats: ['iife'] + } + } + }); + const output = Array.isArray(result) ? result[0] : result; + if (!('output' in output)) throw Error('bundle unavailable'); + const chunks = output.output.filter((x) => x.type === 'chunk'); + expect(chunks).toHaveLength(1); + bundle = chunks[0].code; +}); +test.afterAll(async () => { + for (const s of sockets.clients) s.terminate(); + await new Promise<void>((resolve) => sockets.close(() => resolve())); + await server.close(); +}); +test.beforeEach(async ({ page }) => { + frames = []; + response = 'accepted'; + await page.addInitScript( + ({ endpoint }) => { + const Native = window.WebSocket; + window.WebSocket = class extends Native { + constructor(url: string | URL, protocols?: string | string[]) { + const parsed = new URL(String(url)); + if ( + !['wss://peer.example.org', 'wss://archive.example.org'].includes( + parsed.origin + ) + ) + throw Error('unapproved fixture destination'); + super( + endpoint + '/?origin=' + encodeURIComponent(parsed.origin), + protocols + ); + } + }; + }, + { endpoint } + ); + await page.goto(server.url + '/search'); + await page.addScriptTag({ content: bundle }); +}); +test.afterEach(async ({ page }) => { + if (!page.isClosed()) + await page.evaluate(() => window.hcp085Fixture?.close()); +}); +async function fixture( + page: import('@playwright/test').Page, + writeOnly = false +) { + await page.evaluate(async (writeOnly) => { + window.hcp085Fixture = await window.hcp085.makeFixture(writeOnly); + }, writeOnly); +} +test('missing and self-only persisted artifacts never acquire a private delivery capability', async ({ + page +}) => { + await fixture(page); + const result = await page.evaluate(async () => { + const f = window.hcp085Fixture; + const missing = !!f.permission('peer'); + const self = await f.prepareSelfOnly(); + return { + missing, + self: self.status, + selfOnly: !!f.permission('peer'), + delivery: await f.deliver('peer') + }; + }); + expect(result).toEqual({ + missing: false, + self: 'saved', + selfOnly: false, + delivery: { status: 'invalid' } + }); + expect(frames).toEqual([]); +}); +test('actual SDK loopback sees only exact persisted independent peer and archive1059 bytes', async ({ + page +}) => { + await fixture(page); + const result = await page.evaluate(async () => { + const f = window.hcp085Fixture; + const row = await f.prepare(); + const before = f.counts(); + const peer = await f.deliver('peer'), + archive = await f.deliver('self_archive'); + const after = f.counts(); + return { + row, + peer, + archive, + before: { + encrypts: before.encrypts, + decrypts: before.decrypts, + signs: before.signs + }, + after: { + encrypts: after.encrypts, + decrypts: after.decrypts, + signs: after.signs + }, + marker: f.marker + }; + }); + expect(result.peer.status).toBe('accepted'); + expect(result.archive.status).toBe('accepted'); + expect(result.after).toEqual(result.before); + const events = frames.filter((x) => x.frame[0] === 'EVENT'); + expect(events).toHaveLength(2); + expect(events.map((x) => x.origin)).toEqual([ + 'wss://peer.example.org', + 'wss://archive.example.org' + ]); + const stored = [result.row!.peerArtifact!, result.row!.self]; + for (let i = 0; i < events.length; i++) { + expect(JSON.stringify(events[i].frame[1])).toBe(stored[i].wire); + expect((events[i].frame[1] as { kind: number }).kind).toBe(1059); + } + expect(JSON.stringify(frames)).not.toContain(result.marker); + expect(stored[0].eventId).not.toBe(stored[1].eventId); +}); +test('raw14 and13 and even a genuine signed1059 object cannot replace opaque persisted permission', async ({ + page +}) => { + await fixture(page); + const statuses = await page.evaluate(async () => { + const f = window.hcp085Fixture, + row = await f.prepare(); + if (!row?.peerArtifact) throw Error('missing actual peer ciphertext'); + const event = JSON.parse(row.peerArtifact.wire) as Record<string, unknown>; + const results = []; + for (const kind of [14, 13, 1059]) + results.push( + ( + await window.hcp085.publishPrivateGiftWrapAttempt( + f.pool, + { ...event, kind } as unknown as Parameters< + typeof window.hcp085.publishPrivateGiftWrapAttempt + >[1], + new AbortController().signal + ) + ).status + ); + return results; + }); + expect(statuses).toEqual(['stopped', 'stopped', 'stopped']); + expect(frames).toEqual([]); +}); +test('role mismatches and unreviewed targets reject without a network effect', async ({ + page +}) => { + await fixture(page); + const result = await page.evaluate(async () => { + const f = window.hcp085Fixture; + await f.prepare(); + return [ + !!f.permission('peer', f.archiveOrigin), + !!f.permission('self_archive', f.peerOrigin), + !!f.permission('peer', 'wss://other.example.org'), + !!f.permission('peer', f.peerOrigin, 'not_reviewed') + ]; + }); + expect(result).toEqual([false, false, false, false]); + expect(frames).toEqual([]); +}); +for (const mode of ['remove', 'revision', 'readback'] as const) + test( + 'actual ' + + mode + + ' after capture prevents EVENT from stale persisted evidence', + async ({ page }) => { + await fixture(page); + const result = await page.evaluate(async (mode) => { + const f = window.hcp085Fixture; + await f.prepare(); + const permission = f.permission('peer'); + if (!permission) throw Error('permission missing'); + if (mode === 'remove') await f.remove(); + else if (mode === 'revision') await f.changePairRevision(); + else f.failReadback(); + return f.publish(permission); + }, mode); + expect(result.status).toBe('stopped'); + expect(frames).toEqual([]); + } + ); +for (const mode of ['Stop', 'Disconnect', 'changed key'] as const) + test( + mode + ' before effect fences the exact candidate and opens no socket', + async ({ page }) => { + await fixture(page); + const result = await page.evaluate(async (mode) => { + const f = window.hcp085Fixture; + await f.prepare(); + const permission = f.permission('peer'); + if (!permission) throw Error('permission missing'); + if (mode === 'Stop') f.stop(); + else if (mode === 'Disconnect') f.disconnect(); + else f.mode('changed_key'); + return f.publish(permission); + }, mode); + expect(result.status).toBe('stopped'); + expect(frames).toEqual([]); + } + ); +test('one opaque permission cannot issue a second SDK EVENT and detached views cannot retarget it', async ({ + page +}) => { + await fixture(page); + const result = await page.evaluate(async () => { + const f = window.hcp085Fixture; + await f.prepare(); + const p = f.permission('peer'); + if (!p) throw Error('permission missing'); + const view = window.hcp085.privatePublicationSnapshot(p)!; + const first = await f.publish(p); + const second = await f.publish(p); + return { first, second, view }; + }); + expect(result.first.status).toBe('accepted'); + expect(result.second.status).toBe('stopped'); + expect(result.view.role).toBe('peer'); + expect(frames.filter((x) => x.frame[0] === 'EVENT')).toHaveLength(1); +}); +test('actual relay refusal is a named attempt outcome without recipient or order success', async ({ + page +}) => { + response = 'refused'; + await fixture(page); + const result = await page.evaluate(async () => { + const f = window.hcp085Fixture; + await f.prepare(); + return f.deliver('self_archive'); + }); + expect(result.status).toBe('refused'); + expect(frames.filter((x) => x.frame[0] === 'EVENT')).toHaveLength(1); +}); +test('a write-only destination can publish but private reads stay on read-admitted origins', async ({ + page +}) => { + await fixture(page, true); + const result = await page.evaluate(async () => { + const f = window.hcp085Fixture; + await f.prepare(); + const write = await f.deliver('peer'); + await f.readOrigins(); + return write; + }); + expect(result.status).toBe('accepted'); + expect( + frames.filter((x) => x.frame[0] === 'REQ').map((x) => x.origin) + ).toEqual(['wss://archive.example.org']); +}); +for (const newer of [false, true]) + test( + 'successful same-owner actual delivery preserves ' + + (newer ? 'newer unsaved text' : 'captured saved encrypted text') + + ' and its composer state', + async ({ page }) => { + await fixture(page); + const result = await page.evaluate(async (newer) => { + const f = window.hcp085Fixture; + await f.prepare(); + const before = f.bindComposer(newer); + const delivery = await f.deliver('peer'); + return { before, delivery, after: f.composerState() }; + }, newer); + expect(result.delivery.status).toBe('accepted'); + expect(result.after).toEqual(result.before); + expect(result.before.snapshot?.dirty).toBe(newer); + expect(result.before.snapshot?.state).toBe( + newer ? 'unsaved' : 'saved_encrypted' + ); + expect(frames.filter((x) => x.frame[0] === 'EVENT')).toHaveLength(1); + expect(JSON.stringify(frames)).not.toContain( + 'HCP085_NEWER_PRIVATE_TEXT_MEMORY_ONLY' + ); + } + ); +test('actual owner loss still clears the bound private composer and prevents publication', async ({ + page +}) => { + await fixture(page); + const result = await page.evaluate(async () => { + const f = window.hcp085Fixture; + await f.prepare(); + const before = f.bindComposer(true); + const permission = f.permission('peer'); + if (!permission) throw Error('missing actual permission'); + f.disconnect(); + return { + before, + after: f.composerState(), + attempt: await f.publish(permission) + }; + }); + expect(result.before.snapshot?.dirty).toBe(true); + expect(result.after).toEqual({ text: undefined, snapshot: undefined }); + expect(result.attempt.status).toBe('stopped'); + expect(frames).toEqual([]); +}); diff --git a/web/tests/e2e/private-storage.spec.ts b/web/tests/e2e/private-storage.spec.ts @@ -262,7 +262,7 @@ test('two actual connections race for the last send slot without evicting existi test('private-send stored UTF8 bytes refuse oversized updates and preserve their exact base', async ({ page }) => { - test.setTimeout(120_000); + test.setTimeout(1_800_000); await load(page); const result = await page.evaluate(async () => { const f = window.hcp080Fixture, @@ -299,7 +299,7 @@ test('private-send stored UTF8 bytes refuse oversized updates and preserve their test('received count cap remains separate from a full unresolved outbox and refuses without eviction', async ({ page }) => { - test.setTimeout(120_000); + test.setTimeout(1_800_000); await load(page); const result = await page.evaluate(async () => { const f = window.hcp080Fixture, @@ -340,7 +340,7 @@ test('received count cap remains separate from a full unresolved outbox and refu test('received 48MiB byte cap refuses below count cap and preserves both independent namespaces', async ({ page }) => { - test.setTimeout(120_000); + test.setTimeout(1_800_000); await load(page); const result = await page.evaluate(async () => { const f = window.hcp080Fixture, diff --git a/web/tests/e2e/product-details.spec.ts b/web/tests/e2e/product-details.spec.ts @@ -31,7 +31,7 @@ let server: Awaited<ReturnType<typeof createStaticHarness>>; // Verification fixture: compile exact primary source, deriving only its fixed // deployment allowlist. Never alter the primary output or production policy. test.beforeAll(async () => { - test.setTimeout(120000); + test.setTimeout(1_800_000); directory = await mkdtemp(path.join(tmpdir(), 'hcp044-details-')); try { const checkout = path.join(directory, 'checkout'), @@ -94,7 +94,7 @@ test.beforeAll(async () => { '--store-dir', path.dirname(sourceStore) ], - { cwd: web, timeout: 90000 } + { cwd: web, timeout: 1800000 } ).toString(); const sourceAudit = execFileSync( process.execPath, @@ -105,7 +105,7 @@ test.beforeAll(async () => { const compiled = execFileSync( process.execPath, ['node_modules/vite/bin/vite.js', 'build'], - { cwd: web, timeout: 90000 } + { cwd: web, timeout: 1800000 } ).toString(); console.log( JSON.stringify({ diff --git a/web/tests/e2e/search-form.spec.ts b/web/tests/e2e/search-form.spec.ts @@ -20,7 +20,7 @@ const capsule = fileURLToPath(new URL('../../../', import.meta.url)); let directory: string; let server: Awaited<ReturnType<typeof createStaticHarness>>; test.beforeAll(async () => { - test.setTimeout(120_000); + test.setTimeout(1_800_000); directory = await mkdtemp(path.join(tmpdir(), 'hcp015-search-form-')); try { const checkout = path.join(directory, 'checkout'); @@ -74,7 +74,7 @@ test.beforeAll(async () => { '--store-dir', path.dirname(sourceStore) ], - { cwd: path.join(checkout, 'web'), stdio: 'pipe', timeout: 90_000 } + { cwd: path.join(checkout, 'web'), stdio: 'pipe', timeout: 1800000 } ); const sourceAudit = execFileSync( process.execPath, @@ -107,7 +107,7 @@ test.beforeAll(async () => { { cwd: path.join(checkout, 'web'), stdio: 'pipe', - timeout: 90_000 + timeout: 1800000 } ); async function payload( diff --git a/web/tests/e2e/search-results.spec.ts b/web/tests/e2e/search-results.spec.ts @@ -30,7 +30,7 @@ let server: Awaited<ReturnType<typeof createStaticHarness>>; // Verification fixture: compile exact primary source, deriving only its fixed // deployment allowlist. Never alter the primary output or production policy. test.beforeAll(async () => { - test.setTimeout(120000); + test.setTimeout(1_800_000); directory = await mkdtemp(path.join(tmpdir(), 'hcp043-search-')); try { const checkout = path.join(directory, 'checkout'), @@ -93,7 +93,7 @@ test.beforeAll(async () => { '--store-dir', path.dirname(sourceStore) ], - { cwd: web, timeout: 90000 } + { cwd: web, timeout: 1800000 } ).toString(); const sourceAudit = execFileSync( process.execPath, @@ -104,7 +104,7 @@ test.beforeAll(async () => { const compiled = execFileSync( process.execPath, ['node_modules/vite/bin/vite.js', 'build'], - { cwd: web, timeout: 90000 } + { cwd: web, timeout: 1800000 } ).toString(); console.log( JSON.stringify({ diff --git a/web/tests/e2e/shell.spec.ts b/web/tests/e2e/shell.spec.ts @@ -21,7 +21,7 @@ const capsule = fileURLToPath(new URL('../../../', import.meta.url)); let directory: string; let server: Awaited<ReturnType<typeof createStaticHarness>>; test.beforeAll(async () => { - test.setTimeout(120_000); + test.setTimeout(1_800_000); directory = await mkdtemp(path.join(tmpdir(), 'hcp014-shell-')); try { const checkout = path.join(directory, 'checkout'); @@ -71,7 +71,7 @@ test.beforeAll(async () => { '--store-dir', path.dirname(sourceStore) ], - { cwd: path.join(checkout, 'web'), stdio: 'pipe', timeout: 90_000 } + { cwd: path.join(checkout, 'web'), stdio: 'pipe', timeout: 1800000 } ); const fixtureLayout = '<script lang="ts">import "../theme.css"; import "../app.css"; import type { Snippet } from "svelte"; let { children }: { children: Snippet } = $props();</script>{@render children()}'; @@ -123,7 +123,7 @@ test.beforeAll(async () => { { cwd: path.join(checkout, 'web'), stdio: 'pipe', - timeout: 90_000 + timeout: 1800000 } ); async function payload( diff --git a/web/tests/provenance/commands.test.mjs b/web/tests/provenance/commands.test.mjs @@ -65,7 +65,7 @@ fi cwd: root, env: { ...env, ...extra }, encoding: 'utf8', - timeout: 30000 + timeout: 1800000 } ); return { @@ -111,7 +111,7 @@ fi await test( 'standalone web targets select web cwd and run every required lane without native tools', - { timeout: 180000 }, + { timeout: 1800000 }, async (t) => { const { root, run, calls } = await fixture(t); for (const target of [ @@ -150,7 +150,7 @@ await test( await test( 'doctor rejects a mismatched selected manager before installation', - { timeout: 45000 }, + { timeout: 1800000 }, async (t) => { const { run, calls } = await fixture(t); const result = run('web-install', { HC_PNPM_VERSION: '10.25.0' }); @@ -166,7 +166,7 @@ await test( await test( 'web check propagates failing commands and stops subsequent lanes', - { timeout: 45000 }, + { timeout: 1800000 }, async (t) => { const { run, calls } = await fixture(t); const result = run('web-check', { HC_FAIL_COMMAND: 'lint' }); @@ -185,7 +185,7 @@ await test( await test( 'missing web tooling fails without trying native tools', - { timeout: 45000 }, + { timeout: 1800000 }, async (t) => { const { root, run } = await fixture(t); await rm(path.join(root, 'bin/corepack')); @@ -197,7 +197,7 @@ await test( await test( 'doctor rejects mismatched toolchain authorities', - { timeout: 45000 }, + { timeout: 1800000 }, async (t) => { const { root, run } = await fixture(t); await writeFile(path.join(root, 'web/.node-version'), '24.20.0\n'); @@ -213,7 +213,7 @@ await test( await test( 'doctor rejects wrong selected Node before invoking Corepack', - { timeout: 45000 }, + { timeout: 1800000 }, async (t) => { const { root, run } = await fixture(t); const file = path.join(root, 'web/package.json'); diff --git a/web/tests/provenance/message-interop.test.mjs b/web/tests/provenance/message-interop.test.mjs @@ -29,7 +29,7 @@ void test('explicit Message interop runner rejects unapproved arguments before C { cwd: new URL('../../', import.meta.url), encoding: 'utf8', - timeout: 10000 + timeout: 1800000 } ); assert.equal(result.status, 1); diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs @@ -131,7 +131,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; execFileSync( process.execPath, [path.join(source, 'web/node_modules/vite/bin/vite.js'), 'build'], - { cwd: web, stdio: 'pipe', timeout: 300000 } + { cwd: web, stdio: 'pipe', timeout: 1800000 } ); active(t); } finally { @@ -142,7 +142,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; } await test( 'actual output fixture setup', - { timeout: 600000 }, + { timeout: 1800000 }, async (t) => { // Compile actual current source once in isolation. No install/native subprocess. for (const name of git( @@ -191,7 +191,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; ); await test( 'public-only owned lifecycle remains independently compilable', - { timeout: 600000 }, + { timeout: 1800000 }, async (t) => { const f = await fixture(t); for (const [name, value] of Object.entries(historicalPublicOnly)) { @@ -223,7 +223,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; ); await test( 'predecessor SDK graph remains qualified with the historical search form fixture', - { timeout: 600000 }, + { timeout: 1800000 }, async (t) => { const f = await fixture(t); // This historical graph predates identity activation. Restore its @@ -264,7 +264,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; ); await test( 'HCP043 search graph remains qualified with the exact historical product shell', - { timeout: 600000 }, + { timeout: 1800000 }, async (t) => { const f = await fixture(t); for (const [name, value] of Object.entries(historicalPublicOnly)) @@ -284,7 +284,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; { timeout: 1800000 }, async (t) => { /** @param {string} name @param {(context: import('node:test').TestContext) => Promise<void>} run @param {number} [timeout] */ - const check = (name, run, timeout = 120000) => + const check = (name, run, timeout = 1800000) => t.test(name, { timeout }, run); await check( 'actual compiled payload passes and build dispatch invokes the guard last', @@ -1562,7 +1562,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; { cwd: f.web, encoding: 'utf8', - timeout: 120000, + timeout: 1800000, maxBuffer: 4096 } ) @@ -1606,7 +1606,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; ); await test( 'actual compiler admits nonempty approved theme/app CSS', - { timeout: 600000 }, + { timeout: 1800000 }, async (t) => { ready(t); const layout = path.join(base, 'web/src/routes/+layout.svelte'); diff --git a/web/tests/provenance/source-boundaries.test.mjs b/web/tests/provenance/source-boundaries.test.mjs @@ -139,7 +139,7 @@ async function fixture(run) { const result = spawnSync(process.execPath, args, { cwd: directory, encoding: 'utf8', - timeout: 8000 + timeout: 1800000 }); assert.equal(result.error, undefined); return result; @@ -594,7 +594,7 @@ for (const script of ['check', 'lint', 'build', 'test:unit', 'dev']) const result = spawnSync('corepack', ['pnpm', 'run', script], { cwd: directory, encoding: 'utf8', - timeout: 8000 + timeout: 1800000 }); assert.equal(result.error, undefined); assert.equal(result.status, 1, result.stdout + result.stderr); @@ -832,7 +832,7 @@ for (const script of ['check', 'lint', 'build', 'test:unit', 'dev']) const result = spawnSync('corepack', ['pnpm', 'run', script], { cwd: directory, encoding: 'utf8', - timeout: 8000 + timeout: 1800000 }); assert.equal(result.error, undefined); assert.equal(result.status, 1, result.stdout + result.stderr); @@ -1587,7 +1587,7 @@ for (const command of ['check', 'lint', 'build', 'test:unit', 'dev']) const result = spawnSync('corepack', ['pnpm', 'run', command], { cwd: directory, encoding: 'utf8', - timeout: 8000 + timeout: 1800000 }); assert.equal(result.error, undefined); assert.equal(result.status, 1, result.stdout + result.stderr); @@ -1885,7 +1885,7 @@ for (const command of ['check', 'lint', 'build', 'test:unit', 'dev']) const result = spawnSync('corepack', ['pnpm', 'run', command], { cwd: directory, encoding: 'utf8', - timeout: 8000 + timeout: 1800000 }); assert.equal(result.error, undefined); assert.equal(result.status, 1, result.stdout + result.stderr); @@ -2101,8 +2101,8 @@ test('history scroll owner rejects malformed values without coercion or SSR effe test( 'HCP076 allows only the byte-pinned disposable gift-wrap producer and rejects key escape or copied construction', - // Nine sequential audits retain8s each, plus bounded real fixture setup. - { timeout: 90000 }, + // Sequential audits retain generous host allowances on busy workstations. + { timeout: 1800000 }, async () => { await fixture(async ({ directory, put, execute }) => { await confineSvelte(directory); @@ -2156,7 +2156,7 @@ test( ); test( 'HCP076 rejects production key generation and secret access through named, aliased, namespace and bracket APIs outside the exact wrapper', - { timeout: 30000 }, + { timeout: 1800000 }, async () => { await fixture(async ({ directory, put, execute }) => { await confineSvelte(directory); diff --git a/web/tests/unit/private-publisher.test.ts b/web/tests/unit/private-publisher.test.ts @@ -0,0 +1,89 @@ +import { describe, it, expect } from 'vitest'; +import { + capturePrivatePublication, + privatePublicationSnapshot, + takePrivatePublication, + type PrivatePublication +} from '../../src/lib/nostr/private-publisher.ts'; +import { + publishPrivateGiftWrapAttempt, + type PrivatePool +} from '../../src/lib/nostr/private-pool.ts'; +import type { PrivateSession } from '../../src/lib/runtime/private-session.ts'; +import type { PrivateStorageRepository } from '../../src/lib/persistence/private-storage.ts'; +import type { PairedDeliveryAcknowledgement } from '../../src/lib/persistence/private-sends.ts'; +import type { PairedDeliveryContext } from '../../src/lib/messaging/prepare-send.ts'; +describe('private publication has no arbitrary event sink', () => { + it('SSR refuses forged local acknowledgement and publication without effects', async () => { + const session = {} as PrivateSession; + expect( + capturePrivatePublication( + {} as PrivateStorageRepository, + session, + {} as PairedDeliveryAcknowledgement, + {} as PairedDeliveryContext, + 'peer', + 'wss://peer.example.org', + 'reviewed_private_delivery' + ) + ).toBeUndefined(); + expect( + privatePublicationSnapshot({} as PrivatePublication) + ).toBeUndefined(); + expect( + await takePrivatePublication( + {} as PrivatePublication, + session, + {} as PairedDeliveryContext['policy'], + 'wss://peer.example.org' + ) + ).toBeUndefined(); + expect( + await publishPrivateGiftWrapAttempt( + {} as PrivatePool, + {} as PrivatePublication, + new AbortController().signal + ) + ).toEqual({ status: 'stopped' }); + }); + it.each([14, 13, 1059])( + 'a caller event of kind %i cannot act as publication permission', + async (kind) => { + const raw = { + kind, + content: 'PRIVATE_TEXT', + tags: [], + id: '0'.repeat(64) + } as unknown as PrivatePublication; + expect(privatePublicationSnapshot(raw)).toBeUndefined(); + expect( + await publishPrivateGiftWrapAttempt( + {} as PrivatePool, + raw, + new AbortController().signal + ) + ).toEqual({ status: 'stopped' }); + } + ); + it('review objects and forged capabilities are not coerced', () => { + let calls = 0; + const review = { + toString() { + calls++; + return 'reviewed_private_delivery'; + } + }; + expect( + capturePrivatePublication( + {} as PrivateStorageRepository, + {} as PrivateSession, + {} as PairedDeliveryAcknowledgement, + {} as PairedDeliveryContext, + 'peer', + 'wss://peer.example.org', + review + ) + ).toBeUndefined(); + expect(calls).toBe(0); + }); +}); diff --git a/web/tests/unit/relay-config.test.ts b/web/tests/unit/relay-config.test.ts @@ -283,7 +283,7 @@ describe('fixed relay policy', () => { { cwd: fileURLToPath(new URL('../../', import.meta.url)), encoding: 'utf8', - timeout: 10000 + timeout: 1800000 } ); expect(result.error).toBeUndefined(); diff --git a/web/tools/check-food-interop.mjs b/web/tools/check-food-interop.mjs @@ -30,7 +30,7 @@ const run = (command, argv, cwd = root) => { const result = spawnSync(command, argv, { cwd, encoding: 'utf8', - timeout: 180000, + timeout: 1800000, maxBuffer: 1024 * 1024 }); assert.ifError(result.error); diff --git a/web/tools/check-message-interop.mjs b/web/tools/check-message-interop.mjs @@ -40,7 +40,7 @@ function success(command, argv, cwd = root) { const r = spawnSync(command, argv, { cwd, encoding: 'utf8', - timeout: 180000, + timeout: 1800000, maxBuffer: 1024 * 1024 }); assert.ifError(r.error); diff --git a/web/tools/doctor.mjs b/web/tools/doctor.mjs @@ -53,7 +53,7 @@ const selectedPnpm = execFileSync('corepack', ['pnpm', '--version'], { cwd: process.cwd(), env: { ...process.env, COREPACK_ENABLE_NETWORK: '0' }, encoding: 'utf8', - timeout: 10000, + timeout: 600000, maxBuffer: 64 * 1024, stdio: ['ignore', 'pipe', 'pipe'] }).trim(); diff --git a/web/vitest.config.ts b/web/vitest.config.ts @@ -7,7 +7,7 @@ export default defineConfig({ test: { environment: 'node', fileParallelism: false, - testTimeout: 120_000, + testTimeout: 600_000, include: ['tests/unit/**/*.test.ts'], setupFiles: ['tests/unit/ssr-effects.ts'], passWithNoTests: false