diff --git a/packages/account-core/src/core/sessionContracts.ts b/packages/account-core/src/core/sessionContracts.ts index 9f449efe81a..e57a2d87297 100644 --- a/packages/account-core/src/core/sessionContracts.ts +++ b/packages/account-core/src/core/sessionContracts.ts @@ -96,14 +96,14 @@ export interface MintHandle { * (`createWebCrossTabRefreshPort` from `@comfyorg/account-core/web`); tests pass * fakes. */ -export interface CrossTabRefreshPort { +export interface CrossTabRefreshPort { /** * Queue for the key's lease. `onAcquired` fires if and when this tab * becomes leader; the returned function abandons the request or releases * held leadership. */ requestLeadership: (key: string, onAcquired: () => void) => () => void - publishCredential: (key: string, credential: AccountCredential) => void + publishCredential: (key: string, credential: Message) => void /** Messages cross a serialization boundary; the client validates them. */ onCredential: ( key: string, diff --git a/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts b/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts new file mode 100644 index 00000000000..00c8e04fd09 --- /dev/null +++ b/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts @@ -0,0 +1,554 @@ +import { describe, expect, it, vi } from 'vitest' + +import type { FakeWebSessionEndpoint, FakeWebSessionState } from '../testing.js' +import { createFakeWebSessionEndpoint, fakeWebSessionUser } from '../testing.js' +import type { + CrossTabRefreshPort, + WebSession, + WebSessionResult +} from './sessionContracts.js' +import type { + RememberedLogin, + ScheduleRetry, + VisibilityPort, + WebSessionIdentityOptions, + WebSessionIdentityState, + WebSessionIdentityTransition, + WebSessionSharedMessage +} from './webSessionIdentity.js' +import { + createWebSessionIdentity, + transitionWebSessionIdentity +} from './webSessionIdentity.js' + +const API = 'https://cloud.example/api' +const ORIGIN = 'https://www.comfy.example' +const HEARTBEAT_MS = 10 * 60 * 1000 +const USER_1 = fakeWebSessionUser({ id: 'user-1' }) +const USER_2 = fakeWebSessionUser({ id: 'user-2', email: 'user-2@example.com' }) + +type AccountChange = Parameters< + NonNullable +>[0] + +function createFakeScheduler() { + const pending: { run: () => void; delayMs: number }[] = [] + const schedule: ScheduleRetry = (run, delayMs) => { + const timer = { run, delayMs } + pending.push(timer) + return () => { + const index = pending.indexOf(timer) + if (index !== -1) pending.splice(index, 1) + } + } + return { + schedule, + delays: () => pending.map(({ delayMs }) => delayMs), + fire: (delayMs: number) => { + const timer = pending.find((candidate) => candidate.delayMs === delayMs) + if (!timer) throw new Error(`no timer armed for ${delayMs}ms`) + pending.splice(pending.indexOf(timer), 1) + timer.run() + } + } +} + +function createFakeVisibility(initial: boolean) { + const listeners = new Set<(visible: boolean) => void>() + let visible = initial + const port: VisibilityPort = { + isVisible: () => visible, + onChange: (listener) => { + listeners.add(listener) + return () => { + listeners.delete(listener) + } + } + } + return { + port, + set: (next: boolean) => { + visible = next + listeners.forEach((listener) => listener(next)) + } + } +} + +/** One site's Web Locks + BroadcastChannel: the first requester leads. */ +function createFakeSiteBus() { + const waiters: { onAcquired: () => void }[] = [] + const subscribers: { tab: object; callback: (message: unknown) => void }[] = + [] + return (): CrossTabRefreshPort => { + const tab = {} + return { + requestLeadership: (_key, onAcquired) => { + const waiter = { onAcquired } + waiters.push(waiter) + if (waiters.length === 1) onAcquired() + return () => { + const index = waiters.indexOf(waiter) + if (index === -1) return + waiters.splice(index, 1) + if (index === 0) waiters[0]?.onAcquired() + } + }, + publishCredential: (_key, message) => { + subscribers + .filter((subscriber) => subscriber.tab !== tab) + .forEach(({ callback }) => callback(structuredClone(message))) + }, + onCredential: (_key, callback) => { + const subscriber = { tab, callback } + subscribers.push(subscriber) + return () => { + subscribers.splice(subscribers.indexOf(subscriber), 1) + } + } + } + } +} + +function fakeRememberedLogin(userId: string | null) { + return { + currentUserId: vi.fn(async () => userId), + getProof: vi.fn(async () => 'remembered-proof'), + signOutLocally: vi.fn(async () => undefined) + } satisfies RememberedLogin +} + +function openTab({ + endpoint, + site, + visible = true, + remembered = 'user-1', + fetchImpl = endpoint.fetch +}: { + endpoint: FakeWebSessionEndpoint + site?: () => CrossTabRefreshPort + visible?: boolean + remembered?: string | null + fetchImpl?: typeof fetch +}) { + const scheduler = createFakeScheduler() + const visibility = createFakeVisibility(visible) + const login = fakeRememberedLogin(remembered) + const changes: AccountChange[] = [] + const remoteSignOuts: { origin: string }[] = [] + const identity = createWebSessionIdentity({ + session: { apiBaseUrl: API, fetchImpl }, + principal: { kind: 'account', rememberedLogin: login }, + origin: ORIGIN, + heartbeat: { visibility: visibility.port, crossTab: site?.() }, + schedule: scheduler.schedule, + onAccountChanged: (change) => changes.push(change), + onSignedOutRemotely: (event) => remoteSignOuts.push(event) + }) + identity.boot() + return { scheduler, visibility, login, changes, remoteSignOuts, identity } +} + +function liveEndpoint( + state: FakeWebSessionState = { kind: 'live', user: USER_1 } +) { + return createFakeWebSessionEndpoint({ state, signInUser: USER_2 }) +} + +const settle = () => new Promise((resolve) => setTimeout(resolve, 0)) + +function summarize(state: WebSessionIdentityState): string { + if (state.phase === 'signed_in') return `signed_in:${state.session.user.id}` + if (state.phase === 'signed_out') return `signed_out:${state.outcome}` + return state.phase +} + +function methods(endpoint: FakeWebSessionEndpoint): string[] { + return endpoint.requests.map(({ method }) => method) +} + +describe('heartbeat', () => { + it('reads every 10 minutes while visible, with GET only', async () => { + const endpoint = liveEndpoint() + const tab = openTab({ endpoint }) + await settle() + expect(tab.scheduler.delays()).toEqual([HEARTBEAT_MS]) + + tab.scheduler.fire(HEARTBEAT_MS) + await settle() + tab.scheduler.fire(HEARTBEAT_MS) + await settle() + + expect(methods(endpoint)).toEqual(['GET', 'GET', 'GET']) + expect(tab.scheduler.delays()).toEqual([HEARTBEAT_MS]) + }) + + it('arms nothing on a hidden tab and reads at once when it becomes visible', async () => { + const endpoint = liveEndpoint() + const tab = openTab({ endpoint, visible: false }) + await settle() + expect(tab.scheduler.delays()).toEqual([]) + + tab.visibility.set(true) + await settle() + + expect(methods(endpoint)).toEqual(['GET', 'GET']) + expect(tab.scheduler.delays()).toEqual([HEARTBEAT_MS]) + + tab.visibility.set(false) + expect(tab.scheduler.delays()).toEqual([]) + }) + + it('stops for good on dispose', async () => { + const endpoint = liveEndpoint() + const tab = openTab({ endpoint }) + await settle() + + tab.identity.dispose() + tab.visibility.set(true) + await settle() + + expect(tab.scheduler.delays()).toEqual([]) + expect(methods(endpoint)).toEqual(['GET']) + }) +}) + +describe('tabs of one site', () => { + it('lets only the leader read; followers adopt its answer', async () => { + const endpoint = liveEndpoint() + const site = createFakeSiteBus() + const leader = openTab({ endpoint, site }) + const follower = openTab({ endpoint, site }) + await settle() + expect(follower.scheduler.delays()).toEqual([]) + + endpoint.state = { kind: 'live', user: USER_2 } + leader.scheduler.fire(HEARTBEAT_MS) + await settle() + + expect(methods(endpoint)).toEqual(['GET', 'GET', 'GET']) + expect(summarize(follower.identity.getState())).toBe('signed_in:user-2') + expect(follower.changes).toEqual([ + expect.objectContaining({ reason: 'user_changed', epoch: 1 }) + ]) + }) + + it('hands leadership to a visible sibling when the leader is hidden', async () => { + const endpoint = liveEndpoint() + const site = createFakeSiteBus() + const first = openTab({ endpoint, site }) + const second = openTab({ endpoint, site }) + await settle() + + first.visibility.set(false) + await settle() + + expect(first.scheduler.delays()).toEqual([]) + expect(second.scheduler.delays()).toEqual([HEARTBEAT_MS]) + }) + + it('ignores a message that is not a session answer', async () => { + const endpoint = liveEndpoint() + const site = createFakeSiteBus() + const tab = openTab({ endpoint, site }) + await settle() + + site().publishCredential('any', { + from: 'heartbeat', + result: { status: 'error', code: 'NO_SESSION', retryable: false } + }) + await settle() + + expect(summarize(tab.identity.getState())).toBe('signed_in:user-1') + }) + + it('follows a sibling that signs in or out', async () => { + const endpoint = liveEndpoint({ kind: 'dead', code: 'no_session' }) + const site = createFakeSiteBus() + const acting = openTab({ endpoint, site, remembered: null }) + const sibling = openTab({ endpoint, site, remembered: null }) + await settle() + + await acting.identity.signedIn(async () => 'fresh-proof') + await settle() + expect(summarize(sibling.identity.getState())).toBe('signed_in:user-2') + + await acting.identity.signOut() + await settle() + expect(summarize(sibling.identity.getState())).toBe('signed_out:revoked') + expect(sibling.login.signOutLocally).toHaveBeenCalledOnce() + expect(sibling.remoteSignOuts).toEqual([]) + }) + + it('a tab that signed out is not signed back in by a sibling heartbeat', async () => { + const endpoint = liveEndpoint() + const site = createFakeSiteBus() + const tab = openTab({ endpoint, site }) + await settle() + + await tab.identity.signOut() + const lateAnswer: WebSessionSharedMessage = { + from: 'heartbeat', + result: { + status: 'ok', + session: { + user: USER_1, + csrfToken: 'csrf-late', + expiresAt: Date.now() + HEARTBEAT_MS, + absoluteExpiresAt: Date.now() + 2 * HEARTBEAT_MS + } + } + } + site().publishCredential('any', lateAnswer) + await settle() + + expect(summarize(tab.identity.getState())).toBe('signed_out:signed_out') + expect(tab.changes).toEqual([ + { reason: 'signed_out', outcome: 'signed_out', epoch: 1 } + ]) + }) + + it('one revocation is reported once, by the tab that read it', async () => { + const endpoint = liveEndpoint() + const site = createFakeSiteBus() + const leader = openTab({ endpoint, site }) + const follower = openTab({ endpoint, site }) + await settle() + + endpoint.state = { kind: 'dead', code: 'session_revoked' } + leader.scheduler.fire(HEARTBEAT_MS) + await settle() + + expect(summarize(follower.identity.getState())).toBe('signed_out:revoked') + expect(follower.login.signOutLocally).toHaveBeenCalledOnce() + expect(leader.remoteSignOuts).toEqual([{ origin: ORIGIN }]) + expect(follower.remoteSignOuts).toEqual([]) + }) +}) + +describe('signing in and out', () => { + it('creates a session only through an interactive sign-in, never on a beat', async () => { + const endpoint = liveEndpoint({ kind: 'dead', code: 'no_session' }) + const tab = openTab({ endpoint, remembered: null }) + await settle() + expect(summarize(tab.identity.getState())).toBe('signed_out:signed_out') + + const result = await tab.identity.signedIn(async () => 'fresh-proof') + await settle() + tab.scheduler.fire(HEARTBEAT_MS) + await settle() + tab.scheduler.fire(HEARTBEAT_MS) + await settle() + + expect(result.status).toBe('ok') + expect(summarize(tab.identity.getState())).toBe('signed_in:user-2') + expect(methods(endpoint)).toEqual(['GET', 'POST', 'GET', 'GET', 'GET']) + expect(tab.login.getProof).not.toHaveBeenCalled() + }) + + it('signs out at once and deletes the session, even a dead one', async () => { + const endpoint = liveEndpoint() + const tab = openTab({ endpoint }) + await settle() + endpoint.state = { kind: 'dead', code: 'session_expired' } + + const deleting = tab.identity.signOut() + expect(summarize(tab.identity.getState())).toBe('signed_out:signed_out') + + expect(await deleting).toEqual({ status: 'ok' }) + expect(methods(endpoint)).toEqual(['GET', 'DELETE']) + expect(tab.login.signOutLocally).toHaveBeenCalledOnce() + expect(tab.changes).toEqual([ + { reason: 'signed_out', outcome: 'signed_out', epoch: 1 } + ]) + expect(tab.remoteSignOuts).toEqual([]) + expect(tab.scheduler.delays()).toEqual([]) + }) + + it('a sign-out on one site signs an open tab on another out at its next beat', async () => { + const endpoint = liveEndpoint() + const website = openTab({ endpoint, site: createFakeSiteBus() }) + const cloud = openTab({ endpoint, site: createFakeSiteBus() }) + await settle() + + await website.identity.signOut() + cloud.scheduler.fire(HEARTBEAT_MS) + await settle() + + expect(summarize(cloud.identity.getState())).toBe('signed_out:revoked') + expect(cloud.login.signOutLocally).toHaveBeenCalledOnce() + expect(cloud.remoteSignOuts).toEqual([{ origin: ORIGIN }]) + expect(cloud.changes).toEqual([ + { reason: 'signed_out', outcome: 'revoked', epoch: 1 } + ]) + }) +}) + +describe('account change under an open tab', () => { + it('discards an answer started under the old account', async () => { + const endpoint = liveEndpoint() + const site = createFakeSiteBus() + let holdNext = false + let release: () => void = () => undefined + const held: typeof fetch = async (input, init) => { + const response = await endpoint.fetch(input, init) + if (!holdNext) return response + holdNext = false + return new Promise((resolve) => { + release = () => resolve(response) + }) + } + const leader = openTab({ endpoint, site }) + const stale = openTab({ endpoint, site, visible: false, fetchImpl: held }) + await settle() + const pendingAction = stale.identity.getEpoch() + + holdNext = true + stale.visibility.set(true) + await settle() + endpoint.state = { kind: 'live', user: USER_2 } + leader.scheduler.fire(HEARTBEAT_MS) + await settle() + release() + await settle() + + expect(summarize(stale.identity.getState())).toBe('signed_in:user-2') + expect(stale.changes).toHaveLength(1) + expect(stale.identity.getEpoch()).not.toBe(pendingAction) + }) +}) + +function session(userId: string, csrfToken = 'csrf-1'): WebSession { + return { + user: fakeWebSessionUser({ id: userId }), + csrfToken, + expiresAt: 1, + absoluteExpiresAt: 2 + } +} + +const SIGNED_IN: WebSessionIdentityState = { + phase: 'signed_in', + session: session('user-1') +} + +function failure( + code: Extract['code'] +): WebSessionResult { + return { status: 'error', code, retryable: code === 'SESSION_UNAVAILABLE' } +} + +describe('a heartbeat answer while signed in', () => { + it.for([ + { + name: 'same user adopts the new CSRF token', + result: { status: 'ok', session: session('user-1', 'csrf-2') }, + remembered: 'user-1', + expected: { + state: { phase: 'signed_in', session: session('user-1', 'csrf-2') }, + effects: [] + } + }, + { + name: 'another user replaces the account and signs the old login out', + result: { status: 'ok', session: session('user-2') }, + remembered: 'user-1', + expected: { + state: { phase: 'signed_in', session: session('user-2') }, + effects: [ + { type: 'sign_out_locally' }, + { + type: 'account_changed', + change: { reason: 'user_changed', session: session('user-2') } + } + ] + } + }, + { + name: 'SESSION_UNAVAILABLE keeps the account for the next beat', + result: failure('SESSION_UNAVAILABLE'), + remembered: 'user-1', + expected: { state: SIGNED_IN, effects: [] } + }, + { + name: 'an ambiguous refusal keeps the account', + result: failure('CSRF_STALE'), + remembered: 'user-1', + expected: { state: SIGNED_IN, effects: [] } + }, + { + name: 'revoked signs out remotely', + result: failure('SESSION_REVOKED'), + remembered: 'user-1', + expected: { + state: { phase: 'signed_out', outcome: 'revoked' }, + effects: [ + { type: 'sign_out_locally' }, + { type: 'report_signed_out_remotely' }, + { + type: 'account_changed', + change: { reason: 'signed_out', outcome: 'revoked' } + } + ] + } + }, + { + name: 'no session with a remembered login restores in place', + result: failure('NO_SESSION'), + remembered: 'user-1', + expected: { + state: SIGNED_IN, + effects: [{ type: 'restore', expectedUserId: 'user-1' }] + } + }, + { + name: 'an expired session without a remembered login signs out', + result: failure('SESSION_EXPIRED'), + remembered: null, + expected: { + state: { phase: 'signed_out', outcome: 'signed_out' }, + effects: [ + { + type: 'account_changed', + change: { reason: 'signed_out', outcome: 'signed_out' } + } + ] + } + } + ] satisfies { + name: string + result: WebSessionResult + remembered: string | null + expected: WebSessionIdentityTransition + }[])('$name', ({ result, remembered, expected }) => { + expect( + transitionWebSessionIdentity(SIGNED_IN, { + type: 'session_observed', + from: 'this_tab', + result, + rememberedUserId: remembered + }) + ).toEqual(expected) + }) + + it.for([ + { event: 'proof_errored', phase: 'signed_in' }, + { event: 'proof_missing', phase: 'signed_out' } + ] as const)( + 'a heartbeat restore whose proof is $event leaves the tab $phase', + ({ event, phase }) => { + expect( + transitionWebSessionIdentity(SIGNED_IN, { type: event }).state.phase + ).toBe(phase) + } + ) + + it('a failed heartbeat restore signs out instead of restoring again', () => { + expect( + transitionWebSessionIdentity(SIGNED_IN, { + type: 'restore_answered', + result: failure('NO_SESSION'), + rememberedUserId: 'user-1' + }).state + ).toEqual({ phase: 'signed_out', outcome: 'restore_failed' }) + }) +}) diff --git a/packages/account-core/src/core/webSessionIdentity.ts b/packages/account-core/src/core/webSessionIdentity.ts index 0a88bae8cd6..8f033e72421 100644 --- a/packages/account-core/src/core/webSessionIdentity.ts +++ b/packages/account-core/src/core/webSessionIdentity.ts @@ -3,13 +3,21 @@ * and follows the server's answer. It keeps no record of past sessions, and * the remembered provider login is an opaque port, so no provider leaks in. */ +import { z } from 'zod' + import type { + CrossTabRefreshPort, WebSession, + WebSessionCommandResult, WebSessionFailure, WebSessionResult } from './sessionContracts.js' import type { WebSessionOptions } from './webSession.js' -import { createWebSession, readWebSession } from './webSession.js' +import { + createWebSession, + deleteWebSession, + readWebSession +} from './webSession.js' export interface RememberedLogin { /** The Comfy user id of the login this browser remembers, or null. */ @@ -37,6 +45,11 @@ export interface WebSessionBootstrapEvent { type SignedOutOutcome = Exclude +/** The account this tab holds changed under it, or went away. */ +export type WebSessionAccountChange = + | { readonly reason: 'user_changed'; readonly session: WebSession } + | { readonly reason: 'signed_out'; readonly outcome: SignedOutOutcome } + export type WebSessionIdentityState = | { readonly phase: 'idle' } | { readonly phase: 'api_key' } @@ -47,6 +60,13 @@ export type WebSessionIdentityState = | { readonly phase: 'signed_in'; readonly session: WebSession } | { readonly phase: 'signed_out'; readonly outcome: SignedOutOutcome } +/** Only a sibling's sign-in is news to a tab that has signed out. */ +export type SessionObservedFrom = + | 'this_tab' + | 'sibling_heartbeat' + | 'sibling_sign_in' + | 'sibling_sign_out' + export type WebSessionIdentityEvent = | { readonly type: 'boot' } | { @@ -56,6 +76,15 @@ export type WebSessionIdentityEvent = } | { readonly type: 'proof_missing' | 'proof_errored' | 'login_errored' } | { readonly type: 'retry_due' } + /** A heartbeat answer, this tab's or one a sibling tab published. */ + | { + readonly type: 'session_observed' + readonly from: SessionObservedFrom + readonly result: WebSessionResult + readonly rememberedUserId: string | null + } + | { readonly type: 'session_created'; readonly session: WebSession } + | { readonly type: 'sign_out_requested' } export type WebSessionIdentityEffect = | { readonly type: 'read' } @@ -63,6 +92,11 @@ export type WebSessionIdentityEffect = | { readonly type: 'schedule_retry'; readonly failures: number } | { readonly type: 'sign_out_locally' } | { readonly type: 'report'; readonly outcome: WebSessionBootOutcome } + | { + readonly type: 'account_changed' + readonly change: WebSessionAccountChange + } + | { readonly type: 'report_signed_out_remotely' } export interface WebSessionIdentityTransition { readonly state: WebSessionIdentityState @@ -72,17 +106,24 @@ export interface WebSessionIdentityTransition { const read: WebSessionIdentityEffect = { type: 'read' } const signOutLocally: WebSessionIdentityEffect = { type: 'sign_out_locally' } +function signOutDifferentLogin( + session: WebSession, + rememberedUserId: string | null +): WebSessionIdentityEffect[] { + return rememberedUserId !== null && rememberedUserId !== session.user.id + ? [signOutLocally] + : [] +} + function settleSignedIn( session: WebSession, rememberedUserId: string | null, outcome: 'signed_in' | 'restored' ): WebSessionIdentityTransition { - const loginDiffers = - rememberedUserId !== null && rememberedUserId !== session.user.id return { state: { phase: 'signed_in', session }, effects: [ - ...(loginDiffers ? [signOutLocally] : []), + ...signOutDifferentLogin(session, rememberedUserId), { type: 'report', outcome } ] } @@ -142,69 +183,230 @@ function applyRestoreAnswered( return settleSignedOut('restore_failed') } -/** A remembered-login lookup can fail while reading; a proof only while restoring. */ -function transientLookupError( - state: WebSessionIdentityState, - event: 'proof_errored' | 'login_errored' +function leaveAccount( + outcome: SignedOutOutcome, + effects: readonly WebSessionIdentityEffect[] = [] ): WebSessionIdentityTransition { - const retries = - state.phase === 'restoring' || - (state.phase === 'reading' && event === 'login_errored') - return retries ? waitToRetry(state.failures + 1) : { state, effects: [] } + return { + state: { phase: 'signed_out', outcome }, + effects: [ + ...effects, + { type: 'account_changed', change: { reason: 'signed_out', outcome } } + ] + } } -/** Pure: an event that means nothing in the current phase changes nothing. */ -export function transitionWebSessionIdentity( - state: WebSessionIdentityState, +function replaceSession( + held: WebSession, + session: WebSession, + effects: readonly WebSessionIdentityEffect[] = [] +): WebSessionIdentityTransition { + const state: WebSessionIdentityState = { phase: 'signed_in', session } + if (session.user.id === held.user.id) return { state, effects: [] } + return { + state, + effects: [ + ...effects, + { type: 'account_changed', change: { reason: 'user_changed', session } } + ] + } +} + +/** A read never signs out on doubt: only revoked or no live session does. */ +function observeWhileSignedIn( + state: Extract, + result: WebSessionResult, + rememberedUserId: string | null, + restored: boolean, + ownRead: boolean +): WebSessionIdentityTransition { + if (result.status === 'ok') { + return replaceSession( + state.session, + result.session, + signOutDifferentLogin(result.session, rememberedUserId) + ) + } + if (result.retryable) return { state, effects: [] } + if (result.code === 'SESSION_REVOKED') { + return leaveAccount( + 'revoked', + ownRead + ? [signOutLocally, { type: 'report_signed_out_remotely' }] + : [signOutLocally] + ) + } + if (restored) return leaveAccount('restore_failed') + if (!isNoLiveSession(result)) return { state, effects: [] } + if (rememberedUserId === null) return leaveAccount('signed_out') + return { + state, + effects: [{ type: 'restore', expectedUserId: rememberedUserId }] + } +} + +function transitionSignedIn( + state: Extract, event: WebSessionIdentityEvent ): WebSessionIdentityTransition { - const unchanged = { state, effects: [] } switch (event.type) { - case 'boot': - return state.phase === 'idle' - ? { - state: { phase: 'reading', failures: 0 }, - effects: [read] - } - : unchanged - case 'read_answered': - return state.phase === 'reading' - ? applyReadAnswered( - state.failures, - event.result, - event.rememberedUserId - ) - : unchanged + case 'session_observed': + return observeWhileSignedIn( + state, + event.result, + event.rememberedUserId, + false, + event.from === 'this_tab' + ) case 'restore_answered': - return state.phase === 'restoring' - ? applyRestoreAnswered( + return observeWhileSignedIn( + state, + event.result, + event.rememberedUserId, + true, + true + ) + case 'session_created': + return replaceSession(state.session, event.session) + case 'proof_missing': + return leaveAccount('restore_failed') + case 'sign_out_requested': + return leaveAccount('signed_out', [signOutLocally]) + default: + return { state, effects: [] } + } +} + +type SettlingState = Exclude< + WebSessionIdentityState, + { readonly phase: 'idle' | 'api_key' | 'signed_in' } +> + +function transitionRestoring( + state: Extract, + event: WebSessionIdentityEvent +): WebSessionIdentityTransition { + switch (event.type) { + case 'restore_answered': + return applyRestoreAnswered( + state.failures, + event.result, + event.rememberedUserId + ) + case 'proof_missing': + return settleSignedOut('restore_failed') + case 'proof_errored': + case 'login_errored': + return waitToRetry(state.failures + 1) + default: + return { state, effects: [] } + } +} + +function transitionBoot( + state: SettlingState, + event: WebSessionIdentityEvent +): WebSessionIdentityTransition { + switch (state.phase) { + case 'reading': + if (event.type === 'login_errored') return waitToRetry(state.failures + 1) + return event.type === 'read_answered' + ? applyReadAnswered( state.failures, event.result, event.rememberedUserId ) - : unchanged - case 'proof_missing': - return state.phase === 'restoring' - ? settleSignedOut('restore_failed') - : unchanged - case 'proof_errored': - case 'login_errored': - return transientLookupError(state, event.type) - case 'retry_due': - return state.phase === 'retry_wait' + : { state, effects: [] } + case 'retry_wait': + return event.type === 'retry_due' ? { state: { ...state, phase: 'reading' }, effects: [read] } - : unchanged + : { state, effects: [] } + case 'restoring': + return transitionRestoring(state, event) + default: + return { state, effects: [] } + } +} + +function transitionSettling( + state: SettlingState, + event: WebSessionIdentityEvent +): WebSessionIdentityTransition { + switch (event.type) { + case 'session_observed': { + const { result } = event + const adoptable = + state.phase === 'retry_wait' || + (state.phase === 'signed_out' && event.from === 'sibling_sign_in') + if (result.status !== 'ok' || !adoptable) return { state, effects: [] } + return { + state: { phase: 'signed_in', session: result.session }, + effects: signOutDifferentLogin(result.session, event.rememberedUserId) + } + } + case 'session_created': + return { + state: { phase: 'signed_in', session: event.session }, + effects: [] + } + case 'sign_out_requested': + return state.phase === 'signed_out' + ? { state, effects: [] } + : { + state: { phase: 'signed_out', outcome: 'signed_out' }, + effects: [signOutLocally] + } + default: + return transitionBoot(state, event) + } +} + +/** Pure: an event that means nothing in the current phase changes nothing. */ +export function transitionWebSessionIdentity( + state: WebSessionIdentityState, + event: WebSessionIdentityEvent +): WebSessionIdentityTransition { + switch (state.phase) { + case 'idle': + return event.type === 'boot' + ? { state: { phase: 'reading', failures: 0 }, effects: [read] } + : { state, effects: [] } + case 'api_key': + return { state, effects: [] } + case 'signed_in': + return transitionSignedIn(state, event) + default: + return transitionSettling(state, event) } } export type ScheduleRetry = (run: () => void, delayMs: number) => () => void +export interface VisibilityPort { + isVisible: () => boolean + onChange: (listener: (visible: boolean) => void) => () => void +} + +export interface WebSessionHeartbeatOptions { + readonly visibility: VisibilityPort + /** Without it every tab reads for itself. */ + readonly crossTab?: CrossTabRefreshPort + readonly intervalMs?: number +} + export interface WebSessionIdentityOptions { readonly session: WebSessionOptions readonly principal: WebSessionPrincipal /** The site reporting the boot, e.g. `https://www.comfy.org`. */ readonly origin: string readonly onBootstrap?: (event: WebSessionBootstrapEvent) => void + /** Telemetry for `session_signed_out_remotely`. */ + readonly onSignedOutRemotely?: (event: { readonly origin: string }) => void + /** The host drops pending actions and user-scoped state here. */ + readonly onAccountChanged?: ( + change: WebSessionAccountChange & { readonly epoch: number } + ) => void + readonly heartbeat?: WebSessionHeartbeatOptions readonly schedule?: ScheduleRetry readonly retryBaseMs?: number readonly retryMaxMs?: number @@ -214,12 +416,62 @@ export interface WebSessionIdentity { getState: () => WebSessionIdentityState /** Delivers the current state at once, then every change. */ subscribe: (listener: (state: WebSessionIdentityState) => void) => () => void - /** Starts the boot; a no-op unless idle. */ + /** Starts the boot and the heartbeat; a no-op unless idle. */ boot: () => void - /** Cancels the retry, ignores answers in flight, and returns to idle. */ + /** Only after an interactive sign-in; a token refresh must never call it. */ + signedIn: (getProof: () => Promise) => Promise + signOut: () => Promise + /** Changes with the account; an answer started under an older epoch is stale. */ + getEpoch: () => number + /** Cancels timers, ignores answers in flight, and returns to idle. */ dispose: () => void } +const HEARTBEAT_KEY = '@comfyorg/account-core web-session heartbeat' +const HEARTBEAT_INTERVAL_MS = 10 * 60 * 1000 + +const zSharedResult = z.discriminatedUnion('status', [ + z.object({ + status: z.literal('ok'), + session: z.object({ + user: z.object({ + id: z.string(), + email: z.string(), + name: z.string().optional(), + emailVerified: z.boolean(), + signInProvider: z.string().optional() + }), + csrfToken: z.string(), + expiresAt: z.number(), + absoluteExpiresAt: z.number() + }) + }), + z.object({ + status: z.literal('error'), + code: z.literal('SESSION_REVOKED'), + retryable: z.literal(false) + }) +]) + +const zSharedMessage = z.object({ + from: z.enum(['heartbeat', 'sign_in', 'sign_out']), + result: zSharedResult +}) + +type SharedFrom = z.infer['from'] + +/** What one tab of a site tells its siblings, and why. */ +export interface WebSessionSharedMessage { + readonly from: SharedFrom + readonly result: WebSessionResult +} + +const revoked: WebSessionResult = { + status: 'error', + code: 'SESSION_REVOKED', + retryable: false +} + const scheduleWithTimer: ScheduleRetry = (run, delayMs) => { const timer = setTimeout(run, delayMs) return () => clearTimeout(timer) @@ -238,6 +490,13 @@ function createApiKeyIdentity(): WebSessionIdentity { return () => undefined }, boot: () => undefined, + signedIn: async () => ({ + status: 'error', + code: 'SESSION_REQUEST_REFUSED', + retryable: false + }), + signOut: async () => ({ status: 'ok' }), + getEpoch: () => 0, dispose: () => undefined } } @@ -249,22 +508,35 @@ function createAccountIdentity( const schedule = options.schedule ?? scheduleWithTimer const retryBaseMs = options.retryBaseMs ?? 1000 const retryMaxMs = options.retryMaxMs ?? 60_000 + const heartbeat = options.heartbeat const listeners = new Set<(state: WebSessionIdentityState) => void>() let state: WebSessionIdentityState = { phase: 'idle' } - let generation = 0 + let epoch = 0 let cancelRetry: (() => void) | undefined + let cancelBeat: (() => void) | undefined + let releaseLeadership: (() => void) | undefined + let stopWatching: (() => void)[] = [] function dispatch(event: WebSessionIdentityEvent): void { const next = transitionWebSessionIdentity(state, event) - if (next.state === state) return + const changed = next.state !== state state = next.state - listeners.forEach((listener) => listener(state)) next.effects.forEach(run) + if (changed) listeners.forEach((listener) => listener(state)) + syncLeadership() + } + + function publish(from: SharedFrom, result: WebSessionResult): void { + heartbeat?.crossTab?.publishCredential(HEARTBEAT_KEY, { from, result }) } + type Answered = + | { readonly type: 'read_answered' | 'restore_answered' } + | { readonly type: 'session_observed'; readonly from: SessionObservedFrom } + async function answer( started: number, - type: 'read_answered' | 'restore_answered', + answered: Answered, request: () => Promise ): Promise { const result = await request() @@ -272,9 +544,80 @@ function createAccountIdentity( (value) => ({ value }), () => undefined ) - if (started !== generation) return + if (started !== epoch) return if (remembered === undefined) return dispatch({ type: 'login_errored' }) - dispatch({ type, result, rememberedUserId: remembered.value }) + dispatch({ ...answered, result, rememberedUserId: remembered.value }) + } + + function beat(): void { + const started = epoch + const observed = { type: 'session_observed', from: 'this_tab' } as const + void answer(started, observed, async () => { + const result = await readWebSession(options.session) + const shared = result.status === 'ok' || result.code === 'SESSION_REVOKED' + if (shared && started === epoch) publish('heartbeat', result) + return result + }) + } + + function adopt(message: unknown): void { + const parsed = zSharedMessage.safeParse(message) + if (!parsed.success) return + const { from, result } = parsed.data + const observed = { + type: 'session_observed', + from: `sibling_${from}` + } as const + void answer(epoch, observed, async () => result) + } + + function wantsBeat(): boolean { + return ( + stopWatching.length > 0 && + state.phase === 'signed_in' && + heartbeat?.visibility.isVisible() === true + ) + } + + function armBeat(): void { + cancelBeat = schedule(() => { + beat() + armBeat() + }, heartbeat?.intervalMs ?? HEARTBEAT_INTERVAL_MS) + } + + function lead(): void { + if (wantsBeat() && cancelBeat === undefined) armBeat() + } + + function syncLeadership(): void { + const wanted = wantsBeat() + if (wanted && releaseLeadership === undefined) { + const port = heartbeat?.crossTab + if (port) { + releaseLeadership = port.requestLeadership(HEARTBEAT_KEY, lead) + } else { + releaseLeadership = () => undefined + lead() + } + } else if (!wanted && releaseLeadership !== undefined) { + releaseLeadership() + releaseLeadership = undefined + cancelBeat?.() + cancelBeat = undefined + } + } + + function watch(): void { + if (heartbeat === undefined) return + const { visibility, crossTab } = heartbeat + stopWatching = [ + visibility.onChange((visible) => { + if (visible && state.phase === 'signed_in') beat() + syncLeadership() + }), + ...(crossTab ? [crossTab.onCredential(HEARTBEAT_KEY, adopt)] : []) + ] } async function restore( @@ -285,11 +628,11 @@ function createAccountIdentity( (value) => ({ value }), () => undefined ) - if (started !== generation) return + if (started !== epoch) return if (proof === undefined) return dispatch({ type: 'proof_errored' }) const { value } = proof if (value === null) return dispatch({ type: 'proof_missing' }) - await answer(started, 'restore_answered', () => + await answer(started, { type: 'restore_answered' }, () => createWebSession(options.session, async () => value, { expectedUserId }) ) } @@ -297,12 +640,12 @@ function createAccountIdentity( function run(effect: WebSessionIdentityEffect): void { switch (effect.type) { case 'read': - void answer(generation, 'read_answered', () => + void answer(epoch, { type: 'read_answered' }, () => readWebSession(options.session) ) return case 'restore': - void restore(generation, effect.expectedUserId) + void restore(epoch, effect.expectedUserId) return case 'schedule_retry': cancelRetry = schedule( @@ -316,14 +659,34 @@ function createAccountIdentity( case 'sign_out_locally': login.signOutLocally().catch(reportLocalSignOutFailure) return + default: + notify(effect) + } + } + + function notify(effect: WebSessionIdentityEffect): void { + switch (effect.type) { case 'report': options.onBootstrap?.({ outcome: effect.outcome, origin: options.origin }) + return + case 'account_changed': + epoch += 1 + options.onAccountChanged?.({ ...effect.change, epoch }) + return + case 'report_signed_out_remotely': + options.onSignedOutRemotely?.({ origin: options.origin }) } } + function stopHeartbeat(): void { + stopWatching.forEach((stop) => stop()) + stopWatching = [] + syncLeadership() + } + return { getState: () => state, subscribe: (listener) => { @@ -333,11 +696,30 @@ function createAccountIdentity( listeners.delete(listener) } }, - boot: () => dispatch({ type: 'boot' }), + boot: () => { + if (state.phase !== 'idle') return + watch() + dispatch({ type: 'boot' }) + }, + signedIn: async (getProof) => { + const result = await createWebSession(options.session, getProof) + if (result.status !== 'ok') return result + dispatch({ type: 'session_created', session: result.session }) + publish('sign_in', result) + return result + }, + signOut: async () => { + dispatch({ type: 'sign_out_requested' }) + const result = await deleteWebSession(options.session) + if (result.status === 'ok') publish('sign_out', revoked) + return result + }, + getEpoch: () => epoch, dispose: () => { - generation += 1 + epoch += 1 cancelRetry?.() cancelRetry = undefined + stopHeartbeat() state = { phase: 'idle' } listeners.forEach((listener) => listener(state)) } diff --git a/packages/account-core/src/web/crossTabRefresh.test.ts b/packages/account-core/src/web/crossTabRefresh.test.ts index 563891ee885..997413798f7 100644 --- a/packages/account-core/src/web/crossTabRefresh.test.ts +++ b/packages/account-core/src/web/crossTabRefresh.test.ts @@ -1,7 +1,10 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' import type { AccountCredential } from '../core/session.js' -import { createWebCrossTabRefreshPort } from './crossTabRefresh.js' +import { + createWebCrossTabRefreshPort, + createWebVisibilityPort +} from './crossTabRefresh.js' class FakeBroadcastChannel { static all: FakeBroadcastChannel[] = [] @@ -173,3 +176,25 @@ describe('createWebCrossTabRefreshPort channel lifecycle', () => { ) }) }) + +describe('createWebVisibilityPort', () => { + it('is absent without a document', () => { + expect(createWebVisibilityPort()).toBeUndefined() + }) + + it('reports the page visibility and each change until stopped', () => { + const page = Object.assign(new EventTarget(), { visibilityState: 'hidden' }) + vi.stubGlobal('document', page) + const port = createWebVisibilityPort() + const seen: boolean[] = [] + const stop = port?.onChange((visible) => seen.push(visible)) + + page.visibilityState = 'visible' + page.dispatchEvent(new Event('visibilitychange')) + stop?.() + page.dispatchEvent(new Event('visibilitychange')) + + expect(port?.isVisible()).toBe(true) + expect(seen).toEqual([true]) + }) +}) diff --git a/packages/account-core/src/web/crossTabRefresh.ts b/packages/account-core/src/web/crossTabRefresh.ts index 9aafd9ab49c..0b560f609fe 100644 --- a/packages/account-core/src/web/crossTabRefresh.ts +++ b/packages/account-core/src/web/crossTabRefresh.ts @@ -1,4 +1,5 @@ -import type { CrossTabRefreshPort } from '../core/session.js' +import type { AccountCredential, CrossTabRefreshPort } from '../core/session.js' +import type { VisibilityPort } from '../core/webSessionIdentity.js' /** * Web Locks + BroadcastChannel implementation of the cross-tab refresh port. @@ -16,8 +17,8 @@ import type { CrossTabRefreshPort } from '../core/session.js' * can do to siblings (hand them a token), not what it can reach. Hosts that * load third-party script into the realm accept that when they opt in. */ -export function createWebCrossTabRefreshPort(): - | CrossTabRefreshPort +export function createWebCrossTabRefreshPort(): + | CrossTabRefreshPort | undefined { // Feature-detect defensively: test DOMs ship these piecemeal (happy-dom // has a BroadcastChannel but a null navigator.locks), and either gap must @@ -118,3 +119,16 @@ export function createWebCrossTabRefreshPort(): } } } + +export function createWebVisibilityPort(): VisibilityPort | undefined { + if (typeof document === 'undefined') return undefined + const isVisible = () => document.visibilityState === 'visible' + return { + isVisible, + onChange: (listener) => { + const handler = () => listener(isVisible()) + document.addEventListener('visibilitychange', handler) + return () => document.removeEventListener('visibilitychange', handler) + } + } +} diff --git a/packages/account-core/src/webSessionInertImport.test.ts b/packages/account-core/src/webSessionInertImport.test.ts index 7a1f4b398d1..8e18ce53605 100644 --- a/packages/account-core/src/webSessionInertImport.test.ts +++ b/packages/account-core/src/webSessionInertImport.test.ts @@ -8,6 +8,7 @@ it.for([ '@comfyorg/account-core/webSession', '@comfyorg/account-core/requestAuth', '@comfyorg/account-core/webSessionIdentity', + '@comfyorg/account-core/web', '@comfyorg/account-core/testing' ])( 'importing %s starts no timer, listener, channel, or request',