LCOV - code coverage report
Current view: top level - src/platform/updates/common - versionCompatibilityStore.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 88.1 % 67 59
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { until, useStorage } from '@vueuse/core'
       2              : import { defineStore } from 'pinia'
       3              : import { coerce, gt } from 'semver'
       4              : import { computed } from 'vue'
       5              : 
       6              : import config from '@/config'
       7              : import { useSettingStore } from '@/platform/settings/settingStore'
       8              : import { useSystemStatsStore } from '@/stores/systemStatsStore'
       9              : 
      10              : interface OutdatedComfyPackage {
      11              :   name: string
      12              :   installed: string
      13              :   required: string
      14              : }
      15              : 
      16         2355 : const DISMISSAL_DURATION_MS = 7 * 24 * 60 * 60 * 1000 // 7 days
      17              : 
      18              : // Already covered by the dedicated frontend warning, which uses the
      19              : // running bundle's version rather than the installed pip version.
      20         2355 : const FRONTEND_PACKAGE_NAME = 'comfyui-frontend-package'
      21              : 
      22              : // Backend reports PEP 440 versions (e.g. "0.3.0.post1", "1.0.0rc1");
      23              : // coerce strips the suffix so we can compare with semver. Note: this means
      24              : // "0.4.0" vs "0.4.0.post1" both coerce to "0.4.0" and compare equal — a
      25              : // post-release alone is not treated as outdated.
      26        11673 : function isOutdated(installed: string, required: string): boolean {
      27        11673 :   const installedSemver = coerce(installed)
      28        11673 :   const requiredSemver = coerce(required)
      29        11673 :   if (!installedSemver || !requiredSemver) return false
      30        11673 :   return gt(requiredSemver, installedSemver)
      31              : }
      32              : 
      33         2355 : export const useVersionCompatibilityStore = defineStore(
      34              :   'versionCompatibility',
      35              :   () => {
      36         2355 :     const systemStatsStore = useSystemStatsStore()
      37         2355 :     const settingStore = useSettingStore()
      38              : 
      39         2355 :     const frontendVersion = computed(() => config.app_version)
      40         2355 :     const backendVersion = computed(
      41              :       () => systemStatsStore.systemStats?.system.comfyui_version ?? ''
      42              :     )
      43         2355 :     const requiredFrontendVersion = computed(
      44              :       () => systemStatsStore.systemStats?.system.required_frontend_version ?? ''
      45              :     )
      46              : 
      47         2355 :     const isFrontendOutdated = computed(() => {
      48         2355 :       if (!frontendVersion.value || !requiredFrontendVersion.value) return false
      49         2337 :       return isOutdated(frontendVersion.value, requiredFrontendVersion.value)
      50              :     })
      51              : 
      52         2355 :     const isFrontendNewer = computed(() => {
      53              :       // We don't warn about frontend being newer than backend
      54              :       // Only warn when frontend is outdated (behind required version)
      55            0 :       return false
      56              :     })
      57              : 
      58         2355 :     const outdatedComfyPackages = computed<OutdatedComfyPackage[]>(() => {
      59         2355 :       const packages =
      60              :         systemStatsStore.systemStats?.system.comfy_package_versions ?? []
      61         2355 :       const out: OutdatedComfyPackage[] = []
      62         2355 :       for (const pkg of packages) {
      63        11670 :         if (pkg.name === FRONTEND_PACKAGE_NAME) continue
      64        11670 :         if (!pkg.installed || !pkg.required) continue
      65         9336 :         if (!isOutdated(pkg.installed, pkg.required)) continue
      66            0 :         out.push({
      67              :           name: pkg.name,
      68              :           installed: pkg.installed,
      69              :           required: pkg.required
      70              :         })
      71              :       }
      72         2355 :       return out
      73              :     })
      74              : 
      75         2355 :     const hasVersionMismatch = computed(() => {
      76         2355 :       return isFrontendOutdated.value || outdatedComfyPackages.value.length > 0
      77              :     })
      78              : 
      79         2355 :     const versionKey = computed(() => {
      80            2 :       if (!frontendVersion.value) return null
      81            2 :       if (
      82              :         !backendVersion.value &&
      83              :         !requiredFrontendVersion.value &&
      84              :         outdatedComfyPackages.value.length === 0
      85              :       ) {
      86            0 :         return null
      87              :       }
      88            2 :       const baseKey = `${frontendVersion.value}-${backendVersion.value}-${requiredFrontendVersion.value}`
      89            2 :       if (outdatedComfyPackages.value.length === 0) return baseKey
      90              :       const packageKey = [...outdatedComfyPackages.value]
      91              :         .sort(
      92              :           (a, b) =>
      93              :             a.name.localeCompare(b.name) ||
      94              :             a.installed.localeCompare(b.installed) ||
      95              :             a.required.localeCompare(b.required)
      96              :         )
      97              :         .map((pkg) => `${pkg.name}@${pkg.installed}->${pkg.required}`)
      98              :         .join(',')
      99            0 :       return `${baseKey}-${packageKey}`
     100              :     })
     101              : 
     102              :     // Use reactive storage for dismissals - creates a reactive ref that syncs with localStorage
     103              :     // All version mismatch dismissals are stored in a single object for clean localStorage organization
     104         2355 :     const dismissalStorage = useStorage(
     105              :       'comfy.versionMismatch.dismissals',
     106              :       {} as Record<string, number>,
     107              :       localStorage,
     108              :       {
     109              :         serializer: {
     110              :           read: (value: string) => {
     111           98 :             try {
     112           98 :               return JSON.parse(value)
     113              :             } catch {
     114            0 :               return {}
     115              :             }
     116              :           },
     117              :           write: (value: Record<string, number>) => JSON.stringify(value)
     118              :         }
     119              :       }
     120              :     )
     121              : 
     122         2355 :     const isDismissed = computed(() => {
     123            3 :       if (!versionKey.value) return false
     124              : 
     125            3 :       const dismissedUntil = dismissalStorage.value[versionKey.value]
     126            3 :       if (!dismissedUntil) return false
     127              : 
     128              :       // Check if dismissal has expired
     129            2 :       return Date.now() < dismissedUntil
     130              :     })
     131              : 
     132         2355 :     const warningsDisabled = computed(() =>
     133              :       settingStore.get('Comfy.VersionCompatibility.DisableWarnings')
     134              :     )
     135              : 
     136         2355 :     const shouldShowWarning = computed(() => {
     137         2356 :       return (
     138              :         hasVersionMismatch.value &&
     139              :         !isDismissed.value &&
     140              :         !warningsDisabled.value
     141              :       )
     142              :     })
     143              : 
     144         2355 :     const warningMessage = computed(() => {
     145            1 :       if (isFrontendOutdated.value) {
     146            1 :         return {
     147              :           type: 'outdated' as const,
     148              :           frontendVersion: frontendVersion.value,
     149              :           requiredVersion: requiredFrontendVersion.value
     150              :         }
     151              :       }
     152            0 :       return null
     153              :     })
     154              : 
     155         2355 :     const packageWarningMessages = computed(() =>
     156              :       outdatedComfyPackages.value.map((pkg) => ({
     157              :         name: pkg.name,
     158              :         installedVersion: pkg.installed,
     159              :         requiredVersion: pkg.required
     160              :       }))
     161              :     )
     162              : 
     163         2355 :     async function checkVersionCompatibility() {
     164         2355 :       if (!systemStatsStore.systemStats) {
     165            0 :         await until(systemStatsStore.isInitialized)
     166              :       }
     167              :     }
     168              : 
     169            1 :     function dismissWarning() {
     170            1 :       if (!versionKey.value) return
     171              : 
     172            1 :       const now = Date.now()
     173            1 :       const pruned: Record<string, number> = {}
     174            1 :       for (const [key, until] of Object.entries(dismissalStorage.value)) {
     175            0 :         if (until > now) pruned[key] = until
     176              :       }
     177            1 :       pruned[versionKey.value] = now + DISMISSAL_DURATION_MS
     178            1 :       dismissalStorage.value = pruned
     179              :     }
     180              : 
     181         2355 :     async function initialize() {
     182         2355 :       await checkVersionCompatibility()
     183              :     }
     184              : 
     185         2355 :     return {
     186              :       frontendVersion,
     187              :       backendVersion,
     188              :       requiredFrontendVersion,
     189              :       hasVersionMismatch,
     190              :       shouldShowWarning,
     191              :       warningMessage,
     192              :       packageWarningMessages,
     193              :       outdatedComfyPackages,
     194              :       isFrontendOutdated,
     195              :       isFrontendNewer,
     196              :       checkVersionCompatibility,
     197              :       dismissWarning,
     198              :       initialize
     199              :     }
     200              :   }
     201              : )
        

Generated by: LCOV version 2.0-1