From ead8b559dc23de16c17e1d1542b5db2609907ed8 Mon Sep 17 00:00:00 2001 From: Dante Date: Sat, 26 Sep 2026 12:11:46 +0000 Subject: [PATCH] FE-2897 feat(account-core): session lifecycle, create on sign-in, delete on sign-out, heartbeat (#18719) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit > **Stacked on #18715 (FE-2894) → #18710 (FE-2892). Do not merge** until those merge and BE-17061 (C1) and BE-17063 (C3) are on testcloud (the web session backend is not on staging yet). The base of this PR is the FE-2894 branch. ## Why With one shared session, signing in or out on one site has to reach every open tab on every other site, and a tab must never finish Alice's action as Bob. TDD §7, §12 and A8 define how: create the session only on a real sign-in, delete it on sign-out, and run a heartbeat that notices a remote sign-out or an account change and tells the app to reset. ## How This extends the FE-2894 state machine rather than adding a second module, so there is still one state and one pure transition. - `signedIn(getProof)`: the host calls it only after an interactive sign-in. A token refresh never creates a session. - `signOut()`: signs the tab out at once, sends `DELETE /api/auth/session` (which works on a dead session), and tells sibling tabs. - Heartbeat: `GET /session` every 10 minutes while the tab is visible, and once when it becomes visible. The GET never extends the idle timer. - A new CSRF token is adopted silently. - `session_revoked` → signed out. - `no_session`/`session_expired` → restore in place from the remembered login, without bumping the epoch. - `SESSION_UNAVAILABLE` and other ambiguous answers keep the user signed in; the next beat tries again. - Cross-tab: within one site, only a visible, signed-in tab holds the lead and beats. Siblings adopt `ok` and `revoked` answers over the existing broadcast port and validate each message with a schema before adopting it. - `CrossTabRefreshPort` gains a message type parameter (``). The change is type-only, and the cloud app's existing `createWebCrossTabRefreshPort()` call keeps the same runtime behaviour. - `createWebVisibilityPort()` joins `./web`, so the core still touches no browser global. - Account change: `onAccountChanged` fires on a remote sign-out, a different user in any answer, and the host's own sign-out. `getEpoch()` goes up on each change, and an answer started under an older epoch is discarded. The host tags requests with the epoch and clears its own caches, workspace selection and socket (FE-2903). `onSignedOutRemotely` is the `session_signed_out_remotely` event (revoked only). - Inert until `boot()`: nothing watches visibility or the channel before then; the inert-import test now covers `./web`. - Size: about 358 net non-test lines, over the ~300 guideline. If you want it smaller, the split is cross-tab adoption + the visibility port + the generic port type (~70 lines) into a follow-up, or the pure transition into its own module. ## AS IS / TO BE No UI; the evidence is tests with injected time, fake visibility and a fake cross-tab port, no sleeps. - AS IS: no session lifecycle or heartbeat. - TO BE: `webSessionIdentity.lifecycle.test.ts` covers: - a sign-out on another site reaching this tab at its next beat or on focus; - a different user in a heartbeat resetting state, with a pending answer from the old epoch dropped; - a hidden tab never beating; - followers adopting instead of reading; - a token refresh never creating a session; - `SESSION_UNAVAILABLE` never signing out. ``` pnpm --filter @comfyorg/account-core test Tests 1094 passed pnpm --filter @comfyorg/account-core typecheck / lint clean pnpm typecheck clean pnpm knip clean pnpm fallow audit --base No issues in 6 changed files ``` Mutation checks (each reverted): | Mutation | Result | | --- | --- | | hidden tab beats | 2 red | | followers read too | 1 red | | heartbeat creates a session | 5 red | | `SESSION_UNAVAILABLE` signs out | 1 red | | old-epoch answer applied after an account change | 1 red | For review: - The CSRF token travels on the same-origin broadcast channel, the same trust boundary the port already documents for the workspace token. - `signOut()` calls `RememberedLogin.signOutLocally` itself, which may overlap the host's own Firebase sign-out. ## Links - TDD: https://app.notion.com/p/3de6d73d365081d7a4c8f808c0a0384b (sections 7, 12, 15 F2, A8) - Action items and dependency graph: https://app.notion.com/p/3e56d73d3650812d962decc97fbd9ea3 - Linear: https://linear.app/comfyorg/issue/FE-2897 ## Where this PR sits in the plan | Ticket | Scope | Blocked by | State | | --- | --- | --- | --- | | FE-2891 | `unified_web_session` client flag, off by default | BE-17135 to turn on; C11 for website/billing-web readers | #18708 | | FE-2892 | account-core web session client + error codes | C1, C3 (BE-17063 generated types) | #18710, do not merge | | FE-2893 | ADR for the shared web session | none | #18707 | | FE-2901 | non-web clients stay on tokens (baseline) | FE-2895 for `authorize()` rows | #18711 | | FE-2894 | session-backed identity + boot rules (stacked on #18710) | FE-2892, C3 | #18715, do not merge | | FE-2895 | `authorize()` for cookie requests (stacked on #18710) | FE-2892, C5 | #18716, do not merge | | **FE-2897 (this PR)** | session lifecycle, heartbeat (stacked on #18715) | FE-2894, C1, C3 | #18719, do not merge | | FE-2906 | cross-origin E2E harness + §17 test ids | C3/C5/C6/C7 on staging for the rows | #18718 (harness only) | | FE-2896, 2898–2900, 2902–2905, 2907, 2908 | apps, token mint, rollout, cleanup | C5/C6/C7/C8/C11 contracts | not started | ```mermaid flowchart LR subgraph BE["BE · cloud ingest and infra"] C0["BE-17071 C0 preview CORS gate"] C1["BE-17061 C1 sessions table + revocable cookie"] C3["BE-17063 C3 GET /session, trusted origins, flag"] C4["BE-17062 C4 shared workspace resolution"] C5["BE-17066 C5 cookie on API: CSRF, Origin, workspace header"] C2["BE-17064 C2 revoke-all, purge, caps"] C6["BE-17067 C6 WebSocket on session"] C7["BE-17068 C7 scoped media"] C8["BE-17069 C8 token mint from session"] C9["BE-17065 C9 Redis cache + load test"] C10["BE-17072 C10 prod config, cleanup"] C11["C11 flag before sign-in (OQ17)"] B135["BE-17135 serve unified_web_session (server AND)"] I2["BE-17070 I2 edge limit, log + DNS audit"] end subgraph SDK["FE · account-core"] F2891["FE-2891 flag"] F2892["FE-2892 web session client"] F2894["FE-2894 identity + boot rules"] F2897["FE-2897 lifecycle, heartbeat"] F2895["FE-2895 authorize()"] F2900["FE-2900 lazy token mint"] F2901["FE-2901 non-web stay on tokens"] end subgraph APPS["FE · apps"] F2896["FE-2896 website header"] F2903["FE-2903 cloud lifecycle"] F2899["FE-2899 website credits"] F2904["FE-2904 cloud API client"] F2905["FE-2905 socket + media"] F2898["FE-2898 billing-web joins session"] F2902["FE-2902 platform"] end subgraph QA["QA · rollout · docs"] F2906["FE-2906 cross-origin E2E"] F2893["FE-2893 ADR + docs"] F2907["FE-2907 ramp + rollback"] F2908["FE-2908 cleanup"] end C0 --> C1 --> C3 --> C5 C3 --> C11 --> F2891 B135 --> F2891 C4 --> C5 C1 --> C2 C1 --> C9 C5 --> C6 & C7 & C8 C3 --> F2892 C1 --> F2892 F2891 --> F2894 C3 --> F2894 F2892 --> F2894 --> F2896 F2894 --> F2897 --> F2903 C1 --> F2897 F2892 --> F2895 C5 --> F2895 F2895 --> F2899 & F2904 & F2900 & F2901 & F2902 C5 --> F2899 & F2904 F2903 --> F2904 --> F2905 C6 --> F2905 C7 --> F2905 C8 --> F2900 F2894 --> F2898 F2895 --> F2898 C3 --> F2898 C5 --> F2898 F2903 & F2904 & F2905 & F2898 --> F2906 C3 & C2 --> F2906 F2906 --> F2907 C9 & C10 & I2 --> F2907 F2907 --> F2908 C10 --> F2908 classDef thisPr fill:#ffe08a,stroke:#b8860b,stroke-width:4px,color:#000 class F2897 thisPr ``` - Blocked by: #18715 (FE-2894), #18710 (FE-2892), BE-17061 (C1), BE-17063 (C3). - Unblocks: FE-2903 (cloud app joins the lifecycle), and through it FE-2904, FE-2905 and FE-2906 rows E2E-02/05/07. --------- Co-authored-by: mattmillerai <7741082+mattmillerai@users.noreply.github.com> (cherry picked from commit 1685d3352be73fb15bfac57c3c9858031d2d60f7) --- .../account-core/src/core/sessionContracts.ts | 4 +- .../core/webSessionIdentity.lifecycle.test.ts | 554 ++++++++++++++++++ .../src/core/webSessionIdentity.ts | 498 ++++++++++++++-- .../src/web/crossTabRefresh.test.ts | 27 +- .../account-core/src/web/crossTabRefresh.ts | 20 +- .../src/webSessionInertImport.test.ts | 1 + 6 files changed, 1040 insertions(+), 64 deletions(-) create mode 100644 packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts 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',