LCOV - code coverage report
Current view: top level - src/platform/extensions/services - extensionService.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 63.6 % 143 91
Test Date: 2026-11-17 04:17:53

            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)
        

Generated by: LCOV version 2.0-1