LCOV - code coverage report
Current view: top level - src/platform/workspace/stores - deploymentLibraryModelsStore.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 3.7 % 81 3
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { defineStore } from 'pinia'
       2              : import { effectScope, onScopeDispose, shallowReactive, watch } from 'vue'
       3              : 
       4              : import { useFeatureFlags } from '@/composables/useFeatureFlags'
       5              : import type { ComboWidgetInventoryStatus } from '@/core/graph/widgets/comboWidgetInventory'
       6              : import { assetService } from '@/platform/assets/services/assetService'
       7              : import { reportError } from '@comfyorg/telemetry/reportError'
       8              : import { pendingServerFact } from '@/platform/serverFacts/pendingServerFact'
       9              : import { useDeploymentPickStore } from '@/platform/workspace/stores/deploymentPickStore'
      10              : import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore'
      11              : import { useAssetDownloadStore } from '@/stores/assetDownloadStore'
      12              : import { useModelToNodeStore } from '@/stores/modelToNodeStore'
      13              : 
      14              : interface LibraryFolder {
      15              :   names: readonly string[]
      16              :   status: ComboWidgetInventoryStatus
      17              : }
      18              : 
      19         2356 : const NO_NAMES: readonly string[] = []
      20              : 
      21         2356 : const WORKER_MODEL_FOLDERS = new Set([
      22              :   'checkpoints',
      23              :   'loras',
      24              :   'vae',
      25              :   'vae_approx',
      26              :   'controlnet',
      27              :   't2i_adapter',
      28              :   'clip',
      29              :   'clip_vision',
      30              :   'text_encoders',
      31              :   'diffusion_models',
      32              :   'unet',
      33              :   'upscale_models',
      34              :   'latent_upscale_models',
      35              :   'embeddings',
      36              :   'hypernetworks',
      37              :   'style_models',
      38              :   'gligen',
      39              :   'photomaker',
      40              :   'model_patches',
      41              :   'audio_encoders',
      42              :   'background_removal',
      43              :   'frame_interpolation',
      44              :   'geometry_estimation',
      45              :   'optical_flow',
      46              :   'detection'
      47              : ])
      48              : 
      49            0 : export function deploymentDownloads(folder: string, name?: string): boolean {
      50            0 :   return pendingServerFact(
      51              :     'BE-24448',
      52              :     !!useDeploymentPickStore().bootDeployment &&
      53              :       WORKER_MODEL_FOLDERS.has(folder) &&
      54              :       (name === undefined ||
      55              :         (!name.startsWith('.') &&
      56              :           !/[/\\\0]/.test(name) &&
      57              :           !name.includes('..') &&
      58              :           name.toLowerCase().endsWith('.safetensors')))
      59              :   )
      60              : }
      61              : 
      62              : /** The workspace library's model names by folder, offered after the Release's in a deployment's loader dropdowns. */
      63         2356 : export const useDeploymentLibraryModelsStore = defineStore(
      64              :   'deploymentLibraryModels',
      65              :   () => {
      66            0 :     const { flags } = useFeatureFlags()
      67            0 :     const workspaceStore = useTeamWorkspaceStore()
      68            0 :     const downloads = useAssetDownloadStore()
      69            0 :     const folders = shallowReactive(new Map<string, LibraryFolder>())
      70            0 :     const watchedFolders = new Map<string, number>()
      71            0 :     const latestRequest = new Map<string, number>()
      72            0 :     const listeners = effectScope()
      73            0 :     let generation = 0
      74              : 
      75            0 :     function loadWatchedFolders() {
      76            0 :       for (const folder of watchedFolders.keys()) {
      77            0 :         if (!folders.has(folder)) refresh(folder)
      78              :       }
      79              :     }
      80              : 
      81            0 :     watch(
      82              :       () => workspaceStore.workspaceId,
      83              :       () => {
      84            0 :         generation++
      85            0 :         folders.clear()
      86            0 :         latestRequest.clear()
      87            0 :         loadWatchedFolders()
      88              :       },
      89              :       { flush: 'sync' }
      90              :     )
      91              : 
      92            0 :     watch(
      93              :       () => flags.runtimeLibraryModelsEnabled,
      94              :       (enabled) => {
      95            0 :         if (enabled) {
      96            0 :           loadWatchedFolders()
      97            0 :           return
      98              :         }
      99            0 :         generation++
     100            0 :         folders.clear()
     101            0 :         latestRequest.clear()
     102              :       },
     103              :       { flush: 'sync' }
     104              :     )
     105              : 
     106            0 :     watch(
     107              :       () => downloads.lastCompletedDownload,
     108              :       (completed) => {
     109            0 :         if (!completed || !folders.has(completed.modelType)) return
     110            0 :         refresh(completed.modelType)
     111              :       }
     112              :     )
     113              : 
     114            0 :     onScopeDispose(
     115              :       assetService.onAssetsChanged(() => {
     116            0 :         for (const folder of folders.keys()) refresh(folder)
     117              :       })
     118              :     )
     119              : 
     120            0 :     function folderFor(nodeType: string, widgetName: string) {
     121            0 :       if (!assetService.isAssetBrowserEligible(nodeType, widgetName)) {
     122            0 :         return undefined
     123              :       }
     124            0 :       const folder = useModelToNodeStore().getCategoryForNodeType(nodeType)
     125            0 :       return folder && deploymentDownloads(folder) ? folder : undefined
     126              :     }
     127              : 
     128            0 :     function refresh(folder: string) {
     129            0 :       if (!flags.runtimeLibraryModelsEnabled || !workspaceStore.workspaceId) {
     130            0 :         return
     131              :       }
     132            0 :       const startedIn = generation
     133            0 :       const request = (latestRequest.get(folder) ?? 0) + 1
     134            0 :       latestRequest.set(folder, request)
     135            0 :       const isCurrent = () =>
     136              :         startedIn === generation && latestRequest.get(folder) === request
     137            0 :       const previous = folders.get(folder)
     138            0 :       const entry: LibraryFolder = {
     139              :         names: previous?.names ?? NO_NAMES,
     140              :         status: previous?.status === 'ready' ? 'ready' : 'loading'
     141              :       }
     142            0 :       folders.set(folder, entry)
     143            0 :       void assetService.getWorkspaceLibraryModels(folder).then(
     144              :         (names) => {
     145            0 :           if (!isCurrent()) return
     146            0 :           folders.set(folder, {
     147              :             names: names.filter((name) => deploymentDownloads(folder, name)),
     148              :             status: 'ready'
     149              :           })
     150              :         },
     151              :         (err: unknown) => {
     152            0 :           if (!isCurrent()) return
     153            0 :           folders.set(folder, { ...entry, status: 'error' })
     154            0 :           reportError(err, {
     155              :             surface: 'workspace',
     156              :             errorType: 'error_loading_library_models',
     157              :             level: 'warning',
     158              :             tags: { folder }
     159              :           })
     160              :         }
     161              :       )
     162              :     }
     163              : 
     164            0 :     function loaded(folder: string): LibraryFolder | undefined {
     165            0 :       return flags.runtimeLibraryModelsEnabled ? folders.get(folder) : undefined
     166              :     }
     167              : 
     168            0 :     function namesIn(folder: string): readonly string[] {
     169            0 :       return loaded(folder)?.names ?? NO_NAMES
     170              :     }
     171              : 
     172            0 :     function statusOf(folder: string): ComboWidgetInventoryStatus {
     173            0 :       return loaded(folder)?.status ?? 'ready'
     174              :     }
     175              : 
     176              :     /**
     177              :      * Loads the folder and calls back each time its names change, until the returned stop is called.
     178              :      */
     179            0 :     function watchFolder(folder: string, onChange: () => void): () => void {
     180            0 :       watchedFolders.set(folder, (watchedFolders.get(folder) ?? 0) + 1)
     181            0 :       if (!folders.has(folder)) refresh(folder)
     182            0 :       const stopWatch = listeners.run(() =>
     183              :         watch(() => namesIn(folder), onChange)
     184              :       )
     185            0 :       let stopped = false
     186            0 :       return () => {
     187            0 :         if (stopped) return
     188            0 :         stopped = true
     189            0 :         stopWatch?.()
     190            0 :         const count = (watchedFolders.get(folder) ?? 1) - 1
     191            0 :         if (count > 0) watchedFolders.set(folder, count)
     192            0 :         else watchedFolders.delete(folder)
     193              :       }
     194              :     }
     195              : 
     196            0 :     function waitForSettled(folder: string): Promise<void> {
     197            0 :       if (statusOf(folder) !== 'loading') return Promise.resolve()
     198            0 :       return new Promise((resolve) => {
     199            0 :         const stop = listeners.run(() =>
     200              :           watch(
     201              :             () => [flags.runtimeLibraryModelsEnabled, folders.get(folder)],
     202              :             () => {
     203            0 :               if (statusOf(folder) === 'loading') return
     204            0 :               stop?.()
     205            0 :               resolve()
     206              :             }
     207              :           )
     208              :         )
     209            0 :         if (!stop) resolve()
     210              :       })
     211              :     }
     212              : 
     213            0 :     return {
     214              :       folderFor,
     215              :       watchFolder,
     216              :       namesIn,
     217              :       statusOf,
     218              :       waitForSettled,
     219              :       refresh
     220              :     }
     221              :   }
     222              : )
        

Generated by: LCOV version 2.0-1