From 37391a88f9e25f86c6f15964c5cf0a8b7e36dc9f Mon Sep 17 00:00:00 2001 From: PabloWiedemann Date: Tue, 20 Oct 2026 10:41:51 -0700 Subject: [PATCH 1/5] feat(auth): use shared account sessions for Desktop login --- .../comfyDesktopBridge.d.ts | 1 + src/main/auth/desktopLoginCode/client.ts | 1 + src/main/cloud/accountSession.test.ts | 137 ++++++++++++++ src/main/cloud/accountSession.ts | 174 ++++++++++++++++++ src/main/cloud/session.test.ts | 134 +++++++++----- src/main/cloud/session.ts | 126 +++++++++++-- src/main/cloud/tokenStore.test.ts | 19 ++ src/main/cloud/tokenStore.ts | 9 +- src/main/cloud/types.ts | 3 +- src/main/lib/embeddedSession.ts | 16 ++ .../registerEmbeddedSessionHandlers.test.ts | 4 +- .../ipc/registerEmbeddedSessionHandlers.ts | 5 + src/preload/comfyPreload.ts | 2 + src/types/comfyDesktopBridge.ts | 1 + 14 files changed, 562 insertions(+), 70 deletions(-) create mode 100644 src/main/cloud/accountSession.test.ts create mode 100644 src/main/cloud/accountSession.ts diff --git a/packages/comfyui-desktop-bridge-types/comfyDesktopBridge.d.ts b/packages/comfyui-desktop-bridge-types/comfyDesktopBridge.d.ts index 8aa95ab0d..ba40fd280 100644 --- a/packages/comfyui-desktop-bridge-types/comfyDesktopBridge.d.ts +++ b/packages/comfyui-desktop-bridge-types/comfyDesktopBridge.d.ts @@ -130,6 +130,7 @@ export interface ComfyDesktop2AuthBridge { * is scoped to; null when signed out, disabled, or the scope is missing, * malformed or different. The refresh token never leaves Desktop. */ getWorkspaceToken(workspaceId: string): Promise + getPartnerNodeToken?(workspaceId: string): Promise /** Runs Desktop's browser sign-in and resolves with the resulting state. */ requestSignIn(): Promise /** Signs Desktop out of its account (every view follows) and resolves with diff --git a/src/main/auth/desktopLoginCode/client.ts b/src/main/auth/desktopLoginCode/client.ts index 8f1020a4c..be61ab53a 100644 --- a/src/main/auth/desktopLoginCode/client.ts +++ b/src/main/auth/desktopLoginCode/client.ts @@ -37,6 +37,7 @@ export class DesktopLoginCodeError extends Error { } export interface CreateDesktopLoginCodeRequest { + session_type?: 'account' /** Telemetry machine hash; included only when consent is granted. */ installation_id?: string platform: string diff --git a/src/main/cloud/accountSession.test.ts b/src/main/cloud/accountSession.test.ts new file mode 100644 index 000000000..341c1a51e --- /dev/null +++ b/src/main/cloud/accountSession.test.ts @@ -0,0 +1,137 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' + +const mocks = vi.hoisted(() => ({ fetch: vi.fn(), open: vi.fn() })) +vi.mock('electron', () => ({ + app: { getVersion: () => '1.0.0' }, + net: { fetch: mocks.fetch }, + shell: { openExternal: mocks.open } +})) + +import { mintWorkspaceToken, signInAccount } from './accountSession' + +const ROOT = 'comfy-session-secret' +const CODE = `dls_${'a'.repeat(43)}` +const EXPIRES = '2030-01-01T00:00:00.000Z' + +function respond(data: unknown, status = 200): Response { + return Response.json(data, { status }) +} + +beforeEach(() => { + vi.useFakeTimers() + mocks.fetch.mockReset() + mocks.open.mockReset().mockResolvedValue(undefined) +}) + +afterEach(() => { + vi.useRealTimers() + vi.restoreAllMocks() +}) + +describe('native account login', () => { + it('hands off a proof-bound code and keeps the account credential out of the browser URL', async () => { + mocks.fetch + .mockResolvedValueOnce(respond({ code: CODE, expires_in: 300, poll_interval: 1 }, 201)) + .mockResolvedValueOnce(respond({ status: 'pending' })) + .mockResolvedValueOnce(respond({ status: 'complete', session_token: ROOT })) + .mockResolvedValueOnce(respond({ token: 'workspace-token', expires_at: EXPIRES })) + const onUrl = vi.fn() + const login = signInAccount(onUrl, new AbortController().signal) + await vi.advanceTimersByTimeAsync(2000) + await expect(login).resolves.toEqual({ + accessToken: 'workspace-token', + sessionToken: ROOT, + expiresAt: Date.parse(EXPIRES) + }) + const url = new URL(onUrl.mock.calls[0]![0]) + expect(url.searchParams.get('desktop_login_code')).toBe(CODE) + expect(url.href).not.toContain(ROOT) + const createBody = JSON.parse(mocks.fetch.mock.calls[0]![1].body) + expect(createBody).toMatchObject({ session_type: 'account' }) + const exchangeBody = JSON.parse(mocks.fetch.mock.calls[1]![1].body) + expect(exchangeBody.code_verifier).not.toBe(createBody.code_challenge) + expect(exchangeBody.code).toBe(CODE) + expect(mocks.fetch.mock.calls[3]![1]).toMatchObject({ + credentials: 'omit', + redirect: 'error', + headers: { Authorization: `Bearer ${ROOT}` }, + body: '{}' + }) + }) + + it('refuses an older server before opening a Firebase-only handoff', async () => { + mocks.fetch.mockResolvedValue( + respond({ code: 'dlc_old', expires_in: 300, poll_interval: 1 }, 201) + ) + await expect(signInAccount(vi.fn(), new AbortController().signal)).rejects.toMatchObject({ + reason: 'server_error' + }) + expect(mocks.open).not.toHaveBeenCalled() + }) + + it('cancels even when the system browser never reports that it opened', async () => { + mocks.fetch.mockResolvedValue(respond({ code: CODE, expires_in: 300, poll_interval: 1 }, 201)) + mocks.open.mockReturnValue(new Promise(() => {})) + const abort = new AbortController() + const login = signInAccount(vi.fn(), abort.signal) + const result = expect(login).rejects.toMatchObject({ name: 'AbortError' }) + await vi.advanceTimersByTimeAsync(0) + abort.abort() + await result + }) + + it('reports expiry while awaiting the browser without changing caller cancellation', async () => { + const expiry = new AbortController() + vi.spyOn(AbortSignal, 'timeout').mockReturnValue(expiry.signal) + mocks.fetch.mockResolvedValue(respond({ code: CODE, expires_in: 300, poll_interval: 1 }, 201)) + mocks.open.mockReturnValue(new Promise(() => {})) + const result = expect( + signInAccount(vi.fn(), new AbortController().signal) + ).rejects.toMatchObject({ reason: 'timeout' }) + await vi.advanceTimersByTimeAsync(0) + expiry.abort(new DOMException('expired', 'TimeoutError')) + await result + }) + + it('revokes a handed-off session if the first workspace request fails', async () => { + mocks.fetch + .mockResolvedValueOnce(respond({ code: CODE, expires_in: 300, poll_interval: 1 }, 201)) + .mockResolvedValueOnce(respond({ status: 'complete', session_token: ROOT })) + .mockResolvedValueOnce(respond({ code: 'FORBIDDEN' }, 403)) + .mockResolvedValueOnce(new Response(null, { status: 204 })) + .mockResolvedValueOnce(respond({ success: true })) + const result = expect( + signInAccount(vi.fn(), new AbortController().signal) + ).rejects.toMatchObject({ httpStatus: 403 }) + await vi.advanceTimersByTimeAsync(1000) + await result + expect(mocks.fetch.mock.calls[3]![0]).toMatch(/\/auth\/token\/revoke$/) + expect(mocks.fetch.mock.calls[4]![0]).toMatch(/\/auth\/session$/) + expect(mocks.fetch.mock.calls[4]![1]).toMatchObject({ + method: 'DELETE', + headers: { Authorization: `Bearer ${ROOT}` } + }) + }) +}) + +describe('workspace mint', () => { + it('asks the backend for the selected workspace using the account credential', async () => { + mocks.fetch.mockResolvedValue(respond({ token: 'scoped-token', expires_at: EXPIRES })) + await expect(mintWorkspaceToken(ROOT, 'w-team')).resolves.toMatchObject({ + accessToken: 'scoped-token', + sessionToken: ROOT + }) + expect(mocks.fetch.mock.calls[0]![1]).toMatchObject({ + body: JSON.stringify({ workspace_id: 'w-team' }), + credentials: 'omit' + }) + }) + + it.each([{}, { token: 'token', expires_at: 'invalid' }])( + 'rejects an invalid workspace token response', + async (body) => { + mocks.fetch.mockResolvedValue(respond(body)) + await expect(mintWorkspaceToken(ROOT)).rejects.toMatchObject({ reason: 'server_error' }) + } + ) +}) diff --git a/src/main/cloud/accountSession.ts b/src/main/cloud/accountSession.ts new file mode 100644 index 000000000..9ec810f37 --- /dev/null +++ b/src/main/cloud/accountSession.ts @@ -0,0 +1,174 @@ +import { app, net } from 'electron' + +import { + createDesktopLoginCode, + DesktopLoginCodeError, + type DesktopLoginCodeGrant, + postJson +} from '../auth/desktopLoginCode/client' +import { abortable, abortableSleep } from '../auth/firebaseBridge/flowControl' +import { CLOUD_CONFIG } from './config' +import { openAuthorizePage } from './oauth' +import { codeChallengeFromVerifier, generateCodeVerifier } from './pkce' +import { SignInFailure } from './signInFailure' +import type { AuthTokens } from './types' + +export async function signInAccount( + onAuthorizeUrl: (url: string) => void, + signal: AbortSignal +): Promise { + const verifier = generateCodeVerifier() + const grant = await createDesktopLoginCode( + CLOUD_CONFIG.issuer, + { + platform: process.platform, + app_version: app.getVersion(), + code_challenge: codeChallengeFromVerifier(verifier), + session_type: 'account' + }, + { signal } + ) + if (!grant.code.startsWith('dls_')) { + throw new SignInFailure('Account login is unavailable on this server', 'server_error') + } + const url = new URL('/cloud/login', CLOUD_CONFIG.issuer) + url.searchParams.set('desktop_login_code', grant.code) + onAuthorizeUrl(url.href) + const expiry = AbortSignal.timeout(grant.expires_in * 1000) + const deadline = AbortSignal.any([signal, expiry]) + try { + return await pollForAccountSession(grant, verifier, url.href, deadline) + } catch (error) { + if (expiry.aborted && !signal.aborted) { + throw new SignInFailure('Sign-in timed out', 'timeout') + } + throw error + } +} + +async function pollForAccountSession( + grant: DesktopLoginCodeGrant, + verifier: string, + url: string, + deadline: AbortSignal +): Promise { + await abortable(openAuthorizePage(url), deadline) + while (!deadline.aborted) { + await abortableSleep(grant.poll_interval * 1000, deadline) + let response + try { + response = await postJson( + `${CLOUD_CONFIG.apiBase}/auth/desktop-login-codes/exchange`, + { code: grant.code, code_verifier: verifier }, + { signal: deadline } + ) + } catch (error) { + if (error instanceof DesktopLoginCodeError && error.retryable) continue + throw error + } + if (response.status >= 500 || response.status === 429 || response.status === 408) continue + if (!response.ok) { + throw new SignInFailure('Restart sign-in to continue', 'server_error', { + httpStatus: response.status + }) + } + const data = response.data + if (data && typeof data === 'object' && 'status' in data && data.status === 'pending') continue + if ( + !data || + typeof data !== 'object' || + !('status' in data) || + data.status !== 'complete' || + !('session_token' in data) || + typeof data.session_token !== 'string' || + !data.session_token.startsWith('comfy-session-') + ) { + throw new SignInFailure('Invalid account login response', 'server_error') + } + try { + return await mintWorkspaceToken(data.session_token, undefined, deadline) + } catch (error) { + await revokeAccountSession(data.session_token).catch(() => {}) + throw error + } + } + throw new SignInFailure('Sign-in timed out', 'timeout') +} + +async function sessionRequest( + sessionToken: string, + path: string, + method: string, + body?: unknown, + signal?: AbortSignal +): Promise { + const timeout = AbortSignal.timeout(15_000) + const response = await net.fetch(`${CLOUD_CONFIG.apiBase}${path}`, { + method, + headers: { + Authorization: `Bearer ${sessionToken}`, + 'Content-Type': 'application/json' + }, + credentials: 'omit', + redirect: 'error', + signal: signal ? AbortSignal.any([signal, timeout]) : timeout, + ...(body === undefined ? {} : { body: JSON.stringify(body) }) + }) + if (!response.ok) { + throw new SignInFailure('Account session request failed', 'server_error', { + httpStatus: response.status + }) + } + return response.status === 204 ? undefined : response.json() +} + +export async function mintWorkspaceToken( + sessionToken: string, + workspaceId?: string, + signal?: AbortSignal +): Promise { + const data = await sessionRequest( + sessionToken, + '/auth/token', + 'POST', + { workspace_id: workspaceId }, + signal + ) + return mintedTokens(data, sessionToken) +} + +function mintedTokens(data: unknown, sessionToken: string): AuthTokens { + if ( + !data || + typeof data !== 'object' || + !('token' in data) || + typeof data.token !== 'string' || + data.token.length === 0 || + !('expires_at' in data) || + typeof data.expires_at !== 'string' || + !Number.isFinite(Date.parse(data.expires_at)) || + Date.parse(data.expires_at) <= Date.now() + ) { + throw new SignInFailure('Invalid workspace token response', 'server_error') + } + return { accessToken: data.token, expiresAt: Date.parse(data.expires_at), sessionToken } +} + +export async function mintPartnerNodeToken( + sessionToken: string, + workspaceId: string +): Promise { + const data = await sessionRequest(sessionToken, '/auth/token', 'POST', { + workspace_id: workspaceId, + resource: 'partner-node' + }) + return mintedTokens(data, sessionToken) +} + +export async function revokeAccountSession(sessionToken: string): Promise { + try { + await sessionRequest(sessionToken, '/auth/token/revoke', 'POST') + } finally { + await sessionRequest(sessionToken, '/auth/session', 'DELETE') + } +} diff --git a/src/main/cloud/session.test.ts b/src/main/cloud/session.test.ts index 0079c27e0..a7c025512 100644 --- a/src/main/cloud/session.test.ts +++ b/src/main/cloud/session.test.ts @@ -2,10 +2,15 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' vi.mock('./oauth', () => ({ - signIn: vi.fn(), refresh: vi.fn(), openAuthorizePage: vi.fn(() => Promise.resolve()) })) +vi.mock('./accountSession', () => ({ + signInAccount: vi.fn(), + mintWorkspaceToken: vi.fn(), + mintPartnerNodeToken: vi.fn(), + revokeAccountSession: vi.fn(async () => {}) +})) vi.mock('./tokenStore', () => ({ activateWorkspace: vi.fn(), clearTokens: vi.fn(), @@ -22,7 +27,14 @@ vi.mock('./workspaces', () => ({ })) import { statusFromAccessToken, workspaceIdOf } from './claims' -import { openAuthorizePage, refresh, signIn } from './oauth' +import { openAuthorizePage, refresh } from './oauth' +import { + signInAccount, + mintWorkspaceToken, + mintPartnerNodeToken, + revokeAccountSession +} from './accountSession' +import { SignInFailure } from './signInFailure' import { CloudSession } from './session' import { activateWorkspace, @@ -196,8 +208,8 @@ describe('CloudSession access tokens', () => { describe('CloudSession browser auth', () => { it('single-flights repeated login requests', async () => { - let finishLogin!: (value: Awaited>) => void - mocked(signIn).mockReturnValue( + let finishLogin!: (value: Awaited>) => void + mocked(signInAccount).mockReturnValue( new Promise((resolve) => { finishLogin = resolve }) @@ -207,49 +219,49 @@ describe('CloudSession browser auth', () => { const first = session.login() const second = session.login() const tokens = makeTokens('w1') - finishLogin({ tokens, status: statusFromAccessToken(tokens.accessToken) }) + finishLogin(tokens) await expect(Promise.all([first, second])).resolves.toHaveLength(2) - expect(signIn).toHaveBeenCalledOnce() + expect(signInAccount).toHaveBeenCalledOnce() expect(saveTokens).toHaveBeenCalledExactlyOnceWith(tokens) }) it('reopens the pending sign-in page when login is requested again', async () => { - mocked(signIn).mockImplementation(async (options) => { - options?.onAuthorizeUrl?.('https://cloud.test/authorize?state=s1') + mocked(signInAccount).mockImplementation(async (onAuthorizeUrl) => { + onAuthorizeUrl('https://cloud.test/authorize?state=s1') return new Promise(() => {}) }) const session = new CloudSession() void session.login() - await vi.waitFor(() => expect(signIn).toHaveBeenCalledOnce()) + await vi.waitFor(() => expect(signInAccount).toHaveBeenCalledOnce()) void session.login() - expect(signIn).toHaveBeenCalledOnce() + expect(signInAccount).toHaveBeenCalledOnce() expect(openAuthorizePage).toHaveBeenCalledExactlyOnceWith( 'https://cloud.test/authorize?state=s1' ) }) it('does not reopen a sign-in page after logout', async () => { - mocked(signIn).mockImplementation(async (options) => { - options?.onAuthorizeUrl?.('https://cloud.test/authorize?state=s1') + mocked(signInAccount).mockImplementation(async (onAuthorizeUrl) => { + onAuthorizeUrl('https://cloud.test/authorize?state=s1') return new Promise(() => {}) }) const session = new CloudSession() void session.login() - await vi.waitFor(() => expect(signIn).toHaveBeenCalledOnce()) + await vi.waitFor(() => expect(signInAccount).toHaveBeenCalledOnce()) session.logout() void session.login() - expect(signIn).toHaveBeenCalledTimes(2) + expect(signInAccount).toHaveBeenCalledTimes(2) expect(openAuthorizePage).not.toHaveBeenCalled() }) it('does not persist browser auth that finishes after logout', async () => { - let finishLogin!: (value: Awaited>) => void - mocked(signIn).mockReturnValue( + let finishLogin!: (value: Awaited>) => void + mocked(signInAccount).mockReturnValue( new Promise((resolve) => { finishLogin = resolve }) @@ -259,7 +271,7 @@ describe('CloudSession browser auth', () => { const login = session.login() session.logout() const tokens = makeTokens('w1') - finishLogin({ tokens, status: statusFromAccessToken(tokens.accessToken) }) + finishLogin(tokens) await expect(login).resolves.toEqual({ signedIn: false }) expect(saveTokens).not.toHaveBeenCalled() @@ -279,7 +291,7 @@ describe('CloudSession workspaces', () => { expect(activateWorkspace).toHaveBeenNthCalledWith(1, 'w2') expect(activateWorkspace).toHaveBeenNthCalledWith(2, 'w1') - expect(signIn).not.toHaveBeenCalled() + expect(signInAccount).not.toHaveBeenCalled() }) it('refreshes an expired cached workspace independently before activating it', async () => { @@ -296,7 +308,7 @@ describe('CloudSession workspaces', () => { expect(refresh).toHaveBeenCalledExactlyOnceWith(staleTwo.refreshToken) expect(activateWorkspace).toHaveBeenCalledExactlyOnceWith('w2') - expect(signIn).not.toHaveBeenCalled() + expect(signInAccount).not.toHaveBeenCalled() }) it('uses browser auth when the active workspace can no longer refresh', async () => { @@ -304,52 +316,80 @@ describe('CloudSession workspaces', () => { const authorized = makeTokens('w1', future, '-authorized') cache(stale, true) mocked(refresh).mockRejectedValue(new Error('revoked')) - mocked(signIn).mockResolvedValue({ - tokens: authorized, - status: statusFromAccessToken(authorized.accessToken) - }) + mocked(signInAccount).mockResolvedValue(authorized) await expect(new CloudSession().switchWorkspace('w1')).resolves.toMatchObject({ workspaceId: 'w1' }) expect(refresh).toHaveBeenCalledExactlyOnceWith(stale.refreshToken) - expect(signIn).toHaveBeenCalledExactlyOnceWith({ workspaceId: 'w1' }) + expect(signInAccount).toHaveBeenCalledExactlyOnceWith( + expect.any(Function), + expect.any(AbortSignal) + ) expect(saveTokens).toHaveBeenCalledExactlyOnceWith(authorized) }) - it('uses browser auth for an uncached workspace and rejects a different selection', async () => { - const workspaceOne = makeTokens('w1') + it('keeps the active workspace when the backend refuses another workspace', async () => { + const workspaceOne = { ...makeTokens('w1'), sessionToken: 'comfy-session-root' } cache(workspaceOne, true) - mocked(signIn).mockResolvedValue({ - tokens: workspaceOne, - status: statusFromAccessToken(workspaceOne.accessToken) + mocked(mintWorkspaceToken).mockRejectedValue( + new SignInFailure('denied', 'server_error', { httpStatus: 404 }) + ) + await expect(new CloudSession().switchWorkspace('w2')).rejects.toMatchObject({ + httpStatus: 404 }) + expect(active).toEqual(workspaceOne) + expect(signInAccount).not.toHaveBeenCalled() + }) - await expect(new CloudSession().switchWorkspace('w2')).resolves.toMatchObject({ - workspaceId: 'w1' - }) + it('checks membership on each workspace switch without browser auth', async () => { + const root = 'comfy-session-root' + cache({ ...makeTokens('w1'), sessionToken: root }, true) + mocked(mintWorkspaceToken).mockImplementation(async (_, workspaceId) => ({ + ...makeTokens(workspaceId!), + refreshToken: undefined, + sessionToken: root + })) + const session = new CloudSession() + for (const workspace of ['w2', 'w1', 'w2']) { + await expect(session.switchWorkspace(workspace)).resolves.toMatchObject({ + workspaceId: workspace + }) + expect(mintWorkspaceToken).toHaveBeenLastCalledWith(root, workspace) + } + expect(signInAccount).not.toHaveBeenCalled() + }) - expect(signIn).toHaveBeenCalledExactlyOnceWith({ workspaceId: 'w2' }) + it('discards a workspace response that arrives after sign-out', async () => { + const tokens = { ...makeTokens('w1'), sessionToken: 'comfy-session-root' } + cache(tokens, true) + const response = Promise.withResolvers() + mocked(mintWorkspaceToken).mockReturnValue(response.promise) + const session = new CloudSession() + const switching = session.switchWorkspace('w2') + session.logout() + response.resolve({ ...makeTokens('w2'), sessionToken: tokens.sessionToken }) + await expect(switching).resolves.toEqual({ signedIn: false }) expect(saveTokens).not.toHaveBeenCalled() + expect(revokeAccountSession).toHaveBeenCalledWith(tokens.sessionToken) }) - it('stores first-time workspace authorization for later silent activation', async () => { - const workspaceOne = makeTokens('w1') - const workspaceTwo = makeTokens('w2') - cache(workspaceOne, true) - mocked(signIn).mockResolvedValue({ - tokens: workspaceTwo, - status: statusFromAccessToken(workspaceTwo.accessToken) + it('obtains partner-node access only for the active workspace', async () => { + const tokens = { ...makeTokens('w1'), sessionToken: 'comfy-session-root' } + cache(tokens, true) + mocked(mintPartnerNodeToken).mockResolvedValue({ + accessToken: 'partner-token', + expiresAt: future, + sessionToken: tokens.sessionToken }) const session = new CloudSession() - - await expect(session.switchWorkspace('w2')).resolves.toMatchObject({ workspaceId: 'w2' }) - await expect(session.switchWorkspace('w1')).resolves.toMatchObject({ workspaceId: 'w1' }) - await expect(session.switchWorkspace('w2')).resolves.toMatchObject({ workspaceId: 'w2' }) - - expect(signIn).toHaveBeenCalledOnce() - expect(saveTokens).toHaveBeenCalledExactlyOnceWith(workspaceTwo) + await expect(session.getPartnerNodeToken('w2')).resolves.toBeNull() + await expect( + Promise.all([session.getPartnerNodeToken('w1'), session.getPartnerNodeToken('w1')]) + ).resolves.toEqual(['partner-token', 'partner-token']) + await expect(session.getPartnerNodeToken('w1')).resolves.toBe('partner-token') + expect(mintPartnerNodeToken).toHaveBeenCalledExactlyOnceWith(tokens.sessionToken, 'w1') }) it('listWorkspaces and the provider use only the active token', async () => { diff --git a/src/main/cloud/session.ts b/src/main/cloud/session.ts index e26bfc5b8..76653ae50 100644 --- a/src/main/cloud/session.ts +++ b/src/main/cloud/session.ts @@ -8,8 +8,14 @@ */ import type { TokenProvider } from '../comfybuilder' import { workspaceIdOf } from './claims' -import type { OAuthOptions } from './oauth' -import { openAuthorizePage, refresh, signIn } from './oauth' +import { openAuthorizePage, refresh } from './oauth' +import { + mintPartnerNodeToken, + mintWorkspaceToken, + revokeAccountSession, + signInAccount +} from './accountSession' +import { SignInFailure } from './signInFailure' import { activateWorkspace, clearTokens, @@ -29,8 +35,10 @@ const REFRESH_SKEW_MS = 60_000 export class CloudSession { /** Refresh rotations are single-flight per workspace token family. */ private readonly refreshing = new Map>() + private readonly partnerTokens = new Map>() private loginInFlight: Promise | null = null private loginAuthorizeUrl: string | null = null + private loginAbort: AbortController | null = null /** Latest browser-auth intent. Older flows may finish, but cannot replace * tokens chosen by a newer login, workspace switch, or logout. */ @@ -57,15 +65,20 @@ export class CloudSession { } private clearPendingLogin(): void { + this.loginAbort?.abort() + this.loginAbort = null this.loginInFlight = null this.loginAuthorizeUrl = null } - /** Forget tokens. Installed environments are untouched. */ + /** Clear local credentials and request server sign-out. */ logout(): void { this.authGeneration += 1 + this.partnerTokens.clear() this.clearPendingLogin() + const sessionToken = loadTokens()?.sessionToken clearTokens() + if (sessionToken) void revokeAccountSession(sessionToken).catch(() => {}) } status(): AuthStatus { @@ -89,12 +102,15 @@ export class CloudSession { async getAccessToken(): Promise { const tokens = loadTokens() if (!tokens) return null - if (tokens.expiresAt - REFRESH_SKEW_MS > Date.now() || !tokens.refreshToken) - return tokens.accessToken + if (tokens.expiresAt - REFRESH_SKEW_MS > Date.now()) return tokens.accessToken const workspaceId = workspaceIdOf(tokens.accessToken) await this.refreshWorkspaceTokens(workspaceId, tokens) const active = loadTokens() - return active && workspaceIdOf(active.accessToken) === workspaceId ? active.accessToken : null + return active && + active.expiresAt > Date.now() && + workspaceIdOf(active.accessToken) === workspaceId + ? active.accessToken + : null } private refreshKey(workspaceId: string | null, refreshToken: string): string { @@ -105,7 +121,7 @@ export class CloudSession { workspaceId: string | null, tokens: AuthTokens ): Promise { - const key = this.refreshKey(workspaceId, tokens.refreshToken ?? '') + const key = this.refreshKey(workspaceId, tokens.sessionToken ?? tokens.refreshToken ?? '') const inFlight = this.refreshing.get(key) if (inFlight) return inFlight const refreshing = this.doRefresh(workspaceId, tokens).finally(() => { @@ -120,13 +136,23 @@ export class CloudSession { tokens: AuthTokens ): Promise { const refreshToken = tokens.refreshToken - if (!refreshToken) return tokens + if (!refreshToken && !tokens.sessionToken) return null try { - const rotated = await refresh(refreshToken) + const rotated = tokens.sessionToken + ? await mintWorkspaceToken(tokens.sessionToken, workspaceId ?? undefined) + : await refresh(refreshToken!) const saved = replaceWorkspaceTokens(workspaceId, tokens.accessToken, refreshToken, rotated) return saved ? rotated : loadWorkspaceTokens(workspaceId) - } catch { - return loadWorkspaceTokens(workspaceId) + } catch (error) { + if ( + error instanceof SignInFailure && + error.httpStatus === 401 && + loadTokens()?.sessionToken === tokens.sessionToken && + tokens.sessionToken + ) { + this.logout() + } + return null } } @@ -146,11 +172,21 @@ export class CloudSession { return listWorkspaceMembers(token) } - /** Activate cached workspace credentials, using browser auth only when needed. */ + /** Select a workspace through the account session, or migrate a legacy login. */ async switchWorkspace(workspaceId: string): Promise { this.clearPendingLogin() const generation = ++this.authGeneration const current = loadTokens() + if (current?.sessionToken) { + const tokens = await mintWorkspaceToken(current.sessionToken, workspaceId) + if ( + generation === this.authGeneration && + loadTokens()?.sessionToken === current.sessionToken && + workspaceIdOf(tokens.accessToken) === workspaceId + ) + saveTokens(tokens) + return this.status() + } let cached = current && workspaceIdOf(current.accessToken) === workspaceId ? current @@ -168,14 +204,68 @@ export class CloudSession { private async authenticateAtGeneration( generation: number, - options: OAuthOptions + options: { workspaceId?: string; onAuthorizeUrl?: (url: string) => void } ): Promise { - const { workspaceId } = options - const { tokens, status } = await signIn(options) - if (generation !== this.authGeneration) return this.status() - if (workspaceId && status.workspaceId !== workspaceId) return this.status() + const controller = new AbortController() + this.loginAbort?.abort() + this.loginAbort = controller + let tokens = await signInAccount(options.onAuthorizeUrl ?? (() => {}), controller.signal) + if (generation !== this.authGeneration) { + if (tokens.sessionToken) await revokeAccountSession(tokens.sessionToken).catch(() => {}) + return this.status() + } + try { + if (options.workspaceId && tokens.sessionToken) { + tokens = await mintWorkspaceToken( + tokens.sessionToken, + options.workspaceId, + controller.signal + ) + } + if (options.workspaceId && workspaceIdOf(tokens.accessToken) !== options.workspaceId) { + throw new SignInFailure('Unexpected workspace in login response', 'server_error') + } + if (generation !== this.authGeneration) { + if (tokens.sessionToken) await revokeAccountSession(tokens.sessionToken).catch(() => {}) + return this.status() + } + } catch (error) { + if (tokens.sessionToken) await revokeAccountSession(tokens.sessionToken).catch(() => {}) + throw error + } + const previous = loadTokens()?.sessionToken + this.partnerTokens.clear() + clearTokens() saveTokens(tokens) - return status + if (previous && previous !== tokens.sessionToken) + void revokeAccountSession(previous).catch(() => {}) + return this.status() + } + + async getPartnerNodeToken(workspaceId: string): Promise { + const tokens = loadTokens() + if (!tokens || workspaceIdOf(tokens.accessToken) !== workspaceId) return null + const generation = this.authGeneration + const credential = tokens.sessionToken ?? tokens.accessToken + const key = `${workspaceId}\0${credential}` + const existing = this.partnerTokens.get(key) + if (existing) { + const cached = await existing.catch(() => undefined) + if (generation !== this.authGeneration) return null + if (cached && cached.expiresAt - REFRESH_SKEW_MS > Date.now()) { + return cached.accessToken + } + if (this.partnerTokens.get(key) !== existing) return this.getPartnerNodeToken(workspaceId) + } + const pending = mintPartnerNodeToken(credential, workspaceId) + this.partnerTokens.set(key, pending) + try { + const token = await pending + return generation === this.authGeneration ? token.accessToken : null + } catch { + if (this.partnerTokens.get(key) === pending) this.partnerTokens.delete(key) + return null + } } /** Adapter for the comfy-builder client's auth seam. */ diff --git a/src/main/cloud/tokenStore.test.ts b/src/main/cloud/tokenStore.test.ts index 63c6d2a0f..23d2feb58 100644 --- a/src/main/cloud/tokenStore.test.ts +++ b/src/main/cloud/tokenStore.test.ts @@ -62,6 +62,25 @@ describe('workspace token vault', () => { _resetForTest() }) + it.each([true, false])( + 'keeps the account credential private with secure storage available=%s', + (available) => { + electronState.encryptionAvailable = available + const account = { + ...tokens('user-1', 'w1'), + refreshToken: undefined, + sessionToken: 'comfy-session-root' + } + saveTokens(account) + expect(loadTokens()).toEqual(account) + expect(getAuthStatus()).not.toHaveProperty('sessionToken') + _resetForTest() + expect(loadTokens()).toEqual(available ? account : null) + if (!available) + expect(fs.existsSync(path.join(electronState.userData, 'comfy-cloud-auth.bin'))).toBe(false) + } + ) + it('keeps independent workspace bundles and reactivates either one', () => { const workspaceOne = tokens('user-1', 'w1') const workspaceTwo = tokens('user-1', 'w2') diff --git a/src/main/cloud/tokenStore.ts b/src/main/cloud/tokenStore.ts index 94218a34a..f568d57f8 100644 --- a/src/main/cloud/tokenStore.ts +++ b/src/main/cloud/tokenStore.ts @@ -1,5 +1,5 @@ /** - * OAuth token store (main process only). Tokens are encrypted at rest with + * Cloud token store (main process only). Tokens are encrypted at rest with * Electron `safeStorage` in `userData/comfy-cloud-auth.bin` and never reach the * renderer, logs, or disk in plaintext. When the OS secure-storage backend is * unavailable, tokens are kept in memory for the process lifetime only. @@ -56,7 +56,10 @@ function isTokens(v: unknown): v is AuthTokens { !!v && typeof v === 'object' && typeof (v as AuthTokens).accessToken === 'string' && - typeof (v as AuthTokens).expiresAt === 'number' + typeof (v as AuthTokens).expiresAt === 'number' && + ((v as AuthTokens).sessionToken === undefined || + (typeof (v as AuthTokens).sessionToken === 'string' && + (v as AuthTokens).sessionToken?.startsWith('comfy-session-') === true)) ) } @@ -198,7 +201,7 @@ export function activateWorkspace(workspaceId: string): AuthTokens | null { export function replaceWorkspaceTokens( workspaceId: string | null, expectedAccessToken: string, - expectedRefreshToken: string, + expectedRefreshToken: string | undefined, tokens: AuthTokens ): boolean { const vault = loadVault() diff --git a/src/main/cloud/types.ts b/src/main/cloud/types.ts index 6d18a0602..4e94e7e27 100644 --- a/src/main/cloud/types.ts +++ b/src/main/cloud/types.ts @@ -7,10 +7,11 @@ * `CloudSession` exposes a `TokenProvider` that client consumes. */ -/** OAuth tokens held in the (main-process only) token store. */ +/** Workspace tokens and the native account credential, held only in main. */ export interface AuthTokens { accessToken: string refreshToken?: string + sessionToken?: string /** Epoch ms when the access token expires. */ expiresAt: number } diff --git a/src/main/lib/embeddedSession.ts b/src/main/lib/embeddedSession.ts index b60296456..b052706da 100644 --- a/src/main/lib/embeddedSession.ts +++ b/src/main/lib/embeddedSession.ts @@ -20,6 +20,7 @@ import { isEmbeddedSessionEnabled } from './embeddedSessionFlag' export const EMBEDDED_SESSION_CHANNELS = { getState: 'desktop2-auth:get-state', getWorkspaceToken: 'desktop2-auth:get-workspace-token', + getPartnerNodeToken: 'desktop2-auth:get-partner-node-token', requestSignIn: 'desktop2-auth:request-sign-in', signOut: 'desktop2-auth:sign-out', switchWorkspace: 'desktop2-auth:switch-workspace', @@ -133,3 +134,18 @@ export async function broadcastEmbeddedSessionChanged(): Promise { contents.send(EMBEDDED_SESSION_CHANNELS.changed, state) } } + +export async function partnerNodeTokenForSender( + event: EmbeddedSessionSender, + workspaceId: unknown +): Promise { + if ( + typeof workspaceId !== 'string' || + !workspaceId || + !isTrustedSender(event) || + !(await isEmbeddedSessionEnabled()) + ) + return null + const token = await getCloudSession().getPartnerNodeToken(workspaceId) + return isTrustedSender(event) ? token : null +} diff --git a/src/main/lib/ipc/registerEmbeddedSessionHandlers.test.ts b/src/main/lib/ipc/registerEmbeddedSessionHandlers.test.ts index f3524bd27..393f42b2d 100644 --- a/src/main/lib/ipc/registerEmbeddedSessionHandlers.test.ts +++ b/src/main/lib/ipc/registerEmbeddedSessionHandlers.test.ts @@ -20,13 +20,15 @@ vi.mock('../embeddedSession', () => ({ EMBEDDED_SESSION_CHANNELS: { getState: 'desktop2-auth:get-state', getWorkspaceToken: 'desktop2-auth:get-workspace-token', + getPartnerNodeToken: 'desktop2-auth:get-partner-node-token', requestSignIn: 'desktop2-auth:request-sign-in', signOut: 'desktop2-auth:sign-out', switchWorkspace: 'desktop2-auth:switch-workspace' }, stateForSender: mocks.stateForSender, switchWorkspaceForSender: vi.fn(), - workspaceTokenForSender: vi.fn() + workspaceTokenForSender: vi.fn(), + partnerNodeTokenForSender: vi.fn() })) vi.mock('./registerDevPlatformHandlers', () => ({ diff --git a/src/main/lib/ipc/registerEmbeddedSessionHandlers.ts b/src/main/lib/ipc/registerEmbeddedSessionHandlers.ts index b1a401489..118c55eb8 100644 --- a/src/main/lib/ipc/registerEmbeddedSessionHandlers.ts +++ b/src/main/lib/ipc/registerEmbeddedSessionHandlers.ts @@ -8,6 +8,7 @@ import { findEntryByComfySender } from '../../host/registry' import type { ComfyDesktop2AuthState } from '../../../types/comfyDesktopBridge' import { EMBEDDED_SESSION_CHANNELS, + partnerNodeTokenForSender, stateForSender, switchWorkspaceForSender, workspaceTokenForSender @@ -16,6 +17,10 @@ import { reportHostSignIn } from '../hostSignInTelemetry' import { signInToCloud, signOutOfCloud, switchCloudWorkspace } from './registerDevPlatformHandlers' export function registerEmbeddedSessionHandlers(): void { + ipcMain.handle(EMBEDDED_SESSION_CHANNELS.getPartnerNodeToken, (event, workspaceId: unknown) => + partnerNodeTokenForSender(event, workspaceId) + ) + ipcMain.handle(EMBEDDED_SESSION_CHANNELS.getState, (event) => stateForSender(event)) ipcMain.handle(EMBEDDED_SESSION_CHANNELS.getWorkspaceToken, (event, workspaceId: unknown) => diff --git a/src/preload/comfyPreload.ts b/src/preload/comfyPreload.ts index c3ee4a473..34bd42949 100644 --- a/src/preload/comfyPreload.ts +++ b/src/preload/comfyPreload.ts @@ -310,6 +310,8 @@ const Auth: ComfyDesktop2AuthBridge = { getState: () => ipcRenderer.invoke('desktop2-auth:get-state'), getWorkspaceToken: (workspaceId) => ipcRenderer.invoke('desktop2-auth:get-workspace-token', workspaceId), + getPartnerNodeToken: (workspaceId) => + ipcRenderer.invoke('desktop2-auth:get-partner-node-token', workspaceId), requestSignIn: () => ipcRenderer.invoke('desktop2-auth:request-sign-in'), signOut: () => ipcRenderer.invoke('desktop2-auth:sign-out'), switchWorkspace: (workspaceId) => diff --git a/src/types/comfyDesktopBridge.ts b/src/types/comfyDesktopBridge.ts index 8ee45aedc..1c16e39d9 100644 --- a/src/types/comfyDesktopBridge.ts +++ b/src/types/comfyDesktopBridge.ts @@ -129,6 +129,7 @@ export interface ComfyDesktop2AuthBridge { * is scoped to; null when signed out, disabled, or the scope is missing, * malformed or different. The refresh token never leaves Desktop. */ getWorkspaceToken(workspaceId: string): Promise + getPartnerNodeToken?(workspaceId: string): Promise /** Runs Desktop's browser sign-in and resolves with the resulting state. */ requestSignIn(): Promise /** Signs Desktop out of its account (every view follows) and resolves with From 3a8eca595c59b547151bb76867eacba60cc743e7 Mon Sep 17 00:00:00 2001 From: PabloWiedemann Date: Tue, 20 Oct 2026 10:44:04 -0700 Subject: [PATCH 2/5] fix(auth): clear revoked account sessions on workspace switch --- src/main/cloud/session.test.ts | 10 ++++++++++ src/main/cloud/session.ts | 16 +++++++++++++++- 2 files changed, 25 insertions(+), 1 deletion(-) diff --git a/src/main/cloud/session.test.ts b/src/main/cloud/session.test.ts index a7c025512..4d57021bb 100644 --- a/src/main/cloud/session.test.ts +++ b/src/main/cloud/session.test.ts @@ -343,6 +343,16 @@ describe('CloudSession workspaces', () => { expect(signInAccount).not.toHaveBeenCalled() }) + it('clears a revoked account session when switching workspaces', async () => { + cache({ ...makeTokens('w1'), sessionToken: 'comfy-session-root' }, true) + mocked(mintWorkspaceToken).mockRejectedValue( + new SignInFailure('revoked', 'server_error', { httpStatus: 401 }) + ) + await expect(new CloudSession().switchWorkspace('w2')).resolves.toEqual({ signedIn: false }) + expect(clearTokens).toHaveBeenCalledOnce() + expect(signInAccount).not.toHaveBeenCalled() + }) + it('checks membership on each workspace switch without browser auth', async () => { const root = 'comfy-session-root' cache({ ...makeTokens('w1'), sessionToken: root }, true) diff --git a/src/main/cloud/session.ts b/src/main/cloud/session.ts index 76653ae50..50bc8eeea 100644 --- a/src/main/cloud/session.ts +++ b/src/main/cloud/session.ts @@ -178,7 +178,21 @@ export class CloudSession { const generation = ++this.authGeneration const current = loadTokens() if (current?.sessionToken) { - const tokens = await mintWorkspaceToken(current.sessionToken, workspaceId) + let tokens: AuthTokens + try { + tokens = await mintWorkspaceToken(current.sessionToken, workspaceId) + } catch (error) { + if ( + error instanceof SignInFailure && + error.httpStatus === 401 && + generation === this.authGeneration && + loadTokens()?.sessionToken === current.sessionToken + ) { + this.logout() + return this.status() + } + throw error + } if ( generation === this.authGeneration && loadTokens()?.sessionToken === current.sessionToken && From af130178f9838667cdbc22fa35c1ccef54f011e2 Mon Sep 17 00:00:00 2001 From: PabloWiedemann Date: Tue, 20 Oct 2026 10:47:07 -0700 Subject: [PATCH 3/5] chore(bridge): bump types for optional partner token method --- packages/comfyui-desktop-bridge-types/package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/comfyui-desktop-bridge-types/package.json b/packages/comfyui-desktop-bridge-types/package.json index d587b23c6..93c5e1d04 100644 --- a/packages/comfyui-desktop-bridge-types/package.json +++ b/packages/comfyui-desktop-bridge-types/package.json @@ -1,6 +1,6 @@ { "name": "@comfyorg/comfyui-desktop-bridge-types", - "version": "0.5.0", + "version": "0.6.0", "description": "TypeScript definitions for the Comfy Desktop hosted frontend bridge", "type": "module", "main": "./index.js", From 0fbc0d3f73130b532ff245a1f192eefd2a4cb577 Mon Sep 17 00:00:00 2001 From: PabloWiedemann Date: Tue, 20 Oct 2026 13:06:33 -0700 Subject: [PATCH 4/5] fix(auth): address account login and session review findings --- src/main/cloud/accountSession.test.ts | 32 ++++++ src/main/cloud/accountSession.ts | 57 ++++++---- src/main/cloud/session.test.ts | 101 +++++++++++++++++- src/main/cloud/session.ts | 95 ++++++++++------ .../lib/ipc/registerDevPlatformHandlers.ts | 3 +- 5 files changed, 234 insertions(+), 54 deletions(-) diff --git a/src/main/cloud/accountSession.test.ts b/src/main/cloud/accountSession.test.ts index 341c1a51e..c528a0485 100644 --- a/src/main/cloud/accountSession.test.ts +++ b/src/main/cloud/accountSession.test.ts @@ -59,6 +59,27 @@ describe('native account login', () => { }) }) + it('completes login when the browser launch promise never settles', async () => { + mocks.open.mockReturnValue(new Promise(() => {})) + mocks.fetch + .mockResolvedValueOnce(respond({ code: CODE, expires_in: 300, poll_interval: 1 }, 201)) + .mockResolvedValueOnce(respond({ status: 'complete', session_token: ROOT })) + .mockResolvedValueOnce(respond({ token: 'workspace-token', expires_at: EXPIRES })) + const login = signInAccount(vi.fn(), new AbortController().signal) + await vi.advanceTimersByTimeAsync(1000) + await expect(login).resolves.toMatchObject({ sessionToken: ROOT }) + }) + + it('stops polling when opening the browser fails', async () => { + mocks.open.mockRejectedValue(new Error('browser handler failed')) + mocks.fetch.mockResolvedValue(respond({ code: CODE, expires_in: 300, poll_interval: 1 }, 201)) + await expect(signInAccount(vi.fn(), new AbortController().signal)).rejects.toMatchObject({ + reason: 'browser_unavailable' + }) + await vi.advanceTimersByTimeAsync(2000) + expect(mocks.fetch).toHaveBeenCalledOnce() + }) + it('refuses an older server before opening a Firebase-only handoff', async () => { mocks.fetch.mockResolvedValue( respond({ code: 'dlc_old', expires_in: 300, poll_interval: 1 }, 201) @@ -127,6 +148,17 @@ describe('workspace mint', () => { }) }) + it.each([ + () => Promise.reject(new TypeError('sensitive transport detail')), + () => Promise.resolve(new Response('sensitive non-JSON response')) + ])('sanitizes transport and JSON failures', async (response) => { + mocks.fetch.mockImplementation(response) + await expect(mintWorkspaceToken(ROOT)).rejects.toMatchObject({ + reason: 'server_error', + message: 'Account session request failed' + }) + }) + it.each([{}, { token: 'token', expires_at: 'invalid' }])( 'rejects an invalid workspace token response', async (body) => { diff --git a/src/main/cloud/accountSession.ts b/src/main/cloud/accountSession.ts index 9ec810f37..1c2a92564 100644 --- a/src/main/cloud/accountSession.ts +++ b/src/main/cloud/accountSession.ts @@ -6,7 +6,7 @@ import { type DesktopLoginCodeGrant, postJson } from '../auth/desktopLoginCode/client' -import { abortable, abortableSleep } from '../auth/firebaseBridge/flowControl' +import { abortableSleep } from '../auth/firebaseBridge/flowControl' import { CLOUD_CONFIG } from './config' import { openAuthorizePage } from './oauth' import { codeChallengeFromVerifier, generateCodeVerifier } from './pkce' @@ -36,23 +36,37 @@ export async function signInAccount( onAuthorizeUrl(url.href) const expiry = AbortSignal.timeout(grant.expires_in * 1000) const deadline = AbortSignal.any([signal, expiry]) + const polling = new AbortController() try { - return await pollForAccountSession(grant, verifier, url.href, deadline) + const account = pollForAccountSession( + grant, + verifier, + AbortSignal.any([deadline, polling.signal]) + ) + return await Promise.race([ + account, + openAuthorizePage(url.href).then( + () => account, + () => { + throw new SignInFailure('Could not open the browser', 'browser_unavailable') + } + ) + ]) } catch (error) { if (expiry.aborted && !signal.aborted) { throw new SignInFailure('Sign-in timed out', 'timeout') } throw error + } finally { + polling.abort() } } async function pollForAccountSession( grant: DesktopLoginCodeGrant, verifier: string, - url: string, deadline: AbortSignal ): Promise { - await abortable(openAuthorizePage(url), deadline) while (!deadline.aborted) { await abortableSleep(grant.poll_interval * 1000, deadline) let response @@ -103,23 +117,28 @@ async function sessionRequest( signal?: AbortSignal ): Promise { const timeout = AbortSignal.timeout(15_000) - const response = await net.fetch(`${CLOUD_CONFIG.apiBase}${path}`, { - method, - headers: { - Authorization: `Bearer ${sessionToken}`, - 'Content-Type': 'application/json' - }, - credentials: 'omit', - redirect: 'error', - signal: signal ? AbortSignal.any([signal, timeout]) : timeout, - ...(body === undefined ? {} : { body: JSON.stringify(body) }) - }) - if (!response.ok) { - throw new SignInFailure('Account session request failed', 'server_error', { - httpStatus: response.status + try { + const response = await net.fetch(`${CLOUD_CONFIG.apiBase}${path}`, { + method, + headers: { + Authorization: `Bearer ${sessionToken}`, + 'Content-Type': 'application/json' + }, + credentials: 'omit', + redirect: 'error', + signal: signal ? AbortSignal.any([signal, timeout]) : timeout, + ...(body === undefined ? {} : { body: JSON.stringify(body) }) }) + if (!response.ok) { + throw new SignInFailure('Account session request failed', 'server_error', { + httpStatus: response.status + }) + } + return response.status === 204 ? undefined : await response.json() + } catch (error) { + if (signal?.aborted || error instanceof SignInFailure) throw error + throw new SignInFailure('Account session request failed', 'server_error') } - return response.status === 204 ? undefined : response.json() } export async function mintWorkspaceToken( diff --git a/src/main/cloud/session.test.ts b/src/main/cloud/session.test.ts index 4d57021bb..8b8f6edd7 100644 --- a/src/main/cloud/session.test.ts +++ b/src/main/cloud/session.test.ts @@ -389,7 +389,7 @@ describe('CloudSession workspaces', () => { const tokens = { ...makeTokens('w1'), sessionToken: 'comfy-session-root' } cache(tokens, true) mocked(mintPartnerNodeToken).mockResolvedValue({ - accessToken: 'partner-token', + accessToken: jwt('w1', '-partner'), expiresAt: future, sessionToken: tokens.sessionToken }) @@ -397,8 +397,8 @@ describe('CloudSession workspaces', () => { await expect(session.getPartnerNodeToken('w2')).resolves.toBeNull() await expect( Promise.all([session.getPartnerNodeToken('w1'), session.getPartnerNodeToken('w1')]) - ).resolves.toEqual(['partner-token', 'partner-token']) - await expect(session.getPartnerNodeToken('w1')).resolves.toBe('partner-token') + ).resolves.toEqual([jwt('w1', '-partner'), jwt('w1', '-partner')]) + await expect(session.getPartnerNodeToken('w1')).resolves.toBe(jwt('w1', '-partner')) expect(mintPartnerNodeToken).toHaveBeenCalledExactlyOnceWith(tokens.sessionToken, 'w1') }) @@ -428,3 +428,98 @@ describe('CloudSession workspaces', () => { expect(listWorkspaceMembers).toHaveBeenCalledExactlyOnceWith(tokens.accessToken) }) }) + +describe('account session review regressions', () => { + it('keeps a new login alive when the old account is rejected', async () => { + cache({ ...makeTokens('w1', past), sessionToken: 'comfy-session-old' }, true) + const refreshing = Promise.withResolvers() + const signingIn = Promise.withResolvers() + mocked(mintWorkspaceToken).mockReturnValue(refreshing.promise) + mocked(signInAccount).mockReturnValue(signingIn.promise) + const session = new CloudSession() + const access = session.getAccessToken() + const login = session.login() + refreshing.reject(new SignInFailure('revoked', 'server_error', { httpStatus: 401 })) + await expect(access).resolves.toBeNull() + expect(mocked(signInAccount).mock.calls.at(-1)![1].aborted).toBe(false) + signingIn.resolve({ ...makeTokens('w2'), sessionToken: 'comfy-session-new' }) + await expect(login).resolves.toMatchObject({ workspaceId: 'w2' }) + }) + + it('resolves an aborted login with the current state after logout', async () => { + mocked(signInAccount).mockImplementation( + (_, signal) => + new Promise((_, reject) => { + signal.addEventListener('abort', () => + reject(new DOMException('cancelled', 'AbortError')) + ) + }) + ) + const session = new CloudSession() + const login = session.login() + await session.logout() + await expect(login).resolves.toEqual({ signedIn: false }) + }) + + it('rejects a workspace response with a different scope', async () => { + const tokens = { ...makeTokens('w1'), sessionToken: 'comfy-session-root' } + cache(tokens, true) + mocked(mintWorkspaceToken).mockResolvedValue({ + ...makeTokens('w3'), + sessionToken: tokens.sessionToken + }) + await expect(new CloudSession().switchWorkspace('w2')).rejects.toMatchObject({ + reason: 'server_error' + }) + expect(active).toBe(tokens) + }) + + it('uses a still-valid legacy token when refresh temporarily fails', async () => { + cache(makeTokens('w1'), true) + cache(makeTokens('w2', Date.now() + 30_000)) + mocked(refresh).mockRejectedValue(new Error('offline')) + await expect(new CloudSession().switchWorkspace('w2')).resolves.toMatchObject({ + workspaceId: 'w2' + }) + expect(signInAccount).not.toHaveBeenCalled() + }) + + it('shares failed partner requests and backs off before retrying', async () => { + vi.useFakeTimers() + try { + cache({ ...makeTokens('w1'), sessionToken: 'comfy-session-root' }, true) + mocked(mintPartnerNodeToken).mockRejectedValue(new Error('offline')) + const session = new CloudSession() + await expect( + Promise.all(Array.from({ length: 10 }, () => session.getPartnerNodeToken('w1'))) + ).resolves.toEqual(Array(10).fill(null)) + await expect(session.getPartnerNodeToken('w1')).resolves.toBeNull() + expect(mintPartnerNodeToken).toHaveBeenCalledOnce() + await vi.advanceTimersByTimeAsync(5000) + await session.getPartnerNodeToken('w1') + expect(mintPartnerNodeToken).toHaveBeenCalledTimes(2) + } finally { + vi.useRealTimers() + } + }) + + it('refreshes legacy credentials before requesting a partner token and rejects another scope', async () => { + cache(makeTokens('w1', past), true) + const fresh = makeTokens('w1', future, '-fresh') + mocked(refresh).mockResolvedValue(fresh) + mocked(mintPartnerNodeToken).mockResolvedValue(makeTokens('w2')) + await expect(new CloudSession().getPartnerNodeToken('w1')).resolves.toBeNull() + expect(mintPartnerNodeToken).toHaveBeenCalledWith(fresh.accessToken, 'w1') + }) + + it('waits for server logout and reports a failed revocation', async () => { + cache({ ...makeTokens('w1'), sessionToken: 'comfy-session-root' }, true) + const revocation = Promise.withResolvers() + mocked(revokeAccountSession).mockReturnValueOnce(revocation.promise) + const logout = new CloudSession().logout() + expect(active).toBeNull() + const result = expect(logout).rejects.toThrow('offline') + revocation.reject(new Error('offline')) + await result + }) +}) diff --git a/src/main/cloud/session.ts b/src/main/cloud/session.ts index 50bc8eeea..f904babe9 100644 --- a/src/main/cloud/session.ts +++ b/src/main/cloud/session.ts @@ -35,7 +35,14 @@ const REFRESH_SKEW_MS = 60_000 export class CloudSession { /** Refresh rotations are single-flight per workspace token family. */ private readonly refreshing = new Map>() - private readonly partnerTokens = new Map>() + private readonly partnerTokens = new Map< + string, + { + credential: string + pending: Promise + expiresAt: number + } + >() private loginInFlight: Promise | null = null private loginAuthorizeUrl: string | null = null private loginAbort: AbortController | null = null @@ -72,13 +79,13 @@ export class CloudSession { } /** Clear local credentials and request server sign-out. */ - logout(): void { + async logout(): Promise { this.authGeneration += 1 this.partnerTokens.clear() this.clearPendingLogin() const sessionToken = loadTokens()?.sessionToken clearTokens() - if (sessionToken) void revokeAccountSession(sessionToken).catch(() => {}) + if (sessionToken) await revokeAccountSession(sessionToken) } status(): AuthStatus { @@ -150,9 +157,11 @@ export class CloudSession { loadTokens()?.sessionToken === tokens.sessionToken && tokens.sessionToken ) { - this.logout() + this.invalidateStoredSession() + return null } - return null + const cached = loadWorkspaceTokens(workspaceId) + return cached && cached.expiresAt > Date.now() ? cached : null } } @@ -188,17 +197,20 @@ export class CloudSession { generation === this.authGeneration && loadTokens()?.sessionToken === current.sessionToken ) { - this.logout() + this.invalidateStoredSession() return this.status() } throw error } if ( generation === this.authGeneration && - loadTokens()?.sessionToken === current.sessionToken && - workspaceIdOf(tokens.accessToken) === workspaceId - ) + loadTokens()?.sessionToken === current.sessionToken + ) { + if (workspaceIdOf(tokens.accessToken) !== workspaceId) { + throw new SignInFailure('Unexpected workspace in token response', 'server_error') + } saveTokens(tokens) + } return this.status() } let cached = @@ -223,7 +235,13 @@ export class CloudSession { const controller = new AbortController() this.loginAbort?.abort() this.loginAbort = controller - let tokens = await signInAccount(options.onAuthorizeUrl ?? (() => {}), controller.signal) + let tokens: AuthTokens + try { + tokens = await signInAccount(options.onAuthorizeUrl ?? (() => {}), controller.signal) + } catch (error) { + if (generation !== this.authGeneration) return this.status() + throw error + } if (generation !== this.authGeneration) { if (tokens.sessionToken) await revokeAccountSession(tokens.sessionToken).catch(() => {}) return this.status() @@ -245,6 +263,7 @@ export class CloudSession { } } catch (error) { if (tokens.sessionToken) await revokeAccountSession(tokens.sessionToken).catch(() => {}) + if (generation !== this.authGeneration) return this.status() throw error } const previous = loadTokens()?.sessionToken @@ -257,29 +276,43 @@ export class CloudSession { } async getPartnerNodeToken(workspaceId: string): Promise { - const tokens = loadTokens() - if (!tokens || workspaceIdOf(tokens.accessToken) !== workspaceId) return null const generation = this.authGeneration - const credential = tokens.sessionToken ?? tokens.accessToken - const key = `${workspaceId}\0${credential}` - const existing = this.partnerTokens.get(key) - if (existing) { - const cached = await existing.catch(() => undefined) - if (generation !== this.authGeneration) return null - if (cached && cached.expiresAt - REFRESH_SKEW_MS > Date.now()) { - return cached.accessToken - } - if (this.partnerTokens.get(key) !== existing) return this.getPartnerNodeToken(workspaceId) + let tokens = loadTokens() + if (!tokens || workspaceIdOf(tokens.accessToken) !== workspaceId) return null + if (!tokens.sessionToken) { + if (!(await this.getAccessToken()) || generation !== this.authGeneration) return null + tokens = loadTokens() + if (!tokens || workspaceIdOf(tokens.accessToken) !== workspaceId) return null } - const pending = mintPartnerNodeToken(credential, workspaceId) - this.partnerTokens.set(key, pending) - try { - const token = await pending - return generation === this.authGeneration ? token.accessToken : null - } catch { - if (this.partnerTokens.get(key) === pending) this.partnerTokens.delete(key) - return null + const credential = tokens.sessionToken ?? tokens.accessToken + let entry = this.partnerTokens.get(workspaceId) + if (!entry || entry.credential !== credential || entry.expiresAt <= Date.now()) { + const pending = mintPartnerNodeToken(credential, workspaceId) + .then( + (token) => { + if (workspaceIdOf(token.accessToken) !== workspaceId) return null + created.expiresAt = token.expiresAt - REFRESH_SKEW_MS + return token.accessToken + }, + () => null + ) + .then((token) => { + if (!token) created.expiresAt = Date.now() + 5_000 + return token + }) + const created = { credential, pending, expiresAt: Infinity } + entry = created + this.partnerTokens.set(workspaceId, entry) } + const token = await entry.pending + return generation === this.authGeneration && this.currentWorkspaceId() === workspaceId + ? token + : null + } + + private invalidateStoredSession(): void { + this.partnerTokens.clear() + clearTokens() } /** Adapter for the comfy-builder client's auth seam. */ @@ -290,7 +323,7 @@ export class CloudSession { // A request issued before a newer login may return 401 afterward. Only // invalidate the exact token the server rejected, never the new session. if (loadTokens()?.accessToken !== rejectedAccessToken) return - this.logout() + this.invalidateStoredSession() onSignedOut?.() } } diff --git a/src/main/lib/ipc/registerDevPlatformHandlers.ts b/src/main/lib/ipc/registerDevPlatformHandlers.ts index 5f19bcaae..b56550317 100644 --- a/src/main/lib/ipc/registerDevPlatformHandlers.ts +++ b/src/main/lib/ipc/registerDevPlatformHandlers.ts @@ -181,9 +181,10 @@ export async function signOutOfCloud(host: ComfyWindowEntry | undefined): Promis }) } } - session.logout() + const revocation = session.logout() clearVersionCache() broadcastAuthChanged(SIGNED_OUT) + await revocation return SIGNED_OUT } From 8c0a6ace3e96c3e212b62a5359350e9ebdf59e3b Mon Sep 17 00:00:00 2001 From: PabloWiedemann Date: Tue, 20 Oct 2026 14:48:15 -0700 Subject: [PATCH 5/5] fix(auth): handle native session cleanup and workspace races --- src/main/cloud/accountSession.test.ts | 33 +++++++++++++++++++++++---- src/main/cloud/accountSession.ts | 13 ++++++----- src/main/cloud/session.test.ts | 21 ++++++++++++----- src/main/cloud/session.ts | 12 ++++++---- src/main/cloud/tokenStore.test.ts | 14 ++++++++++++ src/main/cloud/tokenStore.ts | 2 ++ src/main/lib/embeddedSession.test.ts | 23 ++++++++++++++++++- src/main/lib/embeddedSession.ts | 2 +- 8 files changed, 98 insertions(+), 22 deletions(-) diff --git a/src/main/cloud/accountSession.test.ts b/src/main/cloud/accountSession.test.ts index c528a0485..ab029451b 100644 --- a/src/main/cloud/accountSession.test.ts +++ b/src/main/cloud/accountSession.test.ts @@ -7,7 +7,7 @@ vi.mock('electron', () => ({ shell: { openExternal: mocks.open } })) -import { mintWorkspaceToken, signInAccount } from './accountSession' +import { mintWorkspaceToken, revokeAccountSession, signInAccount } from './accountSession' const ROOT = 'comfy-session-secret' const CODE = `dls_${'a'.repeat(43)}` @@ -114,6 +114,32 @@ describe('native account login', () => { await result }) + it('preserves a mint refusal when cleanup crosses the sign-in deadline', async () => { + const expiry = new AbortController() + vi.spyOn(AbortSignal, 'timeout').mockReturnValue(expiry.signal) + mocks.fetch + .mockResolvedValueOnce(respond({ code: CODE, expires_in: 300, poll_interval: 1 }, 201)) + .mockResolvedValueOnce(respond({ status: 'complete', session_token: ROOT })) + .mockResolvedValueOnce(respond({ code: 'FORBIDDEN' }, 403)) + .mockImplementationOnce(async () => { + expiry.abort(new DOMException('expired', 'TimeoutError')) + return respond({ success: true }) + }) + const result = expect( + signInAccount(vi.fn(), new AbortController().signal) + ).rejects.toMatchObject({ reason: 'server_error', httpStatus: 403 }) + await vi.advanceTimersByTimeAsync(1000) + await result + }) + + it('uses one server request to revoke the account and its partner sessions', async () => { + mocks.fetch.mockResolvedValue(respond({ success: true })) + await revokeAccountSession(ROOT) + expect(mocks.fetch).toHaveBeenCalledOnce() + expect(mocks.fetch.mock.calls[0]![0]).toMatch(/\/auth\/session$/) + expect(mocks.fetch.mock.calls[0]![1].method).toBe('DELETE') + }) + it('revokes a handed-off session if the first workspace request fails', async () => { mocks.fetch .mockResolvedValueOnce(respond({ code: CODE, expires_in: 300, poll_interval: 1 }, 201)) @@ -126,9 +152,8 @@ describe('native account login', () => { ).rejects.toMatchObject({ httpStatus: 403 }) await vi.advanceTimersByTimeAsync(1000) await result - expect(mocks.fetch.mock.calls[3]![0]).toMatch(/\/auth\/token\/revoke$/) - expect(mocks.fetch.mock.calls[4]![0]).toMatch(/\/auth\/session$/) - expect(mocks.fetch.mock.calls[4]![1]).toMatchObject({ + expect(mocks.fetch.mock.calls[3]![0]).toMatch(/\/auth\/session$/) + expect(mocks.fetch.mock.calls[3]![1]).toMatchObject({ method: 'DELETE', headers: { Authorization: `Bearer ${ROOT}` } }) diff --git a/src/main/cloud/accountSession.ts b/src/main/cloud/accountSession.ts index 1c2a92564..8a9dbc3ad 100644 --- a/src/main/cloud/accountSession.ts +++ b/src/main/cloud/accountSession.ts @@ -53,7 +53,12 @@ export async function signInAccount( ) ]) } catch (error) { - if (expiry.aborted && !signal.aborted) { + if ( + expiry.aborted && + !signal.aborted && + error instanceof Error && + (error.name === 'AbortError' || error.name === 'TimeoutError') + ) { throw new SignInFailure('Sign-in timed out', 'timeout') } throw error @@ -185,9 +190,5 @@ export async function mintPartnerNodeToken( } export async function revokeAccountSession(sessionToken: string): Promise { - try { - await sessionRequest(sessionToken, '/auth/token/revoke', 'POST') - } finally { - await sessionRequest(sessionToken, '/auth/session', 'DELETE') - } + await sessionRequest(sessionToken, '/auth/session', 'DELETE') } diff --git a/src/main/cloud/session.test.ts b/src/main/cloud/session.test.ts index 8b8f6edd7..859733784 100644 --- a/src/main/cloud/session.test.ts +++ b/src/main/cloud/session.test.ts @@ -336,8 +336,8 @@ describe('CloudSession workspaces', () => { mocked(mintWorkspaceToken).mockRejectedValue( new SignInFailure('denied', 'server_error', { httpStatus: 404 }) ) - await expect(new CloudSession().switchWorkspace('w2')).rejects.toMatchObject({ - httpStatus: 404 + await expect(new CloudSession().switchWorkspace('w2')).resolves.toMatchObject({ + workspaceId: 'w1' }) expect(active).toEqual(workspaceOne) expect(signInAccount).not.toHaveBeenCalled() @@ -468,8 +468,8 @@ describe('account session review regressions', () => { ...makeTokens('w3'), sessionToken: tokens.sessionToken }) - await expect(new CloudSession().switchWorkspace('w2')).rejects.toMatchObject({ - reason: 'server_error' + await expect(new CloudSession().switchWorkspace('w2')).resolves.toMatchObject({ + workspaceId: 'w1' }) expect(active).toBe(tokens) }) @@ -484,6 +484,15 @@ describe('account session review regressions', () => { expect(signInAccount).not.toHaveBeenCalled() }) + it('reuses a short-lived partner token without reminting on every call', async () => { + cache({ ...makeTokens('w1'), sessionToken: 'comfy-session-root' }, true) + mocked(mintPartnerNodeToken).mockResolvedValue(makeTokens('w1', Date.now() + 30_000)) + const session = new CloudSession() + await session.getPartnerNodeToken('w1') + await session.getPartnerNodeToken('w1') + expect(mintPartnerNodeToken).toHaveBeenCalledOnce() + }) + it('shares failed partner requests and backs off before retrying', async () => { vi.useFakeTimers() try { @@ -512,13 +521,13 @@ describe('account session review regressions', () => { expect(mintPartnerNodeToken).toHaveBeenCalledWith(fresh.accessToken, 'w1') }) - it('waits for server logout and reports a failed revocation', async () => { + it('finishes local logout even when server revocation fails', async () => { cache({ ...makeTokens('w1'), sessionToken: 'comfy-session-root' }, true) const revocation = Promise.withResolvers() mocked(revokeAccountSession).mockReturnValueOnce(revocation.promise) const logout = new CloudSession().logout() expect(active).toBeNull() - const result = expect(logout).rejects.toThrow('offline') + const result = expect(logout).resolves.toBeUndefined() revocation.reject(new Error('offline')) await result }) diff --git a/src/main/cloud/session.ts b/src/main/cloud/session.ts index f904babe9..2b8da675d 100644 --- a/src/main/cloud/session.ts +++ b/src/main/cloud/session.ts @@ -85,7 +85,11 @@ export class CloudSession { this.clearPendingLogin() const sessionToken = loadTokens()?.sessionToken clearTokens() - if (sessionToken) await revokeAccountSession(sessionToken) + if (sessionToken) { + await revokeAccountSession(sessionToken).catch(() => { + console.warn('Cloud account signed out locally; server revocation failed') + }) + } } status(): AuthStatus { @@ -200,14 +204,14 @@ export class CloudSession { this.invalidateStoredSession() return this.status() } - throw error + return this.status() } if ( generation === this.authGeneration && loadTokens()?.sessionToken === current.sessionToken ) { if (workspaceIdOf(tokens.accessToken) !== workspaceId) { - throw new SignInFailure('Unexpected workspace in token response', 'server_error') + return this.status() } saveTokens(tokens) } @@ -291,7 +295,7 @@ export class CloudSession { .then( (token) => { if (workspaceIdOf(token.accessToken) !== workspaceId) return null - created.expiresAt = token.expiresAt - REFRESH_SKEW_MS + created.expiresAt = Math.max(Date.now() + 5_000, token.expiresAt - REFRESH_SKEW_MS) return token.accessToken }, () => null diff --git a/src/main/cloud/tokenStore.test.ts b/src/main/cloud/tokenStore.test.ts index 23d2feb58..19af9cbd3 100644 --- a/src/main/cloud/tokenStore.test.ts +++ b/src/main/cloud/tokenStore.test.ts @@ -81,6 +81,20 @@ describe('workspace token vault', () => { } ) + it('refuses malformed native credentials without losing saved workspaces', () => { + const valid = tokens('user-1', 'w1') + saveTokens(valid) + expect(() => saveTokens({ ...tokens('user-1', 'w2'), sessionToken: 'bad' })).toThrow() + expect( + replaceWorkspaceTokens('w1', valid.accessToken, valid.refreshToken, { + ...valid, + sessionToken: 'bad' + }) + ).toBe(false) + _resetForTest() + expect(loadTokens()).toEqual(valid) + }) + it('keeps independent workspace bundles and reactivates either one', () => { const workspaceOne = tokens('user-1', 'w1') const workspaceTwo = tokens('user-1', 'w2') diff --git a/src/main/cloud/tokenStore.ts b/src/main/cloud/tokenStore.ts index f568d57f8..7a808149f 100644 --- a/src/main/cloud/tokenStore.ts +++ b/src/main/cloud/tokenStore.ts @@ -147,6 +147,7 @@ function loadVault(): TokenVault | null { /** Save and activate a browser-auth token bundle. A changed account replaces the vault. */ export function saveTokens(tokens: AuthTokens): void { + if (!isTokens(tokens)) throw new Error('Invalid cloud credentials') const current = loadVault() const nextSubject = subjectOf(tokens.accessToken) const accountChanged = current !== null && (!nextSubject || current.subject !== nextSubject) @@ -204,6 +205,7 @@ export function replaceWorkspaceTokens( expectedRefreshToken: string | undefined, tokens: AuthTokens ): boolean { + if (!isTokens(tokens)) return false const vault = loadVault() if (!vault) return false const key = workspaceKey(workspaceId) diff --git a/src/main/lib/embeddedSession.test.ts b/src/main/lib/embeddedSession.test.ts index 3dcf4bd04..add56151f 100644 --- a/src/main/lib/embeddedSession.test.ts +++ b/src/main/lib/embeddedSession.test.ts @@ -4,6 +4,7 @@ import { beforeEach, describe, expect, it, vi } from 'vitest' const mocks = vi.hoisted(() => ({ enabled: true, getAccessToken: vi.fn<() => Promise>(), + getPartnerNodeToken: vi.fn<() => Promise>(), entries: [] as unknown[] })) @@ -11,7 +12,10 @@ vi.mock('./embeddedSessionFlag', () => ({ isEmbeddedSessionEnabled: async () => mocks.enabled })) vi.mock('../devplatform/session', () => ({ - getCloudSession: () => ({ getAccessToken: mocks.getAccessToken }) + getCloudSession: () => ({ + getAccessToken: mocks.getAccessToken, + getPartnerNodeToken: mocks.getPartnerNodeToken + }) })) vi.mock('../host/registry', () => ({ get comfyWindows() { @@ -25,6 +29,7 @@ vi.mock('../host/registry', () => ({ import { EMBEDDED_SESSION_CHANNELS, + partnerNodeTokenForSender, workspaceTokenForSender, broadcastEmbeddedSessionChanged, stateForSender, @@ -161,6 +166,22 @@ describe('embeddedSession', () => { expect(switchWorkspace).not.toHaveBeenCalled() }) + it('drops a partner token when its view is destroyed during mint', async () => { + const { event, webContents } = view('http://127.0.0.1:8000') + const pending = Promise.withResolvers() + mocks.getPartnerNodeToken.mockReturnValueOnce(pending.promise) + const request = partnerNodeTokenForSender(event, 'ws-1') + await vi.waitFor(() => expect(mocks.getPartnerNodeToken).toHaveBeenCalledOnce()) + webContents.isDestroyed = () => true + Object.defineProperty(webContents, 'mainFrame', { + get: () => { + throw new Error('destroyed') + } + }) + pending.resolve('partner-token') + await expect(request).resolves.toBeNull() + }) + it('refuses an unregistered sender', async () => { const event = { sender: { mainFrame: { processId: 1, routingId: 1 } }, diff --git a/src/main/lib/embeddedSession.ts b/src/main/lib/embeddedSession.ts index b052706da..75aadeeaf 100644 --- a/src/main/lib/embeddedSession.ts +++ b/src/main/lib/embeddedSession.ts @@ -61,7 +61,7 @@ function servesEntry(entry: ComfyWindowEntry, currentUrl: string): boolean { /** The sender is the main frame of a registered comfyView, on its own loopback ComfyUI. */ export function isTrustedSender({ sender, senderFrame }: EmbeddedSessionSender): boolean { const entry = findEntryByComfySender(sender) - if (!entry || !senderFrame) return false + if (!entry || !senderFrame || sender.isDestroyed() || senderFrame.detached) return false const mainFrame = sender.mainFrame if ( senderFrame.processId !== mainFrame.processId ||