LCOV - code coverage report
Current view: top level - src/platform/openOnCloud - cloudCompatibilityApi.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 1.8 % 111 2
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import type { CompatibilityModel } from '@comfyorg/ingest-types'
       2              : import { zCheckCloudCompatibilityResponse } from '@comfyorg/ingest-types/zod'
       3              : import { reportError } from '@comfyorg/telemetry/reportError'
       4              : 
       5              : import { getComfyCloudBaseUrl } from '@/config/comfyApi'
       6              : import type {
       7              :   ExecutableLGraphNode,
       8              :   ExecutionId,
       9              :   LGraph
      10              : } from '@/lib/litegraph/src/litegraph'
      11              : import {
      12              :   ExecutableNodeDTO,
      13              :   LGraphEventMode
      14              : } from '@/lib/litegraph/src/litegraph'
      15              : import { app } from '@/scripts/app'
      16              : import { useAuthStore } from '@/stores/authStore'
      17              : import { useModelStore } from '@/stores/modelStore'
      18              : import { useModelToNodeStore } from '@/stores/modelToNodeStore'
      19              : import { isModelFileName } from '@/platform/workflowErrors/missingModel/missingModelScan'
      20              : import { matchesWidgetName } from '@/utils/widgetBinding'
      21              : import type { CloudWorkflowCheckResult } from '@/platform/openOnCloud/cloudWorkflowCheck'
      22              : 
      23         2355 : const LINKED = Symbol('linked')
      24              : 
      25              : type CheckedNode = {
      26              :   class_type: string
      27              :   inputs: Record<string, unknown>
      28              :   pickerInputs: Set<string>
      29              :   hasUnreadableModels: boolean
      30              : }
      31              : 
      32         2355 : const PICKER_WIDGET_TYPES = new Set(['combo', 'asset'])
      33              : 
      34            0 : function isSkippedByExecution(mode: LGraphEventMode | undefined): boolean {
      35            0 :   return mode === LGraphEventMode.NEVER || mode === LGraphEventMode.BYPASS
      36              : }
      37              : 
      38            0 : function executableNodes(graph: LGraph): ExecutableLGraphNode[] {
      39            0 :   const byId = new Map<ExecutionId, ExecutableLGraphNode>()
      40            0 :   for (const node of graph.nodes) {
      41            0 :     const dto = new ExecutableNodeDTO(node, [], byId)
      42            0 :     byId.set(dto.id, dto)
      43            0 :     if (isSkippedByExecution(node.mode)) continue
      44            0 :     for (const inner of dto.getInnerNodes()) byId.set(inner.id, inner)
      45              :   }
      46            0 :   return [...byId.values()].filter(
      47              :     (node) => !node.isVirtualNode && !isSkippedByExecution(node.mode)
      48              :   )
      49              : }
      50              : 
      51            0 : function nodeType(node: ExecutableLGraphNode): string {
      52              :   const source = node instanceof ExecutableNodeDTO ? node.node : null
      53            0 :   return source?.last_serialization?.type ?? node.comfyClass ?? node.type
      54              : }
      55              : 
      56            0 : function nodeInputs(node: ExecutableLGraphNode): Record<string, unknown> {
      57            0 :   const widgets = (node.widgets ?? []).filter(
      58              :     (widget) => widget.name && widget.options.serialize !== false
      59              :   )
      60            0 :   const inputs: Record<string, unknown> = Object.fromEntries(
      61              :     widgets.map((widget) => [widget.name, widget.value])
      62              :   )
      63            0 :   for (const [slot, input] of node.inputs.entries()) {
      64            0 :     const resolved = node.resolveInput(slot)
      65            0 :     if (!resolved) continue
      66            0 :     inputs[input.name] = resolved.widgetInfo
      67              :       ? resolved.widgetInfo.value
      68              :       : LINKED
      69              :   }
      70            0 :   return inputs
      71              : }
      72              : 
      73            0 : function pickerInputs(node: ExecutableLGraphNode): Set<string> {
      74            0 :   const widgets = (node.widgets ?? []).filter((widget) =>
      75              :     PICKER_WIDGET_TYPES.has(widget.type)
      76              :   )
      77            0 :   return new Set(widgets.map((widget) => widget.name))
      78              : }
      79              : 
      80            0 : function hasUnreadableModels(node: ExecutableLGraphNode): boolean {
      81            0 :   if (node.comfyClass || !(node instanceof ExecutableNodeDTO)) return false
      82            0 :   const values: unknown = node.node.last_serialization?.widgets_values
      83              :   const saved = Array.isArray(values)
      84              :     ? values
      85              :     : values && typeof values === 'object'
      86              :       ? Object.values(values)
      87              :       : []
      88            0 :   return saved.some(
      89              :     (value) => typeof value === 'string' && isModelFileName(value)
      90              :   )
      91              : }
      92              : 
      93            0 : function checkedNodes(graph: LGraph): CheckedNode[] {
      94            0 :   return executableNodes(graph).map((node) => ({
      95              :     class_type: nodeType(node),
      96              :     inputs: nodeInputs(node),
      97              :     pickerInputs: pickerInputs(node),
      98              :     hasUnreadableModels: hasUnreadableModels(node)
      99              :   }))
     100              : }
     101              : 
     102            0 : function modelInputsByNodeType() {
     103            0 :   const store = useModelToNodeStore()
     104            0 :   store.registerDefaults()
     105            0 :   const inputs = new Map<string, [folder: string, key: string | RegExp][]>()
     106            0 :   for (const [folder, providers] of Object.entries(store.modelToNodeMap)) {
     107            0 :     for (const { nodeDef, key } of providers ?? []) {
     108            0 :       const entries = inputs.get(nodeDef.name) ?? []
     109            0 :       inputs.set(nodeDef.name, [...entries, [folder, key]])
     110              :     }
     111              :   }
     112            0 :   return inputs
     113              : }
     114              : 
     115            0 : async function localModelFolders(): Promise<Map<string, string | null>> {
     116            0 :   const folders = await useModelStore().loadModels()
     117            0 :   const folderByName = new Map<string, string | null>()
     118            0 :   for (const folder of folders) {
     119            0 :     for (const model of Object.values(folder.models)) {
     120            0 :       const known = folderByName.get(model.file_name)
     121            0 :       folderByName.set(
     122              :         model.file_name,
     123              :         known === undefined || known === folder.directory
     124              :           ? folder.directory
     125              :           : null
     126              :       )
     127              :     }
     128              :   }
     129            0 :   return folderByName
     130              : }
     131              : 
     132            0 : function loaderFolders(
     133              :   loaderInputs: [folder: string, key: string | RegExp][],
     134              :   input: string
     135              : ): string[] {
     136            0 :   return loaderInputs
     137              :     .filter(([, key]) => matchesWidgetName(input, key))
     138              :     .map(([folder]) => folder)
     139              : }
     140              : 
     141              : type ModelScan = {
     142              :   mapped: CompatibilityModel[]
     143              :   unmapped: string[]
     144              :   hasLinkedModelInput: boolean
     145              : }
     146              : 
     147            0 : function scanNode(
     148              :   node: CheckedNode,
     149              :   loaderInputs: [folder: string, key: string | RegExp][],
     150              :   scan: ModelScan
     151              : ) {
     152            0 :   for (const [input, value] of Object.entries(node.inputs)) {
     153            0 :     const folders = loaderFolders(loaderInputs, input)
     154            0 :     const isModelInput = folders.length > 0 || node.pickerInputs.has(input)
     155            0 :     if (value === LINKED) {
     156            0 :       if (isModelInput) scan.hasLinkedModelInput = true
     157            0 :       continue
     158              :     }
     159            0 :     if (typeof value !== 'string') continue
     160            0 :     scan.mapped.push(...folders.map((folder) => ({ folder, name: value })))
     161            0 :     if (!folders.length && isModelInput && isModelFileName(value))
     162            0 :       scan.unmapped.push(value)
     163              :   }
     164              : }
     165              : 
     166            0 : function scanModelInputs(nodes: CheckedNode[]): ModelScan {
     167            0 :   const inputsByType = modelInputsByNodeType()
     168            0 :   const scan: ModelScan = {
     169              :     mapped: [],
     170              :     unmapped: [],
     171              :     hasLinkedModelInput: false
     172              :   }
     173            0 :   for (const node of nodes)
     174            0 :     scanNode(node, inputsByType.get(node.class_type) ?? [], scan)
     175            0 :   return scan
     176              : }
     177              : 
     178            0 : async function resolveUnmapped(
     179              :   names: string[]
     180              : ): Promise<CompatibilityModel[] | null> {
     181            0 :   if (!names.length) return []
     182            0 :   const folderByName = await localModelFolders()
     183            0 :   const resolved: CompatibilityModel[] = []
     184            0 :   for (const name of names) {
     185            0 :     const folder = folderByName.get(name)
     186            0 :     if (!folder) return null
     187            0 :     resolved.push({ folder, name })
     188              :   }
     189            0 :   return resolved
     190              : }
     191              : 
     192            0 : async function collectModels(
     193              :   nodes: CheckedNode[]
     194              : ): Promise<CompatibilityModel[] | null> {
     195            0 :   const { mapped, unmapped, hasLinkedModelInput } = scanModelInputs(nodes)
     196            0 :   if (hasLinkedModelInput) return null
     197            0 :   const resolved = await resolveUnmapped(unmapped)
     198            0 :   if (!resolved) return null
     199            0 :   const models = new Map<string, CompatibilityModel>()
     200            0 :   for (const model of [...mapped, ...resolved])
     201            0 :     models.set(JSON.stringify([model.folder, model.name]), model)
     202            0 :   return [...models.values()]
     203              : }
     204              : 
     205            0 : async function postCompatibilityCheck(
     206              :   nodes: CheckedNode[]
     207              : ): Promise<Response | null> {
     208            0 :   const models = await collectModels(nodes)
     209            0 :   if (!models) return null
     210            0 :   const nodeTypes = [...new Set(nodes.map((node) => node.class_type))]
     211            0 :   const auth = await useAuthStore().getAuthHeader()
     212            0 :   return fetch(new URL('/api/cloud/compatibility', getComfyCloudBaseUrl()), {
     213              :     method: 'POST',
     214              :     headers: { 'Content-Type': 'application/json', ...auth },
     215              :     body: JSON.stringify({
     216              :       node_types: nodeTypes,
     217              :       models
     218              :     }),
     219              :     signal: AbortSignal.timeout(10_000)
     220              :   })
     221              : }
     222              : 
     223            0 : function giveUp(cause: unknown): null {
     224            0 :   reportError(cause, {
     225              :     errorType: 'failure_checking_cloud_compatibility',
     226              :     surface: 'platform'
     227              :   })
     228            0 :   return null
     229              : }
     230              : 
     231              : /** Resolves null when no verdict is available. */
     232            0 : export async function checkCloudCompatibility(): Promise<CloudWorkflowCheckResult> {
     233            0 :   let body: unknown
     234            0 :   try {
     235            0 :     const nodes = checkedNodes(app.rootGraph)
     236            0 :     const unreadableLoader = nodes.find((node) => node.hasUnreadableModels)
     237            0 :     if (unreadableLoader)
     238            0 :       return {
     239              :         kind: 'unreadableModelLoader',
     240              :         nodeType: unreadableLoader.class_type
     241              :       }
     242            0 :     const response = await postCompatibilityCheck(nodes)
     243            0 :     if (!response) return null
     244            0 :     if (!response.ok)
     245            0 :       return giveUp(
     246              :         new Error(`Cloud compatibility returned ${response.status}`)
     247              :       )
     248            0 :     body = await response.json()
     249              :   } catch (error) {
     250            0 :     return giveUp(error)
     251              :   }
     252            0 :   const parsed = zCheckCloudCompatibilityResponse.safeParse(body)
     253            0 :   if (!parsed.success) return giveUp(parsed.error)
     254            0 :   const { missing_node_types: nodePacks, missing_models: models = [] } =
     255              :     parsed.data.cloud
     256            0 :   return nodePacks.length || models.length
     257              :     ? { kind: 'missing', gaps: { nodePacks, models } }
     258              :     : { kind: 'canOpen' }
     259              : }
        

Generated by: LCOV version 2.0-1