app

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

inbox-setup-view.ts (18570B)


      1 import { operationEnabled } from '../config/operation-flags.ts';
      2 import {
      3   readRelayPolicy,
      4   inboxRelayTargets,
      5   type RelayPolicy
      6 } from '../config/relays.ts';
      7 import { deploymentRelayPolicy } from '../config/deployment-relays.ts';
      8 import {
      9   identityMessagingOwnership,
     10   subscribeIdentityInvalidation,
     11   type IdentitySession
     12 } from '../runtime/identity-session.ts';
     13 import {
     14   createPrivateSession,
     15   closePrivateSession,
     16   type PrivateSession
     17 } from '../runtime/private-session.ts';
     18 import {
     19   identityViewSession,
     20   type IdentityViewContext
     21 } from '../runtime/view-context.ts';
     22 import {
     23   createPublicView,
     24   beginPublicViewRun,
     25   disposePublicView,
     26   type PublicRuntime
     27 } from '../runtime/public-runtime.ts';
     28 import {
     29   resolveInboxPreference,
     30   settleInboxResolver,
     31   inboxResolutionSnapshot,
     32   closeInboxResolver,
     33   type InboxResolver
     34 } from './resolve-inbox.ts';
     35 import {
     36   inboxPreferenceSnapshot,
     37   inboxPreferenceWire
     38 } from '../nostr/inbox-preferences.ts';
     39 import {
     40   reviewInboxSetup,
     41   inboxSetupPreview,
     42   type InboxSetupReview
     43 } from './inbox-setup.ts';
     44 import {
     45   beginInboxPreferenceOperation,
     46   runInboxPreferenceOperation,
     47   stopInboxPreferenceOperation,
     48   type InboxPreferenceAction
     49 } from './inbox-setup-operation.ts';
     50 import {
     51   openBrowserDatabase,
     52   closeBrowserDatabase,
     53   type BrowserDatabase
     54 } from '../persistence/database.ts';
     55 import {
     56   createPublicQuotaRepository,
     57   loadPreferenceOperation,
     58   type PublicQuotaRepository
     59 } from '../persistence/quota.ts';
     60 import {
     61   publicRecordSnapshot,
     62   type PublicRecordHandle
     63 } from '../persistence/records.ts';
     64 import {
     65   resolveInboxReadback,
     66   inboxReadbackSnapshot,
     67   closeInboxReadback,
     68   type InboxReadback
     69 } from '../nostr/inbox-readback.ts';
     70 import {
     71   existingInboxSetupSnapshot,
     72   verifyInboxSetupOperation
     73 } from './inbox-setup-verification.ts';
     74 import type { ObserveInboxAccess } from './readiness.ts';
     75 declare const viewBrand: unique symbol;
     76 export type InboxSetupView = Readonly<{ [viewBrand]: true }>;
     77 export type InboxSetupViewSnapshot = Readonly<{
     78   status: string;
     79   busy: boolean;
     80   owner?: string;
     81   currentWire: string | null;
     82   existingInboxes: string[];
     83   availableInboxes: string[];
     84   preview?: NonNullable<ReturnType<typeof inboxSetupPreview>>;
     85   accepted: string[];
     86   readback: string[];
     87   setupComplete: boolean;
     88 }>;
     89 // Internal trusted orchestration ports require real opaque discovery/readback
     90 // owners. Neither displayed facts nor caller booleans admit a preference effect.
     91 type Inputs = Readonly<{
     92   identity: IdentitySession;
     93   policy: RelayPolicy;
     94   lookup(current?: () => boolean): Promise<InboxResolver>;
     95   readback?(
     96     record: PublicRecordHandle,
     97     owner: string,
     98     id: string
     99   ): InboxReadback | undefined;
    100   observeAccess?: ObserveInboxAccess;
    101   now?(): number;
    102   close?(): void;
    103 }>;
    104 type Controller = {
    105   ownership():
    106     | Readonly<{
    107         identity: IdentitySession;
    108         policy: RelayPolicy;
    109         session: PrivateSession | undefined;
    110         resolver: InboxResolver | undefined;
    111         observeAccess: ObserveInboxAccess | undefined;
    112         current(): boolean;
    113       }>
    114     | undefined;
    115   observe(): void;
    116   snapshot(): InboxSetupViewSnapshot;
    117   subscribe(listener: (state: InboxSetupViewSnapshot) => void): () => void;
    118   check(): Promise<void>;
    119   review(
    120     selected: string[],
    121     removeTags: number[],
    122     removeFields: string[]
    123   ): Promise<void>;
    124   enable(): Promise<void>;
    125   unlock(): Promise<void>;
    126   readback(): Promise<void>;
    127   stop(): void;
    128   close(): void;
    129 };
    130 const views = new WeakMap<InboxSetupView, Controller>();
    131 const unavailable = (): InboxSetupViewSnapshot => ({
    132   status: 'unavailable',
    133   busy: false,
    134   currentWire: null,
    135   existingInboxes: [],
    136   availableInboxes: [],
    137   accepted: [],
    138   readback: [],
    139   setupComplete: false
    140 });
    141 export function createInboxSetupView(
    142   input: Inputs
    143 ): InboxSetupView | undefined {
    144   if (typeof window === 'undefined') return undefined;
    145   const initial = identityMessagingOwnership(input.identity);
    146   if (!initial || !initial.current()) return undefined;
    147   const capture = initial;
    148   const manifest = readRelayPolicy(input.policy);
    149   const available = manifest.inbox
    150     .filter(
    151       ({ read, write, origin }) =>
    152         read && write && !manifest.operatorDenylist.includes(origin)
    153     )
    154     .map((row) => row.origin);
    155   const token = Object.freeze({}) as InboxSetupView;
    156   let state = {
    157       ...unavailable(),
    158       status: 'not_checked',
    159       owner: capture.owner,
    160       availableInboxes: available
    161     },
    162     epoch = 0,
    163     closed = false;
    164   let pendingClose: (() => void)[] | undefined;
    165   let resolver: InboxResolver | undefined,
    166     review: InboxSetupReview | undefined,
    167     action: InboxPreferenceAction | undefined,
    168     database: BrowserDatabase | undefined,
    169     repository: PublicQuotaRepository | undefined,
    170     session: PrivateSession | undefined,
    171     reader: InboxReadback | undefined,
    172     command: string | undefined;
    173   const listeners = new Map<symbol, (state: InboxSetupViewSnapshot) => void>();
    174   const current = (generation = epoch) =>
    175     !closed && generation === epoch && capture.current();
    176   const snapshot = () => {
    177     if (closed) return { ...unavailable(), status: 'closed' };
    178     if (!capture.current()) return unavailable();
    179     return JSON.parse(JSON.stringify(state)) as InboxSetupViewSnapshot;
    180   };
    181   function notify() {
    182     for (const listener of listeners.values()) {
    183       try {
    184         listener(snapshot());
    185       } catch {
    186         /* Isolate presentation observers. */
    187       }
    188     }
    189   }
    190   function update(status: string, busy = state.busy) {
    191     state = { ...state, status, busy };
    192     notify();
    193   }
    194   function inspect() {
    195     if (!resolver || !current()) return;
    196     const observed = inboxResolutionSnapshot(resolver);
    197     if (!current() || observed.author !== capture.owner) return;
    198     const head = observed.head && inboxPreferenceSnapshot(observed.head);
    199     state = {
    200       ...state,
    201       currentWire: observed.head
    202         ? (inboxPreferenceWire(observed.head) ?? null)
    203         : null,
    204       existingInboxes: head?.relays.slice() ?? [],
    205       setupComplete: false
    206     };
    207     if (
    208       observed.coverage !== 'bounded-eose' ||
    209       observed.status === 'inconclusive'
    210     ) {
    211       update('lookup_incomplete');
    212       return;
    213     }
    214     const compatible =
    215       head?.status === 'supported' &&
    216       inboxRelayTargets(input.policy, head.relays, 'read').length > 0 &&
    217       inboxRelayTargets(input.policy, head.relays, 'write').length > 0;
    218     update(
    219       compatible
    220         ? 'compatible'
    221         : observed.status === 'missing'
    222           ? 'not_observed'
    223           : 'needs_review'
    224     );
    225   }
    226   async function work(
    227     status: string,
    228     perform: (generation: number) => Promise<void>
    229   ) {
    230     if (!current() || state.busy) return;
    231     const generation = epoch;
    232     update(status, true);
    233     if (!current(generation)) return;
    234     try {
    235       await perform(generation);
    236     } catch {
    237       if (current(generation)) update('unavailable');
    238     } finally {
    239       if (current(generation)) {
    240         state = { ...state, busy: false };
    241         notify();
    242       }
    243     }
    244   }
    245   function stop() {
    246     epoch++;
    247     if (action) stopInboxPreferenceOperation(action);
    248     review = undefined;
    249     state = { ...state, preview: undefined, setupComplete: false };
    250     if (reader) closeInboxReadback(reader);
    251     reader = undefined;
    252     if (resolver) closeInboxResolver(resolver);
    253     resolver = undefined;
    254     update('paused', false);
    255   }
    256   const invalidate = subscribeIdentityInvalidation(input.identity, () => {
    257     if (!capture.current()) stop();
    258   });
    259   views.set(token, {
    260     ownership: () =>
    261       current()
    262         ? {
    263             identity: input.identity,
    264             policy: input.policy,
    265             session,
    266             resolver,
    267             observeAccess: input.observeAccess,
    268             current: () => current()
    269           }
    270         : undefined,
    271     observe() {
    272       if (current() && !state.busy && state.status === 'lookup_incomplete')
    273         inspect();
    274     },
    275     snapshot,
    276     subscribe(listener) {
    277       const id = Symbol();
    278       listeners.set(id, listener);
    279       try {
    280         listener(snapshot());
    281       } catch {
    282         /* Isolate presentation observers. */
    283       }
    284       return () => {
    285         listeners.delete(id);
    286       };
    287     },
    288     check: () =>
    289       work('checking', async (generation) => {
    290         if (resolver) closeInboxResolver(resolver);
    291         const found = await input.lookup(() => current(generation));
    292         if (!current(generation)) {
    293           closeInboxResolver(found);
    294           return;
    295         }
    296         resolver = found;
    297         review = undefined;
    298         state = { ...state, preview: undefined };
    299         inspect();
    300       }),
    301     review: (selected, removeTags, removeFields) =>
    302       work('reviewing', async (generation) => {
    303         if (!resolver) {
    304           update('lookup_incomplete');
    305           return;
    306         }
    307         inspect();
    308         if (!current(generation) || state.status === 'compatible') return;
    309         const result = await reviewInboxSetup(
    310           input.identity,
    311           resolver,
    312           input.policy,
    313           JSON.stringify({
    314             selectedInboxes: selected,
    315             removeTagIndices: removeTags,
    316             removeExtraFields: removeFields,
    317             createdAt: (input.now ?? (() => Math.floor(Date.now() / 1000)))()
    318           }),
    319           input.now
    320         );
    321         if (!current(generation)) return;
    322         if (result.status !== 'review') {
    323           update(result.reason);
    324           return;
    325         }
    326         review = result.review;
    327         state = { ...state, preview: inboxSetupPreview(review) };
    328         update('review');
    329       }),
    330     enable: () =>
    331       work('approval_wait', async (generation) => {
    332         if (
    333           !review ||
    334           state.preview === undefined ||
    335           !operationEnabled(input.policy, 'messaging')
    336         ) {
    337           update('unavailable');
    338           return;
    339         }
    340         const opened = await openBrowserDatabase();
    341         if (!current(generation)) {
    342           if (opened.state === 'ready') closeBrowserDatabase(opened.owner);
    343           return;
    344         }
    345         if (opened.state !== 'ready') {
    346           update('storage_unavailable');
    347           return;
    348         }
    349         if (database) closeBrowserDatabase(database);
    350         database = opened.owner;
    351         repository = createPublicQuotaRepository(database, capture.owner);
    352         if (!repository) {
    353           update('storage_unavailable');
    354           return;
    355         }
    356         command = crypto.randomUUID();
    357         const prepared = await beginInboxPreferenceOperation(
    358           repository,
    359           input.identity,
    360           input.policy,
    361           review,
    362           command,
    363           () => input.lookup(() => current(generation)),
    364           'reviewed_global_inbox_replacement'
    365         );
    366         if (!current(generation)) {
    367           if (prepared.status === 'prepared')
    368             stopInboxPreferenceOperation(prepared.action);
    369           return;
    370         }
    371         if (prepared.status !== 'prepared') {
    372           update(prepared.status);
    373           return;
    374         }
    375         action = prepared.action;
    376         const result = await runInboxPreferenceOperation(action);
    377         if (!current(generation)) return;
    378         const stored = await loadPreferenceOperation(repository, command);
    379         if (!current(generation)) return;
    380         const row =
    381           stored.ok &&
    382           publicRecordSnapshot(stored.value, capture.owner, command);
    383         state = {
    384           ...state,
    385           accepted:
    386             row && row.family === 'preference_operation'
    387               ? row.receipts
    388                   .filter(
    389                     (fact) =>
    390                       fact.status === 'accepted' &&
    391                       fact.eventId === row.artifact?.eventId
    392                   )
    393                   .map((fact) => fact.origin)
    394               : [],
    395           setupComplete: false
    396         };
    397         review = undefined;
    398         state = { ...state, preview: undefined };
    399         update(
    400           result.status === 'completed' ? 'awaiting_readback' : result.status
    401         );
    402       }),
    403     unlock: () =>
    404       work('approval_wait', async (generation) => {
    405         const acquired = await createPrivateSession(
    406           input.identity,
    407           'reviewed_private_session'
    408         );
    409         if (!current(generation)) {
    410           if (acquired) closePrivateSession(acquired);
    411           return;
    412         }
    413         session = acquired;
    414         if (!session || !resolver) {
    415           update('unavailable');
    416           return;
    417         }
    418         const result = existingInboxSetupSnapshot(
    419           input.identity,
    420           session,
    421           input.policy,
    422           resolver,
    423           input.observeAccess
    424         );
    425         if (!current(generation)) return;
    426         state = { ...state, setupComplete: result.setupComplete };
    427         update(result.status);
    428       }),
    429     readback: () =>
    430       work('checking_readback', async (generation) => {
    431         if (!repository || !command || !input.readback) {
    432           update('awaiting_readback');
    433           return;
    434         }
    435         if (!reader) {
    436           const stored = await loadPreferenceOperation(repository, command);
    437           if (!current(generation)) return;
    438           if (!stored.ok) {
    439             update('storage_unavailable');
    440             return;
    441           }
    442           reader = input.readback(stored.value, capture.owner, command);
    443         }
    444         const observation = reader && inboxReadbackSnapshot(reader);
    445         if (!observation || observation.status === 'pending') {
    446           update('awaiting_readback');
    447           return;
    448         }
    449         state = { ...state, readback: observation.sources.slice() };
    450         const result = await verifyInboxSetupOperation(
    451           repository,
    452           input.identity,
    453           session,
    454           input.policy,
    455           reader!,
    456           input.observeAccess
    457         );
    458         if (!current(generation)) return;
    459         state = { ...state, setupComplete: result.setupComplete };
    460         closeInboxReadback(reader!);
    461         reader = undefined;
    462         update(result.status);
    463       }),
    464     stop,
    465     close() {
    466       if (!pendingClose) {
    467         closed = true;
    468         const originalResolver = resolver,
    469           originalReader = reader,
    470           originalSession = session,
    471           originalDatabase = database;
    472         pendingClose = [
    473           stop,
    474           invalidate,
    475           () => {
    476             if (originalReader) closeInboxReadback(originalReader);
    477           },
    478           () => {
    479             if (originalResolver) closeInboxResolver(originalResolver);
    480           },
    481           () => {
    482             if (originalSession && !closePrivateSession(originalSession))
    483               throw Error('private_cleanup_required');
    484           },
    485           () => {
    486             if (originalDatabase) closeBrowserDatabase(originalDatabase);
    487           },
    488           () => input.close?.(),
    489           () => listeners.clear()
    490         ];
    491       }
    492       let unfinished = Array.from<() => void>([]);
    493       for (const cleanup of pendingClose) {
    494         try {
    495           cleanup();
    496         } catch {
    497           unfinished = unfinished.concat(cleanup);
    498         }
    499       }
    500       pendingClose = unfinished;
    501       // Closed admission and completed disposal are separate facts. A failed
    502       // original cleanup remains owned and retryable after invalidation.
    503       if (unfinished.length > 0) throw Error('inbox_setup_cleanup_required');
    504     }
    505   });
    506   return token;
    507 }
    508 // Production egress always comes from the root's governed runtime and fixed
    509 // deployment manifest. No fixture, arbitrary relay, signing template or sender.
    510 export function createRuntimeInboxSetupView(
    511   context: IdentityViewContext,
    512   runtime: PublicRuntime
    513 ): InboxSetupView | undefined {
    514   const identity = identityViewSession(context);
    515   if (!identity) return undefined;
    516   const view = createPublicView(runtime);
    517   try {
    518     const controller = createInboxSetupView({
    519       identity,
    520       policy: deploymentRelayPolicy,
    521       lookup: (current = () => true) => {
    522         const owner = identityMessagingOwnership(identity);
    523         if (!owner) throw new Error('inbox_owner_unavailable');
    524         return settleInboxResolver(
    525           resolveInboxPreference(view, beginPublicViewRun(view), owner.owner),
    526           () => owner.current() && current()
    527         );
    528       },
    529       readback: (record, owner, id) =>
    530         resolveInboxReadback(
    531           view,
    532           beginPublicViewRun(view),
    533           record,
    534           owner,
    535           id,
    536           deploymentRelayPolicy
    537         ),
    538       close: () => disposePublicView(view)
    539     });
    540     if (!controller) disposePublicView(view);
    541     return controller;
    542   } catch {
    543     disposePublicView(view);
    544     return undefined;
    545   }
    546 }
    547 export function inboxSetupViewSnapshot(
    548   view: InboxSetupView | undefined
    549 ): InboxSetupViewSnapshot {
    550   return (view && views.get(view)?.snapshot()) || unavailable();
    551 }
    552 export function subscribeInboxSetupView(
    553   view: InboxSetupView | undefined,
    554   listener: (state: InboxSetupViewSnapshot) => void
    555 ): () => void {
    556   return (view && views.get(view)?.subscribe(listener)) || (() => {});
    557 }
    558 export async function checkInboxSetupView(
    559   view: InboxSetupView | undefined
    560 ): Promise<void> {
    561   await (view && views.get(view)?.check());
    562 }
    563 export async function reviewInboxSetupView(
    564   view: InboxSetupView | undefined,
    565   selected: string[],
    566   removeTags: number[],
    567   removeFields: string[]
    568 ): Promise<void> {
    569   await (view && views.get(view)?.review(selected, removeTags, removeFields));
    570 }
    571 export async function enableInboxSetupView(
    572   view: InboxSetupView | undefined
    573 ): Promise<void> {
    574   await (view && views.get(view)?.enable());
    575 }
    576 export async function unlockInboxSetupView(
    577   view: InboxSetupView | undefined
    578 ): Promise<void> {
    579   await (view && views.get(view)?.unlock());
    580 }
    581 export async function readbackInboxSetupView(
    582   view: InboxSetupView | undefined
    583 ): Promise<void> {
    584   await (view && views.get(view)?.readback());
    585 }
    586 export function stopInboxSetupView(view: InboxSetupView | undefined): void {
    587   if (view) views.get(view)?.stop();
    588 }
    589 export function closeInboxSetupView(view: InboxSetupView | undefined): void {
    590   if (view) views.get(view)?.close();
    591 }
    592 
    593 // Detached original-token observation for trusted page orchestration. Neither
    594 // its scalar fields nor mutation of this fresh object changes stored custody.
    595 export function inboxSetupViewOwnership(view: InboxSetupView | undefined) {
    596   return view && views.get(view)?.ownership();
    597 }
    598 export function observeInboxSetupView(view: InboxSetupView | undefined): void {
    599   if (view) views.get(view)?.observe();
    600 }