refactor: Add helper functions to managerStateStore for better code r…

…euse

- Add isManagerEnabled(), isNewManagerUI(), isLegacyManagerUI() helpers
- Add shouldShowInstallButton(), shouldShowManagerButtons() for UI logic
- Update components to use helper functions where applicable
- Add comprehensive tests for new helper functions
- Centralize state checking logic to reduce duplication

src/components/dialog/content/LoadWorkflowWarning.vue

@@ -115,12 +115,12 @@ const managerStateStore = useManagerStateStore()
 
 // Show manager buttons unless manager is disabled
 const showManagerButtons = computed(() => {
-  return managerStateStore.getManagerUIState() !== ManagerUIState.DISABLED
+  return managerStateStore.shouldShowManagerButtons()
 })
 
 // Only show Install All button for NEW_UI (new manager with v4 support)
 const showInstallAllButton = computed(() => {
-  return managerStateStore.getManagerUIState() === ManagerUIState.NEW_UI
+  return managerStateStore.shouldShowInstallButton()
 })
 
 const openManager = async () => {

src/services/comfyManagerService.ts

@@ -3,10 +3,7 @@ import { v4 as uuidv4 } from 'uuid'
 import { ref } from 'vue'
 
 import { api } from '@/scripts/api'
-import {
-  ManagerUIState,
-  useManagerStateStore
-} from '@/stores/managerStateStore'
+import { useManagerStateStore } from '@/stores/managerStateStore'
 import { components } from '@/types/generatedManagerTypes'
 import { isAbortError } from '@/utils/typeGuardUtil'
 
@@ -58,7 +55,7 @@ export const useComfyManagerService = () => {
   // Check if manager service should be available
   const isManagerServiceAvailable = () => {
     const managerStore = useManagerStateStore()
-    return managerStore.getManagerUIState() === ManagerUIState.NEW_UI
+    return managerStore.isNewManagerUI()
   }
 
   const handleRequestError = (

src/stores/managerStateStore.ts

@@ -61,7 +61,49 @@ export const useManagerStateStore = defineStore('managerState', () => {
     return ManagerUIState.DISABLED
   }
 
+  /**
+   * Helper function to check if manager is enabled (not DISABLED)
+   */
+  const isManagerEnabled = (): boolean => {
+    return getManagerUIState() !== ManagerUIState.DISABLED
+  }
+
+  /**
+   * Helper function to check if manager UI is in NEW_UI mode
+   */
+  const isNewManagerUI = (): boolean => {
+    return getManagerUIState() === ManagerUIState.NEW_UI
+  }
+
+  /**
+   * Helper function to check if manager UI is in LEGACY_UI mode
+   */
+  const isLegacyManagerUI = (): boolean => {
+    return getManagerUIState() === ManagerUIState.LEGACY_UI
+  }
+
+  /**
+   * Helper function to check if install button should be shown
+   * (only in NEW_UI mode)
+   */
+  const shouldShowInstallButton = (): boolean => {
+    return isNewManagerUI()
+  }
+
+  /**
+   * Helper function to check if manager buttons should be shown
+   * (when manager is not disabled)
+   */
+  const shouldShowManagerButtons = (): boolean => {
+    return isManagerEnabled()
+  }
+
   return {
-    getManagerUIState
+    getManagerUIState,
+    isManagerEnabled,
+    isNewManagerUI,
+    isLegacyManagerUI,
+    shouldShowInstallButton,
+    shouldShowManagerButtons
   }
 })

tests-ui/tests/stores/managerStateStore.test.ts

@@ -191,4 +191,100 @@ describe('useManagerStateStore', () => {
       expect(store.getManagerUIState()).toBe(ManagerUIState.NEW_UI)
     })
   })
+
+  describe('helper functions', () => {
+    it('isManagerEnabled should return true when state is not DISABLED', () => {
+      vi.mocked(useSystemStatsStore).mockReturnValue({
+        systemStats: { system: { argv: ['python', 'main.py'] } }
+      } as any)
+      vi.mocked(api.getClientFeatureFlags).mockReturnValue({
+        supports_manager_v4_ui: true
+      })
+      vi.mocked(api.getServerFeature).mockReturnValue(true)
+      vi.mocked(useExtensionStore).mockReturnValue({
+        extensions: []
+      } as any)
+
+      const store = useManagerStateStore()
+      expect(store.isManagerEnabled()).toBe(true)
+    })
+
+    it('isManagerEnabled should return false when state is DISABLED', () => {
+      vi.mocked(useSystemStatsStore).mockReturnValue({
+        systemStats: {
+          system: { argv: ['python', 'main.py', '--disable-manager'] }
+        }
+      } as any)
+      vi.mocked(api.getClientFeatureFlags).mockReturnValue({})
+      vi.mocked(useExtensionStore).mockReturnValue({
+        extensions: []
+      } as any)
+
+      const store = useManagerStateStore()
+      expect(store.isManagerEnabled()).toBe(false)
+    })
+
+    it('isNewManagerUI should return true when state is NEW_UI', () => {
+      vi.mocked(useSystemStatsStore).mockReturnValue({
+        systemStats: { system: { argv: ['python', 'main.py'] } }
+      } as any)
+      vi.mocked(api.getClientFeatureFlags).mockReturnValue({
+        supports_manager_v4_ui: true
+      })
+      vi.mocked(api.getServerFeature).mockReturnValue(true)
+      vi.mocked(useExtensionStore).mockReturnValue({
+        extensions: []
+      } as any)
+
+      const store = useManagerStateStore()
+      expect(store.isNewManagerUI()).toBe(true)
+    })
+
+    it('isLegacyManagerUI should return true when state is LEGACY_UI', () => {
+      vi.mocked(useSystemStatsStore).mockReturnValue({
+        systemStats: {
+          system: { argv: ['python', 'main.py', '--enable-manager-legacy-ui'] }
+        }
+      } as any)
+      vi.mocked(api.getClientFeatureFlags).mockReturnValue({})
+      vi.mocked(useExtensionStore).mockReturnValue({
+        extensions: []
+      } as any)
+
+      const store = useManagerStateStore()
+      expect(store.isLegacyManagerUI()).toBe(true)
+    })
+
+    it('shouldShowInstallButton should return true only for NEW_UI', () => {
+      vi.mocked(useSystemStatsStore).mockReturnValue({
+        systemStats: { system: { argv: ['python', 'main.py'] } }
+      } as any)
+      vi.mocked(api.getClientFeatureFlags).mockReturnValue({
+        supports_manager_v4_ui: true
+      })
+      vi.mocked(api.getServerFeature).mockReturnValue(true)
+      vi.mocked(useExtensionStore).mockReturnValue({
+        extensions: []
+      } as any)
+
+      const store = useManagerStateStore()
+      expect(store.shouldShowInstallButton()).toBe(true)
+    })
+
+    it('shouldShowManagerButtons should return true when not DISABLED', () => {
+      vi.mocked(useSystemStatsStore).mockReturnValue({
+        systemStats: { system: { argv: ['python', 'main.py'] } }
+      } as any)
+      vi.mocked(api.getClientFeatureFlags).mockReturnValue({
+        supports_manager_v4_ui: true
+      })
+      vi.mocked(api.getServerFeature).mockReturnValue(true)
+      vi.mocked(useExtensionStore).mockReturnValue({
+        extensions: []
+      } as any)
+
+      const store = useManagerStateStore()
+      expect(store.shouldShowManagerButtons()).toBe(true)
+    })
+  })
 })