fix: Restore correct interfaces from PR #3367

- Restore original useManagerQueue, useServerLogs, and comfyManagerService interfaces
- Restore original component implementations for ManagerProgressDialogContent and ManagerProgressHeader
- Fix all TypeScript interface compatibility issues by using original PR implementations
- Remove duplicate setting that was causing runtime errors

This fixes merge errors where interfaces were incorrectly mixed between old and new implementations.

Author: christian-byrne

CLAUDE.md

@@ -54,6 +54,13 @@ Key Nx features:
 - Add "Fixes #n" to PR descriptions
 - Never mention Claude/AI in commits
 
+### Git Conflict Resolution
+
+**pnpm-lock.yaml and pnpm-workspace.yaml conflicts:**
+- Always use main's version: `git checkout --theirs pnpm-lock.yaml pnpm-workspace.yaml`
+- Manager migration work doesn't involve package.json changes
+- Avoids unnecessary merge conflicts in lock files
+
 ## External Resources
 
 - PrimeVue docs: <https://primevue.org>

MANAGER_MIGRATION_BACKUPS.md

@@ -18,6 +18,18 @@ This document tracks backup branches created during the manager migration recove
   - Updated type definitions and store interfaces
   - Resolved merge conflicts and formatting fixes
 
+### `manager-migration-clean-tested`
+- **Created**: 2025-08-30
+- **Source Branch**: `manager-migration-clean`
+- **Source Commit**: `380f335bf` - "feat: Integrate ComfyUI Manager migration with v2 API and enhanced UI"
+- **Purpose**: Backup before manual testing via dev server
+- **Contains**:
+  - Single squashed commit with complete manager migration
+  - All recovered functionality from PR #3367
+  - v2 API integration and enhanced UI components
+  - Resolved TypeScript issues and quality checks passed
+  - Clean, production-ready state ready for manual testing
+
 ### `manager-migration-upstream-backup` 
 - **Created**: Earlier in recovery process
 - **Purpose**: Backup of upstream state before major changes

pnpm-lock.yaml

@@ -18,7 +18,7 @@
         'max-h-0': !isExpanded
       }"
     >
-      <div v-for="(log, index) in focusedLogs" :key="index">
+      <div v-for="(panel, index) in taskPanels" :key="index">
         <Panel
           :expanded="collapsedPanels[index] || false"
           toggleable
@@ -27,7 +27,7 @@
           <template #header>
             <div class="flex items-center justify-between w-full py-2">
               <div class="flex flex-col text-sm font-medium leading-normal">
