private-dispose.test.ts (16059B)
1 import { test } from 'node:test'; 2 import assert from 'node:assert/strict'; 3 import { once } from 'node:events'; 4 import WebSocket, { WebSocketServer } from 'ws'; 5 import { RelayPool } from 'applesauce-relay/pool'; 6 import { 7 createIdentitySession, 8 connectIdentity, 9 probeIdentityMessaging, 10 disconnectIdentity, 11 recheckIdentityOwner 12 } from '../../src/lib/runtime/identity-session.ts'; 13 import { 14 createPrivateSession, 15 closePrivateSession, 16 privateSessionSnapshot, 17 privateSessionCleanupRequired, 18 subscribePrivateSessionClose 19 } from '../../src/lib/runtime/private-session.ts'; 20 import { 21 getPrivateVisibilityScope, 22 privateVisibilitySnapshot, 23 closePrivateVisibilityScope 24 } from '../../src/lib/runtime/dispose.ts'; 25 import { 26 getPrivatePool, 27 subscribePrivatePage, 28 closePrivatePool 29 } from '../../src/lib/nostr/private-pool.ts'; 30 import { 31 getPublicPool, 32 subscribePublicPool, 33 closePublicPool 34 } from '../../src/lib/nostr/public-pool.ts'; 35 import { 36 getPrivateCacheScope, 37 retainPrivateCacheWire, 38 privateCacheWire, 39 privateCacheSnapshot 40 } from '../../src/lib/nostr/private-cache-scope.ts'; 41 import { 42 getPrivateEnvelopeCapability, 43 privateEnvelopeConstructionOwnership 44 } from '../../src/lib/nostr/private-envelope-capability.ts'; 45 import { validateRelayPolicy } from '../../src/lib/config/relays.ts'; 46 47 // HC_TEST_ONLY_PROVIDER/RELAY/DOCUMENT: actual SDK sockets on isolated loopback; 48 // echo probe and controlled EventTarget qualify lifetime, not crypto/browser Q. 49 await test('private disposal owns real SDK sockets, retryable cleanup and terminal visibility while public browsing continues', async (t) => { 50 const owner = 51 '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'; 52 const other = 53 'c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5'; 54 const origin = 'wss://relay.example.org'; 55 const policy = validateRelayPolicy( 56 JSON.stringify({ 57 schemaVersion: 1, 58 public: [{ origin, read: true, write: false, nip50: false }], 59 inbox: [{ origin, read: true, write: true }], 60 postingEnabled: false, 61 messagingEnabled: true, 62 operatorDenylist: [] 63 }) 64 ); 65 assert.ok(policy); 66 const server = new WebSocketServer({ 67 host: '127.0.0.1', 68 port: 0, 69 maxPayload: 65536 70 }); 71 const requests = new Map<WebSocket, { kind: number; id: string }>(); 72 let privateReady = () => {}; 73 server.on('connection', (socket) => 74 socket.on('message', (bytes) => { 75 const buffer = Array.isArray(bytes) 76 ? Buffer.concat(bytes) 77 : Buffer.isBuffer(bytes) 78 ? bytes 79 : Buffer.from(bytes); 80 const frame: unknown = JSON.parse(buffer.toString('utf8')); 81 assert.ok(Array.isArray(frame)); 82 if (frame[0] !== 'REQ') return; 83 const filter = frame[2] as { kinds: number[] }; 84 requests.set(socket, { kind: filter.kinds[0], id: frame[1] as string }); 85 if (filter.kinds[0] === 1059) privateReady(); 86 else socket.send(JSON.stringify(['EOSE', frame[1]])); 87 }) 88 ); 89 await once(server, 'listening'); 90 const address = server.address(); 91 assert.ok(address && typeof address !== 'string'); 92 const fixturePort = address.port; 93 const originalSocket = globalThis.WebSocket, 94 originalFetch = globalThis.fetch, 95 originalReq = Reflect.get<RelayPool, 'req'>(RelayPool.prototype, 'req'), 96 originalClose = Reflect.get<RelayPool, 'close'>( 97 RelayPool.prototype, 98 'close' 99 ); 100 const documentTarget = new EventTarget(); 101 Object.defineProperty(documentTarget, 'visibilityState', { 102 configurable: true, 103 writable: true, 104 value: 'visible' 105 }); 106 Object.defineProperty(globalThis, 'document', { 107 configurable: true, 108 value: documentTarget 109 }); 110 let key = owner, 111 prompts = 0, 112 signatures = 0; 113 Object.defineProperty(globalThis, 'window', { 114 configurable: true, 115 value: { 116 nostr: { 117 getPublicKey: () => { 118 prompts++; 119 return Promise.resolve(key); 120 }, 121 signEvent: () => { 122 signatures++; 123 return Promise.reject(new Error('HC_TEST_ONLY_UNEXPECTED_SIGN')); 124 }, 125 nip44: { 126 encrypt: (_peer: string, text: string) => 127 Promise.resolve('fixture:' + text), 128 decrypt: (_peer: string, text: string) => 129 Promise.resolve(text.slice(8)) 130 } 131 } 132 } 133 }); 134 class FixtureSocket extends WebSocket { 135 constructor(url: string | URL) { 136 assert.equal(new URL(String(url)).origin, origin); 137 super(`ws://127.0.0.1:${fixturePort}`); 138 } 139 } 140 globalThis.WebSocket = 141 FixtureSocket as unknown as typeof globalThis.WebSocket; 142 globalThis.fetch = () => 143 Promise.reject(new Error('HC_TEST_ONLY_UNEXPECTED_FETCH')); 144 const sdkScopes = new Map<'public' | 'private', RelayPool>(); 145 RelayPool.prototype.req = function (relays, filters, options) { 146 assert.ok(Array.isArray(filters)); 147 const filter = filters[0] as { kinds: number[] }; 148 sdkScopes.set(filter.kinds[0] === 1059 ? 'private' : 'public', this); 149 return originalReq.call(this, relays, filters, options); 150 }; 151 const identity = createIdentitySession(); 152 let pool: ReturnType<typeof getPrivatePool>, 153 publicPool: ReturnType<typeof getPublicPool>; 154 const stops: Array<() => void> = []; 155 async function connect() { 156 assert.equal((await connectIdentity(identity)).state, 'signing_only'); 157 assert.equal( 158 (await probeIdentityMessaging(identity, 'reviewed_self_copy')).state, 159 'messaging_capable' 160 ); 161 const session = await createPrivateSession( 162 identity, 163 'reviewed_private_session' 164 ); 165 assert.ok(session); 166 return session; 167 } 168 async function held(session: Awaited<ReturnType<typeof connect>>) { 169 pool = getPrivatePool(session, policy!, [origin]); 170 assert.ok(pool); 171 const ready = new Promise<void>((resolve) => { 172 privateReady = resolve; 173 }); 174 stops.push(subscribePrivatePage(pool, 1, () => {})); 175 await ready; 176 return [...server.clients].filter((s) => requests.get(s)?.kind === 1059); 177 } 178 async function publicPage() { 179 assert.ok(publicPool); 180 await new Promise<void>((resolve) => { 181 stops.push( 182 subscribePublicPool( 183 publicPool!, 184 [{ kinds: [0], limit: 1 }], 185 (message) => { 186 if (message.type === 'EOSE') resolve(); 187 } 188 ) 189 ); 190 }); 191 } 192 function visible(value: 'visible' | 'hidden') { 193 Object.defineProperty(documentTarget, 'visibilityState', { 194 configurable: true, 195 writable: true, 196 value 197 }); 198 documentTarget.dispatchEvent(new Event('visibilitychange')); 199 } 200 try { 201 await t.test( 202 'guest and forged scopes allocate no sockets or provider prompts', 203 () => { 204 assert.throws( 205 () => getPrivateVisibilityScope({} as never), 206 /private_session_invalid/ 207 ); 208 assert.equal(prompts, 0); 209 assert.equal(server.clients.size, 0); 210 } 211 ); 212 publicPool = getPublicPool(policy); 213 assert.ok(publicPool); 214 await publicPage(); 215 const publicSdk = sdkScopes.get('public'); 216 assert.ok(publicSdk); 217 let session = await connect(); 218 await t.test( 219 'hidden document closes actual private sockets, caches and permissions without affecting public SDK', 220 async () => { 221 const cache = getPrivateCacheScope(session, 'projection_ownership'); 222 assert.ok(cache); 223 assert.equal( 224 retainPrivateCacheWire( 225 cache, 226 'a'.repeat(64), 227 '"HC_TEST_ONLY_SYNTHETIC_OWNERSHIP"' 228 ), 229 'accepted' 230 ); 231 const capability = getPrivateEnvelopeCapability(session); 232 assert.ok(capability); 233 const scope = getPrivateVisibilityScope(session); 234 assert.ok(scope); 235 assert.equal(privateVisibilitySnapshot(scope).active, true); 236 const sockets = await held(session), 237 closed = sockets.map((s) => once(s, 'close')); 238 assert.equal(sockets.length, 1); 239 const late = () => 240 retainPrivateCacheWire( 241 cache, 242 'b'.repeat(64), 243 '"HC_TEST_ONLY_LATE_OWNERSHIP"' 244 ); 245 visible('hidden'); 246 await Promise.all(closed); 247 assert.deepEqual(privateVisibilitySnapshot(scope), { 248 active: false, 249 cleanupRequired: false 250 }); 251 assert.equal(privateSessionSnapshot(session)?.current, false); 252 assert.equal(privateCacheWire(cache, 'a'.repeat(64)), undefined); 253 assert.equal(privateCacheSnapshot(cache).count, 0); 254 assert.equal(late(), 'closed'); 255 assert.equal( 256 privateEnvelopeConstructionOwnership(capability), 257 undefined 258 ); 259 const before = prompts; 260 visible('visible'); 261 assert.equal(prompts, before); 262 assert.equal(privateVisibilitySnapshot(scope).active, false); 263 await publicPage(); 264 assert.equal(sdkScopes.get('public'), publicSdk); 265 } 266 ); 267 session = await connect(); 268 await t.test( 269 'failed physical SDK close is retained, drains other resources and blocks replacement before provider prompts', 270 async () => { 271 const cache = getPrivateCacheScope(session, 'projection_ownership'); 272 assert.ok(cache); 273 retainPrivateCacheWire( 274 cache, 275 'c'.repeat(64), 276 '"HC_TEST_ONLY_SYNTHETIC_OWNERSHIP"' 277 ); 278 const sockets = await held(session); 279 const sdk = sdkScopes.get('private'); 280 assert.ok(sdk); 281 let closeCalls = 0; 282 RelayPool.prototype.close = function () { 283 if (this === sdk) { 284 closeCalls++; 285 throw new Error('HC_TEST_ONLY_CLOSE_FAILURE'); 286 } 287 return originalClose.call(this); 288 }; 289 disconnectIdentity(identity); 290 assert.equal(privateSessionSnapshot(session)?.current, false); 291 assert.equal(privateSessionCleanupRequired(session), true); 292 assert.equal(privateCacheSnapshot(cache).count, 0); 293 assert.equal(closePrivateSession(session), false); 294 assert.ok(closeCalls >= 2); 295 assert.equal((await connectIdentity(identity)).state, 'signing_only'); 296 assert.equal( 297 (await probeIdentityMessaging(identity, 'reviewed_self_copy')).state, 298 'messaging_capable' 299 ); 300 const before = prompts; 301 assert.equal( 302 await createPrivateSession(identity, 'reviewed_private_session'), 303 undefined 304 ); 305 assert.equal(prompts, before); 306 await publicPage(); 307 assert.equal(sdkScopes.get('public'), publicSdk); 308 const closed = sockets.map((s) => once(s, 'close')); 309 RelayPool.prototype.close = originalClose; 310 assert.equal(closePrivateSession(session), true); 311 await Promise.all(closed); 312 assert.equal(privateSessionCleanupRequired(session), false); 313 const next = await createPrivateSession( 314 identity, 315 'reviewed_private_session' 316 ); 317 assert.ok(next); 318 assert.notEqual(next, session); 319 session = next; 320 } 321 ); 322 await t.test( 323 'successful callbacks drain once and failed registrations retry without reviving authority', 324 () => { 325 let failed = 0, 326 success = 0; 327 subscribePrivateSessionClose(session, () => { 328 failed++; 329 if (failed === 1) throw new Error('HC_TEST_ONLY_CALLBACK_FAILURE'); 330 }); 331 subscribePrivateSessionClose(session, () => { 332 success++; 333 }); 334 assert.equal(closePrivateSession(session), false); 335 assert.equal(success, 1); 336 assert.equal(failed, 1); 337 assert.equal(closePrivateSession(session), true); 338 assert.equal(success, 1); 339 assert.equal(failed, 2); 340 } 341 ); 342 session = await connect(); 343 await t.test( 344 'explicit route disposal and observed account loss close actual scopes with no hidden restart', 345 async () => { 346 const scope = getPrivateVisibilityScope(session); 347 assert.ok(scope); 348 const sockets = await held(session); 349 const closed = sockets.map((s) => once(s, 'close')); 350 assert.equal(closePrivateVisibilityScope(scope), true); 351 await Promise.all(closed); 352 assert.equal(privateVisibilitySnapshot(scope).active, false); 353 visible('hidden'); 354 visible('visible'); 355 assert.equal(privateVisibilitySnapshot(scope).active, false); 356 await publicPage(); 357 session = await connect(); 358 const replacement = getPrivateVisibilityScope(session); 359 assert.ok(replacement); 360 const nextSockets = await held(session), 361 nextClosed = nextSockets.map((s) => once(s, 'close')); 362 key = other; 363 assert.equal((await recheckIdentityOwner(identity)).state, 'guest'); 364 await Promise.all(nextClosed); 365 assert.equal(privateVisibilitySnapshot(replacement).active, false); 366 await publicPage(); 367 assert.equal(signatures, 0); 368 } 369 ); 370 await t.test( 371 'initially hidden visibility admission suspends without provider or socket effects', 372 async () => { 373 session = await connect(); 374 visible('hidden'); 375 const before = prompts; 376 const socketCount = server.clients.size; 377 const scope = getPrivateVisibilityScope(session); 378 assert.ok(scope); 379 assert.deepEqual(privateVisibilitySnapshot(scope), { 380 active: false, 381 cleanupRequired: false 382 }); 383 assert.equal(prompts, before); 384 assert.equal(server.clients.size, socketCount); 385 visible('visible'); 386 assert.equal(privateVisibilitySnapshot(scope).active, false); 387 await publicPage(); 388 } 389 ); 390 await t.test( 391 'failed visibility listener removal stays terminal and blocks new admission until actual retry', 392 async () => { 393 session = await connect(); 394 const scope = getPrivateVisibilityScope(session); 395 assert.ok(scope); 396 const remove = Reflect.get<EventTarget, 'removeEventListener'>( 397 EventTarget.prototype, 398 'removeEventListener' 399 ); 400 Object.defineProperty(documentTarget, 'removeEventListener', { 401 configurable: true, 402 value: () => { 403 throw new Error('HC_TEST_ONLY_LISTENER_REMOVAL_FAILURE'); 404 } 405 }); 406 try { 407 assert.equal(closePrivateVisibilityScope(scope), false); 408 assert.deepEqual(privateVisibilitySnapshot(scope), { 409 active: false, 410 cleanupRequired: true 411 }); 412 const before = prompts; 413 assert.equal( 414 await createPrivateSession(identity, 'reviewed_private_session'), 415 undefined 416 ); 417 assert.equal(prompts, before); 418 await publicPage(); 419 } finally { 420 Object.defineProperty(documentTarget, 'removeEventListener', { 421 configurable: true, 422 value: remove 423 }); 424 } 425 assert.equal(closePrivateVisibilityScope(scope), true); 426 assert.deepEqual(privateVisibilitySnapshot(scope), { 427 active: false, 428 cleanupRequired: false 429 }); 430 const next = await createPrivateSession( 431 identity, 432 'reviewed_private_session' 433 ); 434 assert.ok(next); 435 assert.notEqual(next, session); 436 session = next; 437 } 438 ); 439 } finally { 440 RelayPool.prototype.close = originalClose; 441 disconnectIdentity(identity); 442 if (pool) closePrivatePool(pool); 443 for (const stop of stops) stop(); 444 if (publicPool) closePublicPool(publicPool); 445 RelayPool.prototype.req = originalReq; 446 globalThis.WebSocket = originalSocket; 447 globalThis.fetch = originalFetch; 448 Reflect.deleteProperty(globalThis, 'window'); 449 Reflect.deleteProperty(globalThis, 'document'); 450 for (const socket of server.clients) socket.terminate(); 451 await new Promise<void>((resolve, reject) => 452 server.close((error) => (error ? reject(error) : resolve())) 453 ); 454 } 455 });