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 }