inbox-access-controller.ts (12166B)
1 import { 2 inboxRelayTargets, 3 publicRelayTargets, 4 readRelayPolicy, 5 type RelayPolicy 6 } from '../config/relays.ts'; 7 import { inboxPreferenceSnapshot } from '../nostr/inbox-preferences.ts'; 8 import { 9 beginInboxAuthentication, 10 respondInboxAuthentication, 11 closeInboxAuthentication, 12 inboxAuthSnapshot, 13 type InboxAuthAction 14 } from '../nostr/inbox-auth.ts'; 15 import { 16 getPrivatePool, 17 closePrivatePool, 18 privatePoolCleanupRequired, 19 type PrivatePool 20 } from '../nostr/private-pool.ts'; 21 import { 22 privateSessionOwnership, 23 subscribePrivateSessionClose, 24 type PrivateSession 25 } from '../runtime/private-session.ts'; 26 import { 27 inboxResolutionSnapshot, 28 inboxResolverCurrentAfterSample, 29 type InboxResolver 30 } from './resolve-inbox.ts'; 31 32 declare const accessBrand: unique symbol; 33 export type InboxAccessController = Readonly<{ [accessBrand]: true }>; 34 type Binding = Readonly<{ 35 owner: string; 36 preferenceId: string; 37 preferenceCreatedAt: number; 38 readTargets: string[]; 39 archiveTargets: string[]; 40 }>; 41 export type InboxAccessSourceSnapshot = Readonly< 42 Binding & { 43 state: string; 44 busy: boolean; 45 cleanupRequired: boolean; 46 auth: { origin: string; state: string; responses: number }[]; 47 } 48 >; 49 export type InboxAccessSnapshot = Readonly< 50 InboxAccessSourceSnapshot & { readiness: 'unavailable' } 51 >; 52 type Control = { 53 session: PrivateSession; 54 subscribe(listener: () => void): () => void; 55 policy: RelayPolicy; 56 binding: string; 57 current(): boolean; 58 closed(): boolean; 59 cleanupRequired(): boolean; 60 sourceSnapshot(): InboxAccessSourceSnapshot; 61 snapshot(): InboxAccessSnapshot; 62 authenticate(origin: unknown, review: unknown): Promise<string>; 63 respond(origin: unknown, review: unknown): Promise<string>; 64 close(): boolean; 65 }; 66 const controllers = new WeakMap<InboxAccessController, Control>(); 67 const currentControllers = new WeakMap<PrivateSession, InboxAccessController>(); 68 function binding( 69 session: PrivateSession, 70 policy: RelayPolicy, 71 own: InboxResolver 72 ): Binding | undefined { 73 try { 74 const capture = privateSessionOwnership(session), 75 head = inboxResolutionSnapshot(own); 76 const sources = publicRelayTargets(policy, 'read'); 77 const preference = head.head && inboxPreferenceSnapshot(head.head); 78 if ( 79 !capture?.current() || 80 !readRelayPolicy(policy).messagingEnabled || 81 head.author !== capture.owner || 82 head.status !== 'ready' || 83 head.coverage !== 'bounded-eose' || 84 !preference || 85 preference.status !== 'supported' || 86 preference.author !== capture.owner || 87 preference.id !== head.knownBase?.id || 88 preference.createdAt !== head.knownBase.createdAt || 89 !sources.length || 90 head.sources.length !== sources.length || 91 !sources.every((origin) => 92 head.sources.some( 93 (source) => source.source === origin && source.state === 'eose' 94 ) 95 ) 96 ) 97 return undefined; 98 const readTargets = inboxRelayTargets( 99 policy, 100 preference.relays, 101 'read' 102 ).slice(); 103 const archiveTargets = inboxRelayTargets( 104 policy, 105 preference.relays, 106 'write' 107 ).slice(); 108 if ( 109 !readTargets.length || 110 !archiveTargets.length || 111 !capture.current() || 112 !inboxResolverCurrentAfterSample(own) 113 ) 114 return undefined; 115 return { 116 owner: capture.owner, 117 preferenceId: preference.id, 118 preferenceCreatedAt: preference.createdAt, 119 readTargets, 120 archiveTargets 121 }; 122 } catch { 123 return undefined; 124 } 125 } 126 // Capture only genuine current discovery/session metadata. No socket, provider, 127 // AUTH, probe or publication occurs here. AUTH alone never grants readiness; 128 // the separate qualified access probe must supply that later capability. 129 export function createInboxAccessController( 130 session: PrivateSession, 131 policy: RelayPolicy, 132 own: InboxResolver 133 ): InboxAccessController | undefined { 134 if (typeof window === 'undefined') return undefined; 135 const captured = binding(session, policy, own); 136 if (!captured) return undefined; 137 const initial = captured; 138 const wire = JSON.stringify(initial), 139 previous = currentControllers.get(session); 140 const prior = previous && controllers.get(previous); 141 if ( 142 prior && 143 !prior.closed() && 144 prior.current() && 145 prior.policy === policy && 146 prior.binding === wire 147 ) 148 return previous; 149 // Stale or failed disposal cannot be silently replaced by another capture. 150 if (prior && (!prior.closed() || prior.cleanupRequired())) return undefined; 151 const token = Object.freeze({}) as InboxAccessController; 152 const auth = new Map<string, InboxAuthAction>(); 153 const constructionClosures = new Map<symbol, () => void>(); 154 let pool: PrivatePool | undefined, 155 closed = false, 156 closing = false, 157 cleaned = false, 158 busy = false, 159 epoch = 0, 160 phase = 'not_checked'; 161 let off = () => {}; 162 const current = () => 163 !closed && JSON.stringify(binding(session, policy, own)) === wire; 164 function close(): boolean { 165 closed = true; 166 if (closing) return false; 167 closing = true; 168 try { 169 epoch++; 170 phase = 'stopped'; 171 let failed = false; 172 // Revoke construction before any asynchronous/throwing transport cleanup. 173 // Only failed original closures remain registered for an honest retry. 174 for (const [id, listener] of constructionClosures) { 175 try { 176 listener(); 177 constructionClosures.delete(id); 178 } catch { 179 failed = true; 180 } 181 } 182 for (const [origin, action] of auth) { 183 try { 184 closeInboxAuthentication(action); 185 auth.delete(origin); 186 } catch { 187 failed = true; 188 } 189 } 190 if (pool) { 191 try { 192 closePrivatePool(pool); 193 } catch { 194 failed = true; 195 } 196 if (privatePoolCleanupRequired(pool)) failed = true; 197 } 198 cleaned = !failed; 199 if (cleaned) off(); 200 return cleaned; 201 } finally { 202 closing = false; 203 } 204 } 205 async function authenticate( 206 origin: unknown, 207 review: unknown 208 ): Promise<string> { 209 if ( 210 review !== 'reviewed_inbox_connection_auth' || 211 typeof origin !== 'string' || 212 !current() || 213 (!initial.readTargets.includes(origin) && 214 !initial.archiveTargets.includes(origin)) 215 ) 216 return 'unavailable'; 217 if (busy) return 'busy'; 218 const existing = auth.get(origin); 219 if (existing) return inboxAuthSnapshot(existing)?.state ?? 'stopped'; 220 busy = true; 221 const generation = epoch; 222 try { 223 pool ??= getPrivatePool( 224 session, 225 policy, 226 Array.from( 227 new Set([...initial.readTargets, ...initial.archiveTargets]) 228 ), 229 token, 230 'access', 231 current 232 ); 233 if (!pool || !current()) return 'unavailable'; 234 const action = await beginInboxAuthentication( 235 pool, 236 origin, 237 'reviewed_connection_auth' 238 ); 239 if (!action) return (phase = 'unavailable'); 240 if (!current() || generation !== epoch) { 241 closeInboxAuthentication(action); 242 return 'stopped'; 243 } 244 auth.set(origin, action); 245 phase = 'authenticating'; 246 return inboxAuthSnapshot(action)?.state ?? 'unavailable'; 247 } catch { 248 return (phase = closed ? 'stopped' : 'unavailable'); 249 } finally { 250 busy = false; 251 } 252 } 253 async function respond(origin: unknown, review: unknown): Promise<string> { 254 const action = typeof origin === 'string' && auth.get(origin); 255 if (!action || review !== 'reviewed_inbox_auth_response' || !current()) 256 return 'unavailable'; 257 if (busy) return 'busy'; 258 busy = true; 259 const generation = epoch; 260 try { 261 const result = await respondInboxAuthentication(action); 262 if (!current() || generation !== epoch) { 263 closeInboxAuthentication(action); 264 return 'stopped'; 265 } 266 phase = result.status; 267 return result.status; 268 } catch { 269 return (phase = closed ? 'stopped' : 'unavailable'); 270 } finally { 271 busy = false; 272 } 273 } 274 // Construction and qualification consume this source projection directly. 275 // Presentation may later observe qualification, so it cannot be their input. 276 const sourceSnapshot = (): InboxAccessSourceSnapshot => ({ 277 ...initial, 278 readTargets: [...initial.readTargets], 279 archiveTargets: [...initial.archiveTargets], 280 state: closed ? 'stopped' : current() ? phase : 'stale', 281 busy, 282 cleanupRequired: 283 closed && (!cleaned || (!!pool && privatePoolCleanupRequired(pool))), 284 auth: [...auth].map(([origin, action]) => ({ 285 origin, 286 state: inboxAuthSnapshot(action)?.state ?? 'stopped', 287 responses: inboxAuthSnapshot(action)?.responses ?? 0 288 })) 289 }); 290 controllers.set(token, { 291 session, 292 subscribe(listener) { 293 const id = Symbol(); 294 constructionClosures.set(id, listener); 295 if (closed) { 296 try { 297 listener(); 298 constructionClosures.delete(id); 299 } catch (error) { 300 cleaned = false; 301 throw error; 302 } 303 } 304 return () => { 305 constructionClosures.delete(id); 306 }; 307 }, 308 policy, 309 binding: wire, 310 current, 311 closed: () => closed, 312 cleanupRequired: () => 313 closed && (!cleaned || (!!pool && privatePoolCleanupRequired(pool))), 314 authenticate, 315 respond, 316 close, 317 sourceSnapshot, 318 snapshot: () => ({ 319 ...sourceSnapshot(), 320 readiness: 'unavailable' 321 }) 322 }); 323 off = subscribePrivateSessionClose(session, () => { 324 if (!close()) throw Error('inbox_access_cleanup_required'); 325 }); 326 if (!current()) { 327 close(); 328 return undefined; 329 } 330 currentControllers.set(session, token); 331 return token; 332 } 333 export function inboxAccessControllerSnapshot( 334 token: InboxAccessController 335 ): InboxAccessSnapshot | undefined { 336 return controllers.get(token)?.snapshot(); 337 } 338 export function inboxAccessControllerSourceSnapshot( 339 token: InboxAccessController 340 ): InboxAccessSourceSnapshot | undefined { 341 return controllers.get(token)?.sourceSnapshot(); 342 } 343 export function authenticateInboxAccess( 344 token: InboxAccessController, 345 origin: unknown, 346 review: unknown 347 ): Promise<string> { 348 return ( 349 controllers.get(token)?.authenticate(origin, review) ?? 350 Promise.resolve('unavailable') 351 ); 352 } 353 export function respondInboxAccessAuthentication( 354 token: InboxAccessController, 355 origin: unknown, 356 review: unknown 357 ): Promise<string> { 358 return ( 359 controllers.get(token)?.respond(origin, review) ?? 360 Promise.resolve('unavailable') 361 ); 362 } 363 export function closeInboxAccessController( 364 token: InboxAccessController 365 ): boolean { 366 return controllers.get(token)?.close() ?? false; 367 } 368 369 // Narrow source-owned construction binding. It authenticates current discovery 370 // metadata only; it grants neither readiness nor a socket/sign/publication port. 371 export function inboxAccessConstructionBinding( 372 token: InboxAccessController, 373 session: PrivateSession, 374 policy: RelayPolicy 375 ): Readonly<Binding & { session: symbol; current(): boolean }> | undefined { 376 const state = controllers.get(token); 377 if ( 378 !state || 379 state.closed() || 380 state.session !== session || 381 state.policy !== policy 382 ) 383 return undefined; 384 const ownership = privateSessionOwnership(session); 385 if (!ownership?.current() || !state.current()) return undefined; 386 const captured = state.sourceSnapshot(); 387 if ( 388 captured.owner !== ownership.owner || 389 !state.current() || 390 !ownership.current() 391 ) 392 return undefined; 393 return { 394 owner: captured.owner, 395 preferenceId: captured.preferenceId, 396 preferenceCreatedAt: captured.preferenceCreatedAt, 397 readTargets: [...captured.readTargets], 398 archiveTargets: [...captured.archiveTargets], 399 session: ownership.session, 400 current: () => ownership.current() && state.current() 401 }; 402 } 403 export function subscribeInboxAccessControllerClose( 404 token: InboxAccessController, 405 listener: () => void 406 ): () => void { 407 const state = controllers.get(token); 408 if (!state) throw Error('inbox_access_controller_invalid'); 409 return state.subscribe(listener); 410 }