app

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

inbox-retention.ts (6813B)


      1 import { LOCAL_PERSISTENCE_BUDGETS } from '../config/budgets.ts';
      2 import {
      3   privateSessionOwnership,
      4   subscribePrivateSessionClose,
      5   type PrivateSession
      6 } from '../runtime/private-session.ts';
      7 import {
      8   privateRecordIdentity,
      9   privateRecordWire,
     10   type PrivateRecordHandle
     11 } from './private-records.ts';
     12 import {
     13   listPrivateReceivedRecords,
     14   removePrivateReceivedRecords,
     15   type PrivateStorageRepository,
     16   type PrivateStorageFailure
     17 } from './private-storage.ts';
     18 declare const cleanupBrand: unique symbol;
     19 export type ReceivedCleanup = Readonly<{ [cleanupBrand]: true }>;
     20 type Result = Readonly<{
     21   status: 'removed' | 'invalid' | 'busy' | 'stopped' | PrivateStorageFailure;
     22   removed?: number;
     23 }>;
     24 type Snapshot = Readonly<{
     25   owner: string;
     26   state: 'review' | 'running' | 'removed' | 'needs_action' | 'stopped';
     27   selected: number;
     28   bytes: number;
     29   ids: readonly string[];
     30   localCopyLoss: true;
     31   relayRecovery: 'not_guaranteed';
     32   outbox: 'unchanged';
     33   reason: string | null;
     34 }>;
     35 type Controller = {
     36   run(review: unknown): Promise<Result>;
     37   snapshot(): Snapshot;
     38   stop(): void;
     39 };
     40 const actions = new WeakMap<ReceivedCleanup, Controller>();
     41 // Complete bounded selection, copied before admission. IDs alone are not
     42 // effect authority and no malformed tail is silently truncated.
     43 export function selectReceivedCleanupIds(value: unknown): string[] | undefined {
     44   try {
     45     if (
     46       !Array.isArray(value) ||
     47       !value.length ||
     48       value.length > LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes
     49     )
     50       return undefined;
     51     const copy: Array<unknown> = Array.from(value);
     52     if (!copy.every((x) => typeof x === 'string' && /^[0-9a-f]{64}$/.test(x)))
     53       return undefined;
     54     return [...new Set(copy as string[])];
     55   } catch {
     56     return undefined;
     57   }
     58 }
     59 // Explicit local-copy loss preview only, no delete/SDK/network operation.
     60 // Genuine installed original private generation owns this opaque action;
     61 // remembered owner strings and copied previews cannot grant deletion.
     62 export async function captureReceivedCleanup(
     63   repository: PrivateStorageRepository,
     64   session: PrivateSession,
     65   selection: unknown,
     66   review: unknown
     67 ): Promise<ReceivedCleanup | undefined> {
     68   if (
     69     typeof window === 'undefined' ||
     70     review !== 'reviewed_received_cleanup_selection' ||
     71     !navigator.locks?.request
     72   )
     73     return undefined;
     74   const ids = selectReceivedCleanupIds(selection),
     75     observed = privateSessionOwnership(session);
     76   if (!ids || !observed?.current()) return undefined;
     77   const ownership = observed;
     78   try {
     79     const scan = await listPrivateReceivedRecords(repository);
     80     if (!scan.ok || !ownership.current()) return undefined;
     81     let selected = Array.from<PrivateRecordHandle>([]),
     82       bytes = 0;
     83     for (const id of ids) {
     84       const row = scan.value.find((h) => privateRecordIdentity(h)?.id === id),
     85         identity = row && privateRecordIdentity(row),
     86         wire = row && privateRecordWire(row, ownership.owner, id);
     87       if (!row || identity?.owner !== ownership.owner || !wire)
     88         return undefined;
     89       selected = selected.concat(row);
     90       bytes += new TextEncoder().encode(
     91         JSON.stringify({ owner: ownership.owner, id, wire })
     92       ).length;
     93     }
     94     const token = Object.freeze({}) as ReceivedCleanup;
     95     const cancellation = new AbortController();
     96     let state: Snapshot['state'] = 'review',
     97       reason: string | null = null,
     98       used = false,
     99       stopped = false;
    100     let off = () => {};
    101     function stop() {
    102       if (stopped) return;
    103       stopped = true;
    104       cancellation.abort();
    105       state = 'stopped';
    106       selected = [];
    107       off();
    108     }
    109     actions.set(token, {
    110       snapshot: () => ({
    111         owner: ownership.owner,
    112         state,
    113         selected: ids.length,
    114         bytes,
    115         ids: ids.slice(),
    116         localCopyLoss: true,
    117         relayRecovery: 'not_guaranteed',
    118         outbox: 'unchanged',
    119         reason
    120       }),
    121       stop,
    122       async run(reviewed) {
    123         if (stopped || !ownership.current()) return { status: 'stopped' };
    124         if (reviewed !== 'reviewed_delete_local_received_copies' || used)
    125           return { status: 'invalid' };
    126         used = true;
    127         state = 'running';
    128         const original = selected.slice();
    129         let result: Result;
    130         try {
    131           result = await navigator.locks.request(
    132             'harvestcircle:owner:' + ownership.owner,
    133             { mode: 'exclusive', ifAvailable: true },
    134             async (lock): Promise<Result> => {
    135               if (!lock) return { status: 'busy' };
    136               if (stopped || !ownership.current()) return { status: 'stopped' };
    137               const committed = await removePrivateReceivedRecords(
    138                 repository,
    139                 session,
    140                 original,
    141                 'reviewed_delete_local_received_copies',
    142                 cancellation.signal
    143               );
    144               if (!committed.ok)
    145                 return {
    146                   status:
    147                     committed.reason === 'invalid_scope' &&
    148                     (stopped || !ownership.current())
    149                       ? 'stopped'
    150                       : committed.reason
    151                 };
    152               // Native complete precedes this fresh strict RO absence verification.
    153               // A failed readback or owner loss cannot establish definite no deletion.
    154               const readback = await listPrivateReceivedRecords(repository);
    155               if (
    156                 !readback.ok ||
    157                 stopped ||
    158                 !ownership.current() ||
    159                 readback.value.some((h) =>
    160                   ids.includes(privateRecordIdentity(h)?.id ?? '')
    161                 )
    162               )
    163                 return { status: 'unknown_completion' };
    164               return { status: 'removed', removed: committed.value.removed };
    165             }
    166           );
    167         } catch {
    168           result = { status: 'unknown_completion' };
    169         }
    170         reason = result.status === 'removed' ? null : result.status;
    171         if (!stopped)
    172           state = result.status === 'removed' ? 'removed' : 'needs_action';
    173         selected = [];
    174         off();
    175         return result;
    176       }
    177     });
    178     off = subscribePrivateSessionClose(session, stop);
    179     if (!ownership.current()) {
    180       stop();
    181       return undefined;
    182     }
    183     return token;
    184   } catch {
    185     return undefined;
    186   }
    187 }
    188 export function receivedCleanupSnapshot(
    189   token: ReceivedCleanup
    190 ): Snapshot | undefined {
    191   return actions.get(token)?.snapshot();
    192 }
    193 export function deleteReviewedReceivedCopies(
    194   token: ReceivedCleanup,
    195   review: unknown
    196 ): Promise<Result> {
    197   return (
    198     actions.get(token)?.run(review) ?? Promise.resolve({ status: 'invalid' })
    199   );
    200 }
    201 export function stopReceivedCleanup(token: ReceivedCleanup): void {
    202   actions.get(token)?.stop();
    203 }