From 58f8b474646d5e52da325f826ff479f3fa7d5ede Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Thu, 24 Sep 2026 08:35:44 -0400 Subject: [PATCH 01/30] feat(account-core): web session client and session error codes readWebSession, createWebSession, deleteWebSession and revokeAllWebSessions for the shared __Host-comfy_session cookie on ingest. Every call sends credentials, failures are coded (six session codes plus a transient and a refused bucket), and 429/5xx/network never read as a sign-out. Nothing imports it yet; importing it starts no timer, listener or request. --- packages/account-core/package.json | 5 + packages/account-core/scripts/smokePack.ts | 4 + .../account-core/src/core/importGuard.test.ts | 62 ++- .../account-core/src/core/sessionContracts.ts | 50 +++ .../account-core/src/core/webSession.test.ts | 366 ++++++++++++++++++ packages/account-core/src/core/webSession.ts | 182 +++++++++ .../src/core/webSessionDraftContract.ts | 17 + packages/account-core/src/testing.ts | 136 +++++++ .../src/webSessionInertImport.test.ts | 34 ++ 9 files changed, 855 insertions(+), 1 deletion(-) create mode 100644 packages/account-core/src/core/webSession.test.ts create mode 100644 packages/account-core/src/core/webSession.ts create mode 100644 packages/account-core/src/core/webSessionDraftContract.ts create mode 100644 packages/account-core/src/webSessionInertImport.test.ts diff --git a/packages/account-core/package.json b/packages/account-core/package.json index 2055251b53c..77c79b6639f 100644 --- a/packages/account-core/package.json +++ b/packages/account-core/package.json @@ -24,6 +24,7 @@ "./boundedOperation": "./src/core/boundedOperation.ts", "./lazyIdentity": "./src/core/lazyIdentity.ts", "./session": "./src/core/session.ts", + "./webSession": "./src/core/webSession.ts", "./billing": "./src/core/billing/index.ts", "./firebase": "./src/firebase/index.ts", "./web": "./src/web/crossTabRefresh.ts", @@ -50,6 +51,10 @@ "types": "./dist/core/session.d.ts", "import": "./dist/core/session.js" }, + "./webSession": { + "types": "./dist/core/webSession.d.ts", + "import": "./dist/core/webSession.js" + }, "./billing": { "types": "./dist/core/billing/index.d.ts", "import": "./dist/core/billing/index.js" diff --git a/packages/account-core/scripts/smokePack.ts b/packages/account-core/scripts/smokePack.ts index e82ebcc3096..895bb30af58 100644 --- a/packages/account-core/scripts/smokePack.ts +++ b/packages/account-core/scripts/smokePack.ts @@ -201,6 +201,8 @@ import type { OperationHandle } from '@comfyorg/account-core/boundedOperation' import { createBoundedOperation } from '@comfyorg/account-core/boundedOperation' import type { AccountUser, SessionSnapshot } from '@comfyorg/account-core/session' import { createSessionClient } from '@comfyorg/account-core/session' +import type { WebSessionResult } from '@comfyorg/account-core/webSession' +import { readWebSession } from '@comfyorg/account-core/webSession' import type { BillingErrorCode } from '@comfyorg/account-core/billing' import { createSessionBillingTransport } from '@comfyorg/account-core/billing' import type { @@ -256,6 +258,7 @@ import { useGenerationGuard } from '@comfyorg/account-ui/auth/useGenerationGuard export const values = { createBoundedOperation, createSessionClient, + readWebSession, createSessionBillingTransport, createFirebaseIdentity, resolveFirebaseIdentity, @@ -290,6 +293,7 @@ export const values = { export interface Types { boundedOperation: OperationHandle session: SessionSnapshot + webSession: WebSessionResult billing: BillingErrorCode firebase: FirebaseIdentityAppConfig firebaseResolve: ResolveFirebaseIdentityOptions diff --git a/packages/account-core/src/core/importGuard.test.ts b/packages/account-core/src/core/importGuard.test.ts index f36bcc22d7a..d45a06576cf 100644 --- a/packages/account-core/src/core/importGuard.test.ts +++ b/packages/account-core/src/core/importGuard.test.ts @@ -1,5 +1,5 @@ import { readFileSync, readdirSync } from 'node:fs' -import { dirname, join } from 'node:path' +import { dirname, join, relative, resolve } from 'node:path' import { fileURLToPath } from 'node:url' import { describe, expect, it } from 'vitest' @@ -10,6 +10,34 @@ const FORBIDDEN_IMPORTS = ['firebase', 'vue', 'pinia', 'astro', '@/'] const FORBIDDEN_GLOBALS = /\b(?:globalThis\.)?(window|document|localStorage|sessionStorage)\s*[.[(]/ +/** Any route into Firebase: the SDK, its scoped packages, or this package's firebase entry. */ +const FIREBASE_SPECIFIER = /^@?firebase(?:\/|$)|(?:^|\/)firebase(?:\/|\.|$)/ + +const SPECIFIER = /(?:from|import|require)\s*\(?\s*['"]([^'"]+)['"]/g + +function importSpecifiers(text: string): string[] { + return [...text.matchAll(SPECIFIER)].map(([, specifier]) => specifier) +} + +/** Every source file reachable from `entry` through relative imports. */ +function relativeImportClosure(entry: string): Map { + const closure = new Map() + const pending = [resolve(CORE_DIR, entry)] + for (let file = pending.pop(); file; file = pending.pop()) { + if (closure.has(file)) continue + const specifiers = importSpecifiers(readFileSync(file, 'utf8')) + closure.set(file, specifiers) + pending.push( + ...specifiers + .filter((specifier) => specifier.startsWith('.')) + .map((specifier) => + resolve(dirname(file), specifier.replace(/\.js$/, '.ts')) + ) + ) + } + return closure +} + function specifierPattern(forbidden: string): RegExp { const escaped = forbidden.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&') return new RegExp( @@ -36,6 +64,38 @@ describe('core import guard', () => { } }) + it('scans the web session sources', () => { + expect(sources.map(({ name }) => name)).toEqual( + expect.arrayContaining(['webSession.ts', 'webSessionDraftContract.ts']) + ) + }) + + it('keeps the web session module and everything it imports off Firebase', () => { + const closure = relativeImportClosure('webSession.ts') + const firebaseImports = [...closure].flatMap(([file, specifiers]) => + specifiers + .filter((specifier) => FIREBASE_SPECIFIER.test(specifier)) + .map((specifier) => `${relative(CORE_DIR, file)} -> ${specifier}`) + ) + + expect([...closure.keys()].map((file) => relative(CORE_DIR, file))).toEqual( + expect.arrayContaining(['webSession.ts', 'webSessionDraftContract.ts']) + ) + expect(firebaseImports).toEqual([]) + }) + + it.for([ + 'firebase/auth', + '@firebase/app', + '../firebase/index.js', + '@comfyorg/account-core/firebase' + ])('recognizes %s as a Firebase import', (specifier) => { + expect(importSpecifiers(`import x from '${specifier}'`)).toEqual([ + specifier + ]) + expect(specifier).toMatch(FIREBASE_SPECIFIER) + }) + it('keeps the core off browser globals', () => { for (const { name, text } of sources) { expect(text, `${name} touches a browser global`).not.toMatch( diff --git a/packages/account-core/src/core/sessionContracts.ts b/packages/account-core/src/core/sessionContracts.ts index 1ab8dae269f..9f449efe81a 100644 --- a/packages/account-core/src/core/sessionContracts.ts +++ b/packages/account-core/src/core/sessionContracts.ts @@ -147,3 +147,53 @@ export interface RefreshSchedulerOptions { */ readonly onScheduledOutcome?: (report: ScheduledRefreshReport) => void } + +/** The signed-in principal behind the shared `__Host-comfy_session` cookie. */ +export interface WebSessionUser { + readonly id: string + readonly email: string + readonly name?: string + readonly emailVerified: boolean + readonly signInProvider?: string +} + +export interface WebSession { + readonly user: WebSessionUser + readonly csrfToken: string + /** ms since epoch; the sliding idle expiry */ + readonly expiresAt: number + /** ms since epoch; the hard cap regardless of activity */ + readonly absoluteExpiresAt: number +} + +/** + * `SESSION_UNAVAILABLE` is the only transient code: 429, 5xx, network, + * abort, and unreadable bodies land there so an outage never reads as a + * sign-out. `SESSION_REQUEST_REFUSED` is a request no fresh session can fix. + */ +export type WebSessionErrorCode = + | 'NO_SESSION' + | 'SESSION_EXPIRED' + | 'SESSION_REVOKED' + | 'CSRF_STALE' + | 'IDENTITY_CHANGED' + | 'WORKSPACE_ACCESS_DENIED' + | 'SESSION_REQUEST_REFUSED' + | 'SESSION_UNAVAILABLE' + +export interface WebSessionFailure { + readonly status: 'error' + readonly code: WebSessionErrorCode + readonly retryable: boolean + readonly httpStatus?: number + /** The server's `ErrorResponse.code`, when the body carried one. */ + readonly serverCode?: string +} + +export type WebSessionResult = + | { readonly status: 'ok'; readonly session: WebSession } + | WebSessionFailure + +export type WebSessionCommandResult = + | { readonly status: 'ok' } + | WebSessionFailure diff --git a/packages/account-core/src/core/webSession.test.ts b/packages/account-core/src/core/webSession.test.ts new file mode 100644 index 00000000000..ce43ddeb7ba --- /dev/null +++ b/packages/account-core/src/core/webSession.test.ts @@ -0,0 +1,366 @@ +import { describe, expect, it, vi } from 'vitest' + +import type { FakeWebSessionState } from '../testing.js' +import { createFakeWebSessionEndpoint, fakeWebSessionUser } from '../testing.js' +import type { WebSessionOptions } from './webSession.js' +import { + createWebSession, + deleteWebSession, + readWebSession, + revokeAllWebSessions +} from './webSession.js' + +const API = 'https://cloud.example/api' +const NOW = Date.parse('2024-06-15T12:00:00Z') + +function fakeEndpoint(state: FakeWebSessionState) { + return createFakeWebSessionEndpoint({ state, now: () => NOW }) +} + +function optionsFor(fetchImpl: typeof fetch): WebSessionOptions { + return { apiBaseUrl: API, fetchImpl } +} + +function respondWith(status: number, body: string): typeof fetch { + return vi.fn(async () => new Response(body, { status })) +} + +const errorBody = (code: string) => JSON.stringify({ code, message: code }) + +const ENDPOINTS = [ + { name: 'read', call: (o: WebSessionOptions) => readWebSession(o) }, + { + name: 'create', + call: (o: WebSessionOptions) => createWebSession(o, async () => 'proof') + }, + { name: 'delete', call: (o: WebSessionOptions) => deleteWebSession(o) }, + { + name: 'revoke-all', + call: (o: WebSessionOptions) => revokeAllWebSessions(o, 'csrf') + } +] + +describe('web session status mapping', () => { + it.for([ + { + status: 401, + body: errorBody('no_session'), + code: 'NO_SESSION', + server: 'no_session' + }, + { + status: 401, + body: errorBody('session_expired'), + code: 'SESSION_EXPIRED', + server: 'session_expired' + }, + { + status: 401, + body: errorBody('session_revoked'), + code: 'SESSION_REVOKED', + server: 'session_revoked' + }, + { + status: 401, + body: errorBody('token_mismatch'), + code: 'NO_SESSION', + server: 'token_mismatch' + }, + { + status: 403, + body: errorBody('csrf_invalid'), + code: 'CSRF_STALE', + server: 'csrf_invalid' + }, + { + status: 403, + body: errorBody('workspace_access_denied'), + code: 'WORKSPACE_ACCESS_DENIED', + server: 'workspace_access_denied' + }, + { + status: 403, + body: errorBody('origin_not_allowed'), + code: 'SESSION_REQUEST_REFUSED', + server: 'origin_not_allowed' + }, + { + status: 403, + body: errorBody('cross_site_request'), + code: 'SESSION_REQUEST_REFUSED', + server: 'cross_site_request' + }, + { + status: 403, + body: errorBody('FORBIDDEN'), + code: 'SESSION_REQUEST_REFUSED', + server: 'FORBIDDEN' + }, + { + status: 400, + body: errorBody('workspace_id_invalid'), + code: 'SESSION_REQUEST_REFUSED', + server: 'workspace_id_invalid' + }, + { + status: 404, + body: errorBody('not_found'), + code: 'SESSION_REQUEST_REFUSED', + server: 'not_found' + } + ] as const)( + '$status $server is permanent $code', + async ({ status, body, code, server }) => { + const result = await readWebSession(optionsFor(respondWith(status, body))) + + expect(result).toEqual({ + status: 'error', + code, + retryable: false, + httpStatus: status, + serverCode: server + }) + } + ) + + it.for([ + { name: '429 edge rate limit', status: 429, body: errorBody('no_session') }, + { + name: '500 carrying a revoked code', + status: 500, + body: errorBody('session_revoked') + }, + { name: '503 html page', status: 503, body: 'down' }, + { + name: '401 without an error body', + status: 401, + body: '401' + }, + { name: '403 without an error body', status: 403, body: '' }, + { name: '200 failing the session schema', status: 200, body: '{"user":{}}' } + ])( + '$name is transient, never a session verdict', + async ({ status, body }) => { + const result = await readWebSession(optionsFor(respondWith(status, body))) + + expect(result).toEqual({ + status: 'error', + code: 'SESSION_UNAVAILABLE', + retryable: true, + httpStatus: status + }) + } + ) + + it.for([ + { name: 'network failure', error: new TypeError('Failed to fetch') }, + { name: 'abort', error: new DOMException('Aborted', 'AbortError') } + ])('$name is transient', async ({ error }) => { + const fetchImpl = vi.fn(async () => { + throw error + }) + + const result = await readWebSession(optionsFor(fetchImpl)) + + expect(result).toEqual({ + status: 'error', + code: 'SESSION_UNAVAILABLE', + retryable: true + }) + }) + + it.for(ENDPOINTS)('$name maps a revoked session', async ({ call }) => { + const fetchImpl = respondWith(401, errorBody('session_revoked')) + + const result = await call(optionsFor(fetchImpl)) + + expect(result).toMatchObject({ code: 'SESSION_REVOKED', retryable: false }) + }) + + it.for(ENDPOINTS)('$name treats a 500 as transient', async ({ call }) => { + const result = await call(optionsFor(respondWith(500, ''))) + + expect(result).toMatchObject({ + code: 'SESSION_UNAVAILABLE', + retryable: true + }) + }) +}) + +describe('web session requests', () => { + it.for([ + { name: 'read', call: readWebSession, expected: ['include'] }, + { + name: 'create', + call: (o: WebSessionOptions) => createWebSession(o, async () => 'proof'), + expected: ['include', 'include'] + }, + { name: 'delete', call: deleteWebSession, expected: ['include'] }, + { + name: 'revoke-all', + call: (o: WebSessionOptions) => + revokeAllWebSessions(o, 'fake-csrf-token'), + expected: ['include'] + } + ])('$name always sends credentials', async ({ call, expected }) => { + const endpoint = fakeEndpoint({ kind: 'live', user: fakeWebSessionUser() }) + + await call(optionsFor(endpoint.fetch)) + + expect(endpoint.requests.map((request) => request.credentials)).toEqual( + expected + ) + }) + + it('reads the live session uncached and in SDK shape', async () => { + const endpoint = fakeEndpoint({ + kind: 'live', + user: fakeWebSessionUser({ id: 'u-7', email: 'a@b.c', name: undefined }) + }) + + const result = await readWebSession(optionsFor(endpoint.fetch)) + + expect(endpoint.requests[0]).toMatchObject({ + method: 'GET', + path: '/api/auth/session', + cache: 'no-store' + }) + expect(result).toEqual({ + status: 'ok', + session: { + user: { + id: 'u-7', + email: 'a@b.c', + emailVerified: true, + signInProvider: 'google.com' + }, + csrfToken: 'fake-csrf-token', + expiresAt: Date.parse('2024-06-16T12:00:00Z'), + absoluteExpiresAt: Date.parse('2024-06-22T12:00:00Z') + } + }) + }) + + it('reports IDENTITY_CHANGED when the session belongs to another user', async () => { + const endpoint = fakeEndpoint({ + kind: 'live', + user: fakeWebSessionUser({ id: 'someone-else' }) + }) + + const result = await readWebSession(optionsFor(endpoint.fetch), { + expectedUserId: 'user-1' + }) + + expect(result).toMatchObject({ + code: 'IDENTITY_CHANGED', + retryable: false + }) + }) + + it('creates a session from the proof and returns the signed-in user', async () => { + const endpoint = createFakeWebSessionEndpoint({ + state: { kind: 'dead', code: 'no_session' }, + signInUser: fakeWebSessionUser({ id: 'new-user' }), + now: () => NOW + }) + + const result = await createWebSession( + optionsFor(endpoint.fetch), + async () => 'id-token' + ) + + expect(endpoint.requests[0]).toMatchObject({ + method: 'POST', + headers: { authorization: 'Bearer id-token' } + }) + expect(result).toMatchObject({ + status: 'ok', + session: { user: { id: 'new-user' }, csrfToken: 'fake-csrf-token' } + }) + }) + + it('leaves an identity-proof failure to the caller and sends nothing', async () => { + const endpoint = fakeEndpoint({ kind: 'dead', code: 'no_session' }) + + await expect( + createWebSession(optionsFor(endpoint.fetch), () => + Promise.reject(new Error('signed out of the provider')) + ) + ).rejects.toThrow('signed out of the provider') + expect(endpoint.requests).toEqual([]) + }) + + it('signs out a dead session without a CSRF token', async () => { + const endpoint = fakeEndpoint({ kind: 'dead', code: 'session_expired' }) + + const result = await deleteWebSession(optionsFor(endpoint.fetch)) + + expect(result).toEqual({ status: 'ok' }) + expect(endpoint.requests[0]).toMatchObject({ method: 'DELETE' }) + expect(endpoint.requests[0].headers).not.toHaveProperty('x-csrf-token') + }) + + it('revokes every session with the CSRF token', async () => { + const endpoint = fakeEndpoint({ kind: 'live', user: fakeWebSessionUser() }) + const options = optionsFor(endpoint.fetch) + + const revoked = await revokeAllWebSessions(options, 'fake-csrf-token') + + expect(revoked).toEqual({ status: 'ok' }) + expect(await readWebSession(options)).toMatchObject({ + code: 'SESSION_REVOKED' + }) + }) + + it('reports a stale CSRF token on revoke-all', async () => { + const endpoint = fakeEndpoint({ kind: 'live', user: fakeWebSessionUser() }) + + const result = await revokeAllWebSessions( + optionsFor(endpoint.fetch), + 'old-token' + ) + + expect(result).toMatchObject({ code: 'CSRF_STALE', retryable: false }) + }) +}) + +describe('boot cases against the testing fake', () => { + it.for<{ name: string; state: FakeWebSessionState; expected: object }>([ + { + name: 'live session', + state: { kind: 'live', user: fakeWebSessionUser() }, + expected: { status: 'ok', session: { user: { id: 'user-1' } } } + }, + { + name: '401 session_revoked', + state: { kind: 'dead', code: 'session_revoked' }, + expected: { code: 'SESSION_REVOKED', retryable: false } + }, + { + name: '401 no_session', + state: { kind: 'dead', code: 'no_session' }, + expected: { code: 'NO_SESSION', retryable: false } + }, + { + name: '401 session_expired', + state: { kind: 'dead', code: 'session_expired' }, + expected: { code: 'SESSION_EXPIRED', retryable: false } + }, + { + name: 'network error', + state: { kind: 'network_error' }, + expected: { code: 'SESSION_UNAVAILABLE', retryable: true } + }, + { + name: '503 outage', + state: { kind: 'unavailable', status: 503 }, + expected: { code: 'SESSION_UNAVAILABLE', retryable: true } + } + ])('$name', async ({ state, expected }) => { + const endpoint = fakeEndpoint(state) + + const result = await readWebSession(optionsFor(endpoint.fetch)) + + expect(result).toMatchObject(expected) + }) +}) diff --git a/packages/account-core/src/core/webSession.ts b/packages/account-core/src/core/webSession.ts new file mode 100644 index 00000000000..c2873495f5e --- /dev/null +++ b/packages/account-core/src/core/webSession.ts @@ -0,0 +1,182 @@ +/** + * Client for the shared web session on ingest (`/api/auth/session*`). It only + * sends and classifies: retries, boot rules, and sign-out belong to callers. + * Identity proof is an opaque string from the caller, so no provider leaks in. + */ +import { + zCreateSessionResponse, + zDeleteSessionResponse, + zErrorResponse +} from '@comfyorg/ingest-types/zod' + +import type { + WebSessionCommandResult, + WebSessionErrorCode, + WebSessionFailure, + WebSessionResult +} from './sessionContracts.js' +import { zWebSessionResponse } from './webSessionDraftContract.js' + +export type { + WebSession, + WebSessionCommandResult, + WebSessionErrorCode, + WebSessionFailure, + WebSessionResult, + WebSessionUser +} from './sessionContracts.js' + +export interface WebSessionOptions { + /** Ingest API root, e.g. `https://cloud.comfy.org/api`. */ + readonly apiBaseUrl: string + readonly fetchImpl: typeof fetch + readonly signal?: AbortSignal +} + +const UNAUTHORIZED_CODES: Readonly> = { + no_session: 'NO_SESSION', + session_expired: 'SESSION_EXPIRED', + session_revoked: 'SESSION_REVOKED' +} + +const FORBIDDEN_CODES: Readonly> = { + csrf_invalid: 'CSRF_STALE', + workspace_access_denied: 'WORKSPACE_ACCESS_DENIED' +} + +function failure( + code: WebSessionErrorCode, + httpStatus?: number, + serverCode?: string +): WebSessionFailure { + return { + status: 'error', + code, + retryable: code === 'SESSION_UNAVAILABLE', + ...(httpStatus === undefined ? {} : { httpStatus }), + ...(serverCode === undefined ? {} : { serverCode }) + } +} + +async function readJson(response: Response): Promise { + try { + return await response.json() + } catch { + return undefined + } +} + +async function classifyFailure(response: Response): Promise { + const { status } = response + if (status === 429 || status >= 500) { + return failure('SESSION_UNAVAILABLE', status) + } + const parsed = zErrorResponse.safeParse(await readJson(response)) + if (!parsed.success) return failure('SESSION_UNAVAILABLE', status) + const serverCode = parsed.data.code + const byServerCode = + status === 401 + ? (UNAUTHORIZED_CODES[serverCode] ?? 'NO_SESSION') + : status === 403 + ? (FORBIDDEN_CODES[serverCode] ?? 'SESSION_REQUEST_REFUSED') + : 'SESSION_REQUEST_REFUSED' + return failure(byServerCode, status, serverCode) +} + +async function send( + options: WebSessionOptions, + path: string, + init: RequestInit +): Promise<{ readonly response: Response } | WebSessionFailure> { + let response: Response + try { + response = await options.fetchImpl( + `${options.apiBaseUrl.replace(/\/+$/, '')}${path}`, + { ...init, credentials: 'include', signal: options.signal } + ) + } catch { + return failure('SESSION_UNAVAILABLE') + } + return response.ok ? { response } : classifyFailure(response) +} + +export async function readWebSession( + options: WebSessionOptions, + { expectedUserId }: { readonly expectedUserId?: string } = {} +): Promise { + const sent = await send(options, '/auth/session', { + method: 'GET', + cache: 'no-store' + }) + if (!('response' in sent)) return sent + + const { status } = sent.response + const parsed = zWebSessionResponse.safeParse(await readJson(sent.response)) + if (!parsed.success) return failure('SESSION_UNAVAILABLE', status) + const { user, csrf_token, expires_at, absolute_expires_at } = parsed.data + if (expectedUserId !== undefined && user.id !== expectedUserId) { + return failure('IDENTITY_CHANGED', status) + } + return { + status: 'ok', + session: { + user: { + id: user.id, + email: user.email, + name: user.name, + emailVerified: user.email_verified, + signInProvider: user.sign_in_provider + }, + csrfToken: csrf_token, + expiresAt: Date.parse(expires_at), + absoluteExpiresAt: Date.parse(absolute_expires_at) + } + } +} + +/** + * Creates the session, then reads it back for the user and CSRF token. A + * failure to produce the proof is the provider's error and propagates. + */ +export async function createWebSession( + options: WebSessionOptions, + getIdentityProof: () => Promise +): Promise { + const proof = await getIdentityProof() + const sent = await send(options, '/auth/session', { + method: 'POST', + headers: { Authorization: `Bearer ${proof}` } + }) + if (!('response' in sent)) return sent + + const parsed = zCreateSessionResponse.safeParse(await readJson(sent.response)) + if (!parsed.success || !parsed.data.success) { + return failure('SESSION_UNAVAILABLE', sent.response.status) + } + return readWebSession(options) +} + +/** Sends no CSRF token: sign-out must work against a dead session. */ +export async function deleteWebSession( + options: WebSessionOptions +): Promise { + const sent = await send(options, '/auth/session', { method: 'DELETE' }) + if (!('response' in sent)) return sent + + const parsed = zDeleteSessionResponse.safeParse(await readJson(sent.response)) + if (!parsed.success || !parsed.data.success) { + return failure('SESSION_UNAVAILABLE', sent.response.status) + } + return { status: 'ok' } +} + +export async function revokeAllWebSessions( + options: WebSessionOptions, + csrfToken: string +): Promise { + const sent = await send(options, '/auth/sessions/revoke-all', { + method: 'POST', + headers: { 'X-CSRF-Token': csrfToken } + }) + return 'response' in sent ? { status: 'ok' } : sent +} diff --git a/packages/account-core/src/core/webSessionDraftContract.ts b/packages/account-core/src/core/webSessionDraftContract.ts new file mode 100644 index 00000000000..a5781e9258e --- /dev/null +++ b/packages/account-core/src/core/webSessionDraftContract.ts @@ -0,0 +1,17 @@ +/** Mirrors GET /api/auth/session from cloud#10549; replace with `@comfyorg/ingest-types/zod` once BE-17063 is generated. */ +import { z } from 'zod' + +const zWebSessionUser = z.object({ + id: z.string(), + email: z.string(), + name: z.string().optional(), + email_verified: z.boolean(), + sign_in_provider: z.string().optional() +}) + +export const zWebSessionResponse = z.object({ + user: zWebSessionUser, + csrf_token: z.string(), + expires_at: z.string().datetime(), + absolute_expires_at: z.string().datetime() +}) diff --git a/packages/account-core/src/testing.ts b/packages/account-core/src/testing.ts index 387c12bdca1..c5c838bc066 100644 --- a/packages/account-core/src/testing.ts +++ b/packages/account-core/src/testing.ts @@ -2,9 +2,145 @@ * The test seam for fakes: a hand-written port becomes an identity the * session client accepts. Production hosts use `@comfyorg/account-core/firebase`. */ +import type { WebSessionUser } from './core/sessionContracts.js' + export type { IdentityPort } from './core/identity.js' export { brandIdentity as createTestIdentity } from './core/identity.js' // Enumerating wording (CWE-204) each host asserts its copy never matches; shared so the two suites can't drift. export const ENUMERATION_ORACLE = /\bexists?\b|already (?:registered|in use|have|exists)|wrong password|no account|not found|is registered|different (?:sign-in method|credential)/i + +export type { WebSessionUser } from './core/sessionContracts.js' + +export function fakeWebSessionUser( + overrides: Partial = {} +): WebSessionUser { + return { + id: 'user-1', + email: 'user-1@example.com', + name: 'Test User', + emailVerified: true, + signInProvider: 'google.com', + ...overrides + } +} + +/** The five boot cases, plus any other transient status. */ +export type FakeWebSessionState = + | { readonly kind: 'live'; readonly user: WebSessionUser } + | { + readonly kind: 'dead' + readonly code: 'no_session' | 'session_expired' | 'session_revoked' + } + | { readonly kind: 'network_error' } + | { readonly kind: 'unavailable'; readonly status: number } + +export interface FakeWebSessionRequest { + readonly method: string + readonly path: string + readonly credentials: RequestCredentials | undefined + readonly cache: RequestCache | undefined + readonly headers: Readonly> +} + +export interface FakeWebSessionEndpoint { + readonly fetch: typeof fetch + readonly requests: readonly FakeWebSessionRequest[] + state: FakeWebSessionState +} + +const FAKE_CSRF_TOKEN = 'fake-csrf-token' +const DAY_MS = 24 * 60 * 60 * 1000 + +function jsonResponse(status: number, body: unknown): Response { + return new Response(JSON.stringify(body), { + status, + headers: { 'Content-Type': 'application/json' } + }) +} + +function errorResponse(status: number, code: string): Response { + return jsonResponse(status, { code, message: code }) +} + +/** + * A `fetch` serving ingest's session routes under `/api/auth`. POST with a + * bearer proof signs `signInUser` in; DELETE and revoke-all leave the cookie + * revoked, as the real endpoint does. + */ +export function createFakeWebSessionEndpoint({ + state, + signInUser = fakeWebSessionUser(), + now = Date.now +}: { + state: FakeWebSessionState + signInUser?: WebSessionUser + now?: () => number +}): FakeWebSessionEndpoint { + const requests: FakeWebSessionRequest[] = [] + const endpoint: FakeWebSessionEndpoint = { + state, + requests, + fetch: async (input, init = {}) => { + const method = (init.method ?? 'GET').toUpperCase() + const { pathname } = new URL( + input instanceof Request ? input.url : String(input) + ) + const requestHeaders = new Headers(init.headers) + const headers = Object.fromEntries(requestHeaders) + requests.push({ + method, + path: pathname, + credentials: init.credentials, + cache: init.cache, + headers + }) + + const current = endpoint.state + if (current.kind === 'network_error') { + throw new TypeError('Failed to fetch') + } + if (current.kind === 'unavailable') { + return errorResponse(current.status, 'unavailable') + } + const route = `${method} ${pathname}` + if (route === 'POST /api/auth/session') { + if (!requestHeaders.get('authorization')?.startsWith('Bearer ')) { + return errorResponse(401, 'no_session') + } + endpoint.state = { kind: 'live', user: signInUser } + return jsonResponse(200, { success: true, expiresIn: DAY_MS / 1000 }) + } + if (route === 'DELETE /api/auth/session') { + endpoint.state = { kind: 'dead', code: 'session_revoked' } + return jsonResponse(200, { success: true }) + } + if (current.kind === 'dead') return errorResponse(401, current.code) + if (route === 'GET /api/auth/session') { + const { user } = current + return jsonResponse(200, { + user: { + id: user.id, + email: user.email, + name: user.name, + email_verified: user.emailVerified, + sign_in_provider: user.signInProvider + }, + csrf_token: FAKE_CSRF_TOKEN, + expires_at: new Date(now() + DAY_MS).toISOString(), + absolute_expires_at: new Date(now() + 7 * DAY_MS).toISOString() + }) + } + if (route === 'POST /api/auth/sessions/revoke-all') { + if (requestHeaders.get('x-csrf-token') !== FAKE_CSRF_TOKEN) { + return errorResponse(403, 'csrf_invalid') + } + endpoint.state = { kind: 'dead', code: 'session_revoked' } + return new Response(null, { status: 204 }) + } + return errorResponse(404, 'not_found') + } + } + return endpoint +} diff --git a/packages/account-core/src/webSessionInertImport.test.ts b/packages/account-core/src/webSessionInertImport.test.ts new file mode 100644 index 00000000000..540ea8f244c --- /dev/null +++ b/packages/account-core/src/webSessionInertImport.test.ts @@ -0,0 +1,34 @@ +import { beforeEach, expect, it, vi } from 'vitest' + +beforeEach(() => { + vi.resetModules() +}) + +it.for(['@comfyorg/account-core/webSession', '@comfyorg/account-core/testing'])( + 'importing %s starts no timer, listener, channel, or request', + async (specifier) => { + const fetchSpy = vi.fn() + vi.stubGlobal('fetch', fetchSpy) + const channelSpy = vi.fn() + vi.stubGlobal('BroadcastChannel', channelSpy) + const setTimeoutSpy = vi.spyOn(globalThis, 'setTimeout') + const setIntervalSpy = vi.spyOn(globalThis, 'setInterval') + const listenerSpy = vi.spyOn(EventTarget.prototype, 'addEventListener') + + await import(/* @vite-ignore */ specifier) + + expect({ + fetch: fetchSpy.mock.calls.length, + broadcastChannel: channelSpy.mock.calls.length, + setTimeout: setTimeoutSpy.mock.calls.length, + setInterval: setIntervalSpy.mock.calls.length, + addEventListener: listenerSpy.mock.calls.length + }).toEqual({ + fetch: 0, + broadcastChannel: 0, + setTimeout: 0, + setInterval: 0, + addEventListener: 0 + }) + } +) From 0771e7564d74053f186cb472019d87d8c200da36 Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Thu, 24 Sep 2026 08:43:36 -0400 Subject: [PATCH 02/30] test: pin the cloud auth requests with unified_web_session off --- src/platform/auth/webSessionFlagOff.test.ts | 373 ++++++++++++++++++++ 1 file changed, 373 insertions(+) create mode 100644 src/platform/auth/webSessionFlagOff.test.ts diff --git a/src/platform/auth/webSessionFlagOff.test.ts b/src/platform/auth/webSessionFlagOff.test.ts new file mode 100644 index 00000000000..3eb2cdf0b9f --- /dev/null +++ b/src/platform/auth/webSessionFlagOff.test.ts @@ -0,0 +1,373 @@ +import { fromPartial } from '@total-typescript/shoehorn' +import type { User } from 'firebase/auth' +import { afterEach, assert, beforeEach, describe, expect, it, vi } from 'vitest' +import { effectScope } from 'vue' + +import type { ExchangeTokenResponse } from '@comfyorg/ingest-types' + +import { useCurrentUser } from '@/composables/auth/useCurrentUser' +import type { FirebaseIdentity } from '@comfyorg/account-core/firebase' +import { refreshRemoteConfig } from '@/platform/remoteConfig/refreshRemoteConfig' +import { remoteConfig } from '@/platform/remoteConfig/remoteConfig' +import { TOKEN_REFRESH_BUFFER_MS } from '@/platform/workspace/workspaceConstants' +import { api } from '@/scripts/api' +import type { useExtensionService } from '@/services/extensionService' +import type { ComfyApp } from '@/scripts/app' +import type { ComfyExtension } from '@/types/comfy' + +type IdentityObserver = (user: User | null) => void + +const identity = vi.hoisted(() => { + const userObservers = new Set() + const tokenObservers = new Set() + const state: { user: User | null } = { user: null } + return { + userObservers, + tokenObservers, + state, + reset() { + userObservers.clear() + tokenObservers.clear() + state.user = null + }, + signIn(user: User) { + state.user = user + userObservers.forEach((observer) => observer(user)) + tokenObservers.forEach((observer) => observer(user)) + }, + refreshIdToken() { + tokenObservers.forEach((observer) => observer(state.user)) + } + } +}) + +const registeredExtensions = vi.hoisted((): ComfyExtension[] => []) + +vi.mock(import('@/platform/distribution/types'), () => ({ + DISTRIBUTION: 'cloud' as const, + isCloud: true, + isDesktop: false, + isNightly: false +})) + +vi.mock(import('@/platform/auth/firebaseIdentity'), () => ({ + firebaseIdentity: fromPartial({ + onUserChanged: (observer: IdentityObserver) => { + identity.userObservers.add(observer) + return () => identity.userObservers.delete(observer) + }, + onTokenChanged: (observer: IdentityObserver) => { + identity.tokenObservers.add(observer) + return () => identity.tokenObservers.delete(observer) + }, + currentUser: () => identity.state.user + }) +})) + +vi.mock(import('@/services/extensionService'), () => ({ + useExtensionService: () => + fromPartial>({ + registerExtension: (extension: ComfyExtension) => { + registeredExtensions.push(extension) + } + }) +})) + +vi.mock(import('@/platform/telemetry')) + +vi.mock(import('@/platform/telemetry/reportError'), () => ({ + reportError: vi.fn() +})) + +await import('@/extensions/core/cloudSessionCookie') + +const ONE_HOUR_MS = 60 * 60 * 1000 + +const FIREBASE_USER = fromPartial({ + uid: 'user-a', + getIdToken: async () => 'firebase-id-token' +}) + +interface RecordedRequest { + method: string + path: string + headers: Record + credentials: RequestCredentials | null +} + +function requestUrl(input: RequestInfo | URL): string { + if (typeof input === 'string') return input + return input instanceof URL ? input.href : input.url +} + +function recordRequest( + input: RequestInfo | URL, + init: RequestInit | undefined +): RecordedRequest { + const url = new URL(requestUrl(input), location.href) + return { + method: (init?.method ?? 'GET').toUpperCase(), + path: url.origin === location.origin ? url.pathname + url.search : url.href, + headers: Object.fromEntries( + [...new Headers(init?.headers).entries()].map(([key, value]) => [ + key.toLowerCase(), + value + ]) + ), + credentials: init?.credentials ?? null + } +} + +function jsonResponse(body: unknown, status = 200): Response { + return new Response(JSON.stringify(body), { + status, + headers: { 'Content-Type': 'application/json' } + }) +} + +function installFetchRecorder(features: Record) { + const all: RecordedRequest[] = [] + let pending: RecordedRequest[] = [] + let mintCount = 0 + + const mintResponse = (): ExchangeTokenResponse => { + mintCount += 1 + return { + token: `cloud-jwt-${mintCount}`, + expires_at: new Date(Date.now() + ONE_HOUR_MS).toISOString(), + workspace: { id: 'ws-personal', name: 'Personal', type: 'personal' }, + role: 'owner', + permissions: ['owner:*'] + } + } + + const respond = (request: RecordedRequest): Response => { + switch (`${request.method} ${request.path}`) { + case 'GET /api/features': + return jsonResponse(features) + case 'POST /api/auth/session': + return jsonResponse({ success: true }) + case 'POST /api/auth/token': + return jsonResponse(mintResponse()) + case 'GET /api/queue': + return jsonResponse({ queue_running: [], queue_pending: [] }) + case 'POST /api/prompt': + return jsonResponse({ prompt_id: 'prompt-1', number: 1 }) + default: + return jsonResponse({ message: 'unexpected request' }, 404) + } + } + + vi.stubGlobal( + 'fetch', + vi.fn(async (input, init) => { + const request = recordRequest(input, init) + all.push(request) + pending.push(request) + return respond(request) + }) + ) + + return { + all, + get pending() { + return pending + }, + take() { + const taken = pending + pending = [] + return taken + } + } +} + +function wireSessionCookieExtension() { + const extension = registeredExtensions.find( + ({ name }) => name === 'Comfy.Cloud.SessionCookie' + ) + assert.exists(extension) + const scope = effectScope() + scope.run(() => { + const { onUserResolved, onTokenRefreshed } = useCurrentUser() + onUserResolved( + (user) => + void extension.onAuthUserResolved?.(user, fromPartial({})) + ) + onTokenRefreshed(() => void extension.onAuthTokenRefreshed?.()) + }) + return scope +} + +const FEATURES_BOOTSTRAP: RecordedRequest[] = [ + { method: 'GET', path: '/api/features', headers: {}, credentials: null } +] + +const SESSION_POST: RecordedRequest = { + method: 'POST', + path: '/api/auth/session', + headers: { + authorization: 'Bearer firebase-id-token', + 'content-type': 'application/json' + }, + credentials: 'include' +} + +const TOKEN_MINT: RecordedRequest = { + method: 'POST', + path: '/api/auth/token', + headers: { + authorization: 'Bearer firebase-id-token', + 'content-type': 'application/json' + }, + credentials: null +} + +interface FlowGolden { + signIn: RecordedRequest[] + tokenRefresh: RecordedRequest[] + apiCall: RecordedRequest[] +} + +const UNIFIED_CLOUD_AUTH_OFF: FlowGolden = { + signIn: [SESSION_POST], + tokenRefresh: [SESSION_POST], + apiCall: [ + { + method: 'GET', + path: '/api/queue', + headers: { authorization: 'Bearer firebase-id-token', 'comfy-user': '' }, + credentials: null + }, + { + method: 'POST', + path: '/api/prompt', + headers: { + authorization: 'Bearer firebase-id-token', + 'comfy-user': '', + 'content-type': 'application/json' + }, + credentials: null + } + ] +} + +const UNIFIED_CLOUD_AUTH_ON: FlowGolden = { + signIn: [TOKEN_MINT, SESSION_POST], + tokenRefresh: [TOKEN_MINT, SESSION_POST], + apiCall: [ + { + method: 'GET', + path: '/api/queue', + headers: { authorization: 'Bearer cloud-jwt-2', 'comfy-user': '' }, + credentials: null + }, + { + method: 'POST', + path: '/api/prompt', + headers: { + authorization: 'Bearer cloud-jwt-2', + 'comfy-user': '', + 'content-type': 'application/json' + }, + credentials: null + } + ] +} + +const FORBIDDEN_HEADERS = [ + 'x-comfy-workspace-id', + 'x-csrf-token', + 'x-comfy-client' +] + +const isSessionMutation = ({ method, path }: RecordedRequest) => + path === '/api/auth/session' && (method === 'POST' || method === 'DELETE') + +describe('cloud auth requests with unified_web_session off', () => { + let hooks: ReturnType | undefined + + beforeEach(() => { + identity.reset() + }) + + afterEach(() => { + hooks?.stop() + hooks = undefined + remoteConfig.value = {} + }) + + it.for([ + { + name: 'unified_cloud_auth off, unified_web_session absent', + features: { unified_cloud_auth: false }, + golden: UNIFIED_CLOUD_AUTH_OFF + }, + { + name: 'unified_cloud_auth off, unified_web_session false', + features: { unified_cloud_auth: false, unified_web_session: false }, + golden: UNIFIED_CLOUD_AUTH_OFF + }, + { + name: 'unified_cloud_auth on, unified_web_session absent', + features: { unified_cloud_auth: true }, + golden: UNIFIED_CLOUD_AUTH_ON + }, + { + name: 'unified_cloud_auth on, unified_web_session false', + features: { unified_cloud_auth: true, unified_web_session: false }, + golden: UNIFIED_CLOUD_AUTH_ON + } + ])( + 'sends the pinned sign-in, refresh and API requests ($name)', + async ({ features, golden }) => { + const recorder = installFetchRecorder(features) + + await refreshRemoteConfig({ useAuth: false }) + expect(recorder.take()).toEqual(FEATURES_BOOTSTRAP) + + hooks = wireSessionCookieExtension() + identity.signIn(FIREBASE_USER) + await vi.waitFor(() => expect(recorder.pending).toEqual(golden.signIn)) + recorder.take() + + identity.refreshIdToken() + await vi.advanceTimersByTimeAsync(ONE_HOUR_MS - TOKEN_REFRESH_BUFFER_MS) + await vi.waitFor(() => + expect(recorder.pending).toEqual(golden.tokenRefresh) + ) + recorder.take() + + await api.fetchApi('/queue') + await api.fetchApi('/prompt', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ prompt: {} }) + }) + expect(recorder.take()).toEqual(golden.apiCall) + + expect(recorder.all).toEqual([ + ...FEATURES_BOOTSTRAP, + ...golden.signIn, + ...golden.tokenRefresh, + ...golden.apiCall + ]) + + expect( + recorder.all.flatMap(({ headers }) => + Object.keys(headers).filter((key) => FORBIDDEN_HEADERS.includes(key)) + ) + ).toEqual([]) + expect( + recorder.all.filter( + (request) => + request.credentials === 'include' && !isSessionMutation(request) + ) + ).toEqual([]) + expect( + recorder.all.filter( + ({ method, path }) => method === 'GET' && path === '/api/auth/session' + ) + ).toEqual([]) + } + ) +}) From 3171270544c9515142a3826d9e1f88a09f8eb64f Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Thu, 24 Sep 2026 08:51:10 -0400 Subject: [PATCH 03/30] test(account-core): route table for the fake web session endpoint --- packages/account-core/src/testing.ts | 115 ++++++++++++++++++--------- 1 file changed, 76 insertions(+), 39 deletions(-) diff --git a/packages/account-core/src/testing.ts b/packages/account-core/src/testing.ts index c5c838bc066..c3c321e0383 100644 --- a/packages/account-core/src/testing.ts +++ b/packages/account-core/src/testing.ts @@ -64,6 +64,77 @@ function errorResponse(status: number, code: string): Response { return jsonResponse(status, { code, message: code }) } +type RouteHandler = ( + endpoint: FakeWebSessionEndpoint, + headers: Headers +) => Response + +function sessionBody(user: WebSessionUser, now: () => number) { + return { + user: { + id: user.id, + email: user.email, + name: user.name, + email_verified: user.emailVerified, + sign_in_provider: user.signInProvider + }, + csrf_token: FAKE_CSRF_TOKEN, + expires_at: new Date(now() + DAY_MS).toISOString(), + absolute_expires_at: new Date(now() + 7 * DAY_MS).toISOString() + } +} + +function routesFor( + signInUser: WebSessionUser, + now: () => number +): ReadonlyMap { + const revoke = (endpoint: FakeWebSessionEndpoint) => { + endpoint.state = { kind: 'dead', code: 'session_revoked' } + } + return new Map([ + [ + 'POST /api/auth/session', + (endpoint, headers) => { + if (!headers.get('authorization')?.startsWith('Bearer ')) { + return errorResponse(401, 'no_session') + } + endpoint.state = { kind: 'live', user: signInUser } + return jsonResponse(200, { success: true, expiresIn: DAY_MS / 1000 }) + } + ], + [ + 'DELETE /api/auth/session', + (endpoint) => { + revoke(endpoint) + return jsonResponse(200, { success: true }) + } + ], + [ + 'GET /api/auth/session', + ({ state }) => + state.kind === 'live' + ? jsonResponse(200, sessionBody(state.user, now)) + : errorResponse( + 401, + state.kind === 'dead' ? state.code : 'no_session' + ) + ], + [ + 'POST /api/auth/sessions/revoke-all', + (endpoint, headers) => { + if (endpoint.state.kind === 'dead') { + return errorResponse(401, endpoint.state.code) + } + if (headers.get('x-csrf-token') !== FAKE_CSRF_TOKEN) { + return errorResponse(403, 'csrf_invalid') + } + revoke(endpoint) + return new Response(null, { status: 204 }) + } + ] + ]) +} + /** * A `fetch` serving ingest's session routes under `/api/auth`. POST with a * bearer proof signs `signInUser` in; DELETE and revoke-all leave the cookie @@ -79,6 +150,7 @@ export function createFakeWebSessionEndpoint({ now?: () => number }): FakeWebSessionEndpoint { const requests: FakeWebSessionRequest[] = [] + const routes = routesFor(signInUser, now) const endpoint: FakeWebSessionEndpoint = { state, requests, @@ -87,14 +159,13 @@ export function createFakeWebSessionEndpoint({ const { pathname } = new URL( input instanceof Request ? input.url : String(input) ) - const requestHeaders = new Headers(init.headers) - const headers = Object.fromEntries(requestHeaders) + const headers = new Headers(init.headers) requests.push({ method, path: pathname, credentials: init.credentials, cache: init.cache, - headers + headers: Object.fromEntries(headers) }) const current = endpoint.state @@ -104,42 +175,8 @@ export function createFakeWebSessionEndpoint({ if (current.kind === 'unavailable') { return errorResponse(current.status, 'unavailable') } - const route = `${method} ${pathname}` - if (route === 'POST /api/auth/session') { - if (!requestHeaders.get('authorization')?.startsWith('Bearer ')) { - return errorResponse(401, 'no_session') - } - endpoint.state = { kind: 'live', user: signInUser } - return jsonResponse(200, { success: true, expiresIn: DAY_MS / 1000 }) - } - if (route === 'DELETE /api/auth/session') { - endpoint.state = { kind: 'dead', code: 'session_revoked' } - return jsonResponse(200, { success: true }) - } - if (current.kind === 'dead') return errorResponse(401, current.code) - if (route === 'GET /api/auth/session') { - const { user } = current - return jsonResponse(200, { - user: { - id: user.id, - email: user.email, - name: user.name, - email_verified: user.emailVerified, - sign_in_provider: user.signInProvider - }, - csrf_token: FAKE_CSRF_TOKEN, - expires_at: new Date(now() + DAY_MS).toISOString(), - absolute_expires_at: new Date(now() + 7 * DAY_MS).toISOString() - }) - } - if (route === 'POST /api/auth/sessions/revoke-all') { - if (requestHeaders.get('x-csrf-token') !== FAKE_CSRF_TOKEN) { - return errorResponse(403, 'csrf_invalid') - } - endpoint.state = { kind: 'dead', code: 'session_revoked' } - return new Response(null, { status: 204 }) - } - return errorResponse(404, 'not_found') + const route = routes.get(`${method} ${pathname}`) + return route ? route(endpoint, headers) : errorResponse(404, 'not_found') } } return endpoint From 7974b8b88523fa9a17f3064aa707fe0d529c3d34 Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Thu, 24 Sep 2026 12:34:55 -0400 Subject: [PATCH 04/30] test: pin sign-out and the WebSocket URL with unified_web_session off --- src/platform/auth/webSessionFlagOff.test.ts | 81 +++++++++++++++++++-- 1 file changed, 76 insertions(+), 5 deletions(-) diff --git a/src/platform/auth/webSessionFlagOff.test.ts b/src/platform/auth/webSessionFlagOff.test.ts index 3eb2cdf0b9f..9bf485493a4 100644 --- a/src/platform/auth/webSessionFlagOff.test.ts +++ b/src/platform/auth/webSessionFlagOff.test.ts @@ -37,6 +37,11 @@ const identity = vi.hoisted(() => { }, refreshIdToken() { tokenObservers.forEach((observer) => observer(state.user)) + }, + signOut() { + state.user = null + userObservers.forEach((observer) => observer(null)) + tokenObservers.forEach((observer) => observer(null)) } } }) @@ -158,6 +163,32 @@ function installFetchRecorder(features: Record) { } } + class RecordingWebSocket extends EventTarget { + static readonly CONNECTING = 0 + static readonly OPEN = 1 + static readonly CLOSING = 2 + static readonly CLOSED = 3 + readyState = RecordingWebSocket.CONNECTING + binaryType = 'blob' + constructor(url: string | URL) { + super() + const parsed = new URL(String(url)) + const request: RecordedRequest = { + method: 'WEBSOCKET', + path: parsed.pathname + parsed.search, + headers: {}, + credentials: null + } + all.push(request) + pending.push(request) + } + send() {} + close() { + this.readyState = RecordingWebSocket.CLOSED + } + } + vi.stubGlobal('WebSocket', RecordingWebSocket) + vi.stubGlobal( 'fetch', vi.fn(async (input, init) => { @@ -188,12 +219,13 @@ function wireSessionCookieExtension() { assert.exists(extension) const scope = effectScope() scope.run(() => { - const { onUserResolved, onTokenRefreshed } = useCurrentUser() + const { onUserResolved, onTokenRefreshed, onUserLogout } = useCurrentUser() onUserResolved( (user) => void extension.onAuthUserResolved?.(user, fromPartial({})) ) onTokenRefreshed(() => void extension.onAuthTokenRefreshed?.()) + onUserLogout(() => void extension.onAuthUserLogout?.()) }) return scope } @@ -222,10 +254,22 @@ const TOKEN_MINT: RecordedRequest = { credentials: null } +const SIGN_OUT: RecordedRequest[] = [ + { + method: 'DELETE', + path: '/api/auth/session', + headers: {}, + credentials: 'include' + }, + { method: 'WEBSOCKET', path: '/ws', headers: {}, credentials: null } +] + interface FlowGolden { signIn: RecordedRequest[] tokenRefresh: RecordedRequest[] apiCall: RecordedRequest[] + socket: RecordedRequest[] + signOut: RecordedRequest[] } const UNIFIED_CLOUD_AUTH_OFF: FlowGolden = { @@ -248,7 +292,16 @@ const UNIFIED_CLOUD_AUTH_OFF: FlowGolden = { }, credentials: null } - ] + ], + socket: [ + { + method: 'WEBSOCKET', + path: '/ws?token=firebase-id-token', + headers: {}, + credentials: null + } + ], + signOut: SIGN_OUT } const UNIFIED_CLOUD_AUTH_ON: FlowGolden = { @@ -271,7 +324,16 @@ const UNIFIED_CLOUD_AUTH_ON: FlowGolden = { }, credentials: null } - ] + ], + socket: [ + { + method: 'WEBSOCKET', + path: '/ws?token=cloud-jwt-2', + headers: {}, + credentials: null + } + ], + signOut: SIGN_OUT } const FORBIDDEN_HEADERS = [ @@ -318,7 +380,7 @@ describe('cloud auth requests with unified_web_session off', () => { golden: UNIFIED_CLOUD_AUTH_ON } ])( - 'sends the pinned sign-in, refresh and API requests ($name)', + 'sends the pinned sign-in, refresh, API, socket and sign-out requests ($name)', async ({ features, golden }) => { const recorder = installFetchRecorder(features) @@ -345,11 +407,20 @@ describe('cloud auth requests with unified_web_session off', () => { }) expect(recorder.take()).toEqual(golden.apiCall) + await api.resetSocket() + expect(recorder.take()).toEqual(golden.socket) + + identity.signOut() + await vi.advanceTimersByTimeAsync(1_000) + expect(recorder.take()).toEqual(golden.signOut) + expect(recorder.all).toEqual([ ...FEATURES_BOOTSTRAP, ...golden.signIn, ...golden.tokenRefresh, - ...golden.apiCall + ...golden.apiCall, + ...golden.socket, + ...golden.signOut ]) expect( From a2b3d137ad4d9a3aa75abdcfd66e5feacc650f1c Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Thu, 24 Sep 2026 13:16:21 -0400 Subject: [PATCH 05/30] test: pin customer provisioning and media URLs with unified_web_session off --- src/platform/auth/webSessionFlagOff.test.ts | 50 ++++++++++++++++++--- 1 file changed, 44 insertions(+), 6 deletions(-) diff --git a/src/platform/auth/webSessionFlagOff.test.ts b/src/platform/auth/webSessionFlagOff.test.ts index 9bf485493a4..4488542c89e 100644 --- a/src/platform/auth/webSessionFlagOff.test.ts +++ b/src/platform/auth/webSessionFlagOff.test.ts @@ -1,16 +1,19 @@ import { fromPartial } from '@total-typescript/shoehorn' -import type { User } from 'firebase/auth' +import type { User, UserCredential } from 'firebase/auth' import { afterEach, assert, beforeEach, describe, expect, it, vi } from 'vitest' import { effectScope } from 'vue' import type { ExchangeTokenResponse } from '@comfyorg/ingest-types' import { useCurrentUser } from '@/composables/auth/useCurrentUser' +import { getComfyApiBaseUrl } from '@/config/comfyApi' import type { FirebaseIdentity } from '@comfyorg/account-core/firebase' import { refreshRemoteConfig } from '@/platform/remoteConfig/refreshRemoteConfig' import { remoteConfig } from '@/platform/remoteConfig/remoteConfig' import { TOKEN_REFRESH_BUFFER_MS } from '@/platform/workspace/workspaceConstants' import { api } from '@/scripts/api' +import { useAuthStore } from '@/stores/authStore' +import { resultItemPreviewUrl, resultItemUrl } from '@/utils/resultItemUrl' import type { useExtensionService } from '@/services/extensionService' import type { ComfyApp } from '@/scripts/app' import type { ComfyExtension } from '@/types/comfy' @@ -65,7 +68,11 @@ vi.mock(import('@/platform/auth/firebaseIdentity'), () => ({ identity.tokenObservers.add(observer) return () => identity.tokenObservers.delete(observer) }, - currentUser: () => identity.state.user + currentUser: () => identity.state.user, + signInWithEmail: async () => { + identity.signIn(FIREBASE_USER) + return fromPartial({ user: FIREBASE_USER }) + } }) })) @@ -147,6 +154,9 @@ function installFetchRecorder(features: Record) { } const respond = (request: RecordedRequest): Response => { + if (request.path === `${getComfyApiBaseUrl()}/customers`) { + return jsonResponse({ id: 'customer-1' }, 201) + } switch (`${request.method} ${request.path}`) { case 'GET /api/features': return jsonResponse(features) @@ -254,6 +264,19 @@ const TOKEN_MINT: RecordedRequest = { credentials: null } +const MEDIA_ITEM = { + filename: 'output.png', + subfolder: '', + type: 'output', + nodeId: '1', + mediaType: 'images' +} as const + +const MEDIA_URLS = [ + '/api/view?filename=output.png&type=output&subfolder=', + '/api/view?filename=output.png&type=output&subfolder=&res=512' +] + const SIGN_OUT: RecordedRequest[] = [ { method: 'DELETE', @@ -264,6 +287,16 @@ const SIGN_OUT: RecordedRequest[] = [ { method: 'WEBSOCKET', path: '/ws', headers: {}, credentials: null } ] +const CUSTOMER_PROVISIONING: RecordedRequest = { + method: 'POST', + path: `${getComfyApiBaseUrl()}/customers`, + headers: { + authorization: 'Bearer firebase-id-token', + 'content-type': 'application/json' + }, + credentials: null +} + interface FlowGolden { signIn: RecordedRequest[] tokenRefresh: RecordedRequest[] @@ -273,7 +306,7 @@ interface FlowGolden { } const UNIFIED_CLOUD_AUTH_OFF: FlowGolden = { - signIn: [SESSION_POST], + signIn: [SESSION_POST, CUSTOMER_PROVISIONING], tokenRefresh: [SESSION_POST], apiCall: [ { @@ -305,7 +338,7 @@ const UNIFIED_CLOUD_AUTH_OFF: FlowGolden = { } const UNIFIED_CLOUD_AUTH_ON: FlowGolden = { - signIn: [TOKEN_MINT, SESSION_POST], + signIn: [TOKEN_MINT, SESSION_POST, CUSTOMER_PROVISIONING], tokenRefresh: [TOKEN_MINT, SESSION_POST], apiCall: [ { @@ -380,7 +413,7 @@ describe('cloud auth requests with unified_web_session off', () => { golden: UNIFIED_CLOUD_AUTH_ON } ])( - 'sends the pinned sign-in, refresh, API, socket and sign-out requests ($name)', + 'pins sign-in, refresh, API, socket, media and sign-out traffic ($name)', async ({ features, golden }) => { const recorder = installFetchRecorder(features) @@ -388,7 +421,7 @@ describe('cloud auth requests with unified_web_session off', () => { expect(recorder.take()).toEqual(FEATURES_BOOTSTRAP) hooks = wireSessionCookieExtension() - identity.signIn(FIREBASE_USER) + await useAuthStore().login('user-a@example.com', 'password') await vi.waitFor(() => expect(recorder.pending).toEqual(golden.signIn)) recorder.take() @@ -410,6 +443,11 @@ describe('cloud auth requests with unified_web_session off', () => { await api.resetSocket() expect(recorder.take()).toEqual(golden.socket) + expect([ + resultItemUrl(MEDIA_ITEM), + resultItemPreviewUrl(MEDIA_ITEM) + ]).toEqual(MEDIA_URLS) + identity.signOut() await vi.advanceTimersByTimeAsync(1_000) expect(recorder.take()).toEqual(golden.signOut) From 59764515d1cf4a2c43f87580c9b25ab101a496ab Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Thu, 24 Sep 2026 13:19:40 -0400 Subject: [PATCH 06/30] feat(account-core): session-backed identity and boot rules Boots a site from GET /auth/session and follows the server's answer: signed in on 200 (signing out a different remembered login), local sign-out on session_revoked with no restore, one silent restore from a remembered login on no_session/session_expired, and pending with backoff on a network error. An API-key principal never touches the session. Reports session_bootstrap through an injected callback. --- packages/account-core/package.json | 5 + packages/account-core/scripts/smokePack.ts | 4 + .../account-core/src/core/importGuard.test.ts | 16 +- .../src/core/webSessionIdentity.test.ts | 340 ++++++++++++++++++ .../src/core/webSessionIdentity.ts | 319 ++++++++++++++++ .../src/webSessionInertImport.test.ts | 6 +- 6 files changed, 685 insertions(+), 5 deletions(-) create mode 100644 packages/account-core/src/core/webSessionIdentity.test.ts create mode 100644 packages/account-core/src/core/webSessionIdentity.ts diff --git a/packages/account-core/package.json b/packages/account-core/package.json index 77c79b6639f..a2646031d89 100644 --- a/packages/account-core/package.json +++ b/packages/account-core/package.json @@ -25,6 +25,7 @@ "./lazyIdentity": "./src/core/lazyIdentity.ts", "./session": "./src/core/session.ts", "./webSession": "./src/core/webSession.ts", + "./webSessionIdentity": "./src/core/webSessionIdentity.ts", "./billing": "./src/core/billing/index.ts", "./firebase": "./src/firebase/index.ts", "./web": "./src/web/crossTabRefresh.ts", @@ -55,6 +56,10 @@ "types": "./dist/core/webSession.d.ts", "import": "./dist/core/webSession.js" }, + "./webSessionIdentity": { + "types": "./dist/core/webSessionIdentity.d.ts", + "import": "./dist/core/webSessionIdentity.js" + }, "./billing": { "types": "./dist/core/billing/index.d.ts", "import": "./dist/core/billing/index.js" diff --git a/packages/account-core/scripts/smokePack.ts b/packages/account-core/scripts/smokePack.ts index 895bb30af58..7269d67c0b2 100644 --- a/packages/account-core/scripts/smokePack.ts +++ b/packages/account-core/scripts/smokePack.ts @@ -203,6 +203,8 @@ import type { AccountUser, SessionSnapshot } from '@comfyorg/account-core/sessio import { createSessionClient } from '@comfyorg/account-core/session' import type { WebSessionResult } from '@comfyorg/account-core/webSession' import { readWebSession } from '@comfyorg/account-core/webSession' +import type { WebSessionIdentityState } from '@comfyorg/account-core/webSessionIdentity' +import { createWebSessionIdentity } from '@comfyorg/account-core/webSessionIdentity' import type { BillingErrorCode } from '@comfyorg/account-core/billing' import { createSessionBillingTransport } from '@comfyorg/account-core/billing' import type { @@ -259,6 +261,7 @@ export const values = { createBoundedOperation, createSessionClient, readWebSession, + createWebSessionIdentity, createSessionBillingTransport, createFirebaseIdentity, resolveFirebaseIdentity, @@ -294,6 +297,7 @@ export interface Types { boundedOperation: OperationHandle session: SessionSnapshot webSession: WebSessionResult + webSessionIdentity: WebSessionIdentityState billing: BillingErrorCode firebase: FirebaseIdentityAppConfig firebaseResolve: ResolveFirebaseIdentityOptions diff --git a/packages/account-core/src/core/importGuard.test.ts b/packages/account-core/src/core/importGuard.test.ts index d45a06576cf..87532db4de1 100644 --- a/packages/account-core/src/core/importGuard.test.ts +++ b/packages/account-core/src/core/importGuard.test.ts @@ -66,12 +66,16 @@ describe('core import guard', () => { it('scans the web session sources', () => { expect(sources.map(({ name }) => name)).toEqual( - expect.arrayContaining(['webSession.ts', 'webSessionDraftContract.ts']) + expect.arrayContaining([ + 'webSession.ts', + 'webSessionDraftContract.ts', + 'webSessionIdentity.ts' + ]) ) }) - it('keeps the web session module and everything it imports off Firebase', () => { - const closure = relativeImportClosure('webSession.ts') + it('keeps the web session identity and everything it imports off Firebase', () => { + const closure = relativeImportClosure('webSessionIdentity.ts') const firebaseImports = [...closure].flatMap(([file, specifiers]) => specifiers .filter((specifier) => FIREBASE_SPECIFIER.test(specifier)) @@ -79,7 +83,11 @@ describe('core import guard', () => { ) expect([...closure.keys()].map((file) => relative(CORE_DIR, file))).toEqual( - expect.arrayContaining(['webSession.ts', 'webSessionDraftContract.ts']) + expect.arrayContaining([ + 'webSessionIdentity.ts', + 'webSession.ts', + 'webSessionDraftContract.ts' + ]) ) expect(firebaseImports).toEqual([]) }) diff --git a/packages/account-core/src/core/webSessionIdentity.test.ts b/packages/account-core/src/core/webSessionIdentity.test.ts new file mode 100644 index 00000000000..1f0f976b742 --- /dev/null +++ b/packages/account-core/src/core/webSessionIdentity.test.ts @@ -0,0 +1,340 @@ +import { describe, expect, it, vi } from 'vitest' + +import type { FakeWebSessionState } from '../testing.js' +import { createFakeWebSessionEndpoint, fakeWebSessionUser } from '../testing.js' +import type { WebSessionFailure } from './sessionContracts.js' +import type { + RememberedLogin, + ScheduleRetry, + WebSessionBootstrapEvent, + WebSessionIdentity, + WebSessionIdentityState +} from './webSessionIdentity.js' +import { + createWebSessionIdentity, + transitionWebSessionIdentity +} from './webSessionIdentity.js' + +const API = 'https://cloud.example/api' +const ORIGIN = 'https://www.comfy.example' +const SESSION_USER = fakeWebSessionUser({ id: 'user-1' }) + +function createFakeScheduler() { + const pending: { run: () => void; delayMs: number }[] = [] + const schedule: ScheduleRetry = (run, delayMs) => { + const timer = { run, delayMs } + pending.push(timer) + return () => { + pending.splice(pending.indexOf(timer), 1) + } + } + return { + schedule, + delays: () => pending.map(({ delayMs }) => delayMs), + fireNext: () => pending.shift()?.run() + } +} + +function fakeRememberedLogin( + userId: string | null, + getProof: () => Promise = async () => 'remembered-proof' +) { + return { + currentUserId: vi.fn(async () => userId), + getProof: vi.fn(getProof), + signOutLocally: vi.fn(async () => undefined) + } satisfies RememberedLogin +} + +function bootIdentity({ + state, + login, + fetchImpl +}: { + state: FakeWebSessionState + login: RememberedLogin + fetchImpl?: (endpointFetch: typeof fetch) => typeof fetch +}) { + const endpoint = createFakeWebSessionEndpoint({ + state, + signInUser: SESSION_USER + }) + const scheduler = createFakeScheduler() + const reports: WebSessionBootstrapEvent[] = [] + const identity = createWebSessionIdentity({ + session: { + apiBaseUrl: API, + fetchImpl: fetchImpl ? fetchImpl(endpoint.fetch) : endpoint.fetch + }, + principal: { kind: 'account', rememberedLogin: login }, + origin: ORIGIN, + onBootstrap: (event) => reports.push(event), + schedule: scheduler.schedule + }) + identity.boot() + return { endpoint, scheduler, reports, identity } +} + +const RESTING_PHASES: ReadonlySet = new Set([ + 'signed_in', + 'signed_out', + 'retry_wait' +]) + +function nextRest( + identity: WebSessionIdentity +): Promise { + return new Promise((resolve) => { + const unsubscribe = identity.subscribe((state) => { + if (!RESTING_PHASES.has(state.phase)) return + queueMicrotask(unsubscribe) + resolve(state) + }) + }) +} + +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 requestLog(endpoint: { requests: readonly { method: string }[] }) { + return endpoint.requests.map(({ method }) => method) +} + +describe('how a site boots', () => { + it.for([ + { + name: '200 with the same remembered user signs in', + state: { kind: 'live', user: SESSION_USER }, + remembered: 'user-1', + expected: 'signed_in:user-1', + localSignOuts: 0, + requests: ['GET'], + outcomes: ['signed_in'] + }, + { + name: '200 with a different remembered user signs in and signs that login out', + state: { kind: 'live', user: SESSION_USER }, + remembered: 'user-2', + expected: 'signed_in:user-1', + localSignOuts: 1, + requests: ['GET'], + outcomes: ['signed_in'] + }, + { + name: '401 session_revoked signs out locally and never restores', + state: { kind: 'dead', code: 'session_revoked' }, + remembered: 'user-1', + expected: 'signed_out:revoked', + localSignOuts: 1, + requests: ['GET'], + outcomes: ['revoked'] + }, + { + name: '401 no_session with a remembered login restores once', + state: { kind: 'dead', code: 'no_session' }, + remembered: 'user-1', + expected: 'signed_in:user-1', + localSignOuts: 0, + requests: ['GET', 'POST', 'GET'], + outcomes: ['restored'] + }, + { + name: '401 session_expired with a remembered login restores once', + state: { kind: 'dead', code: 'session_expired' }, + remembered: 'user-1', + expected: 'signed_in:user-1', + localSignOuts: 0, + requests: ['GET', 'POST', 'GET'], + outcomes: ['restored'] + }, + { + name: '401 no_session without a remembered login is signed out', + state: { kind: 'dead', code: 'no_session' }, + remembered: null, + expected: 'signed_out:signed_out', + localSignOuts: 0, + requests: ['GET'], + outcomes: ['signed_out'] + }, + { + name: 'a network error stays pending and never signs out', + state: { kind: 'network_error' }, + remembered: 'user-1', + expected: 'retry_wait', + localSignOuts: 0, + requests: ['GET'], + outcomes: [] + } + ] satisfies { + name: string + state: FakeWebSessionState + remembered: string | null + expected: string + localSignOuts: number + requests: string[] + outcomes: string[] + }[])( + '$name', + async ({ + state, + remembered, + expected, + localSignOuts, + requests, + outcomes + }) => { + const login = fakeRememberedLogin(remembered) + const { endpoint, reports, identity } = bootIdentity({ state, login }) + + const settled = await nextRest(identity) + + expect(summarize(settled)).toBe(expected) + expect(login.signOutLocally).toHaveBeenCalledTimes(localSignOuts) + expect(requestLog(endpoint)).toEqual(requests) + expect(reports).toEqual( + outcomes.map((outcome) => ({ outcome, origin: ORIGIN })) + ) + } + ) +}) + +describe('network errors', () => { + it('retries with doubling backoff until the session answers', async () => { + const login = fakeRememberedLogin('user-1') + const { endpoint, scheduler, identity } = bootIdentity({ + state: { kind: 'network_error' }, + login + }) + await nextRest(identity) + expect(scheduler.delays()).toEqual([1000]) + + scheduler.fireNext() + await nextRest(identity) + expect(scheduler.delays()).toEqual([2000]) + + endpoint.state = { kind: 'live', user: SESSION_USER } + scheduler.fireNext() + + expect(summarize(await nextRest(identity))).toBe('signed_in:user-1') + expect(login.signOutLocally).not.toHaveBeenCalled() + }) + + it('dispose cancels the pending retry', async () => { + const { scheduler, identity } = bootIdentity({ + state: { kind: 'network_error' }, + login: fakeRememberedLogin('user-1') + }) + await nextRest(identity) + + identity.dispose() + + expect(scheduler.delays()).toEqual([]) + expect(identity.getState()).toEqual({ phase: 'idle' }) + }) +}) + +describe('silent restore', () => { + it('runs at most once: a restore lost to the network is not repeated', async () => { + const posts: string[] = [] + const { endpoint, scheduler, reports, identity } = bootIdentity({ + state: { kind: 'dead', code: 'no_session' }, + login: fakeRememberedLogin('user-1'), + fetchImpl: (endpointFetch) => async (input, init) => { + if (init?.method !== 'POST') return endpointFetch(input, init) + posts.push(String(input)) + throw new TypeError('Failed to fetch') + } + }) + expect(summarize(await nextRest(identity))).toBe('retry_wait') + + scheduler.fireNext() + + expect(summarize(await nextRest(identity))).toBe( + 'signed_out:restore_failed' + ) + expect(posts).toHaveLength(1) + expect(requestLog(endpoint)).toEqual(['GET', 'GET']) + expect(reports).toEqual([{ outcome: 'restore_failed', origin: ORIGIN }]) + }) + + it('settles signed out when the remembered login cannot produce proof', async () => { + const login = fakeRememberedLogin('user-1', async () => { + throw new Error('login expired') + }) + const { endpoint, identity } = bootIdentity({ + state: { kind: 'dead', code: 'no_session' }, + login + }) + + expect(summarize(await nextRest(identity))).toBe( + 'signed_out:restore_failed' + ) + expect(requestLog(endpoint)).toEqual(['GET']) + }) + + it.for([ + { + code: 'IDENTITY_CHANGED', + retryable: false, + state: { phase: 'signed_out', outcome: 'restore_failed' }, + effects: [{ type: 'report', outcome: 'restore_failed' }] + }, + { + code: 'NO_SESSION', + retryable: false, + state: { phase: 'signed_out', outcome: 'restore_failed' }, + effects: [{ type: 'report', outcome: 'restore_failed' }] + }, + { + code: 'SESSION_REVOKED', + retryable: false, + state: { phase: 'signed_out', outcome: 'revoked' }, + effects: [ + { type: 'sign_out_locally' }, + { type: 'report', outcome: 'revoked' } + ] + }, + { + code: 'SESSION_UNAVAILABLE', + retryable: true, + state: { phase: 'retry_wait', failures: 1, restoreSpent: true }, + effects: [{ type: 'schedule_retry', failures: 1 }] + } + ] satisfies (Pick & + ReturnType)[])( + 'a restore answered $code never restores again', + ({ code, retryable, state, effects }) => { + expect( + transitionWebSessionIdentity( + { phase: 'restoring' }, + { + type: 'restore_answered', + result: { status: 'error', code, retryable }, + rememberedUserId: 'user-1' + } + ) + ).toEqual({ state, effects }) + } + ) +}) + +describe('api-key principal', () => { + it('never reads or creates a session', () => { + const endpoint = createFakeWebSessionEndpoint({ + state: { kind: 'dead', code: 'no_session' } + }) + const identity = createWebSessionIdentity({ + session: { apiBaseUrl: API, fetchImpl: endpoint.fetch }, + principal: { kind: 'api_key' }, + origin: ORIGIN + }) + + identity.boot() + + expect(identity.getState()).toEqual({ phase: 'api_key' }) + expect(endpoint.requests).toEqual([]) + }) +}) diff --git a/packages/account-core/src/core/webSessionIdentity.ts b/packages/account-core/src/core/webSessionIdentity.ts new file mode 100644 index 00000000000..01868fffaa8 --- /dev/null +++ b/packages/account-core/src/core/webSessionIdentity.ts @@ -0,0 +1,319 @@ +/** + * The session-backed identity source: boots a site from `GET /auth/session` + * 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 type { + WebSession, + WebSessionFailure, + WebSessionResult +} from './sessionContracts.js' +import type { WebSessionOptions } from './webSession.js' +import { createWebSession, readWebSession } from './webSession.js' + +export interface RememberedLogin { + /** The Comfy user id of the login this browser remembers, or null. */ + currentUserId: () => Promise + getProof: () => Promise + signOutLocally: () => Promise +} + +export type WebSessionPrincipal = + | { readonly kind: 'account'; readonly rememberedLogin: RememberedLogin } + | { readonly kind: 'api_key' } + +export type WebSessionBootOutcome = + | 'signed_in' + | 'restored' + | 'signed_out' + | 'revoked' + | 'restore_failed' + +export interface WebSessionBootstrapEvent { + readonly outcome: WebSessionBootOutcome + readonly origin: string +} + +type SignedOutOutcome = Exclude + +export type WebSessionIdentityState = + | { readonly phase: 'idle' } + | { readonly phase: 'api_key' } + | { + readonly phase: 'reading' | 'retry_wait' + readonly failures: number + readonly restoreSpent: boolean + } + | { readonly phase: 'restoring' } + | { readonly phase: 'signed_in'; readonly session: WebSession } + | { readonly phase: 'signed_out'; readonly outcome: SignedOutOutcome } + +export type WebSessionIdentityEvent = + | { readonly type: 'boot' } + | { + readonly type: 'read_answered' | 'restore_answered' + readonly result: WebSessionResult + readonly rememberedUserId: string | null + } + | { readonly type: 'proof_unavailable' } + | { readonly type: 'retry_due' } + +export type WebSessionIdentityEffect = + | { readonly type: 'read' } + | { readonly type: 'restore' } + | { readonly type: 'schedule_retry'; readonly failures: number } + | { readonly type: 'sign_out_locally' } + | { readonly type: 'report'; readonly outcome: WebSessionBootOutcome } + +export interface WebSessionIdentityTransition { + readonly state: WebSessionIdentityState + readonly effects: readonly WebSessionIdentityEffect[] +} + +const read: WebSessionIdentityEffect = { type: 'read' } +const signOutLocally: WebSessionIdentityEffect = { type: 'sign_out_locally' } + +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] : []), + { type: 'report', outcome } + ] + } +} + +function settleSignedOut( + outcome: SignedOutOutcome +): WebSessionIdentityTransition { + return { + state: { phase: 'signed_out', outcome }, + effects: [ + ...(outcome === 'revoked' ? [signOutLocally] : []), + { type: 'report', outcome } + ] + } +} + +function waitToRetry( + failures: number, + restoreSpent: boolean +): WebSessionIdentityTransition { + return { + state: { phase: 'retry_wait', failures, restoreSpent }, + effects: [{ type: 'schedule_retry', failures }] + } +} + +function isNoLiveSession(failure: WebSessionFailure): boolean { + return failure.code === 'NO_SESSION' || failure.code === 'SESSION_EXPIRED' +} + +function applyReadAnswered( + { failures, restoreSpent }: { failures: number; restoreSpent: boolean }, + result: WebSessionResult, + rememberedUserId: string | null +): WebSessionIdentityTransition { + if (result.status === 'ok') { + return settleSignedIn(result.session, rememberedUserId, 'signed_in') + } + if (result.retryable) return waitToRetry(failures + 1, restoreSpent) + if (result.code === 'SESSION_REVOKED') return settleSignedOut('revoked') + if (!isNoLiveSession(result)) return settleSignedOut('signed_out') + if (restoreSpent) return settleSignedOut('restore_failed') + if (rememberedUserId === null) return settleSignedOut('signed_out') + return { state: { phase: 'restoring' }, effects: [{ type: 'restore' }] } +} + +function applyRestoreAnswered( + result: WebSessionResult, + rememberedUserId: string | null +): WebSessionIdentityTransition { + if (result.status === 'ok') { + return settleSignedIn(result.session, rememberedUserId, 'restored') + } + if (result.retryable) return waitToRetry(1, true) + if (result.code === 'SESSION_REVOKED') return settleSignedOut('revoked') + return settleSignedOut('restore_failed') +} + +/** Pure: an event that means nothing in the current phase changes nothing. */ +export function transitionWebSessionIdentity( + state: WebSessionIdentityState, + event: WebSessionIdentityEvent +): WebSessionIdentityTransition { + const unchanged = { state, effects: [] } + switch (event.type) { + case 'boot': + return state.phase === 'idle' + ? { + state: { phase: 'reading', failures: 0, restoreSpent: false }, + effects: [read] + } + : unchanged + case 'read_answered': + return state.phase === 'reading' + ? applyReadAnswered(state, event.result, event.rememberedUserId) + : unchanged + case 'restore_answered': + return state.phase === 'restoring' + ? applyRestoreAnswered(event.result, event.rememberedUserId) + : unchanged + case 'proof_unavailable': + return state.phase === 'restoring' + ? settleSignedOut('restore_failed') + : unchanged + case 'retry_due': + return state.phase === 'retry_wait' + ? { state: { ...state, phase: 'reading' }, effects: [read] } + : unchanged + } +} + +export type ScheduleRetry = (run: () => void, delayMs: number) => () => void + +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 + readonly schedule?: ScheduleRetry + readonly retryBaseMs?: number + readonly retryMaxMs?: number +} + +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. */ + boot: () => void + /** Cancels the retry, ignores answers in flight, and returns to idle. */ + dispose: () => void +} + +const scheduleWithTimer: ScheduleRetry = (run, delayMs) => { + const timer = setTimeout(run, delayMs) + return () => clearTimeout(timer) +} + +function reportLocalSignOutFailure(error: unknown): void { + console.warn('webSessionIdentity: local sign-out failed', error) +} + +function createApiKeyIdentity(): WebSessionIdentity { + const state: WebSessionIdentityState = { phase: 'api_key' } + return { + getState: () => state, + subscribe: (listener) => { + listener(state) + return () => undefined + }, + boot: () => undefined, + dispose: () => undefined + } +} + +function createAccountIdentity( + options: WebSessionIdentityOptions, + login: RememberedLogin +): WebSessionIdentity { + const schedule = options.schedule ?? scheduleWithTimer + const retryBaseMs = options.retryBaseMs ?? 1000 + const retryMaxMs = options.retryMaxMs ?? 60_000 + const listeners = new Set<(state: WebSessionIdentityState) => void>() + let state: WebSessionIdentityState = { phase: 'idle' } + let generation = 0 + let cancelRetry: (() => void) | undefined + + function dispatch(event: WebSessionIdentityEvent): void { + const next = transitionWebSessionIdentity(state, event) + if (next.state === state) return + state = next.state + listeners.forEach((listener) => listener(state)) + next.effects.forEach(run) + } + + async function answer( + started: number, + type: 'read_answered' | 'restore_answered', + request: () => Promise + ): Promise { + const result = await request() + const rememberedUserId = await login.currentUserId().catch(() => null) + if (started === generation) dispatch({ type, result, rememberedUserId }) + } + + function restore(started: number): void { + answer(started, 'restore_answered', () => + createWebSession(options.session, login.getProof) + ).catch(() => { + if (started === generation) dispatch({ type: 'proof_unavailable' }) + }) + } + + function run(effect: WebSessionIdentityEffect): void { + switch (effect.type) { + case 'read': + void answer(generation, 'read_answered', () => + readWebSession(options.session) + ) + return + case 'restore': + restore(generation) + return + case 'schedule_retry': + cancelRetry = schedule( + () => { + cancelRetry = undefined + dispatch({ type: 'retry_due' }) + }, + Math.min(retryBaseMs * 2 ** (effect.failures - 1), retryMaxMs) + ) + return + case 'sign_out_locally': + login.signOutLocally().catch(reportLocalSignOutFailure) + return + case 'report': + options.onBootstrap?.({ + outcome: effect.outcome, + origin: options.origin + }) + } + } + + return { + getState: () => state, + subscribe: (listener) => { + listeners.add(listener) + listener(state) + return () => { + listeners.delete(listener) + } + }, + boot: () => dispatch({ type: 'boot' }), + dispose: () => { + generation += 1 + cancelRetry?.() + cancelRetry = undefined + state = { phase: 'idle' } + listeners.forEach((listener) => listener(state)) + } + } +} + +/** Inert until `boot()`: constructing it sends no request and arms no timer. */ +export function createWebSessionIdentity( + options: WebSessionIdentityOptions +): WebSessionIdentity { + return options.principal.kind === 'api_key' + ? createApiKeyIdentity() + : createAccountIdentity(options, options.principal.rememberedLogin) +} diff --git a/packages/account-core/src/webSessionInertImport.test.ts b/packages/account-core/src/webSessionInertImport.test.ts index 540ea8f244c..76f481379a2 100644 --- a/packages/account-core/src/webSessionInertImport.test.ts +++ b/packages/account-core/src/webSessionInertImport.test.ts @@ -4,7 +4,11 @@ beforeEach(() => { vi.resetModules() }) -it.for(['@comfyorg/account-core/webSession', '@comfyorg/account-core/testing'])( +it.for([ + '@comfyorg/account-core/webSession', + '@comfyorg/account-core/webSessionIdentity', + '@comfyorg/account-core/testing' +])( 'importing %s starts no timer, listener, channel, or request', async (specifier) => { const fetchSpy = vi.fn() From d66f19db248caa66f7a0b82f9e6f17cf6d4b1622 Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Thu, 24 Sep 2026 13:20:29 -0400 Subject: [PATCH 07/30] feat(account-core): requestAuth authorize() for cookie requests authorize decides the credential headers for one request: a cookie session on ingest sends the workspace header, the CSRF token on unsafe methods, the SDK client header, and credentials include; a resource target gets a Bearer workspace token from an injected source; Firebase and API-key principals keep today's single header. createCredentialedBillingTransport opts in through webSession: headers come from authorize, and csrf_invalid is retried once after re-reading the session for the same user. A changed user abandons the request; origin_not_allowed, cross_site_request and workspace_access_denied are never retried. Hosts that do not pass webSession are unchanged. --- packages/account-core/package.json | 5 + packages/account-core/scripts/smokePack.ts | 4 + .../src/core/billing/credentialedTransport.ts | 154 +++++++++-- .../credentialedTransport.webSession.test.ts | 241 ++++++++++++++++++ .../account-core/src/core/billing/index.ts | 5 +- .../account-core/src/core/requestAuth.test.ts | 235 +++++++++++++++++ packages/account-core/src/core/requestAuth.ts | 87 +++++++ .../src/webSessionInertImport.test.ts | 6 +- 8 files changed, 720 insertions(+), 17 deletions(-) create mode 100644 packages/account-core/src/core/billing/credentialedTransport.webSession.test.ts create mode 100644 packages/account-core/src/core/requestAuth.test.ts create mode 100644 packages/account-core/src/core/requestAuth.ts diff --git a/packages/account-core/package.json b/packages/account-core/package.json index 77c79b6639f..4e31587aa3e 100644 --- a/packages/account-core/package.json +++ b/packages/account-core/package.json @@ -25,6 +25,7 @@ "./lazyIdentity": "./src/core/lazyIdentity.ts", "./session": "./src/core/session.ts", "./webSession": "./src/core/webSession.ts", + "./requestAuth": "./src/core/requestAuth.ts", "./billing": "./src/core/billing/index.ts", "./firebase": "./src/firebase/index.ts", "./web": "./src/web/crossTabRefresh.ts", @@ -55,6 +56,10 @@ "types": "./dist/core/webSession.d.ts", "import": "./dist/core/webSession.js" }, + "./requestAuth": { + "types": "./dist/core/requestAuth.d.ts", + "import": "./dist/core/requestAuth.js" + }, "./billing": { "types": "./dist/core/billing/index.d.ts", "import": "./dist/core/billing/index.js" diff --git a/packages/account-core/scripts/smokePack.ts b/packages/account-core/scripts/smokePack.ts index 895bb30af58..b501ece0f3e 100644 --- a/packages/account-core/scripts/smokePack.ts +++ b/packages/account-core/scripts/smokePack.ts @@ -203,6 +203,8 @@ import type { AccountUser, SessionSnapshot } from '@comfyorg/account-core/sessio import { createSessionClient } from '@comfyorg/account-core/session' import type { WebSessionResult } from '@comfyorg/account-core/webSession' import { readWebSession } from '@comfyorg/account-core/webSession' +import type { RequestAuthorization } from '@comfyorg/account-core/requestAuth' +import { createRequestAuthorizer } from '@comfyorg/account-core/requestAuth' import type { BillingErrorCode } from '@comfyorg/account-core/billing' import { createSessionBillingTransport } from '@comfyorg/account-core/billing' import type { @@ -259,6 +261,7 @@ export const values = { createBoundedOperation, createSessionClient, readWebSession, + createRequestAuthorizer, createSessionBillingTransport, createFirebaseIdentity, resolveFirebaseIdentity, @@ -294,6 +297,7 @@ export interface Types { boundedOperation: OperationHandle session: SessionSnapshot webSession: WebSessionResult + requestAuth: RequestAuthorization billing: BillingErrorCode firebase: FirebaseIdentityAppConfig firebaseResolve: ResolveFirebaseIdentityOptions diff --git a/packages/account-core/src/core/billing/credentialedTransport.ts b/packages/account-core/src/core/billing/credentialedTransport.ts index dcd8dc8e822..8563826fc5a 100644 --- a/packages/account-core/src/core/billing/credentialedTransport.ts +++ b/packages/account-core/src/core/billing/credentialedTransport.ts @@ -13,14 +13,24 @@ * `authenticationRetrySkipped` stays unset; it means a replayable retry was * possible and skipped, which is never the case on this transport. * - * No CSRF header is sent. What stands in for one is the JSON content type - * `exchangeBillingRequest` always sends: it makes every request non-simple, - * so a cross-site caller has to clear a preflight it cannot satisfy. That - * rests on the cookie's `SameSite` attribute and the backend's CORS - * allowlist, neither of which is enforced here — sending a form-encoded or - * otherwise CORS-simple request from this transport removes the protection. - * A CSRF header is added here when the backend names one. + * Without a web session no CSRF header is sent. What stands in for one is + * the JSON content type `exchangeBillingRequest` always sends: it makes + * every request non-simple, so a cross-site caller has to clear a preflight + * it cannot satisfy. That rests on the cookie's `SameSite` attribute and the + * backend's CORS allowlist, neither of which is enforced here — sending a + * form-encoded or otherwise CORS-simple request from this transport removes + * the protection. + * A host on the shared web session opts in through `webSession`: headers + * then come from `authorize`, and a `csrf_invalid` answer is retried once + * after re-reading the session, only while it still belongs to the same user. */ +import type { RequestAuthorization, RequestAuthorizer } from '../requestAuth.js' +import type { + WebSession, + WebSessionErrorCode, + WebSessionFailure, + WebSessionResult +} from '../sessionContracts.js' import type { BillingHttpResponse, BillingRequest, @@ -29,6 +39,7 @@ import type { } from './billingContracts.js' import type { BillingScope, BillingScopeSource } from './billingScope.js' import { sameBillingScope } from './billingScope.js' +import { readBillingErrorCode } from './billingErrorBody.js' import { DEFAULT_BILLING_TIMEOUT_MS, exchangeBillingRequest, @@ -43,8 +54,22 @@ export interface CredentialedBillingTransportOptions { readonly credentials?: RequestCredentials readonly fetchImpl?: typeof fetch readonly defaultTimeoutMs?: number + /** Opt-in cookie-session headers; `credentials` is then ignored. */ + readonly webSession?: CredentialedWebSession +} + +export interface CredentialedWebSession { + readonly authorize: RequestAuthorizer + readonly getSession: () => WebSession | undefined + /** `readWebSession` bound to the host's ingest options. */ + readonly readSession: (request: { + readonly expectedUserId: string + readonly signal: AbortSignal + }) => Promise } +type Exchange = BillingResult + /** * Any scope other than the captured one supersedes the response, undefined * included. A source has no "still minting" state: undefined means the scope @@ -70,6 +95,70 @@ function markSessionEnded(response: BillingHttpResponse): BillingHttpResponse { return { ...response, authenticationNotRenewable: true } } +const SESSION_ENDED: ReadonlySet = new Set([ + 'NO_SESSION', + 'SESSION_EXPIRED', + 'SESSION_REVOKED' +]) + +function isCsrfInvalid(response: BillingHttpResponse): boolean { + return ( + response.httpStatus === 403 && + readBillingErrorCode(response.body) === 'csrf_invalid' + ) +} + +function rereadFailure({ code }: WebSessionFailure): Exchange { + if (code === 'IDENTITY_CHANGED') + return { status: 'error', code: 'SUPERSEDED' } + return { + status: 'error', + code: SESSION_ENDED.has(code) ? 'NOT_AUTHENTICATED' : 'REQUEST_FAILED' + } +} + +/** + * `csrf_invalid` is the one refusal a fresh token can fix, and the server + * refused before acting, so the replay is safe for a write too. The re-read + * is pinned to the user the request started as, and the retry to the + * captured workspace: a changed user abandons the request rather than + * finishing it as someone else. + */ +async function exchangeWithSession( + request: BillingRequest, + webSession: CredentialedWebSession, + session: WebSession, + context: { + readonly workspaceId: string + readonly signal: AbortSignal + readonly stillInScope: () => boolean + readonly send: (authorization: RequestAuthorization) => Promise + } +): Promise { + const sendAs = async (current: WebSession) => { + const authorization = await webSession.authorize( + { kind: 'session', session: current }, + { + target: 'ingest', + method: request.method, + workspaceId: context.workspaceId + } + ) + return context.send(authorization) + } + + const first = await sendAs(session) + if (first.status === 'error' || !isCsrfInvalid(first.value)) return first + if (!context.stillInScope()) return { status: 'error', code: 'SUPERSEDED' } + + const reread = await webSession.readSession({ + expectedUserId: session.user.id, + signal: context.signal + }) + if (reread.status === 'error') return rereadFailure(reread) + return sendAs(reread.session) +} + export function createCredentialedBillingTransport( options: CredentialedBillingTransportOptions ): BillingTransport { @@ -78,14 +167,54 @@ export function createCredentialedBillingTransport( scopeSource, credentials = 'include', fetchImpl = fetch, - defaultTimeoutMs = DEFAULT_BILLING_TIMEOUT_MS + defaultTimeoutMs = DEFAULT_BILLING_TIMEOUT_MS, + webSession } = options + type Send = ( + request: BillingRequest, + captured: BillingScope, + signal: AbortSignal + ) => Promise + + const exchange = ( + request: BillingRequest, + signal: AbortSignal, + auth: { + readonly credentials?: RequestCredentials + readonly headers?: Readonly> + } + ) => + exchangeBillingRequest(request, { + fetchImpl, + url: resolveUrl(request.route), + signal, + ...auth + }) + + const sendPlain: Send = (request, _captured, signal) => + exchange(request, signal, { credentials }) + + function sessionSender(session: WebSession | undefined): Send | undefined { + if (webSession === undefined || session === undefined) return undefined + return (request, captured, signal) => + exchangeWithSession(request, webSession, session, { + workspaceId: captured.workspaceId, + signal, + stillInScope: () => !movedOutOfScope(scopeSource, captured), + send: (authorization) => exchange(request, signal, authorization) + }) + } + return async function transport( request: BillingRequest ): Promise> { const captured = scopeSource.getScope() - if (captured === undefined) { + const send = + webSession === undefined + ? sendPlain + : sessionSender(webSession.getSession()) + if (captured === undefined || send === undefined) { return { status: 'error', code: 'NOT_AUTHENTICATED' } } @@ -94,12 +223,7 @@ export function createCredentialedBillingTransport( request.timeoutMs ?? defaultTimeoutMs ) try { - const response = await exchangeBillingRequest(request, { - fetchImpl, - url: resolveUrl(request.route), - signal: budget.signal, - credentials - }) + const response = await send(request, captured, budget.signal) if (response.status === 'error') return response if (movedOutOfScope(scopeSource, captured)) { return { status: 'error', code: 'SUPERSEDED' } diff --git a/packages/account-core/src/core/billing/credentialedTransport.webSession.test.ts b/packages/account-core/src/core/billing/credentialedTransport.webSession.test.ts new file mode 100644 index 00000000000..04bbb5e976a --- /dev/null +++ b/packages/account-core/src/core/billing/credentialedTransport.webSession.test.ts @@ -0,0 +1,241 @@ +import { describe, expect, it, vi } from 'vitest' + +import type { FakeWebSessionState } from '../../testing.js' +import { + createFakeWebSessionEndpoint, + fakeWebSessionUser +} from '../../testing.js' +import { COMFY_CLIENT, createRequestAuthorizer } from '../requestAuth.js' +import type { WebSession } from '../sessionContracts.js' +import { readWebSession } from '../webSession.js' +import type { BillingScope } from './billingScope.js' +import { createCredentialedBillingTransport } from './credentialedTransport.js' + +const BASE = 'https://cloud.test/api' +const USER = fakeWebSessionUser({ id: 'user-1' }) +const SCOPE: BillingScope = { + userId: 'user-1', + workspaceId: 'ws-1', + role: 'owner' +} + +const STALE_SESSION: WebSession = { + user: USER, + csrfToken: 'stale-csrf', + expiresAt: 0, + absoluteExpiresAt: 0 +} + +function jsonResponse(status: number, body: unknown): Response { + return new Response(JSON.stringify(body), { + status, + headers: { 'Content-Type': 'application/json' } + }) +} + +function refusal(code: string): Response { + return jsonResponse(403, { code, message: code }) +} + +function makeTransport( + options: { + responses?: Response[] + session?: WebSession | undefined + sessionState?: FakeWebSessionState + scope?: () => BillingScope | undefined + } = {} +) { + const endpoint = createFakeWebSessionEndpoint({ + state: options.sessionState ?? { kind: 'live', user: USER } + }) + const queue = [...(options.responses ?? [jsonResponse(200, { ok: true })])] + const fetchImpl = vi.fn( + async () => queue.shift() ?? jsonResponse(200, { ok: true }) + ) + const transport = createCredentialedBillingTransport({ + resolveUrl: (route) => `${BASE}${route}`, + scopeSource: { + getScope: options.scope ?? (() => SCOPE), + subscribe: () => () => {} + }, + fetchImpl, + webSession: { + authorize: createRequestAuthorizer({ + getWorkspaceToken: () => Promise.reject(new Error('not a resource')) + }), + getSession: () => + 'session' in options ? options.session : STALE_SESSION, + readSession: ({ expectedUserId, signal }) => + readWebSession( + { apiBaseUrl: BASE, fetchImpl: endpoint.fetch, signal }, + { expectedUserId } + ) + } + }) + const sent = () => + fetchImpl.mock.calls.map(([, init]) => ({ + credentials: init?.credentials, + headers: Object.fromEntries(new Headers(init?.headers)) + })) + return { transport, fetchImpl, endpoint, sent } +} + +describe('createCredentialedBillingTransport with a web session', () => { + it.for([ + { + method: 'GET' as const, + expected: { + 'x-comfy-client': COMFY_CLIENT, + 'x-comfy-workspace-id': 'ws-1' + } + }, + { + method: 'POST' as const, + expected: { + 'x-comfy-client': COMFY_CLIENT, + 'x-comfy-workspace-id': 'ws-1', + 'x-csrf-token': 'stale-csrf' + } + } + ])( + 'sends the cookie headers authorize decides for a $method', + async ({ method, expected }) => { + const { transport, sent } = makeTransport() + + await transport({ method, route: '/billing/status' }) + + expect(sent()).toEqual([ + { + credentials: 'include', + headers: { 'content-type': 'application/json', ...expected } + } + ]) + } + ) + + it('retries csrf_invalid once with the re-read token, in the same workspace', async () => { + const { transport, sent } = makeTransport({ + responses: [refusal('csrf_invalid'), jsonResponse(200, { ok: true })] + }) + + const result = await transport({ + method: 'POST', + route: '/billing/topup', + body: { amount_cents: 500 } + }) + + expect(result).toMatchObject({ status: 'ok', value: { httpStatus: 200 } }) + expect( + sent().map(({ headers }) => [ + headers['x-csrf-token'], + headers['x-comfy-workspace-id'] + ]) + ).toEqual([ + ['stale-csrf', 'ws-1'], + ['fake-csrf-token', 'ws-1'] + ]) + }) + + it('returns a second csrf_invalid rather than retrying again', async () => { + const { transport, fetchImpl } = makeTransport({ + responses: [refusal('csrf_invalid'), refusal('csrf_invalid')] + }) + + const result = await transport({ method: 'POST', route: '/billing/topup' }) + + expect(result).toMatchObject({ status: 'ok', value: { httpStatus: 403 } }) + expect(fetchImpl).toHaveBeenCalledTimes(2) + }) + + it('abandons the request when the session now belongs to another user', async () => { + const { transport, fetchImpl } = makeTransport({ + responses: [refusal('csrf_invalid')], + sessionState: { + kind: 'live', + user: fakeWebSessionUser({ id: 'user-2' }) + } + }) + + const result = await transport({ method: 'POST', route: '/billing/topup' }) + + expect(result).toEqual({ status: 'error', code: 'SUPERSEDED' }) + expect(fetchImpl).toHaveBeenCalledOnce() + }) + + it.for([ + 'origin_not_allowed', + 'cross_site_request', + 'workspace_access_denied' + ])('never retries %s or re-reads the session for it', async (code) => { + const { transport, fetchImpl, endpoint } = makeTransport({ + responses: [refusal(code)] + }) + + const result = await transport({ method: 'POST', route: '/billing/topup' }) + + expect(result).toMatchObject({ + status: 'ok', + value: { httpStatus: 403, body: { code } } + }) + expect(fetchImpl).toHaveBeenCalledOnce() + expect(endpoint.requests).toEqual([]) + }) + + it.for<{ state: FakeWebSessionState; code: string }>([ + { + state: { kind: 'dead', code: 'session_revoked' }, + code: 'NOT_AUTHENTICATED' + }, + { + state: { kind: 'dead', code: 'session_expired' }, + code: 'NOT_AUTHENTICATED' + }, + { state: { kind: 'unavailable', status: 503 }, code: 'REQUEST_FAILED' } + ])( + 'reports $code without a retry when the re-read finds $state.kind', + async ({ state, code }) => { + const { transport, fetchImpl } = makeTransport({ + responses: [refusal('csrf_invalid')], + sessionState: state + }) + + const result = await transport({ + method: 'POST', + route: '/billing/topup' + }) + + expect(result).toEqual({ status: 'error', code }) + expect(fetchImpl).toHaveBeenCalledOnce() + } + ) + + it('does not retry once the host has left the scope the request started in', async () => { + const scopes: Array = [ + SCOPE, + { ...SCOPE, workspaceId: 'ws-2' } + ] + let current = 0 + const { transport, fetchImpl, endpoint } = makeTransport({ + scope: () => scopes[current] + }) + fetchImpl.mockImplementationOnce(async () => { + current = 1 + return refusal('csrf_invalid') + }) + + const result = await transport({ method: 'POST', route: '/billing/topup' }) + + expect(result).toEqual({ status: 'error', code: 'SUPERSEDED' }) + expect(fetchImpl).toHaveBeenCalledOnce() + expect(endpoint.requests).toEqual([]) + }) + + it('reports NOT_AUTHENTICATED without sending when there is no session', async () => { + const { transport, fetchImpl } = makeTransport({ session: undefined }) + + const result = await transport({ method: 'GET', route: '/billing/status' }) + + expect(result).toEqual({ status: 'error', code: 'NOT_AUTHENTICATED' }) + expect(fetchImpl).not.toHaveBeenCalled() + }) +}) diff --git a/packages/account-core/src/core/billing/index.ts b/packages/account-core/src/core/billing/index.ts index 3f4f789b3f3..f3d459ff7e6 100644 --- a/packages/account-core/src/core/billing/index.ts +++ b/packages/account-core/src/core/billing/index.ts @@ -20,7 +20,10 @@ export type { export { matchesServerCode, unwrapServerCode } from './billingContracts.js' export type { SessionBillingTransportOptions } from './transport.js' export { createSessionBillingTransport } from './transport.js' -export type { CredentialedBillingTransportOptions } from './credentialedTransport.js' +export type { + CredentialedBillingTransportOptions, + CredentialedWebSession +} from './credentialedTransport.js' export { createCredentialedBillingTransport } from './credentialedTransport.js' export type { BillingScope, BillingScopeSource } from './billingScope.js' export { sessionBillingScopeSource } from './billingScope.js' diff --git a/packages/account-core/src/core/requestAuth.test.ts b/packages/account-core/src/core/requestAuth.test.ts new file mode 100644 index 00000000000..c11809c2b9d --- /dev/null +++ b/packages/account-core/src/core/requestAuth.test.ts @@ -0,0 +1,235 @@ +import { describe, expect, it } from 'vitest' + +import { fakeWebSessionUser } from '../testing.js' +import type { + RequestAuthorization, + RequestPrincipal, + RequestTarget +} from './requestAuth.js' +import { COMFY_CLIENT, createRequestAuthorizer } from './requestAuth.js' + +const SESSION: RequestPrincipal = { + kind: 'session', + session: { + user: fakeWebSessionUser(), + csrfToken: 'csrf-1', + expiresAt: 0, + absoluteExpiresAt: 0 + } +} +const FIREBASE: RequestPrincipal = { + kind: 'firebase', + getIdToken: async () => 'firebase-id-token' +} +const API_KEY: RequestPrincipal = { kind: 'apiKey', apiKey: 'comfyui-key' } + +const authorize = createRequestAuthorizer({ + getWorkspaceToken: async (workspaceId) => `jwt-for-${workspaceId}` +}) + +const COOKIE_READ: RequestAuthorization = { + headers: { + 'X-Comfy-Client': COMFY_CLIENT, + 'X-Comfy-Workspace-ID': 'ws-1' + }, + credentials: 'include' +} +const COOKIE_WRITE: RequestAuthorization = { + headers: { ...COOKIE_READ.headers, 'X-CSRF-Token': 'csrf-1' }, + credentials: 'include' +} +const WORKSPACE_BEARER: RequestAuthorization = { + headers: { Authorization: 'Bearer jwt-for-ws-1' } +} +const FIREBASE_BEARER: RequestAuthorization = { + headers: { Authorization: 'Bearer firebase-id-token' } +} +const API_KEY_HEADER: RequestAuthorization = { + headers: { 'X-API-KEY': 'comfyui-key' } +} + +describe('createRequestAuthorizer', () => { + it.for<{ + target: RequestTarget + principal: RequestPrincipal + method: string + expected: RequestAuthorization + }>([ + { + target: 'ingest', + principal: SESSION, + method: 'GET', + expected: COOKIE_READ + }, + { + target: 'ingest', + principal: SESSION, + method: 'HEAD', + expected: COOKIE_READ + }, + { + target: 'ingest', + principal: SESSION, + method: 'OPTIONS', + expected: COOKIE_READ + }, + { + target: 'ingest', + principal: SESSION, + method: 'get', + expected: COOKIE_READ + }, + { + target: 'ingest', + principal: SESSION, + method: 'POST', + expected: COOKIE_WRITE + }, + { + target: 'ingest', + principal: SESSION, + method: 'PUT', + expected: COOKIE_WRITE + }, + { + target: 'ingest', + principal: SESSION, + method: 'PATCH', + expected: COOKIE_WRITE + }, + { + target: 'ingest', + principal: SESSION, + method: 'DELETE', + expected: COOKIE_WRITE + }, + { + target: 'ingest', + principal: SESSION, + method: 'delete', + expected: COOKIE_WRITE + }, + { + target: 'resource', + principal: SESSION, + method: 'GET', + expected: WORKSPACE_BEARER + }, + { + target: 'resource', + principal: SESSION, + method: 'POST', + expected: WORKSPACE_BEARER + }, + { + target: 'resource', + principal: SESSION, + method: 'DELETE', + expected: WORKSPACE_BEARER + }, + { + target: 'ingest', + principal: FIREBASE, + method: 'GET', + expected: FIREBASE_BEARER + }, + { + target: 'ingest', + principal: FIREBASE, + method: 'POST', + expected: FIREBASE_BEARER + }, + { + target: 'ingest', + principal: FIREBASE, + method: 'DELETE', + expected: FIREBASE_BEARER + }, + { + target: 'resource', + principal: FIREBASE, + method: 'GET', + expected: FIREBASE_BEARER + }, + { + target: 'resource', + principal: FIREBASE, + method: 'POST', + expected: FIREBASE_BEARER + }, + { + target: 'resource', + principal: FIREBASE, + method: 'DELETE', + expected: FIREBASE_BEARER + }, + { + target: 'ingest', + principal: API_KEY, + method: 'GET', + expected: API_KEY_HEADER + }, + { + target: 'ingest', + principal: API_KEY, + method: 'POST', + expected: API_KEY_HEADER + }, + { + target: 'ingest', + principal: API_KEY, + method: 'DELETE', + expected: API_KEY_HEADER + }, + { + target: 'resource', + principal: API_KEY, + method: 'GET', + expected: API_KEY_HEADER + }, + { + target: 'resource', + principal: API_KEY, + method: 'POST', + expected: API_KEY_HEADER + }, + { + target: 'resource', + principal: API_KEY, + method: 'DELETE', + expected: API_KEY_HEADER + } + ])( + '$target $method as $principal.kind', + async ({ target, principal, method, expected }) => { + await expect( + authorize(principal, { target, method, workspaceId: 'ws-1' }) + ).resolves.toEqual(expected) + } + ) + + it.for<{ target: RequestTarget; expected: RequestAuthorization }>([ + { + target: 'ingest', + expected: { + headers: { 'X-Comfy-Client': COMFY_CLIENT, 'X-CSRF-Token': 'csrf-1' }, + credentials: 'include' + } + }, + { + target: 'resource', + expected: { headers: { Authorization: 'Bearer jwt-for-undefined' } } + } + ])( + 'sends no workspace header to $target for the personal workspace', + async ({ target, expected }) => { + await expect( + authorize(SESSION, { target, method: 'POST' }) + ).resolves.toEqual(expected) + } + ) + + it('names the SDK package and its version as the client', () => { + expect(COMFY_CLIENT).toMatch(/^@comfyorg\/account-core\/\d+\.\d+\.\d+/) + }) +}) diff --git a/packages/account-core/src/core/requestAuth.ts b/packages/account-core/src/core/requestAuth.ts new file mode 100644 index 00000000000..890f282e453 --- /dev/null +++ b/packages/account-core/src/core/requestAuth.ts @@ -0,0 +1,87 @@ +/** + * Decides the credential headers for one request, and nothing else: callers + * send, retry, and track scope. A cookie session authorizes ingest itself; + * every other service takes a Bearer workspace token. Firebase and API-key + * principals keep the single header they send today, whatever the target. + */ +import packageManifest from '../../package.json' with { type: 'json' } + +import type { WebSession } from './sessionContracts.js' + +export type RequestTarget = 'ingest' | 'resource' + +export type RequestPrincipal = + | { readonly kind: 'session'; readonly session: WebSession } + | { readonly kind: 'firebase'; readonly getIdToken: () => Promise } + | { readonly kind: 'apiKey'; readonly apiKey: string } + +export interface RequestAuthInput { + readonly target: RequestTarget + readonly method: string + /** Absent means the personal workspace. */ + readonly workspaceId?: string +} + +export interface RequestAuthorization { + readonly headers: Readonly> + /** Set only for a cookie request, which must carry the session cookie. */ + readonly credentials?: 'include' +} + +export type RequestAuthorizer = ( + principal: RequestPrincipal, + input: RequestAuthInput +) => Promise + +export interface RequestAuthOptions { + /** A workspace token for a session principal; minting is the caller's. */ + readonly getWorkspaceToken: ( + workspaceId: string | undefined + ) => Promise +} + +export const COMFY_CLIENT = `${packageManifest.name}/${packageManifest.version}` + +const SAFE_METHODS: ReadonlySet = new Set(['GET', 'HEAD', 'OPTIONS']) + +function sessionHeaders( + session: WebSession, + { method, workspaceId }: RequestAuthInput +): Record { + return { + 'X-Comfy-Client': COMFY_CLIENT, + ...(workspaceId === undefined + ? {} + : { 'X-Comfy-Workspace-ID': workspaceId }), + ...(SAFE_METHODS.has(method.toUpperCase()) + ? {} + : { 'X-CSRF-Token': session.csrfToken }) + } +} + +export function createRequestAuthorizer({ + getWorkspaceToken +}: RequestAuthOptions): RequestAuthorizer { + return async function authorize( + principal, + input + ): Promise { + switch (principal.kind) { + case 'apiKey': + return { headers: { 'X-API-KEY': principal.apiKey } } + case 'firebase': + return { + headers: { Authorization: `Bearer ${await principal.getIdToken()}` } + } + case 'session': + if (input.target === 'resource') { + const token = await getWorkspaceToken(input.workspaceId) + return { headers: { Authorization: `Bearer ${token}` } } + } + return { + headers: sessionHeaders(principal.session, input), + credentials: 'include' + } + } + } +} diff --git a/packages/account-core/src/webSessionInertImport.test.ts b/packages/account-core/src/webSessionInertImport.test.ts index 540ea8f244c..967d92eacc2 100644 --- a/packages/account-core/src/webSessionInertImport.test.ts +++ b/packages/account-core/src/webSessionInertImport.test.ts @@ -4,7 +4,11 @@ beforeEach(() => { vi.resetModules() }) -it.for(['@comfyorg/account-core/webSession', '@comfyorg/account-core/testing'])( +it.for([ + '@comfyorg/account-core/webSession', + '@comfyorg/account-core/requestAuth', + '@comfyorg/account-core/testing' +])( 'importing %s starts no timer, listener, channel, or request', async (specifier) => { const fetchSpy = vi.fn() From 404220c0e4a1f5c9c8bc520ca95d1cd361946da4 Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Thu, 24 Sep 2026 13:23:19 -0400 Subject: [PATCH 08/30] fix(account-core): keep a network-lost restore unspent A restore that gets no answer, or whose proof throws, waits and retries from a fresh read instead of spending the restore, so a network blip never signs the user out. getProof returns null when the provider has no usable login, which settles signed out without a local sign-out. --- .../src/core/webSessionIdentity.test.ts | 92 ++++++++++++++----- .../src/core/webSessionIdentity.ts | 69 ++++++++------ 2 files changed, 114 insertions(+), 47 deletions(-) diff --git a/packages/account-core/src/core/webSessionIdentity.test.ts b/packages/account-core/src/core/webSessionIdentity.test.ts index 1f0f976b742..aef5c93d0ef 100644 --- a/packages/account-core/src/core/webSessionIdentity.test.ts +++ b/packages/account-core/src/core/webSessionIdentity.test.ts @@ -37,7 +37,7 @@ function createFakeScheduler() { function fakeRememberedLogin( userId: string | null, - getProof: () => Promise = async () => 'remembered-proof' + getProof: () => Promise = async () => 'remembered-proof' ) { return { currentUserId: vi.fn(async () => userId), @@ -236,35 +236,66 @@ describe('network errors', () => { }) }) +function failingPosts(times: number, log: string[]) { + let remaining = times + return (endpointFetch: typeof fetch): typeof fetch => + async (input, init) => { + log.push(init?.method ?? 'GET') + if (init?.method !== 'POST' || remaining === 0) { + return endpointFetch(input, init) + } + remaining -= 1 + throw new TypeError('Failed to fetch') + } +} + describe('silent restore', () => { - it('runs at most once: a restore lost to the network is not repeated', async () => { - const posts: string[] = [] - const { endpoint, scheduler, reports, identity } = bootIdentity({ + it('retries a restore lost to the network until it succeeds', async () => { + const log: string[] = [] + const login = fakeRememberedLogin('user-1') + const { scheduler, reports, identity } = bootIdentity({ + state: { kind: 'dead', code: 'no_session' }, + login, + fetchImpl: failingPosts(2, log) + }) + expect(summarize(await nextRest(identity))).toBe('retry_wait') + expect(scheduler.delays()).toEqual([1000]) + + scheduler.fireNext() + expect(summarize(await nextRest(identity))).toBe('retry_wait') + expect(scheduler.delays()).toEqual([2000]) + + scheduler.fireNext() + + expect(summarize(await nextRest(identity))).toBe('signed_in:user-1') + expect(log).toEqual(['GET', 'POST', 'GET', 'POST', 'GET', 'POST', 'GET']) + expect(reports).toEqual([{ outcome: 'restored', origin: ORIGIN }]) + expect(login.signOutLocally).not.toHaveBeenCalled() + }) + + it('re-reads before restoring again, so a lost POST that landed is not repeated', async () => { + const log: string[] = [] + const { scheduler, identity } = bootIdentity({ state: { kind: 'dead', code: 'no_session' }, login: fakeRememberedLogin('user-1'), fetchImpl: (endpointFetch) => async (input, init) => { - if (init?.method !== 'POST') return endpointFetch(input, init) - posts.push(String(input)) - throw new TypeError('Failed to fetch') + log.push(init?.method ?? 'GET') + const response = await endpointFetch(input, init) + if (init?.method === 'POST') throw new TypeError('Failed to fetch') + return response } }) expect(summarize(await nextRest(identity))).toBe('retry_wait') scheduler.fireNext() - expect(summarize(await nextRest(identity))).toBe( - 'signed_out:restore_failed' - ) - expect(posts).toHaveLength(1) - expect(requestLog(endpoint)).toEqual(['GET', 'GET']) - expect(reports).toEqual([{ outcome: 'restore_failed', origin: ORIGIN }]) + expect(summarize(await nextRest(identity))).toBe('signed_in:user-1') + expect(log).toEqual(['GET', 'POST', 'GET']) }) - it('settles signed out when the remembered login cannot produce proof', async () => { - const login = fakeRememberedLogin('user-1', async () => { - throw new Error('login expired') - }) - const { endpoint, identity } = bootIdentity({ + it('settles signed out when the remembered login has no usable proof', async () => { + const login = fakeRememberedLogin('user-1', async () => null) + const { endpoint, reports, identity } = bootIdentity({ state: { kind: 'dead', code: 'no_session' }, login }) @@ -273,6 +304,25 @@ describe('silent restore', () => { 'signed_out:restore_failed' ) expect(requestLog(endpoint)).toEqual(['GET']) + expect(reports).toEqual([{ outcome: 'restore_failed', origin: ORIGIN }]) + expect(login.signOutLocally).not.toHaveBeenCalled() + }) + + it('treats a proof that throws as transient and restores on retry', async () => { + const login = fakeRememberedLogin('user-1') + login.getProof.mockRejectedValueOnce(new Error('provider offline')) + const { endpoint, scheduler, identity } = bootIdentity({ + state: { kind: 'dead', code: 'no_session' }, + login + }) + expect(summarize(await nextRest(identity))).toBe('retry_wait') + expect(requestLog(endpoint)).toEqual(['GET']) + + scheduler.fireNext() + + expect(summarize(await nextRest(identity))).toBe('signed_in:user-1') + expect(requestLog(endpoint)).toEqual(['GET', 'GET', 'POST', 'GET']) + expect(login.signOutLocally).not.toHaveBeenCalled() }) it.for([ @@ -300,16 +350,16 @@ describe('silent restore', () => { { code: 'SESSION_UNAVAILABLE', retryable: true, - state: { phase: 'retry_wait', failures: 1, restoreSpent: true }, + state: { phase: 'retry_wait', failures: 1 }, effects: [{ type: 'schedule_retry', failures: 1 }] } ] satisfies (Pick & ReturnType)[])( - 'a restore answered $code never restores again', + 'a restore answered $code settles or waits, never restoring in place', ({ code, retryable, state, effects }) => { expect( transitionWebSessionIdentity( - { phase: 'restoring' }, + { phase: 'restoring', failures: 0 }, { type: 'restore_answered', result: { status: 'error', code, retryable }, diff --git a/packages/account-core/src/core/webSessionIdentity.ts b/packages/account-core/src/core/webSessionIdentity.ts index 01868fffaa8..2efa1eb8816 100644 --- a/packages/account-core/src/core/webSessionIdentity.ts +++ b/packages/account-core/src/core/webSessionIdentity.ts @@ -14,7 +14,8 @@ import { createWebSession, readWebSession } from './webSession.js' export interface RememberedLogin { /** The Comfy user id of the login this browser remembers, or null. */ currentUserId: () => Promise - getProof: () => Promise + /** Null when the provider has no usable login; a throw is transient. */ + getProof: () => Promise signOutLocally: () => Promise } @@ -40,11 +41,9 @@ export type WebSessionIdentityState = | { readonly phase: 'idle' } | { readonly phase: 'api_key' } | { - readonly phase: 'reading' | 'retry_wait' + readonly phase: 'reading' | 'retry_wait' | 'restoring' readonly failures: number - readonly restoreSpent: boolean } - | { readonly phase: 'restoring' } | { readonly phase: 'signed_in'; readonly session: WebSession } | { readonly phase: 'signed_out'; readonly outcome: SignedOutOutcome } @@ -55,7 +54,7 @@ export type WebSessionIdentityEvent = readonly result: WebSessionResult readonly rememberedUserId: string | null } - | { readonly type: 'proof_unavailable' } + | { readonly type: 'proof_missing' | 'proof_errored' } | { readonly type: 'retry_due' } export type WebSessionIdentityEffect = @@ -101,12 +100,9 @@ function settleSignedOut( } } -function waitToRetry( - failures: number, - restoreSpent: boolean -): WebSessionIdentityTransition { +function waitToRetry(failures: number): WebSessionIdentityTransition { return { - state: { phase: 'retry_wait', failures, restoreSpent }, + state: { phase: 'retry_wait', failures }, effects: [{ type: 'schedule_retry', failures }] } } @@ -116,29 +112,32 @@ function isNoLiveSession(failure: WebSessionFailure): boolean { } function applyReadAnswered( - { failures, restoreSpent }: { failures: number; restoreSpent: boolean }, + failures: number, result: WebSessionResult, rememberedUserId: string | null ): WebSessionIdentityTransition { if (result.status === 'ok') { return settleSignedIn(result.session, rememberedUserId, 'signed_in') } - if (result.retryable) return waitToRetry(failures + 1, restoreSpent) + if (result.retryable) return waitToRetry(failures + 1) if (result.code === 'SESSION_REVOKED') return settleSignedOut('revoked') if (!isNoLiveSession(result)) return settleSignedOut('signed_out') - if (restoreSpent) return settleSignedOut('restore_failed') if (rememberedUserId === null) return settleSignedOut('signed_out') - return { state: { phase: 'restoring' }, effects: [{ type: 'restore' }] } + return { + state: { phase: 'restoring', failures }, + effects: [{ type: 'restore' }] + } } function applyRestoreAnswered( + failures: number, result: WebSessionResult, rememberedUserId: string | null ): WebSessionIdentityTransition { if (result.status === 'ok') { return settleSignedIn(result.session, rememberedUserId, 'restored') } - if (result.retryable) return waitToRetry(1, true) + if (result.retryable) return waitToRetry(failures + 1) if (result.code === 'SESSION_REVOKED') return settleSignedOut('revoked') return settleSignedOut('restore_failed') } @@ -153,22 +152,34 @@ export function transitionWebSessionIdentity( case 'boot': return state.phase === 'idle' ? { - state: { phase: 'reading', failures: 0, restoreSpent: false }, + state: { phase: 'reading', failures: 0 }, effects: [read] } : unchanged case 'read_answered': return state.phase === 'reading' - ? applyReadAnswered(state, event.result, event.rememberedUserId) + ? applyReadAnswered( + state.failures, + event.result, + event.rememberedUserId + ) : unchanged case 'restore_answered': return state.phase === 'restoring' - ? applyRestoreAnswered(event.result, event.rememberedUserId) + ? applyRestoreAnswered( + state.failures, + event.result, + event.rememberedUserId + ) : unchanged - case 'proof_unavailable': + case 'proof_missing': return state.phase === 'restoring' ? settleSignedOut('restore_failed') : unchanged + case 'proof_errored': + return state.phase === 'restoring' + ? waitToRetry(state.failures + 1) + : unchanged case 'retry_due': return state.phase === 'retry_wait' ? { state: { ...state, phase: 'reading' }, effects: [read] } @@ -251,12 +262,18 @@ function createAccountIdentity( if (started === generation) dispatch({ type, result, rememberedUserId }) } - function restore(started: number): void { - answer(started, 'restore_answered', () => - createWebSession(options.session, login.getProof) - ).catch(() => { - if (started === generation) dispatch({ type: 'proof_unavailable' }) - }) + async function restore(started: number): Promise { + const proof = await login.getProof().then( + (value) => ({ value }), + () => undefined + ) + if (started !== generation) 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', () => + createWebSession(options.session, async () => value) + ) } function run(effect: WebSessionIdentityEffect): void { @@ -267,7 +284,7 @@ function createAccountIdentity( ) return case 'restore': - restore(generation) + void restore(generation) return case 'schedule_retry': cancelRetry = schedule( From f1d353d55dfbe3a760e39325b064f68da7f5fcb7 Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Thu, 24 Sep 2026 13:34:37 -0400 Subject: [PATCH 09/30] feat(account-core): web session lifecycle and heartbeat Create the session only on an interactive sign-in, delete it on sign-out, and read it every 10 minutes from the one visible leader tab per site so a sign-out or account change elsewhere reaches every open tab. Account changes bump an epoch the host tags requests with, so answers started under the old account are discarded. --- .../account-core/src/core/sessionContracts.ts | 4 +- .../core/webSessionIdentity.lifecycle.test.ts | 503 ++++++++++++++++++ .../src/core/webSessionIdentity.ts | 442 +++++++++++++-- .../src/web/crossTabRefresh.test.ts | 27 +- .../account-core/src/web/crossTabRefresh.ts | 20 +- .../src/webSessionInertImport.test.ts | 1 + 6 files changed, 942 insertions(+), 55 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..8cf337bfac9 --- /dev/null +++ b/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts @@ -0,0 +1,503 @@ +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 +} 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', { + 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') + }) +}) + +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' }] } + }, + { + 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', + 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 2efa1eb8816..cbbe7d5a7f1 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' } @@ -56,6 +69,14 @@ export type WebSessionIdentityEvent = } | { readonly type: 'proof_missing' | 'proof_errored' } | { readonly type: 'retry_due' } + /** A heartbeat answer, this tab's or one a sibling tab published. */ + | { + readonly type: 'session_observed' + 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 +84,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 +98,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,59 +175,213 @@ function applyRestoreAnswered( return settleSignedOut('restore_failed') } -/** Pure: an event that means nothing in the current phase changes nothing. */ -export function transitionWebSessionIdentity( - state: WebSessionIdentityState, +function leaveAccount( + outcome: SignedOutOutcome, + effects: readonly WebSessionIdentityEffect[] = [] +): WebSessionIdentityTransition { + return { + state: { phase: 'signed_out', outcome }, + effects: [ + ...effects, + { type: 'account_changed', change: { reason: 'signed_out', outcome } } + ] + } +} + +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 +): 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', [ + signOutLocally, + { type: 'report_signed_out_remotely' } + ]) + } + if (restored) return leaveAccount('restore_failed') + if (!isNoLiveSession(result)) return { state, effects: [] } + if (rememberedUserId === null) return leaveAccount('signed_out') + return { state, effects: [{ type: 'restore' }] } +} + +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': case 'restore_answered': - return state.phase === 'restoring' - ? applyRestoreAnswered( + return observeWhileSignedIn( + state, + event.result, + event.rememberedUserId, + event.type === 'restore_answered' + ) + 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': + return waitToRetry(state.failures + 1) + default: + return { state, effects: [] } + } +} + +function transitionBoot( + state: SettlingState, + event: WebSessionIdentityEvent +): WebSessionIdentityTransition { + switch (state.phase) { + case 'reading': + 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': - return state.phase === 'restoring' - ? waitToRetry(state.failures + 1) - : unchanged - 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 === 'signed_out' || state.phase === 'retry_wait' + 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 @@ -204,12 +391,49 @@ 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 revoked: WebSessionResult = { + status: 'error', + code: 'SESSION_REVOKED', + retryable: false +} + const scheduleWithTimer: ScheduleRetry = (run, delayMs) => { const timer = setTimeout(run, delayMs) return () => clearTimeout(timer) @@ -228,6 +452,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 } } @@ -239,27 +470,101 @@ 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(result: WebSessionResult): void { + heartbeat?.crossTab?.publishCredential(HEARTBEAT_KEY, result) } async function answer( started: number, - type: 'read_answered' | 'restore_answered', + type: 'read_answered' | 'restore_answered' | 'session_observed', request: () => Promise ): Promise { const result = await request() const rememberedUserId = await login.currentUserId().catch(() => null) - if (started === generation) dispatch({ type, result, rememberedUserId }) + if (started === epoch) dispatch({ type, result, rememberedUserId }) + } + + function beat(): void { + const started = epoch + void answer(started, 'session_observed', async () => { + const result = await readWebSession(options.session) + const shared = result.status === 'ok' || result.code === 'SESSION_REVOKED' + if (shared && started === epoch) publish(result) + return result + }) + } + + function adopt(message: unknown): void { + const parsed = zSharedResult.safeParse(message) + if (!parsed.success) return + void answer(epoch, 'session_observed', async () => parsed.data) + } + + 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(started: number): Promise { @@ -267,7 +572,7 @@ 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' }) @@ -279,12 +584,12 @@ function createAccountIdentity( function run(effect: WebSessionIdentityEffect): void { switch (effect.type) { case 'read': - void answer(generation, 'read_answered', () => + void answer(epoch, 'read_answered', () => readWebSession(options.session) ) return case 'restore': - void restore(generation) + void restore(epoch) return case 'schedule_retry': cancelRetry = schedule( @@ -298,14 +603,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) => { @@ -315,11 +640,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(result) + return result + }, + signOut: async () => { + dispatch({ type: 'sign_out_requested' }) + const result = await deleteWebSession(options.session) + if (result.status === 'ok') publish(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 76f481379a2..9800d92b6d9 100644 --- a/packages/account-core/src/webSessionInertImport.test.ts +++ b/packages/account-core/src/webSessionInertImport.test.ts @@ -7,6 +7,7 @@ beforeEach(() => { it.for([ '@comfyorg/account-core/webSession', '@comfyorg/account-core/webSessionIdentity', + '@comfyorg/account-core/web', '@comfyorg/account-core/testing' ])( 'importing %s starts no timer, listener, channel, or request', From 5dfb638cd8e7bb81292a2271eaf7694a16a16a9f Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Thu, 24 Sep 2026 17:01:24 -0400 Subject: [PATCH 10/30] test: assert sign-out closes the previous WebSocket --- src/platform/auth/webSessionFlagOff.test.ts | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/platform/auth/webSessionFlagOff.test.ts b/src/platform/auth/webSessionFlagOff.test.ts index 4488542c89e..2e225321e61 100644 --- a/src/platform/auth/webSessionFlagOff.test.ts +++ b/src/platform/auth/webSessionFlagOff.test.ts @@ -140,6 +140,7 @@ function jsonResponse(body: unknown, status = 200): Response { function installFetchRecorder(features: Record) { const all: RecordedRequest[] = [] let pending: RecordedRequest[] = [] + let socketCloses = 0 let mintCount = 0 const mintResponse = (): ExchangeTokenResponse => { @@ -194,6 +195,7 @@ function installFetchRecorder(features: Record) { } send() {} close() { + socketCloses += 1 this.readyState = RecordingWebSocket.CLOSED } } @@ -214,6 +216,9 @@ function installFetchRecorder(features: Record) { get pending() { return pending }, + get socketCloses() { + return socketCloses + }, take() { const taken = pending pending = [] @@ -448,9 +453,11 @@ describe('cloud auth requests with unified_web_session off', () => { resultItemPreviewUrl(MEDIA_ITEM) ]).toEqual(MEDIA_URLS) + expect(recorder.socketCloses).toBe(0) identity.signOut() await vi.advanceTimersByTimeAsync(1_000) expect(recorder.take()).toEqual(golden.signOut) + expect(recorder.socketCloses).toBe(1) expect(recorder.all).toEqual([ ...FEATURES_BOOTSTRAP, From 59e9361dd7f7554e4d2144729bca8de61a032285 Mon Sep 17 00:00:00 2001 From: mattmillerai <7741082+mattmillerai@users.noreply.github.com> Date: Fri, 25 Sep 2026 01:15:11 +0000 Subject: [PATCH 11/30] [chore] Update Ingest API types from cloud@70c573d --- packages/ingest-types/src/index.ts | 7 ++ packages/ingest-types/src/types.gen.ts | 89 ++++++++++++++++++++++++-- packages/ingest-types/src/zod.gen.ts | 26 ++++++++ 3 files changed, 117 insertions(+), 5 deletions(-) diff --git a/packages/ingest-types/src/index.ts b/packages/ingest-types/src/index.ts index 377e03d1b22..fbe8d919ffe 100644 --- a/packages/ingest-types/src/index.ts +++ b/packages/ingest-types/src/index.ts @@ -632,6 +632,11 @@ export type { GetSecretErrors, GetSecretResponse, GetSecretResponses, + GetSessionData, + GetSessionError, + GetSessionErrors, + GetSessionResponse, + GetSessionResponses, GetSettingByIdData, GetSettingByIdError, GetSettingByIdErrors, @@ -1118,6 +1123,8 @@ export type { ViewFileErrors, ViewFileResponse, ViewFileResponses, + WebSessionResponse, + WebSessionUser, WorkflowApiAssetsRequest, WorkflowApiAssetsResponse, WorkflowForkedFrom, diff --git a/packages/ingest-types/src/types.gen.ts b/packages/ingest-types/src/types.gen.ts index 9864f0b2825..e42ede5a6bd 100644 --- a/packages/ingest-types/src/types.gen.ts +++ b/packages/ingest-types/src/types.gen.ts @@ -279,6 +279,45 @@ export type WorkflowApiAssetsRequest = { } } +/** + * The user a web session belongs to + */ +export type WebSessionUser = { + email: string + /** + * The identity provider's verified-email claim when the session was created + */ + email_verified: boolean + /** + * Comfy user id + */ + id: string + name?: string + /** + * Sign-in method, for example `google.com` or `password` + */ + sign_in_provider?: string +} + +/** + * The live web session and the user it belongs to + */ +export type WebSessionResponse = { + /** + * The session ends at this time regardless of use + */ + absolute_expires_at: string + /** + * Send as `X-CSRF-Token` on requests that change data with this session + */ + csrf_token: string + /** + * Idle expiry. Real use slides it; reading the session does not. + */ + expires_at: string + user: WebSessionUser +} + /** * Result of validating a set of asset operations. */ @@ -1466,11 +1505,11 @@ export type PreviewSubscribeResponse = { new_plan: PreviewPlanInfo /** * The Stripe payment method configuration governing which payment - * methods the embedded checkout offers for this environment. Mount - * Stripe Elements with `paymentMethodConfiguration` set to this id - * instead of hardcoding payment method types. Present on every - * successful preview while embedded checkout is enabled and absent - * from legacy previews. + * methods a checkout offers for this environment. Mount Stripe + * Elements with `paymentMethodConfiguration` set to this id instead + * of hardcoding payment method types. Present on every successful + * preview whenever the environment has one configured, independent + * of embedded_checked_enabled; absent when it is not configured. * */ payment_method_configuration_id?: string @@ -6970,6 +7009,46 @@ export type DeleteSessionResponses = { export type DeleteSessionResponse2 = DeleteSessionResponses[keyof DeleteSessionResponses] +export type GetSessionData = { + body?: never + path?: never + query?: never + url: '/api/auth/session' +} + +export type GetSessionErrors = { + /** + * No live session. `code` is `session_expired`, `session_revoked`, + * or `no_session`: no cookie, a cookie the server never issued, a + * session whose user no longer exists, or `web_session_enabled` off + * for the session's user. + * + */ + 401: ErrorResponse + /** + * Refused. `code` is `origin_not_allowed` (untrusted or missing + * Origin), `cross_site_request`, or `FORBIDDEN` when the account is + * scheduled for deletion. + * + */ + 403: ErrorResponse + /** + * The session store is unreachable; retry with backoff + */ + 500: ErrorResponse +} + +export type GetSessionError = GetSessionErrors[keyof GetSessionErrors] + +export type GetSessionResponses = { + /** + * The live session + */ + 200: WebSessionResponse +} + +export type GetSessionResponse = GetSessionResponses[keyof GetSessionResponses] + export type CreateSessionData = { body?: never path?: never diff --git a/packages/ingest-types/src/zod.gen.ts b/packages/ingest-types/src/zod.gen.ts index 149aac982ac..06964401730 100644 --- a/packages/ingest-types/src/zod.gen.ts +++ b/packages/ingest-types/src/zod.gen.ts @@ -185,6 +185,27 @@ export const zWorkflowApiAssetsRequest = z.object({ workflow_api_json: z.record(z.unknown()) }) +/** + * The user a web session belongs to + */ +export const zWebSessionUser = z.object({ + email: z.string(), + email_verified: z.boolean(), + id: z.string(), + name: z.string().optional(), + sign_in_provider: z.string().optional() +}) + +/** + * The live web session and the user it belongs to + */ +export const zWebSessionResponse = z.object({ + absolute_expires_at: z.string().datetime(), + csrf_token: z.string(), + expires_at: z.string().datetime(), + user: zWebSessionUser +}) + /** * Details of a single validation error encountered during asset operations. */ @@ -3300,6 +3321,11 @@ export const zRedeemDesktopLoginCodeResponse = zDesktopLoginCodeRedeemResponse */ export const zDeleteSessionResponse2 = zDeleteSessionResponse +/** + * The live session + */ +export const zGetSessionResponse = zWebSessionResponse + /** * Session created successfully */ From 5a09df14dee983652f094e26e76d02b9a171317e Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Thu, 24 Sep 2026 21:53:41 -0400 Subject: [PATCH 12/30] refactor(account-core): parse GET /session with the generated schema --- .../account-core/src/core/importGuard.test.ts | 4 ++-- packages/account-core/src/core/webSession.ts | 6 +++--- .../src/core/webSessionDraftContract.ts | 17 ----------------- 3 files changed, 5 insertions(+), 22 deletions(-) delete mode 100644 packages/account-core/src/core/webSessionDraftContract.ts diff --git a/packages/account-core/src/core/importGuard.test.ts b/packages/account-core/src/core/importGuard.test.ts index d45a06576cf..724ad4831c3 100644 --- a/packages/account-core/src/core/importGuard.test.ts +++ b/packages/account-core/src/core/importGuard.test.ts @@ -66,7 +66,7 @@ describe('core import guard', () => { it('scans the web session sources', () => { expect(sources.map(({ name }) => name)).toEqual( - expect.arrayContaining(['webSession.ts', 'webSessionDraftContract.ts']) + expect.arrayContaining(['webSession.ts']) ) }) @@ -79,7 +79,7 @@ describe('core import guard', () => { ) expect([...closure.keys()].map((file) => relative(CORE_DIR, file))).toEqual( - expect.arrayContaining(['webSession.ts', 'webSessionDraftContract.ts']) + expect.arrayContaining(['webSession.ts']) ) expect(firebaseImports).toEqual([]) }) diff --git a/packages/account-core/src/core/webSession.ts b/packages/account-core/src/core/webSession.ts index c2873495f5e..ccc4673aa02 100644 --- a/packages/account-core/src/core/webSession.ts +++ b/packages/account-core/src/core/webSession.ts @@ -6,7 +6,8 @@ import { zCreateSessionResponse, zDeleteSessionResponse, - zErrorResponse + zErrorResponse, + zGetSessionResponse } from '@comfyorg/ingest-types/zod' import type { @@ -15,7 +16,6 @@ import type { WebSessionFailure, WebSessionResult } from './sessionContracts.js' -import { zWebSessionResponse } from './webSessionDraftContract.js' export type { WebSession, @@ -111,7 +111,7 @@ export async function readWebSession( if (!('response' in sent)) return sent const { status } = sent.response - const parsed = zWebSessionResponse.safeParse(await readJson(sent.response)) + const parsed = zGetSessionResponse.safeParse(await readJson(sent.response)) if (!parsed.success) return failure('SESSION_UNAVAILABLE', status) const { user, csrf_token, expires_at, absolute_expires_at } = parsed.data if (expectedUserId !== undefined && user.id !== expectedUserId) { diff --git a/packages/account-core/src/core/webSessionDraftContract.ts b/packages/account-core/src/core/webSessionDraftContract.ts deleted file mode 100644 index a5781e9258e..00000000000 --- a/packages/account-core/src/core/webSessionDraftContract.ts +++ /dev/null @@ -1,17 +0,0 @@ -/** Mirrors GET /api/auth/session from cloud#10549; replace with `@comfyorg/ingest-types/zod` once BE-17063 is generated. */ -import { z } from 'zod' - -const zWebSessionUser = z.object({ - id: z.string(), - email: z.string(), - name: z.string().optional(), - email_verified: z.boolean(), - sign_in_provider: z.string().optional() -}) - -export const zWebSessionResponse = z.object({ - user: zWebSessionUser, - csrf_token: z.string(), - expires_at: z.string().datetime(), - absolute_expires_at: z.string().datetime() -}) From 31eca584704839fb5188cd62bc05d5c0e0b642c6 Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Thu, 24 Sep 2026 23:51:33 -0400 Subject: [PATCH 13/30] fix(account-core): refuse unrecognised 4xx bodies and hold revoke-all until its contract exists An error body that does not parse now lets the status decide: 4xx is SESSION_REQUEST_REFUSED (not retryable), 429/5xx stay SESSION_UNAVAILABLE. revokeAllWebSessions is removed until cloud#10589 adds the route and its generated schema. createWebSession can check the read-back user. --- .../account-core/src/core/webSession.test.ts | 88 ++++++++++--------- packages/account-core/src/core/webSession.ts | 20 ++--- packages/account-core/src/testing.ts | 17 +--- 3 files changed, 54 insertions(+), 71 deletions(-) diff --git a/packages/account-core/src/core/webSession.test.ts b/packages/account-core/src/core/webSession.test.ts index ce43ddeb7ba..f1084a81ec1 100644 --- a/packages/account-core/src/core/webSession.test.ts +++ b/packages/account-core/src/core/webSession.test.ts @@ -6,8 +6,7 @@ import type { WebSessionOptions } from './webSession.js' import { createWebSession, deleteWebSession, - readWebSession, - revokeAllWebSessions + readWebSession } from './webSession.js' const API = 'https://cloud.example/api' @@ -33,11 +32,7 @@ const ENDPOINTS = [ name: 'create', call: (o: WebSessionOptions) => createWebSession(o, async () => 'proof') }, - { name: 'delete', call: (o: WebSessionOptions) => deleteWebSession(o) }, - { - name: 'revoke-all', - call: (o: WebSessionOptions) => revokeAllWebSessions(o, 'csrf') - } + { name: 'delete', call: (o: WebSessionOptions) => deleteWebSession(o) } ] describe('web session status mapping', () => { @@ -131,22 +126,42 @@ describe('web session status mapping', () => { body: errorBody('session_revoked') }, { name: '503 html page', status: 503, body: 'down' }, + { name: '200 failing the session schema', status: 200, body: '{"user":{}}' } + ])( + '$name is transient, never a session verdict', + async ({ status, body }) => { + const result = await readWebSession(optionsFor(respondWith(status, body))) + + expect(result).toEqual({ + status: 'error', + code: 'SESSION_UNAVAILABLE', + retryable: true, + httpStatus: status + }) + } + ) + + it.for([ { name: '401 without an error body', status: 401, body: '401' }, { name: '403 without an error body', status: 403, body: '' }, - { name: '200 failing the session schema', status: 200, body: '{"user":{}}' } + { + name: '404 router default body', + status: 404, + body: '{"message":"Not Found"}' + } ])( - '$name is transient, never a session verdict', + '$name is refused, not retryable and not a sign-out', async ({ status, body }) => { const result = await readWebSession(optionsFor(respondWith(status, body))) expect(result).toEqual({ status: 'error', - code: 'SESSION_UNAVAILABLE', - retryable: true, + code: 'SESSION_REQUEST_REFUSED', + retryable: false, httpStatus: status }) } @@ -195,13 +210,7 @@ describe('web session requests', () => { call: (o: WebSessionOptions) => createWebSession(o, async () => 'proof'), expected: ['include', 'include'] }, - { name: 'delete', call: deleteWebSession, expected: ['include'] }, - { - name: 'revoke-all', - call: (o: WebSessionOptions) => - revokeAllWebSessions(o, 'fake-csrf-token'), - expected: ['include'] - } + { name: 'delete', call: deleteWebSession, expected: ['include'] } ])('$name always sends credentials', async ({ call, expected }) => { const endpoint = fakeEndpoint({ kind: 'live', user: fakeWebSessionUser() }) @@ -279,6 +288,26 @@ describe('web session requests', () => { }) }) + it('reports IDENTITY_CHANGED when the created session is not the expected user', async () => { + const endpoint = createFakeWebSessionEndpoint({ + state: { kind: 'dead', code: 'no_session' }, + signInUser: fakeWebSessionUser({ id: 'someone-else' }), + now: () => NOW + }) + + const result = await createWebSession( + optionsFor(endpoint.fetch), + async () => 'id-token', + { expectedUserId: 'new-user' } + ) + + expect(result).toMatchObject({ + status: 'error', + code: 'IDENTITY_CHANGED', + retryable: false + }) + }) + it('leaves an identity-proof failure to the caller and sends nothing', async () => { const endpoint = fakeEndpoint({ kind: 'dead', code: 'no_session' }) @@ -299,29 +328,6 @@ describe('web session requests', () => { expect(endpoint.requests[0]).toMatchObject({ method: 'DELETE' }) expect(endpoint.requests[0].headers).not.toHaveProperty('x-csrf-token') }) - - it('revokes every session with the CSRF token', async () => { - const endpoint = fakeEndpoint({ kind: 'live', user: fakeWebSessionUser() }) - const options = optionsFor(endpoint.fetch) - - const revoked = await revokeAllWebSessions(options, 'fake-csrf-token') - - expect(revoked).toEqual({ status: 'ok' }) - expect(await readWebSession(options)).toMatchObject({ - code: 'SESSION_REVOKED' - }) - }) - - it('reports a stale CSRF token on revoke-all', async () => { - const endpoint = fakeEndpoint({ kind: 'live', user: fakeWebSessionUser() }) - - const result = await revokeAllWebSessions( - optionsFor(endpoint.fetch), - 'old-token' - ) - - expect(result).toMatchObject({ code: 'CSRF_STALE', retryable: false }) - }) }) describe('boot cases against the testing fake', () => { diff --git a/packages/account-core/src/core/webSession.ts b/packages/account-core/src/core/webSession.ts index ccc4673aa02..a8d44d654ac 100644 --- a/packages/account-core/src/core/webSession.ts +++ b/packages/account-core/src/core/webSession.ts @@ -72,7 +72,7 @@ async function classifyFailure(response: Response): Promise { return failure('SESSION_UNAVAILABLE', status) } const parsed = zErrorResponse.safeParse(await readJson(response)) - if (!parsed.success) return failure('SESSION_UNAVAILABLE', status) + if (!parsed.success) return failure('SESSION_REQUEST_REFUSED', status) const serverCode = parsed.data.code const byServerCode = status === 401 @@ -112,7 +112,7 @@ export async function readWebSession( const { status } = sent.response const parsed = zGetSessionResponse.safeParse(await readJson(sent.response)) - if (!parsed.success) return failure('SESSION_UNAVAILABLE', status) + if (!parsed.success) return failure('SESSION_REQUEST_REFUSED', status) const { user, csrf_token, expires_at, absolute_expires_at } = parsed.data if (expectedUserId !== undefined && user.id !== expectedUserId) { return failure('IDENTITY_CHANGED', status) @@ -140,7 +140,8 @@ export async function readWebSession( */ export async function createWebSession( options: WebSessionOptions, - getIdentityProof: () => Promise + getIdentityProof: () => Promise, + { expectedUserId }: { readonly expectedUserId?: string } = {} ): Promise { const proof = await getIdentityProof() const sent = await send(options, '/auth/session', { @@ -153,7 +154,7 @@ export async function createWebSession( if (!parsed.success || !parsed.data.success) { return failure('SESSION_UNAVAILABLE', sent.response.status) } - return readWebSession(options) + return readWebSession(options, { expectedUserId }) } /** Sends no CSRF token: sign-out must work against a dead session. */ @@ -169,14 +170,3 @@ export async function deleteWebSession( } return { status: 'ok' } } - -export async function revokeAllWebSessions( - options: WebSessionOptions, - csrfToken: string -): Promise { - const sent = await send(options, '/auth/sessions/revoke-all', { - method: 'POST', - headers: { 'X-CSRF-Token': csrfToken } - }) - return 'response' in sent ? { status: 'ok' } : sent -} diff --git a/packages/account-core/src/testing.ts b/packages/account-core/src/testing.ts index c3c321e0383..6f417285df6 100644 --- a/packages/account-core/src/testing.ts +++ b/packages/account-core/src/testing.ts @@ -118,27 +118,14 @@ function routesFor( 401, state.kind === 'dead' ? state.code : 'no_session' ) - ], - [ - 'POST /api/auth/sessions/revoke-all', - (endpoint, headers) => { - if (endpoint.state.kind === 'dead') { - return errorResponse(401, endpoint.state.code) - } - if (headers.get('x-csrf-token') !== FAKE_CSRF_TOKEN) { - return errorResponse(403, 'csrf_invalid') - } - revoke(endpoint) - return new Response(null, { status: 204 }) - } ] ]) } /** * A `fetch` serving ingest's session routes under `/api/auth`. POST with a - * bearer proof signs `signInUser` in; DELETE and revoke-all leave the cookie - * revoked, as the real endpoint does. + * bearer proof signs `signInUser` in; DELETE leaves the cookie revoked, as + * the real endpoint does. */ export function createFakeWebSessionEndpoint({ state, From c22e39b7c83a70bd88939b9fdd3dc17bd5fcc04c Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Thu, 24 Sep 2026 23:53:15 -0400 Subject: [PATCH 14/30] fix(account-core): keep a 200 that fails the session schema transient --- packages/account-core/src/core/webSession.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/account-core/src/core/webSession.ts b/packages/account-core/src/core/webSession.ts index a8d44d654ac..51f9dd1104a 100644 --- a/packages/account-core/src/core/webSession.ts +++ b/packages/account-core/src/core/webSession.ts @@ -112,7 +112,7 @@ export async function readWebSession( const { status } = sent.response const parsed = zGetSessionResponse.safeParse(await readJson(sent.response)) - if (!parsed.success) return failure('SESSION_REQUEST_REFUSED', status) + if (!parsed.success) return failure('SESSION_UNAVAILABLE', status) const { user, csrf_token, expires_at, absolute_expires_at } = parsed.data if (expectedUserId !== undefined && user.id !== expectedUserId) { return failure('IDENTITY_CHANGED', status) From 2789fe7f17849d88d61da63306fe0decbafecd06 Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Fri, 25 Sep 2026 08:52:04 -0400 Subject: [PATCH 15/30] fix(account-core): check the restored user and retry a failed remembered-login lookup A silent restore now passes the remembered user id to createWebSession, so a read-back for another user ends in restore_failed instead of switching accounts. A throwing currentUserId() is transient (retry_wait), not "nothing remembered". Adds dispose-during-flight coverage. --- .../src/core/webSessionIdentity.test.ts | 75 +++++++++++++++++-- .../src/core/webSessionIdentity.ts | 28 +++++-- 2 files changed, 90 insertions(+), 13 deletions(-) diff --git a/packages/account-core/src/core/webSessionIdentity.test.ts b/packages/account-core/src/core/webSessionIdentity.test.ts index aef5c93d0ef..0c23aa9b612 100644 --- a/packages/account-core/src/core/webSessionIdentity.test.ts +++ b/packages/account-core/src/core/webSessionIdentity.test.ts @@ -49,16 +49,15 @@ function fakeRememberedLogin( function bootIdentity({ state, login, - fetchImpl + fetchImpl, + signInUser = SESSION_USER }: { state: FakeWebSessionState login: RememberedLogin fetchImpl?: (endpointFetch: typeof fetch) => typeof fetch + signInUser?: typeof SESSION_USER }) { - const endpoint = createFakeWebSessionEndpoint({ - state, - signInUser: SESSION_USER - }) + const endpoint = createFakeWebSessionEndpoint({ state, signInUser }) const scheduler = createFakeScheduler() const reports: WebSessionBootstrapEvent[] = [] const identity = createWebSessionIdentity({ @@ -222,6 +221,56 @@ describe('network errors', () => { expect(login.signOutLocally).not.toHaveBeenCalled() }) + it('treats a remembered-login lookup that throws as transient', async () => { + const login = fakeRememberedLogin('user-1') + login.currentUserId.mockRejectedValueOnce(new Error('provider offline')) + const { endpoint, scheduler, identity } = bootIdentity({ + state: { kind: 'dead', code: 'no_session' }, + login + }) + expect(summarize(await nextRest(identity))).toBe('retry_wait') + + scheduler.fireNext() + + expect(summarize(await nextRest(identity))).toBe('signed_in:user-1') + expect(requestLog(endpoint)).toEqual(['GET', 'GET', 'POST', 'GET']) + expect(login.signOutLocally).not.toHaveBeenCalled() + }) + + it.for([ + { name: 'a pending session read', pending: 'read' }, + { name: 'a pending identity proof', pending: 'proof' } + ] as const)('dispose ignores the answer to $name', async ({ pending }) => { + let release: () => void = () => {} + const gate = new Promise((resolve) => { + release = resolve + }) + const login = fakeRememberedLogin('user-1', async () => { + await gate + return 'remembered-proof' + }) + const { reports, identity } = bootIdentity({ + state: { kind: 'dead', code: 'no_session' }, + login, + fetchImpl: (endpointFetch) => async (input, init) => { + if (pending === 'read') await gate + return endpointFetch(input, init) + } + }) + if (pending === 'proof') { + await vi.waitFor(() => expect(login.getProof).toHaveBeenCalled()) + } + + identity.dispose() + release() + await gate + await new Promise((resolve) => setTimeout(resolve, 0)) + + expect(identity.getState()).toEqual({ phase: 'idle' }) + expect(reports).toEqual([]) + expect(login.signOutLocally).not.toHaveBeenCalled() + }) + it('dispose cancels the pending retry', async () => { const { scheduler, identity } = bootIdentity({ state: { kind: 'network_error' }, @@ -293,6 +342,22 @@ describe('silent restore', () => { expect(log).toEqual(['GET', 'POST', 'GET']) }) + it('fails the restore when the created session belongs to another user', async () => { + const login = fakeRememberedLogin('user-1') + const { endpoint, reports, identity } = bootIdentity({ + state: { kind: 'dead', code: 'no_session' }, + login, + signInUser: fakeWebSessionUser({ id: 'someone-else' }) + }) + + expect(summarize(await nextRest(identity))).toBe( + 'signed_out:restore_failed' + ) + expect(requestLog(endpoint)).toEqual(['GET', 'POST', 'GET']) + expect(reports).toEqual([{ outcome: 'restore_failed', origin: ORIGIN }]) + expect(login.signOutLocally).not.toHaveBeenCalled() + }) + it('settles signed out when the remembered login has no usable proof', async () => { const login = fakeRememberedLogin('user-1', async () => null) const { endpoint, reports, identity } = bootIdentity({ diff --git a/packages/account-core/src/core/webSessionIdentity.ts b/packages/account-core/src/core/webSessionIdentity.ts index 2efa1eb8816..964a1b3a8d3 100644 --- a/packages/account-core/src/core/webSessionIdentity.ts +++ b/packages/account-core/src/core/webSessionIdentity.ts @@ -54,12 +54,12 @@ export type WebSessionIdentityEvent = readonly result: WebSessionResult readonly rememberedUserId: string | null } - | { readonly type: 'proof_missing' | 'proof_errored' } + | { readonly type: 'proof_missing' | 'proof_errored' | 'login_errored' } | { readonly type: 'retry_due' } export type WebSessionIdentityEffect = | { readonly type: 'read' } - | { readonly type: 'restore' } + | { readonly type: 'restore'; readonly expectedUserId: string } | { readonly type: 'schedule_retry'; readonly failures: number } | { readonly type: 'sign_out_locally' } | { readonly type: 'report'; readonly outcome: WebSessionBootOutcome } @@ -125,7 +125,7 @@ function applyReadAnswered( if (rememberedUserId === null) return settleSignedOut('signed_out') return { state: { phase: 'restoring', failures }, - effects: [{ type: 'restore' }] + effects: [{ type: 'restore', expectedUserId: rememberedUserId }] } } @@ -180,6 +180,10 @@ export function transitionWebSessionIdentity( return state.phase === 'restoring' ? waitToRetry(state.failures + 1) : unchanged + case 'login_errored': + return state.phase === 'reading' || state.phase === 'restoring' + ? waitToRetry(state.failures + 1) + : unchanged case 'retry_due': return state.phase === 'retry_wait' ? { state: { ...state, phase: 'reading' }, effects: [read] } @@ -258,11 +262,19 @@ function createAccountIdentity( request: () => Promise ): Promise { const result = await request() - const rememberedUserId = await login.currentUserId().catch(() => null) - if (started === generation) dispatch({ type, result, rememberedUserId }) + const remembered = await login.currentUserId().then( + (value) => ({ value }), + () => undefined + ) + if (started !== generation) return + if (remembered === undefined) return dispatch({ type: 'login_errored' }) + dispatch({ type, result, rememberedUserId: remembered.value }) } - async function restore(started: number): Promise { + async function restore( + started: number, + expectedUserId: string + ): Promise { const proof = await login.getProof().then( (value) => ({ value }), () => undefined @@ -272,7 +284,7 @@ function createAccountIdentity( const { value } = proof if (value === null) return dispatch({ type: 'proof_missing' }) await answer(started, 'restore_answered', () => - createWebSession(options.session, async () => value) + createWebSession(options.session, async () => value, { expectedUserId }) ) } @@ -284,7 +296,7 @@ function createAccountIdentity( ) return case 'restore': - void restore(generation) + void restore(generation, effect.expectedUserId) return case 'schedule_retry': cancelRetry = schedule( From e59536023665155ae3ad753462b0ba0a76d80187 Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Fri, 25 Sep 2026 09:17:04 -0400 Subject: [PATCH 16/30] feat(cloud): join the shared web session lifecycle behind unified_web_session With the flag on, the cloud app creates the session only after an interactive sign-in, deletes it on sign-out, and boots, heartbeats and follows other tabs through createWebSessionIdentity. An account change clears the workspace selection, resets team workspaces and the socket, and shows a notice. Token refresh no longer re-creates the cookie. With the flag off, the session cookie path is unchanged. --- src/locales/en/main.json | 4 + .../auth/session/cloudWebSessionStore.ts | 156 +++++++++ src/platform/auth/session/useSessionCookie.ts | 7 + src/platform/auth/webSessionFlagOn.test.ts | 307 ++++++++++++++++++ src/stores/authStore.ts | 10 +- 5 files changed, 483 insertions(+), 1 deletion(-) create mode 100644 src/platform/auth/session/cloudWebSessionStore.ts create mode 100644 src/platform/auth/webSessionFlagOn.test.ts diff --git a/src/locales/en/main.json b/src/locales/en/main.json index 8a8835ead46..7bb6a0fe217 100644 --- a/src/locales/en/main.json +++ b/src/locales/en/main.json @@ -2657,6 +2657,10 @@ "signOutAnyway": "Sign out anyway", "saveFailed": "Sign-out cancelled because saving \"{workflow}\" failed." }, + "accountChanged": { + "title": "Account changed", + "detail": "Another tab or Comfy site signed in as {email}, so this page was reset." + }, "passwordUpdate": { "success": "Password Updated", "successDetail": "Your password has been updated successfully" diff --git a/src/platform/auth/session/cloudWebSessionStore.ts b/src/platform/auth/session/cloudWebSessionStore.ts new file mode 100644 index 00000000000..36e3dad8818 --- /dev/null +++ b/src/platform/auth/session/cloudWebSessionStore.ts @@ -0,0 +1,156 @@ +import type { User } from 'firebase/auth' +import { defineStore } from 'pinia' +import { onScopeDispose } from 'vue' + +import type { + WebSessionAccountChange, + WebSessionIdentity, + WebSessionIdentityState +} from '@comfyorg/account-core/webSessionIdentity' +import type { WebSessionResult } from '@comfyorg/account-core/webSession' +import { createWebSessionIdentity } from '@comfyorg/account-core/webSessionIdentity' +import { + createWebCrossTabRefreshPort, + createWebVisibilityPort +} from '@comfyorg/account-core/web' + +import { useFeatureFlags } from '@/composables/useFeatureFlags' +import { t } from '@/i18n' +import { firebaseIdentity } from '@/platform/auth/firebaseIdentity' +import { reportError } from '@/platform/telemetry/reportError' +import { useToastStore } from '@/platform/updates/common/toastStore' +import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore' +import { useWorkspaceAuthStore } from '@/platform/workspace/stores/workspaceAuthStore' +import { api } from '@/scripts/api' + +interface InteractiveSignIn { + readonly uid: string + readonly getProof: () => Promise +} + +const UNSETTLED_PHASES: ReadonlySet = new Set( + ['idle', 'reading', 'restoring'] +) + +async function whenSettled(identity: WebSessionIdentity): Promise { + let stop = () => {} + await new Promise((resolve) => { + stop = identity.subscribe((state) => { + if (!UNSETTLED_PHASES.has(state.phase)) resolve() + }) + }) + stop() +} + +function resetForAccountChange(change: WebSessionAccountChange): void { + useWorkspaceAuthStore().clearWorkspaceContext() + useTeamWorkspaceStore().resetForIdentityChange() + void api.resetSocket() + if (change.reason !== 'user_changed') return + useToastStore().add({ + severity: 'info', + summary: t('auth.accountChanged.title'), + detail: t('auth.accountChanged.detail', { + email: change.session.user.email + }), + life: 8000 + }) +} + +function createCloudIdentity(): WebSessionIdentity { + const visibility = createWebVisibilityPort() + const crossTab = createWebCrossTabRefreshPort() + return createWebSessionIdentity({ + session: { + apiBaseUrl: api.apiURL(''), + fetchImpl: (input, init) => fetch(input, init) + }, + principal: { + kind: 'account', + rememberedLogin: { + currentUserId: async () => firebaseIdentity.currentUser()?.uid ?? null, + getProof: async () => + (await firebaseIdentity.currentUser()?.getIdToken()) ?? null, + signOutLocally: () => firebaseIdentity.signOut() + } + }, + origin: window.location.origin, + onAccountChanged: resetForAccountChange, + ...(visibility && { + heartbeat: { visibility, ...(crossTab && { crossTab }) } + }) + }) +} + +/** + * The cloud app's side of the shared web session. `unified_web_session` is + * read once, on the first `start()`, and decides the whole page load. + */ +export const useCloudWebSessionStore = defineStore('cloudWebSession', () => { + let decided = false + let identity: WebSessionIdentity | null = null + let ready: Promise = Promise.resolve() + let pendingSignIn: InteractiveSignIn | null = null + + onScopeDispose(() => identity?.dispose()) + + async function createSession( + session: WebSessionIdentity, + getProof: () => Promise + ): Promise { + const result = await session.signedIn(getProof).catch(() => null) + if (result?.status === 'ok') return + reportError(new Error('Web session creation failed'), { + errorType: 'session_cookie_creation_failure', + level: 'warning' + }) + } + + async function bootAfter( + session: WebSessionIdentity, + signIn: InteractiveSignIn | null + ): Promise { + if (signIn && signIn.uid === firebaseIdentity.currentUser()?.uid) { + await createSession(session, signIn.getProof) + } + session.boot() + } + + /** Decides the flag for this page load; true when the session is on. */ + function start(): boolean { + if (decided) return identity !== null + decided = true + if (!useFeatureFlags().flags.unifiedWebSessionEnabled) return false + const session = createCloudIdentity() + identity = session + ready = whenSettled(session) + void bootAfter(session, pendingSignIn) + pendingSignIn = null + return true + } + + /** Only after an interactive sign-in; a token refresh never calls this. */ + function signedInInteractively(user: User): void { + const getProof = () => user.getIdToken() + if (identity) void createSession(identity, getProof) + else if (!decided) pendingSignIn = { uid: user.uid, getProof } + } + + async function signOut(): Promise { + pendingSignIn = null + const result = await identity?.signOut() + if (result === undefined || result.status === 'ok') return + reportError(new Error('Session cookie deletion failed'), { + errorType: 'auth_session_cookie_delete_failed', + level: 'error' + }) + } + + return { + start, + isActive: () => identity !== null, + whenReady: () => ready, + signedInInteractively, + signOut + } +}) diff --git a/src/platform/auth/session/useSessionCookie.ts b/src/platform/auth/session/useSessionCookie.ts index 2d687340d5d..7c3d1d57fdc 100644 --- a/src/platform/auth/session/useSessionCookie.ts +++ b/src/platform/auth/session/useSessionCookie.ts @@ -1,3 +1,4 @@ +import { useCloudWebSessionStore } from '@/platform/auth/session/cloudWebSessionStore' import { isCloud } from '@/platform/distribution/types' import { reportError } from '@/platform/telemetry/reportError' import { api } from '@/scripts/api' @@ -116,11 +117,14 @@ export const useSessionCookie = () => { const ensureSessionCookie = async (): Promise => { if (!isCloud) return + const webSession = useCloudWebSessionStore() + if (webSession.start()) return webSession.whenReady() await establishSession(currentOwnerUidOrThrow(), false) } const createSession = async (): Promise => { if (!isCloud) return + if (useCloudWebSessionStore().start()) return try { await establishSession(currentOwnerUidOrThrow(), true) } catch (error) { @@ -135,6 +139,8 @@ export const useSessionCookie = () => { const createSessionOrThrow = async (): Promise => { if (!isCloud) return + const webSession = useCloudWebSessionStore() + if (webSession.isActive()) return webSession.whenReady() await establishSession(currentOwnerUidOrThrow(), true) } @@ -144,6 +150,7 @@ export const useSessionCookie = () => { */ const deleteSession = async (): Promise => { if (!isCloud) return + if (useCloudWebSessionStore().isActive()) return confirmedSessionOwnerUid = null inFlightCreateSession = null diff --git a/src/platform/auth/webSessionFlagOn.test.ts b/src/platform/auth/webSessionFlagOn.test.ts new file mode 100644 index 00000000000..0bdc609b275 --- /dev/null +++ b/src/platform/auth/webSessionFlagOn.test.ts @@ -0,0 +1,307 @@ +import { fromPartial } from '@total-typescript/shoehorn' +import type { User, UserCredential } from 'firebase/auth' +import { afterEach, assert, beforeEach, describe, expect, it, vi } from 'vitest' +import { effectScope } from 'vue' + +import type { FirebaseIdentity } from '@comfyorg/account-core/firebase' + +import { useCurrentUser } from '@/composables/auth/useCurrentUser' +import { useSessionCookie } from '@/platform/auth/session/useSessionCookie' +import { refreshRemoteConfig } from '@/platform/remoteConfig/refreshRemoteConfig' +import { remoteConfig } from '@/platform/remoteConfig/remoteConfig' +import { useToastStore } from '@/platform/updates/common/toastStore' +import { WORKSPACE_STORAGE_KEYS } from '@/platform/workspace/workspaceConstants' +import { api } from '@/scripts/api' +import type { ComfyApp } from '@/scripts/app' +import type { useExtensionService } from '@/services/extensionService' +import { useAuthStore } from '@/stores/authStore' +import type { ComfyExtension } from '@/types/comfy' + +type IdentityObserver = (user: User | null) => void + +const identity = vi.hoisted(() => { + const userObservers = new Set() + const tokenObservers = new Set() + const state: { user: User | null } = { user: null } + return { + userObservers, + tokenObservers, + state, + reset() { + userObservers.clear() + tokenObservers.clear() + state.user = null + }, + signIn(user: User) { + state.user = user + userObservers.forEach((observer) => observer(user)) + tokenObservers.forEach((observer) => observer(user)) + }, + refreshIdToken() { + tokenObservers.forEach((observer) => observer(state.user)) + }, + signOut() { + state.user = null + userObservers.forEach((observer) => observer(null)) + tokenObservers.forEach((observer) => observer(null)) + } + } +}) + +const firebaseSignOut = vi.hoisted(() => vi.fn<() => Promise>()) +const registeredExtensions = vi.hoisted((): ComfyExtension[] => []) + +vi.mock(import('@/platform/distribution/types'), () => ({ + DISTRIBUTION: 'cloud' as const, + isCloud: true, + isDesktop: false, + isNightly: false +})) + +vi.mock(import('@/platform/auth/firebaseIdentity'), () => ({ + firebaseIdentity: fromPartial({ + onUserChanged: (observer: IdentityObserver) => { + identity.userObservers.add(observer) + return () => identity.userObservers.delete(observer) + }, + onTokenChanged: (observer: IdentityObserver) => { + identity.tokenObservers.add(observer) + return () => identity.tokenObservers.delete(observer) + }, + currentUser: () => identity.state.user, + signInWithEmail: async () => { + identity.signIn(USER_A) + return fromPartial({ user: USER_A }) + }, + signOut: firebaseSignOut + }) +})) + +vi.mock(import('@/services/extensionService'), () => ({ + useExtensionService: () => + fromPartial>({ + registerExtension: (extension: ComfyExtension) => { + registeredExtensions.push(extension) + } + }) +})) + +vi.mock(import('@/platform/telemetry')) + +vi.mock(import('@/platform/telemetry/reportError'), () => ({ + reportError: vi.fn() +})) + +await import('@/extensions/core/cloudSessionCookie') + +const TEN_MINUTES_MS = 10 * 60 * 1000 + +const USER_A = fromPartial({ + uid: 'user-a', + getIdToken: async () => 'firebase-id-token' +}) + +type ServerSession = 'none' | 'revoked' | { userId: string } + +interface SessionRequest { + method: string + authorization: string | null + credentials: RequestCredentials | null +} + +function jsonResponse(body: unknown, status = 200): Response { + return new Response(JSON.stringify(body), { + status, + headers: { 'Content-Type': 'application/json' } + }) +} + +function sessionBody(userId: string) { + return { + user: { + id: userId, + email: `${userId}@example.com`, + email_verified: true + }, + csrf_token: `csrf-${userId}`, + expires_at: new Date(Date.now() + 86_400_000).toISOString(), + absolute_expires_at: new Date(Date.now() + 604_800_000).toISOString() + } +} + +function installServer(initial: ServerSession) { + const server = { session: initial, requests: [] as SessionRequest[] } + + const answerSession = (method: string): Response => { + if (method === 'POST') { + server.session = { userId: 'user-a' } + return jsonResponse({ success: true }) + } + if (method === 'DELETE') { + server.session = 'revoked' + return jsonResponse({ success: true }) + } + const { session } = server + if (typeof session === 'object') + return jsonResponse(sessionBody(session.userId)) + const code = session === 'revoked' ? 'session_revoked' : 'no_session' + return jsonResponse({ code, message: code }, 401) + } + + vi.stubGlobal( + 'fetch', + vi.fn(async (input, init) => { + const url = new URL(String(input), location.href) + const method = (init?.method ?? 'GET').toUpperCase() + if (url.pathname === '/api/features') { + return jsonResponse({ unified_web_session: true }) + } + if (url.pathname !== '/api/auth/session') { + return jsonResponse({ id: 'customer-1' }, 201) + } + server.requests.push({ + method, + authorization: new Headers(init?.headers).get('authorization'), + credentials: init?.credentials ?? null + }) + return answerSession(method) + }) + ) + return server +} + +function wireSessionCookieExtension() { + const extension = registeredExtensions.find( + ({ name }) => name === 'Comfy.Cloud.SessionCookie' + ) + assert.exists(extension) + const scope = effectScope() + scope.run(() => { + const { onUserResolved, onTokenRefreshed, onUserLogout } = useCurrentUser() + onUserResolved( + (user) => + void extension.onAuthUserResolved?.(user, fromPartial({})) + ) + onTokenRefreshed(() => void extension.onAuthTokenRefreshed?.()) + onUserLogout(() => void extension.onAuthUserLogout?.()) + }) + return scope +} + +const methodsOf = (requests: SessionRequest[]) => + requests.map(({ method }) => method) + +describe('cloud app on the shared web session (unified_web_session on)', () => { + let hooks: ReturnType | undefined + + beforeEach(() => { + identity.reset() + firebaseSignOut.mockReset() + firebaseSignOut.mockImplementation(async () => identity.signOut()) + vi.spyOn(api, 'resetSocket').mockResolvedValue() + }) + + afterEach(() => { + hooks?.stop() + hooks = undefined + remoteConfig.value = {} + }) + + it('creates the session once per interactive sign-in, never on refresh, and deletes it on sign-out', async () => { + const server = installServer('none') + await refreshRemoteConfig({ useAuth: false }) + + await useAuthStore().login('user-a@example.com', 'password') + hooks = wireSessionCookieExtension() + await vi.waitFor(() => + expect(methodsOf(server.requests)).toEqual(['POST', 'GET', 'GET']) + ) + expect(server.requests[0]).toEqual({ + method: 'POST', + authorization: 'Bearer firebase-id-token', + credentials: 'include' + }) + server.requests.length = 0 + + identity.refreshIdToken() + identity.refreshIdToken() + await vi.advanceTimersByTimeAsync(1_000) + expect(server.requests).toEqual([]) + + await useAuthStore().logout() + expect(server.requests).toEqual([ + { method: 'DELETE', authorization: null, credentials: 'include' } + ]) + server.requests.length = 0 + + await useAuthStore().login('user-a@example.com', 'password') + await vi.waitFor(() => + expect(methodsOf(server.requests)).toEqual(['POST', 'GET']) + ) + }) + + it.for([ + { + name: '200 for the remembered user signs in as is', + session: { userId: 'user-a' }, + requests: ['GET'], + signsOutLocally: false + }, + { + name: '200 for another user signs the remembered login out', + session: { userId: 'user-b' }, + requests: ['GET'], + signsOutLocally: true + }, + { + name: '401 session_revoked signs out and never restores', + session: 'revoked', + requests: ['GET'], + signsOutLocally: true + }, + { + name: '401 no_session restores once from the remembered login', + session: 'none', + requests: ['GET', 'POST', 'GET'], + signsOutLocally: false + } + ] satisfies { + name: string + session: ServerSession + requests: string[] + signsOutLocally: boolean + }[])('boot: $name', async ({ session, requests, signsOutLocally }) => { + const server = installServer(session) + await refreshRemoteConfig({ useAuth: false }) + identity.signIn(USER_A) + + await useSessionCookie().ensureSessionCookie() + + expect(methodsOf(server.requests)).toEqual(requests) + expect(firebaseSignOut).toHaveBeenCalledTimes(signsOutLocally ? 1 : 0) + }) + + it('resets the tab and tells the user when another account takes the session', async () => { + const server = installServer({ userId: 'user-a' }) + await refreshRemoteConfig({ useAuth: false }) + identity.signIn(USER_A) + await useSessionCookie().ensureSessionCookie() + sessionStorage.setItem(WORKSPACE_STORAGE_KEYS.CURRENT_WORKSPACE, 'ws-team') + firebaseSignOut.mockResolvedValue() + + server.session = { userId: 'user-b' } + await vi.advanceTimersByTimeAsync(TEN_MINUTES_MS) + + expect(firebaseSignOut).toHaveBeenCalledOnce() + expect(api.resetSocket).toHaveBeenCalledOnce() + expect( + sessionStorage.getItem(WORKSPACE_STORAGE_KEYS.CURRENT_WORKSPACE) + ).toBeNull() + expect(useToastStore().messagesToAdd).toEqual([ + expect.objectContaining({ + severity: 'info', + detail: expect.stringContaining('user-b@example.com') + }) + ]) + }) +}) diff --git a/src/stores/authStore.ts b/src/stores/authStore.ts index fc1a7fcfad7..3a93504f043 100644 --- a/src/stores/authStore.ts +++ b/src/stores/authStore.ts @@ -13,6 +13,7 @@ import { import { getComfyApiBaseUrl } from '@/config/comfyApi' import { t } from '@/i18n' import { firebaseIdentity } from '@/platform/auth/firebaseIdentity' +import { useCloudWebSessionStore } from '@/platform/auth/session/cloudWebSessionStore' import { fetchWithUnifiedRemint } from '@/platform/auth/unified/remintRetry' import { DISTRIBUTION, isCloud } from '@/platform/distribution/types' import { clearOnboardingReplay } from '@/platform/onboarding/onboardingReplay' @@ -583,6 +584,7 @@ export const useAuthStore = defineStore('auth', () => { { createCustomer: true } ) + useCloudWebSessionStore().signedInInteractively(result.user) useTelemetry()?.trackAuth({ method: 'email', is_new_user: false, @@ -617,6 +619,7 @@ export const useAuthStore = defineStore('auth', () => { }) ) + useCloudWebSessionStore().signedInInteractively(result.user) useTelemetry()?.trackAuth({ method: 'email', is_new_user: true, @@ -656,6 +659,7 @@ export const useAuthStore = defineStore('auth', () => { ) const additionalUserInfo = getAdditionalUserInfo(result) + useCloudWebSessionStore().signedInInteractively(result.user) useTelemetry()?.trackAuth({ method: 'google', is_new_user: options?.isNewUser || additionalUserInfo?.isNewUser || false, @@ -679,6 +683,7 @@ export const useAuthStore = defineStore('auth', () => { ) const additionalUserInfo = getAdditionalUserInfo(result) + useCloudWebSessionStore().signedInInteractively(result.user) useTelemetry()?.trackAuth({ method: 'github', is_new_user: options?.isNewUser || additionalUserInfo?.isNewUser || false, @@ -691,7 +696,10 @@ export const useAuthStore = defineStore('auth', () => { } const logout = async (): Promise => - executeAuthAction(firebaseIdentity.signOut) + executeAuthAction(async () => { + await useCloudWebSessionStore().signOut() + await firebaseIdentity.signOut() + }) const sendPasswordReset = async (email: string): Promise => executeAuthAction(() => firebaseIdentity.sendPasswordReset(email)) From c32b77ab5e241a9115a5396bc32c7ea397481b5e Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Fri, 25 Sep 2026 09:47:11 -0400 Subject: [PATCH 17/30] refactor(account-core): pull the transient lookup-error rule out of the transition --- .../src/core/webSessionIdentity.ts | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/packages/account-core/src/core/webSessionIdentity.ts b/packages/account-core/src/core/webSessionIdentity.ts index 964a1b3a8d3..0a88bae8cd6 100644 --- a/packages/account-core/src/core/webSessionIdentity.ts +++ b/packages/account-core/src/core/webSessionIdentity.ts @@ -142,6 +142,17 @@ 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' +): WebSessionIdentityTransition { + const retries = + state.phase === 'restoring' || + (state.phase === 'reading' && event === 'login_errored') + return retries ? waitToRetry(state.failures + 1) : { state, effects: [] } +} + /** Pure: an event that means nothing in the current phase changes nothing. */ export function transitionWebSessionIdentity( state: WebSessionIdentityState, @@ -177,13 +188,8 @@ export function transitionWebSessionIdentity( ? settleSignedOut('restore_failed') : unchanged case 'proof_errored': - return state.phase === 'restoring' - ? waitToRetry(state.failures + 1) - : unchanged case 'login_errored': - return state.phase === 'reading' || state.phase === 'restoring' - ? waitToRetry(state.failures + 1) - : unchanged + return transientLookupError(state, event.type) case 'retry_due': return state.phase === 'retry_wait' ? { state: { ...state, phase: 'reading' }, effects: [read] } From e7085c16e7659521a9edadc10aa509263fd5bbcd Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Fri, 25 Sep 2026 11:11:34 -0400 Subject: [PATCH 18/30] feat(cloud): send ingest requests on the web session behind unified_web_session With the cloud web session active, fetchApi takes its credential headers from authorize(): X-Comfy-Client, the tab's team workspace, X-CSRF-Token on unsafe methods and credentials include, with no Authorization. A workspace switch reads role from GET /api/workspaces/current instead of minting a token. csrf_invalid is retried once after re-reading the session for the same user and epoch; workspace_access_denied drops the selection and is not replayed. Flag off keeps today's path. --- .../auth/session/cloudWebSessionStore.ts | 77 +++++- src/platform/auth/session/webSessionFetch.ts | 98 ++++++++ src/platform/auth/webSessionFlagOn.test.ts | 232 ++++++++++++++++++ .../workspace/stores/workspaceAuthStore.ts | 45 +++- src/scripts/api.ts | 81 +++--- src/stores/authStore.ts | 3 + 6 files changed, 499 insertions(+), 37 deletions(-) create mode 100644 src/platform/auth/session/webSessionFetch.ts diff --git a/src/platform/auth/session/cloudWebSessionStore.ts b/src/platform/auth/session/cloudWebSessionStore.ts index 36e3dad8818..fd725e46a3b 100644 --- a/src/platform/auth/session/cloudWebSessionStore.ts +++ b/src/platform/auth/session/cloudWebSessionStore.ts @@ -7,7 +7,12 @@ import type { WebSessionIdentity, WebSessionIdentityState } from '@comfyorg/account-core/webSessionIdentity' -import type { WebSessionResult } from '@comfyorg/account-core/webSession' +import type { + WebSession, + WebSessionOptions, + WebSessionResult +} from '@comfyorg/account-core/webSession' +import { readWebSession } from '@comfyorg/account-core/webSession' import { createWebSessionIdentity } from '@comfyorg/account-core/webSessionIdentity' import { createWebCrossTabRefreshPort, @@ -17,6 +22,11 @@ import { import { useFeatureFlags } from '@/composables/useFeatureFlags' import { t } from '@/i18n' import { firebaseIdentity } from '@/platform/auth/firebaseIdentity' +import type { WebSessionRequestScope } from '@/platform/auth/session/webSessionFetch' +import { + fetchOnWebSession, + provideWebSessionRequests +} from '@/platform/auth/session/webSessionFetch' import { reportError } from '@/platform/telemetry/reportError' import { useToastStore } from '@/platform/updates/common/toastStore' import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore' @@ -57,14 +67,18 @@ function resetForAccountChange(change: WebSessionAccountChange): void { }) } +function sessionOptions(): WebSessionOptions { + return { + apiBaseUrl: api.apiURL(''), + fetchImpl: (input, init) => fetch(input, init) + } +} + function createCloudIdentity(): WebSessionIdentity { const visibility = createWebVisibilityPort() const crossTab = createWebCrossTabRefreshPort() return createWebSessionIdentity({ - session: { - apiBaseUrl: api.apiURL(''), - fetchImpl: (input, init) => fetch(input, init) - }, + session: sessionOptions(), principal: { kind: 'account', rememberedLogin: { @@ -91,8 +105,13 @@ export const useCloudWebSessionStore = defineStore('cloudWebSession', () => { let identity: WebSessionIdentity | null = null let ready: Promise = Promise.resolve() let pendingSignIn: InteractiveSignIn | null = null + let reread: WebSession | null = null + let releaseRequests = () => {} - onScopeDispose(() => identity?.dispose()) + onScopeDispose(() => { + releaseRequests() + identity?.dispose() + }) async function createSession( session: WebSessionIdentity, @@ -123,6 +142,10 @@ export const useCloudWebSessionStore = defineStore('cloudWebSession', () => { if (!useFeatureFlags().flags.unifiedWebSessionEnabled) return false const session = createCloudIdentity() identity = session + session.subscribe(() => { + reread = null + }) + releaseRequests = provideWebSessionRequests({ scope: requestScope, send }) ready = whenSettled(session) void bootAfter(session, pendingSignIn) pendingSignIn = null @@ -146,6 +169,48 @@ export const useCloudWebSessionStore = defineStore('cloudWebSession', () => { }) } + function currentSession(): WebSession | undefined { + const state = identity?.getState() + if (state?.phase !== 'signed_in') return undefined + return reread?.user.id === state.session.user.id ? reread : state.session + } + + /** Undefined unless this tab is signed in on the session. */ + async function requestScope(): Promise { + await ready + const session = currentSession() + if (!identity || !session) return undefined + const workspace = useWorkspaceAuthStore().currentWorkspace + return { + session, + epoch: identity.getEpoch(), + ...(workspace?.type === 'team' && { workspaceId: workspace.id }) + } + } + + async function rereadFor( + scope: WebSessionRequestScope + ): Promise { + const result = await readWebSession(sessionOptions(), { + expectedUserId: scope.session.user.id + }) + if (result.status !== 'ok' || identity?.getEpoch() !== scope.epoch) return + reread = result.session + return { ...scope, session: result.session } + } + + function send( + url: string, + init: RequestInit, + scope: WebSessionRequestScope + ): Promise { + return fetchOnWebSession(url, init, scope, { + reread: rereadFor, + workspaceDenied: (workspaceId) => + useWorkspaceAuthStore().dropDeniedWorkspace(workspaceId) + }) + } + return { start, isActive: () => identity !== null, diff --git a/src/platform/auth/session/webSessionFetch.ts b/src/platform/auth/session/webSessionFetch.ts new file mode 100644 index 00000000000..5884756a00f --- /dev/null +++ b/src/platform/auth/session/webSessionFetch.ts @@ -0,0 +1,98 @@ +import { zErrorResponse } from '@comfyorg/ingest-types/zod' +import { createRequestAuthorizer } from '@comfyorg/account-core/requestAuth' +import type { WebSession } from '@comfyorg/account-core/webSession' + +/** The user, session epoch and workspace one request was started for. */ +export interface WebSessionRequestScope { + readonly session: WebSession + readonly epoch: number + /** Absent means the personal workspace. */ + readonly workspaceId?: string +} + +export interface WebSessionFetchPorts { + /** A fresh session for the same user and epoch, or undefined to abandon. */ + readonly reread: ( + scope: WebSessionRequestScope + ) => Promise + readonly workspaceDenied: (workspaceId: string) => void +} + +const authorize = createRequestAuthorizer({ + getWorkspaceToken: () => + Promise.reject(new Error('The cloud app sends no resource requests yet')) +}) + +async function refusalCode(response: Response): Promise { + if (response.status !== 403) return undefined + const body: unknown = await response + .clone() + .json() + .catch(() => undefined) + return zErrorResponse.safeParse(body).data?.code +} + +/** + * Sends one ingest request on the session cookie. `csrf_invalid` is the one + * refusal a fresh token can fix, so it is retried once for the same user and + * workspace; `workspace_access_denied` drops that workspace and is returned + * as is, never replayed elsewhere. + */ +export async function fetchOnWebSession( + url: string, + init: RequestInit, + scope: WebSessionRequestScope, + ports: WebSessionFetchPorts +): Promise { + const send = async (current: WebSessionRequestScope) => { + const { headers, credentials } = await authorize( + { kind: 'session', session: current.session }, + { + target: 'ingest', + method: init.method ?? 'GET', + workspaceId: current.workspaceId + } + ) + const merged = new Headers(init.headers) + for (const [name, value] of Object.entries(headers)) merged.set(name, value) + return fetch(url, { ...init, headers: merged, credentials }) + } + + const response = await send(scope) + const code = await refusalCode(response) + if (code === 'workspace_access_denied' && scope.workspaceId !== undefined) { + ports.workspaceDenied(scope.workspaceId) + } + if (code !== 'csrf_invalid' || init.body instanceof ReadableStream) { + return response + } + const fresh = await ports.reread(scope) + return fresh ? send(fresh) : response +} + +/** What a signed-in tab's requests need from the web session. */ +export interface WebSessionRequests { + /** Undefined unless this tab is signed in on the session. */ + readonly scope: () => Promise + readonly send: ( + url: string, + init: RequestInit, + scope: WebSessionRequestScope + ) => Promise +} + +let provided: WebSessionRequests | undefined + +/** Set while the web session is on for this page load; returns its release. */ +export function provideWebSessionRequests( + requests: WebSessionRequests +): () => void { + provided = requests + return () => { + if (provided === requests) provided = undefined + } +} + +export function webSessionRequests(): WebSessionRequests | undefined { + return provided +} diff --git a/src/platform/auth/webSessionFlagOn.test.ts b/src/platform/auth/webSessionFlagOn.test.ts index 0bdc609b275..6c021246194 100644 --- a/src/platform/auth/webSessionFlagOn.test.ts +++ b/src/platform/auth/webSessionFlagOn.test.ts @@ -4,12 +4,16 @@ import { afterEach, assert, beforeEach, describe, expect, it, vi } from 'vitest' import { effectScope } from 'vue' import type { FirebaseIdentity } from '@comfyorg/account-core/firebase' +import { COMFY_CLIENT } from '@comfyorg/account-core/requestAuth' import { useCurrentUser } from '@/composables/auth/useCurrentUser' import { useSessionCookie } from '@/platform/auth/session/useSessionCookie' import { refreshRemoteConfig } from '@/platform/remoteConfig/refreshRemoteConfig' import { remoteConfig } from '@/platform/remoteConfig/remoteConfig' import { useToastStore } from '@/platform/updates/common/toastStore' +import { workspaceApi } from '@/platform/workspace/api/workspaceApi' +import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore' +import { useWorkspaceAuthStore } from '@/platform/workspace/stores/workspaceAuthStore' import { WORKSPACE_STORAGE_KEYS } from '@/platform/workspace/workspaceConstants' import { api } from '@/scripts/api' import type { ComfyApp } from '@/scripts/app' @@ -305,3 +309,231 @@ describe('cloud app on the shared web session (unified_web_session on)', () => { ]) }) }) + +interface ApiRequest { + method: string + path: string + headers: Record + credentials: RequestCredentials | null +} + +function recordApiRequest( + input: RequestInfo | URL, + init: RequestInit | undefined +): ApiRequest { + return { + method: (init?.method ?? 'GET').toUpperCase(), + path: new URL(String(input), location.href).pathname, + headers: Object.fromEntries( + [...new Headers(init?.headers).entries()].map(([name, value]) => [ + name.toLowerCase(), + value + ]) + ), + credentials: init?.credentials ?? null + } +} + +function currentWorkspaceResponse(workspaceId: string | undefined): Response { + if (workspaceId === 'ws-gone') { + return jsonResponse({ code: 'workspace_access_denied', message: 'no' }, 403) + } + const isTeam = workspaceId === 'ws-team' + return jsonResponse({ + id: workspaceId ?? 'ws-personal', + name: isTeam ? 'Team' : 'Personal', + type: isTeam ? 'team' : 'personal', + role: 'owner', + auth_method: 'web_session', + permissions: ['owner:*'] + }) +} + +function installIngest() { + const ingest = { + userId: 'user-a', + csrfToken: 'csrf-1', + refusals: [] as string[], + requests: [] as ApiRequest[] + } + + const respond = ({ path, headers }: ApiRequest): Response => { + if (path === '/api/auth/session') { + return jsonResponse({ + ...sessionBody(ingest.userId), + csrf_token: ingest.csrfToken + }) + } + if (path === '/api/workspaces/current') { + return currentWorkspaceResponse(headers['x-comfy-workspace-id']) + } + const code = ingest.refusals.shift() + return code ? jsonResponse({ code, message: code }, 403) : jsonResponse({}) + } + + vi.stubGlobal( + 'fetch', + vi.fn(async (input, init) => { + const request = recordApiRequest(input, init) + if (request.path === '/api/features') { + return jsonResponse({ unified_web_session: true }) + } + ingest.requests.push(request) + return respond(request) + }) + ) + return ingest +} + +async function bootOnSession() { + const ingest = installIngest() + await refreshRemoteConfig({ useAuth: false }) + useAuthStore() + identity.signIn(USER_A) + await useSessionCookie().ensureSessionCookie() + ingest.requests.length = 0 + return ingest +} + +const postPrompt = () => + api.fetchApi('/prompt', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: '{}' + }) + +const sessionRequest = ( + method: string, + path: string, + headers: Record = {} +): ApiRequest => ({ + method, + path, + headers: { 'x-comfy-client': COMFY_CLIENT, ...headers }, + credentials: 'include' +}) + +const LISTED = { + role: 'owner', + created_at: '2026-01-01T00:00:00Z', + joined_at: '2026-01-01T00:00:00Z' +} as const + +const PROMPT_HEADERS = { 'comfy-user': '', 'content-type': 'application/json' } + +describe('cloud API requests on the shared web session', () => { + beforeEach(() => { + identity.reset() + vi.spyOn(api, 'resetSocket').mockResolvedValue() + }) + + afterEach(() => { + remoteConfig.value = {} + localStorage.clear() + }) + + it('sends the session headers instead of a token, and a workspace switch changes only the header', async () => { + const ingest = await bootOnSession() + const workspaceAuth = useWorkspaceAuthStore() + localStorage.setItem(WORKSPACE_STORAGE_KEYS.LAST_WORKSPACE_ID, 'ws-team') + vi.spyOn(workspaceApi, 'list').mockResolvedValue({ + workspaces: [ + { ...LISTED, id: 'ws-personal', name: 'Personal', type: 'personal' }, + { ...LISTED, id: 'ws-team', name: 'Team', type: 'team' } + ] + }) + + await useTeamWorkspaceStore().initialize() + await api.fetchApi('/queue') + await postPrompt() + expect(await useAuthStore().getAuthHeader()).toEqual({ + Authorization: 'Bearer firebase-id-token' + }) + await workspaceAuth.switchWorkspace('ws-personal') + await api.fetchApi('/queue') + + const team = { 'x-comfy-workspace-id': 'ws-team' } + expect(ingest.requests).toEqual([ + sessionRequest('GET', '/api/workspaces/current', team), + sessionRequest('GET', '/api/queue', { ...team, 'comfy-user': '' }), + sessionRequest('POST', '/api/prompt', { + ...team, + ...PROMPT_HEADERS, + 'x-csrf-token': 'csrf-1' + }), + sessionRequest('GET', '/api/workspaces/current', { + 'x-comfy-workspace-id': 'ws-personal' + }), + sessionRequest('GET', '/api/queue', { 'comfy-user': '' }) + ]) + expect(workspaceAuth.currentWorkspace).toEqual({ + id: 'ws-personal', + name: 'Personal', + type: 'personal', + role: 'owner' + }) + }) + + it.for([ + { + name: 'the same user is re-read once and retried once with the fresh token', + sessionUser: 'user-a', + status: 200, + tokens: ['csrf-1', 'session', 'csrf-2', 'csrf-2'] + }, + { + name: 'a changed user abandons the request', + sessionUser: 'user-b', + status: 403, + tokens: ['csrf-1', 'session', 'csrf-1'] + } + ])('csrf_invalid: $name', async ({ sessionUser, status, tokens }) => { + const ingest = await bootOnSession() + ingest.refusals.push('csrf_invalid') + ingest.userId = sessionUser + ingest.csrfToken = 'csrf-2' + + const response = await postPrompt() + await postPrompt() + + expect(response.status).toBe(status) + expect( + ingest.requests.map(({ path, headers }) => + path === '/api/auth/session' ? 'session' : headers['x-csrf-token'] + ) + ).toEqual(tokens) + }) + + it('workspace_access_denied drops the selection and is never replayed', async () => { + const ingest = await bootOnSession() + vi.spyOn(window.location, 'reload').mockImplementation(() => {}) + const workspaceAuth = useWorkspaceAuthStore() + await workspaceAuth.switchWorkspace('ws-team') + ingest.requests.length = 0 + ingest.refusals.push('workspace_access_denied') + + const response = await postPrompt() + await api.fetchApi('/queue') + + expect(response.status).toBe(403) + expect(workspaceAuth.currentWorkspace).toBeNull() + expect(ingest.requests).toEqual([ + sessionRequest('POST', '/api/prompt', { + 'x-comfy-workspace-id': 'ws-team', + ...PROMPT_HEADERS, + 'x-csrf-token': 'csrf-1' + }), + sessionRequest('GET', '/api/queue', { 'comfy-user': '' }) + ]) + }) + + it('refuses a switch into a workspace the session cannot enter', async () => { + await bootOnSession() + const workspaceAuth = useWorkspaceAuthStore() + + await expect(workspaceAuth.switchWorkspace('ws-gone')).rejects.toThrow( + '403' + ) + expect(workspaceAuth.currentWorkspace).toBeNull() + }) +}) diff --git a/src/platform/workspace/stores/workspaceAuthStore.ts b/src/platform/workspace/stores/workspaceAuthStore.ts index e65e4052fa8..4939f0a0487 100644 --- a/src/platform/workspace/stores/workspaceAuthStore.ts +++ b/src/platform/workspace/stores/workspaceAuthStore.ts @@ -13,8 +13,12 @@ import { isPermanentSessionError } from '@comfyorg/account-core/session' +import { zCurrentWorkspaceResponse } from '@comfyorg/ingest-types/zod' + import { t } from '@/i18n' import { firebaseIdentity } from '@/platform/auth/firebaseIdentity' +import type { WebSessionRequests } from '@/platform/auth/session/webSessionFetch' +import { webSessionRequests } from '@/platform/auth/session/webSessionFetch' import enMessages from '@/locales/en/main.json' with { type: 'json' } import { useTelemetry } from '@/platform/telemetry' import { reportError } from '@/platform/telemetry/reportError' @@ -189,6 +193,39 @@ export const useWorkspaceAuthStore = defineStore('workspaceAuth', () => { } function switchWorkspace(workspaceId: string): Promise { + const requests = webSessionRequests() + if (requests) return switchSessionWorkspace(requests, workspaceId) + + return switchTokenWorkspace(workspaceId) + } + + /** The session selects a workspace by header; the role comes from ingest. */ + async function switchSessionWorkspace( + requests: WebSessionRequests, + workspaceId: string + ): Promise { + const scope = await requests.scope() + if (!scope) return switchTokenWorkspace(workspaceId) + + currentWorkspace.value = null + const response = await requests.send( + workspaceApiUrl('/workspaces/current'), + { method: 'GET', cache: 'no-store' }, + { ...scope, workspaceId } + ) + const current = zCurrentWorkspaceResponse.safeParse( + response.ok ? await response.json() : undefined + ) + if (!current.success || current.data.id !== workspaceId) { + throw new WorkspaceAuthError( + `Workspace switch refused with ${response.status}` + ) + } + const { id, name, type, role = 'member' } = current.data + currentWorkspace.value = { id, name, type, role } + } + + function switchTokenWorkspace(workspaceId: string): Promise { if (flags.unifiedCloudAuthEnabled) { return switchUnifiedWorkspace(workspaceId) } @@ -196,6 +233,11 @@ export const useWorkspaceAuthStore = defineStore('workspaceAuth', () => { return switchLegacyWorkspace(workspaceId) } + function dropDeniedWorkspace(workspaceId: string): void { + if (currentWorkspace.value?.id !== workspaceId) return + endWorkspaceSession(workspaceId) + } + // --- Unified Cloud-JWT lifecycle (flag-gated: unified_cloud_auth) ---------- // // The mint/refresh machinery is delegated to @comfyorg/account-core's session @@ -621,6 +663,7 @@ export const useWorkspaceAuthStore = defineStore('workspaceAuth', () => { getUnifiedToken, getUnifiedSessionClient, getUnifiedMintWorkspaceId, - clearWorkspaceContext + clearWorkspaceContext, + dropDeniedWorkspace } }) diff --git a/src/scripts/api.ts b/src/scripts/api.ts index 05f53b5987a..f0e191ef78b 100644 --- a/src/scripts/api.ts +++ b/src/scripts/api.ts @@ -17,6 +17,7 @@ import { trimEnd } from 'es-toolkit' import { ref } from 'vue' import defaultClientFeatureFlags from '@/config/clientFeatureFlags.json' with { type: 'json' } +import { webSessionRequests } from '@/platform/auth/session/webSessionFetch' import { fetchWithUnifiedRemint, shouldRemintCloudRequest @@ -340,6 +341,8 @@ export type GlobalSubgraphData = { essentials_category?: string } +type WebSessionSend = (url: string, init: RequestInit) => Promise + function addHeaderEntry(headers: HeadersInit, key: string, value: string) { if (Array.isArray(headers)) { headers.push([key, value]) @@ -540,6 +543,35 @@ export class ComfyApi extends EventTarget { } } + private async getWebSessionSend(): Promise { + const requests = webSessionRequests() + if (!requests) return undefined + const scope = await requests.scope() + return scope && ((url, init) => requests.send(url, init, scope)) + } + + /** Adds today's token header; true when a 401 may be re-minted. */ + private async addCloudAuthHeader(headers: HeadersInit): Promise { + // Get Firebase JWT token if user is logged in + const getAuthHeaderIfAvailable = async (): Promise => { + try { + const authStore = await this.getAuthStore() + return authStore ? await authStore.getAuthHeader() : null + } catch (error) { + console.warn('Failed to get auth header:', error) + return null + } + } + + const authHeader = await getAuthHeaderIfAvailable() + if (!authHeader) return false + + for (const [key, value] of Object.entries(authHeader)) { + addHeaderEntry(headers, key, value) + } + return shouldRemintCloudRequest() + } + /** * Waits for Firebase auth to be initialized before proceeding. * Includes 10-second timeout to prevent infinite hanging. @@ -568,28 +600,13 @@ export class ComfyApi extends EventTarget { options ?? {} const headers: HeadersInit = requestOptions.headers ?? {} let unifiedRetryOn401 = false + let sendOnWebSession: WebSessionSend | undefined if (isCloud) { await this.waitForAuthInitialization() - - // Get Firebase JWT token if user is logged in - const getAuthHeaderIfAvailable = async (): Promise => { - try { - const authStore = await this.getAuthStore() - return authStore ? await authStore.getAuthHeader() : null - } catch (error) { - console.warn('Failed to get auth header:', error) - return null - } - } - - const authHeader = await getAuthHeaderIfAvailable() - - if (authHeader) { - for (const [key, value] of Object.entries(authHeader)) { - addHeaderEntry(headers, key, value) - } - unifiedRetryOn401 = await shouldRemintCloudRequest() + sendOnWebSession = await this.getWebSessionSend() + if (!sendOnWebSession) { + unifiedRetryOn401 = await this.addCloudAuthHeader(headers) } } @@ -664,17 +681,21 @@ export class ComfyApi extends EventTarget { } : undefined - return fetchWithUnifiedRemint( - this.apiURL(route), - { - cache: 'no-cache', - ...requestOptions, - headers, - signal - }, - unifiedRetryOn401, - retrySignalLifecycle - ).finally(() => { + const init: RequestInit = { + cache: 'no-cache', + ...requestOptions, + headers, + signal + } + const response = sendOnWebSession + ? sendOnWebSession(this.apiURL(route), init) + : fetchWithUnifiedRemint( + this.apiURL(route), + init, + unifiedRetryOn401, + retrySignalLifecycle + ) + return response.finally(() => { if (timeoutId !== undefined) clearTimeout(timeoutId) if (retryTimeoutId !== undefined) clearTimeout(retryTimeoutId) }) diff --git a/src/stores/authStore.ts b/src/stores/authStore.ts index 3a93504f043..aa15c95ae5c 100644 --- a/src/stores/authStore.ts +++ b/src/stores/authStore.ts @@ -14,6 +14,7 @@ import { getComfyApiBaseUrl } from '@/config/comfyApi' import { t } from '@/i18n' import { firebaseIdentity } from '@/platform/auth/firebaseIdentity' import { useCloudWebSessionStore } from '@/platform/auth/session/cloudWebSessionStore' +import { webSessionRequests } from '@/platform/auth/session/webSessionFetch' import { fetchWithUnifiedRemint } from '@/platform/auth/unified/remintRetry' import { DISTRIBUTION, isCloud } from '@/platform/distribution/types' import { clearOnboardingReplay } from '@/platform/onboarding/onboardingReplay' @@ -230,6 +231,8 @@ export const useAuthStore = defineStore('auth', () => { return token ? { Authorization: `Bearer ${token}` } : null } + if (webSessionRequests()) return getUserAuthHeader() + const workspaceAuth = useWorkspaceAuthStore() const activeWorkspaceId = useTeamWorkspaceStore().activeWorkspaceId From da544d55f982bfafdf2b1ab5fe979fb72d8372a0 Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Fri, 25 Sep 2026 11:41:43 -0400 Subject: [PATCH 19/30] feat(cloud): scope the socket and media URLs to the web session workspace With unified_web_session on and the web session signed in, the WebSocket URL drops the token and carries ?workspace_id= for a team workspace, relying on the session cookie. A change of signed-in user or team workspace re-handshakes the socket without minting a token, keeping the client id. A socket that closes is reconnected as today, but only while someone is still signed in; with no session and no token it stays closed. Media routes built through api.apiURL (/view, /viewvideo, /vhs/viewvideo, /vhs/viewaudio, /assets/:id/content) gain ?workspace_id= for a team workspace. Flag off keeps today's socket and media URLs; the flag-off harness now also pins the video, audio and asset content URLs. --- .../auth/session/cloudWebSessionStore.ts | 31 +++- src/platform/auth/session/sessionMediaUrl.ts | 16 ++ src/platform/auth/session/webSessionFetch.ts | 2 + src/platform/auth/webSessionFlagOff.test.ts | 16 +- src/platform/auth/webSessionFlagOn.test.ts | 150 ++++++++++++++++++ src/scripts/api.ts | 74 ++++++--- 6 files changed, 257 insertions(+), 32 deletions(-) create mode 100644 src/platform/auth/session/sessionMediaUrl.ts diff --git a/src/platform/auth/session/cloudWebSessionStore.ts b/src/platform/auth/session/cloudWebSessionStore.ts index fd725e46a3b..7253413de5b 100644 --- a/src/platform/auth/session/cloudWebSessionStore.ts +++ b/src/platform/auth/session/cloudWebSessionStore.ts @@ -1,6 +1,6 @@ import type { User } from 'firebase/auth' import { defineStore } from 'pinia' -import { onScopeDispose } from 'vue' +import { onScopeDispose, shallowRef, watch } from 'vue' import type { WebSessionAccountChange, @@ -67,6 +67,11 @@ function resetForAccountChange(change: WebSessionAccountChange): void { }) } +function teamWorkspaceId(): string | undefined { + const workspace = useWorkspaceAuthStore().currentWorkspace + return workspace?.type === 'team' ? workspace.id : undefined +} + function sessionOptions(): WebSessionOptions { return { apiBaseUrl: api.apiURL(''), @@ -107,6 +112,16 @@ export const useCloudWebSessionStore = defineStore('cloudWebSession', () => { let pendingSignIn: InteractiveSignIn | null = null let reread: WebSession | null = null let releaseRequests = () => {} + const signedInUserId = shallowRef() + + watch( + () => + signedInUserId.value && + JSON.stringify([signedInUserId.value, teamWorkspaceId()]), + (socketScope) => { + if (socketScope) void api.reconnectSocket() + } + ) onScopeDispose(() => { releaseRequests() @@ -142,10 +157,16 @@ export const useCloudWebSessionStore = defineStore('cloudWebSession', () => { if (!useFeatureFlags().flags.unifiedWebSessionEnabled) return false const session = createCloudIdentity() identity = session - session.subscribe(() => { + session.subscribe((state) => { reread = null + signedInUserId.value = + state.phase === 'signed_in' ? state.session.user.id : undefined + }) + releaseRequests = provideWebSessionRequests({ + scope: requestScope, + workspaceId: () => (currentSession() ? teamWorkspaceId() : undefined), + send }) - releaseRequests = provideWebSessionRequests({ scope: requestScope, send }) ready = whenSettled(session) void bootAfter(session, pendingSignIn) pendingSignIn = null @@ -180,11 +201,11 @@ export const useCloudWebSessionStore = defineStore('cloudWebSession', () => { await ready const session = currentSession() if (!identity || !session) return undefined - const workspace = useWorkspaceAuthStore().currentWorkspace + const workspaceId = teamWorkspaceId() return { session, epoch: identity.getEpoch(), - ...(workspace?.type === 'team' && { workspaceId: workspace.id }) + ...(workspaceId && { workspaceId }) } } diff --git a/src/platform/auth/session/sessionMediaUrl.ts b/src/platform/auth/session/sessionMediaUrl.ts new file mode 100644 index 00000000000..8575b9426b5 --- /dev/null +++ b/src/platform/auth/session/sessionMediaUrl.ts @@ -0,0 +1,16 @@ +const MEDIA_ROUTE = + /^(?:\/api)?\/(?:view|viewvideo|vhs\/viewvideo|vhs\/viewaudio|assets\/[^/?#]+\/content)(?:\?|$)/ + +/** + * Names the workspace on a media route, which an image or video tag loads + * without headers; absent means the personal workspace. + */ +export function scopeMediaRoute( + route: string, + workspaceId: string | undefined +): string { + if (!workspaceId || !MEDIA_ROUTE.test(route)) return route + if (/[?&]workspace_id=/.test(route)) return route + const separator = route.includes('?') ? '&' : '?' + return `${route}${separator}workspace_id=${encodeURIComponent(workspaceId)}` +} diff --git a/src/platform/auth/session/webSessionFetch.ts b/src/platform/auth/session/webSessionFetch.ts index 5884756a00f..e6960e6b4ef 100644 --- a/src/platform/auth/session/webSessionFetch.ts +++ b/src/platform/auth/session/webSessionFetch.ts @@ -74,6 +74,8 @@ export async function fetchOnWebSession( export interface WebSessionRequests { /** Undefined unless this tab is signed in on the session. */ readonly scope: () => Promise + /** The signed-in session's team workspace, for URLs that carry no header. */ + readonly workspaceId: () => string | undefined readonly send: ( url: string, init: RequestInit, diff --git a/src/platform/auth/webSessionFlagOff.test.ts b/src/platform/auth/webSessionFlagOff.test.ts index 2e225321e61..dabe0844ec5 100644 --- a/src/platform/auth/webSessionFlagOff.test.ts +++ b/src/platform/auth/webSessionFlagOff.test.ts @@ -13,7 +13,11 @@ import { remoteConfig } from '@/platform/remoteConfig/remoteConfig' import { TOKEN_REFRESH_BUFFER_MS } from '@/platform/workspace/workspaceConstants' import { api } from '@/scripts/api' import { useAuthStore } from '@/stores/authStore' -import { resultItemPreviewUrl, resultItemUrl } from '@/utils/resultItemUrl' +import { + resultItemPreviewUrl, + resultItemUrl, + resultItemVhsAdvancedPreviewUrl +} from '@/utils/resultItemUrl' import type { useExtensionService } from '@/services/extensionService' import type { ComfyApp } from '@/scripts/app' import type { ComfyExtension } from '@/types/comfy' @@ -279,7 +283,10 @@ const MEDIA_ITEM = { const MEDIA_URLS = [ '/api/view?filename=output.png&type=output&subfolder=', - '/api/view?filename=output.png&type=output&subfolder=&res=512' + '/api/view?filename=output.png&type=output&subfolder=&res=512', + '/api/viewvideo?filename=output.png&type=output&subfolder=', + '/api/vhs/viewaudio?filename=a.wav', + '/api/assets/asset-1/content?disposition=inline' ] const SIGN_OUT: RecordedRequest[] = [ @@ -450,7 +457,10 @@ describe('cloud auth requests with unified_web_session off', () => { expect([ resultItemUrl(MEDIA_ITEM), - resultItemPreviewUrl(MEDIA_ITEM) + resultItemPreviewUrl(MEDIA_ITEM), + resultItemVhsAdvancedPreviewUrl(MEDIA_ITEM), + api.apiURL('/vhs/viewaudio?filename=a.wav'), + api.apiURL('/assets/asset-1/content?disposition=inline') ]).toEqual(MEDIA_URLS) expect(recorder.socketCloses).toBe(0) diff --git a/src/platform/auth/webSessionFlagOn.test.ts b/src/platform/auth/webSessionFlagOn.test.ts index 6c021246194..9b0b556c410 100644 --- a/src/platform/auth/webSessionFlagOn.test.ts +++ b/src/platform/auth/webSessionFlagOn.test.ts @@ -20,6 +20,10 @@ import type { ComfyApp } from '@/scripts/app' import type { useExtensionService } from '@/services/extensionService' import { useAuthStore } from '@/stores/authStore' import type { ComfyExtension } from '@/types/comfy' +import { + resultItemUrl, + resultItemVhsAdvancedPreviewUrl +} from '@/utils/resultItemUrl' type IdentityObserver = (user: User | null) => void @@ -537,3 +541,149 @@ describe('cloud API requests on the shared web session', () => { expect(workspaceAuth.currentWorkspace).toBeNull() }) }) + +class FakeSocket extends EventTarget { + static readonly CONNECTING = 0 + static readonly OPEN = 1 + static readonly CLOSING = 2 + static readonly CLOSED = 3 + static created: FakeSocket[] = [] + readyState = FakeSocket.CONNECTING + binaryType = 'blob' + readonly path: string + constructor(url: string | URL) { + super() + const parsed = new URL(String(url)) + this.path = parsed.pathname + parsed.search + FakeSocket.created.push(this) + } + send() {} + close() { + this.readyState = FakeSocket.CLOSED + } + closeFromServer() { + this.close() + this.dispatchEvent(new Event('close')) + } +} + +const MEDIA_ITEM = { + filename: 'output.png', + subfolder: '', + type: 'output', + nodeId: '1', + mediaType: 'images' +} as const + +describe('live updates and media on the shared web session', () => { + beforeEach(() => { + identity.reset() + firebaseSignOut.mockReset() + firebaseSignOut.mockImplementation(async () => identity.signOut()) + FakeSocket.created = [] + vi.stubGlobal('WebSocket', FakeSocket) + window.name = '' + api.socket = null + }) + + afterEach(() => { + remoteConfig.value = {} + localStorage.clear() + }) + + async function bootWithSocket() { + const ingest = await bootOnSession() + await api.init() + return ingest + } + + it('opens the socket on the cookie and reconnects it into each workspace without minting a token', async () => { + const ingest = await bootWithSocket() + const workspaceAuth = useWorkspaceAuthStore() + expect(FakeSocket.created.map(({ path }) => path)).toEqual(['/ws']) + + await workspaceAuth.switchWorkspace('ws-team') + await vi.waitFor(() => + expect(api.socket).toEqual( + expect.objectContaining({ path: '/ws?workspace_id=ws-team' }) + ) + ) + await workspaceAuth.switchWorkspace('ws-personal') + await vi.waitFor(() => + expect(api.socket).toEqual(expect.objectContaining({ path: '/ws' })) + ) + + expect(api.socket).toBe(FakeSocket.created.at(-1)) + const replaced = FakeSocket.created.slice(0, -1) + expect(replaced.map(({ readyState }) => readyState)).toEqual( + replaced.map(() => FakeSocket.CLOSED) + ) + expect( + FakeSocket.created.filter(({ path }) => path.includes('token')) + ).toEqual([]) + expect(ingest.requests.map(({ path }) => path)).not.toContain( + '/api/auth/token' + ) + }) + + it.for([ + { workspace: 'ws-team', suffix: '&workspace_id=ws-team' }, + { workspace: 'ws-personal', suffix: '' } + ])( + 'media URLs name the workspace only for a team ($workspace)', + async ({ workspace, suffix }) => { + await bootOnSession() + await useWorkspaceAuthStore().switchWorkspace(workspace) + + expect([ + resultItemUrl(MEDIA_ITEM), + resultItemVhsAdvancedPreviewUrl(MEDIA_ITEM), + api.apiURL('/vhs/viewvideo?filename=a.mp4'), + api.apiURL('/api/view?filename=a.png'), + api.apiURL('/assets/asset-1/content?disposition=inline'), + api.apiURL('/queue?view=1') + ]).toEqual([ + `/api/view?filename=output.png&type=output&subfolder=${suffix}`, + `/api/viewvideo?filename=output.png&type=output&subfolder=${suffix}`, + `/api/vhs/viewvideo?filename=a.mp4${suffix}`, + `/api/view?filename=a.png${suffix}`, + `/api/assets/asset-1/content?disposition=inline${suffix}`, + '/api/queue?view=1' + ]) + } + ) + + it('a server close while signed in reconnects on the session', async () => { + await bootWithSocket() + await useWorkspaceAuthStore().switchWorkspace('ws-team') + await vi.waitFor(() => + expect(api.socket).toEqual( + expect.objectContaining({ path: '/ws?workspace_id=ws-team' }) + ) + ) + const closed = api.socket + assert.instanceOf(closed, FakeSocket) + + closed.closeFromServer() + await vi.advanceTimersByTimeAsync(300) + + await vi.waitFor(() => expect(api.socket).not.toBe(closed)) + expect(api.socket).toEqual( + expect.objectContaining({ path: '/ws?workspace_id=ws-team' }) + ) + }) + + it('sign-out closes the socket and opens no other', async () => { + await bootWithSocket() + const sessionSocket = api.socket + assert.instanceOf(sessionSocket, FakeSocket) + + await useAuthStore().logout() + sessionSocket.closeFromServer() + await vi.advanceTimersByTimeAsync(1_000) + + expect(sessionSocket.readyState).toBe(FakeSocket.CLOSED) + expect(FakeSocket.created).toEqual([sessionSocket]) + expect(api.socket).toBeNull() + }) +}) diff --git a/src/scripts/api.ts b/src/scripts/api.ts index f0e191ef78b..5b2b443c607 100644 --- a/src/scripts/api.ts +++ b/src/scripts/api.ts @@ -17,6 +17,7 @@ import { trimEnd } from 'es-toolkit' import { ref } from 'vue' import defaultClientFeatureFlags from '@/config/clientFeatureFlags.json' with { type: 'json' } +import { scopeMediaRoute } from '@/platform/auth/session/sessionMediaUrl' import { webSessionRequests } from '@/platform/auth/session/webSessionFetch' import { fetchWithUnifiedRemint, @@ -518,8 +519,12 @@ export class ComfyApi extends EventTarget { } apiURL(route: string): string { - if (route.startsWith('/api')) return this.api_base + route - return this.api_base + '/api' + route + const requests = webSessionRequests() + const scoped = requests + ? scopeMediaRoute(route, requests.workspaceId()) + : route + if (scoped.startsWith('/api')) return this.api_base + scoped + return this.api_base + '/api' + scoped } fileURL(route: string): string { @@ -856,6 +861,31 @@ export class ComfyApi extends EventTarget { }, 1000) } + /** False when the web session is on and no one is signed in to open it. */ + private async addSocketAuth(params: URLSearchParams): Promise { + const requests = webSessionRequests() + const sessionScope = requests && (await requests.scope()) + if (sessionScope?.workspaceId) { + params.set('workspace_id', sessionScope.workspaceId) + } + if (sessionScope) return true + + // Get auth token and set cloud params if available + // Uses workspace token (if enabled) or Firebase token + try { + const authStore = await this.getAuthStore() + const authToken = await authStore?.getAuthToken() + if (authToken) { + params.set('token', authToken) + } + } catch (error) { + void trackWsTokenUnavailable() + // Continue without auth token if there's an error + console.warn('Could not get auth token for WebSocket connection:', error) + } + return !requests || params.has('token') + } + /** * Creates and connects a WebSocket for realtime updates * @param {boolean} isReconnect If the socket is connection is a reconnect attempt @@ -876,24 +906,7 @@ export class ComfyApi extends EventTarget { params.set('clientId', existingSession) } - // Get auth token and set cloud params if available - // Uses workspace token (if enabled) or Firebase token - if (isCloud) { - try { - const authStore = await this.getAuthStore() - const authToken = await authStore?.getAuthToken() - if (authToken) { - params.set('token', authToken) - } - } catch (error) { - void trackWsTokenUnavailable() - // Continue without auth token if there's an error - console.warn( - 'Could not get auth token for WebSocket connection:', - error - ) - } - } + if (isCloud && !(await this.addSocketAuth(params))) return const protocol = window.location.protocol === 'https:' ? 'wss' : 'ws' const baseUrl = `${protocol}://${this.api_host}${this.api_base}/ws` @@ -1118,16 +1131,29 @@ export class ComfyApi extends EventTarget { * events over a handshake that was authenticated as that account. */ async resetSocket(): Promise { - const previous = this.socket - // Detach before closing so the previous socket's close handler sees it is - // no longer the active socket and does not start a competing reconnect. - this.socket = null // Clear every handshake identity source: createSocket() reads the client id // from window.name (mirrored in session storage), not this.clientId, so the // next connect must not inherit the prior account's id. this.clientId = undefined window.name = '' sessionStorage.removeItem('clientId') + await this.replaceSocket() + } + + /** + * Re-handshakes the socket for the same account, keeping its client id, so + * a new web session workspace takes effect. Does nothing before init(). + */ + async reconnectSocket(): Promise { + if (this.socketGeneration === 0) return + await this.replaceSocket() + } + + private async replaceSocket(): Promise { + const previous = this.socket + // Detach before closing so the previous socket's close handler sees it is + // no longer the active socket and does not start a competing reconnect. + this.socket = null if (previous && previous.readyState !== WebSocket.CLOSED) { try { previous.close() From bbd56b64467dc693459c1d6133fee8e20241d52f Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Fri, 25 Sep 2026 11:45:24 -0400 Subject: [PATCH 20/30] fix(cloud): send the workspace on a session media fetch only in the header fetchApi already names the workspace in X-Comfy-Workspace-ID, so its URL is no longer scoped; the query parameter is for tags that load without headers. --- src/platform/auth/webSessionFlagOn.test.ts | 17 +++++++++++++++++ src/scripts/api.ts | 16 ++++++++++------ 2 files changed, 27 insertions(+), 6 deletions(-) diff --git a/src/platform/auth/webSessionFlagOn.test.ts b/src/platform/auth/webSessionFlagOn.test.ts index 9b0b556c410..387162eaa4c 100644 --- a/src/platform/auth/webSessionFlagOn.test.ts +++ b/src/platform/auth/webSessionFlagOn.test.ts @@ -653,6 +653,23 @@ describe('live updates and media on the shared web session', () => { } ) + it('a media fetch names the team workspace in the header only', async () => { + const ingest = await bootOnSession() + await useWorkspaceAuthStore().switchWorkspace('ws-team') + ingest.requests.length = 0 + + await api.fetchApi('/view?filename=a.png') + + const [url] = vi.mocked(fetch).mock.calls.at(-1) ?? [] + expect(String(url)).toBe('/api/view?filename=a.png') + expect(ingest.requests).toEqual([ + sessionRequest('GET', '/api/view', { + 'x-comfy-workspace-id': 'ws-team', + 'comfy-user': '' + }) + ]) + }) + it('a server close while signed in reconnects on the session', async () => { await bootWithSocket() await useWorkspaceAuthStore().switchWorkspace('ws-team') diff --git a/src/scripts/api.ts b/src/scripts/api.ts index 5b2b443c607..d6e006b5a69 100644 --- a/src/scripts/api.ts +++ b/src/scripts/api.ts @@ -520,11 +520,15 @@ export class ComfyApi extends EventTarget { apiURL(route: string): string { const requests = webSessionRequests() - const scoped = requests - ? scopeMediaRoute(route, requests.workspaceId()) - : route - if (scoped.startsWith('/api')) return this.api_base + scoped - return this.api_base + '/api' + scoped + return this.unscopedApiURL( + requests ? scopeMediaRoute(route, requests.workspaceId()) : route + ) + } + + /** For requests whose headers already name the workspace. */ + private unscopedApiURL(route: string): string { + if (route.startsWith('/api')) return this.api_base + route + return this.api_base + '/api' + route } fileURL(route: string): string { @@ -693,7 +697,7 @@ export class ComfyApi extends EventTarget { signal } const response = sendOnWebSession - ? sendOnWebSession(this.apiURL(route), init) + ? sendOnWebSession(this.unscopedApiURL(route), init) : fetchWithUnifiedRemint( this.apiURL(route), init, From 8f31e90435703d25cd867e9d7a8cd6b95ca0e0d4 Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Fri, 25 Sep 2026 16:21:39 -0400 Subject: [PATCH 21/30] fix(account-core): a signed-out tab adopts only a sibling's sign-in Shared heartbeat messages now say why they were sent. A tab that signed out ignores a sibling's heartbeat answer, which could predate the sign-out, and follows only a sibling's sign-in. A revocation is reported as a remote sign-out only by the tab whose own read saw it. --- .../core/webSessionIdentity.lifecycle.test.ts | 60 ++++++++++++-- .../src/core/webSessionIdentity.ts | 83 ++++++++++++++----- 2 files changed, 117 insertions(+), 26 deletions(-) diff --git a/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts b/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts index d98f0e67e5e..00c8e04fd09 100644 --- a/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts +++ b/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts @@ -13,7 +13,8 @@ import type { VisibilityPort, WebSessionIdentityOptions, WebSessionIdentityState, - WebSessionIdentityTransition + WebSessionIdentityTransition, + WebSessionSharedMessage } from './webSessionIdentity.js' import { createWebSessionIdentity, @@ -78,7 +79,7 @@ function createFakeSiteBus() { const waiters: { onAcquired: () => void }[] = [] const subscribers: { tab: object; callback: (message: unknown) => void }[] = [] - return (): CrossTabRefreshPort => { + return (): CrossTabRefreshPort => { const tab = {} return { requestLeadership: (_key, onAcquired) => { @@ -124,7 +125,7 @@ function openTab({ fetchImpl = endpoint.fetch }: { endpoint: FakeWebSessionEndpoint - site?: () => CrossTabRefreshPort + site?: () => CrossTabRefreshPort visible?: boolean remembered?: string | null fetchImpl?: typeof fetch @@ -252,9 +253,8 @@ describe('tabs of one site', () => { await settle() site().publishCredential('any', { - status: 'error', - code: 'NO_SESSION', - retryable: false + from: 'heartbeat', + result: { status: 'error', code: 'NO_SESSION', retryable: false } }) await settle() @@ -275,6 +275,53 @@ describe('tabs of one site', () => { 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([]) }) }) @@ -476,6 +523,7 @@ describe('a heartbeat answer while signed in', () => { expect( transitionWebSessionIdentity(SIGNED_IN, { type: 'session_observed', + from: 'this_tab', result, rememberedUserId: remembered }) diff --git a/packages/account-core/src/core/webSessionIdentity.ts b/packages/account-core/src/core/webSessionIdentity.ts index d9c2cdced41..8f033e72421 100644 --- a/packages/account-core/src/core/webSessionIdentity.ts +++ b/packages/account-core/src/core/webSessionIdentity.ts @@ -60,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' } | { @@ -72,6 +79,7 @@ export type WebSessionIdentityEvent = /** 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 } @@ -209,7 +217,8 @@ function observeWhileSignedIn( state: Extract, result: WebSessionResult, rememberedUserId: string | null, - restored: boolean + restored: boolean, + ownRead: boolean ): WebSessionIdentityTransition { if (result.status === 'ok') { return replaceSession( @@ -220,10 +229,12 @@ function observeWhileSignedIn( } if (result.retryable) return { state, effects: [] } if (result.code === 'SESSION_REVOKED') { - return leaveAccount('revoked', [ - signOutLocally, - { type: 'report_signed_out_remotely' } - ]) + return leaveAccount( + 'revoked', + ownRead + ? [signOutLocally, { type: 'report_signed_out_remotely' }] + : [signOutLocally] + ) } if (restored) return leaveAccount('restore_failed') if (!isNoLiveSession(result)) return { state, effects: [] } @@ -240,12 +251,20 @@ function transitionSignedIn( ): WebSessionIdentityTransition { switch (event.type) { case 'session_observed': + return observeWhileSignedIn( + state, + event.result, + event.rememberedUserId, + false, + event.from === 'this_tab' + ) case 'restore_answered': return observeWhileSignedIn( state, event.result, event.rememberedUserId, - event.type === 'restore_answered' + true, + true ) case 'session_created': return replaceSession(state.session, event.session) @@ -317,7 +336,8 @@ function transitionSettling( case 'session_observed': { const { result } = event const adoptable = - state.phase === 'signed_out' || state.phase === 'retry_wait' + 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 }, @@ -370,7 +390,7 @@ export interface VisibilityPort { export interface WebSessionHeartbeatOptions { readonly visibility: VisibilityPort /** Without it every tab reads for itself. */ - readonly crossTab?: CrossTabRefreshPort + readonly crossTab?: CrossTabRefreshPort readonly intervalMs?: number } @@ -433,6 +453,19 @@ const zSharedResult = z.discriminatedUnion('status', [ }) ]) +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', @@ -493,13 +526,17 @@ function createAccountIdentity( syncLeadership() } - function publish(result: WebSessionResult): void { - heartbeat?.crossTab?.publishCredential(HEARTBEAT_KEY, result) + 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' | 'session_observed', + answered: Answered, request: () => Promise ): Promise { const result = await request() @@ -509,23 +546,29 @@ function createAccountIdentity( ) 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 - void answer(started, 'session_observed', async () => { + 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(result) + if (shared && started === epoch) publish('heartbeat', result) return result }) } function adopt(message: unknown): void { - const parsed = zSharedResult.safeParse(message) + const parsed = zSharedMessage.safeParse(message) if (!parsed.success) return - void answer(epoch, 'session_observed', async () => parsed.data) + const { from, result } = parsed.data + const observed = { + type: 'session_observed', + from: `sibling_${from}` + } as const + void answer(epoch, observed, async () => result) } function wantsBeat(): boolean { @@ -589,7 +632,7 @@ function createAccountIdentity( 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 }) ) } @@ -597,7 +640,7 @@ function createAccountIdentity( function run(effect: WebSessionIdentityEffect): void { switch (effect.type) { case 'read': - void answer(epoch, 'read_answered', () => + void answer(epoch, { type: 'read_answered' }, () => readWebSession(options.session) ) return @@ -662,13 +705,13 @@ function createAccountIdentity( const result = await createWebSession(options.session, getProof) if (result.status !== 'ok') return result dispatch({ type: 'session_created', session: result.session }) - publish(result) + publish('sign_in', result) return result }, signOut: async () => { dispatch({ type: 'sign_out_requested' }) const result = await deleteWebSession(options.session) - if (result.status === 'ok') publish(revoked) + if (result.status === 'ok') publish('sign_out', revoked) return result }, getEpoch: () => epoch, From bd081efb0b96f94c890928538533b9bdaadf9ef0 Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Fri, 25 Sep 2026 16:23:22 -0400 Subject: [PATCH 22/30] fix(cloud): type the web session cross-tab port with the shared message --- src/platform/auth/session/cloudWebSessionStore.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/platform/auth/session/cloudWebSessionStore.ts b/src/platform/auth/session/cloudWebSessionStore.ts index 36e3dad8818..af32c42a77c 100644 --- a/src/platform/auth/session/cloudWebSessionStore.ts +++ b/src/platform/auth/session/cloudWebSessionStore.ts @@ -5,9 +5,9 @@ import { onScopeDispose } from 'vue' import type { WebSessionAccountChange, WebSessionIdentity, - WebSessionIdentityState + WebSessionIdentityState, + WebSessionSharedMessage } from '@comfyorg/account-core/webSessionIdentity' -import type { WebSessionResult } from '@comfyorg/account-core/webSession' import { createWebSessionIdentity } from '@comfyorg/account-core/webSessionIdentity' import { createWebCrossTabRefreshPort, @@ -59,7 +59,7 @@ function resetForAccountChange(change: WebSessionAccountChange): void { function createCloudIdentity(): WebSessionIdentity { const visibility = createWebVisibilityPort() - const crossTab = createWebCrossTabRefreshPort() + const crossTab = createWebCrossTabRefreshPort() return createWebSessionIdentity({ session: { apiBaseUrl: api.apiURL(''), From e5b476ebb44ab8bc0af64fd8fdd8483e7ad08733 Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Sat, 26 Sep 2026 08:47:42 -0400 Subject: [PATCH 23/30] test(account-core): drop duplicated lines in the pack smoke consumer --- packages/account-core/scripts/smokePack.ts | 2 -- 1 file changed, 2 deletions(-) diff --git a/packages/account-core/scripts/smokePack.ts b/packages/account-core/scripts/smokePack.ts index cf9c2c85f5e..1d4d9f5f039 100644 --- a/packages/account-core/scripts/smokePack.ts +++ b/packages/account-core/scripts/smokePack.ts @@ -269,8 +269,6 @@ export const values = { createSessionTokenMint, createWebSessionIdentity, createSessionBillingTransport, - createFirebaseIdentity, - resolveFirebaseIdentity, resolveStripePublishableKey, createWebCrossTabRefreshPort, createTestIdentity, From 3fc326b17ee7645479cf2cfbb6f0b8c452df6784 Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Sat, 26 Sep 2026 08:48:28 -0400 Subject: [PATCH 24/30] test(account-core): drop duplicated lines in the pack smoke consumer --- packages/account-core/scripts/smokePack.ts | 4 ---- 1 file changed, 4 deletions(-) diff --git a/packages/account-core/scripts/smokePack.ts b/packages/account-core/scripts/smokePack.ts index 4fd44fd731b..1d4d9f5f039 100644 --- a/packages/account-core/scripts/smokePack.ts +++ b/packages/account-core/scripts/smokePack.ts @@ -209,8 +209,6 @@ import type { SessionTokenResult } from '@comfyorg/account-core/sessionTokenMint import { createSessionTokenMint } from '@comfyorg/account-core/sessionTokenMint' import type { WebSessionIdentityState } from '@comfyorg/account-core/webSessionIdentity' import { createWebSessionIdentity } from '@comfyorg/account-core/webSessionIdentity' -import type { RequestAuthorization } from '@comfyorg/account-core/requestAuth' -import { createRequestAuthorizer } from '@comfyorg/account-core/requestAuth' import type { BillingErrorCode } from '@comfyorg/account-core/billing' import { createSessionBillingTransport } from '@comfyorg/account-core/billing' import type { @@ -270,7 +268,6 @@ export const values = { createRequestAuthorizer, createSessionTokenMint, createWebSessionIdentity, - createRequestAuthorizer, createSessionBillingTransport, resolveStripePublishableKey, createWebCrossTabRefreshPort, @@ -307,7 +304,6 @@ export interface Types { requestAuth: RequestAuthorization sessionTokenMint: SessionTokenResult webSessionIdentity: WebSessionIdentityState - requestAuth: RequestAuthorization billing: BillingErrorCode firebase: FirebaseIdentityAppConfig firebaseResolve: ResolveFirebaseIdentityOptions From 5f76d6d3d313dd2771714bb945ac2aeac5cfe218 Mon Sep 17 00:00:00 2001 From: GitHub Action Date: Sat, 26 Sep 2026 12:51:44 +0000 Subject: [PATCH 25/30] [automated] Apply ESLint and Oxfmt fixes --- packages/account-core/package.json | 5 ----- 1 file changed, 5 deletions(-) diff --git a/packages/account-core/package.json b/packages/account-core/package.json index 86c9198b47f..1a7a6b5f9da 100644 --- a/packages/account-core/package.json +++ b/packages/account-core/package.json @@ -28,7 +28,6 @@ "./requestAuth": "./src/core/requestAuth.ts", "./sessionTokenMint": "./src/core/sessionTokenMint.ts", "./webSessionIdentity": "./src/core/webSessionIdentity.ts", - "./requestAuth": "./src/core/requestAuth.ts", "./billing": "./src/core/billing/index.ts", "./firebase": "./src/firebase/index.ts", "./web": "./src/web/crossTabRefresh.ts", @@ -71,10 +70,6 @@ "types": "./dist/core/webSessionIdentity.d.ts", "import": "./dist/core/webSessionIdentity.js" }, - "./requestAuth": { - "types": "./dist/core/requestAuth.d.ts", - "import": "./dist/core/requestAuth.js" - }, "./billing": { "types": "./dist/core/billing/index.d.ts", "import": "./dist/core/billing/index.js" From 1d2145d3cd129967577ba69970f20be850fbf033 Mon Sep 17 00:00:00 2001 From: GitHub Action Date: Sat, 26 Sep 2026 12:51:56 +0000 Subject: [PATCH 26/30] [automated] Apply ESLint and Oxfmt fixes --- packages/account-core/package.json | 5 ----- 1 file changed, 5 deletions(-) diff --git a/packages/account-core/package.json b/packages/account-core/package.json index 86c9198b47f..1a7a6b5f9da 100644 --- a/packages/account-core/package.json +++ b/packages/account-core/package.json @@ -28,7 +28,6 @@ "./requestAuth": "./src/core/requestAuth.ts", "./sessionTokenMint": "./src/core/sessionTokenMint.ts", "./webSessionIdentity": "./src/core/webSessionIdentity.ts", - "./requestAuth": "./src/core/requestAuth.ts", "./billing": "./src/core/billing/index.ts", "./firebase": "./src/firebase/index.ts", "./web": "./src/web/crossTabRefresh.ts", @@ -71,10 +70,6 @@ "types": "./dist/core/webSessionIdentity.d.ts", "import": "./dist/core/webSessionIdentity.js" }, - "./requestAuth": { - "types": "./dist/core/requestAuth.d.ts", - "import": "./dist/core/requestAuth.js" - }, "./billing": { "types": "./dist/core/billing/index.d.ts", "import": "./dist/core/billing/index.js" From 566d14f3e7293eb2e987939300fee2677febc3ea Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Mon, 28 Sep 2026 17:59:51 -0400 Subject: [PATCH 27/30] fix(workspace): keep the current workspace when re-entering it on the session fails --- src/platform/auth/webSessionFlagOn.test.ts | 37 ++++++++++++++++++- .../workspace/stores/workspaceAuthStore.ts | 3 +- 2 files changed, 38 insertions(+), 2 deletions(-) diff --git a/src/platform/auth/webSessionFlagOn.test.ts b/src/platform/auth/webSessionFlagOn.test.ts index 6c021246194..bc790178d0b 100644 --- a/src/platform/auth/webSessionFlagOn.test.ts +++ b/src/platform/auth/webSessionFlagOn.test.ts @@ -354,7 +354,8 @@ function installIngest() { userId: 'user-a', csrfToken: 'csrf-1', refusals: [] as string[], - requests: [] as ApiRequest[] + requests: [] as ApiRequest[], + currentWorkspaceDown: undefined as (() => Response) | undefined } const respond = ({ path, headers }: ApiRequest): Response => { @@ -365,6 +366,7 @@ function installIngest() { }) } if (path === '/api/workspaces/current') { + if (ingest.currentWorkspaceDown) return ingest.currentWorkspaceDown() return currentWorkspaceResponse(headers['x-comfy-workspace-id']) } const code = ingest.refusals.shift() @@ -536,4 +538,37 @@ describe('cloud API requests on the shared web session', () => { ) expect(workspaceAuth.currentWorkspace).toBeNull() }) + + it.for([ + { + name: 'a 503', + down: () => jsonResponse({ code: 'internal', message: 'down' }, 503) + }, + { + name: 'a network failure', + down: () => { + throw new TypeError('Failed to fetch') + } + } + ])( + 're-entering the current workspace keeps it through $name', + async ({ down }) => { + const ingest = await bootOnSession() + const workspaceAuth = useWorkspaceAuthStore() + await workspaceAuth.switchWorkspace('ws-team') + ingest.currentWorkspaceDown = down + + await expect(workspaceAuth.switchWorkspace('ws-team')).rejects.toThrow() + ingest.requests.length = 0 + await api.fetchApi('/queue') + + expect(workspaceAuth.currentWorkspace?.id).toBe('ws-team') + expect(ingest.requests).toEqual([ + sessionRequest('GET', '/api/queue', { + 'x-comfy-workspace-id': 'ws-team', + 'comfy-user': '' + }) + ]) + } + ) }) diff --git a/src/platform/workspace/stores/workspaceAuthStore.ts b/src/platform/workspace/stores/workspaceAuthStore.ts index aaa2b8be969..2312ea2d16c 100644 --- a/src/platform/workspace/stores/workspaceAuthStore.ts +++ b/src/platform/workspace/stores/workspaceAuthStore.ts @@ -207,7 +207,8 @@ export const useWorkspaceAuthStore = defineStore('workspaceAuth', () => { const scope = await requests.scope() if (!scope) return switchTokenWorkspace(workspaceId) - currentWorkspace.value = null + if (currentWorkspace.value?.id !== workspaceId) + currentWorkspace.value = null const response = await requests.send( workspaceApiUrl('/workspaces/current'), { method: 'GET', cache: 'no-store' }, From a7b31b492a68d9899112cf12ecaf1b6cd7e8400d Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Mon, 28 Sep 2026 18:01:16 -0400 Subject: [PATCH 28/30] test(cloud): a request sent on the web session reports as authenticated --- src/platform/auth/webSessionFlagOn.test.ts | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/platform/auth/webSessionFlagOn.test.ts b/src/platform/auth/webSessionFlagOn.test.ts index bc790178d0b..e13b6b80311 100644 --- a/src/platform/auth/webSessionFlagOn.test.ts +++ b/src/platform/auth/webSessionFlagOn.test.ts @@ -529,6 +529,15 @@ describe('cloud API requests on the shared web session', () => { ]) }) + it('reports a request sent on the session as authenticated', async () => { + await bootOnSession() + const onAuthHeader = vi.fn() + + await api.fetchApi('/queue', { onAuthHeader }) + + expect(onAuthHeader).toHaveBeenCalledExactlyOnceWith(true) + }) + it('refuses a switch into a workspace the session cannot enter', async () => { await bootOnSession() const workspaceAuth = useWorkspaceAuthStore() From 9b3e71e868a4cf73d9f7d3746cf06a5458db80a3 Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Mon, 28 Sep 2026 22:03:37 -0400 Subject: [PATCH 29/30] test(account-core): list requestAuth once in the inert-import check --- packages/account-core/src/webSessionInertImport.test.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/packages/account-core/src/webSessionInertImport.test.ts b/packages/account-core/src/webSessionInertImport.test.ts index aa2a3450e31..f789c20de9e 100644 --- a/packages/account-core/src/webSessionInertImport.test.ts +++ b/packages/account-core/src/webSessionInertImport.test.ts @@ -11,7 +11,6 @@ it.for([ '@comfyorg/account-core/sessionTokenMint', '@comfyorg/account-core/webSessionIdentity', '@comfyorg/account-core/web', - '@comfyorg/account-core/requestAuth', '@comfyorg/account-core/testing' ])( 'importing %s starts no timer, listener, channel, or request', From 00417231cbb561c544ed18577627aab5d315210d Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Mon, 28 Sep 2026 23:03:53 -0400 Subject: [PATCH 30/30] test(cloud): assert sign-out closes the session socket before the server close --- src/platform/auth/webSessionFlagOn.test.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/platform/auth/webSessionFlagOn.test.ts b/src/platform/auth/webSessionFlagOn.test.ts index 12d7a53fab1..0398834ecc5 100644 --- a/src/platform/auth/webSessionFlagOn.test.ts +++ b/src/platform/auth/webSessionFlagOn.test.ts @@ -740,10 +740,11 @@ describe('live updates and media on the shared web session', () => { assert.instanceOf(sessionSocket, FakeSocket) await useAuthStore().logout() + expect(sessionSocket.readyState).toBe(FakeSocket.CLOSED) + sessionSocket.closeFromServer() await vi.advanceTimersByTimeAsync(1_000) - expect(sessionSocket.readyState).toBe(FakeSocket.CLOSED) expect(FakeSocket.created).toEqual([sessionSocket]) expect(api.socket).toBeNull() })