app

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

resume-preparation.ts (11834B)


      1 import { canonicalLocalId } from '../private-handles.ts';
      2 import {
      3   identityMessagingOwnership,
      4   subscribeIdentityInvalidation,
      5   type IdentitySession
      6 } from '../runtime/identity-session.ts';
      7 import {
      8   loadPrivateRecord,
      9   type PrivateStorageRepository
     10 } from '../persistence/private-storage.ts';
     11 import { privateRecordWire } from '../persistence/private-records.ts';
     12 import {
     13   captureSelfRecoveryReader,
     14   readSelfRecoveryEnvelope,
     15   recoveredSelfEnvelopeSnapshot,
     16   stopSelfRecoveryReader,
     17   expireSelfRecoveryReaderWait,
     18   type SelfRecoveryReader,
     19   type SelfRecoveryReadResult
     20 } from '../nostr/self-recovery-reader.ts';
     21 import {
     22   restoreRecoveredRumor,
     23   rumorPlanSnapshot,
     24   stopRumorPlan,
     25   type RumorPlan
     26 } from './rumor-plan.ts';
     27 import {
     28   restoreRecoveredSendIdentity,
     29   type ReservedSendIdentity
     30 } from './send-identity.ts';
     31 import {
     32   acknowledgeRecoveredPairedDelivery,
     33   type PairedDeliveryCommitResult
     34 } from '../persistence/private-sends.ts';
     35 import { verifyRecoveredSelfEnvelope } from '../nostr/verify-outbound-envelope.ts';
     36 import {
     37   captureSelfRecoveryPreparation,
     38   prepareSelfRecovery,
     39   preparePairedDelivery,
     40   preparedSelfRecovery,
     41   preparedPairedDelivery,
     42   stopSelfRecoveryPreparation,
     43   type SelfRecoveryPreparation,
     44   type PairedDeliveryContext,
     45   type PairedDeliveryPreparationResult
     46 } from './prepare-send.ts';
     47 declare const resumeBrand: unique symbol;
     48 export type ResumePreparation = Readonly<{ [resumeBrand]: true }>;
     49 export type ResumePreparationResult = Readonly<{
     50   status:
     51     | SelfRecoveryReadResult['status']
     52     | PairedDeliveryPreparationResult['status']
     53     | 'already_prepared';
     54 }>;
     55 type Snapshot = Readonly<{
     56   owner: string;
     57   command: string;
     58   state:
     59     | 'unsaved'
     60     | 'recovering'
     61     | 'recovered'
     62     | 'prepared'
     63     | 'lost'
     64     | 'needs_action';
     65   busy: boolean;
     66   copy: string;
     67   peer?: string;
     68   rumorHash?: string;
     69   createdAt?: number;
     70 }>;
     71 type Controller = {
     72   run(
     73     context: PairedDeliveryContext | undefined,
     74     review: unknown
     75   ): Promise<ResumePreparationResult>;
     76   snapshot(): Snapshot | undefined;
     77   rumor(): RumorPlan | undefined;
     78   qualify(
     79     context: PairedDeliveryContext,
     80     review: unknown
     81   ): Promise<PairedDeliveryCommitResult | Readonly<{ status: 'busy' }>>;
     82   stop(expired: boolean): void;
     83 };
     84 const resumes = new WeakMap<ResumePreparation, Controller>();
     85 // Explicit memory-only recovery workflow. Capture/render performs no IO or
     86 // extension job; actual Resume cannot recreate lost ciphertext or send a relay
     87 // event. Original authenticated command/hash/time survive memory cache loss.
     88 export function captureResumePreparation(
     89   repository: PrivateStorageRepository,
     90   session: IdentitySession,
     91   localId: unknown,
     92   review: unknown
     93 ): ResumePreparation | undefined {
     94   if (typeof window === 'undefined' || review !== 'reviewed_private_resume')
     95     return undefined;
     96   const inputId = canonicalLocalId(localId),
     97     inputOwnership = identityMessagingOwnership(session);
     98   if (!inputId || !inputOwnership?.current()) return undefined;
     99   const id = inputId,
    100     ownership = inputOwnership;
    101   let active = true,
    102     busy = false,
    103     generation = 0,
    104     state: Snapshot['state'] = 'unsaved',
    105     reader: SelfRecoveryReader | undefined,
    106     plan: RumorPlan | undefined,
    107     preparation: SelfRecoveryPreparation | undefined,
    108     recoveredIdentity: ReservedSendIdentity | undefined,
    109     alreadyPaired = false,
    110     peerOnly = false,
    111     originalWire: string | undefined,
    112     unsubscribe = () => {};
    113   function stop(expired: boolean) {
    114     if (!active) return;
    115     active = false;
    116     generation++;
    117     if (reader) {
    118       if (expired) expireSelfRecoveryReaderWait(reader);
    119       else stopSelfRecoveryReader(reader);
    120     }
    121     if (preparation) stopSelfRecoveryPreparation(preparation);
    122     if (plan) stopRumorPlan(plan);
    123     reader = undefined;
    124     preparation = undefined;
    125     plan = undefined;
    126     originalWire = undefined;
    127     recoveredIdentity = undefined;
    128     unsubscribe();
    129     unsubscribe = () => {};
    130   }
    131   function current() {
    132     if (!active || !ownership.current() || (plan && !rumorPlanSnapshot(plan))) {
    133       stop(false);
    134       return false;
    135     }
    136     return true;
    137   }
    138   function snapshot(): Snapshot | undefined {
    139     if (!current()) return undefined;
    140     const rumor = plan && rumorPlanSnapshot(plan);
    141     return {
    142       owner: ownership.owner,
    143       command: id,
    144       state,
    145       busy,
    146       copy:
    147         state === 'lost'
    148           ? 'Encrypted recovery evidence was lost. This message cannot be silently recreated.'
    149           : state === 'needs_action'
    150             ? 'Encrypted recovery needs your review; no message was sent.'
    151             : rumor
    152               ? 'Original encrypted message recovered in this browser; no delivery is claimed.'
    153               : 'Resume is required to decrypt stored recovery evidence.',
    154       ...(rumor
    155         ? { peer: rumor.peer, rumorHash: rumor.id, createdAt: rumor.createdAt }
    156         : {})
    157     };
    158   }
    159   async function run(
    160     context: PairedDeliveryContext | undefined,
    161     reviewed: unknown
    162   ): Promise<ResumePreparationResult> {
    163     if (reviewed !== 'reviewed_private_resume') return { status: 'invalid' };
    164     if (!current()) return { status: 'stopped' };
    165     if (busy) return { status: 'busy' };
    166     busy = true;
    167     const attempt = generation,
    168       admitted = () => current() && generation === attempt;
    169     try {
    170       if (!plan) {
    171         state = 'recovering';
    172         reader = captureSelfRecoveryReader(
    173           repository,
    174           session,
    175           id,
    176           'reviewed_self_decryption'
    177         );
    178         if (!reader) {
    179           state = 'needs_action';
    180           return { status: 'stopped' };
    181         }
    182         const recovered = await readSelfRecoveryEnvelope(reader);
    183         if (!admitted()) return { status: 'stopped' };
    184         if (recovered.status !== 'recovered') {
    185           state =
    186             recovered.status === 'lost_evidence' ? 'lost' : 'needs_action';
    187           stopSelfRecoveryReader(reader);
    188           reader = undefined;
    189           return { status: recovered.status };
    190         }
    191         const source = recoveredSelfEnvelopeSnapshot(recovered.envelope);
    192         plan = restoreRecoveredRumor(session, recovered.envelope);
    193         const reserved =
    194             plan &&
    195             restoreRecoveredSendIdentity(session, recovered.envelope, plan),
    196           proof =
    197             reserved &&
    198             verifyRecoveredSelfEnvelope(
    199               reserved,
    200               recovered.envelope,
    201               'reviewed_recovered_self'
    202             );
    203         if (!source || !plan || !reserved || !proof || !admitted()) {
    204           stop(false);
    205           return { status: 'stopped' };
    206         }
    207         originalWire = source.storedWire;
    208         recoveredIdentity = reserved;
    209         alreadyPaired =
    210           !!source.record.peerArtifact && !!source.record.deliveryPlan;
    211         peerOnly = !!source.record.peerArtifact && !source.record.deliveryPlan;
    212         preparation = captureSelfRecoveryPreparation(
    213           repository,
    214           session,
    215           reserved,
    216           'reviewed_self_recovery',
    217           proof
    218         );
    219         if (!preparation || !admitted()) {
    220           stop(false);
    221           return { status: 'stopped' };
    222         }
    223       }
    224       if (!preparation || !admitted()) return { status: 'stopped' };
    225       if (alreadyPaired || peerOnly) {
    226         const stored = await loadPrivateRecord(repository, 'private_sends', id);
    227         if (!admitted()) return { status: 'stopped' };
    228         if (
    229           !stored.ok ||
    230           privateRecordWire(stored.value, ownership.owner, id) !== originalWire
    231         ) {
    232           state = stored.ok
    233             ? 'needs_action'
    234             : stored.reason === 'invalid_record'
    235               ? 'lost'
    236               : 'needs_action';
    237           if (plan) stopRumorPlan(plan);
    238           plan = undefined;
    239           stopSelfRecoveryPreparation(preparation);
    240           preparation = undefined;
    241           if (reader) stopSelfRecoveryReader(reader);
    242           reader = undefined;
    243           return {
    244             status: stored.ok
    245               ? 'conflict'
    246               : stored.reason === 'invalid_record'
    247                 ? 'lost_evidence'
    248                 : stored.reason
    249           };
    250         }
    251         state = 'recovered';
    252         return {
    253           status: alreadyPaired ? 'already_prepared' : 'review_required'
    254         };
    255       }
    256       const saved = await prepareSelfRecovery(
    257         preparation,
    258         'reviewed_self_recovery'
    259       );
    260       if (!admitted()) return { status: 'stopped' };
    261       if (!['saved', 'existing', 'reconciled'].includes(saved.status)) {
    262         state = 'needs_action';
    263         return { status: saved.status };
    264       }
    265       state = 'recovered';
    266       if (!context) return { status: 'recovered' };
    267       const paired = await preparePairedDelivery(
    268         preparation,
    269         context,
    270         'reviewed_pair_preparation'
    271       );
    272       if (!admitted()) return { status: 'stopped' };
    273       state = paired.status === 'prepared' ? 'prepared' : 'needs_action';
    274       return { status: paired.status };
    275     } catch {
    276       state = 'needs_action';
    277       return { status: admitted() ? 'unavailable' : 'stopped' };
    278     } finally {
    279       busy = false;
    280     }
    281   }
    282   const token = Object.freeze({}) as ResumePreparation;
    283   resumes.set(token, {
    284     run,
    285     snapshot,
    286     rumor: () => (current() ? plan : undefined),
    287     async qualify(context, review) {
    288       if (review !== 'reviewed_stored_private_retry')
    289         return { status: 'invalid' };
    290       if (!current()) return { status: 'stopped' };
    291       if (busy) return { status: 'busy' };
    292       if (!preparation || !recoveredIdentity) return { status: 'invalid' };
    293       busy = true;
    294       try {
    295         const freshPair = preparedPairedDelivery(preparation);
    296         if (freshPair) return { status: 'existing', receipt: freshPair };
    297         if (!alreadyPaired) return { status: 'invalid' };
    298         const saved = await prepareSelfRecovery(
    299           preparation,
    300           'reviewed_self_recovery'
    301         );
    302         if (!current()) return { status: 'stopped' };
    303         if (!['saved', 'existing', 'reconciled'].includes(saved.status))
    304           return { status: saved.status === 'stopped' ? 'stopped' : 'invalid' };
    305         const self = preparedSelfRecovery(preparation);
    306         if (!self) return { status: 'invalid' };
    307         const qualified = await acknowledgeRecoveredPairedDelivery(
    308           repository,
    309           session,
    310           recoveredIdentity,
    311           self,
    312           context,
    313           review
    314         );
    315         return current() ? qualified : { status: 'stopped' };
    316       } finally {
    317         busy = false;
    318       }
    319     },
    320     stop
    321   });
    322   unsubscribe = subscribeIdentityInvalidation(session, () => {
    323     if (!ownership.current()) stop(false);
    324   });
    325   return current() ? token : undefined;
    326 }
    327 export function resumeEncryptedPreparation(
    328   token: ResumePreparation,
    329   context: PairedDeliveryContext | undefined,
    330   review: unknown
    331 ): Promise<ResumePreparationResult> {
    332   return (
    333     resumes.get(token)?.run(context, review) ??
    334     Promise.resolve({ status: 'invalid' })
    335   );
    336 }
    337 export function qualifyRecoveredPrivatePair(
    338   token: ResumePreparation,
    339   context: PairedDeliveryContext,
    340   review: unknown
    341 ): Promise<PairedDeliveryCommitResult | Readonly<{ status: 'busy' }>> {
    342   return (
    343     resumes.get(token)?.qualify(context, review) ??
    344     Promise.resolve({ status: 'invalid' })
    345   );
    346 }
    347 export function resumePreparationSnapshot(token: ResumePreparation) {
    348   return resumes.get(token)?.snapshot();
    349 }
    350 export function resumeRecoveredRumor(token: ResumePreparation) {
    351   return resumes.get(token)?.rumor();
    352 }
    353 export function stopResumePreparation(token: ResumePreparation): void {
    354   resumes.get(token)?.stop(false);
    355 }
    356 export function expireResumePreparationWait(token: ResumePreparation): void {
    357   resumes.get(token)?.stop(true);
    358 }