app

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

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 });