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

            Line data    Source code
       1              : import { until } from '@vueuse/core'
       2              : import { defineStore } from 'pinia'
       3              : import { compare, valid } from 'semver'
       4              : import { computed, ref } from 'vue'
       5              : 
       6              : import { isCloud, isDesktop } from '@/platform/distribution/types'
       7              : import { useOnboardingOverlayStore } from '@/platform/onboarding/onboardingOverlayStore'
       8              : import { useOnboardingTourStore } from '@/platform/onboarding/onboardingTourStore'
       9              : import { useSettingStore } from '@/platform/settings/settingStore'
      10              : import { useSystemStatsStore } from '@/stores/systemStatsStore'
      11              : import { stringToLocale } from '@/utils/formatUtil'
      12              : 
      13              : import { useReleaseService } from './releaseService'
      14              : import type { ReleaseNote } from './releaseService'
      15              : 
      16              : // Store for managing release notes
      17         2355 : export const useReleaseStore = defineStore('release', () => {
      18              :   // State
      19         2353 :   const releases = ref<ReleaseNote[]>([])
      20         2353 :   const isLoading = ref(false)
      21         2353 :   const error = ref<string | null>(null)
      22              : 
      23              :   // Services
      24         2353 :   const releaseService = useReleaseService()
      25         2353 :   const systemStatsStore = useSystemStatsStore()
      26         2353 :   const settingStore = useSettingStore()
      27         2353 :   const onboardingTourStore = useOnboardingTourStore()
      28         2353 :   const onboardingOverlayStore = useOnboardingOverlayStore()
      29              : 
      30         2353 :   const currentVersion = computed(
      31              :     () => systemStatsStore.systemStats?.system.comfyui_version ?? ''
      32              :   )
      33              : 
      34              :   // Release data from settings
      35         2353 :   const locale = computed(() => settingStore.get('Comfy.Locale'))
      36         2353 :   const releaseVersion = computed(() =>
      37              :     settingStore.get('Comfy.Release.Version')
      38              :   )
      39         2353 :   const releaseStatus = computed(() => settingStore.get('Comfy.Release.Status'))
      40         2353 :   const releaseTimestamp = computed(() =>
      41              :     settingStore.get('Comfy.Release.Timestamp')
      42              :   )
      43         2353 :   const showVersionUpdates = computed(() =>
      44              :     settingStore.get('Comfy.Notification.ShowVersionUpdates')
      45              :   )
      46              : 
      47              :   // Most recent release
      48         2353 :   const recentRelease = computed(() => {
      49            1 :     return releases.value.at(0) ?? null
      50              :   })
      51              : 
      52              :   // 3 most recent releases
      53         2353 :   const recentReleases = computed(() => {
      54            5 :     return releases.value.slice(0, 3)
      55              :   })
      56              : 
      57              :   // Helper constants
      58              :   const THREE_DAYS_MS = 3 * 24 * 60 * 60 * 1000 // 3 days
      59              : 
      60         2353 :   const compareVersions = (
      61              :     releaseVersion: string,
      62              :     currentVer: string
      63              :   ): number => {
      64            0 :     if (valid(releaseVersion) && valid(currentVer)) {
      65            0 :       return compare(releaseVersion, currentVer)
      66              :     }
      67              :     // Non-semver (e.g. git hash): assume different = newer
      68            0 :     return releaseVersion === currentVer ? 0 : 1
      69              :   }
      70              : 
      71              :   // New version available?
      72         2353 :   const isNewVersionAvailable = computed(
      73              :     () =>
      74              :       !!recentRelease.value &&
      75              :       compareVersions(
      76              :         recentRelease.value.version,
      77              :         currentVersion.value || '0.0.0'
      78              :       ) > 0
      79              :   )
      80              : 
      81         2353 :   const isLatestVersion = computed(
      82              :     () =>
      83              :       !!recentRelease.value &&
      84              :       compareVersions(
      85              :         recentRelease.value.version,
      86              :         currentVersion.value || '0.0.0'
      87              :       ) === 0
      88              :   )
      89              : 
      90         2353 :   const hasMediumOrHighAttention = computed(() => {
      91            0 :     const attention = recentRelease.value?.attention
      92            0 :     return attention === 'medium' || attention === 'high'
      93              :   })
      94              : 
      95              :   // Show toast if needed
      96         2353 :   const shouldShowToast = computed(() => {
      97              :     // Only show on desktop version
      98              :     if (!isDesktop || isCloud) {
      99         1975 :       return false
     100              :     }
     101              : 
     102              :     // Skip if notifications are disabled
     103              :     if (!showVersionUpdates.value) {
     104              :       return false
     105              :     }
     106              : 
     107              :     if (!isNewVersionAvailable.value) {
     108              :       return false
     109              :     }
     110              : 
     111              :     // Skip if low attention
     112              :     if (!hasMediumOrHighAttention.value) {
     113              :       return false
     114              :     }
     115              : 
     116              :     // Skip if user already skipped or changelog seen
     117              :     if (
     118              :       releaseVersion.value === recentRelease.value?.version &&
     119              :       ['skipped', 'changelog seen'].includes(releaseStatus.value)
     120              :     ) {
     121              :       return false
     122              :     }
     123              : 
     124              :     return true
     125              :   })
     126              : 
     127              :   // Show red-dot indicator
     128         2353 :   const shouldShowRedDot = computed(() => {
     129              :     // Only show on desktop version
     130              :     if (!isDesktop || isCloud) {
     131         1975 :       return false
     132              :     }
     133              : 
     134              :     // Skip if notifications are disabled
     135              :     if (!showVersionUpdates.value) {
     136              :       return false
     137              :     }
     138              : 
     139              :     // Already latest → no dot
     140              :     if (!isNewVersionAvailable.value) {
     141              :       return false
     142              :     }
     143              : 
     144              :     const release = recentRelease.value
     145              :     if (!release) return false
     146              :     const { version } = release
     147              : 
     148              :     // Changelog seen → clear dot
     149              :     if (
     150              :       releaseVersion.value === version &&
     151              :       releaseStatus.value === 'changelog seen'
     152              :     ) {
     153              :       return false
     154              :     }
     155              : 
     156              :     // Attention medium / high (levels 2 & 3)
     157              :     if (hasMediumOrHighAttention.value) {
     158              :       // Persist until changelog is opened
     159              :       return true
     160              :     }
     161              : 
     162              :     // Attention low (level 1) and skipped → keep up to 3 d
     163              :     if (
     164              :       releaseVersion.value === version &&
     165              :       releaseStatus.value === 'skipped' &&
     166              :       releaseTimestamp.value &&
     167              :       Date.now() - releaseTimestamp.value >= THREE_DAYS_MS
     168              :     ) {
     169              :       return false
     170              :     }
     171              : 
     172              :     // Not skipped → show
     173              :     return true
     174              :   })
     175              : 
     176         2353 :   const shouldShowPopup = computed(() => {
     177              :     // Deferred, not dropped: the tour ends and this re-evaluates.
     178         1985 :     if (onboardingTourStore.activeTour === 'firstRun') {
     179            0 :       return false
     180              :     }
     181              : 
     182         1985 :     if (onboardingOverlayStore.active) {
     183            0 :       return false
     184              :     }
     185              : 
     186              :     if (!isDesktop && !isCloud) {
     187         1985 :       return false
     188              :     }
     189              : 
     190              :     if (!showVersionUpdates.value) {
     191              :       return false
     192              :     }
     193              : 
     194              :     if (!recentRelease.value) {
     195              :       return false
     196              :     }
     197              : 
     198              :     // Skip version check if current version isn't semver (e.g. git hash)
     199              :     const skipVersionCheck = !valid(currentVersion.value)
     200              :     if (!skipVersionCheck && !isLatestVersion.value) {
     201              :       return false
     202              :     }
     203              : 
     204              :     if (
     205              :       releaseVersion.value === recentRelease.value.version &&
     206              :       releaseStatus.value === "what's new seen"
     207              :     ) {
     208              :       return false
     209              :     }
     210              : 
     211              :     return true
     212              :   })
     213              : 
     214              :   // Action handlers for user interactions
     215            0 :   async function handleSkipRelease(version: string): Promise<void> {
     216            0 :     if (
     217              :       version !== recentRelease.value?.version ||
     218              :       releaseStatus.value === 'changelog seen'
     219              :     ) {
     220            0 :       return
     221              :     }
     222              : 
     223            0 :     await settingStore.setMany({
     224              :       'Comfy.Release.Version': version,
     225              :       'Comfy.Release.Status': 'skipped',
     226              :       'Comfy.Release.Timestamp': Date.now()
     227              :     })
     228              :   }
     229              : 
     230            1 :   async function handleShowChangelog(version: string): Promise<void> {
     231            1 :     if (version !== recentRelease.value?.version) {
     232            0 :       return
     233              :     }
     234              : 
     235            1 :     await settingStore.setMany({
     236              :       'Comfy.Release.Version': version,
     237              :       'Comfy.Release.Status': 'changelog seen',
     238              :       'Comfy.Release.Timestamp': Date.now()
     239              :     })
     240              :   }
     241              : 
     242            0 :   async function handleWhatsNewSeen(version: string): Promise<void> {
     243            0 :     if (version !== recentRelease.value?.version) {
     244            0 :       return
     245              :     }
     246              : 
     247            0 :     await settingStore.setMany({
     248              :       'Comfy.Release.Version': version,
     249              :       'Comfy.Release.Status': "what's new seen",
     250              :       'Comfy.Release.Timestamp': Date.now()
     251              :     })
     252              :   }
     253              : 
     254              :   // Fetch releases from API
     255        10722 :   async function fetchReleases(): Promise<void> {
     256        10722 :     if (isLoading.value) {
     257         6270 :       return
     258              :     }
     259              : 
     260        10722 :     if (!isCloud && !showVersionUpdates.value) {
     261           17 :       return
     262              :     }
     263              : 
     264              :     // Skip fetching if API nodes are disabled via argv
     265        10722 :     if (
     266              :       systemStatsStore.systemStats?.system.argv?.includes('--disable-api-nodes')
     267              :     ) {
     268            0 :       return
     269              :     }
     270         4435 :     isLoading.value = true
     271         4435 :     error.value = null
     272              : 
     273        10722 :     try {
     274              :       // Ensure system stats are loaded
     275        10705 :       if (!systemStatsStore.systemStats) {
     276            0 :         await until(systemStatsStore.isInitialized)
     277              :       }
     278              : 
     279        10722 :       const fetchedReleases = await releaseService.getReleases(
     280              :         {
     281              :           project: isCloud ? 'cloud' : 'comfyui',
     282              :           current_version: currentVersion.value,
     283              :           form_factor: systemStatsStore.getFormFactor(),
     284              :           locale: stringToLocale(locale.value)
     285              :         },
     286              :         {
     287              :           deployEnvironment:
     288              :             systemStatsStore.systemStats?.system.deploy_environment
     289              :         }
     290              :       )
     291              : 
     292        10703 :       if (fetchedReleases !== null) {
     293         4430 :         releases.value = fetchedReleases
     294            2 :       } else if (releaseService.error.value) {
     295            2 :         error.value = releaseService.error.value
     296              :       }
     297              :     } catch (err) {
     298            0 :       error.value =
     299              :         err instanceof Error ? err.message : 'Unknown error occurred'
     300              :     } finally {
     301         4432 :       isLoading.value = false
     302              :     }
     303              :   }
     304              : 
     305              :   // Initialize store
     306         6521 :   async function initialize(): Promise<void> {
     307         6521 :     await fetchReleases()
     308              :   }
     309              : 
     310         2353 :   return {
     311              :     releases,
     312              :     isLoading,
     313              :     error,
     314              :     recentRelease,
     315              :     recentReleases,
     316              :     shouldShowToast,
     317              :     shouldShowRedDot,
     318              :     shouldShowPopup,
     319              :     shouldShowUpdateButton: isNewVersionAvailable,
     320              :     handleSkipRelease,
     321              :     handleShowChangelog,
     322              :     handleWhatsNewSeen,
     323              :     fetchReleases,
     324              :     initialize
     325              :   }
     326              : })
        

Generated by: LCOV version 2.0-1