diff --git a/src/composables/useFeatureFlags.test.ts b/src/composables/useFeatureFlags.test.ts index 23214593b58..1069e0003b4 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,54 @@ describe('useFeatureFlags', () => { expect(flags.unifiedCloudAuthEnabled).toBe(true) }) }) + + describe('session override precedence', () => { + afterEach(() => { + vi.mocked(getSessionOverride).mockReset() + vi.mocked(distributionTypes).isCloud = false + remoteConfigState.value = 'unloaded' + cachedBillingControlEnabled.value = undefined + 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 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 + ) + + 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/scripts/api.featureFlags.test.ts b/src/scripts/api.featureFlags.test.ts index 7dedbb01500..83dce6d005c 100644 --- a/src/scripts/api.featureFlags.test.ts +++ b/src/scripts/api.featureFlags.test.ts @@ -428,6 +428,72 @@ 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', () => { + beforeEach(() => { + localStorage.clear() + sessionStorage.clear() + window.history.replaceState({}, '', '/') + }) + + afterEach(() => { + localStorage.clear() + sessionStorage.clear() + window.history.replaceState({}, '', '/') + }) + + 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() diff --git a/src/scripts/api.sessionOverride.test.ts b/src/scripts/api.sessionOverride.test.ts new file mode 100644 index 00000000000..d0a7ca57f9a --- /dev/null +++ b/src/scripts/api.sessionOverride.test.ts @@ -0,0 +1,95 @@ +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. 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(() => { + 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) + }) + + 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) + }) +}) diff --git a/src/scripts/api.ts b/src/scripts/api.ts index e91538c6ada..819801801dc 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 @@ -1606,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 @@ -1618,6 +1622,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 new file mode 100644 index 00000000000..5c9b8b4515c --- /dev/null +++ b/src/utils/sessionFeatureFlagOverride.test.ts @@ -0,0 +1,217 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' + +import { getSessionOverride } from '@/utils/sessionFeatureFlagOverride' + +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 } +const STORAGE_KEY = 'Comfy.FeatureFlagOverride' + +function visit(search: string) { + window.history.replaceState({}, '', search) +} + +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', () => { + visit('/?ff=onboarding_tour_enabled') + + expect(getSessionOverride('onboarding_tour_enabled')).toBe(true) + }) + + 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', () => { + visit('/?ff=signup_turnstile:enforce') + + expect(getSessionOverride('signup_turnstile')).toBe('enforce') + }) + + 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', () => { + 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', () => { + visit('/?ff=onboarding_tour_enabled') + + expect(getSessionOverride('workflow_sharing_enabled')).toBeUndefined() + }) + + it('survives navigation away from the ?ff= URL', () => { + visit('/?ff=onboarding_tour_enabled') + expect(getSessionOverride('onboarding_tour_enabled')).toBe(true) + + visit('/some/other/page') + expect(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('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') + + 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', () => { + visit('/?unrelated=1') + + expect(getSessionOverride('onboarding_tour_enabled')).toBeUndefined() + expect(sessionStorage.getItem(STORAGE_KEY)).toBeNull() + }) + + describe('value parsing', () => { + it('reads a numeric value as a number', () => { + visit('/?ff=max_upload_size:209715200') + + expect(getSessionOverride('max_upload_size')).toBe(209715200) + }) + + it('keeps a quoted numeric value a string', () => { + visit('/?ff=churnkey_app_id:"12345"') + + expect(getSessionOverride('churnkey_app_id')).toBe('12345') + }) + + it('reads a JSON object value', () => { + visit('/?ff=node_replacements:{"a":"b"}') + + expect(getSessionOverride('node_replacements')).toEqual({ a: 'b' }) + }) + + 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', () => { + sessionStorage.setItem(STORAGE_KEY, 'not json') + visit('/?ff=onboarding_tour_enabled') + + expect(getSessionOverride('onboarding_tour_enabled')).toBe(true) + }) + }) + + 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', + ([, currentUser]) => { + mockCurrentUser.value = currentUser + visit('/?ff=onboarding_tour_enabled') + + expect(getSessionOverride('onboarding_tour_enabled')).toBeUndefined() + } + ) + + it('applies the override once auth resolves mid-session', () => { + mockCurrentUser.value = undefined + visit('/?ff=onboarding_tour_enabled') + expect(getSessionOverride('onboarding_tour_enabled')).toBeUndefined() + + mockCurrentUser.value = COMFY_EMPLOYEE + expect(getSessionOverride('onboarding_tour_enabled')).toBe(true) + }) + + 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 + 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 new file mode 100644 index 00000000000..f87db62e473 --- /dev/null +++ b/src/utils/sessionFeatureFlagOverride.ts @@ -0,0 +1,169 @@ +import { useCurrentUser } from 'vuefire' + +import { isCloud } from '@/platform/distribution/types' + +const STORAGE_KEY = 'Comfy.FeatureFlagOverride' +const QUERY_PARAM = 'ff' +const EMPLOYEE_EMAIL_DOMAIN = '@comfy.org' + +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, 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 { + try { + const user = useCurrentUser().value + if (!user?.emailVerified) return false + + return user.email?.toLowerCase().endsWith(EMPLOYEE_EMAIL_DOMAIN) ?? false + } catch { + return false + } +} + +/** + * 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 + + 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 does not rewrite + * storage, 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 || Array.isArray(value)) { + return {} + } + return { ...value } +} + +function readStoredState(): StoredState { + let raw: string | null + try { + raw = sessionStorage.getItem(STORAGE_KEY) + } catch { + return emptyState() + } + if (!raw) return emptyState() + + let parsed: unknown + try { + parsed = JSON.parse(raw) + } catch { + return emptyState() + } + if (typeof parsed !== 'object' || parsed === null) return emptyState() + + 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) + } +} + +function writeStoredState(state: StoredState): void { + try { + sessionStorage.setItem(STORAGE_KEY, JSON.stringify(state)) + } 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)] +} + +function readOverrideRequests(search: string): string[] { + try { + return new URLSearchParams(search).getAll(QUERY_PARAM) + } catch { + return [] + } +} + +/** + * 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('')) { + writeStoredState({ search, overrides: {} }) + return {} + } + + const overrides: OverrideMap = { ...stored } + for (const request of requests) { + const [name, rawValue] = splitRequest(request) + overrides[name] = parseOverrideValue(rawValue) + } + + writeStoredState({ search, overrides }) + return overrides +} + +function loadSessionOverrides(): OverrideMap { + 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) +} + +/** + * 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 + * 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 (!Object.hasOwn(overrides, flagKey)) return undefined + if (!isComfyEmployee()) return undefined + + return overrides[flagKey] as T +}