app

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

inbox-access-controller.ts (12166B)


      1 import {
      2   inboxRelayTargets,
      3   publicRelayTargets,
      4   readRelayPolicy,
      5   type RelayPolicy
      6 } from '../config/relays.ts';
      7 import { inboxPreferenceSnapshot } from '../nostr/inbox-preferences.ts';
      8 import {
      9   beginInboxAuthentication,
     10   respondInboxAuthentication,
     11   closeInboxAuthentication,
     12   inboxAuthSnapshot,
     13   type InboxAuthAction
     14 } from '../nostr/inbox-auth.ts';
     15 import {
     16   getPrivatePool,
     17   closePrivatePool,
     18   privatePoolCleanupRequired,
     19   type PrivatePool
     20 } from '../nostr/private-pool.ts';
     21 import {
     22   privateSessionOwnership,
     23   subscribePrivateSessionClose,
     24   type PrivateSession
     25 } from '../runtime/private-session.ts';
     26 import {
     27   inboxResolutionSnapshot,
     28   inboxResolverCurrentAfterSample,
     29   type InboxResolver
     30 } from './resolve-inbox.ts';
     31 
     32 declare const accessBrand: unique symbol;
     33 export type InboxAccessController = Readonly<{ [accessBrand]: true }>;
     34 type Binding = Readonly<{
     35   owner: string;
     36   preferenceId: string;
     37   preferenceCreatedAt: number;
     38   readTargets: string[];
     39   archiveTargets: string[];
     40 }>;
     41 export type InboxAccessSourceSnapshot = Readonly<
     42   Binding & {
     43     state: string;
     44     busy: boolean;
     45     cleanupRequired: boolean;
     46     auth: { origin: string; state: string; responses: number }[];
     47   }
     48 >;
     49 export type InboxAccessSnapshot = Readonly<
     50   InboxAccessSourceSnapshot & { readiness: 'unavailable' }
     51 >;
     52 type Control = {
     53   session: PrivateSession;
     54   subscribe(listener: () => void): () => void;
     55   policy: RelayPolicy;
     56   binding: string;
     57   current(): boolean;
     58   closed(): boolean;
     59   cleanupRequired(): boolean;
     60   sourceSnapshot(): InboxAccessSourceSnapshot;
     61   snapshot(): InboxAccessSnapshot;
     62   authenticate(origin: unknown, review: unknown): Promise<string>;
     63   respond(origin: unknown, review: unknown): Promise<string>;
     64   close(): boolean;
     65 };
     66 const controllers = new WeakMap<InboxAccessController, Control>();
     67 const currentControllers = new WeakMap<PrivateSession, InboxAccessController>();
     68 function binding(
     69   session: PrivateSession,
     70   policy: RelayPolicy,
     71   own: InboxResolver
     72 ): Binding | undefined {
     73   try {
     74     const capture = privateSessionOwnership(session),
     75       head = inboxResolutionSnapshot(own);
     76     const sources = publicRelayTargets(policy, 'read');
     77     const preference = head.head && inboxPreferenceSnapshot(head.head);
     78     if (
     79       !capture?.current() ||
     80       !readRelayPolicy(policy).messagingEnabled ||
     81       head.author !== capture.owner ||
     82       head.status !== 'ready' ||
     83       head.coverage !== 'bounded-eose' ||
     84       !preference ||
     85       preference.status !== 'supported' ||
     86       preference.author !== capture.owner ||
     87       preference.id !== head.knownBase?.id ||
     88       preference.createdAt !== head.knownBase.createdAt ||
     89       !sources.length ||
     90       head.sources.length !== sources.length ||
     91       !sources.every((origin) =>
     92         head.sources.some(
     93           (source) => source.source === origin && source.state === 'eose'
     94         )
     95       )
     96     )
     97       return undefined;
     98     const readTargets = inboxRelayTargets(
     99       policy,
    100       preference.relays,
    101       'read'
    102     ).slice();
    103     const archiveTargets = inboxRelayTargets(
    104       policy,
    105       preference.relays,
    106       'write'
    107     ).slice();
    108     if (
    109       !readTargets.length ||
    110       !archiveTargets.length ||
    111       !capture.current() ||
    112       !inboxResolverCurrentAfterSample(own)
    113     )
    114       return undefined;
    115     return {
    116       owner: capture.owner,
    117       preferenceId: preference.id,
    118       preferenceCreatedAt: preference.createdAt,
    119       readTargets,
    120       archiveTargets
    121     };
    122   } catch {
    123     return undefined;
    124   }
    125 }
    126 // Capture only genuine current discovery/session metadata. No socket, provider,
    127 // AUTH, probe or publication occurs here. AUTH alone never grants readiness;
    128 // the separate qualified access probe must supply that later capability.
    129 export function createInboxAccessController(
    130   session: PrivateSession,
    131   policy: RelayPolicy,
    132   own: InboxResolver
    133 ): InboxAccessController | undefined {
    134   if (typeof window === 'undefined') return undefined;
    135   const captured = binding(session, policy, own);
    136   if (!captured) return undefined;
    137   const initial = captured;
    138   const wire = JSON.stringify(initial),
    139     previous = currentControllers.get(session);
    140   const prior = previous && controllers.get(previous);
    141   if (
    142     prior &&
    143     !prior.closed() &&
    144     prior.current() &&
    145     prior.policy === policy &&
    146     prior.binding === wire
    147   )
    148     return previous;
    149   // Stale or failed disposal cannot be silently replaced by another capture.
    150   if (prior && (!prior.closed() || prior.cleanupRequired())) return undefined;
    151   const token = Object.freeze({}) as InboxAccessController;
    152   const auth = new Map<string, InboxAuthAction>();
    153   const constructionClosures = new Map<symbol, () => void>();
    154   let pool: PrivatePool | undefined,
    155     closed = false,
    156     closing = false,
    157     cleaned = false,
    158     busy = false,
    159     epoch = 0,
    160     phase = 'not_checked';
    161   let off = () => {};
    162   const current = () =>
    163     !closed && JSON.stringify(binding(session, policy, own)) === wire;
    164   function close(): boolean {
    165     closed = true;
    166     if (closing) return false;
    167     closing = true;
    168     try {
    169       epoch++;
    170       phase = 'stopped';
    171       let failed = false;
    172       // Revoke construction before any asynchronous/throwing transport cleanup.
    173       // Only failed original closures remain registered for an honest retry.
    174       for (const [id, listener] of constructionClosures) {
    175         try {
    176           listener();
    177           constructionClosures.delete(id);
    178         } catch {
    179           failed = true;
    180         }
    181       }
    182       for (const [origin, action] of auth) {
    183         try {
    184           closeInboxAuthentication(action);
    185           auth.delete(origin);
    186         } catch {
    187           failed = true;
    188         }
    189       }
    190       if (pool) {
    191         try {
    192           closePrivatePool(pool);
    193         } catch {
    194           failed = true;
    195         }
    196         if (privatePoolCleanupRequired(pool)) failed = true;
    197       }
    198       cleaned = !failed;
    199       if (cleaned) off();
    200       return cleaned;
    201     } finally {
    202       closing = false;
    203     }
    204   }
    205   async function authenticate(
    206     origin: unknown,
    207     review: unknown
    208   ): Promise<string> {
    209     if (
    210       review !== 'reviewed_inbox_connection_auth' ||
    211       typeof origin !== 'string' ||
    212       !current() ||
    213       (!initial.readTargets.includes(origin) &&
    214         !initial.archiveTargets.includes(origin))
    215     )
    216       return 'unavailable';
    217     if (busy) return 'busy';
    218     const existing = auth.get(origin);
    219     if (existing) return inboxAuthSnapshot(existing)?.state ?? 'stopped';
    220     busy = true;
    221     const generation = epoch;
    222     try {
    223       pool ??= getPrivatePool(
    224         session,
    225         policy,
    226         Array.from(
    227           new Set([...initial.readTargets, ...initial.archiveTargets])
    228         ),
    229         token,
    230         'access',
    231         current
    232       );
    233       if (!pool || !current()) return 'unavailable';
    234       const action = await beginInboxAuthentication(
    235         pool,
    236         origin,
    237         'reviewed_connection_auth'
    238       );
    239       if (!action) return (phase = 'unavailable');
    240       if (!current() || generation !== epoch) {
    241         closeInboxAuthentication(action);
    242         return 'stopped';
    243       }
    244       auth.set(origin, action);
    245       phase = 'authenticating';
    246       return inboxAuthSnapshot(action)?.state ?? 'unavailable';
    247     } catch {
    248       return (phase = closed ? 'stopped' : 'unavailable');
    249     } finally {
    250       busy = false;
    251     }
    252   }
    253   async function respond(origin: unknown, review: unknown): Promise<string> {
    254     const action = typeof origin === 'string' && auth.get(origin);
    255     if (!action || review !== 'reviewed_inbox_auth_response' || !current())
    256       return 'unavailable';
    257     if (busy) return 'busy';
    258     busy = true;
    259     const generation = epoch;
    260     try {
    261       const result = await respondInboxAuthentication(action);
    262       if (!current() || generation !== epoch) {
    263         closeInboxAuthentication(action);
    264         return 'stopped';
    265       }
    266       phase = result.status;
    267       return result.status;
    268     } catch {
    269       return (phase = closed ? 'stopped' : 'unavailable');
    270     } finally {
    271       busy = false;
    272     }
    273   }
    274   // Construction and qualification consume this source projection directly.
    275   // Presentation may later observe qualification, so it cannot be their input.
    276   const sourceSnapshot = (): InboxAccessSourceSnapshot => ({
    277     ...initial,
    278     readTargets: [...initial.readTargets],
    279     archiveTargets: [...initial.archiveTargets],
    280     state: closed ? 'stopped' : current() ? phase : 'stale',
    281     busy,
    282     cleanupRequired:
    283       closed && (!cleaned || (!!pool && privatePoolCleanupRequired(pool))),
    284     auth: [...auth].map(([origin, action]) => ({
    285       origin,
    286       state: inboxAuthSnapshot(action)?.state ?? 'stopped',
    287       responses: inboxAuthSnapshot(action)?.responses ?? 0
    288     }))
    289   });
    290   controllers.set(token, {
    291     session,
    292     subscribe(listener) {
    293       const id = Symbol();
    294       constructionClosures.set(id, listener);
    295       if (closed) {
    296         try {
    297           listener();
    298           constructionClosures.delete(id);
    299         } catch (error) {
    300           cleaned = false;
    301           throw error;
    302         }
    303       }
    304       return () => {
    305         constructionClosures.delete(id);
    306       };
    307     },
    308     policy,
    309     binding: wire,
    310     current,
    311     closed: () => closed,
    312     cleanupRequired: () =>
    313       closed && (!cleaned || (!!pool && privatePoolCleanupRequired(pool))),
    314     authenticate,
    315     respond,
    316     close,
    317     sourceSnapshot,
    318     snapshot: () => ({
    319       ...sourceSnapshot(),
    320       readiness: 'unavailable'
    321     })
    322   });
    323   off = subscribePrivateSessionClose(session, () => {
    324     if (!close()) throw Error('inbox_access_cleanup_required');
    325   });
    326   if (!current()) {
    327     close();
    328     return undefined;
    329   }
    330   currentControllers.set(session, token);
    331   return token;
    332 }
    333 export function inboxAccessControllerSnapshot(
    334   token: InboxAccessController
    335 ): InboxAccessSnapshot | undefined {
    336   return controllers.get(token)?.snapshot();
    337 }
    338 export function inboxAccessControllerSourceSnapshot(
    339   token: InboxAccessController
    340 ): InboxAccessSourceSnapshot | undefined {
    341   return controllers.get(token)?.sourceSnapshot();
    342 }
    343 export function authenticateInboxAccess(
    344   token: InboxAccessController,
    345   origin: unknown,
    346   review: unknown
    347 ): Promise<string> {
    348   return (
    349     controllers.get(token)?.authenticate(origin, review) ??
    350     Promise.resolve('unavailable')
    351   );
    352 }
    353 export function respondInboxAccessAuthentication(
    354   token: InboxAccessController,
    355   origin: unknown,
    356   review: unknown
    357 ): Promise<string> {
    358   return (
    359     controllers.get(token)?.respond(origin, review) ??
    360     Promise.resolve('unavailable')
    361   );
    362 }
    363 export function closeInboxAccessController(
    364   token: InboxAccessController
    365 ): boolean {
    366   return controllers.get(token)?.close() ?? false;
    367 }
    368 
    369 // Narrow source-owned construction binding. It authenticates current discovery
    370 // metadata only; it grants neither readiness nor a socket/sign/publication port.
    371 export function inboxAccessConstructionBinding(
    372   token: InboxAccessController,
    373   session: PrivateSession,
    374   policy: RelayPolicy
    375 ): Readonly<Binding & { session: symbol; current(): boolean }> | undefined {
    376   const state = controllers.get(token);
    377   if (
    378     !state ||
    379     state.closed() ||
    380     state.session !== session ||
    381     state.policy !== policy
    382   )
    383     return undefined;
    384   const ownership = privateSessionOwnership(session);
    385   if (!ownership?.current() || !state.current()) return undefined;
    386   const captured = state.sourceSnapshot();
    387   if (
    388     captured.owner !== ownership.owner ||
    389     !state.current() ||
    390     !ownership.current()
    391   )
    392     return undefined;
    393   return {
    394     owner: captured.owner,
    395     preferenceId: captured.preferenceId,
    396     preferenceCreatedAt: captured.preferenceCreatedAt,
    397     readTargets: [...captured.readTargets],
    398     archiveTargets: [...captured.archiveTargets],
    399     session: ownership.session,
    400     current: () => ownership.current() && state.current()
    401   };
    402 }
    403 export function subscribeInboxAccessControllerClose(
    404   token: InboxAccessController,
    405   listener: () => void
    406 ): () => void {
    407   const state = controllers.get(token);
    408   if (!state) throw Error('inbox_access_controller_invalid');
    409   return state.subscribe(listener);
    410 }