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 : }
|