LCOV - code coverage report
Current view: top level - src/platform/customNodes/manager/services - comfyManagerService.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 60.8 % 79 48
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import type { AxiosError, AxiosResponse } from 'axios'
       2              : import axios from 'axios'
       3              : import { v4 as uuidv4 } from 'uuid'
       4              : import { ref } from 'vue'
       5              : 
       6              : import { api } from '@/scripts/api'
       7              : import { isAbortError } from '@/utils/typeGuardUtil'
       8              : import { useManagerState } from '@/platform/customNodes/manager/composables/useManagerState'
       9              : import type { components } from '@comfyorg/api-client/generatedManagerTypes'
      10              : 
      11              : type ManagerQueueStatus = components['schemas']['QueueStatus']
      12              : type InstallPackParams = components['schemas']['InstallPackParams']
      13              : type InstalledPacksResponse = components['schemas']['InstalledPacksResponse']
      14              : type UpdateAllPacksParams = components['schemas']['UpdateAllPacksParams']
      15              : type UpdateComfyUIParams = components['schemas']['UpdateComfyUIParams']
      16              : type ManagerTaskHistory = components['schemas']['HistoryResponse']
      17              : type QueueTaskItem = components['schemas']['QueueTaskItem']
      18              : 
      19         2356 : const GENERIC_SECURITY_ERR_MSG =
      20              :   'Forbidden: A security error has occurred. Please check the terminal logs'
      21              : 
      22              : /**
      23              :  * API routes for ComfyUI Manager
      24              :  */
      25              : enum ManagerRoute {
      26              :   START_QUEUE = 'manager/queue/start',
      27              :   RESET_QUEUE = 'manager/queue/reset',
      28              :   QUEUE_STATUS = 'manager/queue/status',
      29              :   UPDATE_ALL = 'manager/queue/update_all',
      30              :   UPDATE_COMFYUI = 'manager/queue/update_comfyui',
      31              :   LIST_INSTALLED = 'customnode/installed',
      32              :   GET_NODES = 'customnode/getmappings',
      33              :   IMPORT_FAIL_INFO = 'customnode/import_fail_info',
      34              :   IMPORT_FAIL_INFO_BULK = 'customnode/import_fail_info_bulk',
      35              :   REBOOT = 'manager/reboot',
      36              :   IS_LEGACY_MANAGER_UI = 'manager/is_legacy_manager_ui',
      37              :   TASK_HISTORY = 'manager/queue/history',
      38              :   QUEUE_TASK = 'manager/queue/task'
      39              : }
      40              : 
      41         2356 : const managerApiClient = axios.create({
      42              :   headers: {
      43              :     'Content-Type': 'application/json'
      44              :   }
      45              : })
      46              : 
      47         2356 : managerApiClient.interceptors.request.use((config) => {
      48           33 :   config.baseURL = api.apiURL('/v2/')
      49           33 :   return config
      50              : })
      51              : 
      52              : /**
      53              :  * Service for interacting with the ComfyUI Manager API
      54              :  * Provides methods for managing packs, ComfyUI-Manager queue operations, and system functions
      55              :  * Note: This service should only be used when Manager state is NEW_UI
      56              :  */
      57         2356 : export const useComfyManagerService = () => {
      58         2370 :   const isLoading = ref(false)
      59         2370 :   const error = ref<string | null>(null)
      60              : 
      61              :   // Check if manager service should be available
      62         2370 :   const isManagerServiceAvailable = () => {
      63              :     const managerState = useManagerState()
      64         2388 :     return managerState.isNewManagerUI.value
      65              :   }
      66              : 
      67         2370 :   const handleRequestError = (
      68              :     err: unknown,
      69              :     context: string,
      70              :     routeSpecificErrors?: Record<number, string>
      71              :   ) => {
      72              :     // Don't treat cancellation as an error
      73            0 :     if (isAbortError(err)) return
      74              : 
      75            0 :     let message: string
      76            0 :     if (!axios.isAxiosError(err)) {
      77            0 :       message = `${context} failed: ${err instanceof Error ? err.message : String(err)}`
      78              :     } else {
      79            0 :       const axiosError = err as AxiosError<{ message: string }>
      80            0 :       const status = axiosError.response?.status
      81            0 :       if (status && routeSpecificErrors?.[status]) {
      82            0 :         message = routeSpecificErrors[status]
      83            0 :       } else if (status === 404) {
      84            0 :         message = 'Could not connect to ComfyUI-Manager'
      85              :       } else {
      86            0 :         message =
      87              :           axiosError.response?.data.message ??
      88              :           `${context} failed with status ${status}`
      89              :       }
      90              :     }
      91              : 
      92            0 :     error.value = message
      93              :   }
      94              : 
      95         2370 :   const executeRequest = async <T>(
      96              :     requestCall: () => Promise<AxiosResponse<T>>,
      97              :     options: {
      98              :       errorContext: string
      99              :       routeSpecificErrors?: Record<number, string>
     100              :     }
     101              :   ): Promise<T | null> => {
     102         2388 :     const { errorContext, routeSpecificErrors } = options
     103              : 
     104              :     // Block service calls if not in NEW_UI state
     105         2388 :     if (!isManagerServiceAvailable()) {
     106         2355 :       error.value = 'Manager service is not available in current mode'
     107         2355 :       return null
     108              :     }
     109              : 
     110           33 :     isLoading.value = true
     111           33 :     error.value = null
     112              : 
     113           48 :     try {
     114              :       const response = await requestCall()
     115           33 :       return response.data
     116              :     } catch (err) {
     117            0 :       handleRequestError(err, errorContext, routeSpecificErrors)
     118            0 :       return null
     119              :     } finally {
     120           33 :       isLoading.value = false
     121              :     }
     122              :   }
     123              : 
     124         2370 :   const startQueue = async (signal?: AbortSignal) => {
     125              :     const errorContext = 'Starting ComfyUI-Manager job queue'
     126              :     const routeSpecificErrors = {
     127              :       403: GENERIC_SECURITY_ERR_MSG
     128              :     }
     129              : 
     130            1 :     return executeRequest<string>(
     131              :       () => managerApiClient.post(ManagerRoute.START_QUEUE, null, { signal }),
     132              :       { errorContext, routeSpecificErrors }
     133              :     )
     134              :   }
     135              : 
     136         2370 :   const getQueueStatus = async (client_id?: string, signal?: AbortSignal) => {
     137              :     const errorContext = 'Getting ComfyUI-Manager queue status'
     138              : 
     139            1 :     return executeRequest<ManagerQueueStatus>(
     140              :       () =>
     141              :         managerApiClient.get(ManagerRoute.QUEUE_STATUS, {
     142              :           params: client_id ? { client_id } : undefined,
     143              :           signal
     144              :         }),
     145              :       { errorContext }
     146              :     )
     147              :   }
     148              : 
     149         2370 :   const listInstalledPacks = async (signal?: AbortSignal) => {
     150              :     const errorContext = 'Fetching installed packs'
     151              : 
     152         2370 :     return executeRequest<InstalledPacksResponse>(
     153              :       () => managerApiClient.get(ManagerRoute.LIST_INSTALLED, { signal }),
     154              :       { errorContext }
     155              :     )
     156              :   }
     157              : 
     158         2370 :   const getImportFailInfo = async (signal?: AbortSignal) => {
     159              :     const errorContext = 'Fetching import failure information'
     160              : 
     161            0 :     return executeRequest<Record<string, unknown>>(
     162              :       () => managerApiClient.get(ManagerRoute.IMPORT_FAIL_INFO, { signal }),
     163              :       { errorContext }
     164              :     )
     165              :   }
     166              : 
     167         2370 :   const getImportFailInfoBulk = async (
     168              :     params: components['schemas']['ImportFailInfoBulkRequest'] = {},
     169              :     signal?: AbortSignal
     170              :   ) => {
     171           15 :     const errorContext = 'Fetching bulk import failure information'
     172              : 
     173           15 :     if (!params.cnr_ids?.length && !params.urls?.length) {
     174            0 :       return {}
     175              :     }
     176              : 
     177           15 :     return executeRequest<components['schemas']['ImportFailInfoBulkResponse']>(
     178              :       () =>
     179              :         managerApiClient.post(ManagerRoute.IMPORT_FAIL_INFO_BULK, params, {
     180              :           signal
     181              :         }),
     182              :       { errorContext }
     183              :     )
     184              :   }
     185              : 
     186         2370 :   const queueTask = async (
     187              :     kind: QueueTaskItem['kind'],
     188              :     params: QueueTaskItem['params'],
     189              :     ui_id?: string,
     190              :     signal?: AbortSignal
     191              :   ) => {
     192            1 :     const task: QueueTaskItem = {
     193              :       kind,
     194              :       params,
     195              :       ui_id: ui_id || uuidv4(),
     196              :       client_id: api.clientId ?? api.initialClientId ?? 'unknown'
     197              :     }
     198              : 
     199            1 :     const errorContext = `Queueing ${task.kind} task`
     200              :     const routeSpecificErrors = {
     201              :       403: GENERIC_SECURITY_ERR_MSG,
     202              :       404: `Not Found: Task could not be queued`
     203              :     }
     204              : 
     205            1 :     return executeRequest<string>(
     206              :       () => managerApiClient.post(ManagerRoute.QUEUE_TASK, task, { signal }),
     207              :       { errorContext, routeSpecificErrors }
     208              :     )
     209              :   }
     210              : 
     211         2370 :   const installPack = async (
     212              :     params: InstallPackParams,
     213              :     ui_id?: string,
     214              :     signal?: AbortSignal
     215              :   ) => {
     216            1 :     return queueTask('install', params, ui_id, signal)
     217              :   }
     218              : 
     219         2370 :   const uninstallPack = async (
     220              :     params: components['schemas']['UninstallPackParams'],
     221              :     ui_id?: string,
     222              :     signal?: AbortSignal
     223              :   ) => {
     224            0 :     return queueTask('uninstall', params, ui_id, signal)
     225              :   }
     226              : 
     227         2370 :   const disablePack = async (
     228              :     params: components['schemas']['DisablePackParams'],
     229              :     ui_id?: string,
     230              :     signal?: AbortSignal
     231              :   ) => {
     232            0 :     return queueTask('disable', params, ui_id, signal)
     233              :   }
     234              : 
     235         2370 :   const enablePack = async (
     236              :     params: components['schemas']['EnablePackParams'],
     237              :     ui_id?: string,
     238              :     signal?: AbortSignal
     239              :   ) => {
     240            0 :     return queueTask('enable', params, ui_id, signal)
     241              :   }
     242              : 
     243         2370 :   const updatePack = async (
     244              :     params: components['schemas']['UpdatePackParams'],
     245              :     ui_id?: string,
     246              :     signal?: AbortSignal
     247              :   ) => {
     248            0 :     return queueTask('update', params, ui_id, signal)
     249              :   }
     250              : 
     251         2370 :   const updateAllPacks = async (
     252              :     params: UpdateAllPacksParams = {},
     253              :     ui_id?: string,
     254              :     signal?: AbortSignal
     255              :   ) => {
     256            0 :     const errorContext = 'Updating all packs'
     257            0 :     const routeSpecificErrors = {
     258              :       403: 'Forbidden: To use this action, a security_level of `middle or below` is required',
     259              :       401: 'Unauthorized: ComfyUI-Manager job queue is busy'
     260              :     }
     261              : 
     262            0 :     const queryParams = {
     263              :       mode: params.mode,
     264              :       client_id: api.clientId ?? api.initialClientId ?? 'unknown',
     265              :       ui_id: ui_id || uuidv4()
     266              :     }
     267              : 
     268            0 :     return executeRequest<string>(
     269              :       () =>
     270              :         managerApiClient.post(ManagerRoute.UPDATE_ALL, null, {
     271              :           params: queryParams,
     272              :           signal
     273              :         }),
     274              :       { errorContext, routeSpecificErrors }
     275              :     )
     276              :   }
     277              : 
     278         2370 :   const updateComfyUI = async (
     279              :     params: UpdateComfyUIParams = { is_stable: true },
     280              :     ui_id?: string,
     281              :     signal?: AbortSignal
     282              :   ) => {
     283            0 :     const errorContext = 'Updating ComfyUI'
     284            0 :     const routeSpecificErrors = {
     285              :       400: 'Bad Request: Missing required parameters',
     286              :       403: 'Forbidden: To use this action, a security_level of `middle or below` is required'
     287              :     }
     288              : 
     289            0 :     const queryParams = {
     290              :       client_id: api.clientId ?? api.initialClientId ?? 'unknown',
     291              :       ui_id: ui_id || uuidv4(),
     292              :       ...params
     293              :     }
     294              : 
     295            0 :     return executeRequest<string>(
     296              :       () =>
     297              :         managerApiClient.post(ManagerRoute.UPDATE_COMFYUI, null, {
     298              :           params: queryParams,
     299              :           signal
     300              :         }),
     301              :       { errorContext, routeSpecificErrors }
     302              :     )
     303              :   }
     304              : 
     305         2370 :   const rebootComfyUI = async (signal?: AbortSignal) => {
     306              :     const errorContext = 'Rebooting ComfyUI'
     307              :     const routeSpecificErrors = {
     308              :       403: 'Forbidden: Rebooting ComfyUI requires security_level of middle or below'
     309              :     }
     310              : 
     311            0 :     return executeRequest<null>(
     312              :       () => managerApiClient.post(ManagerRoute.REBOOT, null, { signal }),
     313              :       { errorContext, routeSpecificErrors }
     314              :     )
     315              :   }
     316              : 
     317         2370 :   const isLegacyManagerUI = async (signal?: AbortSignal) => {
     318              :     const errorContext = 'Checking if user set Manager to use the legacy UI'
     319              : 
     320            0 :     return executeRequest<{ is_legacy_manager_ui: boolean }>(
     321              :       () => managerApiClient.get(ManagerRoute.IS_LEGACY_MANAGER_UI, { signal }),
     322              :       { errorContext }
     323              :     )
     324              :   }
     325              : 
     326         2370 :   const getTaskHistory = async (
     327              :     options: {
     328              :       ui_id?: string
     329              :       max_items?: number
     330              :       client_id?: string
     331              :       offset?: number
     332              :     } = {},
     333              :     signal?: AbortSignal
     334              :   ) => {
     335              :     const errorContext = 'Getting ComfyUI-Manager task history'
     336              : 
     337            0 :     return executeRequest<ManagerTaskHistory>(
     338              :       () =>
     339              :         managerApiClient.get(ManagerRoute.TASK_HISTORY, {
     340              :           params: options,
     341              :           signal
     342              :         }),
     343              :       { errorContext }
     344              :     )
     345              :   }
     346              : 
     347         2370 :   return {
     348              :     // State
     349              :     isLoading,
     350              :     error,
     351              : 
     352              :     // Queue operations
     353              :     startQueue,
     354              :     getQueueStatus,
     355              :     getTaskHistory,
     356              : 
     357              :     // Pack management
     358              :     listInstalledPacks,
     359              :     getImportFailInfo,
     360              :     getImportFailInfoBulk,
     361              :     installPack,
     362              :     uninstallPack,
     363              :     enablePack,
     364              :     disablePack,
     365              :     updatePack,
     366              :     updateAllPacks,
     367              : 
     368              :     // System operations
     369              :     updateComfyUI,
     370              :     rebootComfyUI,
     371              :     isLegacyManagerUI
     372              :   }
     373              : }
        

Generated by: LCOV version 2.0-1