From efe5d462db6415569f70dedea2709fd5d412d5dd Mon Sep 17 00:00:00 2001 From: huang47 <157390+huang47@users.noreply.github.com> Date: Sun, 2 Aug 2026 11:52:20 -0700 Subject: [PATCH 1/6] feat: parse disabled node metadata --- .../src/__tests__/nodeDefSchema.test.ts | 35 +++++++++++++++++++ .../src/schemas/nodeDefSchema.ts | 13 +++++++ 2 files changed, 48 insertions(+) diff --git a/packages/object-info-parser/src/__tests__/nodeDefSchema.test.ts b/packages/object-info-parser/src/__tests__/nodeDefSchema.test.ts index 41f02e7a717..6845595075d 100644 --- a/packages/object-info-parser/src/__tests__/nodeDefSchema.test.ts +++ b/packages/object-info-parser/src/__tests__/nodeDefSchema.test.ts @@ -27,6 +27,41 @@ describe('validateNodeDef', () => { expect(validateComfyNodeDef(EXAMPLE_NODE_DEF)).not.toBeNull() }) + it('preserves disabled metadata', () => { + expect( + validateComfyNodeDef({ + ...EXAMPLE_NODE_DEF, + disabled: { + reasons: [ + { + type: 'workspace_provider_disabled', + provider_id: 'provider-1' + } + ] + } + })?.disabled + ).toEqual({ + reasons: [ + { + type: 'workspace_provider_disabled', + provider_id: 'provider-1' + } + ] + }) + }) + + it('rejects malformed disabled metadata', () => { + expect( + validateComfyNodeDef( + { + ...EXAMPLE_NODE_DEF, + disabled: { reasons: 'workspace_provider_disabled' } + }, + () => undefined + ) + ).toBeNull() + }) + describe.for([ [{ ckpt_name: ['foo', { default: 1 }] }, ['foo', { default: 1 }]], [{ ckpt_name: ['foo', { bar: 1 }] }, ['foo', { bar: 1 }]], diff --git a/packages/object-info-parser/src/schemas/nodeDefSchema.ts b/packages/object-info-parser/src/schemas/nodeDefSchema.ts index cea5d5c8462..3a3a426f7d2 100644 --- a/packages/object-info-parser/src/schemas/nodeDefSchema.ts +++ b/packages/object-info-parser/src/schemas/nodeDefSchema.ts @@ -273,6 +273,18 @@ const zPriceBadge = z.object({ export type PriceBadge = z.infer +const zNodeDisabled = z.object({ + reasons: z.array( + z + .object({ + type: z.string() + }) + .passthrough() + ) +}) + +export type NodeDisabled = z.infer + export const zComfyNodeDef = z.object({ input: zComfyInputsSpec.optional(), output: zComfyOutputTypesSpec.optional(), @@ -291,6 +303,7 @@ export const zComfyNodeDef = z.object({ deprecated: z.boolean().optional(), experimental: z.boolean().optional(), dev_only: z.boolean().optional(), + disabled: zNodeDisabled.optional(), /** * Whether the node is an API node. Running API nodes requires login to * Comfy Org account. From b888d99f245c7300d40d9f350bba4773584e0eb5 Mon Sep 17 00:00:00 2001 From: huang47 <157390+huang47@users.noreply.github.com> Date: Sun, 2 Aug 2026 11:54:26 -0700 Subject: [PATCH 2/6] feat: hide disabled nodes from discovery --- src/services/litegraphService.test.ts | 29 ++++++++++++++++++ src/services/litegraphService.ts | 6 ++-- src/stores/nodeDefStore.test.ts | 44 +++++++++++++++++++++++++-- src/stores/nodeDefStore.ts | 16 ++++++++-- 4 files changed, 87 insertions(+), 8 deletions(-) diff --git a/src/services/litegraphService.test.ts b/src/services/litegraphService.test.ts index 25a065bae5f..77b925100a7 100644 --- a/src/services/litegraphService.test.ts +++ b/src/services/litegraphService.test.ts @@ -8,6 +8,8 @@ vi.mock('@/scripts/app', () => ({ })) import { app } from '@/scripts/app' +import { LiteGraph } from '@/lib/litegraph/src/litegraph' +import type { ComfyNodeDef } from '@/schemas/nodeDefSchema' import { useLitegraphService } from '@/services/litegraphService' describe('useLitegraphService().getCanvasCenter', () => { @@ -41,3 +43,30 @@ describe('useLitegraphService().getCanvasCenter', () => { expect(center).toEqual([110, 70]) }) }) + +describe('useLitegraphService().registerNodeDef', () => { + beforeEach(() => { + setActivePinia(createTestingPinia({ stubActions: false })) + }) + + it('hides disabled nodes from LiteGraph discovery', async () => { + const nodeDef: ComfyNodeDef = { + name: 'DisabledTestNode', + display_name: 'Disabled Test Node', + category: 'test', + python_module: 'test', + description: '', + input: {}, + output: [], + output_node: false, + disabled: { + reasons: [{ type: 'workspace_provider_disabled' }] + } + } + + await useLitegraphService().registerNodeDef(nodeDef.name, nodeDef) + + expect(LiteGraph.registered_node_types[nodeDef.name].skip_list).toBe(true) + LiteGraph.unregisterNodeType(nodeDef.name) + }) +}) diff --git a/src/services/litegraphService.ts b/src/services/litegraphService.ts index b4beadc87d1..a2c17884f07 100644 --- a/src/services/litegraphService.ts +++ b/src/services/litegraphService.ts @@ -601,9 +601,9 @@ export const useLitegraphService = () => { node.category = nodeDef.category node.title = nodeDef.display_name || nodeDef.name - // Set skip_list for dev-only nodes based on current DevMode setting - // This ensures nodes registered after initial load respect the current setting - if (nodeDef.dev_only) { + if (nodeDef.disabled !== undefined) { + node.skip_list = true + } else if (nodeDef.dev_only) { const settingStore = useSettingStore() node.skip_list = !settingStore.get('Comfy.DevMode') } diff --git a/src/stores/nodeDefStore.test.ts b/src/stores/nodeDefStore.test.ts index 3098197e4de..da46574b51a 100644 --- a/src/stores/nodeDefStore.test.ts +++ b/src/stores/nodeDefStore.test.ts @@ -1,6 +1,7 @@ import { createTestingPinia } from '@pinia/testing' +import axios from 'axios' import { setActivePinia } from 'pinia' -import { beforeEach, describe, expect, it } from 'vitest' +import { beforeEach, describe, expect, it, vi } from 'vitest' import { promoteValueWidgetViaSubgraphInput } from '@/core/graph/subgraph/promotionUtils' import { LGraphNode } from '@/lib/litegraph/src/litegraph' @@ -10,7 +11,7 @@ import { createTestSubgraphNode } from '@/lib/litegraph/src/subgraph/__fixtures__/subgraphHelpers' import type { ComfyNodeDef } from '@/schemas/nodeDefSchema' -import { useNodeDefStore } from '@/stores/nodeDefStore' +import { useNodeDefStore, useNodeFrequencyStore } from '@/stores/nodeDefStore' import type { NodeDefFilter } from '@/stores/nodeDefStore' describe('useNodeDefStore', () => { @@ -246,6 +247,23 @@ describe('useNodeDefStore', () => { expect(store.visibleNodeDefs).toHaveLength(2) }) + it('should hide disabled nodes', () => { + store.updateNodeDefs([ + createMockNodeDef({ name: 'enabled' }), + createMockNodeDef({ + name: 'disabled', + disabled: { + reasons: [{ type: 'workspace_provider_disabled' }] + } + }) + ]) + + expect(store.visibleNodeDefs.map((node) => node.name)).toEqual([ + 'enabled' + ]) + expect(store.nodeDefsByName.disabled.disabled).toBeDefined() + }) + it('should hide subgraph nodes by default', () => { const normalNode = createMockNodeDef({ name: 'normal', @@ -419,4 +437,26 @@ describe('useNodeDefStore', () => { expect(filterCallCount).toBe(10 * 5) }) }) + + it('excludes disabled nodes from frequent suggestions', async () => { + store.updateNodeDefs([ + createMockNodeDef({ name: 'enabled' }), + createMockNodeDef({ + name: 'disabled', + disabled: { + reasons: [{ type: 'workspace_provider_disabled' }] + } + }) + ]) + vi.spyOn(axios, 'get').mockResolvedValue({ + data: { disabled: 2, enabled: 1 } + }) + + const frequencyStore = useNodeFrequencyStore() + await frequencyStore.loadNodeFrequencies() + + expect(frequencyStore.topNodeDefs.map((node) => node.name)).toEqual([ + 'enabled' + ]) + }) }) diff --git a/src/stores/nodeDefStore.ts b/src/stores/nodeDefStore.ts index 9cf0bd3ac94..a6329ef4af9 100644 --- a/src/stores/nodeDefStore.ts +++ b/src/stores/nodeDefStore.ts @@ -19,6 +19,7 @@ import type { ComfyInputsSpec as ComfyInputSpecV1, ComfyNodeDef as ComfyNodeDefV1, ComfyOutputTypesSpec as ComfyOutputSpecV1, + NodeDisabled, PriceBadge } from '@/schemas/nodeDefSchema' import { useSettingStore } from '@/platform/settings/settingStore' @@ -49,6 +50,7 @@ export class ComfyNodeDefImpl readonly deprecated: boolean readonly experimental: boolean readonly dev_only: boolean + readonly disabled?: NodeDisabled readonly output_node: boolean readonly api_node: boolean /** @@ -377,8 +379,10 @@ export const useNodeDefStore = defineStore('nodeDef', () => { }) const visibleNodeDefs = computed(() => { - return nodeDefs.value.filter((nodeDef) => - nodeDefFilters.value.every((filter) => filter.predicate(nodeDef)) + return nodeDefs.value.filter( + (nodeDef) => + nodeDefFilters.value.every((filter) => filter.predicate(nodeDef)) && + nodeDef.disabled === undefined ) }) const nodeSearchService = computed( @@ -560,9 +564,15 @@ export const useNodeFrequencyStore = defineStore('nodeFrequency', () => { const nodeDefStore = useNodeDefStore() const topNodeDefs = computed(() => { + const visibleNodeNames = new Set( + nodeDefStore.visibleNodeDefs.map((nodeDef) => nodeDef.name) + ) return nodeNamesByFrequency.value .map((nodeName: string) => nodeDefStore.nodeDefsByName[nodeName]) - .filter((nodeDef: ComfyNodeDefImpl) => nodeDef !== undefined) + .filter( + (nodeDef): nodeDef is ComfyNodeDefImpl => + nodeDef !== undefined && visibleNodeNames.has(nodeDef.name) + ) .slice(0, topNodeDefLimit.value) }) From 2f60798b0937a192ca9f7a4959408c8245f402e8 Mon Sep 17 00:00:00 2001 From: huang47 <157390+huang47@users.noreply.github.com> Date: Sun, 2 Aug 2026 12:08:28 -0700 Subject: [PATCH 3/6] fix: preserve disabled discovery filtering --- src/services/litegraphService.test.ts | 17 ++++++++++++++--- src/stores/nodeDefStore.ts | 9 ++++++++- 2 files changed, 22 insertions(+), 4 deletions(-) diff --git a/src/services/litegraphService.test.ts b/src/services/litegraphService.test.ts index 77b925100a7..aa98de77b42 100644 --- a/src/services/litegraphService.test.ts +++ b/src/services/litegraphService.test.ts @@ -1,5 +1,6 @@ import { createTestingPinia } from '@pinia/testing' import { setActivePinia } from 'pinia' +import { nextTick } from 'vue' import { beforeEach, describe, expect, it, vi } from 'vitest' vi.mock('@/scripts/app', () => ({ @@ -11,6 +12,8 @@ import { app } from '@/scripts/app' import { LiteGraph } from '@/lib/litegraph/src/litegraph' import type { ComfyNodeDef } from '@/schemas/nodeDefSchema' import { useLitegraphService } from '@/services/litegraphService' +import { useSettingStore } from '@/platform/settings/settingStore' +import { useNodeDefStore } from '@/stores/nodeDefStore' describe('useLitegraphService().getCanvasCenter', () => { beforeEach(() => { @@ -49,7 +52,9 @@ describe('useLitegraphService().registerNodeDef', () => { setActivePinia(createTestingPinia({ stubActions: false })) }) - it('hides disabled nodes from LiteGraph discovery', async () => { + it('keeps disabled nodes hidden when developer mode changes', async () => { + useNodeDefStore() + const settingStore = useSettingStore() const nodeDef: ComfyNodeDef = { name: 'DisabledTestNode', display_name: 'Disabled Test Node', @@ -59,6 +64,7 @@ describe('useLitegraphService().registerNodeDef', () => { input: {}, output: [], output_node: false, + dev_only: true, disabled: { reasons: [{ type: 'workspace_provider_disabled' }] } @@ -66,7 +72,12 @@ describe('useLitegraphService().registerNodeDef', () => { await useLitegraphService().registerNodeDef(nodeDef.name, nodeDef) - expect(LiteGraph.registered_node_types[nodeDef.name].skip_list).toBe(true) - LiteGraph.unregisterNodeType(nodeDef.name) + try { + settingStore.settingValues['Comfy.DevMode'] = true + await nextTick() + expect(LiteGraph.registered_node_types[nodeDef.name].skip_list).toBe(true) + } finally { + LiteGraph.unregisterNodeType(nodeDef.name) + } }) }) diff --git a/src/stores/nodeDefStore.ts b/src/stores/nodeDefStore.ts index a6329ef4af9..21351363e38 100644 --- a/src/stores/nodeDefStore.ts +++ b/src/stores/nodeDefStore.ts @@ -341,7 +341,14 @@ export const useNodeDefStore = defineStore('nodeDef', () => { watchEffect(() => { const devModeEnabled = showDevOnly.value for (const nodeType of Object.values(LiteGraph.registered_node_types)) { - if (nodeType.nodeData?.dev_only) { + const nodeData = nodeType.nodeData + if ( + nodeData && + 'disabled' in nodeData && + nodeData.disabled !== undefined + ) { + nodeType.skip_list = true + } else if (nodeData?.dev_only) { nodeType.skip_list = !devModeEnabled } } From b177977d7bbca45847851b685ba373d05359f3f3 Mon Sep 17 00:00:00 2001 From: ShihChi Huang Date: Mon, 3 Aug 2026 23:03:50 -0700 Subject: [PATCH 4/6] fix: derive disabled nodes from provider policy --- .../src/__tests__/nodeDefSchema.test.ts | 35 --------- .../src/schemas/nodeDefSchema.ts | 13 ---- .../nodeDisabled/nodeDisabledState.test.ts | 76 +++++++++++++++++++ .../nodeDisabled/nodeDisabledState.ts | 42 ++++++++++ .../settings/PartnerNodeAccessPanel.vue | 9 +-- src/services/litegraphService.test.ts | 42 ++++++++-- src/services/litegraphService.ts | 4 +- src/stores/nodeDefStore.test.ts | 38 ++++++++-- src/stores/nodeDefStore.ts | 21 +++-- 9 files changed, 197 insertions(+), 83 deletions(-) create mode 100644 src/platform/nodeDisabled/nodeDisabledState.test.ts create mode 100644 src/platform/nodeDisabled/nodeDisabledState.ts diff --git a/packages/object-info-parser/src/__tests__/nodeDefSchema.test.ts b/packages/object-info-parser/src/__tests__/nodeDefSchema.test.ts index 6845595075d..41f02e7a717 100644 --- a/packages/object-info-parser/src/__tests__/nodeDefSchema.test.ts +++ b/packages/object-info-parser/src/__tests__/nodeDefSchema.test.ts @@ -27,41 +27,6 @@ describe('validateNodeDef', () => { expect(validateComfyNodeDef(EXAMPLE_NODE_DEF)).not.toBeNull() }) - it('preserves disabled metadata', () => { - expect( - validateComfyNodeDef({ - ...EXAMPLE_NODE_DEF, - disabled: { - reasons: [ - { - type: 'workspace_provider_disabled', - provider_id: 'provider-1' - } - ] - } - })?.disabled - ).toEqual({ - reasons: [ - { - type: 'workspace_provider_disabled', - provider_id: 'provider-1' - } - ] - }) - }) - - it('rejects malformed disabled metadata', () => { - expect( - validateComfyNodeDef( - { - ...EXAMPLE_NODE_DEF, - disabled: { reasons: 'workspace_provider_disabled' } - }, - () => undefined - ) - ).toBeNull() - }) - describe.for([ [{ ckpt_name: ['foo', { default: 1 }] }, ['foo', { default: 1 }]], [{ ckpt_name: ['foo', { bar: 1 }] }, ['foo', { bar: 1 }]], diff --git a/packages/object-info-parser/src/schemas/nodeDefSchema.ts b/packages/object-info-parser/src/schemas/nodeDefSchema.ts index 3a3a426f7d2..cea5d5c8462 100644 --- a/packages/object-info-parser/src/schemas/nodeDefSchema.ts +++ b/packages/object-info-parser/src/schemas/nodeDefSchema.ts @@ -273,18 +273,6 @@ const zPriceBadge = z.object({ export type PriceBadge = z.infer -const zNodeDisabled = z.object({ - reasons: z.array( - z - .object({ - type: z.string() - }) - .passthrough() - ) -}) - -export type NodeDisabled = z.infer - export const zComfyNodeDef = z.object({ input: zComfyInputsSpec.optional(), output: zComfyOutputTypesSpec.optional(), @@ -303,7 +291,6 @@ export const zComfyNodeDef = z.object({ deprecated: z.boolean().optional(), experimental: z.boolean().optional(), dev_only: z.boolean().optional(), - disabled: zNodeDisabled.optional(), /** * Whether the node is an API node. Running API nodes requires login to * Comfy Org account. diff --git a/src/platform/nodeDisabled/nodeDisabledState.test.ts b/src/platform/nodeDisabled/nodeDisabledState.test.ts new file mode 100644 index 00000000000..b27d84eec09 --- /dev/null +++ b/src/platform/nodeDisabled/nodeDisabledState.test.ts @@ -0,0 +1,76 @@ +import { createTestingPinia } from '@pinia/testing' +import { setActivePinia } from 'pinia' +import { beforeEach, describe, expect, it } from 'vitest' + +import type { ComfyNodeDef } from '@/schemas/nodeDefSchema' +import { + isNodeFromPartnerProvider, + useNodeDisabledState +} from '@/platform/nodeDisabled/nodeDisabledState' +import type { PartnerProvider } from '@/platform/workspace/api/partnerNodePolicyApi' +import { usePartnerNodeGovernanceStore } from '@/platform/workspace/stores/partnerNodeGovernanceStore' + +const provider: PartnerProvider = { + id: 'openai', + displayName: 'OpenAI', + nodeCategories: ['OpenAI'] +} + +const apiNode = { + api_node: true, + category: 'api/image/OpenAI' +} satisfies Pick + +describe('nodeDisabledState', () => { + beforeEach(() => { + setActivePinia(createTestingPinia({ stubActions: false })) + }) + + it('matches API nodes to provider categories', () => { + expect(isNodeFromPartnerProvider(apiNode, provider)).toBe(true) + expect( + isNodeFromPartnerProvider({ ...apiNode, api_node: false }, provider) + ).toBe(false) + expect( + isNodeFromPartnerProvider( + { ...apiNode, category: 'api/image/Google' }, + provider + ) + ).toBe(false) + }) + + it('derives disabled state from enforced provider policy', () => { + const governanceStore = usePartnerNodeGovernanceStore() + governanceStore.providers = [provider] + governanceStore.policy = { + enforcementEnabled: true, + providers: [{ providerId: provider.id, enabled: false }] + } + const { isNodeDisabled } = useNodeDisabledState() + + expect(isNodeDisabled(apiNode)).toBe(true) + + governanceStore.policy = { + enforcementEnabled: false, + providers: [{ providerId: provider.id, enabled: false }] + } + expect(isNodeDisabled(apiNode)).toBe(false) + + governanceStore.policy = { + enforcementEnabled: true, + providers: [{ providerId: provider.id, enabled: true }] + } + expect(isNodeDisabled(apiNode)).toBe(false) + }) + + it('disables a governed provider missing from an enforced policy', () => { + const governanceStore = usePartnerNodeGovernanceStore() + governanceStore.providers = [provider] + governanceStore.policy = { + enforcementEnabled: true, + providers: [] + } + + expect(useNodeDisabledState().isNodeDisabled(apiNode)).toBe(true) + }) +}) diff --git a/src/platform/nodeDisabled/nodeDisabledState.ts b/src/platform/nodeDisabled/nodeDisabledState.ts new file mode 100644 index 00000000000..e789b4d214d --- /dev/null +++ b/src/platform/nodeDisabled/nodeDisabledState.ts @@ -0,0 +1,42 @@ +import { computed } from 'vue' + +import type { ComfyNodeDef } from '@/schemas/nodeDefSchema' +import type { PartnerProvider } from '@/platform/workspace/api/partnerNodePolicyApi' +import { usePartnerNodeGovernanceStore } from '@/platform/workspace/stores/partnerNodeGovernanceStore' +import { getProviderName } from '@/utils/categoryUtil' + +type NodeDisabledInput = Pick + +export function isNodeFromPartnerProvider( + nodeDef: NodeDisabledInput, + provider: PartnerProvider +): boolean { + return ( + nodeDef.api_node === true && + provider.nodeCategories.includes(getProviderName(nodeDef.category)) + ) +} + +export function useNodeDisabledState() { + const governanceStore = usePartnerNodeGovernanceStore() + const disabledNodeCategories = computed(() => { + if (governanceStore.policy?.enforcementEnabled !== true) { + return new Set() + } + + return new Set( + governanceStore.providers + .filter(({ id }) => !governanceStore.isProviderEnabled(id)) + .flatMap(({ nodeCategories }) => nodeCategories) + ) + }) + + function isNodeDisabled(nodeDef: NodeDisabledInput): boolean { + return ( + nodeDef.api_node === true && + disabledNodeCategories.value.has(getProviderName(nodeDef.category)) + ) + } + + return { isNodeDisabled } +} diff --git a/src/platform/workspace/components/dialogs/settings/PartnerNodeAccessPanel.vue b/src/platform/workspace/components/dialogs/settings/PartnerNodeAccessPanel.vue index 722bef73280..85d0bc2be47 100644 --- a/src/platform/workspace/components/dialogs/settings/PartnerNodeAccessPanel.vue +++ b/src/platform/workspace/components/dialogs/settings/PartnerNodeAccessPanel.vue @@ -328,11 +328,12 @@ import Button from '@/components/ui/button/Button.vue' import { buttonVariants } from '@/components/ui/button/button.variants' import SearchInput from '@/components/ui/search-input/SearchInput.vue' import Skeleton from '@/components/ui/skeleton/Skeleton.vue' +import { isNodeFromPartnerProvider } from '@/platform/nodeDisabled/nodeDisabledState' import { useWorkspaceUI } from '@/platform/workspace/composables/useWorkspaceUI' import { usePartnerNodeGovernanceStore } from '@/platform/workspace/stores/partnerNodeGovernanceStore' import { useNodeDefStore } from '@/stores/nodeDefStore' import { useDialogStore } from '@/stores/dialogStore' -import { getProviderIcon, getProviderName } from '@/utils/categoryUtil' +import { getProviderIcon } from '@/utils/categoryUtil' import { cn } from '@comfyorg/tailwind-utils' const governanceStore = usePartnerNodeGovernanceStore() @@ -372,11 +373,7 @@ const providerRows = computed(() => .filter(({ nodeCategories }) => nodeCategories.length > 0) .map((provider) => { const nodes = Object.values(nodeDefsByName.value) - .filter( - (nodeDef) => - nodeDef.api_node && - provider.nodeCategories.includes(getProviderName(nodeDef.category)) - ) + .filter((nodeDef) => isNodeFromPartnerProvider(nodeDef, provider)) .map((nodeDef) => ({ id: nodeDef.name, name: nodeDef.display_name || nodeDef.name diff --git a/src/services/litegraphService.test.ts b/src/services/litegraphService.test.ts index aa98de77b42..55737428dae 100644 --- a/src/services/litegraphService.test.ts +++ b/src/services/litegraphService.test.ts @@ -10,6 +10,7 @@ vi.mock('@/scripts/app', () => ({ import { app } from '@/scripts/app' import { LiteGraph } from '@/lib/litegraph/src/litegraph' +import { usePartnerNodeGovernanceStore } from '@/platform/workspace/stores/partnerNodeGovernanceStore' import type { ComfyNodeDef } from '@/schemas/nodeDefSchema' import { useLitegraphService } from '@/services/litegraphService' import { useSettingStore } from '@/platform/settings/settingStore' @@ -52,30 +53,55 @@ describe('useLitegraphService().registerNodeDef', () => { setActivePinia(createTestingPinia({ stubActions: false })) }) - it('keeps disabled nodes hidden when developer mode changes', async () => { - useNodeDefStore() + it('reactively applies policy-disabled discovery state in developer mode', async () => { + const nodeDefStore = useNodeDefStore() const settingStore = useSettingStore() + const governanceStore = usePartnerNodeGovernanceStore() + governanceStore.providers = [ + { + id: 'openai', + displayName: 'OpenAI', + nodeCategories: ['OpenAI'] + } + ] + governanceStore.policy = { + enforcementEnabled: true, + providers: [{ providerId: 'openai', enabled: true }] + } const nodeDef: ComfyNodeDef = { name: 'DisabledTestNode', display_name: 'Disabled Test Node', - category: 'test', + category: '_for_testing/partner-governance/OpenAI', python_module: 'test', description: '', input: {}, output: [], output_node: false, dev_only: true, - disabled: { - reasons: [{ type: 'workspace_provider_disabled' }] - } + api_node: true } + settingStore.settingValues['Comfy.DevMode'] = true + await nextTick() await useLitegraphService().registerNodeDef(nodeDef.name, nodeDef) + nodeDefStore.updateNodeDefs([nodeDef]) try { - settingStore.settingValues['Comfy.DevMode'] = true + expect(LiteGraph.getNodeTypesCategories()).toContain(nodeDef.category) + + governanceStore.policy = { + enforcementEnabled: true, + providers: [{ providerId: 'openai', enabled: false }] + } + await nextTick() + expect(LiteGraph.getNodeTypesCategories()).not.toContain(nodeDef.category) + + governanceStore.policy = { + enforcementEnabled: true, + providers: [{ providerId: 'openai', enabled: true }] + } await nextTick() - expect(LiteGraph.registered_node_types[nodeDef.name].skip_list).toBe(true) + expect(LiteGraph.getNodeTypesCategories()).toContain(nodeDef.category) } finally { LiteGraph.unregisterNodeType(nodeDef.name) } diff --git a/src/services/litegraphService.ts b/src/services/litegraphService.ts index a2c17884f07..5755e06d55d 100644 --- a/src/services/litegraphService.ts +++ b/src/services/litegraphService.ts @@ -36,6 +36,7 @@ import type { ISerialisedNode } from '@/lib/litegraph/src/types/serialisation' import type { IBaseWidget } from '@/lib/litegraph/src/types/widgets' +import { useNodeDisabledState } from '@/platform/nodeDisabled/nodeDisabledState' import { useSettingStore } from '@/platform/settings/settingStore' import { useToastStore } from '@/platform/updates/common/toastStore' import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore' @@ -177,6 +178,7 @@ function getMinSize(node: LGraphNode) { */ export const useLitegraphService = () => { const extensionService = useExtensionService() + const { isNodeDisabled } = useNodeDisabledState() const toastStore = useToastStore() const widgetStore = useWidgetStore() const canvasStore = useCanvasStore() @@ -601,7 +603,7 @@ export const useLitegraphService = () => { node.category = nodeDef.category node.title = nodeDef.display_name || nodeDef.name - if (nodeDef.disabled !== undefined) { + if (isNodeDisabled(nodeDef)) { node.skip_list = true } else if (nodeDef.dev_only) { const settingStore = useSettingStore() diff --git a/src/stores/nodeDefStore.test.ts b/src/stores/nodeDefStore.test.ts index da46574b51a..9f910c4f7ad 100644 --- a/src/stores/nodeDefStore.test.ts +++ b/src/stores/nodeDefStore.test.ts @@ -10,10 +10,27 @@ import { createTestSubgraph, createTestSubgraphNode } from '@/lib/litegraph/src/subgraph/__fixtures__/subgraphHelpers' +import type { PartnerProvider } from '@/platform/workspace/api/partnerNodePolicyApi' +import { usePartnerNodeGovernanceStore } from '@/platform/workspace/stores/partnerNodeGovernanceStore' import type { ComfyNodeDef } from '@/schemas/nodeDefSchema' import { useNodeDefStore, useNodeFrequencyStore } from '@/stores/nodeDefStore' import type { NodeDefFilter } from '@/stores/nodeDefStore' +const partnerProvider: PartnerProvider = { + id: 'openai', + displayName: 'OpenAI', + nodeCategories: ['OpenAI'] +} + +function setPartnerProviderEnabled(enabled: boolean) { + const governanceStore = usePartnerNodeGovernanceStore() + governanceStore.providers = [partnerProvider] + governanceStore.policy = { + enforcementEnabled: true, + providers: [{ providerId: partnerProvider.id, enabled }] + } +} + describe('useNodeDefStore', () => { let store: ReturnType @@ -247,21 +264,26 @@ describe('useNodeDefStore', () => { expect(store.visibleNodeDefs).toHaveLength(2) }) - it('should hide disabled nodes', () => { + it('should reactively hide nodes disabled by provider policy', () => { + setPartnerProviderEnabled(false) store.updateNodeDefs([ createMockNodeDef({ name: 'enabled' }), createMockNodeDef({ name: 'disabled', - disabled: { - reasons: [{ type: 'workspace_provider_disabled' }] - } + api_node: true, + category: 'api/image/OpenAI' }) ]) expect(store.visibleNodeDefs.map((node) => node.name)).toEqual([ 'enabled' ]) - expect(store.nodeDefsByName.disabled.disabled).toBeDefined() + + setPartnerProviderEnabled(true) + expect(store.visibleNodeDefs.map((node) => node.name)).toEqual([ + 'enabled', + 'disabled' + ]) }) it('should hide subgraph nodes by default', () => { @@ -439,13 +461,13 @@ describe('useNodeDefStore', () => { }) it('excludes disabled nodes from frequent suggestions', async () => { + setPartnerProviderEnabled(false) store.updateNodeDefs([ createMockNodeDef({ name: 'enabled' }), createMockNodeDef({ name: 'disabled', - disabled: { - reasons: [{ type: 'workspace_provider_disabled' }] - } + api_node: true, + category: 'api/image/OpenAI' }) ]) vi.spyOn(axios, 'get').mockResolvedValue({ diff --git a/src/stores/nodeDefStore.ts b/src/stores/nodeDefStore.ts index 21351363e38..17ad31cc544 100644 --- a/src/stores/nodeDefStore.ts +++ b/src/stores/nodeDefStore.ts @@ -19,9 +19,9 @@ import type { ComfyInputsSpec as ComfyInputSpecV1, ComfyNodeDef as ComfyNodeDefV1, ComfyOutputTypesSpec as ComfyOutputSpecV1, - NodeDisabled, PriceBadge } from '@/schemas/nodeDefSchema' +import { useNodeDisabledState } from '@/platform/nodeDisabled/nodeDisabledState' import { useSettingStore } from '@/platform/settings/settingStore' import { NodeSearchService } from '@/services/nodeSearchService' import { useSubgraphStore } from '@/stores/subgraphStore' @@ -50,7 +50,6 @@ export class ComfyNodeDefImpl readonly deprecated: boolean readonly experimental: boolean readonly dev_only: boolean - readonly disabled?: NodeDisabled readonly output_node: boolean readonly api_node: boolean /** @@ -327,6 +326,7 @@ export interface NodeDefFilter { export const useNodeDefStore = defineStore('nodeDef', () => { const settingStore = useSettingStore() + const { isNodeDisabled } = useNodeDisabledState() const nodeDefsByName = ref>({}) const nodeDefsByDisplayName = ref>({}) @@ -335,21 +335,18 @@ export const useNodeDefStore = defineStore('nodeDef', () => { const showDevOnly = computed(() => settingStore.get('Comfy.DevMode')) const nodeDefFilters = ref([]) - // Update skip_list on all registered node types when dev mode changes - // This ensures LiteGraph's getNodeTypesCategories/getNodeTypesInCategory - // correctly filter dev-only nodes from the right-click context menu watchEffect(() => { const devModeEnabled = showDevOnly.value + const registeredNodeDefs = nodeDefsByName.value for (const nodeType of Object.values(LiteGraph.registered_node_types)) { - const nodeData = nodeType.nodeData - if ( - nodeData && - 'disabled' in nodeData && - nodeData.disabled !== undefined - ) { + const nodeData = + registeredNodeDefs[nodeType.nodeData?.name ?? ''] ?? nodeType.nodeData + if (nodeData && isNodeDisabled(nodeData)) { nodeType.skip_list = true } else if (nodeData?.dev_only) { nodeType.skip_list = !devModeEnabled + } else if (nodeData?.api_node) { + nodeType.skip_list = false } } }) @@ -389,7 +386,7 @@ export const useNodeDefStore = defineStore('nodeDef', () => { return nodeDefs.value.filter( (nodeDef) => nodeDefFilters.value.every((filter) => filter.predicate(nodeDef)) && - nodeDef.disabled === undefined + !isNodeDisabled(nodeDef) ) }) const nodeSearchService = computed( From fd8c4bce34e8f70fcf00c5bfab17cb8fefc2c742 Mon Sep 17 00:00:00 2001 From: ShihChi Huang Date: Tue, 4 Aug 2026 11:10:09 -0700 Subject: [PATCH 5/6] docs: clarify object info migration --- src/platform/nodeDisabled/nodeDisabledState.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/src/platform/nodeDisabled/nodeDisabledState.ts b/src/platform/nodeDisabled/nodeDisabledState.ts index e789b4d214d..1bfd8abb04d 100644 --- a/src/platform/nodeDisabled/nodeDisabledState.ts +++ b/src/platform/nodeDisabled/nodeDisabledState.ts @@ -7,6 +7,7 @@ import { getProviderName } from '@/utils/categoryUtil' type NodeDisabledInput = Pick +// TODO: Remove isNodeFromPartnerProvider once object_info.disabled is available. export function isNodeFromPartnerProvider( nodeDef: NodeDisabledInput, provider: PartnerProvider From 04c32feaa3cc70fc759f54d185463de3c51134f6 Mon Sep 17 00:00:00 2001 From: huang47 <157390+huang47@users.noreply.github.com> Date: Wed, 5 Aug 2026 10:17:51 -0700 Subject: [PATCH 6/6] fix: lazily initialize node governance state --- .../nodeDisabled/nodeDisabledState.ts | 34 ++++++++++++------- 1 file changed, 21 insertions(+), 13 deletions(-) diff --git a/src/platform/nodeDisabled/nodeDisabledState.ts b/src/platform/nodeDisabled/nodeDisabledState.ts index 1bfd8abb04d..7a50641007e 100644 --- a/src/platform/nodeDisabled/nodeDisabledState.ts +++ b/src/platform/nodeDisabled/nodeDisabledState.ts @@ -1,4 +1,5 @@ import { computed } from 'vue' +import type { ComputedRef } from 'vue' import type { ComfyNodeDef } from '@/schemas/nodeDefSchema' import type { PartnerProvider } from '@/platform/workspace/api/partnerNodePolicyApi' @@ -19,23 +20,30 @@ export function isNodeFromPartnerProvider( } export function useNodeDisabledState() { - const governanceStore = usePartnerNodeGovernanceStore() - const disabledNodeCategories = computed(() => { - if (governanceStore.policy?.enforcementEnabled !== true) { - return new Set() - } - - return new Set( - governanceStore.providers - .filter(({ id }) => !governanceStore.isProviderEnabled(id)) - .flatMap(({ nodeCategories }) => nodeCategories) - ) - }) + let disabledNodeCategories: ComputedRef> | undefined + + function getDisabledNodeCategories() { + if (disabledNodeCategories) return disabledNodeCategories + + const governanceStore = usePartnerNodeGovernanceStore() + disabledNodeCategories = computed(() => { + if (governanceStore.policy?.enforcementEnabled !== true) { + return new Set() + } + + return new Set( + governanceStore.providers + .filter(({ id }) => !governanceStore.isProviderEnabled(id)) + .flatMap(({ nodeCategories }) => nodeCategories) + ) + }) + return disabledNodeCategories + } function isNodeDisabled(nodeDef: NodeDisabledInput): boolean { return ( nodeDef.api_node === true && - disabledNodeCategories.value.has(getProviderName(nodeDef.category)) + getDisabledNodeCategories().value.has(getProviderName(nodeDef.category)) ) }