From c24ec68b5672d2cd0fc1a1b347eabe3e564bfc71 Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Fri, 17 Jul 2026 14:06:29 +0900
Subject: [PATCH 1/9] feat: add gated Hugging Face model access hints

---
 .../comfyDesktopBridge.d.ts                   |   3 +
 .../comfyui-desktop-bridge-types/package.json |   2 +-
 src/locales/en/main.json                      |   3 +
 .../components/MissingModelCard.test.ts       |  64 +++++++++++
 .../components/MissingModelCard.vue           |  29 ++++-
 .../components/MissingModelRow.test.ts        | 103 +++++++++++++++++-
 .../components/MissingModelRow.vue            |  59 ++++++----
 .../composables/useMissingModelDownload.ts    |  54 +++++++++
 .../missingModel/missingModelDownload.test.ts |  52 +++++++--
 .../missingModel/missingModelDownload.ts      |  20 +++-
 .../missingModel/missingModelPipeline.test.ts |  45 +++++++-
 .../missingModel/missingModelPipeline.ts      |   4 +
 .../missingModel/missingModelStore.test.ts    |  16 +++
 .../missingModel/missingModelStore.ts         |  10 +-
 14 files changed, 425 insertions(+), 39 deletions(-)
 create mode 100644 src/platform/missingModel/composables/useMissingModelDownload.ts

