Line data Source code
1 : import type { GetFeaturesResponse } from '@comfyorg/ingest-types'
2 : import { computed, reactive, readonly, watchEffect } from 'vue'
3 : import type { Ref } from 'vue'
4 :
5 : import { normalizeHostedBillingDestination } from '@/platform/billing/billingWeb'
6 : import {
7 : opensLocalBillingHandoff,
8 : showsCloudBillingNewUxOnLocal
9 : } from '@/platform/billing/localBillingWebEnabled'
10 : import { isCloud, isNightly } from '@/platform/distribution/types'
11 : import {
12 : isAuthenticatedConfigLoaded,
13 : remoteConfig,
14 : sessionAgentGrant,
15 : sessionAgentGrantValidUntil,
16 : useRemoteConfigCache
17 : } from '@/platform/remoteConfig/remoteConfig'
18 : import { ServerFeatureFlag } from '@/platform/remoteConfig/serverFeatureFlag'
19 : import { useTelemetry } from '@comfyorg/telemetry'
20 : import { api } from '@/scripts/api'
21 : import { getDevOverride } from '@/utils/devFeatureFlagOverride'
22 : import { getSessionOverride } from '@/utils/sessionFeatureFlagOverride'
23 :
24 : function reportFeatureFlagEvaluation<T>(flagKey: string, value: T): T {
25 : useTelemetry()?.trackFeatureFlagEvaluation(flagKey, value)
26 : return value
27 : }
28 :
29 : /**
30 : * Resolves a feature flag value with session override > dev override >
31 : * remoteConfig > serverFeature priority.
32 : */
33 3528804 : function resolveFlag<T>(
34 : flagKey: string,
35 : remoteConfigValue: T | undefined,
36 : defaultValue: T
37 : ): T {
38 3528804 : const sessionOverride = getSessionOverride<T>(flagKey)
39 3528804 : if (sessionOverride !== undefined) return sessionOverride
40 :
41 3528804 : const override = getDevOverride<T>(flagKey)
42 3528804 : if (override !== undefined) return override
43 3528804 : return remoteConfigValue ?? api.getServerFeature(flagKey, defaultValue)
44 : }
45 :
46 : /**
47 : * A flag that enables a payment flow: same channels as `resolveFlag`, but only
48 : * a literal `true` counts. A malformed wire value (`'true'`, `1`) or a failed
49 : * lookup resolves to false rather than switching a charge onto a new transport.
50 : *
51 : * Needs no auth gate: the server returns a concrete `false` for these keys to
52 : * an unauthenticated caller, so the anonymous window resolves to the legacy
53 : * rail and cannot enable a flow before authenticated config confirms it.
54 : */
55 10506 : function resolveStrictBooleanFlag(
56 : flagKey: string,
57 : remoteConfigValue: boolean | undefined
58 : ): boolean {
59 10506 : try {
60 10506 : return resolveFlag<unknown>(flagKey, remoteConfigValue, false) === true
61 : } catch {
62 0 : return false
63 : }
64 : }
65 :
66 : /**
67 : * Resolves a per-user, Cloud-only flag that selects backend behavior. Off the
68 : * Cloud build it is always false; during the auth window it falls back to the
69 : * cached session value so anonymous bootstrap config cannot route the user to
70 : * the wrong backend before authenticated config confirms the flag.
71 : */
72 0 : function resolveAuthGatedFlag(
73 : flagKey: string,
74 : remoteConfigValue: boolean | undefined,
75 : cachedValue: Ref<boolean | undefined>
76 : ): boolean {
77 0 : const sessionOverride = getSessionOverride<boolean>(flagKey)
78 0 : if (sessionOverride !== undefined) return sessionOverride
79 :
80 0 : const override = getDevOverride<boolean>(flagKey)
81 0 : if (override !== undefined) return override
82 :
83 0 : if (!isCloud) return false
84 : if (!isAuthenticatedConfigLoaded.value) return cachedValue.value ?? false
85 :
86 : return remoteConfigValue ?? api.getServerFeature(flagKey, false)
87 : }
88 :
89 : /**
90 : * Resolves a per-user allowlist flag. Before the first authenticated answer it
91 : * is off; after one, a failed refresh falls back to that answer so a blip
92 : * cannot pull a granted surface out from under the user mid-session. Unlike
93 : * `resolveAuthGatedFlag` the fallback is never read from storage — a persisted
94 : * grant is what let one browser show the surface while another hid it for the
95 : * same account (PM-1707).
96 : */
97 0 : function resolveWhitelistFlag(
98 : flagKey: string,
99 : remoteConfigValue: boolean | undefined,
100 : grantedThisSession: Ref<boolean | undefined>,
101 : grantValidUntil: Ref<number | undefined>
102 : ): boolean {
103 0 : const sessionOverride = getSessionOverride<boolean>(flagKey)
104 0 : if (sessionOverride !== undefined) return sessionOverride
105 :
106 0 : const override = getDevOverride<boolean>(flagKey)
107 0 : if (override !== undefined) return override
108 :
109 0 : if (!isCloud) return false
110 : if (!isAuthenticatedConfigLoaded.value)
111 : return (
112 : grantedThisSession.value === true &&
113 : (grantValidUntil.value ?? 0) > Date.now()
114 : )
115 :
116 : return remoteConfigValue === true
117 : }
118 :
119 : /**
120 : * Composable for reactive access to server-side feature flags
121 : */
122 54353 : export function useFeatureFlags() {
123 54353 : const hostedBillingDestination = () =>
124 : normalizeHostedBillingDestination(
125 : resolveFlag(
126 : ServerFeatureFlag.HOSTED_BILLING_DESTINATION,
127 : remoteConfig.value.hosted_billing_destination,
128 : 'stripe'
129 : )
130 : )
131 :
132 54353 : const flags = reactive({
133 : get supportsPreviewMetadata() {
134 0 : return api.getServerFeature(ServerFeatureFlag.SUPPORTS_PREVIEW_METADATA)
135 : },
136 : get maxUploadSize() {
137 0 : return api.getServerFeature<GetFeaturesResponse['max_upload_size']>(
138 : ServerFeatureFlag.MAX_UPLOAD_SIZE
139 : )
140 : },
141 : get supportsManagerV4() {
142 0 : return api.getServerFeature(ServerFeatureFlag.MANAGER_SUPPORTS_V4)
143 : },
144 : /** ComfyUI's `agent` server feature; callers validate `state`. */
145 : get agent() {
146 7065 : return api.getServerFeature<{ state?: unknown } | null | undefined>(
147 : ServerFeatureFlag.AGENT
148 : )
149 : },
150 : get modelUploadButtonEnabled() {
151 9 : return resolveFlag(
152 : ServerFeatureFlag.MODEL_UPLOAD_BUTTON_ENABLED,
153 : remoteConfig.value.model_upload_button_enabled,
154 : false
155 : )
156 : },
157 : get assetDeletionEnabled() {
158 1 : return resolveFlag(
159 : ServerFeatureFlag.ASSET_DELETION_ENABLED,
160 : undefined,
161 : false
162 : )
163 : },
164 : get privateModelsEnabled() {
165 0 : return resolveFlag(
166 : ServerFeatureFlag.PRIVATE_MODELS_ENABLED,
167 : remoteConfig.value.private_models_enabled,
168 : false
169 : )
170 : },
171 : get onboardingSurveyEnabled() {
172 0 : return resolveFlag(
173 : ServerFeatureFlag.ONBOARDING_SURVEY_ENABLED,
174 : remoteConfig.value.onboarding_survey_enabled,
175 : false
176 : )
177 : },
178 : get signedOutRerouteEnabled() {
179 0 : return resolveFlag(
180 : ServerFeatureFlag.SIGNED_OUT_REROUTE_ENABLED,
181 : remoteConfig.value.signed_out_reroute_enabled,
182 : false
183 : )
184 : },
185 : get partnerNodeGovernanceEnabled() {
186 110 : return resolveFlag(
187 : ServerFeatureFlag.PARTNER_NODE_GOVERNANCE_ENABLED,
188 : remoteConfig.value.partner_node_governance_enabled,
189 : false
190 : )
191 : },
192 : get partnerRunGateEnabled() {
193 7181 : return resolveFlag(
194 : ServerFeatureFlag.PARTNER_RUN_GATE_ENABLED,
195 : remoteConfig.value.partner_run_gate_enabled,
196 : true
197 : )
198 : },
199 : get deploymentStartEnabled() {
200 0 : return resolveStrictBooleanFlag(
201 : ServerFeatureFlag.DEPLOYMENT_START_ENABLED,
202 : remoteConfig.value.deployment_start_enabled
203 : )
204 : },
205 : get partnerNodeTokenEnabled() {
206 5 : return resolveStrictBooleanFlag(
207 : ServerFeatureFlag.PARTNER_NODE_TOKEN,
208 : remoteConfig.value.partner_node_token
209 : )
210 : },
211 : get userSecretsEnabled() {
212 113 : return resolveFlag(
213 : ServerFeatureFlag.USER_SECRETS_ENABLED,
214 : remoteConfig.value.user_secrets_enabled,
215 : false
216 : )
217 : },
218 : get nodeReplacementsEnabled() {
219 0 : return api.getServerFeature(ServerFeatureFlag.NODE_REPLACEMENTS, false)
220 : },
221 : get openOnCloudEnabled() {
222 4097 : return resolveFlag(
223 : ServerFeatureFlag.OPEN_ON_CLOUD_ENABLED,
224 : remoteConfig.value.open_on_cloud_enabled,
225 : import.meta.env.DEV
226 : )
227 : },
228 : get openOnCloudUseLocalAgentEnabled() {
229 0 : return (
230 : resolveFlag<unknown>(
231 : ServerFeatureFlag.OPEN_ON_CLOUD_USE_LOCAL_AGENT_ENABLED,
232 : remoteConfig.value.open_on_cloud_use_local_agent_enabled,
233 : false
234 : ) === true
235 : )
236 : },
237 : get deployToCloud() {
238 4001 : return api.getServerFeature(ServerFeatureFlag.DEPLOY_TO_CLOUD, false)
239 : },
240 : get nodeLibraryEssentialsEnabled() {
241 3464292 : return resolveFlag(
242 : ServerFeatureFlag.NODE_LIBRARY_ESSENTIALS_ENABLED,
243 : remoteConfig.value.node_library_essentials_enabled,
244 : isNightly || import.meta.env.DEV
245 : )
246 : },
247 : get comfyHubUploadEnabled() {
248 0 : return resolveFlag(
249 : ServerFeatureFlag.COMFYHUB_UPLOAD_ENABLED,
250 : remoteConfig.value.comfyhub_upload_enabled,
251 : false
252 : )
253 : },
254 : get comfyHubProfileGateEnabled() {
255 51 : return resolveFlag(
256 : ServerFeatureFlag.COMFYHUB_PROFILE_GATE_ENABLED,
257 : remoteConfig.value.comfyhub_profile_gate_enabled,
258 : false
259 : )
260 : },
261 : get deploymentCompatibilityMarksEnabled() {
262 8016 : return resolveFlag(
263 : ServerFeatureFlag.DEPLOYMENT_COMPATIBILITY_MARKS_ENABLED,
264 : remoteConfig.value.deployment_compatibility_marks_enabled,
265 : false
266 : )
267 : },
268 : get runtimeLibraryModelsEnabled() {
269 9396 : return resolveFlag(
270 : ServerFeatureFlag.RUNTIME_LIBRARY_MODELS_ENABLED,
271 : remoteConfig.value.runtime_library_models_enabled,
272 : false
273 : )
274 : },
275 : /** The model folders an uploaded model file may go into; empty when uploads are off. */
276 : get modelUploadFolders(): readonly string[] {
277 0 : return resolveFlag<readonly string[]>(
278 : ServerFeatureFlag.MODEL_UPLOAD_FOLDERS,
279 : remoteConfig.value.model_upload_folders,
280 : []
281 : )
282 : },
283 : get lateCustomNodesEnabled() {
284 2355 : return resolveFlag(
285 : ServerFeatureFlag.LATE_CUSTOM_NODES_ENABLED,
286 : remoteConfig.value.late_custom_nodes_enabled,
287 : false
288 : )
289 : },
290 : get hostedBillingDestination() {
291 0 : return hostedBillingDestination()
292 : },
293 : get hostedBillingWebEnabled() {
294 0 : return hostedBillingDestination() === 'billing_web'
295 : },
296 : get showSignInButton(): boolean | undefined {
297 0 : return api.getServerFeature<boolean | undefined>(
298 : ServerFeatureFlag.SHOW_SIGNIN_BUTTON,
299 : undefined
300 : )
301 : },
302 : get unifiedWebSessionEnabled() {
303 0 : if (!isCloud) return false
304 :
305 : const key = ServerFeatureFlag.UNIFIED_WEB_SESSION
306 : // Overrides skip the server's web_session_enabled pairing; whoever overrides
307 : // this key must also be in the web_session_enabled set.
308 : const value =
309 : getSessionOverride<unknown>(key) ??
310 : getDevOverride<unknown>(key) ??
311 : remoteConfig.value.unified_web_session
312 : return value === true
313 : },
314 : get webSessionLapseRecoveryEnabled() {
315 7091 : return resolveFlag(
316 : ServerFeatureFlag.WEB_SESSION_LAPSE_RECOVERY_ENABLED,
317 : remoteConfig.value.web_session_lapse_recovery_enabled,
318 : false
319 : )
320 : },
321 : get ssoEnabled() {
322 179 : if (!isCloud) return false
323 :
324 : return resolveStrictBooleanFlag(
325 : ServerFeatureFlag.SSO_ENABLED,
326 : remoteConfig.value.sso_enabled
327 : )
328 : },
329 : /** Browser sign-in for a local ComfyUI that Desktop does not host. */
330 : get localWebSsoEnabled() {
331 : if (isCloud) return false
332 :
333 2352 : return resolveStrictBooleanFlag(
334 : ServerFeatureFlag.LOCAL_WEB_SSO,
335 : remoteConfig.value.local_web_sso
336 : )
337 : },
338 : get billingControlEnabled() {
339 0 : return resolveAuthGatedFlag(
340 : ServerFeatureFlag.BILLING_CONTROL_ENABLED,
341 : remoteConfig.value.billing_control_enabled,
342 : useRemoteConfigCache().cachedBillingControlEnabled
343 : )
344 : },
345 : get memberCreditLimitsEnabled() {
346 1 : return resolveStrictBooleanFlag(
347 : ServerFeatureFlag.MEMBER_CREDIT_LIMITS_ENABLED,
348 : remoteConfig.value.member_credit_limits_enabled
349 : )
350 : },
351 : get billingNewUxEnabled() {
352 8144 : return resolveStrictBooleanFlag(
353 : ServerFeatureFlag.BILLING_NEW_UX_ENABLED,
354 : showsCloudBillingNewUxOnLocal()
355 : ? true
356 : : remoteConfig.value.billing_new_ux_enabled
357 : )
358 : },
359 : get billingAutoTopUpAtCheckoutEnabled() {
360 4 : return resolveStrictBooleanFlag(
361 : ServerFeatureFlag.BILLING_AUTO_TOP_UP_AT_CHECKOUT_ENABLED,
362 : remoteConfig.value.billing_auto_top_up_at_checkout_enabled
363 : )
364 : },
365 : /** Top-up, subscription and billing reads run on the billing SDK on Cloud. */
366 : get billingSdkRailEnabled() {
367 93 : return isCloud
368 : },
369 : get unifiedBillingSettingsEnabled() {
370 157 : if (!isCloud) return opensLocalBillingHandoff()
371 : return resolveStrictBooleanFlag(
372 : ServerFeatureFlag.UNIFIED_BILLING_SETTINGS,
373 : remoteConfig.value.unified_billing_settings
374 : )
375 : },
376 : get pricingTableFallback() {
377 0 : return resolveStrictBooleanFlag(
378 : ServerFeatureFlag.PRICING_TABLE_FALLBACK,
379 : remoteConfig.value.pricing_table_fallback
380 : )
381 : },
382 : get oauthConsentSwitchAccountEnabled() {
383 0 : return resolveFlag(
384 : ServerFeatureFlag.OAUTH_CONSENT_SWITCH_ACCOUNT_ENABLED,
385 : remoteConfig.value.oauth_consent_switch_account_enabled,
386 : false
387 : )
388 : },
389 : get v1PaymentRecovery() {
390 0 : return resolveAuthGatedFlag(
391 : ServerFeatureFlag.V1_PAYMENT_RECOVERY,
392 : remoteConfig.value.v1_payment_recovery,
393 : useRemoteConfigCache().cachedV1PaymentRecovery
394 : )
395 : },
396 : get signupTurnstileMode() {
397 2 : return resolveFlag(
398 : ServerFeatureFlag.SIGNUP_TURNSTILE,
399 : remoteConfig.value.signup_turnstile,
400 : 'off'
401 : )
402 : },
403 : get supportsModelTypeTags() {
404 165 : return resolveFlag(
405 : ServerFeatureFlag.SUPPORTS_MODEL_TYPE_TAGS,
406 : remoteConfig.value.supports_model_type_tags,
407 : false
408 : )
409 : },
410 : get assetsEnabled() {
411 15419 : return isCloud || resolveFlag('assets', undefined, false)
412 : },
413 : get agentInAppExperienceEnabled() {
414 0 : return resolveWhitelistFlag(
415 : ServerFeatureFlag.AGENT_IN_APP_EXPERIENCE,
416 : remoteConfig.value['agent-in-app-experience'],
417 : sessionAgentGrant,
418 : sessionAgentGrantValidUntil
419 : )
420 : }
421 : })
422 :
423 54353 : const featureFlag = <T = unknown>(featurePath: string, defaultValue?: T) =>
424 : computed(() => api.getServerFeature(featurePath, defaultValue))
425 :
426 54353 : return {
427 : flags: readonly(flags),
428 : featureFlag
429 : }
430 : }
431 :
432 : export function startFeatureFlagTelemetry() {
433 : const { flags } = useFeatureFlags()
434 :
435 : return watchEffect(() => {
436 : const evaluations = {
437 : [ServerFeatureFlag.SUPPORTS_PREVIEW_METADATA]:
438 : flags.supportsPreviewMetadata,
439 : [ServerFeatureFlag.MAX_UPLOAD_SIZE]: flags.maxUploadSize,
440 : [ServerFeatureFlag.MANAGER_SUPPORTS_V4]: flags.supportsManagerV4,
441 : [ServerFeatureFlag.MODEL_UPLOAD_BUTTON_ENABLED]:
442 : flags.modelUploadButtonEnabled,
443 : [ServerFeatureFlag.ASSET_DELETION_ENABLED]: flags.assetDeletionEnabled,
444 : [ServerFeatureFlag.PRIVATE_MODELS_ENABLED]: flags.privateModelsEnabled,
445 : [ServerFeatureFlag.ONBOARDING_SURVEY_ENABLED]:
446 : flags.onboardingSurveyEnabled,
447 : [ServerFeatureFlag.SIGNED_OUT_REROUTE_ENABLED]:
448 : flags.signedOutRerouteEnabled,
449 : [ServerFeatureFlag.PARTNER_NODE_GOVERNANCE_ENABLED]:
450 : flags.partnerNodeGovernanceEnabled,
451 : [ServerFeatureFlag.USER_SECRETS_ENABLED]: flags.userSecretsEnabled,
452 : [ServerFeatureFlag.NODE_REPLACEMENTS]: flags.nodeReplacementsEnabled,
453 : [ServerFeatureFlag.OPEN_ON_CLOUD_ENABLED]: flags.openOnCloudEnabled,
454 : [ServerFeatureFlag.OPEN_ON_CLOUD_USE_LOCAL_AGENT_ENABLED]:
455 : flags.openOnCloudUseLocalAgentEnabled,
456 : [ServerFeatureFlag.NODE_LIBRARY_ESSENTIALS_ENABLED]:
457 : flags.nodeLibraryEssentialsEnabled,
458 : [ServerFeatureFlag.COMFYHUB_UPLOAD_ENABLED]: flags.comfyHubUploadEnabled,
459 : [ServerFeatureFlag.COMFYHUB_PROFILE_GATE_ENABLED]:
460 : flags.comfyHubProfileGateEnabled,
461 : [ServerFeatureFlag.HOSTED_BILLING_DESTINATION]:
462 : flags.hostedBillingDestination,
463 : [ServerFeatureFlag.SHOW_SIGNIN_BUTTON]: flags.showSignInButton,
464 : [ServerFeatureFlag.UNIFIED_WEB_SESSION]: flags.unifiedWebSessionEnabled,
465 : [ServerFeatureFlag.SSO_ENABLED]: flags.ssoEnabled,
466 : [ServerFeatureFlag.WEB_SESSION_LAPSE_RECOVERY_ENABLED]:
467 : flags.webSessionLapseRecoveryEnabled,
468 : [ServerFeatureFlag.BILLING_CONTROL_ENABLED]: flags.billingControlEnabled,
469 : [ServerFeatureFlag.MEMBER_CREDIT_LIMITS_ENABLED]:
470 : flags.memberCreditLimitsEnabled,
471 : [ServerFeatureFlag.BILLING_NEW_UX_ENABLED]: flags.billingNewUxEnabled,
472 : [ServerFeatureFlag.BILLING_AUTO_TOP_UP_AT_CHECKOUT_ENABLED]:
473 : flags.billingAutoTopUpAtCheckoutEnabled,
474 : [ServerFeatureFlag.UNIFIED_BILLING_SETTINGS]:
475 : flags.unifiedBillingSettingsEnabled,
476 : [ServerFeatureFlag.PRICING_TABLE_FALLBACK]: flags.pricingTableFallback,
477 : [ServerFeatureFlag.OAUTH_CONSENT_SWITCH_ACCOUNT_ENABLED]:
478 : flags.oauthConsentSwitchAccountEnabled,
479 : [ServerFeatureFlag.V1_PAYMENT_RECOVERY]: flags.v1PaymentRecovery,
480 : [ServerFeatureFlag.SIGNUP_TURNSTILE]: flags.signupTurnstileMode,
481 : [ServerFeatureFlag.SUPPORTS_MODEL_TYPE_TAGS]: flags.supportsModelTypeTags,
482 : [ServerFeatureFlag.AGENT_IN_APP_EXPERIENCE]:
483 : flags.agentInAppExperienceEnabled,
484 : assets: flags.assetsEnabled
485 : }
486 :
487 : for (const [key, value] of Object.entries(evaluations))
488 : reportFeatureFlagEvaluation(key, value)
489 : })
490 : }
|