inbox-setup-view.ts (18570B)
1 import { operationEnabled } from '../config/operation-flags.ts'; 2 import { 3 readRelayPolicy, 4 inboxRelayTargets, 5 type RelayPolicy 6 } from '../config/relays.ts'; 7 import { deploymentRelayPolicy } from '../config/deployment-relays.ts'; 8 import { 9 identityMessagingOwnership, 10 subscribeIdentityInvalidation, 11 type IdentitySession 12 } from '../runtime/identity-session.ts'; 13 import { 14 createPrivateSession, 15 closePrivateSession, 16 type PrivateSession 17 } from '../runtime/private-session.ts'; 18 import { 19 identityViewSession, 20 type IdentityViewContext 21 } from '../runtime/view-context.ts'; 22 import { 23 createPublicView, 24 beginPublicViewRun, 25 disposePublicView, 26 type PublicRuntime 27 } from '../runtime/public-runtime.ts'; 28 import { 29 resolveInboxPreference, 30 settleInboxResolver, 31 inboxResolutionSnapshot, 32 closeInboxResolver, 33 type InboxResolver 34 } from './resolve-inbox.ts'; 35 import { 36 inboxPreferenceSnapshot, 37 inboxPreferenceWire 38 } from '../nostr/inbox-preferences.ts'; 39 import { 40 reviewInboxSetup, 41 inboxSetupPreview, 42 type InboxSetupReview 43 } from './inbox-setup.ts'; 44 import { 45 beginInboxPreferenceOperation, 46 runInboxPreferenceOperation, 47 stopInboxPreferenceOperation, 48 type InboxPreferenceAction 49 } from './inbox-setup-operation.ts'; 50 import { 51 openBrowserDatabase, 52 closeBrowserDatabase, 53 type BrowserDatabase 54 } from '../persistence/database.ts'; 55 import { 56 createPublicQuotaRepository, 57 loadPreferenceOperation, 58 type PublicQuotaRepository 59 } from '../persistence/quota.ts'; 60 import { 61 publicRecordSnapshot, 62 type PublicRecordHandle 63 } from '../persistence/records.ts'; 64 import { 65 resolveInboxReadback, 66 inboxReadbackSnapshot, 67 closeInboxReadback, 68 type InboxReadback 69 } from '../nostr/inbox-readback.ts'; 70 import { 71 existingInboxSetupSnapshot, 72 verifyInboxSetupOperation 73 } from './inbox-setup-verification.ts'; 74 import type { ObserveInboxAccess } from './readiness.ts'; 75 declare const viewBrand: unique symbol; 76 export type InboxSetupView = Readonly<{ [viewBrand]: true }>; 77 export type InboxSetupViewSnapshot = Readonly<{ 78 status: string; 79 busy: boolean; 80 owner?: string; 81 currentWire: string | null; 82 existingInboxes: string[]; 83 availableInboxes: string[]; 84 preview?: NonNullable<ReturnType<typeof inboxSetupPreview>>; 85 accepted: string[]; 86 readback: string[]; 87 setupComplete: boolean; 88 }>; 89 // Internal trusted orchestration ports require real opaque discovery/readback 90 // owners. Neither displayed facts nor caller booleans admit a preference effect. 91 type Inputs = Readonly<{ 92 identity: IdentitySession; 93 policy: RelayPolicy; 94 lookup(current?: () => boolean): Promise<InboxResolver>; 95 readback?( 96 record: PublicRecordHandle, 97 owner: string, 98 id: string 99 ): InboxReadback | undefined; 100 observeAccess?: ObserveInboxAccess; 101 now?(): number; 102 close?(): void; 103 }>; 104 type Controller = { 105 ownership(): 106 | Readonly<{ 107 identity: IdentitySession; 108 policy: RelayPolicy; 109 session: PrivateSession | undefined; 110 resolver: InboxResolver | undefined; 111 observeAccess: ObserveInboxAccess | undefined; 112 current(): boolean; 113 }> 114 | undefined; 115 observe(): void; 116 snapshot(): InboxSetupViewSnapshot; 117 subscribe(listener: (state: InboxSetupViewSnapshot) => void): () => void; 118 check(): Promise<void>; 119 review( 120 selected: string[], 121 removeTags: number[], 122 removeFields: string[] 123 ): Promise<void>; 124 enable(): Promise<void>; 125 unlock(): Promise<void>; 126 readback(): Promise<void>; 127 stop(): void; 128 close(): void; 129 }; 130 const views = new WeakMap<InboxSetupView, Controller>(); 131 const unavailable = (): InboxSetupViewSnapshot => ({ 132 status: 'unavailable', 133 busy: false, 134 currentWire: null, 135 existingInboxes: [], 136 availableInboxes: [], 137 accepted: [], 138 readback: [], 139 setupComplete: false 140 }); 141 export function createInboxSetupView( 142 input: Inputs 143 ): InboxSetupView | undefined { 144 if (typeof window === 'undefined') return undefined; 145 const initial = identityMessagingOwnership(input.identity); 146 if (!initial || !initial.current()) return undefined; 147 const capture = initial; 148 const manifest = readRelayPolicy(input.policy); 149 const available = manifest.inbox 150 .filter( 151 ({ read, write, origin }) => 152 read && write && !manifest.operatorDenylist.includes(origin) 153 ) 154 .map((row) => row.origin); 155 const token = Object.freeze({}) as InboxSetupView; 156 let state = { 157 ...unavailable(), 158 status: 'not_checked', 159 owner: capture.owner, 160 availableInboxes: available 161 }, 162 epoch = 0, 163 closed = false; 164 let pendingClose: (() => void)[] | undefined; 165 let resolver: InboxResolver | undefined, 166 review: InboxSetupReview | undefined, 167 action: InboxPreferenceAction | undefined, 168 database: BrowserDatabase | undefined, 169 repository: PublicQuotaRepository | undefined, 170 session: PrivateSession | undefined, 171 reader: InboxReadback | undefined, 172 command: string | undefined; 173 const listeners = new Map<symbol, (state: InboxSetupViewSnapshot) => void>(); 174 const current = (generation = epoch) => 175 !closed && generation === epoch && capture.current(); 176 const snapshot = () => { 177 if (closed) return { ...unavailable(), status: 'closed' }; 178 if (!capture.current()) return unavailable(); 179 return JSON.parse(JSON.stringify(state)) as InboxSetupViewSnapshot; 180 }; 181 function notify() { 182 for (const listener of listeners.values()) { 183 try { 184 listener(snapshot()); 185 } catch { 186 /* Isolate presentation observers. */ 187 } 188 } 189 } 190 function update(status: string, busy = state.busy) { 191 state = { ...state, status, busy }; 192 notify(); 193 } 194 function inspect() { 195 if (!resolver || !current()) return; 196 const observed = inboxResolutionSnapshot(resolver); 197 if (!current() || observed.author !== capture.owner) return; 198 const head = observed.head && inboxPreferenceSnapshot(observed.head); 199 state = { 200 ...state, 201 currentWire: observed.head 202 ? (inboxPreferenceWire(observed.head) ?? null) 203 : null, 204 existingInboxes: head?.relays.slice() ?? [], 205 setupComplete: false 206 }; 207 if ( 208 observed.coverage !== 'bounded-eose' || 209 observed.status === 'inconclusive' 210 ) { 211 update('lookup_incomplete'); 212 return; 213 } 214 const compatible = 215 head?.status === 'supported' && 216 inboxRelayTargets(input.policy, head.relays, 'read').length > 0 && 217 inboxRelayTargets(input.policy, head.relays, 'write').length > 0; 218 update( 219 compatible 220 ? 'compatible' 221 : observed.status === 'missing' 222 ? 'not_observed' 223 : 'needs_review' 224 ); 225 } 226 async function work( 227 status: string, 228 perform: (generation: number) => Promise<void> 229 ) { 230 if (!current() || state.busy) return; 231 const generation = epoch; 232 update(status, true); 233 if (!current(generation)) return; 234 try { 235 await perform(generation); 236 } catch { 237 if (current(generation)) update('unavailable'); 238 } finally { 239 if (current(generation)) { 240 state = { ...state, busy: false }; 241 notify(); 242 } 243 } 244 } 245 function stop() { 246 epoch++; 247 if (action) stopInboxPreferenceOperation(action); 248 review = undefined; 249 state = { ...state, preview: undefined, setupComplete: false }; 250 if (reader) closeInboxReadback(reader); 251 reader = undefined; 252 if (resolver) closeInboxResolver(resolver); 253 resolver = undefined; 254 update('paused', false); 255 } 256 const invalidate = subscribeIdentityInvalidation(input.identity, () => { 257 if (!capture.current()) stop(); 258 }); 259 views.set(token, { 260 ownership: () => 261 current() 262 ? { 263 identity: input.identity, 264 policy: input.policy, 265 session, 266 resolver, 267 observeAccess: input.observeAccess, 268 current: () => current() 269 } 270 : undefined, 271 observe() { 272 if (current() && !state.busy && state.status === 'lookup_incomplete') 273 inspect(); 274 }, 275 snapshot, 276 subscribe(listener) { 277 const id = Symbol(); 278 listeners.set(id, listener); 279 try { 280 listener(snapshot()); 281 } catch { 282 /* Isolate presentation observers. */ 283 } 284 return () => { 285 listeners.delete(id); 286 }; 287 }, 288 check: () => 289 work('checking', async (generation) => { 290 if (resolver) closeInboxResolver(resolver); 291 const found = await input.lookup(() => current(generation)); 292 if (!current(generation)) { 293 closeInboxResolver(found); 294 return; 295 } 296 resolver = found; 297 review = undefined; 298 state = { ...state, preview: undefined }; 299 inspect(); 300 }), 301 review: (selected, removeTags, removeFields) => 302 work('reviewing', async (generation) => { 303 if (!resolver) { 304 update('lookup_incomplete'); 305 return; 306 } 307 inspect(); 308 if (!current(generation) || state.status === 'compatible') return; 309 const result = await reviewInboxSetup( 310 input.identity, 311 resolver, 312 input.policy, 313 JSON.stringify({ 314 selectedInboxes: selected, 315 removeTagIndices: removeTags, 316 removeExtraFields: removeFields, 317 createdAt: (input.now ?? (() => Math.floor(Date.now() / 1000)))() 318 }), 319 input.now 320 ); 321 if (!current(generation)) return; 322 if (result.status !== 'review') { 323 update(result.reason); 324 return; 325 } 326 review = result.review; 327 state = { ...state, preview: inboxSetupPreview(review) }; 328 update('review'); 329 }), 330 enable: () => 331 work('approval_wait', async (generation) => { 332 if ( 333 !review || 334 state.preview === undefined || 335 !operationEnabled(input.policy, 'messaging') 336 ) { 337 update('unavailable'); 338 return; 339 } 340 const opened = await openBrowserDatabase(); 341 if (!current(generation)) { 342 if (opened.state === 'ready') closeBrowserDatabase(opened.owner); 343 return; 344 } 345 if (opened.state !== 'ready') { 346 update('storage_unavailable'); 347 return; 348 } 349 if (database) closeBrowserDatabase(database); 350 database = opened.owner; 351 repository = createPublicQuotaRepository(database, capture.owner); 352 if (!repository) { 353 update('storage_unavailable'); 354 return; 355 } 356 command = crypto.randomUUID(); 357 const prepared = await beginInboxPreferenceOperation( 358 repository, 359 input.identity, 360 input.policy, 361 review, 362 command, 363 () => input.lookup(() => current(generation)), 364 'reviewed_global_inbox_replacement' 365 ); 366 if (!current(generation)) { 367 if (prepared.status === 'prepared') 368 stopInboxPreferenceOperation(prepared.action); 369 return; 370 } 371 if (prepared.status !== 'prepared') { 372 update(prepared.status); 373 return; 374 } 375 action = prepared.action; 376 const result = await runInboxPreferenceOperation(action); 377 if (!current(generation)) return; 378 const stored = await loadPreferenceOperation(repository, command); 379 if (!current(generation)) return; 380 const row = 381 stored.ok && 382 publicRecordSnapshot(stored.value, capture.owner, command); 383 state = { 384 ...state, 385 accepted: 386 row && row.family === 'preference_operation' 387 ? row.receipts 388 .filter( 389 (fact) => 390 fact.status === 'accepted' && 391 fact.eventId === row.artifact?.eventId 392 ) 393 .map((fact) => fact.origin) 394 : [], 395 setupComplete: false 396 }; 397 review = undefined; 398 state = { ...state, preview: undefined }; 399 update( 400 result.status === 'completed' ? 'awaiting_readback' : result.status 401 ); 402 }), 403 unlock: () => 404 work('approval_wait', async (generation) => { 405 const acquired = await createPrivateSession( 406 input.identity, 407 'reviewed_private_session' 408 ); 409 if (!current(generation)) { 410 if (acquired) closePrivateSession(acquired); 411 return; 412 } 413 session = acquired; 414 if (!session || !resolver) { 415 update('unavailable'); 416 return; 417 } 418 const result = existingInboxSetupSnapshot( 419 input.identity, 420 session, 421 input.policy, 422 resolver, 423 input.observeAccess 424 ); 425 if (!current(generation)) return; 426 state = { ...state, setupComplete: result.setupComplete }; 427 update(result.status); 428 }), 429 readback: () => 430 work('checking_readback', async (generation) => { 431 if (!repository || !command || !input.readback) { 432 update('awaiting_readback'); 433 return; 434 } 435 if (!reader) { 436 const stored = await loadPreferenceOperation(repository, command); 437 if (!current(generation)) return; 438 if (!stored.ok) { 439 update('storage_unavailable'); 440 return; 441 } 442 reader = input.readback(stored.value, capture.owner, command); 443 } 444 const observation = reader && inboxReadbackSnapshot(reader); 445 if (!observation || observation.status === 'pending') { 446 update('awaiting_readback'); 447 return; 448 } 449 state = { ...state, readback: observation.sources.slice() }; 450 const result = await verifyInboxSetupOperation( 451 repository, 452 input.identity, 453 session, 454 input.policy, 455 reader!, 456 input.observeAccess 457 ); 458 if (!current(generation)) return; 459 state = { ...state, setupComplete: result.setupComplete }; 460 closeInboxReadback(reader!); 461 reader = undefined; 462 update(result.status); 463 }), 464 stop, 465 close() { 466 if (!pendingClose) { 467 closed = true; 468 const originalResolver = resolver, 469 originalReader = reader, 470 originalSession = session, 471 originalDatabase = database; 472 pendingClose = [ 473 stop, 474 invalidate, 475 () => { 476 if (originalReader) closeInboxReadback(originalReader); 477 }, 478 () => { 479 if (originalResolver) closeInboxResolver(originalResolver); 480 }, 481 () => { 482 if (originalSession && !closePrivateSession(originalSession)) 483 throw Error('private_cleanup_required'); 484 }, 485 () => { 486 if (originalDatabase) closeBrowserDatabase(originalDatabase); 487 }, 488 () => input.close?.(), 489 () => listeners.clear() 490 ]; 491 } 492 let unfinished = Array.from<() => void>([]); 493 for (const cleanup of pendingClose) { 494 try { 495 cleanup(); 496 } catch { 497 unfinished = unfinished.concat(cleanup); 498 } 499 } 500 pendingClose = unfinished; 501 // Closed admission and completed disposal are separate facts. A failed 502 // original cleanup remains owned and retryable after invalidation. 503 if (unfinished.length > 0) throw Error('inbox_setup_cleanup_required'); 504 } 505 }); 506 return token; 507 } 508 // Production egress always comes from the root's governed runtime and fixed 509 // deployment manifest. No fixture, arbitrary relay, signing template or sender. 510 export function createRuntimeInboxSetupView( 511 context: IdentityViewContext, 512 runtime: PublicRuntime 513 ): InboxSetupView | undefined { 514 const identity = identityViewSession(context); 515 if (!identity) return undefined; 516 const view = createPublicView(runtime); 517 try { 518 const controller = createInboxSetupView({ 519 identity, 520 policy: deploymentRelayPolicy, 521 lookup: (current = () => true) => { 522 const owner = identityMessagingOwnership(identity); 523 if (!owner) throw new Error('inbox_owner_unavailable'); 524 return settleInboxResolver( 525 resolveInboxPreference(view, beginPublicViewRun(view), owner.owner), 526 () => owner.current() && current() 527 ); 528 }, 529 readback: (record, owner, id) => 530 resolveInboxReadback( 531 view, 532 beginPublicViewRun(view), 533 record, 534 owner, 535 id, 536 deploymentRelayPolicy 537 ), 538 close: () => disposePublicView(view) 539 }); 540 if (!controller) disposePublicView(view); 541 return controller; 542 } catch { 543 disposePublicView(view); 544 return undefined; 545 } 546 } 547 export function inboxSetupViewSnapshot( 548 view: InboxSetupView | undefined 549 ): InboxSetupViewSnapshot { 550 return (view && views.get(view)?.snapshot()) || unavailable(); 551 } 552 export function subscribeInboxSetupView( 553 view: InboxSetupView | undefined, 554 listener: (state: InboxSetupViewSnapshot) => void 555 ): () => void { 556 return (view && views.get(view)?.subscribe(listener)) || (() => {}); 557 } 558 export async function checkInboxSetupView( 559 view: InboxSetupView | undefined 560 ): Promise<void> { 561 await (view && views.get(view)?.check()); 562 } 563 export async function reviewInboxSetupView( 564 view: InboxSetupView | undefined, 565 selected: string[], 566 removeTags: number[], 567 removeFields: string[] 568 ): Promise<void> { 569 await (view && views.get(view)?.review(selected, removeTags, removeFields)); 570 } 571 export async function enableInboxSetupView( 572 view: InboxSetupView | undefined 573 ): Promise<void> { 574 await (view && views.get(view)?.enable()); 575 } 576 export async function unlockInboxSetupView( 577 view: InboxSetupView | undefined 578 ): Promise<void> { 579 await (view && views.get(view)?.unlock()); 580 } 581 export async function readbackInboxSetupView( 582 view: InboxSetupView | undefined 583 ): Promise<void> { 584 await (view && views.get(view)?.readback()); 585 } 586 export function stopInboxSetupView(view: InboxSetupView | undefined): void { 587 if (view) views.get(view)?.stop(); 588 } 589 export function closeInboxSetupView(view: InboxSetupView | undefined): void { 590 if (view) views.get(view)?.close(); 591 } 592 593 // Detached original-token observation for trusted page orchestration. Neither 594 // its scalar fields nor mutation of this fresh object changes stored custody. 595 export function inboxSetupViewOwnership(view: InboxSetupView | undefined) { 596 return view && views.get(view)?.ownership(); 597 } 598 export function observeInboxSetupView(view: InboxSetupView | undefined): void { 599 if (view) views.get(view)?.observe(); 600 }