diff --git a/packages/comfyui-desktop-bridge-types/comfyDesktopBridge.d.ts b/packages/comfyui-desktop-bridge-types/comfyDesktopBridge.d.ts
index a7c51e63870..629b3f0f2eb 100644
--- a/packages/comfyui-desktop-bridge-types/comfyDesktopBridge.d.ts
+++ b/packages/comfyui-desktop-bridge-types/comfyDesktopBridge.d.ts
@@ -70,6 +70,9 @@ export interface ComfyDesktop2TelemetryBridge {
 
 export interface ComfyDesktop2Bridge {
   isRemote(): boolean
+  /** Opens a model provider access page in the hosted frontend's browser session.
+   *  Resolves `true` when the host accepts the request. */
+  openModelAccessPage?: (url: string) => Promise<boolean>
   downloadModel?: (
     url: string,
     filename: string,
diff --git a/packages/comfyui-desktop-bridge-types/package.json b/packages/comfyui-desktop-bridge-types/package.json
index c3cdbe2a5db..d61214b04f6 100644
--- a/packages/comfyui-desktop-bridge-types/package.json
+++ b/packages/comfyui-desktop-bridge-types/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@comfyorg/comfyui-desktop-bridge-types",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "TypeScript definitions for the Comfy Desktop hosted frontend bridge",
   "homepage": "https://comfy.org",
   "license": "MIT",
diff --git a/src/locales/en/main.json b/src/locales/en/main.json
index 399226430d0..37eed13eaca 100644
--- a/src/locales/en/main.json
+++ b/src/locales/en/main.json
@@ -3991,7 +3991,10 @@
       "importNotSupported": "Import Not Supported",
       "copyModelName": "Copy model name",
       "copyUrl": "Copy URL",
+      "gatedModelsHint": "Some models are gated. To download them, sign in to Hugging Face and accept the model license agreement.",
+      "gatedModelTooltip": "This model is gated and requires you to be logged in to Hugging Face and to accept its license agreement.",
       "locateNode": "Locate node on canvas",
+      "openHuggingFaceRepo": "Open Hugging Face repo",
       "expandNodes": "Show referencing nodes",
       "collapseNodes": "Hide referencing nodes",
       "unknownCategory": "Unknown",
diff --git a/src/platform/missingModel/components/MissingModelCard.test.ts b/src/platform/missingModel/components/MissingModelCard.test.ts
index e5eccda9834..1e4ed26036d 100644
--- a/src/platform/missingModel/components/MissingModelCard.test.ts
+++ b/src/platform/missingModel/components/MissingModelCard.test.ts
@@ -3,6 +3,7 @@ import { render, screen, within } from '@testing-library/vue'
 import userEvent from '@testing-library/user-event'
 import PrimeVue from 'primevue/config'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { nextTick } from 'vue'
 import { createI18n } from 'vue-i18n'
 
 import enMessages from '@/locales/en/main.json' with { type: 'json' }
@@ -10,6 +11,20 @@ import type {
   MissingModelGroup,
   MissingModelViewModel
 } from '@/platform/missingModel/types'
+import type * as MissingModelDownload from '@/platform/missingModel/missingModelDownload'
+import { useMissingModelStore } from '@/platform/missingModel/missingModelStore'
+
+const mockDownloadModel = vi.hoisted(() => vi.fn())
+
+vi.mock('@/platform/missingModel/missingModelDownload', async () => {
+  const actual = await vi.importActual<typeof MissingModelDownload>(
+    '@/platform/missingModel/missingModelDownload'
+  )
+  return {
+    ...actual,
+    downloadModel: mockDownloadModel
+  }
+})
 
 vi.mock('./MissingModelRow.vue', () => ({
   default: {
@@ -131,6 +146,7 @@ function getRowsIn(testId: string) {
 
 describe('MissingModelCard', () => {
   beforeEach(() => {
+    vi.clearAllMocks()
     mockIsCloud.value = true
   })
 
@@ -241,6 +257,21 @@ describe('MissingModelCard', () => {
         screen.queryByTestId('missing-model-actions')
       ).not.toBeInTheDocument()
     })
+
+    it('does not show gated model guidance in cloud', async () => {
+      const group = makeGroup({ withDownloadUrls: true })
+      const url =
+        'https://huggingface.co/comfy/test/resolve/main/model.safetensors'
+      mountCard({ missingModelGroups: [group] })
+
+      useMissingModelStore().gatedRepoUrls[url] =
+        'https://huggingface.co/comfy/test'
+      await nextTick()
+
+      expect(
+        screen.queryByTestId('missing-model-gated-hint')
+      ).not.toBeInTheDocument()
+    })
   })
 
   describe('Event Handling', () => {
@@ -256,6 +287,7 @@ describe('MissingModelCard', () => {
 
 describe('MissingModelCard (OSS)', () => {
   beforeEach(() => {
+    vi.clearAllMocks()
     mockIsCloud.value = false
   })
 
@@ -293,6 +325,38 @@ describe('MissingModelCard (OSS)', () => {
     ).toBeVisible()
   })
 
+  it('shows gated model guidance in OSS', async () => {
+    const group = makeGroup({ withDownloadUrls: true })
+    const url =
+      'https://huggingface.co/comfy/test/resolve/main/model.safetensors'
+    mountCard({ missingModelGroups: [group] })
+
+    useMissingModelStore().gatedRepoUrls[url] =
+      'https://huggingface.co/comfy/test'
+    await nextTick()
+
+    expect(screen.getByTestId('missing-model-gated-hint')).toHaveTextContent(
+      'Some models are gated. To download them, sign in to Hugging Face and accept the model license agreement.'
+    )
+  })
+
+  it('routes Download all through the shared missing-model download handler', async () => {
+    mountCard({
+      missingModelGroups: [makeGroup({ withDownloadUrls: true })]
+    })
+
+    await userEvent.click(screen.getByTestId('missing-model-download-all'))
+
+    expect(mockDownloadModel).toHaveBeenCalledWith(
+      {
+        name: 'model.safetensors',
+        url: 'https://huggingface.co/comfy/test/resolve/main/model.safetensors',
+        directory: 'checkpoints'
+      },
+      {}
+    )
+  })
+
   it('hides Download all when no model is downloadable', () => {
     mountCard()
 
diff --git a/src/platform/missingModel/components/MissingModelCard.vue b/src/platform/missingModel/components/MissingModelCard.vue
index 6e7ec5a1ffd..7316ea07895 100644
--- a/src/platform/missingModel/components/MissingModelCard.vue
+++ b/src/platform/missingModel/components/MissingModelCard.vue
@@ -1,5 +1,20 @@
 <template>
   <div class="px-3">
+    <div
+      v-if="showGatedModelsHint"
+      data-testid="missing-model-gated-hint"
+      role="alert"
+      class="mb-2 flex gap-2 rounded-md border border-warning-background/30 bg-warning-background/10 p-2.5"
+    >
+      <i
+        aria-hidden="true"
+        class="mt-0.5 icon-[lucide--lock] size-4 shrink-0 text-warning-background"
+      />
+      <p class="m-0 text-xs/relaxed text-warning-background">
+        {{ t('rightSidePanel.missingModels.gatedModelsHint') }}
+      </p>
+    </div>
+
     <div
       v-if="importableModelRows.length > 0"
       data-testid="missing-model-importable-rows"
@@ -68,7 +83,7 @@ import type { MissingModelGroup } from '@/platform/missingModel/types'
 import { isCloud } from '@/platform/distribution/types'
 import MissingModelRow from '@/platform/missingModel/components/MissingModelRow.vue'
 import Button from '@/components/ui/button/Button.vue'
-import { downloadModel } from '@/platform/missingModel/missingModelDownload'
+import { useMissingModelDownload } from '@/platform/missingModel/composables/useMissingModelDownload'
 import { getDownloadableModels } from '@/platform/missingModel/missingModelViewUtils'
 import { useMissingModelStore } from '@/platform/missingModel/missingModelStore'
 import { formatSize } from '@/utils/formatUtil'
@@ -100,6 +115,7 @@ const emit = defineEmits<{
 
 const { t } = useI18n()
 const missingModelStore = useMissingModelStore()
+const { downloadMissingModel } = useMissingModelDownload()
 
 const sortedModelRows = computed(() =>
   missingModelGroups
@@ -122,6 +138,15 @@ const unsupportedModelRows = computed(() =>
   isCloud ? sortedModelRows.value.filter((row) => !canCloudImport(row)) : []
 )
 
+const showGatedModelsHint = computed(
+  () =>
+    !isCloud &&
+    sortedModelRows.value.some((row) => {
+      const url = row.model.representative.url
+      return !!url && !!missingModelStore.gatedRepoUrls[url]
+    })
+)
+
 const downloadableModels = computed(() => {
   if (isCloud) return []
 
@@ -139,7 +164,7 @@ const downloadAllLabel = computed(() => {
 
 function downloadAllModels() {
   for (const model of downloadableModels.value) {
-    downloadModel(model, missingModelStore.folderPaths)
+    downloadMissingModel(model)
   }
 }
 
diff --git a/src/platform/missingModel/components/MissingModelRow.test.ts b/src/platform/missingModel/components/MissingModelRow.test.ts
index 441ec813a38..1019f1ae60c 100644
--- a/src/platform/missingModel/components/MissingModelRow.test.ts
+++ b/src/platform/missingModel/components/MissingModelRow.test.ts
@@ -19,6 +19,8 @@ const mockIsCloud = vi.hoisted(() => ({ value: true }))
 const mockShowUploadDialog = vi.hoisted(() => vi.fn())
 const mockCopyToClipboard = vi.hoisted(() => vi.fn())
 const mockDownloadModel = vi.hoisted(() => vi.fn())
+const mockFetchModelMetadata = vi.hoisted(() => vi.fn())
+const mockOpenGatedRepoPage = vi.hoisted(() => vi.fn())
 const mockRootGraph = vi.hoisted<{
   value: Record<string, never> | null
 }>(() => ({ value: null }))
@@ -104,10 +106,8 @@ vi.mock('@/platform/missingModel/missingModelDownload', async () => {
   return {
     ...actual,
     downloadModel: mockDownloadModel,
-    fetchModelMetadata: vi.fn().mockResolvedValue({
-      fileSize: null,
-      gatedRepoUrl: null
-    })
+    fetchModelMetadata: mockFetchModelMetadata,
+    openGatedRepoPage: mockOpenGatedRepoPage
   }
 })
 
@@ -177,12 +177,17 @@ function renderRow(
 describe('MissingModelRow', () => {
   beforeEach(() => {
     vi.clearAllMocks()
+    delete window.__comfyDesktop2
     mockIsCloud.value = true
     mockRootGraph.value = null
     mockApiListeners.clear()
     mockGetNodeByExecutionId.mockReset()
     mockUploadContext.resolver = undefined
     mockUploadCallbacks.onUploadSuccess = undefined
+    mockFetchModelMetadata.mockResolvedValue({
+      fileSize: null,
+      gatedRepoUrl: null
+    })
   })
 
   it('opens the model import dialog from the cloud row', async () => {
@@ -401,6 +406,96 @@ describe('MissingModelRow', () => {
     )
   })
 
+  it('shows a gated HuggingFace access action without replacing download', async () => {
+    mockIsCloud.value = false
+    const model = makeModel([{ nodeId: '1', widgetName: 'ckpt_name' }])
+    model.representative.url =
+      'https://huggingface.co/bfl/FLUX.1/resolve/main/model.safetensors'
+    mockFetchModelMetadata.mockResolvedValueOnce({
+      fileSize: null,
+      gatedRepoUrl: 'https://huggingface.co/bfl/FLUX.1'
+    })
+
+    renderRow(model, vi.fn(), false)
+    const store = useMissingModelStore()
+
+    await waitFor(() => {
+      expect(store.gatedRepoUrls[model.representative.url!]).toBe(
+        'https://huggingface.co/bfl/FLUX.1'
+      )
+    })
+
+    const gatedModelTooltip =
+      'This model is gated and requires you to be logged in to Hugging Face and to accept its license agreement.'
+    expect(screen.getByTestId('missing-model-gated-access')).toHaveAttribute(
+      'title',
+      gatedModelTooltip
+    )
+    expect(screen.getByTestId('missing-model-download')).toHaveAttribute(
+      'title',
+      gatedModelTooltip
+    )
+  })
+
+  it('opens gated repo action separately from the download action', async () => {
+    mockIsCloud.value = false
+    const user = userEvent.setup()
+    const model = makeModel([{ nodeId: '1', widgetName: 'ckpt_name' }])
+    model.representative.url =
+      'https://huggingface.co/bfl/FLUX.1/resolve/main/model.safetensors'
+
+    renderRow(model, vi.fn(), false)
+    const store = useMissingModelStore()
+    store.setGatedRepoUrl(
+      model.representative.url,
+      'https://huggingface.co/bfl/FLUX.1'
+    )
+    await nextTick()
+
+    await user.click(screen.getByTestId('missing-model-gated-access'))
+    expect(mockOpenGatedRepoPage).toHaveBeenCalledWith(
+      'https://huggingface.co/bfl/FLUX.1'
+    )
+
+    await user.click(screen.getByTestId('missing-model-download'))
+    expect(mockDownloadModel).toHaveBeenCalledWith(
+      {
+        name: 'model.safetensors',
+        url: 'https://huggingface.co/bfl/FLUX.1/resolve/main/model.safetensors',
+        directory: 'checkpoints'
+      },
+      {}
+    )
+  })
+
+  it('delegates the gated repo action to the Desktop bridge when available', async () => {
+    mockIsCloud.value = false
+    const user = userEvent.setup()
+    const openModelAccessPage = vi.fn().mockResolvedValue(true)
+    window.__comfyDesktop2 = {
+      isRemote: () => false,
+      openModelAccessPage
+    }
+    const model = makeModel([{ nodeId: '1', widgetName: 'ckpt_name' }])
+    model.representative.url =
+      'https://huggingface.co/bfl/FLUX.1/resolve/main/model.safetensors'
+
+    renderRow(model, vi.fn(), false)
+    const store = useMissingModelStore()
+    store.setGatedRepoUrl(
+      model.representative.url,
+      'https://huggingface.co/bfl/FLUX.1'
+    )
+    await nextTick()
+
+    await user.click(screen.getByTestId('missing-model-gated-access'))
+
+    expect(openModelAccessPage).toHaveBeenCalledWith(
+      'https://huggingface.co/bfl/FLUX.1'
+    )
+    expect(mockOpenGatedRepoPage).not.toHaveBeenCalled()
+  })
+
   it('shows unknown category metadata for models without a directory', () => {
     renderRow(
       makeModel([{ nodeId: '1', widgetName: 'ckpt_name' }]),
diff --git a/src/platform/missingModel/components/MissingModelRow.vue b/src/platform/missingModel/components/MissingModelRow.vue
index f325d7dd2a7..08c8baee5f7 100644
--- a/src/platform/missingModel/components/MissingModelRow.vue
+++ b/src/platform/missingModel/components/MissingModelRow.vue
@@ -126,6 +126,18 @@
       </template>
 
       <template v-else>
+        <Button
+          v-if="showGatedRepoAction"
+          data-testid="missing-model-gated-access"
+          variant="muted-textonly"
+          size="icon"
+          class="size-8 shrink-0 text-warning-background hover:text-warning-background focus-visible:ring-inset"
+          :aria-label="`${t('rightSidePanel.missingModels.openHuggingFaceRepo')} ${model.name}`"
+          :title="gatedModelTooltip"
+          @click="handleOpenGatedRepo"
+        >
+          <i aria-hidden="true" class="icon-[lucide--lock] size-4" />
+        </Button>
         <Button
           v-if="showDownloadAction"
           data-testid="missing-model-download"
@@ -133,6 +145,7 @@
           size="sm"
           class="shrink-0 focus-visible:ring-inset"
           :aria-label="`${t('g.download')} ${model.name}`"
+          :title="gatedModelTooltip"
           @click="handleDownload"
         >
           {{ t('g.download') }}
@@ -212,12 +225,11 @@ import {
   getModelStateKey,
   getNodeDisplayLabel
 } from '@/platform/missingModel/composables/useMissingModelInteractions'
+import { useMissingModelDownload } from '@/platform/missingModel/composables/useMissingModelDownload'
 import { useMissingModelStore } from '@/platform/missingModel/missingModelStore'
 import { useCopyToClipboard } from '@/composables/useCopyToClipboard'
 import { isCloud } from '@/platform/distribution/types'
 import {
-  downloadModel,
-  fetchModelMetadata,
   isModelDownloadable,
   toBrowsableUrl
 } from '@/platform/missingModel/missingModelDownload'
@@ -279,6 +291,8 @@ const store = useMissingModelStore()
 const { selectedLibraryModel } = storeToRefs(store)
 const cloudProgress = useTemplateRef<HTMLElement>('cloudProgress')
 const modelLabelControl = useTemplateRef<HTMLButtonElement>('modelLabelControl')
+const { prefetchModelMetadata, downloadMissingModel, openModelAccessPage } =
+  useMissingModelDownload()
 
 const expanded = computed(
   () =>
@@ -315,6 +329,18 @@ const downloadable = computed(() => {
 })
 
 const showDownloadAction = computed(() => !isCloud && downloadable.value)
+const gatedRepoUrl = computed(() => {
+  const url = model.representative.url
+  return url ? store.gatedRepoUrls[url] : undefined
+})
+const showGatedRepoAction = computed(
+  () => showDownloadAction.value && !!gatedRepoUrl.value
+)
+const gatedModelTooltip = computed(() =>
+  showGatedRepoAction.value
+    ? t('rightSidePanel.missingModels.gatedModelTooltip')
+    : undefined
+)
 
 const downloadSizeLabel = computed(() => {
   if (!showDownloadAction.value) return undefined
@@ -362,34 +388,29 @@ onMounted(() => {
   if (isCloud) return
 
   const url = model.representative.url
-  if (url && !store.fileSizes[url]) {
-    fetchModelMetadata(url)
-      .then((metadata) => {
-        if (metadata.fileSize !== null) {
-          store.setFileSize(url, metadata.fileSize)
-        }
-      })
-      .catch((error: unknown) => {
-        console.warn(
-          `[MissingModelRow] Failed to fetch metadata for ${url}:`,
-          error
-        )
-      })
+  if (url && downloadable.value) {
+    void prefetchModelMetadata(url)
   }
 })
 
 function handleDownload() {
   const rep = model.representative
   if (rep.url && rep.directory) {
-    downloadModel(
-      { name: rep.name, url: rep.url, directory: rep.directory },
-      store.folderPaths
-    )
+    downloadMissingModel({
+      name: rep.name,
+      url: rep.url,
+      directory: rep.directory
+    })
   } else {
     console.warn('[MissingModelRow] Cannot download: missing url or directory')
   }
 }
 
+function handleOpenGatedRepo() {
+  const repoUrl = gatedRepoUrl.value
+  if (repoUrl) openModelAccessPage(repoUrl)
+}
+
 function handleLocatePrimary() {
   const ref = primaryReference.value
   if (ref) emit('locateModel', String(ref.nodeId))
diff --git a/src/platform/missingModel/composables/useMissingModelDownload.ts b/src/platform/missingModel/composables/useMissingModelDownload.ts
new file mode 100644
index 00000000000..7456c54d923
--- /dev/null
+++ b/src/platform/missingModel/composables/useMissingModelDownload.ts
@@ -0,0 +1,54 @@
+import {
+  downloadModel,
+  fetchModelMetadata,
+  openGatedRepoPage
+} from '@/platform/missingModel/missingModelDownload'
+import type { ModelWithUrl } from '@/platform/missingModel/missingModelDownload'
+import { useMissingModelStore } from '@/platform/missingModel/missingModelStore'
+
+export function useMissingModelDownload() {
+  const store = useMissingModelStore()
+
+  async function prefetchModelMetadata(url: string): Promise<void> {
+    if (store.fileSizes[url] !== undefined || store.gatedRepoUrls[url]) return
+
+    try {
+      const metadata = await fetchModelMetadata(url)
+      if (metadata.fileSize !== null) {
+        store.setFileSize(url, metadata.fileSize)
+      }
+      if (metadata.gatedRepoUrl) {
+        store.setGatedRepoUrl(url, metadata.gatedRepoUrl)
+      }
+    } catch (error: unknown) {
+      console.warn(
+        `[MissingModelDownload] Failed to fetch metadata for ${url}:`,
+        error
+      )
+    }
+  }
+
+  function downloadMissingModel(model: ModelWithUrl): void {
+    downloadModel(model, store.folderPaths)
+  }
+
+  function openModelAccessPage(repoUrl: string): void {
+    const desktopBridge = window.__comfyDesktop2
+    if (desktopBridge?.openModelAccessPage) {
+      void desktopBridge
+        .openModelAccessPage(repoUrl)
+        .catch((error: unknown) => {
+          console.error('Failed to open model access page in Desktop:', error)
+        })
+      return
+    }
+
+    openGatedRepoPage(repoUrl)
+  }
+
+  return {
+    prefetchModelMetadata,
+    downloadMissingModel,
+    openModelAccessPage
+  }
+}
diff --git a/src/platform/missingModel/missingModelDownload.test.ts b/src/platform/missingModel/missingModelDownload.test.ts
index 1991cadfe5b..5aaad6d7de0 100644
--- a/src/platform/missingModel/missingModelDownload.test.ts
+++ b/src/platform/missingModel/missingModelDownload.test.ts
@@ -4,6 +4,7 @@ import {
   downloadModel,
   fetchModelMetadata,
   isModelDownloadable,
+  openGatedRepoPage,
   toBrowsableUrl
 } from './missingModelDownload'
 
@@ -89,21 +90,34 @@ describe('fetchModelMetadata', () => {
     expect(fetchMock).toHaveBeenCalledTimes(1)
   })
 
-  it('returns gatedRepoUrl for gated HuggingFace HEAD requests (403)', async () => {
-    fetchMock.mockResolvedValueOnce({ ok: false, status: 403 })
+  it.for([401, 403, 451])(
+    'returns gatedRepoUrl for gated HuggingFace HEAD requests (%s)',
+    async (status) => {
+      fetchMock.mockResolvedValueOnce({ ok: false, status })
+
+      const metadata = await fetchModelMetadata(
+        `https://huggingface.co/bfl/FLUX.1/resolve/main/gated-${status}-${testId}.safetensors`
+      )
+      expect(metadata.gatedRepoUrl).toBe('https://huggingface.co/bfl/FLUX.1')
+      expect(metadata.fileSize).toBeNull()
+    }
+  )
+
+  it('does not treat HuggingFace 404/500 as gated', async () => {
+    fetchMock.mockResolvedValueOnce({ ok: false, status: 404 })
 
     const metadata = await fetchModelMetadata(
-      `https://huggingface.co/bfl/FLUX.1/resolve/main/gated-${testId}.safetensors`
+      `https://huggingface.co/org/model/resolve/main/notfound-${testId}.safetensors`
     )
-    expect(metadata.gatedRepoUrl).toBe('https://huggingface.co/bfl/FLUX.1')
+    expect(metadata.gatedRepoUrl).toBeNull()
     expect(metadata.fileSize).toBeNull()
   })
 
-  it('does not treat HuggingFace 404/500 as gated', async () => {
-    fetchMock.mockResolvedValueOnce({ ok: false, status: 404 })
+  it('does not treat non-HuggingFace hosts as gated', async () => {
+    fetchMock.mockResolvedValueOnce({ ok: false, status: 403 })
 
     const metadata = await fetchModelMetadata(
-      `https://huggingface.co/org/model/resolve/main/notfound-${testId}.safetensors`
+      `https://huggingface.co.evil.com/org/model/resolve/main/gated-${testId}.safetensors`
     )
     expect(metadata.gatedRepoUrl).toBeNull()
     expect(metadata.fileSize).toBeNull()
@@ -188,6 +202,11 @@ describe('toBrowsableUrl', () => {
     expect(toBrowsableUrl(url)).toBe(url)
   })
 
+  it('does not rewrite URLs just because the path contains huggingface.co', () => {
+    const url = 'https://example.com/huggingface.co/org/model/resolve/main/file'
+    expect(toBrowsableUrl(url)).toBe(url)
+  })
+
   it('preserves query params in HuggingFace URLs', () => {
     expect(
       toBrowsableUrl(
@@ -220,6 +239,25 @@ describe('toBrowsableUrl', () => {
   })
 })
 
+describe('openGatedRepoPage', () => {
+  it('opens gated repo pages without a download attribute', () => {
+    const clickedAnchors: HTMLAnchorElement[] = []
+    vi.spyOn(HTMLAnchorElement.prototype, 'click').mockImplementation(
+      function (this: HTMLAnchorElement) {
+        clickedAnchors.push(this)
+      }
+    )
+
+    openGatedRepoPage('https://huggingface.co/bfl/FLUX.1')
+
+    expect(clickedAnchors).toHaveLength(1)
+    expect(clickedAnchors[0]?.href).toBe('https://huggingface.co/bfl/FLUX.1')
+    expect(clickedAnchors[0]?.target).toBe('_blank')
+    expect(clickedAnchors[0]?.rel).toBe('noopener noreferrer')
+    expect(clickedAnchors[0]?.getAttribute('download')).toBeNull()
+  })
+})
+
 describe('isModelDownloadable', () => {
   it('allows civitai.red URLs', () => {
     expect(
diff --git a/src/platform/missingModel/missingModelDownload.ts b/src/platform/missingModel/missingModelDownload.ts
index dd8d8ddeeb2..d033e456449 100644
--- a/src/platform/missingModel/missingModelDownload.ts
+++ b/src/platform/missingModel/missingModelDownload.ts
@@ -47,6 +47,22 @@ async function startDesktop2ModelDownload(
   }
 }
 
+export function openGatedRepoPage(url: string): void {
+  const link = document.createElement('a')
+  link.href = url
+  link.target = '_blank'
+  link.rel = 'noopener noreferrer'
+  link.click()
+}
+
+function isHuggingFaceRepoUrl(url: string): boolean {
+  try {
+    return new URL(url).hostname.toLowerCase() === 'huggingface.co'
+  } catch {
+    return false
+  }
+}
+
 /**
  * Converts a model download URL to a browsable page URL.
  * - HuggingFace: `/resolve/` → `/blob/` (file page with model info)
@@ -56,7 +72,7 @@ export function toBrowsableUrl(url: string): string {
   if (isCivitaiModelUrl(url)) {
     return url.replace('/api/download/', '/').replace('/api/v1/', '/')
   }
-  if (url.includes('huggingface.co')) {
+  if (isHuggingFaceRepoUrl(url)) {
     return url.replace('/resolve/', '/blob/')
   }
   return url
@@ -156,7 +172,7 @@ async function fetchHeadMetadata(url: string): Promise<ModelMetadata> {
     const response = await fetch(url, { method: 'HEAD' })
     if (!response.ok) {
       if (
-        url.includes('huggingface.co') &&
+        isHuggingFaceRepoUrl(url) &&
         GATED_STATUS_CODES.has(response.status)
       ) {
         return { fileSize: null, gatedRepoUrl: downloadUrlToHfRepoUrl(url) }
diff --git a/src/platform/missingModel/missingModelPipeline.test.ts b/src/platform/missingModel/missingModelPipeline.test.ts
index 11464c08fca..03b09bd437d 100644
--- a/src/platform/missingModel/missingModelPipeline.test.ts
+++ b/src/platform/missingModel/missingModelPipeline.test.ts
@@ -33,7 +33,8 @@ const { mockHandles } = vi.hoisted(() => {
         missingModelCandidates: null as MissingModelCandidate[] | null,
         createVerificationAbortController: vi.fn(() => new AbortController()),
         setFolderPaths: vi.fn(),
-        setFileSize: vi.fn()
+        setFileSize: vi.fn(),
+        setGatedRepoUrl: vi.fn()
       },
       workspaceWorkflow: {
         activeWorkflow: null as {
@@ -183,7 +184,10 @@ describe('missingModelPipeline', () => {
     )
     mockHandles.scanAllModelCandidates.mockReturnValue([])
     mockHandles.api.getFolderPaths.mockResolvedValue({})
-    mockHandles.fetchModelMetadata.mockResolvedValue({ fileSize: null })
+    mockHandles.fetchModelMetadata.mockResolvedValue({
+      fileSize: null,
+      gatedRepoUrl: null
+    })
     mockHandles.isAncestorPathActive.mockReturnValue(true)
     mockHandles.isCandidateScopeActive.mockImplementation(
       (graph: LGraph, candidate: MissingModelCandidate) => {
@@ -440,7 +444,10 @@ describe('missingModelPipeline', () => {
         downloadableCandidate,
         urlOnlyCandidate
       ]
-      mockHandles.fetchModelMetadata.mockResolvedValue({ fileSize: 1024 })
+      mockHandles.fetchModelMetadata.mockResolvedValue({
+        fileSize: 1024,
+        gatedRepoUrl: null
+      })
 
       await runMissingModelPipeline({
         graph: createGraph(),
@@ -459,6 +466,38 @@ describe('missingModelPipeline', () => {
       )
     })
 
+    it('stores gated repo URLs for candidates with complete download metadata', async () => {
+      const downloadableCandidate = {
+        nodeType: 'CheckpointLoaderSimple',
+        widgetName: 'ckpt_name',
+        name: 'gated.safetensors',
+        url: 'https://huggingface.co/bfl/FLUX.1/resolve/main/gated.safetensors',
+        directory: 'checkpoints',
+        isMissing: true,
+        isAssetSupported: true
+      } satisfies MissingModelCandidate
+      mockHandles.state.enrichedCandidates = [downloadableCandidate]
+      mockHandles.fetchModelMetadata.mockResolvedValue({
+        fileSize: null,
+        gatedRepoUrl: 'https://huggingface.co/bfl/FLUX.1'
+      })
+
+      await runMissingModelPipeline({
+        graph: createGraph(),
+        graphData: createWorkflowGraphData(),
+        missingModelStore: mockHandles.missingModelStore
+      })
+      await vi.dynamicImportSettled()
+
+      expect(
+        mockHandles.missingModelStore.setGatedRepoUrl
+      ).toHaveBeenCalledWith(
+        'https://huggingface.co/bfl/FLUX.1/resolve/main/gated.safetensors',
+        'https://huggingface.co/bfl/FLUX.1'
+      )
+      expect(mockHandles.missingModelStore.setFileSize).not.toHaveBeenCalled()
+    })
+
     it('clears surfaced and cached missing models when no candidates are confirmed missing', async () => {
       const installedCandidate = {
         nodeType: 'CheckpointLoaderSimple',
diff --git a/src/platform/missingModel/missingModelPipeline.ts b/src/platform/missingModel/missingModelPipeline.ts
index 0642715fe70..c593ae10f9f 100644
--- a/src/platform/missingModel/missingModelPipeline.ts
+++ b/src/platform/missingModel/missingModelPipeline.ts
@@ -33,6 +33,7 @@ interface MissingModelPipelineStore {
   createVerificationAbortController: () => AbortController
   setFolderPaths: (paths: Record<string, string[]>) => void
   setFileSize: (url: string, size: number) => void
+  setGatedRepoUrl: (url: string, repoUrl: string) => void
 }
 
 interface RunMissingModelPipelineOptions {
@@ -212,6 +213,9 @@ export async function runMissingModelPipeline({
           if (!controller.signal.aborted && metadata.fileSize !== null) {
             missingModelStore.setFileSize(c.url, metadata.fileSize)
           }
+          if (!controller.signal.aborted && metadata.gatedRepoUrl) {
+            missingModelStore.setGatedRepoUrl(c.url, metadata.gatedRepoUrl)
+          }
         })
       )
     }
diff --git a/src/platform/missingModel/missingModelStore.test.ts b/src/platform/missingModel/missingModelStore.test.ts
index d3c3c8a6624..750f9ff24b4 100644
--- a/src/platform/missingModel/missingModelStore.test.ts
+++ b/src/platform/missingModel/missingModelStore.test.ts
@@ -262,6 +262,9 @@ describe('missingModelStore', () => {
       ])
       store.modelExpandState['test-key'] = true
       store.selectedLibraryModel['test-key'] = 'some-model'
+      store.gatedRepoUrls[
+        'https://huggingface.co/org/model/resolve/main/a.safetensors'
+      ] = 'https://huggingface.co/org/model'
       expect(store.missingModelCandidates).not.toBeNull()
 
       store.clearMissingModels()
@@ -270,6 +273,19 @@ describe('missingModelStore', () => {
       expect(store.hasMissingModels).toBe(false)
       expect(store.modelExpandState).toEqual({})
       expect(store.selectedLibraryModel).toEqual({})
+      expect(store.gatedRepoUrls).toEqual({})
+    })
+  })
+
+  describe('setGatedRepoUrl', () => {
+    it('stores gated repo URLs by model download URL', () => {
+      const store = useMissingModelStore()
+      const url =
+        'https://huggingface.co/org/model/resolve/main/model.safetensors'
+
+      store.setGatedRepoUrl(url, 'https://huggingface.co/org/model')
+
+      expect(store.gatedRepoUrls[url]).toBe('https://huggingface.co/org/model')
     })
   })
 
diff --git a/src/platform/missingModel/missingModelStore.ts b/src/platform/missingModel/missingModelStore.ts
index 1ee6b6fc417..76daaea68c1 100644
--- a/src/platform/missingModel/missingModelStore.ts
+++ b/src/platform/missingModel/missingModelStore.ts
@@ -85,6 +85,7 @@ export const useMissingModelStore = defineStore('missingModel', () => {
   const importTaskIds = ref<Record<string, string>>({})
   const folderPaths = ref<Record<string, string[]>>({})
   const fileSizes = ref<Record<string, number>>({})
+  const gatedRepoUrls = ref<Record<string, string>>({})
 
   let _verificationAbortController: AbortController | null = null
 
@@ -245,6 +246,10 @@ export const useMissingModelStore = defineStore('missingModel', () => {
     fileSizes.value[url] = size
   }
 
+  function setGatedRepoUrl(url: string, repoUrl: string) {
+    gatedRepoUrls.value[url] = repoUrl
+  }
+
   function clearMissingModels() {
     _verificationAbortController?.abort()
     _verificationAbortController = null
@@ -254,6 +259,7 @@ export const useMissingModelStore = defineStore('missingModel', () => {
     importTaskIds.value = {}
     folderPaths.value = {}
     fileSizes.value = {}
+    gatedRepoUrls.value = {}
   }
 
   function isAbortError(error: unknown) {
@@ -309,8 +315,10 @@ export const useMissingModelStore = defineStore('missingModel', () => {
     importTaskIds,
     folderPaths,
     fileSizes,
+    gatedRepoUrls,
 
     setFolderPaths,
-    setFileSize
+    setFileSize,
+    setGatedRepoUrl
   }
 })

From 41f35c20e0a8e12d10a080863c2e42d0c075f3fc Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Fri, 17 Jul 2026 19:45:49 +0900
Subject: [PATCH 2/9] fix: fall back to browser when the Desktop access-page
 bridge declines

The bridge contract resolves `false` when the host declines to open a model
access page, but the caller only branched on the method's presence and handled
rejections, so a declined request left the shield button doing nothing. Await
the result and fall through to the anchor fallback on both `false` and a thrown
error.

Align the card's gated banner with the row's shield action. The banner keyed off
`gatedRepoUrls` alone while the shield also requires `isModelDownloadable`, and
the pipeline populates `gatedRepoUrls` without checking allowed suffixes. A gated
`.bin` or `.gguf` therefore rendered guidance to accept a license with no shield
or download button on any row. Derive the banner from `downloadableModels` so
both conditions share one authority.

Also:
- Use a polite live region for the gated guidance instead of an assertive one.
- Document that `isRemote()` reports the backend server rather than the user's
  location, and why the access-page bridge is used regardless of it.
- Document that the metadata HEAD is deliberately uncredentialed, so a gated
  result cannot be cleared by a later re-check.
- Extract the duplicated anchor-click code behind one helper.
- Drop the unreachable catch in `prefetchModelMetadata`.
- Cover both 404 and 500 in the not-gated test, and drop the `setGatedRepoUrl`
  test that restated its own implementation.
---
 .../comfyDesktopBridge.d.ts                   |  1 +
 .../components/MissingModelCard.test.ts       | 17 +++++++++
 .../components/MissingModelCard.vue           | 17 ++++-----
 .../components/MissingModelRow.test.ts        | 30 +++++++++++++++
 .../components/MissingModelRow.vue            |  2 +-
 .../composables/useMissingModelDownload.ts    | 38 ++++++++-----------
 .../missingModel/missingModelDownload.test.ts | 19 ++++++----
 .../missingModel/missingModelDownload.ts      | 15 ++++----
 .../missingModel/missingModelStore.test.ts    | 12 ------
 9 files changed, 91 insertions(+), 60 deletions(-)

diff --git a/packages/comfyui-desktop-bridge-types/comfyDesktopBridge.d.ts b/packages/comfyui-desktop-bridge-types/comfyDesktopBridge.d.ts
index 629b3f0f2eb..c0ac768ae97 100644
--- a/packages/comfyui-desktop-bridge-types/comfyDesktopBridge.d.ts
+++ b/packages/comfyui-desktop-bridge-types/comfyDesktopBridge.d.ts
@@ -69,6 +69,7 @@ export interface ComfyDesktop2TelemetryBridge {
 }
 
 export interface ComfyDesktop2Bridge {
+  /** Reports whether the backend server is cloud/remote, not the user's location. */
   isRemote(): boolean
   /** Opens a model provider access page in the hosted frontend's browser session.
    *  Resolves `true` when the host accepts the request. */
diff --git a/src/platform/missingModel/components/MissingModelCard.test.ts b/src/platform/missingModel/components/MissingModelCard.test.ts
index 1e4ed26036d..7f0acf1f6f6 100644
--- a/src/platform/missingModel/components/MissingModelCard.test.ts
+++ b/src/platform/missingModel/components/MissingModelCard.test.ts
@@ -340,6 +340,23 @@ describe('MissingModelCard (OSS)', () => {
     )
   })
 
+  it('does not show gated guidance for a model that is not downloadable', async () => {
+    const group = makeGroup({
+      modelNames: ['model.bin'],
+      withDownloadUrls: true
+    })
+    const url = 'https://huggingface.co/comfy/test/resolve/main/model.bin'
+    mountCard({ missingModelGroups: [group] })
+
+    useMissingModelStore().gatedRepoUrls[url] =
+      'https://huggingface.co/comfy/test'
+    await nextTick()
+
+    expect(
+      screen.queryByTestId('missing-model-gated-hint')
+    ).not.toBeInTheDocument()
+  })
+
   it('routes Download all through the shared missing-model download handler', async () => {
     mountCard({
       missingModelGroups: [makeGroup({ withDownloadUrls: true })]
diff --git a/src/platform/missingModel/components/MissingModelCard.vue b/src/platform/missingModel/components/MissingModelCard.vue
index 7316ea07895..2fa646a6b91 100644
--- a/src/platform/missingModel/components/MissingModelCard.vue
+++ b/src/platform/missingModel/components/MissingModelCard.vue
@@ -3,7 +3,7 @@
     <div
       v-if="showGatedModelsHint"
       data-testid="missing-model-gated-hint"
-      role="alert"
+      role="status"
       class="mb-2 flex gap-2 rounded-md border border-warning-background/30 bg-warning-background/10 p-2.5"
     >
       <i
@@ -138,21 +138,18 @@ const unsupportedModelRows = computed(() =>
   isCloud ? sortedModelRows.value.filter((row) => !canCloudImport(row)) : []
 )
 
-const showGatedModelsHint = computed(
-  () =>
-    !isCloud &&
-    sortedModelRows.value.some((row) => {
-      const url = row.model.representative.url
-      return !!url && !!missingModelStore.gatedRepoUrls[url]
-    })
-)
-
 const downloadableModels = computed(() => {
   if (isCloud) return []
 
   return getDownloadableModels(missingModelGroups)
 })
 
+const showGatedModelsHint = computed(() =>
+  downloadableModels.value.some(
+    (model) => !!missingModelStore.gatedRepoUrls[model.url]
+  )
+)
+
 const downloadAllLabel = computed(() => {
   const base = t('rightSidePanel.missingModels.downloadAll')
   const total = downloadableModels.value.reduce(
diff --git a/src/platform/missingModel/components/MissingModelRow.test.ts b/src/platform/missingModel/components/MissingModelRow.test.ts
index 1019f1ae60c..9619839ee72 100644
--- a/src/platform/missingModel/components/MissingModelRow.test.ts
+++ b/src/platform/missingModel/components/MissingModelRow.test.ts
@@ -496,6 +496,36 @@ describe('MissingModelRow', () => {
     expect(mockOpenGatedRepoPage).not.toHaveBeenCalled()
   })
 
+  it('falls back when the Desktop bridge resolves false', async () => {
+    mockIsCloud.value = false
+    const user = userEvent.setup()
+    const openModelAccessPage = vi.fn().mockResolvedValue(false)
+    window.__comfyDesktop2 = {
+      isRemote: () => false,
+      openModelAccessPage
+    }
+    const model = makeModel([{ nodeId: '1', widgetName: 'ckpt_name' }])
+    model.representative.url =
+      'https://huggingface.co/bfl/FLUX.1/resolve/main/model.safetensors'
+
+    renderRow(model, vi.fn(), false)
+    const store = useMissingModelStore()
+    store.setGatedRepoUrl(
+      model.representative.url,
+      'https://huggingface.co/bfl/FLUX.1'
+    )
+    await nextTick()
+
+    await user.click(screen.getByTestId('missing-model-gated-access'))
+
+    expect(openModelAccessPage).toHaveBeenCalledWith(
+      'https://huggingface.co/bfl/FLUX.1'
+    )
+    expect(mockOpenGatedRepoPage).toHaveBeenCalledWith(
+      'https://huggingface.co/bfl/FLUX.1'
+    )
+  })
+
   it('shows unknown category metadata for models without a directory', () => {
     renderRow(
       makeModel([{ nodeId: '1', widgetName: 'ckpt_name' }]),
diff --git a/src/platform/missingModel/components/MissingModelRow.vue b/src/platform/missingModel/components/MissingModelRow.vue
index 08c8baee5f7..b7133c2e7a7 100644
--- a/src/platform/missingModel/components/MissingModelRow.vue
+++ b/src/platform/missingModel/components/MissingModelRow.vue
@@ -408,7 +408,7 @@ function handleDownload() {
 
 function handleOpenGatedRepo() {
   const repoUrl = gatedRepoUrl.value
-  if (repoUrl) openModelAccessPage(repoUrl)
+  if (repoUrl) void openModelAccessPage(repoUrl)
 }
 
 function handleLocatePrimary() {
diff --git a/src/platform/missingModel/composables/useMissingModelDownload.ts b/src/platform/missingModel/composables/useMissingModelDownload.ts
index 7456c54d923..5c06dcdeb07 100644
--- a/src/platform/missingModel/composables/useMissingModelDownload.ts
+++ b/src/platform/missingModel/composables/useMissingModelDownload.ts
@@ -12,19 +12,12 @@ export function useMissingModelDownload() {
   async function prefetchModelMetadata(url: string): Promise<void> {
     if (store.fileSizes[url] !== undefined || store.gatedRepoUrls[url]) return
 
-    try {
-      const metadata = await fetchModelMetadata(url)
-      if (metadata.fileSize !== null) {
-        store.setFileSize(url, metadata.fileSize)
-      }
-      if (metadata.gatedRepoUrl) {
-        store.setGatedRepoUrl(url, metadata.gatedRepoUrl)
-      }
-    } catch (error: unknown) {
-      console.warn(
-        `[MissingModelDownload] Failed to fetch metadata for ${url}:`,
-        error
-      )
+    const metadata = await fetchModelMetadata(url)
+    if (metadata.fileSize !== null) {
+      store.setFileSize(url, metadata.fileSize)
+    }
+    if (metadata.gatedRepoUrl) {
+      store.setGatedRepoUrl(url, metadata.gatedRepoUrl)
     }
   }
 
@@ -32,15 +25,16 @@ export function useMissingModelDownload() {
     downloadModel(model, store.folderPaths)
   }
 
-  function openModelAccessPage(repoUrl: string): void {
-    const desktopBridge = window.__comfyDesktop2
-    if (desktopBridge?.openModelAccessPage) {
-      void desktopBridge
-        .openModelAccessPage(repoUrl)
-        .catch((error: unknown) => {
-          console.error('Failed to open model access page in Desktop:', error)
-        })
-      return
+  // Use the bridge regardless of isRemote() so provider cookies land in the
+  // host session reused by downloads.
+  async function openModelAccessPage(repoUrl: string): Promise<void> {
+    const openInHost = window.__comfyDesktop2?.openModelAccessPage
+    if (openInHost) {
+      try {
+        if (await openInHost(repoUrl)) return
+      } catch (error: unknown) {
+        console.error('Failed to open model access page in Desktop:', error)
+      }
     }
 
     openGatedRepoPage(repoUrl)
diff --git a/src/platform/missingModel/missingModelDownload.test.ts b/src/platform/missingModel/missingModelDownload.test.ts
index 5aaad6d7de0..282f515648b 100644
--- a/src/platform/missingModel/missingModelDownload.test.ts
+++ b/src/platform/missingModel/missingModelDownload.test.ts
@@ -103,15 +103,18 @@ describe('fetchModelMetadata', () => {
     }
   )
 
-  it('does not treat HuggingFace 404/500 as gated', async () => {
-    fetchMock.mockResolvedValueOnce({ ok: false, status: 404 })
+  it.for([404, 500])(
+    'does not treat HuggingFace %s as gated',
+    async (status) => {
+      fetchMock.mockResolvedValueOnce({ ok: false, status })
 
-    const metadata = await fetchModelMetadata(
-      `https://huggingface.co/org/model/resolve/main/notfound-${testId}.safetensors`
-    )
-    expect(metadata.gatedRepoUrl).toBeNull()
-    expect(metadata.fileSize).toBeNull()
-  })
+      const metadata = await fetchModelMetadata(
+        `https://huggingface.co/org/model/resolve/main/not-gated-${status}-${testId}.safetensors`
+      )
+      expect(metadata.gatedRepoUrl).toBeNull()
+      expect(metadata.fileSize).toBeNull()
+    }
+  )
 
   it('does not treat non-HuggingFace hosts as gated', async () => {
     fetchMock.mockResolvedValueOnce({ ok: false, status: 403 })
diff --git a/src/platform/missingModel/missingModelDownload.ts b/src/platform/missingModel/missingModelDownload.ts
index d033e456449..f27d3a5e809 100644
--- a/src/platform/missingModel/missingModelDownload.ts
+++ b/src/platform/missingModel/missingModelDownload.ts
@@ -47,14 +47,19 @@ async function startDesktop2ModelDownload(
   }
 }
 
-export function openGatedRepoPage(url: string): void {
+function openUrlInNewTab(url: string, downloadAs?: string): void {
   const link = document.createElement('a')
   link.href = url
+  if (downloadAs) link.download = downloadAs
   link.target = '_blank'
   link.rel = 'noopener noreferrer'
   link.click()
 }
 
+export function openGatedRepoPage(url: string): void {
+  openUrlInNewTab(url)
+}
+
 function isHuggingFaceRepoUrl(url: string): boolean {
   try {
     return new URL(url).hostname.toLowerCase() === 'huggingface.co'
@@ -98,12 +103,7 @@ export function downloadModel(
   }
 
   if (!isDesktop) {
-    const link = document.createElement('a')
-    link.href = model.url
-    link.download = model.name
-    link.target = '_blank'
-    link.rel = 'noopener noreferrer'
-    link.click()
+    openUrlInNewTab(model.url, model.name)
     return
   }
 
@@ -169,6 +169,7 @@ const GATED_STATUS_CODES = new Set([401, 403, 451])
 
 async function fetchHeadMetadata(url: string): Promise<ModelMetadata> {
   try {
+    // Deliberately uncredentialed HEADs prevent re-checks from clearing gating.
     const response = await fetch(url, { method: 'HEAD' })
     if (!response.ok) {
       if (
diff --git a/src/platform/missingModel/missingModelStore.test.ts b/src/platform/missingModel/missingModelStore.test.ts
index 750f9ff24b4..087fe25e136 100644
--- a/src/platform/missingModel/missingModelStore.test.ts
+++ b/src/platform/missingModel/missingModelStore.test.ts
@@ -277,18 +277,6 @@ describe('missingModelStore', () => {
     })
   })
 
-  describe('setGatedRepoUrl', () => {
-    it('stores gated repo URLs by model download URL', () => {
-      const store = useMissingModelStore()
-      const url =
-        'https://huggingface.co/org/model/resolve/main/model.safetensors'
-
-      store.setGatedRepoUrl(url, 'https://huggingface.co/org/model')
-
-      expect(store.gatedRepoUrls[url]).toBe('https://huggingface.co/org/model')
-    })
-  })
-
   describe('isWidgetMissingModel', () => {
     it('returns true when specific widget has missing model', () => {
       const store = useMissingModelStore()

From 5a9db5c3684c911ddf29c231439840320b1ef942 Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Fri, 17 Jul 2026 20:28:51 +0900
Subject: [PATCH 3/9] test: cover the gated HuggingFace model flow end to end

The gated flow had no coverage above unit level. The classification is driven
purely by a HEAD response status and the shield, banner, and fallback are
ordinary DOM, so the parts this feature adds are reachable from Playwright even
though a real access grant is not.

Add three tests to the OSS missing-models spec:
- a 403 on the metadata HEAD classifies the model as gated and renders both the
  shield action and the card banner;
- Download stays visible and enabled on a gated row, alongside the shield;
- clicking the shield with no Desktop bridge opens the derived repository URL
  through the anchor fallback.

The stubbed 403 carries `Access-Control-Allow-Origin` because the HEAD is
cross-origin: without it the browser rejects the response, the classification
never runs, and the tests would pass or fail for reasons unrelated to the code
under test. Routing is registered on the browser context rather than the page so
the fallback popup's navigation is stubbed too.

Add a workflow fixture with a HuggingFace URL, since no existing one has a
download source that survives `isModelDownloadable()`, and register the two new
test IDs in the shared selectors.
---
 .../assets/missing/missing_models_gated.json  | 54 ++++++++++++++++
 browser_tests/fixtures/selectors.ts           |  2 +
 .../errorsTabMissingModels.spec.ts            | 63 +++++++++++++++++++
 3 files changed, 119 insertions(+)
 create mode 100644 browser_tests/assets/missing/missing_models_gated.json

diff --git a/browser_tests/assets/missing/missing_models_gated.json b/browser_tests/assets/missing/missing_models_gated.json
new file mode 100644
index 00000000000..650e9380c45
--- /dev/null
+++ b/browser_tests/assets/missing/missing_models_gated.json
@@ -0,0 +1,54 @@
+{
+  "last_node_id": 1,
+  "last_link_id": 1,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "CheckpointLoaderSimple",
+      "pos": [256, 256],
+      "size": [315, 98],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": null
+        },
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": null
+        },
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CheckpointLoaderSimple",
+        "models": [
+          {
+            "name": "gated_model.safetensors",
+            "url": "https://huggingface.co/comfy-e2e/gated-test/resolve/main/gated_model.safetensors",
+            "directory": "checkpoints"
+          }
+        ]
+      },
+      "widgets_values": ["gated_model.safetensors"]
+    }
+  ],
+  "links": [],
+  "groups": [],
+  "config": {},
+  "extra": {
+    "ds": {
+      "offset": [0, 0],
+      "scale": 1
+    }
+  },
+  "version": 0.4
+}
diff --git a/browser_tests/fixtures/selectors.ts b/browser_tests/fixtures/selectors.ts
index 541f4ffd978..66911126596 100644
--- a/browser_tests/fixtures/selectors.ts
+++ b/browser_tests/fixtures/selectors.ts
@@ -65,6 +65,8 @@ export const TestIds = {
     missingModelReferenceCount: 'missing-model-reference-count',
     missingModelUnsupportedSection:
       'missing-model-import-not-supported-section',
+    missingModelGatedAccess: 'missing-model-gated-access',
+    missingModelGatedHint: 'missing-model-gated-hint',
     missingModelDownload: 'missing-model-download',
     missingModelActions: 'missing-model-actions',
     missingModelDownloadAll: 'missing-model-download-all',
diff --git a/browser_tests/tests/propertiesPanel/errorsTabMissingModels.spec.ts b/browser_tests/tests/propertiesPanel/errorsTabMissingModels.spec.ts
index c41fd6145ec..5409738d385 100644
--- a/browser_tests/tests/propertiesPanel/errorsTabMissingModels.spec.ts
+++ b/browser_tests/tests/propertiesPanel/errorsTabMissingModels.spec.ts
@@ -13,6 +13,7 @@ import {
 } from '@e2e/fixtures/helpers/ErrorsTabHelper'
 
 const FAKE_MODEL_NAME = 'fake_model.safetensors'
+const GATED_MODEL_REPO_URL = 'https://huggingface.co/comfy-e2e/gated-test'
 
 function getModelLabel(group: Locator, modelName: string = FAKE_MODEL_NAME) {
   return group.getByRole('button', { name: modelName, exact: true })
@@ -160,5 +161,67 @@ test.describe('Errors tab - Missing models', { tag: '@ui' }, () => {
         comfyPage.page.getByTestId(TestIds.dialogs.missingModelsGroup)
       ).toBeHidden()
     })
+
+    test.describe('Gated Hugging Face model', { tag: '@ui' }, () => {
+      test.beforeEach(async ({ comfyPage }) => {
+        await comfyPage.page
+          .context()
+          .route('https://huggingface.co/**', async (route) => {
+            if (route.request().method() === 'HEAD') {
+              return route.fulfill({
+                status: 403,
+                headers: { 'Access-Control-Allow-Origin': '*' }
+              })
+            }
+
+            return route.fulfill({
+              status: 200,
+              contentType: 'text/html',
+              body: '<html><body>stub repo page</body></html>'
+            })
+          })
+        await loadWorkflowAndOpenErrorsTab(
+          comfyPage,
+          'missing/missing_models_gated'
+        )
+      })
+
+      test('Should classify a 403 model as gated', async ({ comfyPage }) => {
+        await expect(
+          comfyPage.page.getByTestId(TestIds.dialogs.missingModelGatedAccess)
+        ).toBeVisible()
+        await expect(
+          comfyPage.page.getByTestId(TestIds.dialogs.missingModelGatedHint)
+        ).toBeVisible()
+      })
+
+      test('Should keep Download available for a gated model', async ({
+        comfyPage
+      }) => {
+        await expect(
+          comfyPage.page.getByTestId(TestIds.dialogs.missingModelGatedAccess)
+        ).toBeVisible()
+
+        const downloadButton = comfyPage.page.getByTestId(
+          TestIds.dialogs.missingModelDownload
+        )
+
+        await expect(downloadButton).toBeVisible()
+        await expect(downloadButton).toBeEnabled()
+        await expect(downloadButton).toHaveText('Download')
+      })
+
+      test('Should open the gated repository with the browser fallback', async ({
+        comfyPage
+      }) => {
+        const pagePromise = comfyPage.page.context().waitForEvent('page')
+        await comfyPage.page
+          .getByTestId(TestIds.dialogs.missingModelGatedAccess)
+          .click()
+        const accessPage = await pagePromise
+
+        expect(accessPage.url()).toBe(GATED_MODEL_REPO_URL)
+      })
+    })
   })
 })

From 5dbac5b5c8d5c3116a06a19658be7fdd506486c2 Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Fri, 17 Jul 2026 20:40:10 +0900
Subject: [PATCH 4/9] test: cover the gated hint exclusion for undownloadable
 models

The card's gated banner is derived from downloadable models, while the pipeline
records gated repository URLs for any candidate that has a url and a directory.
Nothing above unit level pinned that difference, so a regression would restore
guidance to accept a license on rows that offer no way to act on it.

Add an OSS case for a gated model whose extension is excluded from download:
the row is listed as missing, the HuggingFace HEAD is still answered with 403,
and neither the banner, the shield, nor Download appears. Waiting on the HEAD
count before the absence assertions keeps them from passing merely because
classification had not run yet.
---
 .../missing_models_gated_unsupported.json     | 54 +++++++++++++++++++
 .../errorsTabMissingModels.spec.ts            | 45 ++++++++++++++++
 2 files changed, 99 insertions(+)
 create mode 100644 browser_tests/assets/missing/missing_models_gated_unsupported.json

diff --git a/browser_tests/assets/missing/missing_models_gated_unsupported.json b/browser_tests/assets/missing/missing_models_gated_unsupported.json
new file mode 100644
index 00000000000..7672d8daa36
--- /dev/null
+++ b/browser_tests/assets/missing/missing_models_gated_unsupported.json
@@ -0,0 +1,54 @@
+{
+  "last_node_id": 1,
+  "last_link_id": 1,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "CheckpointLoaderSimple",
+      "pos": [256, 256],
+      "size": [315, 98],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": null
+        },
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": null
+        },
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CheckpointLoaderSimple",
+        "models": [
+          {
+            "name": "gated_model.bin",
+            "url": "https://huggingface.co/comfy-e2e/gated-bin-test/resolve/main/gated_model.bin",
+            "directory": "checkpoints"
+          }
+        ]
+      },
+      "widgets_values": ["gated_model.bin"]
+    }
+  ],
+  "links": [],
+  "groups": [],
+  "config": {},
+  "extra": {
+    "ds": {
+      "offset": [0, 0],
+      "scale": 1
+    }
+  },
+  "version": 0.4
+}
diff --git a/browser_tests/tests/propertiesPanel/errorsTabMissingModels.spec.ts b/browser_tests/tests/propertiesPanel/errorsTabMissingModels.spec.ts
index 5409738d385..eda93858d4a 100644
--- a/browser_tests/tests/propertiesPanel/errorsTabMissingModels.spec.ts
+++ b/browser_tests/tests/propertiesPanel/errorsTabMissingModels.spec.ts
@@ -14,6 +14,7 @@ import {
 
 const FAKE_MODEL_NAME = 'fake_model.safetensors'
 const GATED_MODEL_REPO_URL = 'https://huggingface.co/comfy-e2e/gated-test'
+const UNSUPPORTED_MODEL_NAME = 'gated_model.bin'
 
 function getModelLabel(group: Locator, modelName: string = FAKE_MODEL_NAME) {
   return group.getByRole('button', { name: modelName, exact: true })
@@ -223,5 +224,49 @@ test.describe('Errors tab - Missing models', { tag: '@ui' }, () => {
         expect(accessPage.url()).toBe(GATED_MODEL_REPO_URL)
       })
     })
+
+    test.describe('Gated model with an unsupported extension', () => {
+      test('Should not show gated guidance when no row can act on it', async ({
+        comfyPage
+      }) => {
+        let gatedHeadRequests = 0
+        await comfyPage.page
+          .context()
+          .route('https://huggingface.co/**', async (route) => {
+            if (route.request().method() !== 'HEAD') return route.abort()
+
+            gatedHeadRequests += 1
+            return route.fulfill({
+              status: 403,
+              headers: { 'Access-Control-Allow-Origin': '*' }
+            })
+          })
+        await loadWorkflowAndOpenErrorsTab(
+          comfyPage,
+          'missing/missing_models_gated_unsupported'
+        )
+
+        const modelsGroup = comfyPage.page.getByTestId(
+          TestIds.dialogs.missingModelsGroup
+        )
+        await expect(
+          getModelLabel(modelsGroup, UNSUPPORTED_MODEL_NAME)
+        ).toBeVisible()
+
+        // The pipeline HEADs any candidate with a url and directory, so the
+        // gated response lands before the extension is ever considered.
+        await expect.poll(() => gatedHeadRequests).toBeGreaterThan(0)
+
+        await expect(
+          comfyPage.page.getByTestId(TestIds.dialogs.missingModelDownload)
+        ).toHaveCount(0)
+        await expect(
+          comfyPage.page.getByTestId(TestIds.dialogs.missingModelGatedAccess)
+        ).toHaveCount(0)
+        await expect(
+          comfyPage.page.getByTestId(TestIds.dialogs.missingModelGatedHint)
+        ).toHaveCount(0)
+      })
+    })
   })
 })

From 9e502a92eef74c73b9821013e0457ae9f9e19a35 Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Fri, 17 Jul 2026 23:09:00 +0900
Subject: [PATCH 5/9] fix: correct the access-page rationale and harden the
 gated tests

The comment defending the bridge call justified skipping the isRemote() check
by claiming the host session is reused by downloads. It is not: downloadModel
only takes the bridge when isRemote() is false, so the rationale was false in
the one branch it existed to defend. Skipping the check is still right, for a
different reason, and the comment now gives that reason.

The exclusion test polled a counter incremented when the route handler was
entered, which is before the response is sent, before the store is written, and
before a render. It caught the regression only because an earlier assertion
happened to leave enough time. Serve the gated response first and gate a
downloadable companion's metadata behind it, so a rendered size proves the
gated response was already consumed before the absence assertions run.

Await the popup URL instead of reading it off a page that may not have
navigated yet, and require an explicit true from the bridge rather than any
truthy value. Document what false obligates the caller to do, since the
contract only described the accepting case.
---
 .../missing_models_gated_unsupported.json     | 40 ++++++++++++++++++-
 .../errorsTabMissingModels.spec.ts            | 37 +++++++++++------
 .../comfyDesktopBridge.d.ts                   |  3 +-
 .../composables/useMissingModelDownload.ts    |  8 ++--
 4 files changed, 71 insertions(+), 17 deletions(-)

diff --git a/browser_tests/assets/missing/missing_models_gated_unsupported.json b/browser_tests/assets/missing/missing_models_gated_unsupported.json
index 7672d8daa36..6eaa092d6bb 100644
--- a/browser_tests/assets/missing/missing_models_gated_unsupported.json
+++ b/browser_tests/assets/missing/missing_models_gated_unsupported.json
@@ -1,5 +1,5 @@
 {
-  "last_node_id": 1,
+  "last_node_id": 2,
   "last_link_id": 1,
   "nodes": [
     {
@@ -39,6 +39,44 @@
         ]
       },
       "widgets_values": ["gated_model.bin"]
+    },
+    {
+      "id": 2,
+      "type": "CheckpointLoaderSimple",
+      "pos": [640, 256],
+      "size": [315, 98],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": null
+        },
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": null
+        },
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CheckpointLoaderSimple",
+        "models": [
+          {
+            "name": "companion_model.safetensors",
+            "url": "https://huggingface.co/comfy-e2e/companion-test/resolve/main/companion_model.safetensors",
+            "directory": "checkpoints"
+          }
+        ]
+      },
+      "widgets_values": ["companion_model.safetensors"]
     }
   ],
   "links": [],
diff --git a/browser_tests/tests/propertiesPanel/errorsTabMissingModels.spec.ts b/browser_tests/tests/propertiesPanel/errorsTabMissingModels.spec.ts
index eda93858d4a..946917faa67 100644
--- a/browser_tests/tests/propertiesPanel/errorsTabMissingModels.spec.ts
+++ b/browser_tests/tests/propertiesPanel/errorsTabMissingModels.spec.ts
@@ -221,7 +221,7 @@ test.describe('Errors tab - Missing models', { tag: '@ui' }, () => {
           .click()
         const accessPage = await pagePromise
 
-        expect(accessPage.url()).toBe(GATED_MODEL_REPO_URL)
+        await expect(accessPage).toHaveURL(GATED_MODEL_REPO_URL)
       })
     })
 
@@ -229,16 +229,33 @@ test.describe('Errors tab - Missing models', { tag: '@ui' }, () => {
       test('Should not show gated guidance when no row can act on it', async ({
         comfyPage
       }) => {
-        let gatedHeadRequests = 0
+        let releaseGatedHead: () => void
+        const gatedHeadServed = new Promise<void>((resolve) => {
+          releaseGatedHead = resolve
+        })
+
         await comfyPage.page
           .context()
           .route('https://huggingface.co/**', async (route) => {
             if (route.request().method() !== 'HEAD') return route.abort()
 
-            gatedHeadRequests += 1
+            if (route.request().url().endsWith('.bin')) {
+              await route.fulfill({
+                status: 403,
+                headers: { 'Access-Control-Allow-Origin': '*' }
+              })
+              releaseGatedHead()
+              return
+            }
+
+            await gatedHeadServed
             return route.fulfill({
-              status: 403,
-              headers: { 'Access-Control-Allow-Origin': '*' }
+              status: 200,
+              headers: {
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Expose-Headers': 'content-length',
+                'content-length': '1024'
+              }
             })
           })
         await loadWorkflowAndOpenErrorsTab(
@@ -252,14 +269,10 @@ test.describe('Errors tab - Missing models', { tag: '@ui' }, () => {
         await expect(
           getModelLabel(modelsGroup, UNSUPPORTED_MODEL_NAME)
         ).toBeVisible()
-
-        // The pipeline HEADs any candidate with a url and directory, so the
-        // gated response lands before the extension is ever considered.
-        await expect.poll(() => gatedHeadRequests).toBeGreaterThan(0)
-
         await expect(
-          comfyPage.page.getByTestId(TestIds.dialogs.missingModelDownload)
-        ).toHaveCount(0)
+          modelsGroup.getByText('checkpoints · 1 KB', { exact: true })
+        ).toBeVisible()
+
         await expect(
           comfyPage.page.getByTestId(TestIds.dialogs.missingModelGatedAccess)
         ).toHaveCount(0)
diff --git a/packages/comfyui-desktop-bridge-types/comfyDesktopBridge.d.ts b/packages/comfyui-desktop-bridge-types/comfyDesktopBridge.d.ts
index c0ac768ae97..51254a1f552 100644
--- a/packages/comfyui-desktop-bridge-types/comfyDesktopBridge.d.ts
+++ b/packages/comfyui-desktop-bridge-types/comfyDesktopBridge.d.ts
@@ -72,7 +72,8 @@ export interface ComfyDesktop2Bridge {
   /** Reports whether the backend server is cloud/remote, not the user's location. */
   isRemote(): boolean
   /** Opens a model provider access page in the hosted frontend's browser session.
-   *  Resolves `true` when the host accepts the request. */
+   *  Resolves `true` when the host has taken ownership of the request.
+   *  On `false` or rejection the frontend falls back to opening a new tab. */
   openModelAccessPage?: (url: string) => Promise<boolean>
   downloadModel?: (
     url: string,
diff --git a/src/platform/missingModel/composables/useMissingModelDownload.ts b/src/platform/missingModel/composables/useMissingModelDownload.ts
index 5c06dcdeb07..fe43dfc9981 100644
--- a/src/platform/missingModel/composables/useMissingModelDownload.ts
+++ b/src/platform/missingModel/composables/useMissingModelDownload.ts
@@ -25,13 +25,15 @@ export function useMissingModelDownload() {
     downloadModel(model, store.folderPaths)
   }
 
-  // Use the bridge regardless of isRemote() so provider cookies land in the
-  // host session reused by downloads.
+  // Always try the bridge: it opens in the user's Electron session. isRemote()
+  // describes the backend server, not the user, so it must not gate this. The
+  // anchor fallback inside Electron hits shell.openExternal and strands the
+  // provider cookies in the system browser.
   async function openModelAccessPage(repoUrl: string): Promise<void> {
     const openInHost = window.__comfyDesktop2?.openModelAccessPage
     if (openInHost) {
       try {
-        if (await openInHost(repoUrl)) return
+        if ((await openInHost(repoUrl)) === true) return
       } catch (error: unknown) {
         console.error('Failed to open model access page in Desktop:', error)
       }

From 0e7217aa5df8c94f8c47472b3d0b2fb0b072afdc Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Sat, 18 Jul 2026 00:45:57 +0900
Subject: [PATCH 6/9] fix: bind the access-page bridge call and cover Download
 all fully

Extracting openModelAccessPage into a local detached it from its receiver, so a
host that reads this on the method would throw and the flow would fall to the
system-browser anchor, stranding provider cookies. Call it on the bridge object.

The Download all test drove a single downloadable model, so it could not tell
"downloads all" from "downloads the first". Drive two models and assert each is
dispatched once with its own arguments; reducing the component to the first
model now fails the call count.
---
 .../components/MissingModelCard.test.ts       | 20 ++++++++++++++++---
 .../composables/useMissingModelDownload.ts    |  6 +++---
 2 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/src/platform/missingModel/components/MissingModelCard.test.ts b/src/platform/missingModel/components/MissingModelCard.test.ts
index 7f0acf1f6f6..0610d4c0aa1 100644
--- a/src/platform/missingModel/components/MissingModelCard.test.ts
+++ b/src/platform/missingModel/components/MissingModelCard.test.ts
@@ -359,15 +359,29 @@ describe('MissingModelCard (OSS)', () => {
 
   it('routes Download all through the shared missing-model download handler', async () => {
     mountCard({
-      missingModelGroups: [makeGroup({ withDownloadUrls: true })]
+      missingModelGroups: [
+        makeGroup({
+          withDownloadUrls: true,
+          modelNames: ['first.safetensors', 'second.safetensors']
+        })
+      ]
     })
 
     await userEvent.click(screen.getByTestId('missing-model-download-all'))
 
+    expect(mockDownloadModel).toHaveBeenCalledTimes(2)
+    expect(mockDownloadModel).toHaveBeenCalledWith(
+      {
+        name: 'first.safetensors',
+        url: 'https://huggingface.co/comfy/test/resolve/main/first.safetensors',
+        directory: 'checkpoints'
+      },
+      {}
+    )
     expect(mockDownloadModel).toHaveBeenCalledWith(
       {
-        name: 'model.safetensors',
-        url: 'https://huggingface.co/comfy/test/resolve/main/model.safetensors',
+        name: 'second.safetensors',
+        url: 'https://huggingface.co/comfy/test/resolve/main/second.safetensors',
         directory: 'checkpoints'
       },
       {}
diff --git a/src/platform/missingModel/composables/useMissingModelDownload.ts b/src/platform/missingModel/composables/useMissingModelDownload.ts
index fe43dfc9981..7813dfb8397 100644
--- a/src/platform/missingModel/composables/useMissingModelDownload.ts
+++ b/src/platform/missingModel/composables/useMissingModelDownload.ts
@@ -30,10 +30,10 @@ export function useMissingModelDownload() {
   // anchor fallback inside Electron hits shell.openExternal and strands the
   // provider cookies in the system browser.
   async function openModelAccessPage(repoUrl: string): Promise<void> {
-    const openInHost = window.__comfyDesktop2?.openModelAccessPage
-    if (openInHost) {
+    const bridge = window.__comfyDesktop2
+    if (bridge?.openModelAccessPage) {
       try {
-        if ((await openInHost(repoUrl)) === true) return
+        if ((await bridge.openModelAccessPage(repoUrl)) === true) return
       } catch (error: unknown) {
         console.error('Failed to open model access page in Desktop:', error)
       }

From d33c1dbb5d2235fdeae4d99cffc66507c72694e3 Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Sat, 18 Jul 2026 01:04:37 +0900
Subject: [PATCH 7/9] test: cover rejected model access bridge fallback

---
 .../components/MissingModelRow.test.ts        | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/src/platform/missingModel/components/MissingModelRow.test.ts b/src/platform/missingModel/components/MissingModelRow.test.ts
index 9619839ee72..d1fc8125562 100644
--- a/src/platform/missingModel/components/MissingModelRow.test.ts
+++ b/src/platform/missingModel/components/MissingModelRow.test.ts
@@ -526,6 +526,42 @@ describe('MissingModelRow', () => {
     )
   })
 
+  it('falls back when the Desktop bridge rejects', async () => {
+    mockIsCloud.value = false
+    const user = userEvent.setup()
+    const error = new Error('Desktop bridge unavailable')
+    const consoleErrorSpy = vi
+      .spyOn(console, 'error')
+      .mockImplementation(() => {})
+    window.__comfyDesktop2 = {
+      isRemote: () => false,
+      openModelAccessPage: vi.fn().mockRejectedValue(error)
+    }
+    const model = makeModel([{ nodeId: '1', widgetName: 'ckpt_name' }])
+    model.representative.url =
+      'https://huggingface.co/bfl/FLUX.1/resolve/main/model.safetensors'
+
+    renderRow(model, vi.fn(), false)
+    useMissingModelStore().setGatedRepoUrl(
+      model.representative.url,
+      'https://huggingface.co/bfl/FLUX.1'
+    )
+    await nextTick()
+
+    await user.click(screen.getByTestId('missing-model-gated-access'))
+
+    await waitFor(() => {
+      expect(mockOpenGatedRepoPage).toHaveBeenCalledWith(
+        'https://huggingface.co/bfl/FLUX.1'
+      )
+    })
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      'Failed to open model access page in Desktop:',
+      error
+    )
+    consoleErrorSpy.mockRestore()
+  })
+
   it('shows unknown category metadata for models without a directory', () => {
     renderRow(
       makeModel([{ nodeId: '1', widgetName: 'ckpt_name' }]),

From 33b18fcfcd64e1bc9efa51e41b91b3544d7dd6f9 Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Sat, 18 Jul 2026 02:45:48 +0900
Subject: [PATCH 8/9] fix: require explicit Hugging Face gated responses

---
 .../missing_models_gated_unsupported.json     | 92 -------------------
 .../errorsTabMissingModels.spec.ts            | 64 +------------
 .../components/MissingModelRow.test.ts        | 28 ++++--
 .../missingModel/missingModelDownload.test.ts | 22 ++++-
 .../missingModel/missingModelDownload.ts      |  4 +-
 5 files changed, 43 insertions(+), 167 deletions(-)
 delete mode 100644 browser_tests/assets/missing/missing_models_gated_unsupported.json

diff --git a/browser_tests/assets/missing/missing_models_gated_unsupported.json b/browser_tests/assets/missing/missing_models_gated_unsupported.json
deleted file mode 100644
index 6eaa092d6bb..00000000000
--- a/browser_tests/assets/missing/missing_models_gated_unsupported.json
+++ /dev/null
@@ -1,92 +0,0 @@
-{
-  "last_node_id": 2,
-  "last_link_id": 1,
-  "nodes": [
-    {
-      "id": 1,
-      "type": "CheckpointLoaderSimple",
-      "pos": [256, 256],
-      "size": [315, 98],
-      "flags": {},
-      "order": 0,
-      "mode": 0,
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "MODEL",
-          "type": "MODEL",
-          "links": null
-        },
-        {
-          "name": "CLIP",
-          "type": "CLIP",
-          "links": null
-        },
-        {
-          "name": "VAE",
-          "type": "VAE",
-          "links": null
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "CheckpointLoaderSimple",
-        "models": [
-          {
-            "name": "gated_model.bin",
-            "url": "https://huggingface.co/comfy-e2e/gated-bin-test/resolve/main/gated_model.bin",
-            "directory": "checkpoints"
-          }
-        ]
-      },
-      "widgets_values": ["gated_model.bin"]
-    },
-    {
-      "id": 2,
-      "type": "CheckpointLoaderSimple",
-      "pos": [640, 256],
-      "size": [315, 98],
-      "flags": {},
-      "order": 1,
-      "mode": 0,
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "MODEL",
-          "type": "MODEL",
-          "links": null
-        },
-        {
-          "name": "CLIP",
-          "type": "CLIP",
-          "links": null
-        },
-        {
-          "name": "VAE",
-          "type": "VAE",
-          "links": null
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "CheckpointLoaderSimple",
-        "models": [
-          {
-            "name": "companion_model.safetensors",
-            "url": "https://huggingface.co/comfy-e2e/companion-test/resolve/main/companion_model.safetensors",
-            "directory": "checkpoints"
-          }
-        ]
-      },
-      "widgets_values": ["companion_model.safetensors"]
-    }
-  ],
-  "links": [],
-  "groups": [],
-  "config": {},
-  "extra": {
-    "ds": {
-      "offset": [0, 0],
-      "scale": 1
-    }
-  },
-  "version": 0.4
-}
diff --git a/browser_tests/tests/propertiesPanel/errorsTabMissingModels.spec.ts b/browser_tests/tests/propertiesPanel/errorsTabMissingModels.spec.ts
index 946917faa67..0f912ce297e 100644
--- a/browser_tests/tests/propertiesPanel/errorsTabMissingModels.spec.ts
+++ b/browser_tests/tests/propertiesPanel/errorsTabMissingModels.spec.ts
@@ -14,7 +14,6 @@ import {
 
 const FAKE_MODEL_NAME = 'fake_model.safetensors'
 const GATED_MODEL_REPO_URL = 'https://huggingface.co/comfy-e2e/gated-test'
-const UNSUPPORTED_MODEL_NAME = 'gated_model.bin'
 
 function getModelLabel(group: Locator, modelName: string = FAKE_MODEL_NAME) {
   return group.getByRole('button', { name: modelName, exact: true })
@@ -171,7 +170,11 @@ test.describe('Errors tab - Missing models', { tag: '@ui' }, () => {
             if (route.request().method() === 'HEAD') {
               return route.fulfill({
                 status: 403,
-                headers: { 'Access-Control-Allow-Origin': '*' }
+                headers: {
+                  'Access-Control-Allow-Origin': '*',
+                  'Access-Control-Expose-Headers': 'X-Error-Code',
+                  'X-Error-Code': 'GatedRepo'
+                }
               })
             }
 
@@ -224,62 +227,5 @@ test.describe('Errors tab - Missing models', { tag: '@ui' }, () => {
         await expect(accessPage).toHaveURL(GATED_MODEL_REPO_URL)
       })
     })
-
-    test.describe('Gated model with an unsupported extension', () => {
-      test('Should not show gated guidance when no row can act on it', async ({
-        comfyPage
-      }) => {
-        let releaseGatedHead: () => void
-        const gatedHeadServed = new Promise<void>((resolve) => {
-          releaseGatedHead = resolve
-        })
-
-        await comfyPage.page
-          .context()
-          .route('https://huggingface.co/**', async (route) => {
-            if (route.request().method() !== 'HEAD') return route.abort()
-
-            if (route.request().url().endsWith('.bin')) {
-              await route.fulfill({
-                status: 403,
-                headers: { 'Access-Control-Allow-Origin': '*' }
-              })
-              releaseGatedHead()
-              return
-            }
-
-            await gatedHeadServed
-            return route.fulfill({
-              status: 200,
-              headers: {
-                'Access-Control-Allow-Origin': '*',
-                'Access-Control-Expose-Headers': 'content-length',
-                'content-length': '1024'
-              }
-            })
-          })
-        await loadWorkflowAndOpenErrorsTab(
-          comfyPage,
-          'missing/missing_models_gated_unsupported'
-        )
-
-        const modelsGroup = comfyPage.page.getByTestId(
-          TestIds.dialogs.missingModelsGroup
-        )
-        await expect(
-          getModelLabel(modelsGroup, UNSUPPORTED_MODEL_NAME)
-        ).toBeVisible()
-        await expect(
-          modelsGroup.getByText('checkpoints · 1 KB', { exact: true })
-        ).toBeVisible()
-
-        await expect(
-          comfyPage.page.getByTestId(TestIds.dialogs.missingModelGatedAccess)
-        ).toHaveCount(0)
-        await expect(
-          comfyPage.page.getByTestId(TestIds.dialogs.missingModelGatedHint)
-        ).toHaveCount(0)
-      })
-    })
   })
 })
diff --git a/src/platform/missingModel/components/MissingModelRow.test.ts b/src/platform/missingModel/components/MissingModelRow.test.ts
index d1fc8125562..374df9ed68a 100644
--- a/src/platform/missingModel/components/MissingModelRow.test.ts
+++ b/src/platform/missingModel/components/MissingModelRow.test.ts
@@ -1,7 +1,7 @@
 import { createPinia, setActivePinia } from 'pinia'
 import { render, screen, waitFor } from '@testing-library/vue'
 import userEvent from '@testing-library/user-event'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { nextTick } from 'vue'
 import { createI18n } from 'vue-i18n'
 
@@ -190,6 +190,10 @@ describe('MissingModelRow', () => {
     })
   })
 
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
   it('opens the model import dialog from the cloud row', async () => {
     const user = userEvent.setup()
     renderRow(makeModel([{ nodeId: '1', widgetName: 'ckpt_name' }]))
@@ -468,14 +472,20 @@ describe('MissingModelRow', () => {
     )
   })
 
-  it('delegates the gated repo action to the Desktop bridge when available', async () => {
+  it('delegates the gated repo action to the Desktop bridge with its receiver', async () => {
     mockIsCloud.value = false
     const user = userEvent.setup()
-    const openModelAccessPage = vi.fn().mockResolvedValue(true)
-    window.__comfyDesktop2 = {
-      isRemote: () => false,
-      openModelAccessPage
+    let receiver: unknown
+    let openedUrl: string | undefined
+    const bridge = {
+      isRemote: () => true,
+      async openModelAccessPage(this: unknown, url: string) {
+        receiver = this
+        openedUrl = url
+        return true
+      }
     }
+    window.__comfyDesktop2 = bridge
     const model = makeModel([{ nodeId: '1', widgetName: 'ckpt_name' }])
     model.representative.url =
       'https://huggingface.co/bfl/FLUX.1/resolve/main/model.safetensors'
@@ -490,9 +500,8 @@ describe('MissingModelRow', () => {
 
     await user.click(screen.getByTestId('missing-model-gated-access'))
 
-    expect(openModelAccessPage).toHaveBeenCalledWith(
-      'https://huggingface.co/bfl/FLUX.1'
-    )
+    expect(receiver).toBe(bridge)
+    expect(openedUrl).toBe('https://huggingface.co/bfl/FLUX.1')
     expect(mockOpenGatedRepoPage).not.toHaveBeenCalled()
   })
 
@@ -559,7 +568,6 @@ describe('MissingModelRow', () => {
       'Failed to open model access page in Desktop:',
       error
     )
-    consoleErrorSpy.mockRestore()
   })
 
   it('shows unknown category metadata for models without a directory', () => {
diff --git a/src/platform/missingModel/missingModelDownload.test.ts b/src/platform/missingModel/missingModelDownload.test.ts
index 282f515648b..8816b57d9e5 100644
--- a/src/platform/missingModel/missingModelDownload.test.ts
+++ b/src/platform/missingModel/missingModelDownload.test.ts
@@ -93,7 +93,11 @@ describe('fetchModelMetadata', () => {
   it.for([401, 403, 451])(
     'returns gatedRepoUrl for gated HuggingFace HEAD requests (%s)',
     async (status) => {
-      fetchMock.mockResolvedValueOnce({ ok: false, status })
+      fetchMock.mockResolvedValueOnce({
+        ok: false,
+        status,
+        headers: new Headers({ 'x-error-code': 'GatedRepo' })
+      })
 
       const metadata = await fetchModelMetadata(
         `https://huggingface.co/bfl/FLUX.1/resolve/main/gated-${status}-${testId}.safetensors`
@@ -103,10 +107,14 @@ describe('fetchModelMetadata', () => {
     }
   )
 
-  it.for([404, 500])(
-    'does not treat HuggingFace %s as gated',
+  it.for([401, 403, 451, 404, 500])(
+    'does not treat HuggingFace %s as gated without the GatedRepo error code',
     async (status) => {
-      fetchMock.mockResolvedValueOnce({ ok: false, status })
+      fetchMock.mockResolvedValueOnce({
+        ok: false,
+        status,
+        headers: new Headers()
+      })
 
       const metadata = await fetchModelMetadata(
         `https://huggingface.co/org/model/resolve/main/not-gated-${status}-${testId}.safetensors`
@@ -117,7 +125,11 @@ describe('fetchModelMetadata', () => {
   )
 
   it('does not treat non-HuggingFace hosts as gated', async () => {
-    fetchMock.mockResolvedValueOnce({ ok: false, status: 403 })
+    fetchMock.mockResolvedValueOnce({
+      ok: false,
+      status: 403,
+      headers: new Headers({ 'x-error-code': 'GatedRepo' })
+    })
 
     const metadata = await fetchModelMetadata(
       `https://huggingface.co.evil.com/org/model/resolve/main/gated-${testId}.safetensors`
diff --git a/src/platform/missingModel/missingModelDownload.ts b/src/platform/missingModel/missingModelDownload.ts
index f27d3a5e809..8976565e287 100644
--- a/src/platform/missingModel/missingModelDownload.ts
+++ b/src/platform/missingModel/missingModelDownload.ts
@@ -166,6 +166,7 @@ async function fetchCivitaiMetadata(url: string): Promise<ModelMetadata> {
 }
 
 const GATED_STATUS_CODES = new Set([401, 403, 451])
+const HUGGING_FACE_GATED_ERROR_CODE = 'GatedRepo'
 
 async function fetchHeadMetadata(url: string): Promise<ModelMetadata> {
   try {
@@ -174,7 +175,8 @@ async function fetchHeadMetadata(url: string): Promise<ModelMetadata> {
     if (!response.ok) {
       if (
         isHuggingFaceRepoUrl(url) &&
-        GATED_STATUS_CODES.has(response.status)
+        GATED_STATUS_CODES.has(response.status) &&
+        response.headers.get('x-error-code') === HUGGING_FACE_GATED_ERROR_CODE
       ) {
         return { fileSize: null, gatedRepoUrl: downloadUrlToHfRepoUrl(url) }
       }

From 7caff34ac65968246167b3c5e2ea48dc15adf173 Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Fri, 24 Jul 2026 14:27:46 +0900
Subject: [PATCH 9/9] fix: address gated model review feedback

---
 src/locales/en/main.json                      |   1 +
 .../components/MissingModelCard.test.ts       |   2 +-
 .../components/MissingModelCard.vue           |   2 +-
 .../components/MissingModelRow.test.ts        | 105 +-----------
 .../components/MissingModelRow.vue            |  27 ++-
 .../useMissingModelDownload.test.ts           | 160 ++++++++++++++++++
 .../composables/useMissingModelDownload.ts    |   3 +
 .../missingModel/missingModelDownload.test.ts |  73 +++++++-
 .../missingModel/missingModelDownload.ts      |  66 ++++++--
 9 files changed, 314 insertions(+), 125 deletions(-)
 create mode 100644 src/platform/missingModel/composables/useMissingModelDownload.test.ts

diff --git a/src/locales/en/main.json b/src/locales/en/main.json
index e3acf097ea3..3d0918a7671 100644
--- a/src/locales/en/main.json
+++ b/src/locales/en/main.json
@@ -4007,6 +4007,7 @@
       "copyUrl": "Copy URL",
       "gatedModelsHint": "Some models are gated. To download them, sign in to Hugging Face and accept the model license agreement.",
       "gatedModelTooltip": "This model is gated and requires you to be logged in to Hugging Face and to accept its license agreement.",
+      "gatedModelDownloadTooltip": "Download may require signing in to Hugging Face first.",
       "locateNode": "Locate node on canvas",
       "openHuggingFaceRepo": "Open Hugging Face repo",
       "expandNodes": "Show referencing nodes",
diff --git a/src/platform/missingModel/components/MissingModelCard.test.ts b/src/platform/missingModel/components/MissingModelCard.test.ts
index 0610d4c0aa1..65ab57db26e 100644
--- a/src/platform/missingModel/components/MissingModelCard.test.ts
+++ b/src/platform/missingModel/components/MissingModelCard.test.ts
@@ -335,7 +335,7 @@ describe('MissingModelCard (OSS)', () => {
       'https://huggingface.co/comfy/test'
     await nextTick()
 
-    expect(screen.getByTestId('missing-model-gated-hint')).toHaveTextContent(
+    expect(screen.getByRole('note')).toHaveTextContent(
       'Some models are gated. To download them, sign in to Hugging Face and accept the model license agreement.'
     )
   })
diff --git a/src/platform/missingModel/components/MissingModelCard.vue b/src/platform/missingModel/components/MissingModelCard.vue
index 2fa646a6b91..80c5bee2d1a 100644
--- a/src/platform/missingModel/components/MissingModelCard.vue
+++ b/src/platform/missingModel/components/MissingModelCard.vue
@@ -3,7 +3,7 @@
     <div
       v-if="showGatedModelsHint"
       data-testid="missing-model-gated-hint"
-      role="status"
+      role="note"
       class="mb-2 flex gap-2 rounded-md border border-warning-background/30 bg-warning-background/10 p-2.5"
     >
       <i
diff --git a/src/platform/missingModel/components/MissingModelRow.test.ts b/src/platform/missingModel/components/MissingModelRow.test.ts
index 374df9ed68a..35c8f19b18f 100644
--- a/src/platform/missingModel/components/MissingModelRow.test.ts
+++ b/src/platform/missingModel/components/MissingModelRow.test.ts
@@ -431,14 +431,19 @@ describe('MissingModelRow', () => {
 
     const gatedModelTooltip =
       'This model is gated and requires you to be logged in to Hugging Face and to accept its license agreement.'
+    const gatedModelDownloadTooltip =
+      'Download may require signing in to Hugging Face first.'
     expect(screen.getByTestId('missing-model-gated-access')).toHaveAttribute(
       'title',
       gatedModelTooltip
     )
     expect(screen.getByTestId('missing-model-download')).toHaveAttribute(
       'title',
-      gatedModelTooltip
+      gatedModelDownloadTooltip
     )
+    expect(
+      screen.getByTestId('missing-model-download')
+    ).toHaveAccessibleDescription(gatedModelDownloadTooltip)
   })
 
   it('opens gated repo action separately from the download action', async () => {
@@ -472,104 +477,6 @@ describe('MissingModelRow', () => {
     )
   })
 
-  it('delegates the gated repo action to the Desktop bridge with its receiver', async () => {
-    mockIsCloud.value = false
-    const user = userEvent.setup()
-    let receiver: unknown
-    let openedUrl: string | undefined
-    const bridge = {
-      isRemote: () => true,
-      async openModelAccessPage(this: unknown, url: string) {
-        receiver = this
-        openedUrl = url
-        return true
-      }
-    }
-    window.__comfyDesktop2 = bridge
-    const model = makeModel([{ nodeId: '1', widgetName: 'ckpt_name' }])
-    model.representative.url =
-      'https://huggingface.co/bfl/FLUX.1/resolve/main/model.safetensors'
-
-    renderRow(model, vi.fn(), false)
-    const store = useMissingModelStore()
-    store.setGatedRepoUrl(
-      model.representative.url,
-      'https://huggingface.co/bfl/FLUX.1'
-    )
-    await nextTick()
-
-    await user.click(screen.getByTestId('missing-model-gated-access'))
-
-    expect(receiver).toBe(bridge)
-    expect(openedUrl).toBe('https://huggingface.co/bfl/FLUX.1')
-    expect(mockOpenGatedRepoPage).not.toHaveBeenCalled()
-  })
-
-  it('falls back when the Desktop bridge resolves false', async () => {
-    mockIsCloud.value = false
-    const user = userEvent.setup()
-    const openModelAccessPage = vi.fn().mockResolvedValue(false)
-    window.__comfyDesktop2 = {
-      isRemote: () => false,
-      openModelAccessPage
-    }
-    const model = makeModel([{ nodeId: '1', widgetName: 'ckpt_name' }])
-    model.representative.url =
-      'https://huggingface.co/bfl/FLUX.1/resolve/main/model.safetensors'
-
-    renderRow(model, vi.fn(), false)
-    const store = useMissingModelStore()
-    store.setGatedRepoUrl(
-      model.representative.url,
-      'https://huggingface.co/bfl/FLUX.1'
-    )
-    await nextTick()
-
-    await user.click(screen.getByTestId('missing-model-gated-access'))
-
-    expect(openModelAccessPage).toHaveBeenCalledWith(
-      'https://huggingface.co/bfl/FLUX.1'
-    )
-    expect(mockOpenGatedRepoPage).toHaveBeenCalledWith(
-      'https://huggingface.co/bfl/FLUX.1'
-    )
-  })
-
-  it('falls back when the Desktop bridge rejects', async () => {
-    mockIsCloud.value = false
-    const user = userEvent.setup()
-    const error = new Error('Desktop bridge unavailable')
-    const consoleErrorSpy = vi
-      .spyOn(console, 'error')
-      .mockImplementation(() => {})
-    window.__comfyDesktop2 = {
-      isRemote: () => false,
-      openModelAccessPage: vi.fn().mockRejectedValue(error)
-    }
-    const model = makeModel([{ nodeId: '1', widgetName: 'ckpt_name' }])
-    model.representative.url =
-      'https://huggingface.co/bfl/FLUX.1/resolve/main/model.safetensors'
-
-    renderRow(model, vi.fn(), false)
-    useMissingModelStore().setGatedRepoUrl(
-      model.representative.url,
-      'https://huggingface.co/bfl/FLUX.1'
-    )
-    await nextTick()
-
-    await user.click(screen.getByTestId('missing-model-gated-access'))
-
-    await waitFor(() => {
-      expect(mockOpenGatedRepoPage).toHaveBeenCalledWith(
-        'https://huggingface.co/bfl/FLUX.1'
-      )
-    })
-    expect(consoleErrorSpy).toHaveBeenCalledWith(
-      'Failed to open model access page in Desktop:',
-      error
-    )
-  })
-
   it('shows unknown category metadata for models without a directory', () => {
     renderRow(
       makeModel([{ nodeId: '1', widgetName: 'ckpt_name' }]),
diff --git a/src/platform/missingModel/components/MissingModelRow.vue b/src/platform/missingModel/components/MissingModelRow.vue
index b7133c2e7a7..3042d40d7d1 100644
--- a/src/platform/missingModel/components/MissingModelRow.vue
+++ b/src/platform/missingModel/components/MissingModelRow.vue
@@ -145,11 +145,21 @@
           size="sm"
           class="shrink-0 focus-visible:ring-inset"
           :aria-label="`${t('g.download')} ${model.name}`"
-          :title="gatedModelTooltip"
+          :aria-describedby="
+            showGatedRepoAction ? gatedDownloadDescriptionId : undefined
+          "
+          :title="gatedModelDownloadTooltip"
           @click="handleDownload"
         >
           {{ t('g.download') }}
         </Button>
+        <span
+          v-if="showGatedRepoAction"
+          :id="gatedDownloadDescriptionId"
+          hidden
+        >
+          {{ gatedModelDownloadTooltip }}
+        </span>
       </template>
 
       <Button
@@ -208,7 +218,14 @@
 </template>
 
 <script setup lang="ts">
-import { computed, nextTick, onMounted, useTemplateRef, watch } from 'vue'
+import {
+  computed,
+  nextTick,
+  onMounted,
+  useId,
+  useTemplateRef,
+  watch
+} from 'vue'
 import { storeToRefs } from 'pinia'
 import { useI18n } from 'vue-i18n'
 import { cn } from '@comfyorg/tailwind-utils'
@@ -341,6 +358,12 @@ const gatedModelTooltip = computed(() =>
     ? t('rightSidePanel.missingModels.gatedModelTooltip')
     : undefined
 )
+const gatedModelDownloadTooltip = computed(() =>
+  showGatedRepoAction.value
+    ? t('rightSidePanel.missingModels.gatedModelDownloadTooltip')
+    : undefined
+)
+const gatedDownloadDescriptionId = useId()
 
 const downloadSizeLabel = computed(() => {
   if (!showDownloadAction.value) return undefined
diff --git a/src/platform/missingModel/composables/useMissingModelDownload.test.ts b/src/platform/missingModel/composables/useMissingModelDownload.test.ts
new file mode 100644
index 00000000000..f71bae4e0fd
--- /dev/null
+++ b/src/platform/missingModel/composables/useMissingModelDownload.test.ts
@@ -0,0 +1,160 @@
+import { createTestingPinia } from '@pinia/testing'
+import { setActivePinia } from 'pinia'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type * as MissingModelDownload from '@/platform/missingModel/missingModelDownload'
+import { useMissingModelStore } from '@/platform/missingModel/missingModelStore'
+
+const mocks = vi.hoisted(() => ({
+  downloadModel: vi.fn<typeof MissingModelDownload.downloadModel>(),
+  fetchModelMetadata: vi.fn<typeof MissingModelDownload.fetchModelMetadata>(),
+  isTrustedHuggingFaceUrl:
+    vi.fn<typeof MissingModelDownload.isTrustedHuggingFaceUrl>(),
+  openGatedRepoPage: vi.fn<typeof MissingModelDownload.openGatedRepoPage>()
+}))
+
+vi.mock('@/platform/missingModel/missingModelDownload', () => ({
+  downloadModel: mocks.downloadModel,
+  fetchModelMetadata: mocks.fetchModelMetadata,
+  isTrustedHuggingFaceUrl: mocks.isTrustedHuggingFaceUrl,
+  openGatedRepoPage: mocks.openGatedRepoPage
+}))
+
+import { useMissingModelDownload } from './useMissingModelDownload'
+
+const downloadUrl =
+  'https://huggingface.co/org/model/resolve/main/model.safetensors'
+const repoUrl = 'https://huggingface.co/org/model'
+
+describe('useMissingModelDownload', () => {
+  beforeEach(() => {
+    setActivePinia(createTestingPinia({ stubActions: false }))
+    vi.clearAllMocks()
+    delete window.__comfyDesktop2
+    mocks.isTrustedHuggingFaceUrl.mockImplementation((url) => url === repoUrl)
+    mocks.fetchModelMetadata.mockResolvedValue({
+      fileSize: null,
+      gatedRepoUrl: null
+    })
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('stores fetched file metadata', async () => {
+    mocks.fetchModelMetadata.mockResolvedValueOnce({
+      fileSize: 1024,
+      gatedRepoUrl: null
+    })
+
+    await useMissingModelDownload().prefetchModelMetadata(downloadUrl)
+
+    expect(useMissingModelStore().fileSizes[downloadUrl]).toBe(1024)
+  })
+
+  it('stores fetched gated repository metadata', async () => {
+    mocks.fetchModelMetadata.mockResolvedValueOnce({
+      fileSize: null,
+      gatedRepoUrl: repoUrl
+    })
+
+    await useMissingModelDownload().prefetchModelMetadata(downloadUrl)
+
+    expect(useMissingModelStore().gatedRepoUrls[downloadUrl]).toBe(repoUrl)
+  })
+
+  it('skips metadata already classified by the store', async () => {
+    const store = useMissingModelStore()
+    const sizedUrl = `${downloadUrl}?sized`
+    const gatedUrl = `${downloadUrl}?gated`
+    store.setFileSize(sizedUrl, 1024)
+    store.setGatedRepoUrl(gatedUrl, repoUrl)
+
+    const { prefetchModelMetadata } = useMissingModelDownload()
+    await prefetchModelMetadata(sizedUrl)
+    await prefetchModelMetadata(gatedUrl)
+
+    expect(mocks.fetchModelMetadata).not.toHaveBeenCalled()
+  })
+
+  it('downloads with the current missing-model folder paths', () => {
+    const store = useMissingModelStore()
+    store.setFolderPaths({ checkpoints: ['/models/checkpoints'] })
+    const model = {
+      name: 'model.safetensors',
+      url: downloadUrl,
+      directory: 'checkpoints'
+    }
+
+    useMissingModelDownload().downloadMissingModel(model)
+
+    expect(mocks.downloadModel).toHaveBeenCalledWith(model, {
+      checkpoints: ['/models/checkpoints']
+    })
+  })
+
+  it('opens a trusted access page through the Desktop bridge', async () => {
+    let receiver: unknown
+    let openedUrl: string | undefined
+    const bridge = {
+      isRemote: () => true,
+      async openModelAccessPage(this: unknown, url: string) {
+        receiver = this
+        openedUrl = url
+        return true
+      }
+    }
+    window.__comfyDesktop2 = bridge
+
+    await useMissingModelDownload().openModelAccessPage(repoUrl)
+
+    expect(receiver).toBe(bridge)
+    expect(openedUrl).toBe(repoUrl)
+    expect(mocks.openGatedRepoPage).not.toHaveBeenCalled()
+  })
+
+  it('falls back when the Desktop bridge declines the access page', async () => {
+    const openModelAccessPage = vi.fn().mockResolvedValue(false)
+    window.__comfyDesktop2 = {
+      isRemote: () => false,
+      openModelAccessPage
+    }
+
+    await useMissingModelDownload().openModelAccessPage(repoUrl)
+
+    expect(openModelAccessPage).toHaveBeenCalledWith(repoUrl)
+    expect(mocks.openGatedRepoPage).toHaveBeenCalledWith(repoUrl)
+  })
+
+  it('falls back when the Desktop bridge rejects the access page', async () => {
+    const error = new Error('Desktop bridge unavailable')
+    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
+    window.__comfyDesktop2 = {
+      isRemote: () => false,
+      openModelAccessPage: vi.fn().mockRejectedValue(error)
+    }
+
+    await useMissingModelDownload().openModelAccessPage(repoUrl)
+
+    expect(consoleError).toHaveBeenCalledWith(
+      'Failed to open model access page in Desktop:',
+      error
+    )
+    expect(mocks.openGatedRepoPage).toHaveBeenCalledWith(repoUrl)
+  })
+
+  it('rejects untrusted access page URLs before invoking a host', async () => {
+    const openModelAccessPage = vi.fn().mockResolvedValue(true)
+    window.__comfyDesktop2 = {
+      isRemote: () => false,
+      openModelAccessPage
+    }
+    await useMissingModelDownload().openModelAccessPage(
+      'https://example.com/org/model'
+    )
+
+    expect(openModelAccessPage).not.toHaveBeenCalled()
+    expect(mocks.openGatedRepoPage).not.toHaveBeenCalled()
+  })
+})
diff --git a/src/platform/missingModel/composables/useMissingModelDownload.ts b/src/platform/missingModel/composables/useMissingModelDownload.ts
index 7813dfb8397..b60b5f6fd98 100644
--- a/src/platform/missingModel/composables/useMissingModelDownload.ts
+++ b/src/platform/missingModel/composables/useMissingModelDownload.ts
@@ -1,6 +1,7 @@
 import {
   downloadModel,
   fetchModelMetadata,
+  isTrustedHuggingFaceUrl,
   openGatedRepoPage
 } from '@/platform/missingModel/missingModelDownload'
 import type { ModelWithUrl } from '@/platform/missingModel/missingModelDownload'
@@ -30,6 +31,8 @@ export function useMissingModelDownload() {
   // anchor fallback inside Electron hits shell.openExternal and strands the
   // provider cookies in the system browser.
   async function openModelAccessPage(repoUrl: string): Promise<void> {
+    if (!isTrustedHuggingFaceUrl(repoUrl)) return
+
     const bridge = window.__comfyDesktop2
     if (bridge?.openModelAccessPage) {
       try {
diff --git a/src/platform/missingModel/missingModelDownload.test.ts b/src/platform/missingModel/missingModelDownload.test.ts
index 8816b57d9e5..fc9621fbb75 100644
--- a/src/platform/missingModel/missingModelDownload.test.ts
+++ b/src/platform/missingModel/missingModelDownload.test.ts
@@ -4,6 +4,7 @@ import {
   downloadModel,
   fetchModelMetadata,
   isModelDownloadable,
+  isTrustedHuggingFaceUrl,
   openGatedRepoPage,
   toBrowsableUrl
 } from './missingModelDownload'
@@ -162,14 +163,25 @@ describe('fetchModelMetadata', () => {
     expect(fetchMock).toHaveBeenCalledTimes(1)
   })
 
-  it('does not cache incomplete results so retries are possible', async () => {
-    const url = `https://example.com/retry-${testId}.safetensors`
+  it('caches successful responses without content-length', async () => {
+    const url = `https://example.com/no-size-${testId}.safetensors`
+    fetchMock.mockResolvedValueOnce({
+      ok: true,
+      headers: new Headers({})
+    })
+
+    const first = await fetchModelMetadata(url)
+    const second = await fetchModelMetadata(url)
+
+    expect(first.fileSize).toBeNull()
+    expect(second.fileSize).toBeNull()
+    expect(fetchMock).toHaveBeenCalledTimes(1)
+  })
 
+  it('retries after a metadata request fails', async () => {
+    const url = `https://example.com/retry-${testId}.safetensors`
     fetchMock
-      .mockResolvedValueOnce({
-        ok: true,
-        headers: new Headers({})
-      })
+      .mockRejectedValueOnce(new TypeError('Failed to fetch'))
       .mockResolvedValueOnce({
         ok: true,
         headers: new Headers({ 'content-length': '1024' })
@@ -183,6 +195,24 @@ describe('fetchModelMetadata', () => {
     expect(fetchMock).toHaveBeenCalledTimes(2)
   })
 
+  it('retries after a non-ok HEAD response', async () => {
+    const url = `https://huggingface.co/org/model/resolve/main/retry-${testId}.safetensors`
+    fetchMock
+      .mockResolvedValueOnce({
+        ok: false,
+        status: 503,
+        headers: new Headers()
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers({ 'content-length': '1024' })
+      })
+
+    expect((await fetchModelMetadata(url)).fileSize).toBeNull()
+    expect((await fetchModelMetadata(url)).fileSize).toBe(1024)
+    expect(fetchMock).toHaveBeenCalledTimes(2)
+  })
+
   it('deduplicates concurrent requests for the same URL', async () => {
     const url = `https://huggingface.co/org/model/resolve/main/dedup-${testId}.safetensors`
 
@@ -202,6 +232,18 @@ describe('fetchModelMetadata', () => {
   })
 })
 
+describe('isTrustedHuggingFaceUrl', () => {
+  it.for([
+    { url: 'https://huggingface.co/org/model', expected: true },
+    { url: 'http://huggingface.co/org/model', expected: false },
+    { url: 'https://huggingface.co:8443/org/model', expected: false },
+    { url: 'https://huggingface.co.evil.com/org/model', expected: false },
+    { url: 'javascript:alert(1)', expected: false }
+  ] as const)('returns $expected for $url', ({ url, expected }) => {
+    expect(isTrustedHuggingFaceUrl(url)).toBe(expected)
+  })
+})
+
 describe('toBrowsableUrl', () => {
   it('replaces /resolve/ with /blob/ in HuggingFace URLs', () => {
     expect(
@@ -211,6 +253,14 @@ describe('toBrowsableUrl', () => {
     ).toBe('https://huggingface.co/org/model/blob/main/file.safetensors')
   })
 
+  it('keeps trust validation separate from URL formatting', () => {
+    expect(
+      toBrowsableUrl(
+        'http://huggingface.co/org/model/resolve/main/file.safetensors'
+      )
+    ).toBe('http://huggingface.co/org/model/blob/main/file.safetensors')
+  })
+
   it('returns non-HuggingFace URLs unchanged', () => {
     const url =
       'https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth'
@@ -271,6 +321,17 @@ describe('openGatedRepoPage', () => {
     expect(clickedAnchors[0]?.rel).toBe('noopener noreferrer')
     expect(clickedAnchors[0]?.getAttribute('download')).toBeNull()
   })
+
+  it('does not open untrusted URLs', () => {
+    const anchorClick = vi
+      .spyOn(HTMLAnchorElement.prototype, 'click')
+      .mockImplementation(() => {})
+
+    openGatedRepoPage('javascript:alert(1)')
+    openGatedRepoPage('https://example.com/org/model')
+
+    expect(anchorClick).not.toHaveBeenCalled()
+  })
 })
 
 describe('isModelDownloadable', () => {
diff --git a/src/platform/missingModel/missingModelDownload.ts b/src/platform/missingModel/missingModelDownload.ts
index 8976565e287..8ab3e460ca2 100644
--- a/src/platform/missingModel/missingModelDownload.ts
+++ b/src/platform/missingModel/missingModelDownload.ts
@@ -57,10 +57,11 @@ function openUrlInNewTab(url: string, downloadAs?: string): void {
 }
 
 export function openGatedRepoPage(url: string): void {
+  if (!isTrustedHuggingFaceUrl(url)) return
   openUrlInNewTab(url)
 }
 
-function isHuggingFaceRepoUrl(url: string): boolean {
+function hasHuggingFaceHost(url: string): boolean {
   try {
     return new URL(url).hostname.toLowerCase() === 'huggingface.co'
   } catch {
@@ -68,6 +69,14 @@ function isHuggingFaceRepoUrl(url: string): boolean {
   }
 }
 
+export function isTrustedHuggingFaceUrl(url: string): boolean {
+  try {
+    return new URL(url).origin === 'https://huggingface.co'
+  } catch {
+    return false
+  }
+}
+
 /**
  * Converts a model download URL to a browsable page URL.
  * - HuggingFace: `/resolve/` → `/blob/` (file page with model info)
@@ -77,7 +86,7 @@ export function toBrowsableUrl(url: string): string {
   if (isCivitaiModelUrl(url)) {
     return url.replace('/api/download/', '/').replace('/api/v1/', '/')
   }
-  if (isHuggingFaceRepoUrl(url)) {
+  if (hasHuggingFaceHost(url)) {
     return url.replace('/resolve/', '/blob/')
   }
   return url
@@ -123,6 +132,11 @@ interface ModelMetadata {
   gatedRepoUrl: string | null
 }
 
+interface MetadataFetchResult {
+  metadata: ModelMetadata
+  cacheable: boolean
+}
+
 interface CivitaiModelFile {
   sizeKB: number
   downloadUrl: string
@@ -168,29 +182,44 @@ async function fetchCivitaiMetadata(url: string): Promise<ModelMetadata> {
 const GATED_STATUS_CODES = new Set([401, 403, 451])
 const HUGGING_FACE_GATED_ERROR_CODE = 'GatedRepo'
 
-async function fetchHeadMetadata(url: string): Promise<ModelMetadata> {
+async function fetchHeadMetadata(url: string): Promise<MetadataFetchResult> {
   try {
     // Deliberately uncredentialed HEADs prevent re-checks from clearing gating.
     const response = await fetch(url, { method: 'HEAD' })
     if (!response.ok) {
       if (
-        isHuggingFaceRepoUrl(url) &&
+        isTrustedHuggingFaceUrl(url) &&
         GATED_STATUS_CODES.has(response.status) &&
         response.headers.get('x-error-code') === HUGGING_FACE_GATED_ERROR_CODE
       ) {
-        return { fileSize: null, gatedRepoUrl: downloadUrlToHfRepoUrl(url) }
+        return {
+          metadata: {
+            fileSize: null,
+            gatedRepoUrl: downloadUrlToHfRepoUrl(url)
+          },
+          cacheable: true
+        }
+      }
+      return {
+        metadata: { fileSize: null, gatedRepoUrl: null },
+        cacheable: false
       }
-      return { fileSize: null, gatedRepoUrl: null }
     }
     const size = response.headers.get('content-length')
     const parsedSize = size ? parseInt(size, 10) : null
     return {
-      fileSize:
-        parsedSize !== null && !Number.isNaN(parsedSize) ? parsedSize : null,
-      gatedRepoUrl: null
+      metadata: {
+        fileSize:
+          parsedSize !== null && !Number.isNaN(parsedSize) ? parsedSize : null,
+        gatedRepoUrl: null
+      },
+      cacheable: true
     }
   } catch {
-    return { fileSize: null, gatedRepoUrl: null }
+    return {
+      metadata: { fileSize: null, gatedRepoUrl: null },
+      cacheable: false
+    }
   }
 }
 
@@ -206,14 +235,19 @@ export async function fetchModelMetadata(url: string): Promise<ModelMetadata> {
   if (existing) return existing
 
   const promise = (async () => {
-    const metadata = isCivitaiModelUrl(url)
-      ? await fetchCivitaiMetadata(url)
-      : await fetchHeadMetadata(url)
+    if (isCivitaiModelUrl(url)) {
+      const metadata = await fetchCivitaiMetadata(url)
+      if (isComplete(metadata)) {
+        metadataCache.set(url, metadata)
+      }
+      return metadata
+    }
 
-    if (isComplete(metadata)) {
-      metadataCache.set(url, metadata)
+    const result = await fetchHeadMetadata(url)
+    if (result.cacheable) {
+      metadataCache.set(url, result.metadata)
     }
-    return metadata
+    return result.metadata
   })()
 
   inflight.set(url, promise)