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

            Line data    Source code
       1              : import { useEventListener } from '@vueuse/core'
       2              : import { onUnmounted, ref } from 'vue'
       3              : 
       4              : import type { LogsWsMessage } from '@comfyorg/api-client/executionTypes'
       5              : import { api } from '@/scripts/api'
       6              : import type { components } from '@comfyorg/api-client/generatedManagerTypes'
       7              : 
       8         2356 : const LOGS_MESSAGE_TYPE = 'logs'
       9         2356 : const MANAGER_WS_TASK_DONE_NAME = 'cm-task-completed'
      10         2356 : const MANAGER_WS_TASK_STARTED_NAME = 'cm-task-started'
      11              : 
      12              : type ManagerWsTaskDoneMsg = components['schemas']['MessageTaskDone']
      13              : type ManagerWsTaskStartedMsg = components['schemas']['MessageTaskStarted']
      14              : 
      15              : interface UseServerLogsOptions {
      16              :   ui_id?: string
      17              :   immediate?: boolean
      18              :   messageFilter?: (message: string) => boolean
      19              : }
      20              : 
      21         2356 : export const useServerLogs = (options: UseServerLogsOptions = {}) => {
      22            1 :   const {
      23              :     ui_id,
      24              :     immediate = false,
      25              :     messageFilter = (msg: string) => Boolean(msg.trim())
      26              :   } = options
      27              : 
      28            1 :   const logs = ref<string[]>([])
      29            1 :   const isTaskStarted = ref(!ui_id) // If no ui_id, capture all logs immediately
      30            1 :   let stopLogs: ReturnType<typeof useEventListener> | null = null
      31            1 :   let stopTaskDone: ReturnType<typeof useEventListener> | null = null
      32            1 :   let stopTaskStarted: ReturnType<typeof useEventListener> | null = null
      33              : 
      34            1 :   const isValidLogEvent = (event: CustomEvent<LogsWsMessage>) =>
      35              :     event.type === LOGS_MESSAGE_TYPE && event.detail.entries.length > 0
      36              : 
      37            1 :   const parseLogMessage = (event: CustomEvent<LogsWsMessage>) =>
      38              :     event.detail.entries.map((e) => e.m).filter(messageFilter)
      39              : 
      40            1 :   const handleLogMessage = (event: CustomEvent<LogsWsMessage>) => {
      41              :     // Only capture logs if this task has started
      42            0 :     if (!isTaskStarted.value) return
      43              : 
      44            0 :     if (isValidLogEvent(event)) {
      45            0 :       const messages = parseLogMessage(event)
      46            0 :       if (messages.length > 0) {
      47            0 :         logs.value.push(...messages)
      48              :       }
      49              :     }
      50              :   }
      51              : 
      52            1 :   const handleTaskStarted = (event: CustomEvent<ManagerWsTaskStartedMsg>) => {
      53            0 :     if (ui_id && event.detail.ui_id === ui_id) {
      54            0 :       isTaskStarted.value = true
      55              :     }
      56              :   }
      57              : 
      58            1 :   const handleTaskDone = (event: CustomEvent<ManagerWsTaskDoneMsg>) => {
      59            1 :     if (ui_id && event.detail.ui_id === ui_id) {
      60            1 :       isTaskStarted.value = false
      61              :     }
      62              :   }
      63              : 
      64            1 :   const start = async () => {
      65            1 :     await api.subscribeLogs(true)
      66            1 :     stopLogs = useEventListener(api, LOGS_MESSAGE_TYPE, handleLogMessage)
      67              : 
      68            1 :     if (ui_id) {
      69            1 :       stopTaskStarted = useEventListener(
      70              :         api,
      71              :         MANAGER_WS_TASK_STARTED_NAME,
      72              :         handleTaskStarted
      73              :       )
      74            1 :       stopTaskDone = useEventListener(
      75              :         api,
      76              :         MANAGER_WS_TASK_DONE_NAME,
      77              :         handleTaskDone
      78              :       )
      79              :     }
      80              :   }
      81              : 
      82            1 :   const stopListening = async () => {
      83            0 :     stopLogs?.()
      84            0 :     stopTaskStarted?.()
      85            0 :     stopTaskDone?.()
      86            0 :     stopLogs = null
      87            0 :     stopTaskStarted = null
      88            0 :     stopTaskDone = null
      89            0 :     await api.subscribeLogs(false)
      90              :   }
      91              : 
      92            1 :   if (immediate) {
      93            1 :     void start()
      94              :   }
      95              : 
      96            1 :   onUnmounted(async () => {
      97            0 :     await stopListening()
      98            0 :     logs.value = []
      99              :   })
     100              : 
     101            1 :   return {
     102              :     logs,
     103              :     startListening: start,
     104              :     stopListening
     105              :   }
     106              : }
        

Generated by: LCOV version 2.0-1