app

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

inbox-setup-operation.ts (11882B)


      1 import {
      2   captureInboxSetup,
      3   inboxSetupRecordCurrent,
      4   type InboxSetupReview
      5 } from './inbox-setup.ts';
      6 import { operationEnabled } from '../config/operation-flags.ts';
      7 import type { InboxResolver } from './resolve-inbox.ts';
      8 import { publicRelayTargets, type RelayPolicy } from '../config/relays.ts';
      9 import { canonicalLocalId } from '../private-handles.ts';
     10 import {
     11   identityMessagingOwnership,
     12   captureIdentityPublicOperation,
     13   identityPublicOperationOwnership,
     14   signIdentityPublicOperation,
     15   stopIdentityPublicOperation,
     16   recheckIdentityOwner,
     17   subscribeIdentityInvalidation,
     18   type IdentitySession,
     19   type IdentityPublicOperation
     20 } from '../runtime/identity-session.ts';
     21 import {
     22   runCapturedPublicEffect,
     23   type PublicEffectLease
     24 } from '../runtime/effect-ownership.ts';
     25 import {
     26   publicRecordSnapshot,
     27   decodePublicRecord,
     28   type PublicRecordHandle
     29 } from '../persistence/records.ts';
     30 import {
     31   loadPreferenceOperation,
     32   commitPublicOperationTransition,
     33   observePublicOperationTransition,
     34   publicQuotaOwner,
     35   type PublicQuotaRepository
     36 } from '../persistence/quota.ts';
     37 import {
     38   preparePreferenceSigningTransition,
     39   preparePublicArtifactTransition,
     40   type PublicOperationTransition
     41 } from '../persistence/artifact-records.ts';
     42 import { getPublicPool } from '../nostr/public-pool.ts';
     43 import {
     44   authorizeStoredInboxPreference,
     45   preferencePolicyFingerprint
     46 } from '../nostr/inbox-preference-publication.ts';
     47 import {
     48   publishInboxPreference,
     49   type PreferencePublicationResult
     50 } from '../nostr/inbox-preference-publisher.ts';
     51 declare const actionBrand: unique symbol;
     52 export type InboxPreferenceAction = Readonly<{ [actionBrand]: true }>;
     53 type Lookup = () => Promise<InboxResolver>;
     54 type Saved = Readonly<{
     55   repository: PublicQuotaRepository;
     56   identity: IdentitySession;
     57   policy: RelayPolicy;
     58   original: PublicRecordHandle;
     59   operation: IdentityPublicOperation;
     60   id: string;
     61   actionId: string;
     62   lookup: Lookup;
     63   retry: boolean;
     64   control: AbortController;
     65   running(): boolean;
     66   markRunning(): void;
     67 }>;
     68 const actions = new WeakMap<InboxPreferenceAction, Saved>();
     69 type Prepared =
     70   | Readonly<{ status: 'prepared'; action: InboxPreferenceAction }>
     71   | Readonly<{ status: 'invalid' | 'unavailable' | 'conflict' | 'unknown' }>;
     72 function retain(
     73   repository: PublicQuotaRepository,
     74   identity: IdentitySession,
     75   policy: RelayPolicy,
     76   original: PublicRecordHandle,
     77   id: string,
     78   lookup: Lookup,
     79   retry: boolean
     80 ): Prepared {
     81   const operation = captureIdentityPublicOperation(
     82     identity,
     83     original,
     84     id,
     85     'reviewed_captured_operation'
     86   );
     87   if (!operation || typeof lookup !== 'function')
     88     return { status: 'unavailable' };
     89   let used = false;
     90   const action = Object.freeze({}) as InboxPreferenceAction;
     91   actions.set(action, {
     92     repository,
     93     identity,
     94     policy,
     95     original,
     96     operation,
     97     id,
     98     actionId: crypto.randomUUID(),
     99     lookup,
    100     retry,
    101     control: new AbortController(),
    102     running: () => used,
    103     markRunning: () => {
    104       used = true;
    105     }
    106   });
    107   return { status: 'prepared', action };
    108 }
    109 // Original opaque065 review only. This does not auto-run after connect/setup.
    110 export async function beginInboxPreferenceOperation(
    111   repository: PublicQuotaRepository,
    112   identity: IdentitySession,
    113   policy: RelayPolicy,
    114   review: InboxSetupReview,
    115   command: unknown,
    116   lookup: Lookup,
    117   consent: unknown
    118 ): Promise<Prepared> {
    119   try {
    120     const id = canonicalLocalId(command),
    121       owner = identityMessagingOwnership(identity);
    122     if (!id || !owner || publicQuotaOwner(repository) !== owner.owner)
    123       return { status: 'unavailable' };
    124     const resolver = await lookup(),
    125       captured = captureInboxSetup(review, resolver, id, consent);
    126     if (captured.status !== 'captured') return captured;
    127     if (captured.owner !== owner.owner || !owner.current())
    128       return { status: 'unavailable' };
    129     return retain(
    130       repository,
    131       identity,
    132       policy,
    133       captured.record,
    134       id,
    135       lookup,
    136       false
    137     );
    138   } catch {
    139     return { status: 'unavailable' };
    140   }
    141 }
    142 // Explicit reload review of the actual stored signed operation, with full
    143 // original capture retained. Unsigned uncertainty cannot become a fresh plan.
    144 export async function resumeInboxPreferenceOperation(
    145   repository: PublicQuotaRepository,
    146   identity: IdentitySession,
    147   policy: RelayPolicy,
    148   command: unknown,
    149   lookup: Lookup,
    150   consent: unknown
    151 ): Promise<Prepared> {
    152   try {
    153     if (consent !== 'reviewed_stored_inbox_preference')
    154       return { status: 'invalid' };
    155     const id = canonicalLocalId(command);
    156     await recheckIdentityOwner(identity);
    157     const owner = identityMessagingOwnership(identity);
    158     if (!id || !owner || publicQuotaOwner(repository) !== owner.owner)
    159       return { status: 'unavailable' };
    160     const read = await loadPreferenceOperation(repository, id);
    161     if (!read.ok) return { status: 'unavailable' };
    162     const row = publicRecordSnapshot(read.value, owner.owner, id);
    163     if (row?.family !== 'preference_operation') return { status: 'invalid' };
    164     if (row.revision < 2 || !row.artifact) return { status: 'unknown' };
    165     const fingerprint = await preferencePolicyFingerprint(policy),
    166       resolver = await lookup();
    167     if (
    168       !operationEnabled(policy, 'messaging') ||
    169       row.capture.policyFingerprint !== fingerprint ||
    170       JSON.stringify(row.capture.targets) !==
    171         JSON.stringify(publicRelayTargets(policy, 'write')) ||
    172       !inboxSetupRecordCurrent(read.value, owner.owner, id, resolver, policy) ||
    173       !owner.current()
    174     )
    175       return { status: 'conflict' };
    176     // Historical original signing wire for lease matching only; never written
    177     // back, never a reset. The effect runner uses the actual stored artifact.
    178     const original = decodePublicRecord(
    179       JSON.stringify({ ...row, revision: 0, artifact: null, receipts: [] }),
    180       owner.owner,
    181       id
    182     );
    183     return original.ok
    184       ? retain(repository, identity, policy, original.value, id, lookup, true)
    185       : { status: 'invalid' };
    186   } catch {
    187     return { status: 'unavailable' };
    188   }
    189 }
    190 async function acknowledged(
    191   repository: PublicQuotaRepository,
    192   transition: PublicOperationTransition
    193 ): Promise<boolean> {
    194   const result = await commitPublicOperationTransition(repository, transition);
    195   return (
    196     result.ok &&
    197     (await observePublicOperationTransition(repository, transition)).state ===
    198       'committed'
    199   );
    200 }
    201 async function knownBase(saved: Saved): Promise<(() => boolean) | undefined> {
    202   const owner = identityMessagingOwnership(saved.identity);
    203   const operation = identityPublicOperationOwnership(
    204     saved.identity,
    205     saved.operation
    206   );
    207   if (!owner || !operation || saved.control.signal.aborted) return undefined;
    208   const stored = await loadPreferenceOperation(saved.repository, saved.id);
    209   if (!stored.ok) return undefined;
    210   const resolver = await saved.lookup();
    211   const current = () =>
    212     !saved.control.signal.aborted &&
    213     operation.current() &&
    214     owner.current() &&
    215     inboxSetupRecordCurrent(
    216       stored.value,
    217       owner.owner,
    218       saved.id,
    219       resolver,
    220       saved.policy
    221     );
    222   return current() ? current : undefined;
    223 }
    224 export async function runInboxPreferenceOperation(
    225   action: InboxPreferenceAction
    226 ): Promise<PreferencePublicationResult> {
    227   const saved = actions.get(action);
    228   if (!saved) return { status: 'invalid' };
    229   if (saved.running() || saved.control.signal.aborted)
    230     return { status: 'stopped' };
    231   saved.markRunning();
    232   const capture = identityPublicOperationOwnership(
    233     saved.identity,
    234     saved.operation
    235   );
    236   if (!capture) return { status: 'stopped' };
    237   const messagingOwner = identityMessagingOwnership(saved.identity);
    238   if (
    239     !messagingOwner ||
    240     messagingOwner.owner !== capture.owner ||
    241     messagingOwner.session !== capture.session
    242   )
    243     return { status: 'stopped' };
    244   if (!capture.current() || saved.control.signal.aborted)
    245     return { status: 'stopped' };
    246   const invalidate = subscribeIdentityInvalidation(saved.identity, () => {
    247     // Notifications also describe pending/completed observations. Only actual
    248     // owner/capability/generation loss cancels this original explicit action.
    249     if (!capture.current() || !messagingOwner.current()) saved.control.abort();
    250   });
    251   try {
    252     const result = await runCapturedPublicEffect<PreferencePublicationResult>(
    253       saved.repository,
    254       saved.original,
    255       saved.id,
    256       {
    257         ...capture,
    258         current: () => capture.current() && !saved.control.signal.aborted
    259       },
    260       saved.retry
    261         ? 'reviewed_stored_preference_retry'
    262         : 'reviewed_prepared_preference_operation',
    263       async (lease: PublicEffectLease, claimed: PublicRecordHandle) => {
    264         if (!(await knownBase(saved))) return { status: 'stopped' };
    265         const row = publicRecordSnapshot(claimed, capture.owner, saved.id);
    266         if (row?.family !== 'preference_operation')
    267           return { status: 'invalid' };
    268         if (
    269           !operationEnabled(saved.policy, 'messaging') ||
    270           row.capture.policyFingerprint !==
    271             (await preferencePolicyFingerprint(saved.policy)) ||
    272           JSON.stringify(row.capture.targets) !==
    273             JSON.stringify(publicRelayTargets(saved.policy, 'write'))
    274         )
    275           return { status: 'stopped' };
    276         if (!capture.current() || saved.control.signal.aborted)
    277           return { status: 'stopped' };
    278         if (!row.artifact) {
    279           const marker = preparePreferenceSigningTransition(
    280             claimed,
    281             capture.owner,
    282             saved.id
    283           );
    284           if (
    285             !marker.ok ||
    286             !(await acknowledged(saved.repository, marker.value))
    287           )
    288             return { status: 'storage_failed' };
    289           if (!(await knownBase(saved))) return { status: 'stopped' };
    290           const signed = await signIdentityPublicOperation(
    291             saved.identity,
    292             saved.operation,
    293             lease
    294           );
    295           if (signed.status !== 'signed') return { status: 'stopped' };
    296           const pending = await loadPreferenceOperation(
    297             saved.repository,
    298             saved.id
    299           );
    300           if (!pending.ok) return { status: 'storage_failed' };
    301           if (!capture.current() || saved.control.signal.aborted)
    302             return { status: 'stopped' };
    303           const transition = preparePublicArtifactTransition(
    304             pending.value,
    305             capture.owner,
    306             saved.id,
    307             signed.artifact
    308           );
    309           if (
    310             !transition.ok ||
    311             !(await acknowledged(saved.repository, transition.value))
    312           )
    313             return { status: 'storage_failed' };
    314         }
    315         if (saved.control.signal.aborted || !capture.current())
    316           return { status: 'stopped' };
    317         const pool = getPublicPool(saved.policy);
    318         if (!pool) return { status: 'stopped' };
    319         return await publishInboxPreference(
    320           saved.repository,
    321           capture.owner,
    322           saved.id,
    323           saved.actionId,
    324           pool,
    325           saved.policy,
    326           saved.control.signal,
    327           () =>
    328             authorizeStoredInboxPreference(
    329               saved.repository,
    330               saved.identity,
    331               saved.operation,
    332               lease,
    333               saved.original,
    334               saved.id,
    335               saved.policy,
    336               () => knownBase(saved)
    337             )
    338         );
    339       }
    340     );
    341     return result.status === 'completed' ? result.value : { status: 'stopped' };
    342   } catch {
    343     return { status: 'stopped' };
    344   } finally {
    345     invalidate();
    346   }
    347 }
    348 export function stopInboxPreferenceOperation(
    349   action: InboxPreferenceAction
    350 ): void {
    351   const saved = actions.get(action);
    352   if (!saved) return;
    353   saved.control.abort();
    354   stopIdentityPublicOperation(saved.identity, saved.operation);
    355 }