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 }