inbox-readback.spec.ts (15992B)
1 import { test, expect, type Page } from '@playwright/test'; 2 import { build } from 'vite'; 3 import { fileURLToPath } from 'node:url'; 4 import { createHash } from 'node:crypto'; 5 import { once } from 'node:events'; 6 import { WebSocketServer } from 'ws'; 7 import { createStaticHarness } from '../integration/harness/static.ts'; 8 import type * as Fixture from './harness/inbox-readback.ts'; 9 import type { PublicQuotaRepository } from '../../src/lib/persistence/quota.ts'; 10 import type { BrowserDatabase } from '../../src/lib/persistence/database.ts'; 11 import type { PrivateSession } from '../../src/lib/runtime/private-session.ts'; 12 import type { 13 PublicRuntimeContext, 14 PublicView 15 } from '../../src/lib/runtime/public-runtime.ts'; 16 import type { InboxReadback } from '../../src/lib/nostr/inbox-readback.ts'; 17 declare global { 18 interface Window { 19 hcp067: typeof Fixture; 20 hcp067Clock: ReturnType<typeof Fixture.makeReadbackClock>; 21 hcp067Fixture: Awaited<ReturnType<typeof Fixture.makePublisherFixture>>; 22 hcp067Repo: PublicQuotaRepository; 23 hcp067Db: BrowserDatabase; 24 hcp067Id: string; 25 hcp067Private: PrivateSession | undefined; 26 hcp067Context: PublicRuntimeContext; 27 hcp067View: PublicView; 28 hcp067Readback: InboxReadback; 29 hcp067Restore?: () => void; 30 hcp067Trace: ReturnType<typeof Fixture.installEffectTrace>; 31 } 32 } 33 let server: Awaited<ReturnType<typeof createStaticHarness>>, 34 socketServer: WebSocketServer, 35 bundle: string, 36 endpoint: string; 37 let frames: string[] = [], 38 artifact: unknown, 39 competing: unknown; 40 let response: 'artifact' | 'missing' | 'competing' | 'partial' | 'wrong_wire' = 41 'artifact'; 42 test.beforeAll(async () => { 43 server = await createStaticHarness(); 44 socketServer = new WebSocketServer({ 45 host: '127.0.0.1', 46 port: 0, 47 maxPayload: 65536 48 }); 49 await once(socketServer, 'listening'); 50 const address = socketServer.address(); 51 if (!address || typeof address === 'string') 52 throw new Error('missing loopback'); 53 endpoint = 'ws://127.0.0.1:' + address.port; 54 socketServer.on('connection', (socket) => 55 socket.on('message', (bytes) => { 56 const raw = Buffer.isBuffer(bytes) 57 ? bytes.toString() 58 : Array.isArray(bytes) 59 ? Buffer.concat(bytes).toString() 60 : Buffer.from(bytes).toString(), 61 frame = JSON.parse(raw) as unknown[]; 62 if (frame[0] === 'EVENT') { 63 frames.push(raw); 64 artifact = frame[1]; 65 const event = artifact as { id: string }; 66 socket.send(JSON.stringify(['OK', event.id, true, ''])); 67 } else if (frame[0] === 'REQ') { 68 if (response !== 'missing') { 69 const event = 70 response === 'wrong_wire' 71 ? { 72 ...(artifact as Record<string, unknown>), 73 content: 'altered unverified' 74 } 75 : artifact; 76 socket.send(JSON.stringify(['EVENT', frame[1], event])); 77 } 78 if (response === 'competing') 79 socket.send(JSON.stringify(['EVENT', frame[1], competing])); 80 if (response !== 'partial') 81 socket.send(JSON.stringify(['EOSE', frame[1]])); 82 } 83 }) 84 ); 85 const result = await build({ 86 configFile: false, 87 logLevel: 'silent', 88 build: { 89 write: false, 90 minify: false, 91 lib: { 92 entry: fileURLToPath( 93 new URL('./harness/inbox-readback.ts', import.meta.url) 94 ), 95 name: 'hcp067', 96 formats: ['iife'] 97 } 98 } 99 }); 100 const output = Array.isArray(result) ? result[0] : result; 101 if (!('output' in output)) throw new Error('missing output'); 102 const chunks = output.output.filter((x) => x.type === 'chunk'); 103 expect(chunks).toHaveLength(1); 104 bundle = chunks[0].code; 105 console.log( 106 JSON.stringify({ 107 fixture: 'HCP067_ACTUAL_SDK_REAL_IDB_WEBLOCK_LOOPBACK', 108 bundleSha256: createHash('sha256').update(bundle).digest('hex'), 109 moduleIds: Object.keys(chunks[0].modules), 110 qualification: 111 'controlled local source only; no real extension/operator/retention/client qualification' 112 }) 113 ); 114 }); 115 test.afterAll(async () => { 116 for (const socket of socketServer.clients) socket.terminate(); 117 await new Promise<void>((resolve) => socketServer.close(() => resolve())); 118 await server.close(); 119 }); 120 test.beforeEach(async ({ page }, testInfo) => { 121 frames = []; 122 response = 'artifact'; 123 artifact = undefined; 124 competing = undefined; 125 await page.addInitScript( 126 ({ endpoint }) => { 127 const Native = window.WebSocket; 128 class LoopbackSocket extends Native { 129 constructor(url: string | URL, protocols?: string | string[]) { 130 if ( 131 ![ 132 'wss://discovery.example.org/', 133 'wss://publisher.example.org/' 134 ].includes(String(url)) 135 ) 136 throw new Error('unexpected fixture destination'); 137 super(endpoint, protocols); 138 } 139 } 140 window.WebSocket = LoopbackSocket; 141 }, 142 { endpoint } 143 ); 144 await page.goto(server.url + '/search'); 145 await page.addScriptTag({ content: bundle }); 146 await page.evaluate(async (disjoint) => { 147 const s = window.hcp067, 148 f = disjoint 149 ? await s.makeDisjointReadbackFixture() 150 : await s.makePublisherFixture(); 151 window.hcp067Fixture = f; 152 const opened = await s.openBrowserDatabase(); 153 if (opened.state !== 'ready') throw new Error(opened.reason); 154 window.hcp067Db = opened.owner; 155 const repo = s.createPublicQuotaRepository(opened.owner, f.owner); 156 if (!repo) throw new Error('missing repo'); 157 window.hcp067Repo = repo; 158 const reviewed = await s.reviewInboxSetup( 159 f.identity, 160 f.resolve(), 161 f.policy, 162 s.setupInput(), 163 () => 101 164 ); 165 if (reviewed.status !== 'review') throw new Error(reviewed.reason); 166 const id = crypto.randomUUID(); 167 window.hcp067Id = id; 168 await s.saveInboxPreferenceOperation( 169 repo, 170 reviewed.review, 171 f.resolve(), 172 id, 173 'reviewed_global_inbox_replacement' 174 ); 175 const action = await s.beginInboxPreferenceOperation( 176 repo, 177 f.identity, 178 f.policy, 179 reviewed.review, 180 id, 181 () => Promise.resolve(f.resolve()), 182 'reviewed_global_inbox_replacement' 183 ); 184 if (action.status !== 'prepared') throw new Error(action.status); 185 const published = await s.runInboxPreferenceOperation(action.action); 186 if (published.status !== 'completed') throw new Error(published.status); 187 window.hcp067Private = await s.createPrivateSession( 188 f.identity, 189 'reviewed_private_session' 190 ); 191 const context = s.createPublicRuntimeContext(), 192 clock = s.makeReadbackClock(), 193 runtime = s.mountPublicRuntime(context, f.policy, clock.clock); 194 window.hcp067Clock = clock; 195 if (!runtime) throw new Error('missing runtime'); 196 window.hcp067Context = context; 197 window.hcp067View = s.createPublicView(runtime); 198 }, testInfo.title.includes('distinct discovery and publication origins')); 199 }); 200 test.afterEach(async ({ page }) => { 201 if (!page.isClosed()) 202 await page.evaluate(() => { 203 window.hcp067Restore?.(); 204 window.hcp067Trace?.restore(); 205 if (window.hcp067Readback) 206 window.hcp067.closeInboxReadback(window.hcp067Readback); 207 if (window.hcp067Context) 208 window.hcp067.closePublicRuntime(window.hcp067Context); 209 if (window.hcp067Private) 210 window.hcp067.closePrivateSession(window.hcp067Private); 211 window.hcp067Fixture?.close(); 212 if (window.hcp067Db) window.hcp067.closeBrowserDatabase(window.hcp067Db); 213 }); 214 }); 215 216 async function openReadback(page: Page, settle = true) { 217 await page.evaluate(async () => { 218 const s = window.hcp067, 219 f = window.hcp067Fixture, 220 read = await s.loadPreferenceOperation( 221 window.hcp067Repo, 222 window.hcp067Id 223 ); 224 if (!read.ok) throw new Error(read.reason); 225 const run = s.beginPublicViewRun(window.hcp067View); 226 const reader = s.resolveInboxReadback( 227 window.hcp067View, 228 run, 229 read.value, 230 f.owner, 231 window.hcp067Id, 232 f.policy 233 ); 234 if (!reader) throw new Error('missing reader'); 235 window.hcp067Readback = reader; 236 }); 237 if (settle) 238 await page.waitForFunction( 239 () => 240 window.hcp067.inboxReadbackSnapshot(window.hcp067Readback)?.status !== 241 'pending' 242 ); 243 } 244 async function verify(page: Page, qualified = true) { 245 return await page.evaluate(async (qualified) => { 246 const s = window.hcp067, 247 f = window.hcp067Fixture; 248 const result = await s.verifyInboxSetupOperation( 249 window.hcp067Repo, 250 f.identity, 251 window.hcp067Private, 252 f.policy, 253 window.hcp067Readback, 254 qualified 255 ? (context) => ({ 256 ...context, 257 receive: 'qualified_exercised', 258 archive: 'qualified_exercised', 259 current: () => true 260 }) 261 : undefined 262 ); 263 const read = await s.loadPreferenceOperation( 264 window.hcp067Repo, 265 window.hcp067Id 266 ), 267 row = read.ok 268 ? s.publicRecordSnapshot(read.value, f.owner, window.hcp067Id) 269 : undefined; 270 if (row?.family !== 'preference_operation') 271 throw new Error('missing operation'); 272 return { result, row, signs: f.signs() }; 273 }, qualified); 274 } 275 test('named ACK alone leaves setup closed; exact actual relay readback is durable before setup projection opens', async ({ 276 page 277 }) => { 278 response = 'missing'; 279 await openReadback(page); 280 let result = await verify(page); 281 expect(result.result.setupComplete).toBe(false); 282 expect(result.row?.receipts.every((f) => f.readbackWire === null)).toBe(true); 283 response = 'artifact'; 284 await openReadback(page); 285 result = await verify(page); 286 expect(result.result.status).toBe('verified'); 287 expect(result.result.setupComplete).toBe(true); 288 expect(result.result.newListingReady).toBe(true); 289 expect(result.result.sendReady).toBe(false); 290 expect(result.signs).toBe(1); 291 expect( 292 result.row?.receipts.filter((f) => f.readbackWire !== null) 293 ).toHaveLength(1); 294 expect(frames).toHaveLength(1); 295 }); 296 test('exact readback without qualified exercised access does not claim setup or perpetual availability', async ({ 297 page 298 }) => { 299 await openReadback(page); 300 const result = await verify(page, false); 301 expect(result.result.status).toBe('access_unavailable'); 302 expect(result.result.setupComplete).toBe(false); 303 expect(result.result.newListingReady).toBe(false); 304 expect(frames).toHaveLength(1); 305 }); 306 test('competing newest preference remains visible while exact artifact readback is retained separately', async ({ 307 page 308 }) => { 309 competing = await page.evaluate(() => window.hcp067Fixture.competing()); 310 response = 'competing'; 311 await openReadback(page); 312 const result = await verify(page); 313 expect(result.result.status).toBe('conflict'); 314 expect(result.result.setupComplete).toBe(false); 315 expect(result.result.knownHead?.id).toBe((competing as { id: string }).id); 316 expect( 317 result.row?.receipts.filter((f) => f.readbackWire !== null) 318 ).toHaveLength(1); 319 expect(result.signs).toBe(1); 320 expect(frames).toHaveLength(1); 321 }); 322 test('real IDB readback receipt failure prevents setup completion', async ({ 323 page 324 }) => { 325 await openReadback(page); 326 await page.evaluate(() => { 327 window.hcp067Restore = window.hcp067.failPreferenceWrite(4); 328 }); 329 const result = await verify(page); 330 expect(result.result.status).toBe('storage_failed'); 331 expect(result.result.setupComplete).toBe(false); 332 expect(result.row?.revision).toBe(3); 333 expect(result.row?.receipts.every((f) => f.readbackWire === null)).toBe(true); 334 expect(frames).toHaveLength(1); 335 }); 336 test('partial discovery and invalid signed readback cannot open setup gates', async ({ 337 page 338 }) => { 339 response = 'partial'; 340 await openReadback(page, false); 341 let result = await verify(page); 342 expect(result.result.setupComplete).toBe(false); 343 expect(result.result.newListingReady).toBe(false); 344 response = 'wrong_wire'; 345 await openReadback(page); 346 result = await verify(page); 347 expect(result.result.setupComplete).toBe(false); 348 expect(result.row?.receipts.every((f) => f.readbackWire === null)).toBe(true); 349 expect(frames).toHaveLength(1); 350 }); 351 test('fresh extension owner mismatch stops readback verification without another write or signature', async ({ 352 page 353 }) => { 354 await openReadback(page); 355 await page.evaluate(() => window.hcp067Fixture.changeOwner()); 356 const result = await verify(page); 357 expect(result.result.setupComplete).toBe(false); 358 expect(result.row?.revision).toBe(3); 359 expect(result.signs).toBe(1); 360 expect(frames).toHaveLength(1); 361 }); 362 test('already compatible configuration projects readiness without a redundant preference write', async ({ 363 page 364 }) => { 365 await openReadback(page); 366 const result = await page.evaluate(() => { 367 const s = window.hcp067, 368 f = window.hcp067Fixture; 369 window.hcp067Trace = s.installEffectTrace(); 370 const own = s.inboxReadbackEvidence(window.hcp067Readback)?.resolver; 371 if (!own) throw new Error('missing actual compatible resolver'); 372 const result = s.existingInboxSetupSnapshot( 373 f.identity, 374 window.hcp067Private, 375 f.policy, 376 own, 377 (context) => ({ 378 ...context, 379 receive: 'qualified_exercised', 380 archive: 'qualified_exercised', 381 current: () => true 382 }) 383 ); 384 return { result, events: window.hcp067Trace.events(), signs: f.signs() }; 385 }); 386 expect(result.result.setupComplete).toBe(true); 387 expect(result.events).toEqual([]); 388 expect(result.signs).toBe(1); 389 expect(frames).toHaveLength(1); 390 }); 391 392 test('final readback clock invalidating exercised access leaves setup and listing gates closed', async ({ 393 page 394 }) => { 395 await openReadback(page); 396 const observed = await page.evaluate(async () => { 397 const s = window.hcp067, 398 f = window.hcp067Fixture; 399 let qualified = true, 400 invalidated = false; 401 const result = await s.verifyInboxSetupOperation( 402 window.hcp067Repo, 403 f.identity, 404 window.hcp067Private, 405 f.policy, 406 window.hcp067Readback, 407 (context) => ({ 408 ...context, 409 receive: 'qualified_exercised', 410 archive: 'qualified_exercised', 411 current: () => { 412 window.hcp067Clock.once(() => { 413 qualified = false; 414 invalidated = true; 415 }); 416 return qualified; 417 } 418 }) 419 ); 420 return { result, invalidated, qualified, signs: f.signs() }; 421 }); 422 expect(observed.invalidated).toBe(true); 423 expect(observed.qualified).toBe(false); 424 expect(observed.result.status).toBe('access_unavailable'); 425 expect(observed.result.setupComplete).toBe(false); 426 expect(observed.result.newListingReady).toBe(false); 427 expect(observed.result.sendReady).toBe(false); 428 expect(observed.signs).toBe(1); 429 expect(frames).toHaveLength(1); 430 }); 431 432 test('distinct discovery and publication origins retain separate ACK and readback provenance before setup opens', async ({ 433 page 434 }) => { 435 await openReadback(page); 436 const observed = await verify(page); 437 expect(observed.result.status).toBe('verified'); 438 expect(observed.result.setupComplete).toBe(true); 439 expect(observed.result.newListingReady).toBe(true); 440 expect(observed.result.sendReady).toBe(false); 441 expect(observed.signs).toBe(1); 442 expect(frames).toHaveLength(1); 443 expect( 444 observed.row.receipts.some( 445 (fact) => 446 fact.origin === 'wss://publisher.example.org' && 447 fact.status === 'accepted' && 448 fact.readbackWire === null 449 ) 450 ).toBe(true); 451 const reads = observed.row.receipts.filter( 452 (fact) => fact.readbackWire !== null 453 ); 454 expect(reads).toHaveLength(1); 455 expect(reads[0]).toMatchObject({ 456 origin: 'wss://publisher.example.org', 457 readbackOrigin: 'wss://discovery.example.org', 458 status: 'accepted' 459 }); 460 expect( 461 observed.row.receipts.every( 462 (fact) => fact.origin === 'wss://publisher.example.org' 463 ) 464 ).toBe(true); 465 });