Line data Source code
1 : /**
2 : * The session-backed identity source: boots a site from `GET /auth/session`
3 : * and follows the server's answer. It keeps no record of past sessions, and
4 : * the remembered provider login is an opaque port, so no provider leaks in.
5 : */
6 : import { z } from 'zod'
7 :
8 : import type {
9 : CrossTabRefreshPort,
10 : WebSession,
11 : WebSessionCommandResult,
12 : WebSessionFailure,
13 : WebSessionResult
14 : } from './sessionContracts'
15 : import type { WebSessionOptions } from './webSession'
16 : import {
17 : createWebSession,
18 : deleteWebSession,
19 : readWebSession
20 : } from './webSession'
21 :
22 : export interface RememberedLogin {
23 : /** The Comfy user id of the login this browser remembers, or null. */
24 : currentUserId: () => Promise<string | null>
25 : /** Null when the provider has no usable login; a throw is transient. */
26 : getProof: () => Promise<string | null>
27 : signOutLocally: () => Promise<void>
28 : }
29 :
30 : export type WebSessionPrincipal =
31 : | { readonly kind: 'account'; readonly rememberedLogin: RememberedLogin }
32 : | { readonly kind: 'api_key' }
33 :
34 : export type WebSessionBootOutcome =
35 : | 'signed_in'
36 : | 'restored'
37 : | 'signed_out'
38 : | 'revoked'
39 : | 'restore_failed'
40 :
41 : export interface WebSessionBootstrapEvent {
42 : readonly outcome: WebSessionBootOutcome
43 : readonly origin: string
44 : }
45 :
46 : type SignedOutOutcome = Exclude<WebSessionBootOutcome, 'signed_in' | 'restored'>
47 :
48 : /** The account this tab holds changed under it, or went away. */
49 : export type WebSessionAccountChange =
50 : | { readonly reason: 'user_changed'; readonly session: WebSession }
51 : | { readonly reason: 'signed_out'; readonly outcome: SignedOutOutcome }
52 :
53 : export type WebSessionIdentityState =
54 : | { readonly phase: 'idle' }
55 : | { readonly phase: 'api_key' }
56 : | {
57 : readonly phase: 'reading' | 'retry_wait' | 'restoring'
58 : readonly failures: number
59 : }
60 : | { readonly phase: 'signed_in'; readonly session: WebSession }
61 : | { readonly phase: 'signed_out'; readonly outcome: SignedOutOutcome }
62 :
63 : /** Only a sibling's sign-in is news to a tab that has signed out. */
64 : export type SessionObservedFrom =
65 : | 'this_tab'
66 : | 'sibling_heartbeat'
67 : | 'sibling_sign_in'
68 : | 'sibling_sign_out'
69 :
70 : export type WebSessionIdentityEvent =
71 : | { readonly type: 'boot' }
72 : | {
73 : readonly type: 'read_answered' | 'restore_answered'
74 : readonly result: WebSessionResult
75 : readonly rememberedUserId: string | null
76 : }
77 : | { readonly type: 'proof_missing' | 'proof_errored' | 'login_errored' }
78 : | { readonly type: 'retry_due' }
79 : /** A heartbeat answer, this tab's or one a sibling tab published. */
80 : | {
81 : readonly type: 'session_observed'
82 : readonly from: SessionObservedFrom
83 : readonly result: WebSessionResult
84 : readonly rememberedUserId: string | null
85 : }
86 : | { readonly type: 'session_created'; readonly session: WebSession }
87 : | { readonly type: 'sign_out_requested' }
88 :
89 : export type WebSessionIdentityEffect =
90 : | { readonly type: 'read' }
91 : | { readonly type: 'restore'; readonly expectedUserId: string }
92 : | { readonly type: 'schedule_retry'; readonly failures: number }
93 : | { readonly type: 'sign_out_locally' }
94 : | { readonly type: 'report'; readonly outcome: WebSessionBootOutcome }
95 : | {
96 : readonly type: 'account_changed'
97 : readonly change: WebSessionAccountChange
98 : }
99 : | { readonly type: 'report_signed_out_remotely' }
100 :
101 : export interface WebSessionIdentityTransition {
102 : readonly state: WebSessionIdentityState
103 : readonly effects: readonly WebSessionIdentityEffect[]
104 : }
105 :
106 2356 : const read: WebSessionIdentityEffect = { type: 'read' }
107 2356 : const signOutLocally: WebSessionIdentityEffect = { type: 'sign_out_locally' }
108 :
109 0 : function signOutDifferentLogin(
110 : session: WebSession,
111 : rememberedUserId: string | null
112 : ): WebSessionIdentityEffect[] {
113 0 : return rememberedUserId !== null && rememberedUserId !== session.user.id
114 : ? [signOutLocally]
115 : : []
116 : }
117 :
118 0 : function settleSignedIn(
119 : session: WebSession,
120 : rememberedUserId: string | null,
121 : outcome: 'signed_in' | 'restored'
122 : ): WebSessionIdentityTransition {
123 0 : return {
124 : state: { phase: 'signed_in', session },
125 : effects: [
126 : ...signOutDifferentLogin(session, rememberedUserId),
127 : { type: 'report', outcome }
128 : ]
129 : }
130 : }
131 :
132 0 : function settleSignedOut(
133 : outcome: SignedOutOutcome
134 : ): WebSessionIdentityTransition {
135 0 : return {
136 : state: { phase: 'signed_out', outcome },
137 : effects: [
138 : ...(outcome === 'revoked' ? [signOutLocally] : []),
139 : { type: 'report', outcome }
140 : ]
141 : }
142 : }
143 :
144 0 : function waitToRetry(failures: number): WebSessionIdentityTransition {
145 0 : return {
146 : state: { phase: 'retry_wait', failures },
147 : effects: [{ type: 'schedule_retry', failures }]
148 : }
149 : }
150 :
151 0 : function isNoLiveSession(failure: WebSessionFailure): boolean {
152 0 : return failure.code === 'NO_SESSION' || failure.code === 'SESSION_EXPIRED'
153 : }
154 :
155 0 : function applyReadAnswered(
156 : failures: number,
157 : result: WebSessionResult,
158 : rememberedUserId: string | null
159 : ): WebSessionIdentityTransition {
160 0 : if (result.status === 'ok') {
161 0 : return settleSignedIn(result.session, rememberedUserId, 'signed_in')
162 : }
163 0 : if (result.retryable) return waitToRetry(failures + 1)
164 0 : if (result.code === 'SESSION_REVOKED') return settleSignedOut('revoked')
165 0 : if (!isNoLiveSession(result)) return settleSignedOut('signed_out')
166 0 : if (rememberedUserId === null) return settleSignedOut('signed_out')
167 0 : return {
168 : state: { phase: 'restoring', failures },
169 : effects: [{ type: 'restore', expectedUserId: rememberedUserId }]
170 : }
171 : }
172 :
173 0 : function applyRestoreAnswered(
174 : failures: number,
175 : result: WebSessionResult,
176 : rememberedUserId: string | null
177 : ): WebSessionIdentityTransition {
178 0 : if (result.status === 'ok') {
179 0 : return settleSignedIn(result.session, rememberedUserId, 'restored')
180 : }
181 0 : if (result.retryable) return waitToRetry(failures + 1)
182 0 : if (result.code === 'SESSION_REVOKED') return settleSignedOut('revoked')
183 0 : return settleSignedOut('restore_failed')
184 : }
185 :
186 0 : function leaveAccount(
187 : outcome: SignedOutOutcome,
188 : effects: readonly WebSessionIdentityEffect[] = []
189 : ): WebSessionIdentityTransition {
190 0 : return {
191 : state: { phase: 'signed_out', outcome },
192 : effects: [
193 : ...effects,
194 : { type: 'account_changed', change: { reason: 'signed_out', outcome } }
195 : ]
196 : }
197 : }
198 :
199 0 : function replaceSession(
200 : held: WebSession,
201 : session: WebSession,
202 : effects: readonly WebSessionIdentityEffect[] = []
203 : ): WebSessionIdentityTransition {
204 0 : const state: WebSessionIdentityState = { phase: 'signed_in', session }
205 0 : if (session.user.id === held.user.id) return { state, effects: [] }
206 0 : return {
207 : state,
208 : effects: [
209 : ...effects,
210 : { type: 'account_changed', change: { reason: 'user_changed', session } }
211 : ]
212 : }
213 : }
214 :
215 : /** A read never signs out on doubt: only revoked or no live session does. */
216 0 : function observeWhileSignedIn(
217 : state: Extract<WebSessionIdentityState, { phase: 'signed_in' }>,
218 : result: WebSessionResult,
219 : rememberedUserId: string | null,
220 : restored: boolean,
221 : ownRead: boolean
222 : ): WebSessionIdentityTransition {
223 0 : if (result.status === 'ok') {
224 0 : return replaceSession(
225 : state.session,
226 : result.session,
227 : signOutDifferentLogin(result.session, rememberedUserId)
228 : )
229 : }
230 0 : if (result.retryable) return { state, effects: [] }
231 0 : if (result.code === 'SESSION_REVOKED') {
232 0 : return leaveAccount(
233 : 'revoked',
234 : ownRead
235 : ? [signOutLocally, { type: 'report_signed_out_remotely' }]
236 : : [signOutLocally]
237 : )
238 : }
239 0 : if (restored) return leaveAccount('restore_failed')
240 0 : if (!isNoLiveSession(result)) return { state, effects: [] }
241 0 : if (rememberedUserId === null) return leaveAccount('signed_out')
242 0 : return {
243 : state,
244 : effects: [{ type: 'restore', expectedUserId: rememberedUserId }]
245 : }
246 : }
247 :
248 0 : function transitionSignedIn(
249 : state: Extract<WebSessionIdentityState, { phase: 'signed_in' }>,
250 : event: WebSessionIdentityEvent
251 : ): WebSessionIdentityTransition {
252 0 : switch (event.type) {
253 : case 'session_observed':
254 0 : return observeWhileSignedIn(
255 : state,
256 : event.result,
257 : event.rememberedUserId,
258 : false,
259 : event.from === 'this_tab'
260 : )
261 : case 'restore_answered':
262 0 : return observeWhileSignedIn(
263 : state,
264 : event.result,
265 : event.rememberedUserId,
266 : true,
267 : true
268 : )
269 : case 'session_created':
270 0 : return replaceSession(state.session, event.session)
271 : case 'proof_missing':
272 0 : return leaveAccount('restore_failed')
273 : case 'sign_out_requested':
274 0 : return leaveAccount('signed_out', [signOutLocally])
275 : default:
276 0 : return { state, effects: [] }
277 : }
278 : }
279 :
280 : type SettlingState = Exclude<
281 : WebSessionIdentityState,
282 : { readonly phase: 'idle' | 'api_key' | 'signed_in' }
283 : >
284 :
285 0 : function transitionRestoring(
286 : state: Extract<SettlingState, { readonly failures: number }>,
287 : event: WebSessionIdentityEvent
288 : ): WebSessionIdentityTransition {
289 0 : switch (event.type) {
290 : case 'restore_answered':
291 0 : return applyRestoreAnswered(
292 : state.failures,
293 : event.result,
294 : event.rememberedUserId
295 : )
296 : case 'proof_missing':
297 0 : return settleSignedOut('restore_failed')
298 : case 'proof_errored':
299 : case 'login_errored':
300 0 : return waitToRetry(state.failures + 1)
301 : default:
302 0 : return { state, effects: [] }
303 : }
304 : }
305 :
306 0 : function transitionBoot(
307 : state: SettlingState,
308 : event: WebSessionIdentityEvent
309 : ): WebSessionIdentityTransition {
310 0 : switch (state.phase) {
311 : case 'reading':
312 0 : if (event.type === 'login_errored') return waitToRetry(state.failures + 1)
313 0 : return event.type === 'read_answered'
314 : ? applyReadAnswered(
315 : state.failures,
316 : event.result,
317 : event.rememberedUserId
318 : )
319 : : { state, effects: [] }
320 : case 'retry_wait':
321 0 : return event.type === 'retry_due'
322 : ? { state: { ...state, phase: 'reading' }, effects: [read] }
323 : : { state, effects: [] }
324 : case 'restoring':
325 0 : return transitionRestoring(state, event)
326 : default:
327 0 : return { state, effects: [] }
328 : }
329 : }
330 :
331 0 : function transitionSettling(
332 : state: SettlingState,
333 : event: WebSessionIdentityEvent
334 : ): WebSessionIdentityTransition {
335 0 : switch (event.type) {
336 : case 'session_observed': {
337 0 : const { result } = event
338 0 : const adoptable =
339 : state.phase === 'retry_wait' ||
340 : (state.phase === 'signed_out' && event.from === 'sibling_sign_in')
341 0 : if (result.status !== 'ok' || !adoptable) return { state, effects: [] }
342 0 : return {
343 : state: { phase: 'signed_in', session: result.session },
344 : effects: signOutDifferentLogin(result.session, event.rememberedUserId)
345 : }
346 : }
347 : case 'session_created':
348 0 : return {
349 : state: { phase: 'signed_in', session: event.session },
350 : effects: []
351 : }
352 : case 'sign_out_requested':
353 0 : return state.phase === 'signed_out'
354 : ? { state, effects: [] }
355 : : {
356 : state: { phase: 'signed_out', outcome: 'signed_out' },
357 : effects: [signOutLocally]
358 : }
359 : default:
360 0 : return transitionBoot(state, event)
361 : }
362 : }
363 :
364 : /** Pure: an event that means nothing in the current phase changes nothing. */
365 0 : export function transitionWebSessionIdentity(
366 : state: WebSessionIdentityState,
367 : event: WebSessionIdentityEvent
368 : ): WebSessionIdentityTransition {
369 0 : switch (state.phase) {
370 : case 'idle':
371 0 : return event.type === 'boot'
372 : ? { state: { phase: 'reading', failures: 0 }, effects: [read] }
373 : : { state, effects: [] }
374 : case 'api_key':
375 0 : return { state, effects: [] }
376 : case 'signed_in':
377 0 : return transitionSignedIn(state, event)
378 : default:
379 0 : return transitionSettling(state, event)
380 : }
381 : }
382 :
383 : export type ScheduleRetry = (run: () => void, delayMs: number) => () => void
384 :
385 : export interface VisibilityPort {
386 : isVisible: () => boolean
387 : onChange: (listener: (visible: boolean) => void) => () => void
388 : }
389 :
390 : export interface WebSessionHeartbeatOptions {
391 : readonly visibility: VisibilityPort
392 : /** Without it every tab reads for itself. */
393 : readonly crossTab?: CrossTabRefreshPort<WebSessionSharedMessage>
394 : readonly intervalMs?: number
395 : }
396 :
397 : export interface WebSessionIdentityOptions {
398 : readonly session: WebSessionOptions
399 : readonly principal: WebSessionPrincipal
400 : /** The site reporting the boot, e.g. `https://www.comfy.org`. */
401 : readonly origin: string
402 : readonly onBootstrap?: (event: WebSessionBootstrapEvent) => void
403 : /** Telemetry for `session_signed_out_remotely`. */
404 : readonly onSignedOutRemotely?: (event: { readonly origin: string }) => void
405 : /** The host drops pending actions and user-scoped state here. */
406 : readonly onAccountChanged?: (
407 : change: WebSessionAccountChange & { readonly epoch: number }
408 : ) => void
409 : readonly heartbeat?: WebSessionHeartbeatOptions
410 : readonly schedule?: ScheduleRetry
411 : readonly retryBaseMs?: number
412 : readonly retryMaxMs?: number
413 : }
414 :
415 : export interface WebSessionIdentity {
416 : getState: () => WebSessionIdentityState
417 : /** Delivers the current state at once, then every change. */
418 : subscribe: (listener: (state: WebSessionIdentityState) => void) => () => void
419 : /** Starts the boot and the heartbeat; a no-op unless idle. */
420 : boot: () => void
421 : /** Only after an interactive sign-in; a token refresh must never call it. */
422 : signedIn: (getProof: () => Promise<string>) => Promise<WebSessionResult>
423 : signOut: () => Promise<WebSessionCommandResult>
424 : /**
425 : * Reads the session now, as a heartbeat would, and resolves once the answer
426 : * and any restore it starts have settled. Reads nothing unless signed in as
427 : * `expectedUserId` (any user when omitted).
428 : */
429 : refresh: (expectedUserId?: string) => Promise<WebSessionIdentityState>
430 : /** Changes with the account; an answer started under an older epoch is stale. */
431 : getEpoch: () => number
432 : /** Cancels timers, ignores answers in flight, and returns to idle. */
433 : dispose: () => void
434 : }
435 :
436 2356 : const HEARTBEAT_KEY = '@comfyorg/account-core web-session heartbeat'
437 2356 : const HEARTBEAT_INTERVAL_MS = 10 * 60 * 1000
438 2356 : const PROOF_TIMEOUT_MS = 15_000
439 :
440 2356 : const zSharedResult = z.discriminatedUnion('status', [
441 : z.object({
442 : status: z.literal('ok'),
443 : session: z.object({
444 : user: z.object({
445 : id: z.string(),
446 : email: z.string(),
447 : name: z.string().optional(),
448 : emailVerified: z.boolean(),
449 : signInProvider: z.string().optional(),
450 : hasPersonalWorkspace: z.boolean().optional()
451 : }),
452 : csrfToken: z.string(),
453 : expiresAt: z.number(),
454 : absoluteExpiresAt: z.number()
455 : })
456 : }),
457 : z.object({
458 : status: z.literal('error'),
459 : code: z.literal('SESSION_REVOKED'),
460 : retryable: z.literal(false)
461 : })
462 : ])
463 :
464 : /**
465 : * Every tab of a site reads the same host-only cookie, so a sibling's answer
466 : * is this tab's own session observed elsewhere; that is what makes adopting
467 : * it safe. A per-tab session scope would break this assumption.
468 : */
469 2356 : const zSharedMessage = z.object({
470 : from: z.enum(['heartbeat', 'sign_in', 'sign_out']),
471 : result: zSharedResult
472 : })
473 :
474 : type SharedFrom = z.infer<typeof zSharedMessage>['from']
475 :
476 : /** What one tab of a site tells its siblings, and why. */
477 : export interface WebSessionSharedMessage {
478 : readonly from: SharedFrom
479 : readonly result: WebSessionResult
480 : }
481 :
482 2356 : const revoked: WebSessionResult = {
483 : status: 'error',
484 : code: 'SESSION_REVOKED',
485 : retryable: false
486 : }
487 :
488 2356 : const scheduleWithTimer: ScheduleRetry = (run, delayMs) => {
489 0 : const timer = setTimeout(run, delayMs)
490 0 : return () => clearTimeout(timer)
491 : }
492 :
493 0 : function reportLocalSignOutFailure(error: unknown): void {
494 0 : console.warn('webSessionIdentity: local sign-out failed', error)
495 : }
496 :
497 0 : function createApiKeyIdentity(): WebSessionIdentity {
498 0 : const state: WebSessionIdentityState = { phase: 'api_key' }
499 0 : return {
500 : getState: () => state,
501 : subscribe: (listener) => {
502 0 : listener(state)
503 0 : return () => undefined
504 : },
505 : boot: () => undefined,
506 : signedIn: async () => ({
507 : status: 'error',
508 : code: 'SESSION_REQUEST_REFUSED',
509 : retryable: false
510 : }),
511 : signOut: async () => ({ status: 'ok' }),
512 : refresh: async () => state,
513 : getEpoch: () => 0,
514 : dispose: () => undefined
515 : }
516 : }
517 :
518 0 : function createAccountIdentity(
519 : options: WebSessionIdentityOptions,
520 : login: RememberedLogin
521 : ): WebSessionIdentity {
522 0 : const schedule = options.schedule ?? scheduleWithTimer
523 0 : const retryBaseMs = options.retryBaseMs ?? 1000
524 0 : const retryMaxMs = options.retryMaxMs ?? 60_000
525 0 : const heartbeat = options.heartbeat
526 0 : const listeners = new Set<(state: WebSessionIdentityState) => void>()
527 0 : let state: WebSessionIdentityState = { phase: 'idle' }
528 0 : let epoch = 0
529 0 : let signOuts = 0
530 0 : let signIns = 0
531 0 : let liveSignIn = 0
532 0 : let cancelRetry: (() => void) | undefined
533 0 : let cancelProofRetry: (() => void) | undefined
534 0 : let cancelBeat: (() => void) | undefined
535 0 : let releaseLeadership: (() => void) | undefined
536 0 : let stopWatching: (() => void)[] = []
537 0 : let restoring = { epoch, settled: Promise.resolve(), inFlight: false }
538 :
539 0 : function dispatch(event: WebSessionIdentityEvent): void {
540 0 : const next = transitionWebSessionIdentity(state, event)
541 0 : const changed = next.state !== state
542 0 : if (changed) {
543 0 : cancelProofRetry?.()
544 0 : cancelProofRetry = undefined
545 : }
546 0 : state = next.state
547 0 : next.effects.forEach(run)
548 0 : if (changed) listeners.forEach((listener) => listener(state))
549 0 : syncLeadership()
550 : }
551 :
552 0 : function publish(from: SharedFrom, result: WebSessionResult): void {
553 0 : heartbeat?.crossTab?.publishCredential(HEARTBEAT_KEY, { from, result })
554 : }
555 :
556 : type Answered =
557 : | { readonly type: 'read_answered' | 'restore_answered' }
558 : | { readonly type: 'session_observed'; readonly from: SessionObservedFrom }
559 :
560 0 : async function answer(
561 : started: number,
562 : answered: Answered,
563 : request: () => Promise<WebSessionResult>
564 : ): Promise<void> {
565 0 : const result = await request()
566 0 : const remembered = await login.currentUserId().then(
567 : (value) => ({ value }),
568 : () => undefined
569 : )
570 0 : if (started !== epoch) return
571 : // A failed lookup matters only without a live session to adopt: with one,
572 : // it can skip nothing but the different-user sign-out.
573 0 : if (remembered === undefined && result.status !== 'ok') {
574 0 : return dispatch({ type: 'login_errored' })
575 : }
576 0 : dispatch({
577 : ...answered,
578 : result,
579 : rememberedUserId: remembered?.value ?? null
580 : })
581 : }
582 :
583 0 : function beat(): Promise<void> {
584 0 : const started = epoch
585 : const observed = { type: 'session_observed', from: 'this_tab' } as const
586 0 : return answer(started, observed, async () => {
587 0 : const result = await readWebSession(options.session)
588 : const shared = result.status === 'ok' || result.code === 'SESSION_REVOKED'
589 0 : if (shared && started === epoch) publish('heartbeat', result)
590 0 : return result
591 : })
592 : }
593 :
594 0 : function invalidatePendingSignIns(): void {
595 0 : signOuts += 1
596 0 : liveSignIn = 0
597 : }
598 :
599 0 : function adopt(message: unknown): void {
600 0 : const parsed = zSharedMessage.safeParse(message)
601 0 : if (!parsed.success) return
602 0 : const { from, result } = parsed.data
603 0 : if (from === 'sign_out') invalidatePendingSignIns()
604 0 : const observed = {
605 : type: 'session_observed',
606 : from: `sibling_${from}`
607 : } as const
608 0 : void answer(epoch, observed, async () => result)
609 : }
610 :
611 0 : function wantsBeat(): boolean {
612 0 : return (
613 : stopWatching.length > 0 &&
614 : state.phase === 'signed_in' &&
615 : heartbeat?.visibility.isVisible() === true
616 : )
617 : }
618 :
619 0 : function armBeat(): void {
620 0 : cancelBeat = schedule(() => {
621 0 : void beat()
622 0 : armBeat()
623 : }, heartbeat?.intervalMs ?? HEARTBEAT_INTERVAL_MS)
624 : }
625 :
626 0 : function lead(): void {
627 0 : if (wantsBeat() && cancelBeat === undefined) armBeat()
628 : }
629 :
630 0 : function syncLeadership(): void {
631 0 : const wanted = wantsBeat()
632 0 : if (wanted && releaseLeadership === undefined) {
633 0 : const port = heartbeat?.crossTab
634 0 : if (port) {
635 0 : releaseLeadership = port.requestLeadership(HEARTBEAT_KEY, lead)
636 : } else {
637 0 : releaseLeadership = () => undefined
638 0 : lead()
639 : }
640 0 : } else if (!wanted && releaseLeadership !== undefined) {
641 0 : releaseLeadership()
642 0 : releaseLeadership = undefined
643 0 : cancelBeat?.()
644 0 : cancelBeat = undefined
645 : }
646 : }
647 :
648 0 : function watch(): void {
649 0 : if (heartbeat === undefined) return
650 0 : const { visibility, crossTab } = heartbeat
651 0 : stopWatching = [
652 : visibility.onChange((visible) => {
653 0 : if (visible && state.phase === 'signed_in') void beat()
654 0 : syncLeadership()
655 : }),
656 : ...(crossTab ? [crossTab.onCredential(HEARTBEAT_KEY, adopt)] : [])
657 : ]
658 : }
659 :
660 0 : function proofWithinTimeout(): Promise<{ value: string | null } | undefined> {
661 0 : return new Promise((resolve) => {
662 0 : const cancel = schedule(() => resolve(undefined), PROOF_TIMEOUT_MS)
663 0 : login.getProof().then(
664 : (value) => {
665 0 : cancel()
666 0 : resolve({ value })
667 : },
668 : () => {
669 0 : cancel()
670 0 : resolve(undefined)
671 : }
672 : )
673 : })
674 : }
675 :
676 0 : async function restore(
677 : started: number,
678 : expectedUserId: string,
679 : retried: boolean
680 : ): Promise<void> {
681 0 : const proof = await proofWithinTimeout()
682 0 : if (started !== epoch) return
683 0 : if (proof === undefined) {
684 0 : if (!retried && state.phase === 'signed_in') {
685 0 : cancelProofRetry?.()
686 0 : cancelProofRetry = schedule(() => {
687 0 : cancelProofRetry = undefined
688 0 : if (started === epoch && state.phase === 'signed_in') {
689 0 : startRestore(expectedUserId, true)
690 : }
691 : }, retryBaseMs)
692 : }
693 0 : return dispatch({ type: 'proof_errored' })
694 : }
695 0 : const { value } = proof
696 0 : if (value === null) return dispatch({ type: 'proof_missing' })
697 0 : await answer(started, { type: 'restore_answered' }, () =>
698 : createWebSession(options.session, async () => value, { expectedUserId })
699 : )
700 : }
701 :
702 0 : function startRestore(expectedUserId: string, retried: boolean): void {
703 0 : if (restoring.inFlight && restoring.epoch === epoch) return
704 0 : const settled = restore(epoch, expectedUserId, retried).finally(() => {
705 0 : if (restoring.settled === settled) {
706 0 : restoring = { ...restoring, inFlight: false }
707 : }
708 : })
709 0 : restoring = { epoch, settled, inFlight: true }
710 : }
711 :
712 0 : function run(effect: WebSessionIdentityEffect): void {
713 0 : switch (effect.type) {
714 : case 'read':
715 0 : void answer(epoch, { type: 'read_answered' }, () =>
716 : readWebSession(options.session)
717 : )
718 0 : return
719 : case 'restore':
720 0 : startRestore(effect.expectedUserId, false)
721 0 : return
722 : case 'schedule_retry':
723 0 : cancelRetry = schedule(
724 : () => {
725 0 : cancelRetry = undefined
726 0 : dispatch({ type: 'retry_due' })
727 : },
728 : Math.min(retryBaseMs * 2 ** (effect.failures - 1), retryMaxMs)
729 : )
730 0 : return
731 : case 'sign_out_locally':
732 0 : login.signOutLocally().catch(reportLocalSignOutFailure)
733 0 : return
734 : default:
735 0 : notify(effect)
736 : }
737 : }
738 :
739 0 : function notify(effect: WebSessionIdentityEffect): void {
740 0 : switch (effect.type) {
741 : case 'report':
742 0 : options.onBootstrap?.({
743 : outcome: effect.outcome,
744 : origin: options.origin
745 : })
746 0 : return
747 : case 'account_changed':
748 0 : epoch += 1
749 0 : options.onAccountChanged?.({ ...effect.change, epoch })
750 0 : return
751 : case 'report_signed_out_remotely':
752 0 : options.onSignedOutRemotely?.({ origin: options.origin })
753 : }
754 : }
755 :
756 0 : function stopHeartbeat(): void {
757 0 : stopWatching.forEach((stop) => stop())
758 0 : stopWatching = []
759 0 : syncLeadership()
760 : }
761 :
762 0 : return {
763 : getState: () => state,
764 : subscribe: (listener) => {
765 0 : listeners.add(listener)
766 0 : listener(state)
767 0 : return () => {
768 0 : listeners.delete(listener)
769 : }
770 : },
771 : boot: () => {
772 0 : if (state.phase !== 'idle') return
773 0 : watch()
774 0 : dispatch({ type: 'boot' })
775 : },
776 : signedIn: async (getProof) => {
777 0 : const signOutsAtStart = signOuts
778 0 : const signIn = ++signIns
779 0 : const result = await createWebSession(options.session, getProof)
780 0 : if (result.status !== 'ok') return result
781 0 : if (signOuts !== signOutsAtStart) {
782 : // A later sign-in owns the cookie now; deleting would end its session.
783 0 : if (liveSignIn > signIn) return revoked
784 0 : const cleanup = await deleteWebSession(options.session)
785 0 : return cleanup.status === 'ok' ? revoked : cleanup
786 : }
787 0 : liveSignIn = signIn
788 0 : dispatch({ type: 'session_created', session: result.session })
789 0 : publish('sign_in', result)
790 0 : return result
791 : },
792 : signOut: async () => {
793 0 : invalidatePendingSignIns()
794 0 : dispatch({ type: 'sign_out_requested' })
795 0 : const result = await deleteWebSession(options.session)
796 0 : if (result.status === 'ok') publish('sign_out', revoked)
797 0 : return result
798 : },
799 : refresh: async (expectedUserId) => {
800 0 : if (state.phase !== 'signed_in') return state
801 0 : if ((expectedUserId ?? state.session.user.id) !== state.session.user.id) {
802 0 : return state
803 : }
804 0 : await beat()
805 0 : if (restoring.epoch === epoch) await restoring.settled
806 0 : return state
807 : },
808 : getEpoch: () => epoch,
809 : dispose: () => {
810 0 : epoch += 1
811 0 : cancelRetry?.()
812 0 : cancelRetry = undefined
813 0 : cancelProofRetry?.()
814 0 : cancelProofRetry = undefined
815 0 : stopHeartbeat()
816 0 : state = { phase: 'idle' }
817 0 : listeners.forEach((listener) => listener(state))
818 : }
819 : }
820 : }
821 :
822 : /** Inert until `boot()`: constructing it sends no request and arms no timer. */
823 0 : export function createWebSessionIdentity(
824 : options: WebSessionIdentityOptions
825 : ): WebSessionIdentity {
826 0 : return options.principal.kind === 'api_key'
827 : ? createApiKeyIdentity()
828 : : createAccountIdentity(options, options.principal.rememberedLogin)
829 : }
|