[refactor] Improve workflow domain organization (#5584)

* [refactor] move workflow domain to its own folder

* [refactor] Fix workflow platform architecture organization

- Move workflow rendering functionality to renderer/thumbnail domain
- Rename ui folder to management for better semantic clarity
- Update all import paths to reflect proper domain boundaries
- Fix test imports to use new structure

Architecture improvements:
- rendering → renderer/thumbnail (belongs with other rendering logic)
- ui → management (better name for state management and UI integration)

This ensures proper separation of concerns and domain boundaries.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* [fix] Resolve circular dependency between nodeDefStore and subgraphStore

* [fix] Update browser test imports to use new workflow platform paths

---------

Co-authored-by: Claude <noreply@anthropic.com>

src/platform/workflow/persistence/composables/useWorkflowAutoSave.ts

@@ -0,0 +1,95 @@
+import { computed, onUnmounted, watch } from 'vue'
+
+import { useWorkflowService } from '@/platform/workflow/core/services/workflowService'
+import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore'
+import { api } from '@/scripts/api'
+import { useSettingStore } from '@/stores/settingStore'
+
+export function useWorkflowAutoSave() {
+  const workflowStore = useWorkflowStore()
+  const settingStore = useSettingStore()
+  const workflowService = useWorkflowService()
+
+  // Use computed refs to cache autosave settings
+  const autoSaveSetting = computed(() =>
+    settingStore.get('Comfy.Workflow.AutoSave')
+  )
+  const autoSaveDelay = computed(() =>
+    settingStore.get('Comfy.Workflow.AutoSaveDelay')
+  )
+
+  let autoSaveTimeout: NodeJS.Timeout | null = null
+  let isSaving = false
+  let needsAutoSave = false
+
+  const scheduleAutoSave = () => {
+    // Clear any existing timeout
+    if (autoSaveTimeout) {
+      clearTimeout(autoSaveTimeout)
+      autoSaveTimeout = null
+    }
+
+    // If autosave is enabled
+    if (autoSaveSetting.value === 'after delay') {
+      // If a save is in progress, mark that we need an autosave after saving
+      if (isSaving) {
+        needsAutoSave = true
+        return
+      }
+      const delay = autoSaveDelay.value
+      autoSaveTimeout = setTimeout(async () => {
+        const activeWorkflow = workflowStore.activeWorkflow
+        if (activeWorkflow?.isModified && activeWorkflow.isPersisted) {
+          try {
+            isSaving = true
+            await workflowService.saveWorkflow(activeWorkflow)
+          } catch (err) {
+            console.error('Auto save failed:', err)
+          } finally {
+            isSaving = false
+            if (needsAutoSave) {
+              needsAutoSave = false
+              scheduleAutoSave()
+            }
+          }
+        }
+      }, delay)
+    }
+  }
+
+  // Watch for autosave setting changes
+  watch(
+    autoSaveSetting,
+    (newSetting) => {
+      // Clear any existing timeout when settings change
+      if (autoSaveTimeout) {
+        clearTimeout(autoSaveTimeout)
+        autoSaveTimeout = null
+      }
+
+      // If there's an active modified workflow and autosave is enabled, schedule a save
+      if (
+        newSetting === 'after delay' &&
+        workflowStore.activeWorkflow?.isModified
+      ) {
+        scheduleAutoSave()
+      }
+    },
+    { immediate: true }
+  )
+
+  // Listen for graph changes and schedule autosave when they occur
+  const onGraphChanged = () => {
+    scheduleAutoSave()
+  }
+
+  api.addEventListener('graphChanged', onGraphChanged)
+
+  onUnmounted(() => {
+    if (autoSaveTimeout) {
+      clearTimeout(autoSaveTimeout)
+      autoSaveTimeout = null
+    }
+    api.removeEventListener('graphChanged', onGraphChanged)
+  })
+}

src/platform/workflow/persistence/composables/useWorkflowPersistence.ts

@@ -0,0 +1,147 @@
+import { tryOnScopeDispose } from '@vueuse/core'
+import { computed, watch } from 'vue'
+
+import { useWorkflowService } from '@/platform/workflow/core/services/workflowService'
+import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore'
+import { api } from '@/scripts/api'
+import { app as comfyApp } from '@/scripts/app'
+import { getStorageValue, setStorageValue } from '@/scripts/utils'
+import { useCommandStore } from '@/stores/commandStore'
+import { useSettingStore } from '@/stores/settingStore'
+
+export function useWorkflowPersistence() {
+  const workflowStore = useWorkflowStore()
+  const settingStore = useSettingStore()
+
+  const workflowPersistenceEnabled = computed(() =>
+    settingStore.get('Comfy.Workflow.Persist')
+  )
+
+  const persistCurrentWorkflow = () => {
+    if (!workflowPersistenceEnabled.value) return
+    const workflow = JSON.stringify(comfyApp.graph.serialize())
+    localStorage.setItem('workflow', workflow)
+    if (api.clientId) {
+      sessionStorage.setItem(`workflow:${api.clientId}`, workflow)
+    }
+  }
+
+  const loadWorkflowFromStorage = async (
+    json: string | null,
+    workflowName: string | null
+  ) => {
+    if (!json) return false
+    const workflow = JSON.parse(json)
+    await comfyApp.loadGraphData(workflow, true, true, workflowName)
+    return true
+  }
+
+  const loadPreviousWorkflowFromStorage = async () => {
+    const workflowName = getStorageValue('Comfy.PreviousWorkflow')
+    const clientId = api.initialClientId ?? api.clientId
+
+    // Try loading from session storage first
+    if (clientId) {
+      const sessionWorkflow = sessionStorage.getItem(`workflow:${clientId}`)
+      if (await loadWorkflowFromStorage(sessionWorkflow, workflowName)) {
+        return true
+      }
+    }
+
+    // Fall back to local storage
+    const localWorkflow = localStorage.getItem('workflow')
+    return await loadWorkflowFromStorage(localWorkflow, workflowName)
+  }
+
+  const loadDefaultWorkflow = async () => {
+    if (!settingStore.get('Comfy.TutorialCompleted')) {
+      await settingStore.set('Comfy.TutorialCompleted', true)
+      await useWorkflowService().loadBlankWorkflow()
+      await useCommandStore().execute('Comfy.BrowseTemplates')
+    } else {
+      await comfyApp.loadGraphData()
+    }
+  }
+
+  const restorePreviousWorkflow = async () => {
+    if (!workflowPersistenceEnabled.value) return
+    try {
+      const restored = await loadPreviousWorkflowFromStorage()
+      if (!restored) {
+        await loadDefaultWorkflow()
+      }
+    } catch (err) {
+      console.error('Error loading previous workflow', err)
+      await loadDefaultWorkflow()
+    }
+  }
+
+  // Setup watchers
+  watch(
+    () => workflowStore.activeWorkflow?.key,
+    (activeWorkflowKey) => {
+      if (!activeWorkflowKey) return
+      setStorageValue('Comfy.PreviousWorkflow', activeWorkflowKey)
+      // When the activeWorkflow changes, the graph has already been loaded.
+      // Saving the current state of the graph to the localStorage.
+      persistCurrentWorkflow()
+    }
+  )
+  api.addEventListener('graphChanged', persistCurrentWorkflow)
+
+  // Clean up event listener when component unmounts
+  tryOnScopeDispose(() => {
+    api.removeEventListener('graphChanged', persistCurrentWorkflow)
+  })
+
+  // Restore workflow tabs states
+  const openWorkflows = computed(() => workflowStore.openWorkflows)
+  const activeWorkflow = computed(() => workflowStore.activeWorkflow)
+  const restoreState = computed<{ paths: string[]; activeIndex: number }>(
+    () => {
+      if (!openWorkflows.value || !activeWorkflow.value) {
+        return { paths: [], activeIndex: -1 }
+      }
+
+      const paths = openWorkflows.value
+        .filter((workflow) => workflow?.isPersisted && !workflow.isModified)
+        .map((workflow) => workflow.path)
+      const activeIndex = openWorkflows.value.findIndex(
+        (workflow) => workflow.path === activeWorkflow.value?.path
+      )
+
+      return { paths, activeIndex }
+    }
+  )
+
+  // Get storage values before setting watchers
+  const storedWorkflows = JSON.parse(
+    getStorageValue('Comfy.OpenWorkflowsPaths') || '[]'
+  )
+  const storedActiveIndex = JSON.parse(
+    getStorageValue('Comfy.ActiveWorkflowIndex') || '-1'
+  )
+
+  watch(restoreState, ({ paths, activeIndex }) => {
+    if (workflowPersistenceEnabled.value) {
+      setStorageValue('Comfy.OpenWorkflowsPaths', JSON.stringify(paths))
+      setStorageValue('Comfy.ActiveWorkflowIndex', JSON.stringify(activeIndex))
+    }
+  })
+
+  const restoreWorkflowTabsState = () => {
+    if (!workflowPersistenceEnabled.value) return
+    const isRestorable = storedWorkflows?.length > 0 && storedActiveIndex >= 0
+    if (isRestorable) {
+      workflowStore.openWorkflowsInBackground({
+        left: storedWorkflows.slice(0, storedActiveIndex),
+        right: storedWorkflows.slice(storedActiveIndex)
+      })
+    }
+  }
+
+  return {
+    restorePreviousWorkflow,
+    restoreWorkflowTabsState
+  }
+}