feat(ComboWidget): add ability to have mapped inputs (#6585)

## Summary

1. Add a `getOptionLabel` option to `ComboWidget` so users of it can map
of custom labels to widget values. (e.g., `"My Photo" ->
"my_photo_1235.png"`).
2. Utilize this ability in Cloud environment to map user uploaded
filenames to their corresponding input asset.
3. Copious unit tests to make sure I didn't (AFAIK) break anything
during the refactoring portion of development.
4. Bonus: Scope model browser to only show in cloud distributions until
it's released elsewhere; should prevent some undesired UI behavior if a
user accidentally enables the assetAPI.

## Review Focus

Widget code: please double check the work there.

## Screenshots (if applicable)



https://github.com/user-attachments/assets/a94b3203-c87f-4285-b692-479996859a5a


┆Issue is synchronized with this [Notion
page](https://www.notion.so/PR-6585-Feat-input-mapping-2a26d73d365081faa667e49892c8d45a)
by [Unito](https://www.unito.io)

tests-ui/tests/renderer/extensions/vueNodes/widgets/composables/useComboWidget.test.ts

@@ -4,13 +4,61 @@ import { LGraphNode } from '@/lib/litegraph/src/litegraph'
 import type { IBaseWidget } from '@/lib/litegraph/src/types/widgets'
 import { useAssetBrowserDialog } from '@/platform/assets/composables/useAssetBrowserDialog'
 import { assetService } from '@/platform/assets/services/assetService'
+import type { AssetItem } from '@/platform/assets/schemas/assetSchema'
 import { useComboWidget } from '@/renderer/extensions/vueNodes/widgets/composables/useComboWidget'
 import type { InputSpec } from '@/schemas/nodeDef/nodeDefSchemaV2'
 
+// Mock factory using actual type
+function createMockAssetItem(overrides: Partial<AssetItem> = {}): AssetItem {
+  return {
+    id: 'test-asset-id',
+    name: 'test-image.png',
+    asset_hash: 'hash123',
+    size: 1024,
+    mime_type: 'image/png',
+    tags: ['input'],
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+    last_access_time: new Date().toISOString(),
+    ...overrides
+  }
+}
+
+// Use vi.hoisted() to ensure mock state is initialized before mocks
+const mockDistributionState = vi.hoisted(() => ({ isCloud: false }))
+const mockUpdateInputs = vi.hoisted(() => vi.fn(() => Promise.resolve()))
+const mockGetInputName = vi.hoisted(() => vi.fn((hash: string) => hash))
+const mockAssetsStoreState = vi.hoisted(() => {
+  const inputAssets: AssetItem[] = []
+  return {
+    inputAssets,
+    inputLoading: false
+  }
+})
+
 vi.mock('@/scripts/widgets', () => ({
   addValueControlWidgets: vi.fn()
 }))
 
+vi.mock('@/platform/distribution/types', () => ({
+  get isCloud() {
+    return mockDistributionState.isCloud
+  }
+}))
+
+vi.mock('@/stores/assetsStore', () => ({
+  useAssetsStore: vi.fn(() => ({
+    get inputAssets() {
+      return mockAssetsStoreState.inputAssets
+    },
+    get inputLoading() {
+      return mockAssetsStoreState.inputLoading
+    },
+    updateInputs: mockUpdateInputs,
+    getInputName: mockGetInputName
+  }))
+}))
+
 const mockSettingStoreGet = vi.fn(() => false)
 vi.mock('@/platform/settings/settingStore', () => ({
   useSettingStore: vi.fn(() => ({
@@ -42,7 +90,7 @@ vi.mock('@/platform/assets/composables/useAssetBrowserDialog', () => {
 // Test factory functions
 function createMockWidget(overrides: Partial<IBaseWidget> = {}): IBaseWidget {
   const mockCallback = vi.fn()
-  return {
+  const widget: IBaseWidget = {
     type: 'combo',
     options: {},
     name: 'testWidget',
@@ -50,7 +98,8 @@ function createMockWidget(overrides: Partial<IBaseWidget> = {}): IBaseWidget {
     callback: mockCallback,
     y: 0,
     ...overrides
-  } as IBaseWidget
+  }
+  return widget
 }
 
 function createMockNode(comfyClass = 'TestNode'): LGraphNode {
@@ -73,11 +122,12 @@ function createMockNode(comfyClass = 'TestNode'): LGraphNode {
 }
 
 function createMockInputSpec(overrides: Partial<InputSpec> = {}): InputSpec {
-  return {
+  const inputSpec: InputSpec = {
     type: 'COMBO',
     name: 'testInput',
     ...overrides
-  } as InputSpec
+  }
+  return inputSpec
 }
 
 describe('useComboWidget', () => {
@@ -86,6 +136,10 @@ describe('useComboWidget', () => {
     mockSettingStoreGet.mockReturnValue(false)
     vi.mocked(assetService.isAssetBrowserEligible).mockReturnValue(false)
     vi.mocked(useAssetBrowserDialog).mockClear()
+    mockDistributionState.isCloud = false
+    mockAssetsStoreState.inputAssets = []
+    mockAssetsStoreState.inputLoading = false
+    mockUpdateInputs.mockClear()
   })
 
   it('should handle undefined spec', () => {
@@ -110,6 +164,7 @@ describe('useComboWidget', () => {
   })
 
   it('should create normal combo widget when asset API is disabled', () => {
+    mockDistributionState.isCloud = true
     mockSettingStoreGet.mockReturnValue(false) // Asset API disabled
     vi.mocked(assetService.isAssetBrowserEligible).mockReturnValue(true) // Widget is eligible
 
@@ -137,6 +192,7 @@ describe('useComboWidget', () => {
   })
 
   it('should create asset browser widget when API enabled', () => {
+    mockDistributionState.isCloud = true
     mockSettingStoreGet.mockReturnValue(true)
     vi.mocked(assetService.isAssetBrowserEligible).mockReturnValue(true)
 
@@ -169,36 +225,8 @@ describe('useComboWidget', () => {
     expect(widget).toBe(mockWidget)
   })
 
-  it('should create asset browser widget with options when API enabled', () => {
-    mockSettingStoreGet.mockReturnValue(true)
-    vi.mocked(assetService.isAssetBrowserEligible).mockReturnValue(true)
-
-    const constructor = useComboWidget()
-    const mockWidget = createMockWidget({
-      type: 'asset',
-      name: 'ckpt_name',
-      value: 'model1.safetensors'
-    })
-    const mockNode = createMockNode('CheckpointLoaderSimple')
-    vi.mocked(mockNode.addWidget).mockReturnValue(mockWidget)
-    const inputSpec = createMockInputSpec({
-      name: 'ckpt_name',
-      options: ['model1.safetensors', 'model2.safetensors']
-    })
-
-    const widget = constructor(mockNode, inputSpec)
-
-    expect(mockNode.addWidget).toHaveBeenCalledWith(
-      'asset',
-      'ckpt_name',
-      'model1.safetensors',
-      expect.any(Function)
-    )
-    expect(mockSettingStoreGet).toHaveBeenCalledWith('Comfy.Assets.UseAssetAPI')
-    expect(widget).toBe(mockWidget)
-  })
-
-  it('should use asset browser widget even when inputSpec has a default value but no options', () => {
+  it('should create asset browser widget when default value provided without options', () => {
+    mockDistributionState.isCloud = true
     mockSettingStoreGet.mockReturnValue(true)
     vi.mocked(assetService.isAssetBrowserEligible).mockReturnValue(true)
 
@@ -229,6 +257,7 @@ describe('useComboWidget', () => {
   })
 
   it('should show Select model when asset widget has undefined current value', () => {
+    mockDistributionState.isCloud = true
     mockSettingStoreGet.mockReturnValue(true)
     vi.mocked(assetService.isAssetBrowserEligible).mockReturnValue(true)
 
@@ -256,4 +285,203 @@ describe('useComboWidget', () => {
     expect(mockSettingStoreGet).toHaveBeenCalledWith('Comfy.Assets.UseAssetAPI')
     expect(widget).toBe(mockWidget)
   })
+
+  describe('cloud input asset mapping', () => {
+    const HASH_FILENAME =
+      '72e786ff2a44d682c4294db0b7098e569832bc394efc6dad644e6ec85a78efb7.png'
+    const HASH_FILENAME_2 =
+      'a1b2c3d4e5f6789012345678901234567890abcdef1234567890abcdef123456.jpg'
+
+    it.each([
+      { nodeClass: 'LoadImage', inputName: 'image' },
+      { nodeClass: 'LoadVideo', inputName: 'video' },
+      { nodeClass: 'LoadAudio', inputName: 'audio' }
+    ])(
+      'should create combo widget with getOptionLabel for $nodeClass in cloud',
+      ({ nodeClass, inputName }) => {
+        mockDistributionState.isCloud = true
+
+        const constructor = useComboWidget()
+        const mockWidget = createMockWidget({
+          type: 'combo',
+          name: inputName,
+          value: HASH_FILENAME
+        })
+        const mockNode = createMockNode(nodeClass)
+        vi.mocked(mockNode.addWidget).mockReturnValue(mockWidget)
+        const inputSpec = createMockInputSpec({
+          name: inputName,
+          options: [HASH_FILENAME, HASH_FILENAME_2]
+        })
+
+        const widget = constructor(mockNode, inputSpec)
+
+        expect(mockNode.addWidget).toHaveBeenCalledWith(
+          'combo',
+          inputName,
+          HASH_FILENAME,
+          expect.any(Function),
+          expect.objectContaining({
+            values: [], // Empty initially, populated dynamically by Proxy
+            getOptionLabel: expect.any(Function)
+          })
+        )
+        expect(widget).toBe(mockWidget)
+      }
+    )
+
+    it("should format option labels using store's getInputName function", () => {
+      mockDistributionState.isCloud = true
+      mockGetInputName.mockReturnValue('Beautiful Sunset.png')
+
+      const constructor = useComboWidget()
+      const mockWidget = createMockWidget({
+        type: 'combo',
+        name: 'image',
+        value: HASH_FILENAME
+      })
+      const mockNode = createMockNode('LoadImage')
+      vi.mocked(mockNode.addWidget).mockReturnValue(mockWidget)
+      const inputSpec = createMockInputSpec({
+        name: 'image',
+        options: [HASH_FILENAME]
+      })
+
+      constructor(mockNode, inputSpec)
+
+      // Extract the injected getOptionLabel function with type narrowing
+      const addWidgetCall = vi.mocked(mockNode.addWidget).mock.calls[0]
+      const options = addWidgetCall[4]
+
+      if (typeof options !== 'object' || !options) {
+        throw new Error('Expected options to be an object')
+      }
+
+      if (!('getOptionLabel' in options)) {
+        throw new Error('Expected options to have getOptionLabel property')
+      }
+
+      if (typeof options.getOptionLabel !== 'function') {
+        throw new Error('Expected getOptionLabel to be a function')
+      }
+
+      // Test that the injected function calls getInputName
+      const result = options.getOptionLabel(HASH_FILENAME)
+      expect(mockGetInputName).toHaveBeenCalledWith(HASH_FILENAME)
+      expect(result).toBe('Beautiful Sunset.png')
+    })
+
+    it('should create normal combo widget for non-input nodes in cloud', () => {
+      mockDistributionState.isCloud = true
+
+      const constructor = useComboWidget()
+      const mockWidget = createMockWidget()
+      const mockNode = createMockNode('SomeOtherNode')
+      vi.mocked(mockNode.addWidget).mockReturnValue(mockWidget)
+      const inputSpec = createMockInputSpec({
+        name: 'option',
+        options: [HASH_FILENAME, HASH_FILENAME_2]
+      })
+
+      const widget = constructor(mockNode, inputSpec)
+
+      expect(mockNode.addWidget).toHaveBeenCalledWith(
+        'combo',
+        'option',
+        HASH_FILENAME,
+        expect.any(Function),
+        { values: [HASH_FILENAME, HASH_FILENAME_2] }
+      )
+      expect(widget).toBe(mockWidget)
+    })
+
+    it('should create normal combo widget for LoadImage in OSS', () => {
+      mockDistributionState.isCloud = false
+
+      const constructor = useComboWidget()
+      const mockWidget = createMockWidget()
+      const mockNode = createMockNode('LoadImage')
+      vi.mocked(mockNode.addWidget).mockReturnValue(mockWidget)
+      const inputSpec = createMockInputSpec({
+        name: 'image',
+        options: [HASH_FILENAME, HASH_FILENAME_2]
+      })
+
+      const widget = constructor(mockNode, inputSpec)
+
+      expect(mockNode.addWidget).toHaveBeenCalledWith(
+        'combo',
+        'image',
+        HASH_FILENAME,
+        expect.any(Function),
+        {
+          values: [HASH_FILENAME, HASH_FILENAME_2]
+        }
+      )
+      expect(widget).toBe(mockWidget)
+    })
+
+    it('should trigger lazy load for cloud input nodes', () => {
+      mockDistributionState.isCloud = true
+      mockAssetsStoreState.inputAssets = []
+      mockAssetsStoreState.inputLoading = false
+
+      const constructor = useComboWidget()
+      const mockWidget = createMockWidget({ type: 'combo' })
+      const mockNode = createMockNode('LoadImage')
+      vi.mocked(mockNode.addWidget).mockReturnValue(mockWidget)
+      const inputSpec = createMockInputSpec({
+        name: 'image',
+        options: [HASH_FILENAME]
+      })
+
+      constructor(mockNode, inputSpec)
+
+      expect(mockUpdateInputs).toHaveBeenCalledTimes(1)
+    })
+
+    it('should not trigger lazy load if assets already loading', () => {
+      mockDistributionState.isCloud = true
+      mockAssetsStoreState.inputAssets = []
+      mockAssetsStoreState.inputLoading = true
+
+      const constructor = useComboWidget()
+      const mockWidget = createMockWidget({ type: 'combo' })
+      const mockNode = createMockNode('LoadImage')
+      vi.mocked(mockNode.addWidget).mockReturnValue(mockWidget)
+      const inputSpec = createMockInputSpec({
+        name: 'image',
+        options: [HASH_FILENAME]
+      })
+
+      constructor(mockNode, inputSpec)
+
+      expect(mockUpdateInputs).not.toHaveBeenCalled()
+    })
+
+    it('should not trigger lazy load if assets already loaded', () => {
+      mockDistributionState.isCloud = true
+      mockAssetsStoreState.inputAssets = [
+        createMockAssetItem({
+          id: 'asset-123',
+          name: 'image1.png',
+          asset_hash: HASH_FILENAME
+        })
+      ]
+      mockAssetsStoreState.inputLoading = false
+
+      const constructor = useComboWidget()
+      const mockWidget = createMockWidget({ type: 'combo' })
+      const mockNode = createMockNode('LoadImage')
+      vi.mocked(mockNode.addWidget).mockReturnValue(mockWidget)
+      const inputSpec = createMockInputSpec({
+        name: 'image',
+        options: [HASH_FILENAME]
+      })
+
+      constructor(mockNode, inputSpec)
+
+      expect(mockUpdateInputs).not.toHaveBeenCalled()
+    })
+  })
 })

tests-ui/tests/services/assetService.test.ts

@@ -376,5 +376,48 @@ describe('assetService', () => {
       )
       expect(result).toEqual(testAssets)
     })
+
+    it('should accept custom limit via options', async () => {
+      const testAssets = [MOCK_ASSETS.checkpoints]
+      mockApiResponse(testAssets)
+
+      const result = await assetService.getAssetsByTag('input', false, {
+        limit: 100
+      })
+
+      expect(api.fetchApi).toHaveBeenCalledWith(
+        '/assets?include_tags=input&limit=100&include_public=false'
+      )
+      expect(result).toEqual(testAssets)
+    })
+
+    it('should accept custom offset via options', async () => {
+      const testAssets = [MOCK_ASSETS.loras]
+      mockApiResponse(testAssets)
+
+      const result = await assetService.getAssetsByTag('models', true, {
+        offset: 50
+      })
+
+      expect(api.fetchApi).toHaveBeenCalledWith(
+        '/assets?include_tags=models&limit=500&include_public=true&offset=50'
+      )
+      expect(result).toEqual(testAssets)
+    })
+
+    it('should accept both limit and offset via options', async () => {
+      const testAssets = [MOCK_ASSETS.checkpoints]
+      mockApiResponse(testAssets)
+
+      const result = await assetService.getAssetsByTag('input', false, {
+        limit: 100,
+        offset: 25
+      })
+
+      expect(api.fetchApi).toHaveBeenCalledWith(
+        '/assets?include_tags=input&limit=100&include_public=false&offset=25'
+      )
+      expect(result).toEqual(testAssets)
+    })
   })
 })

tests-ui/tests/store/assetsStore.test.ts

@@ -0,0 +1,157 @@
+import { createPinia, setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it } from 'vitest'
+
+import type { AssetItem } from '@/platform/assets/schemas/assetSchema'
+import { useAssetsStore } from '@/stores/assetsStore'
+
+const HASH_FILENAME =
+  '72e786ff2a44d682c4294db0b7098e569832bc394efc6dad644e6ec85a78efb7.png'
+const HASH_FILENAME_2 =
+  'a1b2c3d4e5f6789012345678901234567890abcdef1234567890abcdef123456.jpg'
+
+function createMockAssetItem(overrides: Partial<AssetItem> = {}): AssetItem {
+  return {
+    id: 'test-id',
+    name: 'test.png',
+    asset_hash: 'test-hash',
+    size: 1024,
+    tags: [],
+    created_at: '2024-01-01T00:00:00.000Z',
+    ...overrides
+  }
+}
+
+describe('assetsStore', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+  })
+
+  describe('input asset mapping helpers', () => {
+    it('should return name for valid asset_hash', () => {
+      const store = useAssetsStore()
+
+      store.inputAssets = [
+        createMockAssetItem({
+          name: 'Beautiful Sunset.png',
+          asset_hash: HASH_FILENAME
+        }),
+        createMockAssetItem({
+          name: 'Mountain Vista.jpg',
+          asset_hash: HASH_FILENAME_2
+        })
+      ]
+
+      expect(store.getInputName(HASH_FILENAME)).toBe('Beautiful Sunset.png')
+      expect(store.getInputName(HASH_FILENAME_2)).toBe('Mountain Vista.jpg')
+    })
+
+    it('should return original hash when no matching asset found', () => {
+      const store = useAssetsStore()
+
+      store.inputAssets = [
+        createMockAssetItem({
+          name: 'Beautiful Sunset.png',
+          asset_hash: HASH_FILENAME
+        })
+      ]
+
+      const unknownHash =
+        'fffffffffffffffffffffffffffuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu.png'
+      expect(store.getInputName(unknownHash)).toBe(unknownHash)
+    })
+
+    it('should return hash as-is when no assets loaded', () => {
+      const store = useAssetsStore()
+
+      store.inputAssets = []
+
+      expect(store.getInputName(HASH_FILENAME)).toBe(HASH_FILENAME)
+    })
+
+    it('should ignore assets without asset_hash', () => {
+      const store = useAssetsStore()
+
+      store.inputAssets = [
+        createMockAssetItem({
+          name: 'Beautiful Sunset.png',
+          asset_hash: HASH_FILENAME
+        }),
+        createMockAssetItem({
+          name: 'No Hash Asset.jpg',
+          asset_hash: null
+        })
+      ]
+
+      // Should find first asset
+      expect(store.getInputName(HASH_FILENAME)).toBe('Beautiful Sunset.png')
+      // Map should only contain one entry
+      expect(store.inputAssetsByFilename.size).toBe(1)
+    })
+  })
+
+  describe('inputAssetsByFilename computed', () => {
+    it('should create map keyed by asset_hash', () => {
+      const store = useAssetsStore()
+
+      store.inputAssets = [
+        createMockAssetItem({
+          id: 'asset-123',
+          name: 'Beautiful Sunset.png',
+          asset_hash: HASH_FILENAME
+        }),
+        createMockAssetItem({
+          id: 'asset-456',
+          name: 'Mountain Vista.jpg',
+          asset_hash: HASH_FILENAME_2
+        })
+      ]
+
+      const map = store.inputAssetsByFilename
+
+      expect(map.size).toBe(2)
+      expect(map.get(HASH_FILENAME)).toMatchObject({
+        id: 'asset-123',
+        name: 'Beautiful Sunset.png',
+        asset_hash: HASH_FILENAME
+      })
+      expect(map.get(HASH_FILENAME_2)).toMatchObject({
+        id: 'asset-456',
+        name: 'Mountain Vista.jpg',
+        asset_hash: HASH_FILENAME_2
+      })
+    })
+
+    it('should exclude assets with null/undefined hash from map', () => {
+      const store = useAssetsStore()
+
+      store.inputAssets = [
+        createMockAssetItem({
+          name: 'Has Hash.png',
+          asset_hash: HASH_FILENAME
+        }),
+        createMockAssetItem({
+          name: 'Null Hash.jpg',
+          asset_hash: null
+        }),
+        createMockAssetItem({
+          name: 'Undefined Hash.jpg',
+          asset_hash: undefined
+        })
+      ]
+
+      const map = store.inputAssetsByFilename
+
+      // Only asset with valid asset_hash should be in map
+      expect(map.size).toBe(1)
+      expect(map.has(HASH_FILENAME)).toBe(true)
+    })
+
+    it('should return empty map when no assets loaded', () => {
+      const store = useAssetsStore()
+
+      store.inputAssets = []
+
+      expect(store.inputAssetsByFilename.size).toBe(0)
+    })
+  })
+})