app

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

private-publisher.spec.ts (18723B)


      1 import { test, expect } from '@playwright/test';
      2 import { build } from 'vite';
      3 import { fileURLToPath } from 'node:url';
      4 import { once } from 'node:events';
      5 import { WebSocketServer, type WebSocket } from 'ws';
      6 import { createStaticHarness } from '../integration/harness/static.ts';
      7 import type * as Fixture from './harness/private-publisher.ts';
      8 declare global {
      9   interface Window {
     10     hcp085: typeof Fixture;
     11     hcp085Fixture: Awaited<ReturnType<typeof Fixture.makeFixture>>;
     12     hcp085DelayClose?: boolean;
     13     hcp085HeldClose?: (() => void)[];
     14     hcp085SharedAction?: NonNullable<
     15       ReturnType<Window['hcp085Fixture']['action']>
     16     >;
     17   }
     18 }
     19 let server: Awaited<ReturnType<typeof createStaticHarness>>,
     20   sockets: WebSocketServer,
     21   endpoint: string,
     22   bundle: string;
     23 let frames: { origin: string; frame: unknown[] }[] = [],
     24   response: 'accepted' | 'refused' | 'unknown' = 'accepted';
     25 const physical = new Set<WebSocket>();
     26 let constructed = 0,
     27   peak = 0;
     28 test.beforeAll(async () => {
     29   server = await createStaticHarness();
     30   sockets = new WebSocketServer({
     31     host: '127.0.0.1',
     32     port: 0,
     33     maxPayload: 65536
     34   });
     35   await once(sockets, 'listening');
     36   const address = sockets.address();
     37   if (!address || typeof address === 'string')
     38     throw Error('loopback unavailable');
     39   endpoint = 'ws://127.0.0.1:' + address.port;
     40   sockets.on('connection', (socket, request) => {
     41     physical.add(socket);
     42     constructed++;
     43     peak = Math.max(peak, physical.size);
     44     socket.on('close', () => physical.delete(socket));
     45     const origin = new URL(request.url!, 'http://127.0.0.1').searchParams.get(
     46       'origin'
     47     )!;
     48     socket.on('message', (bytes) => {
     49       const raw = Buffer.isBuffer(bytes)
     50         ? bytes
     51         : Array.isArray(bytes)
     52           ? Buffer.concat(bytes)
     53           : Buffer.from(bytes);
     54       const frame = JSON.parse(raw.toString()) as unknown[];
     55       frames.push({ origin, frame });
     56       if (frame[0] === 'EVENT' && response !== 'unknown') {
     57         const event = frame[1] as { id: string };
     58         socket.send(
     59           JSON.stringify([
     60             'OK',
     61             event.id,
     62             response === 'accepted',
     63             response === 'accepted' ? '' : 'blocked: fixture refusal'
     64           ])
     65         );
     66       } else if (frame[0] === 'REQ') {
     67         socket.send(JSON.stringify(['EOSE', frame[1]]));
     68       }
     69     });
     70   });
     71   const result = await build({
     72     configFile: false,
     73     logLevel: 'silent',
     74     build: {
     75       write: false,
     76       minify: false,
     77       lib: {
     78         entry: fileURLToPath(
     79           new URL('./harness/private-publisher.ts', import.meta.url)
     80         ),
     81         name: 'hcp085',
     82         formats: ['iife']
     83       }
     84     }
     85   });
     86   const output = Array.isArray(result) ? result[0] : result;
     87   if (!('output' in output)) throw Error('bundle unavailable');
     88   const chunks = output.output.filter((x) => x.type === 'chunk');
     89   expect(chunks).toHaveLength(1);
     90   bundle = chunks[0].code;
     91 });
     92 test.afterAll(async () => {
     93   for (const s of sockets.clients) s.terminate();
     94   await new Promise<void>((resolve) => sockets.close(() => resolve()));
     95   await server.close();
     96 });
     97 test.beforeEach(async ({ page }) => {
     98   await expect.poll(() => physical.size).toBe(0);
     99   constructed = 0;
    100   peak = 0;
    101   frames = [];
    102   response = 'accepted';
    103   await page.addInitScript(
    104     ({ endpoint }) => {
    105       const Native = window.WebSocket;
    106       window.WebSocket = class extends Native {
    107         constructor(url: string | URL, protocols?: string | string[]) {
    108           const parsed = new URL(String(url));
    109           if (
    110             !['wss://peer.example.org', 'wss://archive.example.org'].includes(
    111               parsed.origin
    112             )
    113           )
    114             throw Error('unapproved fixture destination');
    115           super(
    116             endpoint + '/?origin=' + encodeURIComponent(parsed.origin),
    117             protocols
    118           );
    119         }
    120         override close(code?: number, reason?: string) {
    121           if (window.hcp085DelayClose)
    122             (window.hcp085HeldClose ??= []).push(() =>
    123               super.close(code, reason)
    124             );
    125           else super.close(code, reason);
    126         }
    127       };
    128     },
    129     { endpoint }
    130   );
    131   await page.goto(server.url + '/search');
    132   await page.addScriptTag({ content: bundle });
    133 });
    134 test.afterEach(async ({ page }) => {
    135   if (!page.isClosed())
    136     await page.evaluate(() => {
    137       window.hcp085DelayClose = false;
    138       for (const release of window.hcp085HeldClose ?? []) release();
    139       window.hcp085Fixture?.close();
    140     });
    141 });
    142 async function fixture(
    143   page: import('@playwright/test').Page,
    144   writeOnly = false
    145 ) {
    146   await page.evaluate(async (writeOnly) => {
    147     window.hcp085Fixture = await window.hcp085.makeFixture(writeOnly);
    148   }, writeOnly);
    149 }
    150 test('missing and self-only persisted artifacts never acquire a private delivery capability', async ({
    151   page
    152 }) => {
    153   await fixture(page);
    154   const result = await page.evaluate(async () => {
    155     const f = window.hcp085Fixture;
    156     const missing = !!f.permission('peer');
    157     const self = await f.prepareSelfOnly();
    158     return {
    159       missing,
    160       self: self.status,
    161       selfOnly: !!f.permission('peer'),
    162       delivery: await f.deliver('peer')
    163     };
    164   });
    165   expect(result).toEqual({
    166     missing: false,
    167     self: 'saved',
    168     selfOnly: false,
    169     delivery: { status: 'invalid' }
    170   });
    171   expect(frames).toEqual([]);
    172 });
    173 test('actual SDK loopback sees only exact persisted independent peer and archive1059 bytes', async ({
    174   page
    175 }) => {
    176   await fixture(page);
    177   const result = await page.evaluate(async () => {
    178     const f = window.hcp085Fixture;
    179     const row = await f.prepare();
    180     const before = f.counts();
    181     const peer = await f.deliver('peer'),
    182       archive = await f.deliver('self_archive');
    183     const after = f.counts();
    184     return {
    185       row,
    186       peer,
    187       archive,
    188       before: {
    189         encrypts: before.encrypts,
    190         decrypts: before.decrypts,
    191         signs: before.signs
    192       },
    193       after: {
    194         encrypts: after.encrypts,
    195         decrypts: after.decrypts,
    196         signs: after.signs
    197       },
    198       marker: f.marker
    199     };
    200   });
    201   expect(result.peer.status).toBe('accepted');
    202   expect(result.archive.status).toBe('accepted');
    203   expect(result.after).toEqual(result.before);
    204   const events = frames.filter((x) => x.frame[0] === 'EVENT');
    205   expect(events).toHaveLength(2);
    206   expect(events.map((x) => x.origin)).toEqual([
    207     'wss://peer.example.org',
    208     'wss://archive.example.org'
    209   ]);
    210   const stored = [result.row!.peerArtifact!, result.row!.self];
    211   for (let i = 0; i < events.length; i++) {
    212     expect(JSON.stringify(events[i].frame[1])).toBe(stored[i].wire);
    213     expect((events[i].frame[1] as { kind: number }).kind).toBe(1059);
    214   }
    215   expect(JSON.stringify(frames)).not.toContain(result.marker);
    216   expect(stored[0].eventId).not.toBe(stored[1].eventId);
    217 });
    218 test('raw14 and13 and even a genuine signed1059 object cannot replace opaque persisted permission', async ({
    219   page
    220 }) => {
    221   await fixture(page);
    222   const statuses = await page.evaluate(async () => {
    223     const f = window.hcp085Fixture,
    224       row = await f.prepare();
    225     if (!row?.peerArtifact) throw Error('missing actual peer ciphertext');
    226     const event = JSON.parse(row.peerArtifact.wire) as Record<string, unknown>;
    227     const results = [];
    228     for (const kind of [14, 13, 1059])
    229       results.push(
    230         (
    231           await window.hcp085.publishPrivateGiftWrapAttempt(
    232             f.pool,
    233             { ...event, kind } as unknown as Parameters<
    234               typeof window.hcp085.publishPrivateGiftWrapAttempt
    235             >[1],
    236             new AbortController().signal
    237           )
    238         ).status
    239       );
    240     return results;
    241   });
    242   expect(statuses).toEqual(['stopped', 'stopped', 'stopped']);
    243   expect(frames).toEqual([]);
    244 });
    245 test('role mismatches and unreviewed targets reject without a network effect', async ({
    246   page
    247 }) => {
    248   await fixture(page);
    249   const result = await page.evaluate(async () => {
    250     const f = window.hcp085Fixture;
    251     await f.prepare();
    252     return [
    253       !!f.permission('peer', f.archiveOrigin),
    254       !!f.permission('self_archive', f.peerOrigin),
    255       !!f.permission('peer', 'wss://other.example.org'),
    256       !!f.permission('peer', f.peerOrigin, 'not_reviewed')
    257     ];
    258   });
    259   expect(result).toEqual([false, false, false, false]);
    260   expect(frames).toEqual([]);
    261 });
    262 for (const mode of ['remove', 'revision', 'readback'] as const)
    263   test(
    264     'actual ' +
    265       mode +
    266       ' after capture prevents EVENT from stale persisted evidence',
    267     async ({ page }) => {
    268       await fixture(page);
    269       const result = await page.evaluate(async (mode) => {
    270         const f = window.hcp085Fixture;
    271         await f.prepare();
    272         const permission = f.permission('peer');
    273         if (!permission) throw Error('permission missing');
    274         if (mode === 'remove') await f.remove();
    275         else if (mode === 'revision') await f.changePairRevision();
    276         else f.failReadback();
    277         return f.publish(permission);
    278       }, mode);
    279       expect(result.status).toBe('stopped');
    280       expect(frames).toEqual([]);
    281     }
    282   );
    283 for (const mode of ['Stop', 'Disconnect', 'changed key'] as const)
    284   test(
    285     mode + ' before effect fences the exact candidate and opens no socket',
    286     async ({ page }) => {
    287       await fixture(page);
    288       const result = await page.evaluate(async (mode) => {
    289         const f = window.hcp085Fixture;
    290         await f.prepare();
    291         const permission = f.permission('peer');
    292         if (!permission) throw Error('permission missing');
    293         if (mode === 'Stop') f.stop();
    294         else if (mode === 'Disconnect') f.disconnect();
    295         else f.mode('changed_key');
    296         return f.publish(permission);
    297       }, mode);
    298       expect(result.status).toBe('stopped');
    299       expect(frames).toEqual([]);
    300     }
    301   );
    302 test('one opaque permission cannot issue a second SDK EVENT and detached views cannot retarget it', async ({
    303   page
    304 }) => {
    305   await fixture(page);
    306   const result = await page.evaluate(async () => {
    307     const f = window.hcp085Fixture;
    308     await f.prepare();
    309     const p = f.permission('peer');
    310     if (!p) throw Error('permission missing');
    311     const view = window.hcp085.privatePublicationSnapshot(p)!;
    312     const first = await f.publish(p);
    313     const second = await f.publish(p);
    314     return { first, second, view };
    315   });
    316   expect(result.first.status).toBe('accepted');
    317   expect(result.second.status).toBe('stopped');
    318   expect(result.view.role).toBe('peer');
    319   expect(frames.filter((x) => x.frame[0] === 'EVENT')).toHaveLength(1);
    320 });
    321 test('actual relay refusal is a named attempt outcome without recipient or order success', async ({
    322   page
    323 }) => {
    324   response = 'refused';
    325   await fixture(page);
    326   const result = await page.evaluate(async () => {
    327     const f = window.hcp085Fixture;
    328     await f.prepare();
    329     return f.deliver('self_archive');
    330   });
    331   expect(result.status).toBe('refused');
    332   expect(frames.filter((x) => x.frame[0] === 'EVENT')).toHaveLength(1);
    333 });
    334 test('a write-only destination can publish but private reads stay on read-admitted origins', async ({
    335   page
    336 }) => {
    337   await fixture(page, true);
    338   const result = await page.evaluate(async () => {
    339     const f = window.hcp085Fixture;
    340     await f.prepare();
    341     const write = await f.deliver('peer');
    342     await f.readOrigins();
    343     return write;
    344   });
    345   expect(result.status).toBe('accepted');
    346   expect(
    347     frames.filter((x) => x.frame[0] === 'REQ').map((x) => x.origin)
    348   ).toEqual(['wss://archive.example.org']);
    349 });
    350 for (const newer of [false, true])
    351   test(
    352     'successful same-owner actual delivery preserves ' +
    353       (newer ? 'newer unsaved text' : 'captured saved encrypted text') +
    354       ' and its composer state',
    355     async ({ page }) => {
    356       await fixture(page);
    357       const result = await page.evaluate(async (newer) => {
    358         const f = window.hcp085Fixture;
    359         await f.prepare();
    360         const before = f.bindComposer(newer);
    361         const delivery = await f.deliver('peer');
    362         return { before, delivery, after: f.composerState() };
    363       }, newer);
    364       expect(result.delivery.status).toBe('accepted');
    365       expect(result.after).toEqual(result.before);
    366       expect(result.before.snapshot?.dirty).toBe(newer);
    367       expect(result.before.snapshot?.state).toBe(
    368         newer ? 'unsaved' : 'saved_encrypted'
    369       );
    370       expect(frames.filter((x) => x.frame[0] === 'EVENT')).toHaveLength(1);
    371       expect(JSON.stringify(frames)).not.toContain(
    372         'HCP085_NEWER_PRIVATE_TEXT_MEMORY_ONLY'
    373       );
    374     }
    375   );
    376 test('actual owner loss still clears the bound private composer and prevents publication', async ({
    377   page
    378 }) => {
    379   await fixture(page);
    380   const result = await page.evaluate(async () => {
    381     const f = window.hcp085Fixture;
    382     await f.prepare();
    383     const before = f.bindComposer(true);
    384     const permission = f.permission('peer');
    385     if (!permission) throw Error('missing actual permission');
    386     f.disconnect();
    387     return {
    388       before,
    389       after: f.composerState(),
    390       attempt: await f.publish(permission)
    391     };
    392   });
    393   expect(result.before.snapshot?.dirty).toBe(true);
    394   expect(result.after).toEqual({ text: undefined, snapshot: undefined });
    395   expect(result.attempt.status).toBe('stopped');
    396   expect(frames).toEqual([]);
    397 });
    398 
    399 for (const fault of ['SDK acquisition', 'actual network clock abort'] as const)
    400   test(
    401     'original metered action releases reservation after ' +
    402       fault +
    403       ' and permits reviewed retry',
    404     async ({ page }) => {
    405       await fixture(page);
    406       const result = await page.evaluate(async (fault) => {
    407         const f = window.hcp085Fixture;
    408         await f.prepare();
    409         const action = f.action();
    410         if (!action) throw Error('genuine metered action missing');
    411         const firstPermission = f.permission(
    412           'peer',
    413           f.peerOrigin,
    414           'reviewed_private_delivery',
    415           action
    416         );
    417         if (!firstPermission) throw Error('genuine first permission missing');
    418         const abort = new AbortController();
    419         let restore: () => void,
    420           observed = () => true;
    421         if (fault === 'SDK acquisition') restore = f.failAcquisition();
    422         else {
    423           const clock = f.abortOnActualNetworkClock(abort);
    424           restore = clock.restore;
    425           observed = clock.observed;
    426         }
    427         let first;
    428         try {
    429           first = await f.publish(firstPermission, abort.signal);
    430         } finally {
    431           restore();
    432         }
    433         const retryPermission = f.permission(
    434           'peer',
    435           f.peerOrigin,
    436           'reviewed_private_delivery',
    437           action
    438         );
    439         if (!retryPermission)
    440           throw Error('genuine original action retry permission missing');
    441         const retry = await f.publish(
    442           retryPermission,
    443           new AbortController().signal
    444         );
    445         return { first, retry, observed: observed() };
    446       }, fault);
    447       expect(result.observed).toBe(true);
    448       expect(result.first.status).toBe('stopped');
    449       expect(result.first.actionId).toBeUndefined();
    450       expect(result.first.attempt).toBeUndefined();
    451       expect(result.retry.status).toBe('accepted');
    452       expect(result.retry.attempt).toBe(fault === 'SDK acquisition' ? 1 : 2);
    453       expect(frames.filter(({ frame }) => frame[0] === 'EVENT')).toHaveLength(
    454         1
    455       );
    456     }
    457   );
    458 
    459 test('genuine shared-origin peer and archive roles reuse one original connection and distinct exact artifacts', async ({
    460   page
    461 }) => {
    462   const result = await page.evaluate(async () => {
    463     window.hcp085Fixture = await window.hcp085.makeFixture(false, true);
    464     const f = window.hcp085Fixture;
    465     window.hcp085DelayClose = true;
    466     await f.prepare();
    467     const action = f.action();
    468     if (!action) throw Error('genuine metered action');
    469     const peer = f.permission(
    470       'peer',
    471       f.peerOrigin,
    472       'reviewed_private_delivery',
    473       action
    474     );
    475     const archive = f.permission(
    476       'self_archive',
    477       f.archiveOrigin,
    478       'reviewed_private_delivery',
    479       action
    480     );
    481     if (!peer || !archive) throw Error('genuine original two-role permissions');
    482     const first = await f.publish(peer);
    483     const second = await f.publish(archive);
    484     const retry = f.permission(
    485       'peer',
    486       f.peerOrigin,
    487       'reviewed_private_delivery',
    488       action
    489     );
    490     if (!retry) throw Error('genuine reviewed original retry');
    491     const third = await f.publish(retry);
    492     return { first, second, third };
    493   });
    494   expect(constructed).toBe(1);
    495   expect(peak).toBe(1);
    496   expect(physical.size).toBe(1);
    497   expect(await page.evaluate(() => window.hcp085HeldClose?.length ?? 0)).toBe(
    498     0
    499   );
    500   expect(result.first.status).toBe('accepted');
    501   expect(result.second.status).toBe('accepted');
    502   expect(result.third.status).toBe('accepted');
    503   expect(result.first.eventId).not.toBe(result.second.eventId);
    504   expect(result.third.eventId).toBe(result.first.eventId);
    505   expect(result.third.attempt).toBe(2);
    506   const events = frames.filter(({ frame }) => frame[0] === 'EVENT');
    507   expect(events).toHaveLength(3);
    508   expect(
    509     events.every(({ origin }) => origin === 'wss://peer.example.org')
    510   ).toBe(true);
    511 });
    512 
    513 test('original shared-origin unknown EVENT retries the exact artifact on the same actual connection', async ({
    514   page
    515 }) => {
    516   response = 'unknown';
    517   const first = await page.evaluate(async () => {
    518     window.hcp085Fixture = await window.hcp085.makeFixture(false, true);
    519     const f = window.hcp085Fixture;
    520     window.hcp085DelayClose = true;
    521     await f.prepare();
    522     window.hcp085SharedAction = f.action();
    523     if (!window.hcp085SharedAction) throw Error('genuine action');
    524     const permission = f.permission(
    525       'peer',
    526       f.peerOrigin,
    527       'reviewed_private_delivery',
    528       window.hcp085SharedAction
    529     );
    530     if (!permission) throw Error('genuine permission');
    531     return f.publish(permission);
    532   });
    533   expect(['unknown', 'timed_out']).toContain(first.status);
    534   expect(constructed).toBe(1);
    535   response = 'accepted';
    536   const retry = await page.evaluate(async () => {
    537     const f = window.hcp085Fixture;
    538     const permission = f.permission(
    539       'peer',
    540       f.peerOrigin,
    541       'reviewed_private_delivery',
    542       window.hcp085SharedAction
    543     );
    544     if (!permission) throw Error('genuine original explicit retry permission');
    545     return f.publish(permission);
    546   });
    547   expect(retry.status).toBe('accepted');
    548   expect(retry.eventId).toBe(first.eventId);
    549   expect(retry.attempt).toBe(2);
    550   expect(constructed).toBe(1);
    551   expect(peak).toBe(1);
    552   const events = frames.filter(({ frame }) => frame[0] === 'EVENT');
    553   expect(events).toHaveLength(2);
    554   expect(events[1].frame[1]).toEqual(events[0].frame[1]);
    555 });