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..7a50641007e --- /dev/null +++ b/src/platform/nodeDisabled/nodeDisabledState.ts @@ -0,0 +1,51 @@ +import { computed } from 'vue' +import type { ComputedRef } 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 + +// TODO: Remove isNodeFromPartnerProvider once object_info.disabled is available. +export function isNodeFromPartnerProvider( + nodeDef: NodeDisabledInput, + provider: PartnerProvider +): boolean { + return ( + nodeDef.api_node === true && + provider.nodeCategories.includes(getProviderName(nodeDef.category)) + ) +} + +export function useNodeDisabledState() { + 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 && + getDisabledNodeCategories().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 25a065bae5f..55737428dae 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', () => ({ @@ -8,7 +9,12 @@ 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' +import { useNodeDefStore } from '@/stores/nodeDefStore' describe('useLitegraphService().getCanvasCenter', () => { beforeEach(() => { @@ -41,3 +47,63 @@ describe('useLitegraphService().getCanvasCenter', () => { expect(center).toEqual([110, 70]) }) }) + +describe('useLitegraphService().registerNodeDef', () => { + beforeEach(() => { + setActivePinia(createTestingPinia({ stubActions: false })) + }) + + 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: '_for_testing/partner-governance/OpenAI', + python_module: 'test', + description: '', + input: {}, + output: [], + output_node: false, + dev_only: true, + api_node: true + } + + settingStore.settingValues['Comfy.DevMode'] = true + await nextTick() + await useLitegraphService().registerNodeDef(nodeDef.name, nodeDef) + nodeDefStore.updateNodeDefs([nodeDef]) + + try { + 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.getNodeTypesCategories()).toContain(nodeDef.category) + } finally { + LiteGraph.unregisterNodeType(nodeDef.name) + } + }) +}) diff --git a/src/services/litegraphService.ts b/src/services/litegraphService.ts index b4beadc87d1..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,9 +603,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 (isNodeDisabled(nodeDef)) { + 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..9f910c4f7ad 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' @@ -9,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 } from '@/stores/nodeDefStore' +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 @@ -246,6 +264,28 @@ describe('useNodeDefStore', () => { expect(store.visibleNodeDefs).toHaveLength(2) }) + it('should reactively hide nodes disabled by provider policy', () => { + setPartnerProviderEnabled(false) + store.updateNodeDefs([ + createMockNodeDef({ name: 'enabled' }), + createMockNodeDef({ + name: 'disabled', + api_node: true, + category: 'api/image/OpenAI' + }) + ]) + + expect(store.visibleNodeDefs.map((node) => node.name)).toEqual([ + 'enabled' + ]) + + setPartnerProviderEnabled(true) + expect(store.visibleNodeDefs.map((node) => node.name)).toEqual([ + 'enabled', + 'disabled' + ]) + }) + it('should hide subgraph nodes by default', () => { const normalNode = createMockNodeDef({ name: 'normal', @@ -419,4 +459,26 @@ describe('useNodeDefStore', () => { expect(filterCallCount).toBe(10 * 5) }) }) + + it('excludes disabled nodes from frequent suggestions', async () => { + setPartnerProviderEnabled(false) + store.updateNodeDefs([ + createMockNodeDef({ name: 'enabled' }), + createMockNodeDef({ + name: 'disabled', + api_node: true, + category: 'api/image/OpenAI' + }) + ]) + 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..17ad31cc544 100644 --- a/src/stores/nodeDefStore.ts +++ b/src/stores/nodeDefStore.ts @@ -21,6 +21,7 @@ import type { ComfyOutputTypesSpec as ComfyOutputSpecV1, 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' @@ -325,6 +326,7 @@ export interface NodeDefFilter { export const useNodeDefStore = defineStore('nodeDef', () => { const settingStore = useSettingStore() + const { isNodeDisabled } = useNodeDisabledState() const nodeDefsByName = ref>({}) const nodeDefsByDisplayName = ref>({}) @@ -333,14 +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)) { - if (nodeType.nodeData?.dev_only) { + 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 } } }) @@ -377,8 +383,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)) && + !isNodeDisabled(nodeDef) ) }) const nodeSearchService = computed( @@ -560,9 +568,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) })