From 97b2a4b562c739bcbbcfde68cc30582a89ba3ae1 Mon Sep 17 00:00:00 2001 From: Glary-Bot Date: Tue, 11 Aug 2026 03:27:00 +0000 Subject: [PATCH 1/7] feat(featureFlags): add employee-gated session flag overrides via ?ff= Adds an opt-in registry of feature flags that Comfy employees can override per browser tab with ?ff=name or ?ff=name:value, resolved ahead of the dev localStorage override, remote config and the server flag. Overrides are captured into sessionStorage so they survive reloads and in-app navigation but die with the tab, and are only applied for a signed-in user with a verified @comfy.org address on the cloud distribution. --- src/composables/useFeatureFlags.test.ts | 51 +++++ src/composables/useFeatureFlags.ts | 10 +- src/utils/sessionFeatureFlagOverride.test.ts | 190 ++++++++++++++++++ src/utils/sessionFeatureFlagOverride.ts | 200 +++++++++++++++++++ 4 files changed, 450 insertions(+), 1 deletion(-) create mode 100644 src/utils/sessionFeatureFlagOverride.test.ts create mode 100644 src/utils/sessionFeatureFlagOverride.ts diff --git a/src/composables/useFeatureFlags.test.ts b/src/composables/useFeatureFlags.test.ts index 23214593b58..01ca038b093 100644 --- a/src/composables/useFeatureFlags.test.ts +++ b/src/composables/useFeatureFlags.test.ts @@ -13,6 +13,7 @@ import { remoteConfigState } from '@/platform/remoteConfig/remoteConfig' import { api } from '@/scripts/api' +import { getSessionOverride } from '@/utils/sessionFeatureFlagOverride' // Mock the API module vi.mock('@/scripts/api', () => ({ @@ -21,6 +22,10 @@ vi.mock('@/scripts/api', () => ({ } })) +vi.mock('@/utils/sessionFeatureFlagOverride', () => ({ + getSessionOverride: vi.fn() +})) + // Mock the distribution types module vi.mock('@/platform/distribution/types', () => ({ isCloud: false, @@ -489,4 +494,50 @@ describe('useFeatureFlags', () => { expect(flags.unifiedCloudAuthEnabled).toBe(true) }) }) + + describe('session override precedence', () => { + afterEach(() => { + vi.mocked(getSessionOverride).mockReset() + vi.mocked(distributionTypes).isCloud = false + localStorage.clear() + remoteConfig.value = {} + }) + + it('beats the dev override, remote config and the server value', () => { + vi.mocked(getSessionOverride).mockImplementation((flagKey) => + flagKey === ServerFeatureFlag.SIGNUP_TURNSTILE ? 'enforce' : undefined + ) + localStorage.setItem( + `ff:${ServerFeatureFlag.SIGNUP_TURNSTILE}`, + '"shadow"' + ) + remoteConfig.value = { signup_turnstile: 'off' } + vi.mocked(api.getServerFeature).mockReturnValue('off') + + const { flags } = useFeatureFlags() + expect(flags.signupTurnstileMode).toBe('enforce') + }) + + it('applies a false override instead of falling through to an enabled server value', () => { + vi.mocked(getSessionOverride).mockImplementation((flagKey) => + flagKey === ServerFeatureFlag.WORKFLOW_SHARING_ENABLED + ? false + : undefined + ) + vi.mocked(api.getServerFeature).mockReturnValue(true) + + const { flags } = useFeatureFlags() + expect(flags.workflowSharingEnabled).toBe(false) + }) + + it('beats the isCloud and auth-window guards on auth-gated flags', () => { + vi.mocked(distributionTypes).isCloud = false + vi.mocked(getSessionOverride).mockImplementation((flagKey) => + flagKey === ServerFeatureFlag.BILLING_CONTROL_ENABLED ? true : undefined + ) + + const { flags } = useFeatureFlags() + expect(flags.billingControlEnabled).toBe(true) + }) + }) }) diff --git a/src/composables/useFeatureFlags.ts b/src/composables/useFeatureFlags.ts index 22e7d2a7052..a1ab9742c9d 100644 --- a/src/composables/useFeatureFlags.ts +++ b/src/composables/useFeatureFlags.ts @@ -10,6 +10,7 @@ import { } from '@/platform/remoteConfig/remoteConfig' import { api } from '@/scripts/api' import { getDevOverride } from '@/utils/devFeatureFlagOverride' +import { getSessionOverride } from '@/utils/sessionFeatureFlagOverride' /** * Known server feature flags (top-level, not extensions) @@ -42,13 +43,17 @@ export enum ServerFeatureFlag { } /** - * Resolves a feature flag value with dev override > remoteConfig > serverFeature priority. + * Resolves a feature flag value with session override > dev override > + * remoteConfig > serverFeature priority. */ function resolveFlag( flagKey: string, remoteConfigValue: T | undefined, defaultValue: T ): T { + const sessionOverride = getSessionOverride(flagKey) + if (sessionOverride !== undefined) return sessionOverride + const override = getDevOverride(flagKey) if (override !== undefined) return override return remoteConfigValue ?? api.getServerFeature(flagKey, defaultValue) @@ -65,6 +70,9 @@ function resolveAuthGatedFlag( remoteConfigValue: boolean | undefined, cachedValue: Ref ): boolean { + const sessionOverride = getSessionOverride(flagKey) + if (sessionOverride !== undefined) return sessionOverride + const override = getDevOverride(flagKey) if (override !== undefined) return override diff --git a/src/utils/sessionFeatureFlagOverride.test.ts b/src/utils/sessionFeatureFlagOverride.test.ts new file mode 100644 index 00000000000..4250c1e9e0f --- /dev/null +++ b/src/utils/sessionFeatureFlagOverride.test.ts @@ -0,0 +1,190 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' + +const mockDistribution = vi.hoisted(() => ({ + isCloud: true, + isNightly: false +})) +vi.mock('@/platform/distribution/types', () => mockDistribution) + +type MockUser = { email: string | null; emailVerified: boolean } + +const mockCurrentUser = vi.hoisted(() => ({ + value: null as MockUser | null | undefined +})) +vi.mock('vuefire', () => ({ + useCurrentUser: vi.fn(() => mockCurrentUser) +})) + +const COMFY_EMPLOYEE = { email: 'dev@comfy.org', emailVerified: true } + +/** + * Overrides are captured once per page load, so each case re-imports the module + * behind a fresh URL. + */ +async function visit(search: string) { + window.history.replaceState({}, '', search) + vi.resetModules() + return import('@/utils/sessionFeatureFlagOverride') +} + +describe('getSessionOverride', () => { + beforeEach(() => { + mockDistribution.isCloud = true + mockCurrentUser.value = COMFY_EMPLOYEE + sessionStorage.clear() + }) + + afterEach(() => { + window.history.replaceState({}, '', '/') + vi.restoreAllMocks() + }) + + it('reads a bare flag as boolean true', async () => { + const { getSessionOverride } = await visit('/?ff=onboarding_tour_enabled') + + expect(getSessionOverride('onboarding_tour_enabled')).toBe(true) + }) + + it('parses an explicit boolean rather than a truthy string', async () => { + const { getSessionOverride } = await visit( + '/?ff=onboarding_tour_enabled:false' + ) + + expect(getSessionOverride('onboarding_tour_enabled')).toBe(false) + }) + + it('carries a string value for multivariate flags', async () => { + const { getSessionOverride } = await visit('/?ff=signup_turnstile:enforce') + + expect(getSessionOverride('signup_turnstile')).toBe('enforce') + }) + + it('keeps colons inside a string value', async () => { + const { getSessionOverride } = await visit('/?ff=signup_turnstile:a:b') + + expect(getSessionOverride('signup_turnstile')).toBe('a:b') + }) + + it('applies every flag in a repeated query param', async () => { + const { getSessionOverride } = await visit( + '/?ff=workflow_sharing_enabled&ff=signup_turnstile:shadow' + ) + + expect(getSessionOverride('workflow_sharing_enabled')).toBe(true) + expect(getSessionOverride('signup_turnstile')).toBe('shadow') + }) + + it('returns undefined for a flag nobody requested', async () => { + const { getSessionOverride } = await visit('/?ff=onboarding_tour_enabled') + + expect(getSessionOverride('workflow_sharing_enabled')).toBeUndefined() + }) + + it('survives navigation away from the ?ff= URL', async () => { + const first = await visit('/?ff=onboarding_tour_enabled') + expect(first.getSessionOverride('onboarding_tour_enabled')).toBe(true) + + const { getSessionOverride } = await visit('/some/other/page') + expect(getSessionOverride('onboarding_tour_enabled')).toBe(true) + }) + + it('clears every override for the session on a nameless ?ff=', async () => { + const first = await visit('/?ff=onboarding_tour_enabled') + expect(first.getSessionOverride('onboarding_tour_enabled')).toBe(true) + + const { getSessionOverride } = await visit('/?ff=') + expect(getSessionOverride('onboarding_tour_enabled')).toBeUndefined() + expect(sessionStorage.getItem('Comfy.FeatureFlagOverride')).toBeNull() + }) + + describe('rejected requests', () => { + it('ignores a flag that has not opted in', async () => { + const warn = vi.spyOn(console, 'warn').mockImplementation(() => {}) + const { getSessionOverride } = await visit('/?ff=unified_cloud_auth') + + expect(getSessionOverride('unified_cloud_auth')).toBeUndefined() + expect(warn).toHaveBeenCalledWith( + '[ff] "unified_cloud_auth" is not registered as an overridable flag' + ) + }) + + it('ignores a value that is not valid for the declared type', async () => { + const warn = vi.spyOn(console, 'warn').mockImplementation(() => {}) + const { getSessionOverride } = await visit( + '/?ff=onboarding_tour_enabled:yes' + ) + + expect(getSessionOverride('onboarding_tour_enabled')).toBeUndefined() + expect(warn).toHaveBeenCalledWith( + '[ff] Invalid boolean value for "onboarding_tour_enabled":', + 'yes' + ) + }) + + it('ignores a string flag requested without a value', async () => { + const { getSessionOverride } = await visit('/?ff=signup_turnstile') + + expect(getSessionOverride('signup_turnstile')).toBeUndefined() + }) + + it('ignores hand-written sessionStorage entries', async () => { + sessionStorage.setItem( + 'Comfy.FeatureFlagOverride', + JSON.stringify({ + unified_cloud_auth: true, + onboarding_tour_enabled: 'not-a-boolean' + }) + ) + const { getSessionOverride } = await visit('/') + + expect(getSessionOverride('unified_cloud_auth')).toBeUndefined() + expect(getSessionOverride('onboarding_tour_enabled')).toBeUndefined() + }) + }) + + describe('employee gate', () => { + const blockedIdentities: [ + label: string, + currentUser: MockUser | null | undefined + ][] = [ + [ + 'a lookalike domain', + { email: 'dev@notcomfy.org', emailVerified: true } + ], + [ + 'an unverified address', + { email: 'dev@comfy.org', emailVerified: false } + ], + ['a signed-out session', null], + ['a session where auth has not resolved yet', undefined] + ] + + it.for(blockedIdentities)( + 'withholds the override for %s', + async ([, currentUser]) => { + mockCurrentUser.value = currentUser + const { getSessionOverride } = await visit( + '/?ff=onboarding_tour_enabled' + ) + + expect(getSessionOverride('onboarding_tour_enabled')).toBeUndefined() + } + ) + + it('applies the override once auth resolves mid-session', async () => { + mockCurrentUser.value = undefined + const { getSessionOverride } = await visit('/?ff=onboarding_tour_enabled') + expect(getSessionOverride('onboarding_tour_enabled')).toBeUndefined() + + mockCurrentUser.value = COMFY_EMPLOYEE + expect(getSessionOverride('onboarding_tour_enabled')).toBe(true) + }) + + it('withholds the override outside the cloud distribution', async () => { + mockDistribution.isCloud = false + const { getSessionOverride } = await visit('/?ff=onboarding_tour_enabled') + + expect(getSessionOverride('onboarding_tour_enabled')).toBeUndefined() + }) + }) +}) diff --git a/src/utils/sessionFeatureFlagOverride.ts b/src/utils/sessionFeatureFlagOverride.ts new file mode 100644 index 00000000000..a4390a76f08 --- /dev/null +++ b/src/utils/sessionFeatureFlagOverride.ts @@ -0,0 +1,200 @@ +import { useCurrentUser } from 'vuefire' + +import type { ServerFeatureFlag } from '@/composables/useFeatureFlags' +import { isCloud } from '@/platform/distribution/types' + +const STORAGE_KEY = 'Comfy.FeatureFlagOverride' +const QUERY_PARAM = 'ff' +const EMPLOYEE_EMAIL_DOMAIN = '@comfy.org' + +type OverridableFlagType = 'boolean' | 'string' +type OverrideValue = boolean | string + +/** + * Flags that opt in to session overrides, and the value type each one accepts. + * + * Adding a key here is the only way to make a flag overridable — an unlisted + * flag is ignored, so a stale link can never reach into unrelated behaviour. + * The declared type is what makes `?ff=some_flag:false` resolve to the boolean + * `false` rather than the truthy string `'false'`. + */ +const OVERRIDABLE_FEATURE_FLAGS = { + asset_rename_enabled: 'boolean', + comfyhub_profile_gate_enabled: 'boolean', + comfyhub_upload_enabled: 'boolean', + model_upload_button_enabled: 'boolean', + onboarding_survey_enabled: 'boolean', + onboarding_tour_enabled: 'boolean', + partner_node_governance_enabled: 'boolean', + private_models_enabled: 'boolean', + signup_turnstile: 'string', + supports_model_type_tags: 'boolean', + user_secrets_enabled: 'boolean', + workflow_sharing_enabled: 'boolean' +} as const satisfies Partial< + Record<`${ServerFeatureFlag}`, OverridableFlagType> +> + +type OverridableFlag = keyof typeof OVERRIDABLE_FEATURE_FLAGS +type OverrideMap = Partial> + +function isOverridableFlag(name: string): name is OverridableFlag { + return Object.hasOwn(OVERRIDABLE_FEATURE_FLAGS, name) +} + +/** + * Reads Firebase auth straight from VueFire rather than through `authStore`, + * which would pull the whole app module graph into every feature flag read. + * The ref holds undefined until auth resolves and null when signed out. + */ +function currentFirebaseUser() { + try { + return useCurrentUser().value + } catch { + return null + } +} + +/** + * Overrides apply only to a signed-in Comfy employee, so a link handed to a + * customer stays inert on their machine. + */ +function isComfyEmployee(): boolean { + const user = currentFirebaseUser() + if (!user?.emailVerified) return false + + return user.email?.toLowerCase().endsWith(EMPLOYEE_EMAIL_DOMAIN) ?? false +} + +function parseOverrideValue( + flag: OverridableFlag, + rawValue: string | undefined +): OverrideValue | undefined { + if (OVERRIDABLE_FEATURE_FLAGS[flag] === 'string') { + return rawValue || undefined + } + if (rawValue === undefined) return true + + const normalized = rawValue.toLowerCase() + if (normalized === 'true') return true + if (normalized === 'false') return false + return undefined +} + +function readStoredOverrides(): OverrideMap { + let raw: string | null + try { + raw = sessionStorage.getItem(STORAGE_KEY) + } catch { + return {} + } + if (!raw) return {} + + let parsed: unknown + try { + parsed = JSON.parse(raw) + } catch { + return {} + } + if (typeof parsed !== 'object' || parsed === null) return {} + + const overrides: OverrideMap = {} + for (const [name, value] of Object.entries(parsed)) { + if (!isOverridableFlag(name)) continue + if (typeof value !== 'boolean' && typeof value !== 'string') continue + if (typeof value !== OVERRIDABLE_FEATURE_FLAGS[name]) continue + overrides[name] = value + } + return overrides +} + +function writeStoredOverrides(overrides: OverrideMap): void { + try { + if (Object.keys(overrides).length === 0) { + sessionStorage.removeItem(STORAGE_KEY) + return + } + sessionStorage.setItem(STORAGE_KEY, JSON.stringify(overrides)) + } catch { + console.warn('[ff] Failed to persist session feature flag overrides') + } +} + +function splitRequest(request: string): [name: string, value?: string] { + const separator = request.indexOf(':') + if (separator === -1) return [request] + return [request.slice(0, separator), request.slice(separator + 1)] +} + +/** + * Merges `?ff=` requests from the current URL into the overrides already held + * for this tab. An `?ff=` with no name clears every override in the session. + */ +function captureUrlOverrides(stored: OverrideMap): OverrideMap { + let requests: string[] + try { + requests = new URLSearchParams(window.location.search).getAll(QUERY_PARAM) + } catch { + return stored + } + if (requests.length === 0) return stored + + if (requests.includes('')) { + writeStoredOverrides({}) + return {} + } + + const overrides: OverrideMap = { ...stored } + for (const request of requests) { + const [name, rawValue] = splitRequest(request) + + if (!isOverridableFlag(name)) { + console.warn(`[ff] "${name}" is not registered as an overridable flag`) + continue + } + + const value = parseOverrideValue(name, rawValue) + if (value === undefined) { + console.warn( + `[ff] Invalid ${OVERRIDABLE_FEATURE_FLAGS[name]} value for "${name}":`, + rawValue + ) + continue + } + + overrides[name] = value + } + + writeStoredOverrides(overrides) + return overrides +} + +let sessionOverrides: OverrideMap | undefined + +function loadSessionOverrides(): OverrideMap { + sessionOverrides ??= captureUrlOverrides(readStoredOverrides()) + return sessionOverrides +} + +/** + * Gets a session feature flag override requested via `?ff=name` (boolean flags) + * or `?ff=name:value`, repeatable to override several flags at once. + * + * The request is captured into `sessionStorage` on the first read, so it + * survives reloads and in-app navigation but dies when the tab closes. Capture + * happens before authentication resolves; the employee check is applied here on + * every read instead, so a flag flips as soon as the user is known. + * + * Returns undefined (not null) as the "no override" sentinel, matching + * `getDevOverride`. + */ +export function getSessionOverride(flagKey: string): T | undefined { + if (!isCloud) return undefined + + const overrides = loadSessionOverrides() + if (!isOverridableFlag(flagKey)) return undefined + if (!Object.hasOwn(overrides, flagKey)) return undefined + if (!isComfyEmployee()) return undefined + + return overrides[flagKey] as T +} From f9321e6dce0de00f591e2357b1500c3844eff3a6 Mon Sep 17 00:00:00 2001 From: Glary-Bot Date: Tue, 11 Aug 2026 03:50:01 +0000 Subject: [PATCH 2/7] refactor(featureFlags): make override capture idempotent instead of memoised Persist the query string the overrides were captured from, so re-reading the same URL neither re-warns nor rewrites storage. This drops the module-level memo, which per docs/guidance/vitest.md forced the test file to re-import behind vi.resetModules() for every case. --- src/utils/sessionFeatureFlagOverride.test.ts | 130 +++++++++++-------- src/utils/sessionFeatureFlagOverride.ts | 92 ++++++++----- 2 files changed, 136 insertions(+), 86 deletions(-) diff --git a/src/utils/sessionFeatureFlagOverride.test.ts b/src/utils/sessionFeatureFlagOverride.test.ts index 4250c1e9e0f..269e7368010 100644 --- a/src/utils/sessionFeatureFlagOverride.test.ts +++ b/src/utils/sessionFeatureFlagOverride.test.ts @@ -1,5 +1,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' +import { getSessionOverride } from '@/utils/sessionFeatureFlagOverride' + const mockDistribution = vi.hoisted(() => ({ isCloud: true, isNightly: false @@ -16,15 +18,10 @@ vi.mock('vuefire', () => ({ })) const COMFY_EMPLOYEE = { email: 'dev@comfy.org', emailVerified: true } +const STORAGE_KEY = 'Comfy.FeatureFlagOverride' -/** - * Overrides are captured once per page load, so each case re-imports the module - * behind a fresh URL. - */ -async function visit(search: string) { +function visit(search: string) { window.history.replaceState({}, '', search) - vi.resetModules() - return import('@/utils/sessionFeatureFlagOverride') } describe('getSessionOverride', () => { @@ -39,68 +36,81 @@ describe('getSessionOverride', () => { vi.restoreAllMocks() }) - it('reads a bare flag as boolean true', async () => { - const { getSessionOverride } = await visit('/?ff=onboarding_tour_enabled') + it('reads a bare flag as boolean true', () => { + visit('/?ff=onboarding_tour_enabled') expect(getSessionOverride('onboarding_tour_enabled')).toBe(true) }) - it('parses an explicit boolean rather than a truthy string', async () => { - const { getSessionOverride } = await visit( - '/?ff=onboarding_tour_enabled:false' - ) + it('parses an explicit boolean rather than a truthy string', () => { + visit('/?ff=onboarding_tour_enabled:false') expect(getSessionOverride('onboarding_tour_enabled')).toBe(false) }) - it('carries a string value for multivariate flags', async () => { - const { getSessionOverride } = await visit('/?ff=signup_turnstile:enforce') + it('carries a string value for multivariate flags', () => { + visit('/?ff=signup_turnstile:enforce') expect(getSessionOverride('signup_turnstile')).toBe('enforce') }) - it('keeps colons inside a string value', async () => { - const { getSessionOverride } = await visit('/?ff=signup_turnstile:a:b') + it('keeps colons inside a string value', () => { + visit('/?ff=signup_turnstile:a:b') expect(getSessionOverride('signup_turnstile')).toBe('a:b') }) - it('applies every flag in a repeated query param', async () => { - const { getSessionOverride } = await visit( - '/?ff=workflow_sharing_enabled&ff=signup_turnstile:shadow' - ) + it('applies every flag in a repeated query param', () => { + visit('/?ff=workflow_sharing_enabled&ff=signup_turnstile:shadow') expect(getSessionOverride('workflow_sharing_enabled')).toBe(true) expect(getSessionOverride('signup_turnstile')).toBe('shadow') }) - it('returns undefined for a flag nobody requested', async () => { - const { getSessionOverride } = await visit('/?ff=onboarding_tour_enabled') + it('returns undefined for a flag nobody requested', () => { + visit('/?ff=onboarding_tour_enabled') expect(getSessionOverride('workflow_sharing_enabled')).toBeUndefined() }) - it('survives navigation away from the ?ff= URL', async () => { - const first = await visit('/?ff=onboarding_tour_enabled') - expect(first.getSessionOverride('onboarding_tour_enabled')).toBe(true) + it('survives navigation away from the ?ff= URL', () => { + visit('/?ff=onboarding_tour_enabled') + expect(getSessionOverride('onboarding_tour_enabled')).toBe(true) - const { getSessionOverride } = await visit('/some/other/page') + visit('/some/other/page') expect(getSessionOverride('onboarding_tour_enabled')).toBe(true) }) - it('clears every override for the session on a nameless ?ff=', async () => { - const first = await visit('/?ff=onboarding_tour_enabled') - expect(first.getSessionOverride('onboarding_tour_enabled')).toBe(true) + it('clears every override for the session on a nameless ?ff=', () => { + visit('/?ff=onboarding_tour_enabled') + expect(getSessionOverride('onboarding_tour_enabled')).toBe(true) + + visit('/?ff=') + expect(getSessionOverride('onboarding_tour_enabled')).toBeUndefined() + }) + + it('warns once per URL no matter how often a flag is read', () => { + const warn = vi.spyOn(console, 'warn').mockImplementation(() => {}) + visit('/?ff=bogus_flag_name') + + getSessionOverride('onboarding_tour_enabled') + getSessionOverride('onboarding_tour_enabled') + getSessionOverride('signup_turnstile') + + expect(warn).toHaveBeenCalledTimes(1) + }) + + it('leaves storage untouched for a session that never asks for an override', () => { + visit('/?unrelated=1') - const { getSessionOverride } = await visit('/?ff=') expect(getSessionOverride('onboarding_tour_enabled')).toBeUndefined() - expect(sessionStorage.getItem('Comfy.FeatureFlagOverride')).toBeNull() + expect(sessionStorage.getItem(STORAGE_KEY)).toBeNull() }) describe('rejected requests', () => { - it('ignores a flag that has not opted in', async () => { + it('ignores a flag that has not opted in', () => { const warn = vi.spyOn(console, 'warn').mockImplementation(() => {}) - const { getSessionOverride } = await visit('/?ff=unified_cloud_auth') + visit('/?ff=unified_cloud_auth') expect(getSessionOverride('unified_cloud_auth')).toBeUndefined() expect(warn).toHaveBeenCalledWith( @@ -108,11 +118,9 @@ describe('getSessionOverride', () => { ) }) - it('ignores a value that is not valid for the declared type', async () => { + it('ignores a value that is not valid for the declared type', () => { const warn = vi.spyOn(console, 'warn').mockImplementation(() => {}) - const { getSessionOverride } = await visit( - '/?ff=onboarding_tour_enabled:yes' - ) + visit('/?ff=onboarding_tour_enabled:yes') expect(getSessionOverride('onboarding_tour_enabled')).toBeUndefined() expect(warn).toHaveBeenCalledWith( @@ -121,25 +129,35 @@ describe('getSessionOverride', () => { ) }) - it('ignores a string flag requested without a value', async () => { - const { getSessionOverride } = await visit('/?ff=signup_turnstile') + it('ignores a string flag requested without a value', () => { + visit('/?ff=signup_turnstile') expect(getSessionOverride('signup_turnstile')).toBeUndefined() }) - it('ignores hand-written sessionStorage entries', async () => { + it('ignores hand-written sessionStorage entries', () => { sessionStorage.setItem( - 'Comfy.FeatureFlagOverride', + STORAGE_KEY, JSON.stringify({ - unified_cloud_auth: true, - onboarding_tour_enabled: 'not-a-boolean' + search: '', + overrides: { + unified_cloud_auth: true, + onboarding_tour_enabled: 'not-a-boolean' + } }) ) - const { getSessionOverride } = await visit('/') + visit('/') expect(getSessionOverride('unified_cloud_auth')).toBeUndefined() expect(getSessionOverride('onboarding_tour_enabled')).toBeUndefined() }) + + it('ignores a corrupt storage payload', () => { + sessionStorage.setItem(STORAGE_KEY, 'not json') + visit('/?ff=onboarding_tour_enabled') + + expect(getSessionOverride('onboarding_tour_enabled')).toBe(true) + }) }) describe('employee gate', () => { @@ -161,30 +179,36 @@ describe('getSessionOverride', () => { it.for(blockedIdentities)( 'withholds the override for %s', - async ([, currentUser]) => { + ([, currentUser]) => { mockCurrentUser.value = currentUser - const { getSessionOverride } = await visit( - '/?ff=onboarding_tour_enabled' - ) + visit('/?ff=onboarding_tour_enabled') expect(getSessionOverride('onboarding_tour_enabled')).toBeUndefined() } ) - it('applies the override once auth resolves mid-session', async () => { + it('applies the override once auth resolves mid-session', () => { mockCurrentUser.value = undefined - const { getSessionOverride } = await visit('/?ff=onboarding_tour_enabled') + visit('/?ff=onboarding_tour_enabled') expect(getSessionOverride('onboarding_tour_enabled')).toBeUndefined() mockCurrentUser.value = COMFY_EMPLOYEE expect(getSessionOverride('onboarding_tour_enabled')).toBe(true) }) - it('withholds the override outside the cloud distribution', async () => { + it('accepts a verified address regardless of case', () => { + mockCurrentUser.value = { email: 'Dev@Comfy.org', emailVerified: true } + visit('/?ff=onboarding_tour_enabled') + + expect(getSessionOverride('onboarding_tour_enabled')).toBe(true) + }) + + it('withholds the override outside the cloud distribution', () => { mockDistribution.isCloud = false - const { getSessionOverride } = await visit('/?ff=onboarding_tour_enabled') + visit('/?ff=onboarding_tour_enabled') expect(getSessionOverride('onboarding_tour_enabled')).toBeUndefined() + expect(sessionStorage.getItem(STORAGE_KEY)).toBeNull() }) }) }) diff --git a/src/utils/sessionFeatureFlagOverride.ts b/src/utils/sessionFeatureFlagOverride.ts index a4390a76f08..8a6c047dadd 100644 --- a/src/utils/sessionFeatureFlagOverride.ts +++ b/src/utils/sessionFeatureFlagOverride.ts @@ -81,40 +81,58 @@ function parseOverrideValue( return undefined } -function readStoredOverrides(): OverrideMap { +/** + * The captured overrides plus the query string they came from. Remembering the + * source makes capture idempotent: re-reading the same URL neither re-warns nor + * rewrites, so a flag can be read as often as a render needs. + */ +type StoredState = { search: string; overrides: OverrideMap } + +function emptyState(): StoredState { + return { search: '', overrides: {} } +} + +function coerceStoredOverrides(value: unknown): OverrideMap { + if (typeof value !== 'object' || value === null) return {} + + const overrides: OverrideMap = {} + for (const [name, entry] of Object.entries(value)) { + if (!isOverridableFlag(name)) continue + if (typeof entry !== 'boolean' && typeof entry !== 'string') continue + if (typeof entry !== OVERRIDABLE_FEATURE_FLAGS[name]) continue + overrides[name] = entry + } + return overrides +} + +function readStoredState(): StoredState { let raw: string | null try { raw = sessionStorage.getItem(STORAGE_KEY) } catch { - return {} + return emptyState() } - if (!raw) return {} + if (!raw) return emptyState() let parsed: unknown try { parsed = JSON.parse(raw) } catch { - return {} + return emptyState() } - if (typeof parsed !== 'object' || parsed === null) return {} + if (typeof parsed !== 'object' || parsed === null) return emptyState() - const overrides: OverrideMap = {} - for (const [name, value] of Object.entries(parsed)) { - if (!isOverridableFlag(name)) continue - if (typeof value !== 'boolean' && typeof value !== 'string') continue - if (typeof value !== OVERRIDABLE_FEATURE_FLAGS[name]) continue - overrides[name] = value + const search = 'search' in parsed ? parsed.search : undefined + const overrides = 'overrides' in parsed ? parsed.overrides : undefined + return { + search: typeof search === 'string' ? search : '', + overrides: coerceStoredOverrides(overrides) } - return overrides } -function writeStoredOverrides(overrides: OverrideMap): void { +function writeStoredState(state: StoredState): void { try { - if (Object.keys(overrides).length === 0) { - sessionStorage.removeItem(STORAGE_KEY) - return - } - sessionStorage.setItem(STORAGE_KEY, JSON.stringify(overrides)) + sessionStorage.setItem(STORAGE_KEY, JSON.stringify(state)) } catch { console.warn('[ff] Failed to persist session feature flag overrides') } @@ -126,21 +144,25 @@ function splitRequest(request: string): [name: string, value?: string] { return [request.slice(0, separator), request.slice(separator + 1)] } -/** - * Merges `?ff=` requests from the current URL into the overrides already held - * for this tab. An `?ff=` with no name clears every override in the session. - */ -function captureUrlOverrides(stored: OverrideMap): OverrideMap { - let requests: string[] +function readOverrideRequests(search: string): string[] { try { - requests = new URLSearchParams(window.location.search).getAll(QUERY_PARAM) + return new URLSearchParams(search).getAll(QUERY_PARAM) } catch { - return stored + return [] } - if (requests.length === 0) return stored +} +/** + * Merges `?ff=` requests from the current URL into the overrides already held + * for this tab. An `?ff=` with no name clears every override in the session. + */ +function captureRequests( + requests: string[], + stored: OverrideMap, + search: string +): OverrideMap { if (requests.includes('')) { - writeStoredOverrides({}) + writeStoredState({ search, overrides: {} }) return {} } @@ -165,15 +187,19 @@ function captureUrlOverrides(stored: OverrideMap): OverrideMap { overrides[name] = value } - writeStoredOverrides(overrides) + writeStoredState({ search, overrides }) return overrides } -let sessionOverrides: OverrideMap | undefined - function loadSessionOverrides(): OverrideMap { - sessionOverrides ??= captureUrlOverrides(readStoredOverrides()) - return sessionOverrides + const stored = readStoredState() + const search = window.location.search + if (search === stored.search) return stored.overrides + + const requests = readOverrideRequests(search) + if (requests.length === 0) return stored.overrides + + return captureRequests(requests, stored.overrides, search) } /** From 96f70425079f9804ca06d460b88351a19dccc716 Mon Sep 17 00:00:00 2001 From: Glary-Bot Date: Tue, 11 Aug 2026 05:02:18 +0000 Subject: [PATCH 3/7] feat(featureFlags): make every feature flag session-overridable Drops the opt-in registry: any flag can now be overridden from `?ff=`, and `api.getServerFeature` consults the session override too so flags that never went through `resolveFlag` (max_upload_size, node_replacements) are covered. Value typing moves from the registry to JSON parsing, matching the `ff:` localStorage override, so `:false` is boolean and `:12` a number while anything JSON rejects stays a string. The verified @comfy.org gate is now the only boundary, so the rejected-value diagnostic no longer echoes user input. Adds a project-owned currentUserIdentity adapter so tests mock our own seam rather than vuefire, and fixes the auth-gated precedence test to assert a reachable scenario. --- src/composables/useFeatureFlags.test.ts | 8 +- .../auth/identity/currentUserIdentity.ts | 25 ++++ src/scripts/api.ts | 4 + src/utils/sessionFeatureFlagOverride.test.ts | 87 +++++++------ src/utils/sessionFeatureFlagOverride.ts | 120 ++++-------------- 5 files changed, 107 insertions(+), 137 deletions(-) create mode 100644 src/platform/auth/identity/currentUserIdentity.ts diff --git a/src/composables/useFeatureFlags.test.ts b/src/composables/useFeatureFlags.test.ts index 01ca038b093..1069e0003b4 100644 --- a/src/composables/useFeatureFlags.test.ts +++ b/src/composables/useFeatureFlags.test.ts @@ -499,6 +499,8 @@ describe('useFeatureFlags', () => { afterEach(() => { vi.mocked(getSessionOverride).mockReset() vi.mocked(distributionTypes).isCloud = false + remoteConfigState.value = 'unloaded' + cachedBillingControlEnabled.value = undefined localStorage.clear() remoteConfig.value = {} }) @@ -530,8 +532,10 @@ describe('useFeatureFlags', () => { expect(flags.workflowSharingEnabled).toBe(false) }) - it('beats the isCloud and auth-window guards on auth-gated flags', () => { - vi.mocked(distributionTypes).isCloud = false + it('beats the auth-window fallback on auth-gated flags', () => { + vi.mocked(distributionTypes).isCloud = true + remoteConfigState.value = 'unloaded' + cachedBillingControlEnabled.value = false vi.mocked(getSessionOverride).mockImplementation((flagKey) => flagKey === ServerFeatureFlag.BILLING_CONTROL_ENABLED ? true : undefined ) diff --git a/src/platform/auth/identity/currentUserIdentity.ts b/src/platform/auth/identity/currentUserIdentity.ts new file mode 100644 index 00000000000..886139c7082 --- /dev/null +++ b/src/platform/auth/identity/currentUserIdentity.ts @@ -0,0 +1,25 @@ +import { useCurrentUser } from 'vuefire' + +/** + * The only identity fields a caller needs to decide whether the signed-in user + * belongs to a given email domain. + */ +export type UserIdentity = { + email: string | null + emailVerified: boolean +} + +/** + * Reads Firebase auth straight from VueFire rather than through `authStore`, + * which would pull the whole app module graph into the caller. Returns + * undefined until auth resolves and null when nobody is signed in. + */ +export function getCurrentUserIdentity(): UserIdentity | null | undefined { + try { + const user = useCurrentUser().value + if (!user) return user + return { email: user.email, emailVerified: user.emailVerified } + } catch { + return null + } +} diff --git a/src/scripts/api.ts b/src/scripts/api.ts index e91538c6ada..f35ef9ca008 100644 --- a/src/scripts/api.ts +++ b/src/scripts/api.ts @@ -11,6 +11,7 @@ import { shouldRemintCloudRequest } from '@/platform/auth/unified/remintRetry' import { getDevOverride } from '@/utils/devFeatureFlagOverride' +import { getSessionOverride } from '@/utils/sessionFeatureFlagOverride' import type { ModelFile, ModelFolderInfo @@ -1618,6 +1619,9 @@ export class ComfyApi extends EventTarget { * @returns The feature value or default */ getServerFeature(featureName: string, defaultValue?: T): T { + const sessionOverride = getSessionOverride(featureName) + if (sessionOverride !== undefined) return sessionOverride + const override = getDevOverride(featureName) if (override !== undefined) return override return get(this.serverFeatureFlags.value, featureName, defaultValue) as T diff --git a/src/utils/sessionFeatureFlagOverride.test.ts b/src/utils/sessionFeatureFlagOverride.test.ts index 269e7368010..791d5bed92a 100644 --- a/src/utils/sessionFeatureFlagOverride.test.ts +++ b/src/utils/sessionFeatureFlagOverride.test.ts @@ -13,8 +13,8 @@ type MockUser = { email: string | null; emailVerified: boolean } const mockCurrentUser = vi.hoisted(() => ({ value: null as MockUser | null | undefined })) -vi.mock('vuefire', () => ({ - useCurrentUser: vi.fn(() => mockCurrentUser) +vi.mock('@/platform/auth/identity/currentUserIdentity', () => ({ + getCurrentUserIdentity: vi.fn(() => mockCurrentUser.value) })) const COMFY_EMPLOYEE = { email: 'dev@comfy.org', emailVerified: true } @@ -89,15 +89,21 @@ describe('getSessionOverride', () => { expect(getSessionOverride('onboarding_tour_enabled')).toBeUndefined() }) - it('warns once per URL no matter how often a flag is read', () => { - const warn = vi.spyOn(console, 'warn').mockImplementation(() => {}) - visit('/?ff=bogus_flag_name') + it('overrides any flag, with no opt-in registry to join', () => { + visit('/?ff=unified_cloud_auth&ff=some_flag_invented_tomorrow:42') + expect(getSessionOverride('unified_cloud_auth')).toBe(true) + expect(getSessionOverride('some_flag_invented_tomorrow')).toBe(42) + }) + + it('writes storage once per URL no matter how often a flag is read', () => { + visit('/?ff=onboarding_tour_enabled') getSessionOverride('onboarding_tour_enabled') - getSessionOverride('onboarding_tour_enabled') - getSessionOverride('signup_turnstile') - expect(warn).toHaveBeenCalledTimes(1) + const write = vi.spyOn(Storage.prototype, 'setItem') + for (let i = 0; i < 50; i++) getSessionOverride('onboarding_tour_enabled') + + expect(write).not.toHaveBeenCalled() }) it('leaves storage untouched for a session that never asks for an override', () => { @@ -107,49 +113,46 @@ describe('getSessionOverride', () => { expect(sessionStorage.getItem(STORAGE_KEY)).toBeNull() }) - describe('rejected requests', () => { - it('ignores a flag that has not opted in', () => { - const warn = vi.spyOn(console, 'warn').mockImplementation(() => {}) - visit('/?ff=unified_cloud_auth') + describe('value parsing', () => { + it('reads a numeric value as a number', () => { + visit('/?ff=max_upload_size:209715200') - expect(getSessionOverride('unified_cloud_auth')).toBeUndefined() - expect(warn).toHaveBeenCalledWith( - '[ff] "unified_cloud_auth" is not registered as an overridable flag' - ) + expect(getSessionOverride('max_upload_size')).toBe(209715200) }) - it('ignores a value that is not valid for the declared type', () => { - const warn = vi.spyOn(console, 'warn').mockImplementation(() => {}) - visit('/?ff=onboarding_tour_enabled:yes') + it('keeps a quoted numeric value a string', () => { + visit('/?ff=churnkey_app_id:"12345"') - expect(getSessionOverride('onboarding_tour_enabled')).toBeUndefined() - expect(warn).toHaveBeenCalledWith( - '[ff] Invalid boolean value for "onboarding_tour_enabled":', - 'yes' - ) + expect(getSessionOverride('churnkey_app_id')).toBe('12345') }) - it('ignores a string flag requested without a value', () => { - visit('/?ff=signup_turnstile') + it('reads a JSON object value', () => { + visit('/?ff=node_replacements:{"a":"b"}') - expect(getSessionOverride('signup_turnstile')).toBeUndefined() + expect(getSessionOverride('node_replacements')).toEqual({ a: 'b' }) }) - it('ignores hand-written sessionStorage entries', () => { - sessionStorage.setItem( - STORAGE_KEY, - JSON.stringify({ - search: '', - overrides: { - unified_cloud_auth: true, - onboarding_tour_enabled: 'not-a-boolean' - } - }) - ) - visit('/') - - expect(getSessionOverride('unified_cloud_auth')).toBeUndefined() - expect(getSessionOverride('onboarding_tour_enabled')).toBeUndefined() + it('reads an empty value as an empty string', () => { + visit('/?ff=churnkey_app_id:') + + expect(getSessionOverride('churnkey_app_id')).toBe('') + }) + + it('never logs the submitted value, which may carry a pasted secret', () => { + const warn = vi.spyOn(console, 'warn').mockImplementation(() => {}) + const log = vi.spyOn(console, 'log').mockImplementation(() => {}) + visit('/?ff=some_flag:sk-live-not-a-real-secret') + + expect(getSessionOverride('some_flag')).toBe('sk-live-not-a-real-secret') + expect(warn).not.toHaveBeenCalled() + expect(log).not.toHaveBeenCalled() + }) + + it('discards a hand-written storage payload that is not an object', () => { + sessionStorage.setItem(STORAGE_KEY, JSON.stringify(['nope'])) + visit('/?ff=onboarding_tour_enabled') + + expect(getSessionOverride('onboarding_tour_enabled')).toBe(true) }) it('ignores a corrupt storage payload', () => { diff --git a/src/utils/sessionFeatureFlagOverride.ts b/src/utils/sessionFeatureFlagOverride.ts index 8a6c047dadd..72325466d7c 100644 --- a/src/utils/sessionFeatureFlagOverride.ts +++ b/src/utils/sessionFeatureFlagOverride.ts @@ -1,90 +1,45 @@ -import { useCurrentUser } from 'vuefire' - -import type { ServerFeatureFlag } from '@/composables/useFeatureFlags' +import { getCurrentUserIdentity } from '@/platform/auth/identity/currentUserIdentity' import { isCloud } from '@/platform/distribution/types' const STORAGE_KEY = 'Comfy.FeatureFlagOverride' const QUERY_PARAM = 'ff' const EMPLOYEE_EMAIL_DOMAIN = '@comfy.org' -type OverridableFlagType = 'boolean' | 'string' -type OverrideValue = boolean | string - -/** - * Flags that opt in to session overrides, and the value type each one accepts. - * - * Adding a key here is the only way to make a flag overridable — an unlisted - * flag is ignored, so a stale link can never reach into unrelated behaviour. - * The declared type is what makes `?ff=some_flag:false` resolve to the boolean - * `false` rather than the truthy string `'false'`. - */ -const OVERRIDABLE_FEATURE_FLAGS = { - asset_rename_enabled: 'boolean', - comfyhub_profile_gate_enabled: 'boolean', - comfyhub_upload_enabled: 'boolean', - model_upload_button_enabled: 'boolean', - onboarding_survey_enabled: 'boolean', - onboarding_tour_enabled: 'boolean', - partner_node_governance_enabled: 'boolean', - private_models_enabled: 'boolean', - signup_turnstile: 'string', - supports_model_type_tags: 'boolean', - user_secrets_enabled: 'boolean', - workflow_sharing_enabled: 'boolean' -} as const satisfies Partial< - Record<`${ServerFeatureFlag}`, OverridableFlagType> -> - -type OverridableFlag = keyof typeof OVERRIDABLE_FEATURE_FLAGS -type OverrideMap = Partial> - -function isOverridableFlag(name: string): name is OverridableFlag { - return Object.hasOwn(OVERRIDABLE_FEATURE_FLAGS, name) -} - -/** - * Reads Firebase auth straight from VueFire rather than through `authStore`, - * which would pull the whole app module graph into every feature flag read. - * The ref holds undefined until auth resolves and null when signed out. - */ -function currentFirebaseUser() { - try { - return useCurrentUser().value - } catch { - return null - } -} +type OverrideMap = Record /** * Overrides apply only to a signed-in Comfy employee, so a link handed to a - * customer stays inert on their machine. + * customer stays inert on their machine. With every flag overridable, this is + * the only thing standing between a `?ff=` link and the app's behaviour. */ function isComfyEmployee(): boolean { - const user = currentFirebaseUser() + const user = getCurrentUserIdentity() if (!user?.emailVerified) return false return user.email?.toLowerCase().endsWith(EMPLOYEE_EMAIL_DOMAIN) ?? false } -function parseOverrideValue( - flag: OverridableFlag, - rawValue: string | undefined -): OverrideValue | undefined { - if (OVERRIDABLE_FEATURE_FLAGS[flag] === 'string') { - return rawValue || undefined - } +/** + * Reads the value with the same JSON semantics as the `ff:` localStorage + * override, so `:false` is the boolean and `:12` the number rather than a + * truthy string. Anything JSON rejects is taken as a plain string, which is + * what makes `:enforce` work; quote it (`:"12"`) to force a numeric-looking + * value to stay a string. A bare `?ff=name` means "turn this on". + */ +function parseOverrideValue(rawValue: string | undefined): unknown { if (rawValue === undefined) return true - const normalized = rawValue.toLowerCase() - if (normalized === 'true') return true - if (normalized === 'false') return false - return undefined + try { + return JSON.parse(rawValue) + } catch { + return rawValue + } } /** * The captured overrides plus the query string they came from. Remembering the - * source makes capture idempotent: re-reading the same URL neither re-warns nor - * rewrites, so a flag can be read as often as a render needs. + * source makes capture idempotent: re-reading the same URL does not rewrite + * storage, so a flag can be read as often as a render needs. */ type StoredState = { search: string; overrides: OverrideMap } @@ -93,16 +48,10 @@ function emptyState(): StoredState { } function coerceStoredOverrides(value: unknown): OverrideMap { - if (typeof value !== 'object' || value === null) return {} - - const overrides: OverrideMap = {} - for (const [name, entry] of Object.entries(value)) { - if (!isOverridableFlag(name)) continue - if (typeof entry !== 'boolean' && typeof entry !== 'string') continue - if (typeof entry !== OVERRIDABLE_FEATURE_FLAGS[name]) continue - overrides[name] = entry + if (typeof value !== 'object' || value === null || Array.isArray(value)) { + return {} } - return overrides + return { ...value } } function readStoredState(): StoredState { @@ -169,22 +118,7 @@ function captureRequests( const overrides: OverrideMap = { ...stored } for (const request of requests) { const [name, rawValue] = splitRequest(request) - - if (!isOverridableFlag(name)) { - console.warn(`[ff] "${name}" is not registered as an overridable flag`) - continue - } - - const value = parseOverrideValue(name, rawValue) - if (value === undefined) { - console.warn( - `[ff] Invalid ${OVERRIDABLE_FEATURE_FLAGS[name]} value for "${name}":`, - rawValue - ) - continue - } - - overrides[name] = value + overrides[name] = parseOverrideValue(rawValue) } writeStoredState({ search, overrides }) @@ -203,8 +137,9 @@ function loadSessionOverrides(): OverrideMap { } /** - * Gets a session feature flag override requested via `?ff=name` (boolean flags) - * or `?ff=name:value`, repeatable to override several flags at once. + * Gets a session override for any feature flag, requested via `?ff=name` to + * turn it on or `?ff=name:value` for a specific value, repeatable to override + * several flags at once. A nameless `?ff=` clears the session. * * The request is captured into `sessionStorage` on the first read, so it * survives reloads and in-app navigation but dies when the tab closes. Capture @@ -218,7 +153,6 @@ export function getSessionOverride(flagKey: string): T | undefined { if (!isCloud) return undefined const overrides = loadSessionOverrides() - if (!isOverridableFlag(flagKey)) return undefined if (!Object.hasOwn(overrides, flagKey)) return undefined if (!isComfyEmployee()) return undefined From 3a26b582d86e7fe0fdad2b4976bf0e343030dd7a Mon Sep 17 00:00:00 2001 From: Glary-Bot Date: Tue, 11 Aug 2026 06:58:18 +0000 Subject: [PATCH 4/7] refactor(featureFlags): inline the employee check instead of an adapter module The currentUserIdentity adapter existed only to move a test mock boundary off vuefire, and cost a new directory, an exported type and a per-read object copy for one 6-line caller. Reading VueFire directly in isComfyEmployee keeps the one constraint that matters -- never import authStore -- with less machinery. --- .../auth/identity/currentUserIdentity.ts | 25 ------------------- src/utils/sessionFeatureFlagOverride.test.ts | 4 +-- src/utils/sessionFeatureFlagOverride.ts | 19 ++++++++++---- 3 files changed, 16 insertions(+), 32 deletions(-) delete mode 100644 src/platform/auth/identity/currentUserIdentity.ts diff --git a/src/platform/auth/identity/currentUserIdentity.ts b/src/platform/auth/identity/currentUserIdentity.ts deleted file mode 100644 index 886139c7082..00000000000 --- a/src/platform/auth/identity/currentUserIdentity.ts +++ /dev/null @@ -1,25 +0,0 @@ -import { useCurrentUser } from 'vuefire' - -/** - * The only identity fields a caller needs to decide whether the signed-in user - * belongs to a given email domain. - */ -export type UserIdentity = { - email: string | null - emailVerified: boolean -} - -/** - * Reads Firebase auth straight from VueFire rather than through `authStore`, - * which would pull the whole app module graph into the caller. Returns - * undefined until auth resolves and null when nobody is signed in. - */ -export function getCurrentUserIdentity(): UserIdentity | null | undefined { - try { - const user = useCurrentUser().value - if (!user) return user - return { email: user.email, emailVerified: user.emailVerified } - } catch { - return null - } -} diff --git a/src/utils/sessionFeatureFlagOverride.test.ts b/src/utils/sessionFeatureFlagOverride.test.ts index 791d5bed92a..5c9b8b4515c 100644 --- a/src/utils/sessionFeatureFlagOverride.test.ts +++ b/src/utils/sessionFeatureFlagOverride.test.ts @@ -13,8 +13,8 @@ type MockUser = { email: string | null; emailVerified: boolean } const mockCurrentUser = vi.hoisted(() => ({ value: null as MockUser | null | undefined })) -vi.mock('@/platform/auth/identity/currentUserIdentity', () => ({ - getCurrentUserIdentity: vi.fn(() => mockCurrentUser.value) +vi.mock('vuefire', () => ({ + useCurrentUser: vi.fn(() => mockCurrentUser) })) const COMFY_EMPLOYEE = { email: 'dev@comfy.org', emailVerified: true } diff --git a/src/utils/sessionFeatureFlagOverride.ts b/src/utils/sessionFeatureFlagOverride.ts index 72325466d7c..f87db62e473 100644 --- a/src/utils/sessionFeatureFlagOverride.ts +++ b/src/utils/sessionFeatureFlagOverride.ts @@ -1,4 +1,5 @@ -import { getCurrentUserIdentity } from '@/platform/auth/identity/currentUserIdentity' +import { useCurrentUser } from 'vuefire' + import { isCloud } from '@/platform/distribution/types' const STORAGE_KEY = 'Comfy.FeatureFlagOverride' @@ -10,13 +11,21 @@ type OverrideMap = Record /** * Overrides apply only to a signed-in Comfy employee, so a link handed to a * customer stays inert on their machine. With every flag overridable, this is - * the only thing standing between a `?ff=` link and the app's behaviour. + * the only thing standing between a `?ff=` link and the app's behaviour, so it + * fails closed. + * + * Reads VueFire rather than `authStore`, which imports `useFeatureFlags` and + * would drag the whole app module graph into every feature flag read. */ function isComfyEmployee(): boolean { - const user = getCurrentUserIdentity() - if (!user?.emailVerified) return false + try { + const user = useCurrentUser().value + if (!user?.emailVerified) return false - return user.email?.toLowerCase().endsWith(EMPLOYEE_EMAIL_DOMAIN) ?? false + return user.email?.toLowerCase().endsWith(EMPLOYEE_EMAIL_DOMAIN) ?? false + } catch { + return false + } } /** From fd1c150008cf1b0c694f0dd8928841f1f94c5bf1 Mon Sep 17 00:00:00 2001 From: Glary-Bot Date: Tue, 11 Aug 2026 07:09:52 +0000 Subject: [PATCH 5/7] test(api): characterize getServerFeature resolution before the override layer Pins the behaviour getServerFeature had with no override in front of it: verbatim server values, falsy values that must not fall back to the default, dot-notation paths, and default handling. Verified to pass against main's unmodified api.ts, so it characterises existing behaviour rather than the change on this branch. --- src/scripts/api.featureFlags.test.ts | 58 ++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+) diff --git a/src/scripts/api.featureFlags.test.ts b/src/scripts/api.featureFlags.test.ts index 7dedbb01500..81e41e3b30b 100644 --- a/src/scripts/api.featureFlags.test.ts +++ b/src/scripts/api.featureFlags.test.ts @@ -428,6 +428,64 @@ describe('API Feature Flags', () => { expect(autoQueueGraphChanged).toHaveBeenCalledTimes(2) }) + /** + * Pins the resolution behaviour `getServerFeature` had before any override + * layer was placed in front of it, so a future layer cannot quietly change + * how server values, falsy values, nested paths or defaults resolve. + */ + describe('characterization: resolution with no override present', () => { + afterEach(() => { + localStorage.clear() + }) + + it('returns the server value verbatim', () => { + api.serverFeatureFlags.value = { some_flag: 'server_value' } + + expect(api.getServerFeature('some_flag')).toBe('server_value') + }) + + it.for([ + ['false', false], + ['zero', 0], + ['empty string', ''] + ] as [label: string, serverValue: unknown][])( + 'keeps a server value of %s instead of falling back to the default', + ([, serverValue]) => { + api.serverFeatureFlags.value = { some_flag: serverValue } + + expect(api.getServerFeature('some_flag', 'DEFAULT')).toBe(serverValue) + } + ) + + it('returns the default when the flag is absent', () => { + api.serverFeatureFlags.value = {} + + expect(api.getServerFeature('missing_flag', 'DEFAULT')).toBe('DEFAULT') + }) + + it('returns undefined when the flag is absent and no default is given', () => { + api.serverFeatureFlags.value = {} + + expect(api.getServerFeature('missing_flag')).toBeUndefined() + }) + + it('resolves a nested flag through dot notation', () => { + api.serverFeatureFlags.value = { + extension: { manager: { supports_v4: true } } + } + + expect(api.getServerFeature('extension.manager.supports_v4')).toBe(true) + }) + + it('returns the default for a nested path that does not exist', () => { + api.serverFeatureFlags.value = { extension: {} } + + expect( + api.getServerFeature('extension.manager.supports_v4', 'DEFAULT') + ).toBe('DEFAULT') + }) + }) + describe('Dev override via localStorage', () => { afterEach(() => { localStorage.clear() From 42e104146ac77e130fd3b91d648093b8db3ec5ca Mon Sep 17 00:00:00 2001 From: Glary-Bot Date: Tue, 11 Aug 2026 07:10:28 +0000 Subject: [PATCH 6/7] fix(featureFlags): honour session overrides in serverSupportsFeature serverSupportsFeature does not delegate to getServerFeature; it repeats the override lookup itself, so it honoured the ff: localStorage override but skipped the session override. Flags read through it -- such as supports_progress_text_metadata in the websocket parser -- were silently un-overridable. Adds coverage for reaching api.getServerFeature from plain module scope with no active Vue instance, which is how stores and utilities call it. --- src/scripts/api.sessionOverride.test.ts | 84 +++++++++++++++++++++++++ src/scripts/api.ts | 3 + 2 files changed, 87 insertions(+) create mode 100644 src/scripts/api.sessionOverride.test.ts diff --git a/src/scripts/api.sessionOverride.test.ts b/src/scripts/api.sessionOverride.test.ts new file mode 100644 index 00000000000..e253c7d784e --- /dev/null +++ b/src/scripts/api.sessionOverride.test.ts @@ -0,0 +1,84 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' + +import { api } from '@/scripts/api' + +const mockDistribution = vi.hoisted(() => ({ + isCloud: true, + isNightly: false +})) +vi.mock('@/platform/distribution/types', () => mockDistribution) + +const mockCurrentUser = vi.hoisted(() => ({ + value: null as { email: string | null; emailVerified: boolean } | null +})) +vi.mock('vuefire', () => ({ + useCurrentUser: vi.fn(() => mockCurrentUser) +})) + +/** + * Every call here happens at plain module scope — no component, no `setup()`, + * no active Vue instance — which is how `api.getServerFeature` is reached from + * stores and utilities. VueFire's `useFirebaseApp` falls back to the default + * Firebase app when `getCurrentInstance()` is null, so identity resolution does + * not need an injectable context; these tests keep that guarantee honest. + */ +describe('api.getServerFeature session override outside component setup', () => { + beforeEach(() => { + mockDistribution.isCloud = true + mockCurrentUser.value = { email: 'dev@comfy.org', emailVerified: true } + api.serverFeatureFlags.value = {} + sessionStorage.clear() + localStorage.clear() + }) + + afterEach(() => { + window.history.replaceState({}, '', '/') + api.serverFeatureFlags.value = {} + sessionStorage.clear() + localStorage.clear() + vi.restoreAllMocks() + }) + + it('applies a numeric override to a flag that never routes through resolveFlag', () => { + api.serverFeatureFlags.value = { max_upload_size: 100 } + window.history.replaceState({}, '', '/?ff=max_upload_size:209715200') + + expect(api.getServerFeature('max_upload_size')).toBe(209715200) + }) + + it('does not throw when no Vue instance is active', () => { + window.history.replaceState({}, '', '/?ff=some_flag:enforce') + + expect(() => api.getServerFeature('some_flag')).not.toThrow() + expect(api.getServerFeature('some_flag')).toBe('enforce') + }) + + it('beats the dev localStorage override', () => { + localStorage.setItem('ff:some_flag', '"from_local_storage"') + window.history.replaceState({}, '', '/?ff=some_flag:from_url') + + expect(api.getServerFeature('some_flag')).toBe('from_url') + }) + + it('withholds the override from a non-employee', () => { + mockCurrentUser.value = { email: 'someone@gmail.com', emailVerified: true } + api.serverFeatureFlags.value = { max_upload_size: 100 } + window.history.replaceState({}, '', '/?ff=max_upload_size:209715200') + + expect(api.getServerFeature('max_upload_size')).toBe(100) + }) + + it('leaves resolution untouched when no override is requested', () => { + api.serverFeatureFlags.value = { max_upload_size: 100 } + + expect(api.getServerFeature('max_upload_size')).toBe(100) + expect(api.getServerFeature('missing', 'DEFAULT')).toBe('DEFAULT') + }) + + it('reports the override through serverSupportsFeature too', () => { + api.serverFeatureFlags.value = { some_flag: false } + window.history.replaceState({}, '', '/?ff=some_flag') + + expect(api.serverSupportsFeature('some_flag')).toBe(true) + }) +}) diff --git a/src/scripts/api.ts b/src/scripts/api.ts index f35ef9ca008..819801801dc 100644 --- a/src/scripts/api.ts +++ b/src/scripts/api.ts @@ -1607,6 +1607,9 @@ export class ComfyApi extends EventTarget { * @returns true if the feature is supported, false otherwise */ serverSupportsFeature(featureName: string): boolean { + const sessionOverride = getSessionOverride(featureName) + if (sessionOverride !== undefined) return sessionOverride === true + const override = getDevOverride(featureName) if (override !== undefined) return override return get(this.serverFeatureFlags.value, featureName) === true From 9139fd3838d13bf58095b39d6990eefe568136b6 Mon Sep 17 00:00:00 2001 From: Glary-Bot Date: Tue, 11 Aug 2026 07:30:46 +0000 Subject: [PATCH 7/7] test(api): isolate session override state and cover an explicit false override The characterization suite cleared only localStorage, so a stray ?ff= URL or sessionStorage entry could change its results now that getServerFeature reads both. Resets all three around every case. Adds the missing falsy case: an explicit ?ff=flag:false must turn a server value of true off through both serverSupportsFeature and getServerFeature, so a future truthiness check cannot pass unnoticed. Also corrects the suite docstring, which claimed to verify VueFire's default-app fallback -- the vuefire stub bypasses it, and that guarantee is verified against a real Firebase app in the browser instead. --- src/scripts/api.featureFlags.test.ts | 8 ++++++++ src/scripts/api.sessionOverride.test.ts | 17 ++++++++++++++--- 2 files changed, 22 insertions(+), 3 deletions(-) diff --git a/src/scripts/api.featureFlags.test.ts b/src/scripts/api.featureFlags.test.ts index 81e41e3b30b..83dce6d005c 100644 --- a/src/scripts/api.featureFlags.test.ts +++ b/src/scripts/api.featureFlags.test.ts @@ -434,8 +434,16 @@ describe('API Feature Flags', () => { * how server values, falsy values, nested paths or defaults resolve. */ describe('characterization: resolution with no override present', () => { + beforeEach(() => { + localStorage.clear() + sessionStorage.clear() + window.history.replaceState({}, '', '/') + }) + afterEach(() => { localStorage.clear() + sessionStorage.clear() + window.history.replaceState({}, '', '/') }) it('returns the server value verbatim', () => { diff --git a/src/scripts/api.sessionOverride.test.ts b/src/scripts/api.sessionOverride.test.ts index e253c7d784e..d0a7ca57f9a 100644 --- a/src/scripts/api.sessionOverride.test.ts +++ b/src/scripts/api.sessionOverride.test.ts @@ -18,9 +18,12 @@ vi.mock('vuefire', () => ({ /** * Every call here happens at plain module scope — no component, no `setup()`, * no active Vue instance — which is how `api.getServerFeature` is reached from - * stores and utilities. VueFire's `useFirebaseApp` falls back to the default - * Firebase app when `getCurrentInstance()` is null, so identity resolution does - * not need an injectable context; these tests keep that guarantee honest. + * stores and utilities. Identity is stubbed at the `vuefire` boundary, so what + * these cases pin is the precedence and gating logic, not VueFire itself. + * + * That VueFire resolves the default Firebase app outside a component is a + * property of the real SDK and needs a real initialised app, so it is verified + * against a live Firebase app in the browser rather than here. */ describe('api.getServerFeature session override outside component setup', () => { beforeEach(() => { @@ -81,4 +84,12 @@ describe('api.getServerFeature session override outside component setup', () => expect(api.serverSupportsFeature('some_flag')).toBe(true) }) + + it('turns a supported feature off through an explicit false override', () => { + api.serverFeatureFlags.value = { some_flag: true } + window.history.replaceState({}, '', '/?ff=some_flag:false') + + expect(api.serverSupportsFeature('some_flag')).toBe(false) + expect(api.getServerFeature('some_flag')).toBe(false) + }) })