-                <span>{{ log.taskName }}</span>
+                <span>{{ panel.taskName }}</span>
                 <span class="text-muted">
                   {{
                     isInProgress(index)
@@ -52,24 +52,24 @@
           </template>
           <div
             :ref="
-              index === focusedLogs.length - 1
+              index === taskPanels.length - 1
                 ? (el) => (lastPanelRef = el as HTMLElement)
                 : undefined
             "
             class="overflow-y-auto h-64 rounded-lg bg-black"
             :class="{
-              'h-64': index !== focusedLogs.length - 1,
-              'flex-grow': index === focusedLogs.length - 1
+              'h-64': index !== taskPanels.length - 1,
+              'flex-grow': index === taskPanels.length - 1
             }"
             @scroll="handleScroll"
           >
             <div class="h-full">
               <div
-                v-for="(logLine, logIndex) in log.logs"
+                v-for="(log, logIndex) in panel.logs"
                 :key="logIndex"
                 class="text-neutral-400 dark-theme:text-muted"
               >
-                <pre class="whitespace-pre-wrap break-words">{{ logLine }}</pre>
+                <pre class="whitespace-pre-wrap break-words">{{ log }}</pre>
               </div>
             </div>
           </div>
@@ -90,23 +90,17 @@ import {
   useManagerProgressDialogStore
 } from '@/stores/comfyManagerStore'
 
-const comfyManagerStore = useComfyManagerStore()
+const { taskLogs } = useComfyManagerStore()
 const progressDialogContent = useManagerProgressDialogStore()
+const managerStore = useComfyManagerStore()
 
 const isInProgress = (index: number) =>
-  index === comfyManagerStore.managerQueue.historyCount - 1 &&
-  comfyManagerStore.isLoading
+  index === taskPanels.value.length - 1 && managerStore.uncompletedCount > 0
 
+const taskPanels = computed(() => taskLogs)
 const isExpanded = computed(() => progressDialogContent.isExpanded)
 const isCollapsed = computed(() => !isExpanded.value)
 
-const focusedLogs = computed(() => {
-  if (progressDialogContent.getActiveTabIndex() === 0) {
-    return comfyManagerStore.succeededTasksLogs
-  }
-  return comfyManagerStore.failedTasksLogs
-})
-
 const collapsedPanels = ref<Record<number, boolean>>({})
 const togglePanel = (index: number) => {
   collapsedPanels.value[index] = !collapsedPanels.value[index]
@@ -121,7 +115,7 @@ const { y: scrollY } = useScroll(sectionsContainerRef, {
 
 const lastPanelRef = ref<HTMLElement | null>(null)
 const isUserScrolling = ref(false)
-const lastPanelLogs = computed(() => focusedLogs.value?.at(-1)?.logs)
+const lastPanelLogs = computed(() => taskPanels.value?.at(-1)?.logs)
 
 const isAtBottom = (el: HTMLElement | null) => {
   if (!el) return false

src/components/dialog/content/ManagerProgressDialogContent.vue

@@ -18,40 +18,16 @@
 
 <script setup lang="ts">
 import TabMenu from 'primevue/tabmenu'
-import { computed } from 'vue'
+import { ref } from 'vue'
 import { useI18n } from 'vue-i18n'
 
-import {
-  useComfyManagerStore,
-  useManagerProgressDialogStore
-} from '@/stores/comfyManagerStore'
+import { useManagerProgressDialogStore } from '@/stores/comfyManagerStore'
 
 const progressDialogContent = useManagerProgressDialogStore()
-const comfyManagerStore = useComfyManagerStore()
-const activeTabIndex = computed({
-  get: () => progressDialogContent.getActiveTabIndex(),
-  set: (value: number) => progressDialogContent.setActiveTabIndex(value)
-})
+const activeTabIndex = ref(0)
 const { t } = useI18n()
-
-const failedCount = computed(() => comfyManagerStore.failedTasksIds.length)
-
-const queueSuffix = computed(() => {
-  const queueLength = comfyManagerStore.managerQueue.queueLength
-  if (queueLength === 0) {
-    return ''
-  }
-  return ` (${queueLength})`
-})
-const failedSuffix = computed(() => {
-  if (failedCount.value === 0) {
-    return ''
-  }
-  return ` (${failedCount.value})`
-})
-
-const tabs = computed(() => [
-  { label: t('manager.installationQueue') + queueSuffix.value },
-  { label: t('manager.failed') + failedSuffix.value }
-])
+const tabs = [
+  { label: t('manager.installationQueue') },
+  { label: t('manager.failed', { count: 0 }) }
+]
 </script>

src/components/dialog/header/ManagerProgressHeader.vue

@@ -1,34 +1,24 @@
 import { useEventListener } from '@vueuse/core'
-import { ref } from 'vue'
+import { onUnmounted, ref } from 'vue'
 
 import { LogsWsMessage } from '@/schemas/apiSchema'
 import { api } from '@/scripts/api'
-import { components } from '@/types/generatedManagerTypes'
 
 const LOGS_MESSAGE_TYPE = 'logs'
-const MANAGER_WS_TASK_DONE_NAME = 'cm-task-completed'
-const MANAGER_WS_TASK_STARTED_NAME = 'cm-task-started'
-
-type ManagerWsTaskDoneMsg = components['schemas']['MessageTaskDone']
-type ManagerWsTaskStartedMsg = components['schemas']['MessageTaskStarted']
 
 interface UseServerLogsOptions {
-  ui_id: string
   immediate?: boolean
   messageFilter?: (message: string) => boolean
 }
 
-export const useServerLogs = (options: UseServerLogsOptions) => {
+export const useServerLogs = (options: UseServerLogsOptions = {}) => {
   const {
     immediate = false,
     messageFilter = (msg: string) => Boolean(msg.trim())
   } = options
 
   const logs = ref<string[]>([])
-  const isTaskStarted = ref(false)
-  let stopLogs: ReturnType<typeof useEventListener> | null = null
-  let stopTaskDone: ReturnType<typeof useEventListener> | null = null
-  let stopTaskStarted: ReturnType<typeof useEventListener> | null = null
+  let stop: ReturnType<typeof useEventListener> | null = null
 
   const isValidLogEvent = (event: CustomEvent<LogsWsMessage>) =>
     event?.type === LOGS_MESSAGE_TYPE && event.detail?.entries?.length > 0
@@ -37,81 +27,34 @@ export const useServerLogs = (options: UseServerLogsOptions) => {
     event.detail.entries.map((e) => e.m).filter(messageFilter)
 
   const handleLogMessage = (event: CustomEvent<LogsWsMessage>) => {
-    // Only capture logs if this task has started
-    if (!isTaskStarted.value) return
-
     if (isValidLogEvent(event)) {
-      const messages = parseLogMessage(event)
-      if (messages.length > 0) {
-        logs.value.push(...messages)
-      }
-    }
-  }
-
-  const handleTaskStarted = (event: CustomEvent<ManagerWsTaskStartedMsg>) => {
-    if (event?.type === MANAGER_WS_TASK_STARTED_NAME) {
-      // Check if this is our task starting
-      const isOurTask = event.detail.ui_id === options.ui_id
-      if (isOurTask) {
-        isTaskStarted.value = true
-        void stopTaskStarted?.()
-      }
+      logs.value.push(...parseLogMessage(event))
     }
   }
 
-  const handleTaskDone = (event: CustomEvent<ManagerWsTaskDoneMsg>) => {
-    if (event?.type === MANAGER_WS_TASK_DONE_NAME) {
-      const { state } = event.detail
-      // Check if our task is now in the history (completed)
-      const isOurTaskDone = state.history[options.ui_id]
-      if (isOurTaskDone) {
-        isTaskStarted.value = false
-        void stopListening()
-      }
-    }
-  }
-
-  const startListening = async () => {
+  const start = async () => {
     await api.subscribeLogs(true)
-    stopLogs = useEventListener(api, LOGS_MESSAGE_TYPE, handleLogMessage)
-    stopTaskStarted = useEventListener(
-      api,
-      MANAGER_WS_TASK_STARTED_NAME,
-      handleTaskStarted
-    )
-    stopTaskDone = useEventListener(
-      api,
-      MANAGER_WS_TASK_DONE_NAME,
-      handleTaskDone
-    )
+    stop = useEventListener(api, LOGS_MESSAGE_TYPE, handleLogMessage)
   }
 
   const stopListening = async () => {
-    stopLogs?.()
-    stopTaskStarted?.()
-    stopTaskDone?.()
-    stopLogs = null
-    stopTaskStarted = null
-    stopTaskDone = null
-    // TODO: move subscribe/unsubscribe logs to useManagerQueue. Subscribe when task starts if not already subscribed.
-    // Unsubscribe ONLY when there are no tasks running or queued up and the only remaining task finishes.
-    // await api.subscribeLogs(false)
+    stop?.()
+    stop = null
+    await api.subscribeLogs(false)
   }
 
   if (immediate) {
-    void startListening()
+    void start()
   }
 
-  const cleanup = async () => {
+  onUnmounted(async () => {
     await stopListening()
     logs.value = []
-    isTaskStarted.value = false
-  }
+  })
 
   return {
     logs,
-    startListening,
-    stopListening,
-    cleanup
+    startListening: start,
+    stopListening
   }
 }

src/composables/useServerLogs.ts

@@ -935,12 +935,5 @@ export const CORE_SETTINGS: SettingParams[] = [
     name: 'Release seen timestamp',
     type: 'hidden',
     defaultValue: 0
-  },
-  {
-    id: 'Comfy.Memory.AllowManualUnload',
-    name: 'Allow manual unload of models and execution cache via user command',
-    type: 'hidden',
-    defaultValue: true,
-    versionAdded: '1.18.0'
   }
 ]