identity-session.ts (11873B)
1 import { 2 createExtensionAdapter, 3 extensionSnapshot, 4 connectExtensionAdapter, 5 recheckExtensionAdapter, 6 probeExtensionAdapter, 7 disconnectExtensionAdapter, 8 extensionOwnershipCapture, 9 extensionMessagingOwnershipCapture, 10 subscribeExtensionInvalidation, 11 signApprovedExtensionAdapter, 12 markApprovedSigningWaitExpired, 13 type ApprovedSignResult, 14 type ExtensionAdapter, 15 type ExtensionSnapshot, 16 type ExtensionGuestReason 17 } from '../nostr/extension.ts'; 18 import { approveCapturedPublicSigning } from '../nostr/approved-signing.ts'; 19 import { 20 publicRecordSnapshot, 21 publicRecordWire, 22 type PublicRecordHandle 23 } from '../persistence/records.ts'; 24 import { 25 stopPublicEffect, 26 type PublicEffectLease, 27 type PublicEffectCapture 28 } from './effect-ownership.ts'; 29 import { 30 bindLatePublicResponse, 31 latePublicResultIdentity, 32 reviewLatePublicArtifact, 33 type LatePublicArtifact 34 } from './late-results.ts'; 35 import { 36 capturedArtifactSnapshot, 37 type CapturedArtifact 38 } from '../persistence/artifact-records.ts'; 39 40 declare const sessionBrand: unique symbol; 41 export type IdentitySession = Readonly<{ [sessionBrand]: true }>; 42 export type IdentitySnapshot = ( 43 | Readonly<{ state: 'guest'; reason: ExtensionGuestReason }> 44 | Readonly<{ state: 'pending'; action: 'connect' | 'recheck' | 'probe' }> 45 | Readonly<{ 46 state: 'connected' | 'signing_only' | 'messaging_capable'; 47 publicKey: string; 48 messaging: 'not_probed' | 'unsupported' | 'refused' | 'capable'; 49 }> 50 ) & 51 Readonly<{ admission?: 'busy' }>; 52 // Per-client opaque session, never a module-global server user. A public key is 53 // an extension observation, not installed-account or publishing authorization. 54 const sessions = new WeakMap<IdentitySession, ExtensionAdapter>(); 55 type ViewController = { stamp(): symbol; invalidate(): void }; 56 const views = new WeakMap<IdentitySession, ViewController>(); 57 declare const operationBrand: unique symbol; 58 export type IdentityPublicOperation = Readonly<{ [operationBrand]: true }>; 59 type OperationController = { 60 session: IdentitySession; 61 ownership(): PublicEffectCapture | undefined; 62 sign(lease: PublicEffectLease): Promise<ApprovedSignResult>; 63 stop(expired: boolean): void; 64 snapshot(): Readonly<{ 65 owner: string; 66 id: string; 67 revision: number; 68 hash: string; 69 current: boolean; 70 lateAvailable: boolean; 71 outcome: ApprovedSignResult['status'] | 'not_started' | 'pending'; 72 }>; 73 review( 74 record: PublicRecordHandle, 75 review: unknown 76 ): CapturedArtifact | undefined; 77 }; 78 const operations = new WeakMap<IdentityPublicOperation, OperationController>(); 79 export function createIdentitySession(): IdentitySession { 80 const session = Object.freeze({}) as IdentitySession; 81 sessions.set(session, createExtensionAdapter()); 82 let stamp = Symbol(); 83 views.set(session, { 84 stamp: () => stamp, 85 invalidate() { 86 stamp = Symbol(); 87 } 88 }); 89 return session; 90 } 91 function mapIdentitySnapshot(snapshot: ExtensionSnapshot): IdentitySnapshot { 92 if (snapshot.state !== 'connected') return { ...snapshot }; 93 const state: IdentitySnapshot = { 94 state: 95 snapshot.messaging === 'capable' && snapshot.signingCandidate 96 ? 'messaging_capable' 97 : snapshot.signingCandidate 98 ? 'signing_only' 99 : 'connected', 100 publicKey: snapshot.publicKey, 101 messaging: snapshot.messaging 102 }; 103 return snapshot.admission === 'busy' 104 ? { ...state, admission: 'busy' } 105 : state; 106 } 107 export function identitySessionSnapshot( 108 session: IdentitySession 109 ): IdentitySnapshot { 110 const adapter = sessions.get(session); 111 return adapter 112 ? mapIdentitySnapshot(extensionSnapshot(adapter)) 113 : { state: 'guest', reason: 'unavailable' }; 114 } 115 export async function connectIdentity( 116 session: IdentitySession 117 ): Promise<IdentitySnapshot> { 118 const adapter = sessions.get(session); 119 if (adapter) 120 return mapIdentitySnapshot(await connectExtensionAdapter(adapter)); 121 return identitySessionSnapshot(session); 122 } 123 export async function recheckIdentityOwner( 124 session: IdentitySession 125 ): Promise<IdentitySnapshot> { 126 const adapter = sessions.get(session); 127 if (adapter) 128 return mapIdentitySnapshot(await recheckExtensionAdapter(adapter)); 129 return identitySessionSnapshot(session); 130 } 131 export async function probeIdentityMessaging( 132 session: IdentitySession, 133 review: unknown 134 ): Promise<IdentitySnapshot> { 135 const adapter = sessions.get(session); 136 if (adapter) 137 return mapIdentitySnapshot(await probeExtensionAdapter(adapter, review)); 138 return identitySessionSnapshot(session); 139 } 140 export function disconnectIdentity(session: IdentitySession): void { 141 views.get(session)?.invalidate(); 142 const adapter = sessions.get(session); 143 if (adapter) disconnectExtensionAdapter(adapter); 144 } 145 // Internal messaging lifecycle ports. Captured observation is not an inbox 146 // configuration, AUTH, private store or publication permission. 147 export function identityMessagingOwnership( 148 session: IdentitySession 149 ): PublicEffectCapture | undefined { 150 const adapter = sessions.get(session); 151 return adapter && extensionMessagingOwnershipCapture(adapter); 152 } 153 // Local account metadata uses the original observed extension generation. This 154 // grants no signing, messaging, installed account or network effect authority. 155 export function identityLocalOwnership(session: IdentitySession) { 156 const observed = identitySessionSnapshot(session); 157 if (!('publicKey' in observed)) return; 158 const adapter = sessions.get(session); 159 const captured = adapter && extensionOwnershipCapture(adapter); 160 return ( 161 captured && { 162 owner: captured.owner, 163 session: captured.session, 164 current: () => { 165 const state = identitySessionSnapshot(session); 166 return ( 167 captured.current() && 168 'publicKey' in state && 169 state.publicKey === captured.owner 170 ); 171 } 172 } 173 ); 174 } 175 export function subscribeIdentityInvalidation( 176 session: IdentitySession, 177 listener: () => void 178 ): () => void { 179 const adapter = sessions.get(session); 180 return adapter ? subscribeExtensionInvalidation(adapter, listener) : () => {}; 181 } 182 // Explicit route/input lifecycle event. No draft, DB, reconnect or SDK effect. 183 export function invalidateIdentityOperations(session: IdentitySession): void { 184 views.get(session)?.invalidate(); 185 } 186 // Internal public operation capability, never an unrestricted UI template signer. 187 // Current-head/inbox/IDB preparation and publication retain their typed owners. 188 export function captureIdentityPublicOperation( 189 session: IdentitySession, 190 record: PublicRecordHandle, 191 id: unknown, 192 review: unknown 193 ): IdentityPublicOperation | undefined { 194 const adapter = sessions.get(session), 195 view = views.get(session); 196 const captured = adapter && extensionOwnershipCapture(adapter); 197 if (!adapter || !view || !captured) return undefined; 198 const row = publicRecordSnapshot(record, captured.owner, id), 199 recordWire = publicRecordWire(record, captured.owner, id); 200 const approval = approveCapturedPublicSigning( 201 record, 202 captured.owner, 203 id, 204 review 205 ); 206 if ( 207 !row || 208 !recordWire || 209 !approval || 210 row.family === 'public_draft' || 211 row.revision !== 0 212 ) 213 return undefined; 214 const owner = row.owner, 215 command = row.id, 216 epoch = view.stamp(), 217 originalSession = captured.session; 218 let stopped = false, 219 pending = false; 220 let lease: PublicEffectLease | undefined, 221 late: LatePublicArtifact | undefined; 222 let outcome: ApprovedSignResult['status'] | 'not_started' | 'pending' = 223 'not_started'; 224 const current = () => 225 !stopped && view.stamp() === epoch && captured.current(); 226 const token = Object.freeze({}) as IdentityPublicOperation; 227 operations.set(token, { 228 session, 229 ownership: () => 230 current() ? { owner, session: originalSession, current } : undefined, 231 async sign(originalLease) { 232 if (pending) return { status: 'busy' }; 233 if (!current()) return { status: 'stale' }; 234 pending = true; 235 lease = originalLease; 236 outcome = 'pending'; 237 try { 238 let result = await signApprovedExtensionAdapter( 239 adapter, 240 approval, 241 originalLease 242 ); 243 // The adapter's promise can settle before this continuation runs. 244 // Recheck this view before disclosing a normal signed result. 245 if (result.status === 'signed' && !current()) { 246 const artifact = capturedArtifactSnapshot(result.artifact); 247 const originalLate = 248 artifact && 249 bindLatePublicResponse( 250 approval, 251 JSON.parse(artifact.wire), 252 originalSession 253 ); 254 result = originalLate 255 ? { status: 'unknown', late: originalLate } 256 : { status: 'unknown' }; 257 } 258 outcome = result.status; 259 if (result.status === 'unknown' && result.late) { 260 const original = latePublicResultIdentity(result.late); 261 if ( 262 original?.owner === owner && 263 original.id === command && 264 original.recordWire === recordWire && 265 original.session === originalSession 266 ) 267 late = result.late; 268 } 269 // Only disclosure/explicit original-operation review can obtain a late 270 // artifact. A normal signing result never returns it after invalidation. 271 return result.status === 'unknown' ? { status: 'unknown' } : result; 272 } finally { 273 pending = false; 274 lease = undefined; 275 } 276 }, 277 stop(expired) { 278 stopped = true; 279 if (lease) { 280 if (expired) markApprovedSigningWaitExpired(adapter, approval, lease); 281 stopPublicEffect(lease); 282 } 283 }, 284 snapshot: () => ({ 285 owner, 286 id: command, 287 revision: row.revision, 288 hash: row.capture.hash, 289 current: current(), 290 lateAvailable: late !== undefined, 291 outcome 292 }), 293 review(original, consent) { 294 const observed = extensionSnapshot(adapter); 295 return late && 296 observed.state === 'connected' && 297 observed.publicKey === owner 298 ? reviewLatePublicArtifact(late, original, owner, command, consent) 299 : undefined; 300 } 301 }); 302 return token; 303 } 304 function operationOf(session: IdentitySession, token: IdentityPublicOperation) { 305 const operation = operations.get(token); 306 return operation?.session === session ? operation : undefined; 307 } 308 export function identityPublicOperationOwnership( 309 session: IdentitySession, 310 operation: IdentityPublicOperation 311 ): PublicEffectCapture | undefined { 312 return operationOf(session, operation)?.ownership(); 313 } 314 export function identityPublicOperationSnapshot( 315 session: IdentitySession, 316 operation: IdentityPublicOperation 317 ) { 318 return operationOf(session, operation)?.snapshot(); 319 } 320 export function signIdentityPublicOperation( 321 session: IdentitySession, 322 operation: IdentityPublicOperation, 323 lease: PublicEffectLease 324 ): Promise<ApprovedSignResult> { 325 return ( 326 operationOf(session, operation)?.sign(lease) ?? 327 Promise.resolve({ status: 'invalid_approval' }) 328 ); 329 } 330 export function stopIdentityPublicOperation( 331 session: IdentitySession, 332 operation: IdentityPublicOperation 333 ): void { 334 operationOf(session, operation)?.stop(false); 335 } 336 // UI supplies expiry; existing scheduler owns its actual pending promise. 337 export function expireIdentityPublicOperationWait( 338 session: IdentitySession, 339 operation: IdentityPublicOperation 340 ): void { 341 operationOf(session, operation)?.stop(true); 342 } 343 // Pure same-author original review, not fresh author/CAS/resume/publish proof. 344 export function reviewIdentityLatePublicArtifact( 345 session: IdentitySession, 346 operation: IdentityPublicOperation, 347 original: PublicRecordHandle, 348 review: unknown 349 ): CapturedArtifact | undefined { 350 return operationOf(session, operation)?.review(original, review); 351 }