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