private-session.ts (6627B)
1 import { 2 identityMessagingOwnership, 3 recheckIdentityOwner, 4 subscribeIdentityInvalidation, 5 disconnectIdentity, 6 type IdentitySession 7 } from './identity-session.ts'; 8 import type { PublicEffectCapture } from './effect-ownership.ts'; 9 import { 10 browserExtensionScheduler, 11 runExtensionAction 12 } from '../nostr/extension-scheduler.ts'; 13 declare const privateBrand: unique symbol; 14 export type PrivateSession = Readonly<{ [privateBrand]: true }>; 15 type Controller = { 16 identity: IdentitySession; 17 capture: PublicEffectCapture; 18 current(): boolean; 19 close(): boolean; 20 cleanupRequired(): boolean; 21 subscribe(listener: () => void): () => void; 22 }; 23 const sessions = new WeakMap<PrivateSession, Controller>(); 24 const currentSessions = new WeakMap<IdentitySession, PrivateSession>(); 25 // No sockets, decryption, stores or readiness on construction. Only an explicit 26 // capability action may perform the fresh owner recheck through the page SDK 27 // scheduler. The generation is the real adapter's, not a caller-supplied key. 28 export async function createPrivateSession( 29 identity: IdentitySession, 30 review: unknown 31 ): Promise<PrivateSession | undefined> { 32 if (typeof window === 'undefined' || review !== 'reviewed_private_session') 33 return undefined; 34 // Retire unresolved old resources before any new provider observation. A new 35 // author/generation cannot replace failed authenticated socket ownership. 36 const previous = currentSessions.get(identity); 37 const prior = previous && sessions.get(previous); 38 if (prior && !prior.current() && !prior.close()) return undefined; 39 const before = identityMessagingOwnership(identity); 40 if (!before) return undefined; 41 const checked = await recheckIdentityOwner(identity); 42 const capture = identityMessagingOwnership(identity); 43 if ( 44 !before.current() || 45 checked.state !== 'messaging_capable' || 46 checked.admission === 'busy' || 47 !capture || 48 capture.owner !== before.owner || 49 capture.session !== before.session 50 ) 51 return undefined; 52 const existing = currentSessions.get(identity); 53 if (existing && sessions.get(existing)?.current()) return existing; 54 if (existing && !sessions.get(existing)?.close()) return undefined; 55 const token = Object.freeze({}) as PrivateSession; 56 const listeners = new Map<symbol, () => void>(); 57 let closed = false; 58 let closing = false; 59 let unsubscribe = () => {}; 60 const current = () => !closed && capture.current(); 61 function close() { 62 closed = true; 63 if (closing) return false; 64 closing = true; 65 try { 66 unsubscribe(); 67 for (const [id, listener] of listeners) { 68 try { 69 listener(); 70 listeners.delete(id); 71 } catch { 72 // Keep only failed cleanup registrations for an actual retry. Drain 73 // other resources now; passive invalidation never leaks exceptions. 74 } 75 } 76 } finally { 77 closing = false; 78 } 79 return listeners.size === 0; 80 } 81 sessions.set(token, { 82 identity, 83 capture, 84 current, 85 close, 86 cleanupRequired: () => closed && listeners.size !== 0, 87 subscribe(listener) { 88 const id = Symbol(); 89 listeners.set(id, listener); 90 if (!current()) close(); 91 return () => { 92 listeners.delete(id); 93 }; 94 } 95 }); 96 unsubscribe = subscribeIdentityInvalidation(identity, () => { 97 if (!current()) close(); 98 }); 99 // Observe again after registering: no missed invalidation/acquisition seam. 100 if (!current()) { 101 close(); 102 return undefined; 103 } 104 currentSessions.set(identity, token); 105 return token; 106 } 107 export function privateSessionOwnership( 108 token: PrivateSession 109 ): PublicEffectCapture | undefined { 110 const state = sessions.get(token); 111 if (!state?.current()) { 112 state?.close(); 113 return undefined; 114 } 115 return { 116 owner: state.capture.owner, 117 session: state.capture.session, 118 current: () => state.current() 119 }; 120 } 121 export function privateSessionSnapshot( 122 token: PrivateSession 123 ): Readonly<{ owner: string; current: boolean }> | undefined { 124 const state = sessions.get(token); 125 return ( 126 state && { 127 owner: state.capture.owner, 128 current: state.current() 129 } 130 ); 131 } 132 export function privateSessionCleanupRequired(token: PrivateSession): boolean { 133 return sessions.get(token)?.cleanupRequired() ?? false; 134 } 135 export function subscribePrivateSessionClose( 136 token: PrivateSession, 137 listener: () => void 138 ): () => void { 139 const state = sessions.get(token); 140 if (!state) throw new Error('private_session_invalid'); 141 return state.subscribe(listener); 142 } 143 export function closePrivateSession(token: PrivateSession): boolean { 144 return sessions.get(token)?.close() ?? false; 145 } 146 // A trusted private owner has actually observed key/capability loss. Invalidate 147 // synchronously inside its occupied permission job without a second provider 148 // request. The original captured generation must still be current: a late old 149 // callback cannot disconnect a newly connected generation of this identity. 150 export function invalidatePrivateSessionGeneration( 151 token: PrivateSession 152 ): boolean { 153 const state = sessions.get(token); 154 if (!state?.current()) return false; 155 disconnectIdentity(state.identity); 156 state.close(); 157 return true; 158 } 159 // Every new finite network action gets a fresh SDK owner observation; neither 160 // a remembered key nor a still-current presentation snapshot substitutes. 161 export async function recheckPrivateSession( 162 token: PrivateSession 163 ): Promise<boolean> { 164 const state = sessions.get(token); 165 if (!state?.current()) return false; 166 const checked = await recheckIdentityOwner(state.identity); 167 return ( 168 state.current() && 169 checked.state === 'messaging_capable' && 170 checked.publicKey === state.capture.owner && 171 checked.admission !== 'busy' 172 ); 173 } 174 175 // A short local-storage action reserves the actual shared SDK slot without 176 // invoking the provider. No permission/network work belongs inside this job. 177 export async function withIdlePrivateLocalStorage<T>( 178 token: PrivateSession, 179 work: (this: void) => Promise<T> 180 ): Promise<Readonly<{ ok: true; value: T }> | Readonly<{ ok: false }>> { 181 const state = sessions.get(token), 182 scheduler = browserExtensionScheduler(); 183 if (!state?.current() || !scheduler) return { ok: false }; 184 const result = await runExtensionAction( 185 scheduler, 186 { 187 owner: state.capture.owner, 188 session: state.capture.session, 189 operation: Symbol() 190 }, 191 () => state.current(), 192 () => work() 193 ); 194 return result.status === 'completed' && 'value' in result && state.current() 195 ? { ok: true, value: result.value as T } 196 : { ok: false }; 197 }