app

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

reply-controller.ts (16299B)


      1 import { inboxReplyOwnership, type InboxView } from './inbox-view.ts';
      2 import { inboxSetupViewOwnership } from './inbox-setup-view.ts';
      3 import { messagingReadinessSnapshot } from './readiness.ts';
      4 import { operationEnabled } from '../config/operation-flags.ts';
      5 import {
      6   createInboxRoutePlan,
      7   inboxRoutePlanSnapshot
      8 } from './inbox-routing.ts';
      9 import {
     10   resolveInboxPreference,
     11   closeInboxResolver,
     12   type InboxResolver
     13 } from './resolve-inbox.ts';
     14 import {
     15   createPublicView,
     16   beginPublicViewRun,
     17   publicViewRunCurrent,
     18   disposePublicView,
     19   type PublicRuntime
     20 } from '../runtime/public-runtime.ts';
     21 import {
     22   createPrivateComposer,
     23   privateComposerText,
     24   privateComposerSnapshot,
     25   updatePrivateComposerText,
     26   bindPrivateComposerPreparation,
     27   closePrivateComposer
     28 } from './composer-state.ts';
     29 import {
     30   captureDirtyNavigation,
     31   requestPrivateNavigation,
     32   confirmDiscardNavigation,
     33   keepPrivateEditing,
     34   dirtyNavigationSnapshot,
     35   privateNavigationBeforeUnload
     36 } from '../runtime/dirty-navigation.ts';
     37 import {
     38   captureAuthenticatedReplyRumor,
     39   stopRumorPlan,
     40   type RumorPlan
     41 } from './rumor-plan.ts';
     42 import { createPrivateSendReservationRepository } from '../persistence/private-send-reservations.ts';
     43 import { reserveSendIdentity } from './send-identity.ts';
     44 import {
     45   captureSelfRecoveryPreparation,
     46   prepareSelfRecovery,
     47   preparedSelfRecovery,
     48   preparePairedDelivery,
     49   preparedPairedDelivery,
     50   selfRecoveryPreparationSnapshot,
     51   type SelfRecoveryPreparation
     52 } from './prepare-send.ts';
     53 import {
     54   getPrivatePool,
     55   closePrivatePool,
     56   privatePoolCleanupRequired,
     57   type PrivatePool
     58 } from '../nostr/private-pool.ts';
     59 import {
     60   capturePrivateRetry,
     61   runPrivateRetry,
     62   stopPrivateRetry,
     63   type PrivateRetry
     64 } from './retry-send.ts';
     65 import { newLocalId } from '../private-handles.ts';
     66 import { subscribeIdentityInvalidation } from '../runtime/identity-session.ts';
     67 import { subscribePrivateSessionClose } from '../runtime/private-session.ts';
     68 
     69 declare const replyBrand: unique symbol;
     70 export type ReplyController = Readonly<{ [replyBrand]: true }>;
     71 type Result = Readonly<{
     72   status: 'invalid' | 'busy' | 'stopped' | 'needs_action' | 'completed';
     73 }>;
     74 type Options = Readonly<{
     75   lookupPeer?(peer: string): Promise<InboxResolver>;
     76   close?(): void;
     77 }>;
     78 type State =
     79   | 'idle'
     80   | 'checking'
     81   | 'preparing'
     82   | 'publishing'
     83   | 'needs_action'
     84   | 'completed';
     85 type Snapshot = Readonly<{
     86   state: State;
     87   readyToSend: boolean;
     88   busy: boolean;
     89   dirty: boolean;
     90   copy: string;
     91   saveCopy: string;
     92   pairCopy: string;
     93   navigation: 'idle' | 'confirmation_required';
     94 }>;
     95 type Controller = {
     96   snapshot(): Snapshot | undefined;
     97   text(): string | undefined;
     98   update(text: unknown, review: unknown): boolean;
     99   select(parent: unknown, review: unknown): boolean;
    100   send(review: unknown): Promise<Result>;
    101   request(): ReturnType<typeof requestPrivateNavigation>;
    102   keep(): boolean;
    103   discard(review: unknown): ReturnType<typeof confirmDiscardNavigation>;
    104   unload(event: BeforeUnloadEvent): boolean;
    105   close(): void;
    106 };
    107 const controllers = new WeakMap<ReplyController, Controller>();
    108 
    109 // Allocating or typing a draft performs no SDK, native write or discovery.
    110 // Caller hints are resolved through the original selected view's Room/cache.
    111 export function createReplyController(
    112   view: InboxView,
    113   conversationId: unknown,
    114   parent: unknown,
    115   options: Options = {}
    116 ): ReplyController | undefined {
    117   if (typeof window === 'undefined') return;
    118   let scope = inboxReplyOwnership(view, conversationId, parent);
    119   if (!scope?.current()) return;
    120   const original = scope,
    121     composer = createPrivateComposer(
    122       original.identity,
    123       'reviewed_private_composer'
    124     );
    125   const navigation = composer && captureDirtyNavigation(composer);
    126   if (!composer || !navigation) {
    127     if (composer) closePrivateComposer(composer);
    128     return;
    129   }
    130   let active = true,
    131     busy = false,
    132     state: State = 'idle',
    133     copy = '',
    134     attempted = false;
    135   let plan: RumorPlan | undefined,
    136     preparation: SelfRecoveryPreparation | undefined,
    137     retry: PrivateRetry | undefined;
    138   let identityOff = () => {},
    139     privateOff = () => {};
    140   let pool: PrivatePool | undefined;
    141   let poolCleanupFailed = false;
    142   function releasePool() {
    143     if (!pool) return true;
    144     try {
    145       poolCleanupFailed = false;
    146       closePrivatePool(pool);
    147       if (privatePoolCleanupRequired(pool)) return false;
    148       pool = undefined;
    149       return true;
    150     } catch {
    151       poolCleanupFailed = true;
    152       return false;
    153     }
    154   }
    155   function close(sessionCleanup = false) {
    156     if (!active && !pool) return;
    157     active = false;
    158     if (retry) stopPrivateRetry(retry);
    159     closePrivateComposer(composer!);
    160     if (plan) stopRumorPlan(plan);
    161     const clean = releasePool();
    162     options.close?.();
    163     if (!clean) {
    164       if (poolCleanupFailed || sessionCleanup)
    165         throw Error('private_delivery_cleanup_required');
    166       return;
    167     }
    168     identityOff();
    169     privateOff();
    170   }
    171   function current() {
    172     if (!active || !scope?.current() || !privateComposerSnapshot(composer!)) {
    173       try {
    174         close();
    175       } catch {
    176         /* Exact original disposal stays retryable. */
    177       }
    178       return false;
    179     }
    180     return true;
    181   }
    182   function snapshot(): Snapshot | undefined {
    183     if (!current()) return;
    184     const draft = privateComposerSnapshot(composer!),
    185       workflow = preparation && selfRecoveryPreparationSnapshot(preparation);
    186     if (!draft) return;
    187     return {
    188       state,
    189       readyToSend:
    190         !attempted &&
    191         operationEnabled(
    192           inboxSetupViewOwnership(scope!.setup)?.policy,
    193           'messaging'
    194         ),
    195       busy,
    196       dirty: draft.dirty,
    197       copy:
    198         copy ||
    199         (!operationEnabled(
    200           inboxSetupViewOwnership(scope!.setup)?.policy,
    201           'messaging'
    202         )
    203           ? 'Messaging is disabled in this build. Keep your unsent draft and review existing encrypted work separately.'
    204           : state === 'preparing'
    205             ? 'Preparing encryption. The extension may ask for several approvals.'
    206             : state === 'publishing'
    207               ? 'Publishing encrypted copies to the reviewed inbox relays.'
    208               : ''),
    209       saveCopy: draft.copy,
    210       pairCopy: workflow?.pairCopy ?? draft.pairCopy,
    211       navigation: dirtyNavigationSnapshot(navigation!)?.state ?? 'idle'
    212     };
    213   }
    214   async function send(review: unknown): Promise<Result> {
    215     if (review !== 'reviewed_reply_send') return { status: 'invalid' };
    216     if (!current()) return { status: 'stopped' };
    217     if (busy) return { status: 'busy' };
    218     if (
    219       !operationEnabled(
    220         inboxSetupViewOwnership(scope!.setup)?.policy,
    221         'messaging'
    222       )
    223     ) {
    224       state = 'needs_action';
    225       copy =
    226         'Messaging is disabled in this build. Your unsent text remains in memory; existing encrypted work needs its own recovery review.';
    227       return { status: 'needs_action' };
    228     }
    229     const text = privateComposerText(composer!);
    230     if (!text?.trim()) return { status: 'invalid' };
    231     if (attempted) return { status: 'needs_action' };
    232     busy = true;
    233     state = 'checking';
    234     copy =
    235       'Checking the authenticated peer inbox. Your text remains in memory.';
    236     const captured = scope!;
    237     const admitted = () => current() && scope === captured;
    238     function needsAction(definitePreEffect = false): Result {
    239       state = attempted || !definitePreEffect ? 'needs_action' : 'idle';
    240       if (!attempted) {
    241         if (plan) stopRumorPlan(plan);
    242         plan = undefined;
    243       }
    244       copy = attempted
    245         ? 'Send needs review. Keep this draft; check inbox setup or connection, then explicitly send again. Existing encrypted work needs its own recovery review.'
    246         : 'No private send was reserved. Your text stays in memory. Review inbox setup or storage, then explicitly try Send again.';
    247       return { status: 'needs_action' };
    248     }
    249     try {
    250       const setup = inboxSetupViewOwnership(captured.setup);
    251       if (!setup?.current() || !setup.resolver || !options.lookupPeer)
    252         return needsAction();
    253       const other = await options.lookupPeer(captured.peer);
    254       if (!admitted()) return { status: 'stopped' };
    255       if (
    256         !messagingReadinessSnapshot(
    257           captured.identity,
    258           captured.session,
    259           setup.policy,
    260           setup.resolver,
    261           { author: captured.peer, resolver: other },
    262           setup.observeAccess
    263         ).sendReady ||
    264         !admitted()
    265       )
    266         return needsAction();
    267       const routes = createInboxRoutePlan(
    268         setup.policy,
    269         captured.owner,
    270         captured.peer,
    271         setup.resolver,
    272         other
    273       );
    274       const routeData = routes && inboxRoutePlanSnapshot(routes);
    275       const reservations = createPrivateSendReservationRepository(
    276         captured.database,
    277         captured.owner
    278       );
    279       if (!routes || !routeData || !reservations || !admitted())
    280         return needsAction();
    281       plan = captureAuthenticatedReplyRumor(
    282         captured.identity,
    283         captured.session,
    284         captured.unlocked,
    285         captured.room,
    286         text,
    287         Math.floor(Date.now() / 1000)
    288       );
    289       const command = newLocalId();
    290       if (!plan || !command || !admitted()) return needsAction(true);
    291       // After a native intent may exist, repeated Send never creates another
    292       // rumor or silently replays this command. Recovery has its own owner.
    293       attempted = true;
    294       const reserved = await reserveSendIdentity(
    295         reservations,
    296         captured.identity,
    297         command,
    298         plan,
    299         'reviewed_private_intent'
    300       );
    301       if (!admitted()) return { status: 'stopped' };
    302       if (!('identity' in reserved)) {
    303         if (reserved.disposition !== 'not_created') return needsAction();
    304         attempted = false;
    305         return needsAction(true);
    306       }
    307       preparation = captureSelfRecoveryPreparation(
    308         captured.repository,
    309         captured.identity,
    310         reserved.identity,
    311         'reviewed_self_recovery'
    312       );
    313       if (
    314         !preparation ||
    315         !bindPrivateComposerPreparation(
    316           composer!,
    317           reserved.identity,
    318           preparation,
    319           undefined,
    320           'reviewed_composer_preparation'
    321         )
    322       )
    323         return needsAction();
    324       state = 'preparing';
    325       copy = '';
    326       const self = await prepareSelfRecovery(
    327         preparation,
    328         'reviewed_self_recovery'
    329       );
    330       if (!admitted()) return { status: 'stopped' };
    331       const saved = preparedSelfRecovery(preparation);
    332       if (
    333         !['saved', 'existing', 'reconciled'].includes(self.status) ||
    334         !saved ||
    335         !(await captured.acceptLocalReply(saved, 'reviewed_local_reply')) ||
    336         !admitted()
    337       )
    338         return needsAction();
    339       const context = {
    340         plan: routes,
    341         policy: setup.policy,
    342         own: setup.resolver,
    343         other
    344       };
    345       const paired = await preparePairedDelivery(
    346         preparation,
    347         context,
    348         'reviewed_pair_preparation'
    349       );
    350       if (!admitted()) return { status: 'stopped' };
    351       const receipt = preparedPairedDelivery(preparation);
    352       if (
    353         !['prepared', 'existing', 'reconciled'].includes(paired.status) ||
    354         !receipt
    355       )
    356         return needsAction();
    357       const origins = Array.from(
    358         new Set([...routeData.peer.targets, ...routeData.archive.targets])
    359       );
    360       if (!releasePool()) return needsAction();
    361       pool = getPrivatePool(
    362         captured.session,
    363         setup.policy,
    364         origins,
    365         token,
    366         'delivery',
    367         admitted
    368       );
    369       if (!pool || !admitted()) return needsAction();
    370       retry = capturePrivateRetry(
    371         captured.repository,
    372         captured.session,
    373         receipt,
    374         context,
    375         pool,
    376         'reviewed_private_retry'
    377       );
    378       if (!retry || !admitted()) return needsAction();
    379       state = 'publishing';
    380       const delivered = await runPrivateRetry(retry, 'reviewed_private_retry');
    381       if (!admitted()) return { status: 'stopped' };
    382       if (delivered.status !== 'completed') return needsAction();
    383       state = 'completed';
    384       copy =
    385         'Accepted by recipient inbox relay. This does not confirm that the person read the message.';
    386       return { status: 'completed' };
    387     } catch {
    388       return current() ? needsAction() : { status: 'stopped' };
    389     } finally {
    390       busy = false;
    391       releasePool();
    392     }
    393   }
    394   const token = Object.freeze({}) as ReplyController;
    395   controllers.set(token, {
    396     snapshot,
    397     text: () => (current() ? privateComposerText(composer) : undefined),
    398     update: (text, review) =>
    399       current() &&
    400       !busy &&
    401       !attempted &&
    402       updatePrivateComposerText(composer, text, review),
    403     select(parent, review) {
    404       if (review !== 'reviewed_reply_parent' || !current() || busy || attempted)
    405         return false;
    406       const selected = inboxReplyOwnership(view, conversationId, parent);
    407       if (
    408         !selected?.current() ||
    409         selected.identity !== original.identity ||
    410         selected.session !== original.session ||
    411         selected.peer !== original.peer
    412       )
    413         return false;
    414       scope = selected;
    415       return true;
    416     },
    417     send,
    418     request: () =>
    419       current() ? requestPrivateNavigation(navigation) : 'invalid',
    420     keep: () => current() && keepPrivateEditing(navigation),
    421     discard: (review) =>
    422       current() ? confirmDiscardNavigation(navigation, review) : 'invalid',
    423     unload: (event) =>
    424       current() && privateNavigationBeforeUnload(navigation, event),
    425     close
    426   });
    427   identityOff = subscribeIdentityInvalidation(original.identity, () => {
    428     if (!original.current()) close();
    429   });
    430   privateOff = subscribePrivateSessionClose(original.session, () =>
    431     close(true)
    432   );
    433   return current() ? token : undefined;
    434 }
    435 
    436 export function createRuntimeReplyController(
    437   view: InboxView,
    438   id: unknown,
    439   parent: unknown,
    440   runtime: PublicRuntime
    441 ): ReplyController | undefined {
    442   const publicView = createPublicView(runtime);
    443   let resolver: InboxResolver | undefined,
    444     run: ReturnType<typeof beginPublicViewRun> | undefined;
    445   const token = createReplyController(view, id, parent, {
    446     lookupPeer: (peer) => {
    447       // Only this explicit Send lookup may renew an expired run. An active
    448       // lookup retains its original bounded work, including pending results.
    449       if (!resolver || !run || !publicViewRunCurrent(publicView, run)) {
    450         if (resolver) closeInboxResolver(resolver);
    451         resolver = undefined;
    452         run = beginPublicViewRun(publicView);
    453         resolver = resolveInboxPreference(publicView, run, peer);
    454       }
    455       return Promise.resolve(resolver);
    456     },
    457     close: () => {
    458       if (resolver) closeInboxResolver(resolver);
    459       disposePublicView(publicView);
    460     }
    461   });
    462   if (!token) disposePublicView(publicView);
    463   return token;
    464 }
    465 export function replySnapshot(token: ReplyController) {
    466   return controllers.get(token)?.snapshot();
    467 }
    468 export function replyText(token: ReplyController) {
    469   return controllers.get(token)?.text();
    470 }
    471 export function updateReplyText(
    472   token: ReplyController,
    473   text: unknown,
    474   review: unknown
    475 ) {
    476   return controllers.get(token)?.update(text, review) ?? false;
    477 }
    478 export function selectReplyParent(
    479   token: ReplyController,
    480   parent: unknown,
    481   review: unknown
    482 ) {
    483   return controllers.get(token)?.select(parent, review) ?? false;
    484 }
    485 export function sendReply(
    486   token: ReplyController,
    487   review: unknown
    488 ): Promise<Result> {
    489   return (
    490     controllers.get(token)?.send(review) ??
    491     Promise.resolve({ status: 'invalid' })
    492   );
    493 }
    494 export function requestReplyNavigation(token: ReplyController) {
    495   return controllers.get(token)?.request() ?? 'invalid';
    496 }
    497 export function keepReplyEditing(token: ReplyController) {
    498   return controllers.get(token)?.keep() ?? false;
    499 }
    500 export function discardReplyNavigation(
    501   token: ReplyController,
    502   review: unknown
    503 ) {
    504   return controllers.get(token)?.discard(review) ?? 'invalid';
    505 }
    506 export function replyBeforeUnload(
    507   token: ReplyController,
    508   event: BeforeUnloadEvent
    509 ) {
    510   return controllers.get(token)?.unload(event) ?? false;
    511 }
    512 export function closeReplyController(token: ReplyController) {
    513   controllers.get(token)?.close();
    514 }