LCOV - code coverage report
Current view: top level - src/platform/openOnCloud/composables - useLocalHandoffUrlLoader.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 100.0 % 1 1
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { useRoute, useRouter } from 'vue-router'
       2              : 
       3              : import { useToast } from '@/components/ui/toast/toastStore'
       4              : import { useFeatureFlags } from '@/composables/useFeatureFlags'
       5              : import { t } from '@/i18n'
       6              : import {
       7              :   clearPreservedQuery,
       8              :   hydratePreservedQuery,
       9              :   mergePreservedQueryIntoQuery
      10              : } from '@/platform/navigation/preservedQueryManager'
      11              : import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQueryNamespaces'
      12              : import {
      13              :   LOCAL_HANDOFF_PARAM,
      14              :   isLocalOrigin,
      15              :   localHandoffReady,
      16              :   zLocalHandoffWorkflow
      17              : } from '@/platform/openOnCloud/localHandoffProtocol'
      18              : import { reportError } from '@comfyorg/telemetry/reportError'
      19              : import { validateComfyWorkflow } from '@comfyorg/graph-model/workflowSchema'
      20              : import { app } from '@/scripts/app'
      21              : import { takeDesktopWorkflowHandoff } from '@/platform/openOnCloud/desktopWorkflowHandoff'
      22              : 
      23         2355 : const NAMESPACE = PRESERVED_QUERY_NAMESPACES.LOCAL_HANDOFF
      24              : const HANDOFF_WAIT_MS = 60_000
      25              : const NOTICE_MS = 8000
      26              : 
      27              : function showMissingWorkflow() {
      28              :   useToast().error(t('openOnCloud.handoffMissing'), {
      29              :     description: t('openOnCloud.handoffMissingDetail'),
      30              :     duration: NOTICE_MS
      31              :   })
      32              : }
      33              : 
      34              : async function openHandedOffWorkflow(
      35              :   filename: string,
      36              :   data: unknown
      37              : ): Promise<void> {
      38              :   const toast = useToast()
      39              :   const workflow = await validateComfyWorkflow(data)
      40              :   if (!workflow) {
      41              :     toast.error(t('openOnCloud.handoffFailed'), { duration: NOTICE_MS })
      42              :     return
      43              :   }
      44              :   try {
      45              :     const outcome = await app.loadGraphData(workflow, true, true, filename)
      46              :     if (outcome === false || outcome === undefined) return
      47              :   } catch (error) {
      48              :     reportError(error, {
      49              :       errorType: 'failure_loading_open_on_cloud_workflow',
      50              :       surface: 'graph'
      51              :     })
      52              :     toast.error(t('openOnCloud.handoffFailed'), { duration: NOTICE_MS })
      53              :     return
      54              :   }
      55              :   toast.info(t('openOnCloud.openedFromLocal'), {
      56              :     description: t('openOnCloud.openedFromLocalDetail'),
      57              :     duration: NOTICE_MS
      58              :   })
      59              : }
      60              : 
      61              : function requestWorkflow(opener: Window, nonce: string): void {
      62              :   function onMessage(event: MessageEvent) {
      63              :     if (event.source !== opener || !isLocalOrigin(event.origin)) return
      64              :     const handoff = zLocalHandoffWorkflow.safeParse(event.data)
      65              :     if (!handoff.success || handoff.data.nonce !== nonce) return
      66              :     stop()
      67              :     void openHandedOffWorkflow(handoff.data.filename, handoff.data.workflow)
      68              :   }
      69              :   function stop() {
      70              :     window.removeEventListener('message', onMessage)
      71              :     clearTimeout(deadline)
      72              :   }
      73              :   const deadline = setTimeout(() => {
      74              :     stop()
      75              :     showMissingWorkflow()
      76              :   }, HANDOFF_WAIT_MS)
      77              :   window.addEventListener('message', onMessage)
      78              :   opener.postMessage(localHandoffReady(nonce), '*')
      79              : }
      80              : 
      81              : export function useLocalHandoffUrlLoader(
      82              :   getOpener: () => Window | null = () => window.opener
      83              : ) {
      84              :   const route = useRoute()
      85              :   const router = useRouter()
      86              :   const { flags } = useFeatureFlags()
      87              : 
      88              :   async function receiveHandoff(nonce: string) {
      89              :     const desktop = takeDesktopWorkflowHandoff(nonce)
      90              :     if (!flags.openOnCloudEnabled) return
      91              :     if (desktop)
      92              :       return openHandedOffWorkflow(desktop.filename, desktop.workflow)
      93              :     const opener = getOpener()
      94              :     if (opener) requestWorkflow(opener, nonce)
      95              :     else showMissingWorkflow()
      96              :   }
      97              : 
      98              :   async function loadLocalHandoffFromUrl() {
      99              :     hydratePreservedQuery(NAMESPACE)
     100              :     const query =
     101              :       mergePreservedQueryIntoQuery(NAMESPACE, route.query) ?? route.query
     102              :     const nonce = query[LOCAL_HANDOFF_PARAM]
     103              :     if (nonce === undefined) return
     104              : 
     105              :     const cleanQuery = { ...query }
     106              :     delete cleanQuery[LOCAL_HANDOFF_PARAM]
     107              :     const stripped = router.replace({ query: cleanQuery }).catch((error) => {
     108              :       console.warn(
     109              :         '[useLocalHandoffUrlLoader] Failed to clean URL params:',
     110              :         error
     111              :       )
     112              :     })
     113              :     clearPreservedQuery(NAMESPACE)
     114              : 
     115              :     if (typeof nonce === 'string') await receiveHandoff(nonce)
     116              :     await stripped
     117              :   }
     118              : 
     119              :   return { loadLocalHandoffFromUrl }
     120              : }
        

Generated by: LCOV version 2.0-1