Line data Source code
1 : import type { ComfyTemplateInputAsset } from '@comfyorg/comfyui-desktop-bridge-types'
2 : import { computed, onScopeDispose, ref } from 'vue'
3 : import { useI18n } from 'vue-i18n'
4 :
5 : import { useToast } from '@/components/ui/toast/toastStore'
6 : import { createToastId } from '@/types/toastId'
7 : import { isCloud } from '@/platform/distribution/types'
8 : import { isLocalDesktopHost } from '@/utils/envUtil'
9 : import { useSettingStore } from '@/platform/settings/settingStore'
10 : import { useSurveyFeatureTracking } from '@/platform/surveys/useSurveyFeatureTracking'
11 : import { useTelemetry } from '@comfyorg/telemetry'
12 : import { reportError } from '@comfyorg/telemetry/reportError'
13 : import type { TemplateInput } from '@comfyorg/api-client/templateSchema'
14 : import { syncCompletedTemplateInputsWithCurrentGraph } from '@/platform/workflow/templates/composables/useTemplateInputDownloadGraphSync'
15 : import { useWorkflowTemplatesStore } from '@/platform/workflow/templates/repositories/workflowTemplatesStore'
16 : import { usePartnerNodesEducationStore } from '@/platform/workflow/templates/stores/partnerNodesEducationStore'
17 : import type {
18 : TemplateGroup,
19 : TemplateInfo,
20 : WorkflowTemplates
21 : } from '@comfyorg/api-client/templateTypes'
22 : import {
23 : getPendingTemplateSampleInputs,
24 : resolveTemplateInputAssets,
25 : startMissingTemplateInputDownloads
26 : } from '@/platform/workflow/templates/utils/templateInputAssets'
27 : import type {
28 : ComfyWorkflowJSON,
29 : LegacyLoadableWorkflow
30 : } from '@comfyorg/graph-model/workflowSchema'
31 : import {
32 : validateComfyWorkflow,
33 : zLegacyLoadableWorkflow
34 : } from '@comfyorg/graph-model/workflowSchema'
35 : import { api } from '@/scripts/api'
36 : import { app } from '@/scripts/app'
37 : import { useAssetsStore } from '@/stores/assetsStore'
38 : import { useDialogStore } from '@/stores/dialogStore'
39 :
40 : import { prepareTemplateInputs } from '@/platform/workflow/templates/services/templateInputService'
41 :
42 : type TemplateLoadResult = 'loaded' | 'graph-failed' | 'not-started'
43 :
44 : type FetchedTemplate =
45 : | { strict: true; json: ComfyWorkflowJSON }
46 : | { strict: false; json: LegacyLoadableWorkflow }
47 :
48 : export type PreparedWorkflowTemplate = {
49 : id: string
50 : sourceModule: string
51 : workflowName: string
52 : controller: AbortController
53 : data: FetchedTemplate & {
54 : template:
55 : | ReturnType<
56 : typeof useWorkflowTemplatesStore
57 : >['enhancedTemplates'][number]
58 : | undefined
59 : }
60 : }
61 :
62 9 : function updateTemplateEducation(
63 : isPartnerNode: boolean | undefined,
64 : loadedWorkflow: Awaited<ReturnType<typeof app.loadGraphData>>
65 : ) {
66 9 : const educationStore = usePartnerNodesEducationStore()
67 9 : if (isPartnerNode && typeof loadedWorkflow === 'object') {
68 3 : educationStore.requestCard(loadedWorkflow.key)
69 : } else {
70 6 : educationStore.retireCard()
71 : }
72 : }
73 :
74 2381 : export function useTemplateWorkflows() {
75 2381 : const { t } = useI18n()
76 2381 : const workflowTemplatesStore = useWorkflowTemplatesStore()
77 2381 : const dialogStore = useDialogStore()
78 2381 : const { trackFeatureUsed } = useSurveyFeatureTracking('example-workflows')
79 :
80 : // State
81 2381 : const selectedTemplate = ref<WorkflowTemplates | null>(null)
82 2381 : let ownedLoadController: AbortController | undefined
83 2381 : const loadingTemplateId = computed(
84 : () => workflowTemplatesStore.loadingTemplateId
85 : )
86 2381 : onScopeDispose(() => {
87 8 : workflowTemplatesStore.cancelTemplateLoad(ownedLoadController)
88 : })
89 :
90 : // Computed
91 2381 : const isTemplatesLoaded = computed(() => workflowTemplatesStore.isLoaded)
92 2381 : const allTemplateGroups = computed<TemplateGroup[]>(
93 : () => workflowTemplatesStore.groupedTemplates
94 : )
95 :
96 : /**
97 : * Loads all template workflows from the API
98 : */
99 2381 : const loadTemplates = async () => {
100 28 : if (!workflowTemplatesStore.isLoaded) {
101 26 : await workflowTemplatesStore.loadWorkflowTemplates()
102 : }
103 26 : return workflowTemplatesStore.isLoaded
104 : }
105 :
106 : /**
107 : * Selects the first template category as default
108 : */
109 2381 : const selectFirstTemplateCategory = () => {
110 0 : if (allTemplateGroups.value.length > 0) {
111 0 : const firstCategory = allTemplateGroups.value[0].modules[0]
112 0 : selectTemplateCategory(firstCategory)
113 : }
114 : }
115 :
116 : /**
117 : * Selects a template category
118 : */
119 2381 : const selectTemplateCategory = (category: WorkflowTemplates | null) => {
120 0 : selectedTemplate.value = category
121 0 : return category !== null
122 : }
123 :
124 : /**
125 : * Gets template thumbnail URL
126 : */
127 2381 : const getTemplateThumbnailUrl = (
128 : template: TemplateInfo,
129 : sourceModule: string,
130 : index = '1'
131 : ) => {
132 : const basePath =
133 : sourceModule === 'default'
134 : ? api.fileURL(`/templates/${template.name}`)
135 : : api.apiURL(`/workflow_templates/${sourceModule}/${template.name}`)
136 :
137 : const indexSuffix = sourceModule === 'default' && index ? `-${index}` : ''
138 1446 : return `${basePath}${indexSuffix}.${template.mediaSubtype}`
139 : }
140 :
141 : /**
142 : * Gets formatted template title
143 : */
144 2381 : const getTemplateTitle = (template: TemplateInfo, sourceModule: string) => {
145 1909 : const fallback = template.title ?? template.name
146 1909 : return sourceModule === 'default'
147 : ? (template.localizedTitle ?? fallback)
148 : : fallback
149 : }
150 :
151 : /**
152 : * Gets formatted template description
153 : */
154 2381 : const getTemplateDescription = (template: TemplateInfo) => {
155 0 : return (template.localizedDescription || template.description)
156 : .replace(/[-_]/g, ' ')
157 : .trim()
158 : }
159 :
160 10 : function resolveTemplateSource(id: string, sourceModule: string) {
161 10 : if (sourceModule !== 'all') return sourceModule
162 :
163 : const group = allTemplateGroups.value.find(
164 : (group) =>
165 : group.label ===
166 : t('templateWorkflows.category.ComfyUI Examples', 'ComfyUI Examples')
167 : )
168 : const category = group?.modules.find(
169 : (module) => module.moduleName === 'all'
170 : )
171 : const template = category?.templates.find(
172 : (template) => template.name === id
173 : )
174 10 : return template?.sourceModule
175 : }
176 :
177 9 : function startTemplateInputDownloads(id: string, sourceModule: string) {
178 9 : if (!isLocalDesktopHost() || sourceModule !== 'default') return
179 :
180 0 : void resolveTemplateInputAssets(id, () => window.__comfyDesktop2).then(
181 : (assets) => {
182 0 : startMissingTemplateInputDownloads(id, assets, {
183 : getBridge: () => window.__comfyDesktop2,
184 : reportError: (error) => {
185 0 : reportError(error, {
186 : surface: 'graph',
187 : errorType: 'workflow_template_input_download_failed',
188 : level: 'warning'
189 : })
190 : }
191 : })
192 : }
193 : )
194 : }
195 :
196 10 : function releasePreparedLoad(controller: AbortController) {
197 10 : workflowTemplatesStore.finishTemplateLoad(controller)
198 10 : if (ownedLoadController === controller) ownedLoadController = undefined
199 : }
200 :
201 1 : function showTemplateError(detail: string) {
202 1 : useToast().error(t('g.error'), { description: detail })
203 : }
204 :
205 0 : function reportTemplateError(error: unknown) {
206 0 : reportError(error, {
207 : surface: 'graph',
208 : errorType: 'error_loading_template'
209 : })
210 0 : showTemplateError(t('templateWorkflows.error.loading'))
211 : }
212 :
213 3 : async function withPreparedSampleInputs(
214 : workflow: ComfyWorkflowJSON,
215 : inputs: TemplateInput[],
216 : signal: AbortSignal
217 : ) {
218 3 : const toast = useToast()
219 3 : const progressToastId = createToastId()
220 3 : let preparedJson = workflow
221 3 : const errors: unknown[] = []
222 3 : try {
223 3 : const result = await prepareTemplateInputs(workflow, inputs, signal, {
224 : restoreNamed: useSettingStore().get(
225 : 'Comfy.Workflow.NamedValuesRestore'
226 : ),
227 : onStart: () => {
228 3 : toast.loading(t('templateWorkflows.preparingMedia'), {
229 : id: progressToastId
230 : })
231 : }
232 : })
233 3 : errors.push(...result.errors)
234 3 : preparedJson = result.workflow
235 3 : if (result.uploadedCount > 0) {
236 3 : await useAssetsStore().inputAssets.invalidate()
237 3 : await app.reloadNodeDefs()
238 : }
239 3 : signal.throwIfAborted()
240 : } catch (error) {
241 0 : signal.throwIfAborted()
242 0 : errors.push(error)
243 : } finally {
244 3 : toast.dismiss(progressToastId)
245 : }
246 3 : if (errors.length) {
247 0 : reportError(
248 : new AggregateError(errors, 'Template sample preparation failed'),
249 : {
250 : surface: 'graph',
251 : errorType: 'error_loading_template_media'
252 : }
253 : )
254 0 : toast.warning(t('g.warning'), {
255 : description: t('templateWorkflows.error.preparingMedia'),
256 : duration: 8000
257 : })
258 : }
259 3 : return preparedJson
260 : }
261 :
262 10 : async function loadTemplateData(
263 : id: string,
264 : sourceModule: string,
265 : signal: AbortSignal
266 : ) {
267 10 : const fetched = await fetchTemplateJson(id, sourceModule, signal)
268 10 : signal.throwIfAborted()
269 10 : if (!fetched) return null
270 9 : const template = workflowTemplatesStore.enhancedTemplates.find(
271 : (template) =>
272 : template.name === id && template.sourceModule === sourceModule
273 : )
274 9 : return { ...fetched, template }
275 : }
276 :
277 9 : async function loadTemplateGraph(
278 : {
279 : json,
280 : template
281 : }: Pick<PreparedWorkflowTemplate['data'], 'json' | 'template'>,
282 : workflowName: string,
283 : sourceModule: string
284 : ): Promise<TemplateLoadResult> {
285 9 : try {
286 9 : const loadedWorkflow = await app.loadGraphData(
287 : json as ComfyWorkflowJSON,
288 : true,
289 : true,
290 : workflowName,
291 : { openSource: 'template' }
292 : )
293 9 : if (loadedWorkflow === false) return 'graph-failed'
294 9 : if (loadedWorkflow === undefined) return 'not-started'
295 :
296 9 : updateTemplateEducation(template?.isPartnerNode, loadedWorkflow)
297 9 : await syncCompletedTemplateInputsWithCurrentGraph()
298 9 : if (sourceModule === 'default') trackFeatureUsed()
299 9 : return 'loaded'
300 : } catch (error) {
301 0 : reportTemplateError(error)
302 0 : return 'graph-failed'
303 : }
304 : }
305 :
306 10 : async function resolveTemplatePayload(
307 : id: string,
308 : sourceModule: string,
309 : signal: AbortSignal
310 : ) {
311 10 : const source = resolveTemplateSource(id, sourceModule)
312 10 : if (!source) {
313 0 : showTemplateError(
314 : t('templateWorkflows.error.templateNotFound', { templateName: id })
315 : )
316 0 : return null
317 : }
318 10 : const data = await loadTemplateData(id, source, signal)
319 10 : signal.throwIfAborted()
320 10 : if (!data) {
321 1 : showTemplateError(t('templateWorkflows.error.loading'))
322 1 : return null
323 : }
324 9 : return { source, data }
325 : }
326 :
327 10 : async function prepareWorkflowTemplate(
328 : id: string,
329 : sourceModule: string
330 : ): Promise<PreparedWorkflowTemplate | null> {
331 10 : if (!isTemplatesLoaded.value) {
332 0 : showTemplateError(t('templateWorkflows.error.loading'))
333 0 : return null
334 : }
335 10 : const controller = workflowTemplatesStore.startTemplateLoad(id)
336 10 : if (!controller) return null
337 10 : ownedLoadController = controller
338 10 : try {
339 10 : const payload = await resolveTemplatePayload(
340 : id,
341 : sourceModule,
342 : controller.signal
343 : )
344 10 : if (!payload) {
345 1 : releasePreparedLoad(controller)
346 1 : return null
347 : }
348 10 : return {
349 : id,
350 : sourceModule: payload.source,
351 : workflowName:
352 : payload.source === 'default'
353 : ? t(`templateWorkflows.template.${id}`, id)
354 : : id,
355 : controller,
356 : data: payload.data
357 : }
358 : } catch (error) {
359 0 : if (!controller.signal.aborted) reportTemplateError(error)
360 0 : releasePreparedLoad(controller)
361 0 : return null
362 : }
363 : }
364 :
365 9 : async function prepareWorkflowTemplateInputs(
366 : data: PreparedWorkflowTemplate['data'],
367 : sourceModule: string,
368 : signal: AbortSignal,
369 : inputAssets: readonly ComfyTemplateInputAsset[]
370 : ) {
371 9 : const inputs = data.template?.io?.inputs
372 9 : if (
373 : isCloud ||
374 : sourceModule !== 'default' ||
375 : !data.strict ||
376 : !inputs?.length
377 : )
378 6 : return data
379 :
380 3 : return {
381 : ...data,
382 : json: await withPreparedSampleInputs(
383 : data.json,
384 : getPendingTemplateSampleInputs(inputs, inputAssets),
385 : signal
386 : )
387 : }
388 : }
389 :
390 9 : async function openPreparedWorkflowTemplate(
391 : prepared: PreparedWorkflowTemplate,
392 : {
393 : downloadAssets,
394 : inputAssets = []
395 : }: {
396 : downloadAssets?: boolean
397 : inputAssets?: readonly ComfyTemplateInputAsset[]
398 : } = {}
399 : ): Promise<TemplateLoadResult> {
400 9 : const { id, sourceModule, workflowName, controller, data } = prepared
401 9 : try {
402 9 : controller.signal.throwIfAborted()
403 9 : const shouldDownloadAssets = downloadAssets ?? !isLocalDesktopHost()
404 9 : const preparedData = shouldDownloadAssets
405 : ? await prepareWorkflowTemplateInputs(
406 : data,
407 : sourceModule,
408 : controller.signal,
409 : inputAssets
410 : )
411 : : data
412 9 : controller.signal.throwIfAborted()
413 9 : if (!workflowTemplatesStore.startTemplateGraphLoad(controller))
414 0 : return 'not-started'
415 :
416 9 : useTelemetry()?.trackTemplate({
417 : workflow_name: id,
418 : template_source: sourceModule
419 : })
420 :
421 9 : dialogStore.closeDialog()
422 9 : if (shouldDownloadAssets) startTemplateInputDownloads(id, sourceModule)
423 9 : return await loadTemplateGraph(preparedData, workflowName, sourceModule)
424 : } catch (error) {
425 0 : if (!controller.signal.aborted) reportTemplateError(error)
426 0 : return 'not-started'
427 : } finally {
428 9 : releasePreparedLoad(controller)
429 : }
430 : }
431 :
432 133 : function discardPreparedWorkflowTemplate(
433 : prepared: PreparedWorkflowTemplate | null
434 : ) {
435 133 : if (!prepared) return
436 8 : workflowTemplatesStore.cancelTemplateLoad(prepared.controller)
437 8 : if (ownedLoadController === prepared.controller)
438 8 : ownedLoadController = undefined
439 : }
440 :
441 2 : async function loadWorkflowTemplate(
442 : id: string,
443 : sourceModule: string
444 : ): Promise<TemplateLoadResult> {
445 2 : const prepared = await prepareWorkflowTemplate(id, sourceModule)
446 2 : if (!prepared) return 'not-started'
447 1 : return openPreparedWorkflowTemplate(prepared)
448 : }
449 :
450 10 : async function fetchTemplateJson(
451 : id: string,
452 : sourceModule: string,
453 : signal: AbortSignal
454 : ): Promise<FetchedTemplate | null> {
455 : // Default templates provided by frontend are served on this separate endpoint
456 10 : const url =
457 : sourceModule === 'default'
458 : ? api.fileURL(`/templates/${id}.json`)
459 : : api.apiURL(`/workflow_templates/${sourceModule}/${id}.json`)
460 :
461 10 : const response = await fetch(url, { signal })
462 10 : if (!response.ok) {
463 1 : reportError(`Failed to fetch workflow template ${id}`, {
464 : surface: 'graph',
465 : errorType: 'error_fetching_workflow_template'
466 : })
467 1 : return null
468 : }
469 :
470 9 : const json: unknown = await response.json()
471 9 : let schemaMismatch: string | undefined
472 9 : const validated = await validateComfyWorkflow(json, (detail) => {
473 0 : schemaMismatch = detail
474 : })
475 9 : if (validated) return { strict: true, json: validated }
476 :
477 0 : const legacy = zLegacyLoadableWorkflow.safeParse(json)
478 0 : if (!legacy.success) {
479 0 : reportError(`Workflow template ${id} is not a loadable workflow`, {
480 : surface: 'graph',
481 : errorType: 'error_validating_workflow_template'
482 : })
483 0 : return null
484 : }
485 0 : if (schemaMismatch) {
486 0 : reportError(new Error(schemaMismatch), {
487 : surface: 'graph',
488 : errorType: 'error_validating_workflow_template_schema',
489 : level: 'warning'
490 : })
491 : }
492 0 : return { strict: false, json: legacy.data }
493 : }
494 :
495 2381 : return {
496 : // State
497 : selectedTemplate,
498 : loadingTemplateId,
499 :
500 : // Computed
501 : isTemplatesLoaded,
502 : allTemplateGroups,
503 :
504 : // Methods
505 : loadTemplates,
506 : selectFirstTemplateCategory,
507 : selectTemplateCategory,
508 : getTemplateThumbnailUrl,
509 : getTemplateTitle,
510 : getTemplateDescription,
511 : prepareWorkflowTemplate,
512 : openPreparedWorkflowTemplate,
513 : discardPreparedWorkflowTemplate,
514 : loadWorkflowTemplate
515 : }
516 : }
|