app

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

inbox-access-qualification.ts (7396B)


      1 import { makeCleanupFixture } from './inbox-probe-cleanup.ts';
      2 import {
      3   validateInboxOperatorQualification,
      4   inboxOperatorQualificationSnapshot
      5 } from '../../../src/lib/config/inbox-operators.ts';
      6 import {
      7   captureInboxProbeNonceReader,
      8   captureRecoveredInboxProbeNonceReader,
      9   readInboxProbeNonce,
     10   readRecoveredInboxProbeNonce
     11 } from '../../../src/lib/nostr/self-recovery-reader.ts';
     12 import {
     13   commitInboxProbeNonceVerification,
     14   type InboxProbeNonceAcknowledgement
     15 } from '../../../src/lib/persistence/inbox-probes.ts';
     16 import {
     17   qualifyInboxAccess,
     18   qualifyRemovedInboxAccess,
     19   observeQualifiedInboxAccess,
     20   inboxAccessQualificationSnapshot,
     21   type InboxAccessQualification
     22 } from '../../../src/lib/messaging/inbox-access-qualification.ts';
     23 import { inboxAccessConstructionBinding } from '../../../src/lib/messaging/inbox-access-controller.ts';
     24 import {
     25   createPublicView,
     26   beginPublicViewRun,
     27   disposePublicView
     28 } from '../../../src/lib/runtime/public-runtime.ts';
     29 import {
     30   resolveInboxPreference,
     31   settleInboxResolver
     32 } from '../../../src/lib/messaging/resolve-inbox.ts';
     33 import { captureUnlockedSession } from '../../../src/lib/messaging/unlocked-session.ts';
     34 import {
     35   captureInboxSync,
     36   startInboxSync,
     37   stopInboxSync,
     38   inboxSyncSnapshot,
     39   type InboxSync
     40 } from '../../../src/lib/messaging/inbox-sync.ts';
     41 export {
     42   validateInboxOperatorQualification,
     43   inboxOperatorQualificationWire
     44 } from '../../../src/lib/config/inbox-operators.ts';
     45 export {
     46   validateRelayPolicy,
     47   readRelayPolicy
     48 } from '../../../src/lib/config/relays.ts';
     49 export * from './inbox-probe-cleanup.ts';
     50 export * from '../../../src/lib/messaging/inbox-access-qualification.ts';
     51 export {
     52   captureInboxSync,
     53   inboxSyncSnapshot,
     54   startInboxSync,
     55   stopInboxSync
     56 } from '../../../src/lib/messaging/inbox-sync.ts';
     57 export { captureUnlockedSession } from '../../../src/lib/messaging/unlocked-session.ts';
     58 export { closePrivateSession } from '../../../src/lib/runtime/private-session.ts';
     59 export async function makeQualificationFixture(authRequired = false) {
     60   const base = await makeCleanupFixture();
     61   if (authRequired) {
     62     const wire = inboxOperatorQualificationSnapshot(base.host.qualification)!;
     63     const operator = validateInboxOperatorQualification(
     64       JSON.stringify({
     65         ...wire,
     66         relays: wire.relays.map((relay) =>
     67           relay.origin === 'wss://inbox.example.org'
     68             ? { ...relay, auth: 'explicit_required' }
     69             : relay
     70         )
     71       })
     72     );
     73     if (!operator)
     74       throw Error('actual explicitly required operator declaration');
     75     base.host.qualification = operator;
     76   }
     77   let qualification: InboxAccessQualification | undefined;
     78   let latestNonce: InboxProbeNonceAcknowledgement | undefined;
     79   let latestObservations: ReturnType<typeof base.observations> | undefined;
     80   let sync: InboxSync | undefined;
     81   const views: ReturnType<typeof createPublicView>[] = [];
     82   return {
     83     ...base,
     84     qualification: () => qualification,
     85     async renewQualificationNonce(recovered: boolean, origin: string) {
     86       const observation = await (recovered
     87         ? base.read(origin)
     88         : base.originalRead(origin));
     89       if (!observation || observation.status !== 'readback')
     90         throw Error('actual later readback');
     91       if ((await base.appendRead(observation)).status !== 'saved')
     92         throw Error('actual later read append');
     93       const a = base.actors();
     94       const verified = recovered
     95         ? await readRecoveredInboxProbeNonce(
     96             captureRecoveredInboxProbeNonceReader(
     97               base.repository,
     98               a.identity,
     99               a.session,
    100               base.host.policy,
    101               observation,
    102               'reviewed_inbox_probe_nonce_decryption'
    103             )!
    104           )
    105         : await readInboxProbeNonce(
    106             captureInboxProbeNonceReader(
    107               base.repository,
    108               a.identity,
    109               a.session,
    110               base.host.policy,
    111               observation,
    112               'reviewed_inbox_probe_nonce_decryption'
    113             )!
    114           );
    115       if (!('proof' in verified)) throw Error('actual later nonce proof');
    116       const saved = await commitInboxProbeNonceVerification(
    117         base.repository,
    118         a.session,
    119         base.host.policy,
    120         verified.proof
    121       );
    122       if (!saved.acknowledgement) throw Error('actual later nonce native fact');
    123       latestNonce = saved.acknowledgement;
    124       latestObservations = [...base.observations(), observation];
    125       return saved.status;
    126     },
    127     async startOwnInbox() {
    128       if (!qualification) throw Error('actual qualification missing');
    129       const runtime = base.sharedPublicRuntime();
    130       const a = base.actors(),
    131         view = createPublicView(runtime),
    132         resolver = resolveInboxPreference(
    133           view,
    134           beginPublicViewRun(view),
    135           base.host.owner
    136         );
    137       views.push(view);
    138       await settleInboxResolver(resolver);
    139       const unlocked = captureUnlockedSession(
    140         a.session,
    141         'reviewed_messages_unlock'
    142       );
    143       if (!unlocked) throw Error('actual unlocked scope');
    144       sync = captureInboxSync(
    145         base.repository,
    146         a.session,
    147         base.host.policy,
    148         resolver,
    149         unlocked,
    150         observeQualifiedInboxAccess(qualification),
    151         'reviewed_foreground_inbox'
    152       );
    153       return !!sync && startInboxSync(sync, 'reviewed_foreground_inbox');
    154     },
    155     syncSnapshot: () => sync && inboxSyncSnapshot(sync),
    156     stopOwnInbox() {
    157       if (sync) stopInboxSync(sync);
    158     },
    159     close() {
    160       if (sync) stopInboxSync(sync);
    161       for (const view of views) disposePublicView(view);
    162       base.close();
    163     },
    164     context() {
    165       const a = base.actors(),
    166         scope = inboxAccessConstructionBinding(
    167           a.access,
    168           a.session,
    169           base.host.policy
    170         );
    171       if (!scope) throw Error('actual C7 scope missing');
    172       return {
    173         owner: scope.owner,
    174         session: scope.session,
    175         preferenceId: scope.preferenceId,
    176         readTargets: scope.readTargets.slice(),
    177         archiveTargets: scope.archiveTargets.slice()
    178       };
    179     },
    180     async qualifyAccess(
    181       observations = latestObservations ?? base.observations()
    182     ) {
    183       const a = base.actors(),
    184         result = await qualifyInboxAccess(
    185           base.repository,
    186           a.session,
    187           base.host.policy,
    188           a.access,
    189           base.host.qualification,
    190           latestNonce ?? base.nonce()!,
    191           observations,
    192           'reviewed_qualify_inbox_access'
    193         );
    194       if (result.qualification) qualification = result.qualification;
    195       return result;
    196     },
    197     qualifyRemoved() {
    198       const a = base.actors(),
    199         result = qualifyRemovedInboxAccess(
    200           base.repository,
    201           a.session,
    202           base.host.policy,
    203           a.access,
    204           base.host.qualification,
    205           base.removal()!,
    206           'reviewed_qualify_inbox_access'
    207         );
    208       if (result.qualification) qualification = result.qualification;
    209       return result;
    210     },
    211     snapshot: () =>
    212       qualification && inboxAccessQualificationSnapshot(qualification),
    213     observation(
    214       context: Parameters<ReturnType<typeof observeQualifiedInboxAccess>>[0]
    215     ) {
    216       return (
    217         qualification && observeQualifiedInboxAccess(qualification)(context)
    218       );
    219     }
    220   };
    221 }