LCOV - code coverage report
Current view: top level - src/platform/openOnCloud - desktopWorkflowRelay.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 59.3 % 54 32
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { z } from 'zod'
       2              : 
       3              : import { t } from '@/i18n'
       4              : import { isCloud } from '@/platform/distribution/types'
       5              : import {
       6              :   DESKTOP_HANDOFF_HASH,
       7              :   DESKTOP_HANDOFF_LIFETIME_MS,
       8              :   DESKTOP_RELAY_PARAM,
       9              :   captureDesktopWorkflowHandoff,
      10              :   desktopWorkflowUrl
      11              : } from '@/platform/openOnCloud/desktopWorkflowHandoff'
      12              : import {
      13              :   cloudOrigin,
      14              :   isLocalOrigin
      15              : } from '@/platform/openOnCloud/localHandoffProtocol'
      16              : import { api } from '@/scripts/api'
      17              : import type { ComfyWorkflowJSON } from '@comfyorg/graph-model/workflowSchema'
      18              : 
      19         2356 : const zRelayRecord = z.object({
      20              :   destination: z.url().refine((value) => {
      21            0 :     const url = new URL(value)
      22            0 :     return (
      23              :       url.origin === cloudOrigin() && url.hash.startsWith(DESKTOP_HANDOFF_HASH)
      24              :     )
      25              :   }),
      26              :   expiresAt: z.number()
      27              : })
      28              : 
      29         2356 : export async function handleDesktopWorkflowHandoff(): Promise<boolean> {
      30         2356 :   if (!isCloud) return redirectDesktopWorkflowRelay()
      31              :   await captureDesktopWorkflowHandoff()
      32              :   return false
      33              : }
      34              : 
      35            1 : function transferFile(nonce: string) {
      36            1 :   return `open-on-cloud/${nonce}.json`
      37              : }
      38              : 
      39            0 : export async function stageDesktopWorkflowHandoff(
      40              :   filename: string,
      41              :   workflow: ComfyWorkflowJSON
      42              : ): Promise<string | undefined> {
      43            0 :   const nonce = crypto.randomUUID()
      44            0 :   const expiresAt = Date.now() + DESKTOP_HANDOFF_LIFETIME_MS
      45            0 :   const destination = await desktopWorkflowUrl(nonce, {
      46              :     filename,
      47              :     workflow,
      48              :     expiresAt
      49              :   })
      50            0 :   if (!destination) return undefined
      51            0 :   const file = transferFile(nonce)
      52              :   const stored = await api.storeUserData(
      53              :     file,
      54              :     { destination, expiresAt },
      55              :     {
      56              :       stringify: true,
      57              :       overwrite: false,
      58              :       throwOnError: false
      59              :     }
      60              :   )
      61            0 :   if (!stored.ok) return undefined
      62            0 :   setTimeout(() => {
      63            0 :     void api.deleteUserData(file).catch(() => undefined)
      64              :   }, DESKTOP_HANDOFF_LIFETIME_MS)
      65            0 :   const relay = new URL(window.location.href)
      66            0 :   relay.search = ''
      67            0 :   relay.hash = ''
      68            0 :   relay.searchParams.set(DESKTOP_RELAY_PARAM, nonce)
      69            0 :   relay.searchParams.set('user', api.user)
      70            0 :   return relay.href
      71              : }
      72              : 
      73            1 : function relayNonce(url: URL): string | undefined {
      74            1 :   if (!isLocalOrigin(url.origin)) return undefined
      75            1 :   return z.uuid().safeParse(url.searchParams.get(DESKTOP_RELAY_PARAM)).data
      76              : }
      77              : 
      78            1 : async function takeRelayDestination(
      79              :   nonce: string
      80              : ): Promise<string | undefined> {
      81            1 :   const file = transferFile(nonce)
      82            1 :   const response = await api.getUserData(file)
      83            1 :   if (!response.ok) return undefined
      84            0 :   const record = zRelayRecord.safeParse(await response.json().catch(() => null))
      85              :   const removed = await api.deleteUserData(file)
      86            1 :   if (!removed.ok || !record.success || record.data.expiresAt <= Date.now())
      87            0 :     return undefined
      88            0 :   return record.data.destination
      89              : }
      90              : 
      91            3 : async function isOpenOnCloudEnabled(): Promise<boolean> {
      92            3 :   const { refreshRemoteConfig } =
      93              :     await import('@/platform/remoteConfig/refreshRemoteConfig')
      94            3 :   await refreshRemoteConfig({ useAuth: false })
      95            3 :   const { useFeatureFlags } = await import('@/composables/useFeatureFlags')
      96            3 :   return useFeatureFlags().flags.openOnCloudEnabled
      97              : }
      98              : 
      99            1 : async function relayWorkflow(url: URL): Promise<boolean> {
     100            1 :   const nonce = relayNonce(url)
     101            1 :   if (!nonce) return false
     102            1 :   api.user = url.searchParams.get('user') ?? ''
     103            1 :   const destination = await takeRelayDestination(nonce)
     104            1 :   if (!destination) return false
     105            0 :   window.location.replace(destination)
     106            0 :   return true
     107              : }
     108              : 
     109         2356 : async function redirectDesktopWorkflowRelay(): Promise<boolean> {
     110         2356 :   const url = new URL(window.location.href)
     111         2356 :   if (!url.searchParams.has(DESKTOP_RELAY_PARAM)) return false
     112            3 :   if (!(await isOpenOnCloudEnabled().catch(() => false))) return false
     113              :   const relayed = await relayWorkflow(url).catch(() => false)
     114            1 :   if (!relayed) {
     115            1 :     const splash = document.getElementById('splash-loader')
     116            1 :     if (splash) splash.textContent = t('openOnCloud.desktopTransferFailed')
     117              :   }
     118            1 :   return true
     119              : }
        

Generated by: LCOV version 2.0-1