reply-controller.ts (16299B)
1 import { inboxReplyOwnership, type InboxView } from './inbox-view.ts'; 2 import { inboxSetupViewOwnership } from './inbox-setup-view.ts'; 3 import { messagingReadinessSnapshot } from './readiness.ts'; 4 import { operationEnabled } from '../config/operation-flags.ts'; 5 import { 6 createInboxRoutePlan, 7 inboxRoutePlanSnapshot 8 } from './inbox-routing.ts'; 9 import { 10 resolveInboxPreference, 11 closeInboxResolver, 12 type InboxResolver 13 } from './resolve-inbox.ts'; 14 import { 15 createPublicView, 16 beginPublicViewRun, 17 publicViewRunCurrent, 18 disposePublicView, 19 type PublicRuntime 20 } from '../runtime/public-runtime.ts'; 21 import { 22 createPrivateComposer, 23 privateComposerText, 24 privateComposerSnapshot, 25 updatePrivateComposerText, 26 bindPrivateComposerPreparation, 27 closePrivateComposer 28 } from './composer-state.ts'; 29 import { 30 captureDirtyNavigation, 31 requestPrivateNavigation, 32 confirmDiscardNavigation, 33 keepPrivateEditing, 34 dirtyNavigationSnapshot, 35 privateNavigationBeforeUnload 36 } from '../runtime/dirty-navigation.ts'; 37 import { 38 captureAuthenticatedReplyRumor, 39 stopRumorPlan, 40 type RumorPlan 41 } from './rumor-plan.ts'; 42 import { createPrivateSendReservationRepository } from '../persistence/private-send-reservations.ts'; 43 import { reserveSendIdentity } from './send-identity.ts'; 44 import { 45 captureSelfRecoveryPreparation, 46 prepareSelfRecovery, 47 preparedSelfRecovery, 48 preparePairedDelivery, 49 preparedPairedDelivery, 50 selfRecoveryPreparationSnapshot, 51 type SelfRecoveryPreparation 52 } from './prepare-send.ts'; 53 import { 54 getPrivatePool, 55 closePrivatePool, 56 privatePoolCleanupRequired, 57 type PrivatePool 58 } from '../nostr/private-pool.ts'; 59 import { 60 capturePrivateRetry, 61 runPrivateRetry, 62 stopPrivateRetry, 63 type PrivateRetry 64 } from './retry-send.ts'; 65 import { newLocalId } from '../private-handles.ts'; 66 import { subscribeIdentityInvalidation } from '../runtime/identity-session.ts'; 67 import { subscribePrivateSessionClose } from '../runtime/private-session.ts'; 68 69 declare const replyBrand: unique symbol; 70 export type ReplyController = Readonly<{ [replyBrand]: true }>; 71 type Result = Readonly<{ 72 status: 'invalid' | 'busy' | 'stopped' | 'needs_action' | 'completed'; 73 }>; 74 type Options = Readonly<{ 75 lookupPeer?(peer: string): Promise<InboxResolver>; 76 close?(): void; 77 }>; 78 type State = 79 | 'idle' 80 | 'checking' 81 | 'preparing' 82 | 'publishing' 83 | 'needs_action' 84 | 'completed'; 85 type Snapshot = Readonly<{ 86 state: State; 87 readyToSend: boolean; 88 busy: boolean; 89 dirty: boolean; 90 copy: string; 91 saveCopy: string; 92 pairCopy: string; 93 navigation: 'idle' | 'confirmation_required'; 94 }>; 95 type Controller = { 96 snapshot(): Snapshot | undefined; 97 text(): string | undefined; 98 update(text: unknown, review: unknown): boolean; 99 select(parent: unknown, review: unknown): boolean; 100 send(review: unknown): Promise<Result>; 101 request(): ReturnType<typeof requestPrivateNavigation>; 102 keep(): boolean; 103 discard(review: unknown): ReturnType<typeof confirmDiscardNavigation>; 104 unload(event: BeforeUnloadEvent): boolean; 105 close(): void; 106 }; 107 const controllers = new WeakMap<ReplyController, Controller>(); 108 109 // Allocating or typing a draft performs no SDK, native write or discovery. 110 // Caller hints are resolved through the original selected view's Room/cache. 111 export function createReplyController( 112 view: InboxView, 113 conversationId: unknown, 114 parent: unknown, 115 options: Options = {} 116 ): ReplyController | undefined { 117 if (typeof window === 'undefined') return; 118 let scope = inboxReplyOwnership(view, conversationId, parent); 119 if (!scope?.current()) return; 120 const original = scope, 121 composer = createPrivateComposer( 122 original.identity, 123 'reviewed_private_composer' 124 ); 125 const navigation = composer && captureDirtyNavigation(composer); 126 if (!composer || !navigation) { 127 if (composer) closePrivateComposer(composer); 128 return; 129 } 130 let active = true, 131 busy = false, 132 state: State = 'idle', 133 copy = '', 134 attempted = false; 135 let plan: RumorPlan | undefined, 136 preparation: SelfRecoveryPreparation | undefined, 137 retry: PrivateRetry | undefined; 138 let identityOff = () => {}, 139 privateOff = () => {}; 140 let pool: PrivatePool | undefined; 141 let poolCleanupFailed = false; 142 function releasePool() { 143 if (!pool) return true; 144 try { 145 poolCleanupFailed = false; 146 closePrivatePool(pool); 147 if (privatePoolCleanupRequired(pool)) return false; 148 pool = undefined; 149 return true; 150 } catch { 151 poolCleanupFailed = true; 152 return false; 153 } 154 } 155 function close(sessionCleanup = false) { 156 if (!active && !pool) return; 157 active = false; 158 if (retry) stopPrivateRetry(retry); 159 closePrivateComposer(composer!); 160 if (plan) stopRumorPlan(plan); 161 const clean = releasePool(); 162 options.close?.(); 163 if (!clean) { 164 if (poolCleanupFailed || sessionCleanup) 165 throw Error('private_delivery_cleanup_required'); 166 return; 167 } 168 identityOff(); 169 privateOff(); 170 } 171 function current() { 172 if (!active || !scope?.current() || !privateComposerSnapshot(composer!)) { 173 try { 174 close(); 175 } catch { 176 /* Exact original disposal stays retryable. */ 177 } 178 return false; 179 } 180 return true; 181 } 182 function snapshot(): Snapshot | undefined { 183 if (!current()) return; 184 const draft = privateComposerSnapshot(composer!), 185 workflow = preparation && selfRecoveryPreparationSnapshot(preparation); 186 if (!draft) return; 187 return { 188 state, 189 readyToSend: 190 !attempted && 191 operationEnabled( 192 inboxSetupViewOwnership(scope!.setup)?.policy, 193 'messaging' 194 ), 195 busy, 196 dirty: draft.dirty, 197 copy: 198 copy || 199 (!operationEnabled( 200 inboxSetupViewOwnership(scope!.setup)?.policy, 201 'messaging' 202 ) 203 ? 'Messaging is disabled in this build. Keep your unsent draft and review existing encrypted work separately.' 204 : state === 'preparing' 205 ? 'Preparing encryption. The extension may ask for several approvals.' 206 : state === 'publishing' 207 ? 'Publishing encrypted copies to the reviewed inbox relays.' 208 : ''), 209 saveCopy: draft.copy, 210 pairCopy: workflow?.pairCopy ?? draft.pairCopy, 211 navigation: dirtyNavigationSnapshot(navigation!)?.state ?? 'idle' 212 }; 213 } 214 async function send(review: unknown): Promise<Result> { 215 if (review !== 'reviewed_reply_send') return { status: 'invalid' }; 216 if (!current()) return { status: 'stopped' }; 217 if (busy) return { status: 'busy' }; 218 if ( 219 !operationEnabled( 220 inboxSetupViewOwnership(scope!.setup)?.policy, 221 'messaging' 222 ) 223 ) { 224 state = 'needs_action'; 225 copy = 226 'Messaging is disabled in this build. Your unsent text remains in memory; existing encrypted work needs its own recovery review.'; 227 return { status: 'needs_action' }; 228 } 229 const text = privateComposerText(composer!); 230 if (!text?.trim()) return { status: 'invalid' }; 231 if (attempted) return { status: 'needs_action' }; 232 busy = true; 233 state = 'checking'; 234 copy = 235 'Checking the authenticated peer inbox. Your text remains in memory.'; 236 const captured = scope!; 237 const admitted = () => current() && scope === captured; 238 function needsAction(definitePreEffect = false): Result { 239 state = attempted || !definitePreEffect ? 'needs_action' : 'idle'; 240 if (!attempted) { 241 if (plan) stopRumorPlan(plan); 242 plan = undefined; 243 } 244 copy = attempted 245 ? 'Send needs review. Keep this draft; check inbox setup or connection, then explicitly send again. Existing encrypted work needs its own recovery review.' 246 : 'No private send was reserved. Your text stays in memory. Review inbox setup or storage, then explicitly try Send again.'; 247 return { status: 'needs_action' }; 248 } 249 try { 250 const setup = inboxSetupViewOwnership(captured.setup); 251 if (!setup?.current() || !setup.resolver || !options.lookupPeer) 252 return needsAction(); 253 const other = await options.lookupPeer(captured.peer); 254 if (!admitted()) return { status: 'stopped' }; 255 if ( 256 !messagingReadinessSnapshot( 257 captured.identity, 258 captured.session, 259 setup.policy, 260 setup.resolver, 261 { author: captured.peer, resolver: other }, 262 setup.observeAccess 263 ).sendReady || 264 !admitted() 265 ) 266 return needsAction(); 267 const routes = createInboxRoutePlan( 268 setup.policy, 269 captured.owner, 270 captured.peer, 271 setup.resolver, 272 other 273 ); 274 const routeData = routes && inboxRoutePlanSnapshot(routes); 275 const reservations = createPrivateSendReservationRepository( 276 captured.database, 277 captured.owner 278 ); 279 if (!routes || !routeData || !reservations || !admitted()) 280 return needsAction(); 281 plan = captureAuthenticatedReplyRumor( 282 captured.identity, 283 captured.session, 284 captured.unlocked, 285 captured.room, 286 text, 287 Math.floor(Date.now() / 1000) 288 ); 289 const command = newLocalId(); 290 if (!plan || !command || !admitted()) return needsAction(true); 291 // After a native intent may exist, repeated Send never creates another 292 // rumor or silently replays this command. Recovery has its own owner. 293 attempted = true; 294 const reserved = await reserveSendIdentity( 295 reservations, 296 captured.identity, 297 command, 298 plan, 299 'reviewed_private_intent' 300 ); 301 if (!admitted()) return { status: 'stopped' }; 302 if (!('identity' in reserved)) { 303 if (reserved.disposition !== 'not_created') return needsAction(); 304 attempted = false; 305 return needsAction(true); 306 } 307 preparation = captureSelfRecoveryPreparation( 308 captured.repository, 309 captured.identity, 310 reserved.identity, 311 'reviewed_self_recovery' 312 ); 313 if ( 314 !preparation || 315 !bindPrivateComposerPreparation( 316 composer!, 317 reserved.identity, 318 preparation, 319 undefined, 320 'reviewed_composer_preparation' 321 ) 322 ) 323 return needsAction(); 324 state = 'preparing'; 325 copy = ''; 326 const self = await prepareSelfRecovery( 327 preparation, 328 'reviewed_self_recovery' 329 ); 330 if (!admitted()) return { status: 'stopped' }; 331 const saved = preparedSelfRecovery(preparation); 332 if ( 333 !['saved', 'existing', 'reconciled'].includes(self.status) || 334 !saved || 335 !(await captured.acceptLocalReply(saved, 'reviewed_local_reply')) || 336 !admitted() 337 ) 338 return needsAction(); 339 const context = { 340 plan: routes, 341 policy: setup.policy, 342 own: setup.resolver, 343 other 344 }; 345 const paired = await preparePairedDelivery( 346 preparation, 347 context, 348 'reviewed_pair_preparation' 349 ); 350 if (!admitted()) return { status: 'stopped' }; 351 const receipt = preparedPairedDelivery(preparation); 352 if ( 353 !['prepared', 'existing', 'reconciled'].includes(paired.status) || 354 !receipt 355 ) 356 return needsAction(); 357 const origins = Array.from( 358 new Set([...routeData.peer.targets, ...routeData.archive.targets]) 359 ); 360 if (!releasePool()) return needsAction(); 361 pool = getPrivatePool( 362 captured.session, 363 setup.policy, 364 origins, 365 token, 366 'delivery', 367 admitted 368 ); 369 if (!pool || !admitted()) return needsAction(); 370 retry = capturePrivateRetry( 371 captured.repository, 372 captured.session, 373 receipt, 374 context, 375 pool, 376 'reviewed_private_retry' 377 ); 378 if (!retry || !admitted()) return needsAction(); 379 state = 'publishing'; 380 const delivered = await runPrivateRetry(retry, 'reviewed_private_retry'); 381 if (!admitted()) return { status: 'stopped' }; 382 if (delivered.status !== 'completed') return needsAction(); 383 state = 'completed'; 384 copy = 385 'Accepted by recipient inbox relay. This does not confirm that the person read the message.'; 386 return { status: 'completed' }; 387 } catch { 388 return current() ? needsAction() : { status: 'stopped' }; 389 } finally { 390 busy = false; 391 releasePool(); 392 } 393 } 394 const token = Object.freeze({}) as ReplyController; 395 controllers.set(token, { 396 snapshot, 397 text: () => (current() ? privateComposerText(composer) : undefined), 398 update: (text, review) => 399 current() && 400 !busy && 401 !attempted && 402 updatePrivateComposerText(composer, text, review), 403 select(parent, review) { 404 if (review !== 'reviewed_reply_parent' || !current() || busy || attempted) 405 return false; 406 const selected = inboxReplyOwnership(view, conversationId, parent); 407 if ( 408 !selected?.current() || 409 selected.identity !== original.identity || 410 selected.session !== original.session || 411 selected.peer !== original.peer 412 ) 413 return false; 414 scope = selected; 415 return true; 416 }, 417 send, 418 request: () => 419 current() ? requestPrivateNavigation(navigation) : 'invalid', 420 keep: () => current() && keepPrivateEditing(navigation), 421 discard: (review) => 422 current() ? confirmDiscardNavigation(navigation, review) : 'invalid', 423 unload: (event) => 424 current() && privateNavigationBeforeUnload(navigation, event), 425 close 426 }); 427 identityOff = subscribeIdentityInvalidation(original.identity, () => { 428 if (!original.current()) close(); 429 }); 430 privateOff = subscribePrivateSessionClose(original.session, () => 431 close(true) 432 ); 433 return current() ? token : undefined; 434 } 435 436 export function createRuntimeReplyController( 437 view: InboxView, 438 id: unknown, 439 parent: unknown, 440 runtime: PublicRuntime 441 ): ReplyController | undefined { 442 const publicView = createPublicView(runtime); 443 let resolver: InboxResolver | undefined, 444 run: ReturnType<typeof beginPublicViewRun> | undefined; 445 const token = createReplyController(view, id, parent, { 446 lookupPeer: (peer) => { 447 // Only this explicit Send lookup may renew an expired run. An active 448 // lookup retains its original bounded work, including pending results. 449 if (!resolver || !run || !publicViewRunCurrent(publicView, run)) { 450 if (resolver) closeInboxResolver(resolver); 451 resolver = undefined; 452 run = beginPublicViewRun(publicView); 453 resolver = resolveInboxPreference(publicView, run, peer); 454 } 455 return Promise.resolve(resolver); 456 }, 457 close: () => { 458 if (resolver) closeInboxResolver(resolver); 459 disposePublicView(publicView); 460 } 461 }); 462 if (!token) disposePublicView(publicView); 463 return token; 464 } 465 export function replySnapshot(token: ReplyController) { 466 return controllers.get(token)?.snapshot(); 467 } 468 export function replyText(token: ReplyController) { 469 return controllers.get(token)?.text(); 470 } 471 export function updateReplyText( 472 token: ReplyController, 473 text: unknown, 474 review: unknown 475 ) { 476 return controllers.get(token)?.update(text, review) ?? false; 477 } 478 export function selectReplyParent( 479 token: ReplyController, 480 parent: unknown, 481 review: unknown 482 ) { 483 return controllers.get(token)?.select(parent, review) ?? false; 484 } 485 export function sendReply( 486 token: ReplyController, 487 review: unknown 488 ): Promise<Result> { 489 return ( 490 controllers.get(token)?.send(review) ?? 491 Promise.resolve({ status: 'invalid' }) 492 ); 493 } 494 export function requestReplyNavigation(token: ReplyController) { 495 return controllers.get(token)?.request() ?? 'invalid'; 496 } 497 export function keepReplyEditing(token: ReplyController) { 498 return controllers.get(token)?.keep() ?? false; 499 } 500 export function discardReplyNavigation( 501 token: ReplyController, 502 review: unknown 503 ) { 504 return controllers.get(token)?.discard(review) ?? 'invalid'; 505 } 506 export function replyBeforeUnload( 507 token: ReplyController, 508 event: BeforeUnloadEvent 509 ) { 510 return controllers.get(token)?.unload(event) ?? false; 511 } 512 export function closeReplyController(token: ReplyController) { 513 controllers.get(token)?.close(); 514 }