Line data Source code
1 : import { once } from 'es-toolkit'
2 : import type { WatchHandle } from 'vue'
3 :
4 : import { useCurrentUser } from '@/composables/auth/useCurrentUser'
5 : import { useErrorHandling } from '@/composables/useErrorHandling'
6 : import { legacyMenuCompat } from '@/lib/litegraph/src/contextMenuCompat'
7 : import { useSettingStore } from '@/platform/settings/settingStore'
8 : import { useCommandStore } from '@/platform/keybindings/commandStore'
9 : import { useExtensionStore } from '@/platform/extensions/stores/extensionStore'
10 : import { KeybindingImpl } from '@comfyorg/keybindings/keybinding'
11 : import { useKeybindingStore } from '@comfyorg/keybindings/keybindingStore'
12 : import { useMenuItemStore } from '@/stores/menuItemStore'
13 : import { useWidgetStore } from '@/stores/widgetStore'
14 : import { useBottomPanelStore } from '@/stores/workspace/bottomPanelStore'
15 : import { useSidebarTabStore } from '@/stores/workspace/sidebarTabStore'
16 : import type { ComfyApp, ComfyExtension } from '@/types/comfy'
17 : import type { AuthUserInfo } from '@comfyorg/api-client/authTypes'
18 : import { useApp } from '@/scripts/appInstance'
19 : import { provideExtensionService } from '@/platform/extensions/services/extensionServiceAccess'
20 :
21 29597792 : function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
22 29597792 : return (
23 : value instanceof Promise ||
24 : (typeof value === 'object' &&
25 : value !== null &&
26 : typeof (value as { then?: unknown }).then === 'function')
27 : )
28 : }
29 :
30 2356 : const graphLoadLifecycleHooks = new Set<string>([
31 : 'beforeLoadGraph',
32 : 'beforeConfigureGraph',
33 : 'afterConfigureGraph',
34 : 'afterLoadGraph',
35 : 'onGraphLoadError'
36 : ] satisfies (keyof ComfyExtension)[])
37 :
38 2356 : const graphLoadEntrypoints = [
39 : 'loadGraphData',
40 : 'loadApiJson'
41 : ] satisfies (keyof ComfyApp)[]
42 :
43 2356 : const graphLoadHookOrigin = Symbol('graphLoadHookOrigin')
44 :
45 : /** True when this `handleFile` call came through a graph-load hook's app. */
46 1071 : export function isGraphLoadHookOrigin(options: unknown): boolean {
47 1071 : return (
48 : typeof options === 'object' &&
49 : options !== null &&
50 : (options as Record<symbol, unknown>)[graphLoadHookOrigin] === true
51 : )
52 : }
53 :
54 0 : function withGraphLoadHookOrigin(options: unknown): object {
55 0 : return typeof options === 'object' && options !== null
56 : ? { ...options, [graphLoadHookOrigin]: true }
57 : : { [graphLoadHookOrigin]: true }
58 : }
59 :
60 15590 : function createGraphLoadHookDispatch(app: ComfyApp) {
61 15590 : let dispatching = true
62 15590 : const overrides = new Map<PropertyKey, unknown>()
63 15590 : for (const name of graphLoadEntrypoints) {
64 31180 : const original = app[name]
65 31180 : overrides.set(name, (...args: unknown[]) =>
66 : dispatching ? Promise.resolve(false) : Reflect.apply(original, app, args)
67 : )
68 : }
69 : {
70 15590 : const original = app.handleFile
71 15590 : overrides.set('handleFile', (...args: unknown[]) => {
72 0 : if (!dispatching) return Reflect.apply(original, app, args)
73 0 : const [file, openSource, options] = args
74 0 : return Reflect.apply(original, app, [
75 : file,
76 : openSource,
77 : withGraphLoadHookOrigin(options)
78 : ])
79 : })
80 : }
81 : const hookApp = new Proxy(app, {
82 : get(target, property) {
83 1 : const override = overrides.get(property)
84 1 : if (override !== undefined) return override
85 0 : const value: unknown = Reflect.get(target, property, target)
86 1 : return typeof value === 'function' ? value.bind(target) : value
87 : }
88 : })
89 15590 : return {
90 : hookApp,
91 : endDispatch: () => {
92 15590 : dispatching = false
93 : }
94 : }
95 : }
96 :
97 7066 : function createSetupHookApp(app: ComfyApp, extensionName: string): ComfyApp {
98 7066 : const manager = Object(app.extensionManager) as ComfyApp['extensionManager']
99 7066 : const extensionManager = new Proxy(manager, {
100 : get(target, property) {
101 0 : if (property === 'registerSidebarTab') {
102 0 : return (tab: Parameters<typeof target.registerSidebarTab>[0]) => {
103 0 : const attributedManager = target as typeof target & {
104 : registerSidebarTabForExtension?: (
105 : tab: Parameters<typeof target.registerSidebarTab>[0],
106 : extensionName: string
107 : ) => void
108 : }
109 0 : return attributedManager.registerSidebarTabForExtension
110 : ? attributedManager.registerSidebarTabForExtension(
111 : tab,
112 : extensionName
113 : )
114 : : target.registerSidebarTab(tab)
115 : }
116 : }
117 0 : const value: unknown = Reflect.get(target, property, target)
118 0 : return typeof value === 'function' ? value.bind(target) : value
119 : }
120 : })
121 7066 : return new Proxy(app, {
122 : get(target, property) {
123 0 : if (property === 'extensionManager') return extensionManager
124 0 : const value: unknown = Reflect.get(target, property, target)
125 0 : return typeof value === 'function' ? value.bind(target) : value
126 : }
127 : })
128 : }
129 :
130 : type StartupHook =
131 : | 'init'
132 : | 'addCustomNodeDefs'
133 : | 'registerCustomNodes'
134 : | 'setup'
135 :
136 : export interface StartupHookFailure {
137 : extension: ComfyExtension
138 : method: StartupHook
139 : error: unknown
140 : }
141 :
142 2356 : export const useExtensionService = () => {
143 2588804 : const extensionStore = useExtensionStore()
144 2588804 : const settingStore = useSettingStore()
145 2588804 : const keybindingStore = useKeybindingStore()
146 2588804 : const sidebarTabStore = useSidebarTabStore()
147 2588804 : const {
148 : wrapWithErrorHandling,
149 : wrapWithErrorHandlingAsync,
150 : toastErrorHandler
151 : } = useErrorHandling()
152 :
153 : /**
154 : * Register an extension with the app.
155 : * @returns A disposer that stops the extension's auth hooks and unregisters it.
156 : */
157 2588804 : const registerExtension = (extension: ComfyExtension) => {
158 82791 : if (extensionStore.isHoldingCustomNodes) {
159 0 : extensionStore.holdCustomNode(extension)
160 0 : return once(() => extensionStore.releaseHeldCustomNode(extension))
161 : }
162 82791 : return registerExtensionNow(extension)
163 : }
164 :
165 : /** Registers an extension even while new ones are held. */
166 2588804 : const registerExtensionNow = (extension: ComfyExtension) => {
167 82791 : extensionStore.registerExtension(extension)
168 :
169 82791 : const contributes = extensionStore.contributes(extension.name)
170 82791 : const addKeybinding = wrapWithErrorHandling(
171 : keybindingStore.addDefaultKeybinding
172 : )
173 82791 : const addSetting = wrapWithErrorHandling(settingStore.addSetting)
174 :
175 82791 : if (contributes) {
176 82789 : extension.keybindings?.forEach((keybinding) => {
177 7 : addKeybinding(new KeybindingImpl(keybinding))
178 : })
179 82789 : useCommandStore().loadExtensionCommands(extension)
180 82789 : useMenuItemStore().loadExtensionMenuCommands(extension)
181 : }
182 82791 : extension.settings?.forEach(addSetting)
183 82791 : if (contributes) {
184 82789 : useBottomPanelStore().registerExtensionBottomPanelTabs(extension)
185 : }
186 82791 : if (extension.getCustomWidgets) {
187 16477 : void (async () => {
188 16477 : if (extension.getCustomWidgets) {
189 16477 : const widgets = await extension.getCustomWidgets(useApp())
190 16477 : useWidgetStore().registerCustomWidgets(widgets)
191 : }
192 : })()
193 : }
194 :
195 82791 : if (!contributes) {
196 2 : return once(() => extensionStore.unregisterExtension(extension.name))
197 : }
198 :
199 82789 : const authHookHandles: WatchHandle[] = []
200 :
201 82791 : if (extension.onAuthUserResolved) {
202 0 : const { onUserResolved } = useCurrentUser()
203 0 : const handleUserResolved = wrapWithErrorHandlingAsync(
204 : (user: AuthUserInfo) => extension.onAuthUserResolved?.(user, useApp()),
205 : (error) => {
206 0 : console.error('[Extension Auth Hook Error]', {
207 : extension: extension.name,
208 : hook: 'onAuthUserResolved',
209 : error
210 : })
211 0 : toastErrorHandler(error)
212 : }
213 : )
214 0 : authHookHandles.push(
215 : onUserResolved((user) => {
216 0 : void handleUserResolved(user)
217 : })
218 : )
219 : }
220 :
221 82791 : if (extension.onAuthTokenRefreshed) {
222 0 : const { onTokenRefreshed } = useCurrentUser()
223 0 : const handleTokenRefreshed = wrapWithErrorHandlingAsync(
224 : () => extension.onAuthTokenRefreshed?.(),
225 : (error) => {
226 0 : console.error('[Extension Auth Hook Error]', {
227 : extension: extension.name,
228 : hook: 'onAuthTokenRefreshed',
229 : error
230 : })
231 0 : toastErrorHandler(error)
232 : }
233 : )
234 0 : authHookHandles.push(
235 : onTokenRefreshed(() => {
236 0 : void handleTokenRefreshed()
237 : })
238 : )
239 : }
240 :
241 82791 : if (extension.onAuthUserLogout) {
242 0 : const { onUserLogout } = useCurrentUser()
243 0 : const handleUserLogout = wrapWithErrorHandlingAsync(
244 : () => extension.onAuthUserLogout?.(),
245 : (error) => {
246 0 : console.error('[Extension Auth Hook Error]', {
247 : extension: extension.name,
248 : hook: 'onAuthUserLogout',
249 : error
250 : })
251 0 : toastErrorHandler(error)
252 : }
253 : )
254 0 : authHookHandles.push(
255 : onUserLogout(() => {
256 0 : void handleUserLogout()
257 : })
258 : )
259 : }
260 :
261 82789 : return once(() => {
262 0 : authHookHandles.forEach((stop) => stop())
263 0 : extensionStore.unregisterExtension(extension.name)
264 : })
265 : }
266 :
267 : type RemoveLastAppParam<T> = T extends (
268 : ...args: [...infer Rest, ComfyApp]
269 : ) => infer R
270 : ? (...args: Rest) => R
271 : : T
272 :
273 : type KnownExtensionMethods = Exclude<keyof ComfyExtension, number | symbol>
274 :
275 : type ComfyExtensionMethod<T extends KnownExtensionMethods> =
276 : ComfyExtension[T] extends (...args: unknown[]) => unknown
277 : ? ComfyExtension[T]
278 : : (...args: unknown[]) => unknown
279 :
280 : type ComfyExtensionParamsWithoutApp<T extends KnownExtensionMethods> =
281 : RemoveLastAppParam<ComfyExtensionMethod<T>>
282 : /**
283 : * Invoke an extension callback
284 : * @param {keyof ComfyExtension} method The extension callback to execute
285 : * @param {unknown[]} args Any arguments to pass to the callback
286 : * @returns
287 : */
288 2588804 : const invokeExtensions = <T extends KnownExtensionMethods>(
289 : method: T,
290 : ...args: Parameters<ComfyExtensionParamsWithoutApp<T>>
291 : ) => {
292 31061 : const results: ReturnType<ComfyExtensionMethod<T>>[] = []
293 31061 : for (const ext of extensionStore.enabledExtensions) {
294 1118473 : if (method in ext) {
295 4285 : try {
296 4285 : const fn = ext[method]
297 4285 : if (typeof fn === 'function') {
298 4285 : results.push(fn.call(ext, ...args, useApp()))
299 : }
300 : } catch (error) {
301 0 : console.error(
302 : `Error calling extension '${ext.name}' method '${method}'`,
303 : { error },
304 : { extension: ext },
305 : { args }
306 : )
307 : }
308 : }
309 : }
310 31061 : return results
311 : }
312 :
313 : /**
314 : * Invoke an async extension callback
315 : * Each callback will be invoked concurrently, in extension order. Only
316 : * extensions that define the callback do any work, and only promises that
317 : * callbacks actually return are awaited (callbacks that return
318 : * synchronously are never wrapped in a promise). The resolved array holds
319 : * the results of the callbacks that ran, so it is not index-aligned with
320 : * the extensions.
321 : * @param {string} method The extension callback to execute
322 : * @param {...unknown} args Any arguments to pass to the callback
323 : * @returns
324 : */
325 2588804 : const invokeExtensionsAsync = async <T extends KnownExtensionMethods>(
326 : method: T,
327 : ...args: Parameters<ComfyExtensionParamsWithoutApp<T>>
328 : ) => {
329 2488544 : const graphLoadDispatch = graphLoadLifecycleHooks.has(method)
330 : ? createGraphLoadHookDispatch(useApp())
331 : : undefined
332 2488544 : const app = graphLoadDispatch?.hookApp ?? useApp()
333 2488544 : const logError = (ext: ComfyExtension, error: unknown) =>
334 : console.error(
335 : `Error calling extension '${ext.name}' method '${method}'`,
336 : { error },
337 : { extension: ext },
338 : { args }
339 : )
340 :
341 : // This runs once per node def per extension, so avoid allocating promises
342 : // or closures for extensions that do not define the hook.
343 2488544 : const pending: unknown[] = []
344 2488544 : for (const ext of extensionStore.enabledExtensions) {
345 : // The property read is inside the try so a throwing getter or Proxy trap
346 : // only affects its own extension.
347 89523225 : try {
348 89523225 : const fn = ext[method]
349 89523225 : if (typeof fn !== 'function') continue
350 :
351 89523225 : if (method === 'setup') {
352 : // Track the current extension for legacy compatibility
353 7066 : pending.push(
354 : (async () => {
355 7066 : legacyMenuCompat.setCurrentExtension(ext.name)
356 7066 : try {
357 7066 : return await sidebarTabStore.attributeRegistrationsTo(
358 : ext.name,
359 : () => fn.call(ext, ...args, createSetupHookApp(app, ext.name))
360 : )
361 : } finally {
362 7066 : legacyMenuCompat.setCurrentExtension(null)
363 : }
364 : })().catch((error) => logError(ext, error))
365 : )
366 7066 : continue
367 : }
368 :
369 29597792 : const result: unknown = fn.call(ext, ...args, app)
370 89523225 : pending.push(
371 : isPromiseLike(result)
372 : ? Promise.resolve(result).catch((error) => logError(ext, error))
373 : : result
374 : )
375 : } catch (error) {
376 0 : logError(ext, error)
377 : }
378 : }
379 2488544 : try {
380 2488544 : return await Promise.all(pending)
381 : } finally {
382 2488544 : graphLoadDispatch?.endDispatch()
383 : }
384 : }
385 :
386 : /** Runs one startup step on the given extensions only, in order; returns the ones that threw. */
387 2588804 : const invokeStartupHook = async <T extends StartupHook>(
388 : extensions: ComfyExtension[],
389 : method: T,
390 : ...args: Parameters<ComfyExtensionParamsWithoutApp<T>>
391 : ): Promise<StartupHookFailure[]> => {
392 0 : const failures: StartupHookFailure[] = []
393 0 : for (const extension of extensions) {
394 0 : if (!extensionStore.isExtensionEnabled(extension.name)) continue
395 0 : try {
396 0 : const fn: unknown = extension[method]
397 0 : if (typeof fn !== 'function') continue
398 0 : if (method === 'setup') {
399 0 : legacyMenuCompat.setCurrentExtension(extension.name)
400 0 : await sidebarTabStore.attributeRegistrationsTo(extension.name, () =>
401 : fn.call(
402 : extension,
403 : ...args,
404 : createSetupHookApp(useApp(), extension.name)
405 : )
406 : )
407 : } else {
408 0 : await fn.call(extension, ...args, useApp())
409 : }
410 : } catch (error) {
411 0 : failures.push({ extension, method, error })
412 : } finally {
413 0 : if (method === 'setup') legacyMenuCompat.setCurrentExtension(null)
414 : }
415 : }
416 0 : return failures
417 : }
418 :
419 2588804 : return {
420 : registerExtension,
421 : registerExtensionNow,
422 : invokeExtensions,
423 : invokeExtensionsAsync,
424 : invokeStartupHook
425 : }
426 : }
427 :
428 2356 : provideExtensionService(useExtensionService)
|