-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
-
-
diff --git a/src/platform/cloud/onboarding/survey/DynamicSurveyField.vue b/src/platform/cloud/onboarding/survey/DynamicSurveyField.vue
new file mode 100644
index 0000000000..8148d00089
--- /dev/null
+++ b/src/platform/cloud/onboarding/survey/DynamicSurveyField.vue
@@ -0,0 +1,161 @@
+
+
+
+
+
+
{{ errorMessage }}
+
+
+
diff --git a/src/platform/cloud/onboarding/survey/DynamicSurveyForm.test.ts b/src/platform/cloud/onboarding/survey/DynamicSurveyForm.test.ts
new file mode 100644
index 0000000000..72d91d24d0
--- /dev/null
+++ b/src/platform/cloud/onboarding/survey/DynamicSurveyForm.test.ts
@@ -0,0 +1,320 @@
+import userEvent from '@testing-library/user-event'
+import { render, screen } from '@testing-library/vue'
+import PrimeVue from 'primevue/config'
+import { describe, expect, it } from 'vitest'
+import { createI18n } from 'vue-i18n'
+
+import type { OnboardingSurvey } from '@/platform/remoteConfig/types'
+
+import DynamicSurveyForm from './DynamicSurveyForm.vue'
+
+const flushPromises = () => new Promise((resolve) => setTimeout(resolve, 0))
+
+const i18n = createI18n({
+ legacy: false,
+ locale: 'en',
+ messages: {
+ en: {
+ g: { back: 'Back', next: 'Next', submit: 'Submit' },
+ cloudOnboarding: {
+ survey: {
+ intro: 'Help us tailor your ComfyUI experience.',
+ errors: {
+ chooseAnOption: 'Please choose an option.',
+ selectAtLeastOne: 'Please select at least one option.',
+ describeAnswer: 'Please describe your answer.'
+ }
+ }
+ }
+ }
+ }
+})
+
+const renderForm = (survey: OnboardingSurvey) =>
+ render(DynamicSurveyForm, {
+ global: { plugins: [PrimeVue, i18n] },
+ props: { survey }
+ })
+
+const twoStepSurvey: OnboardingSurvey = {
+ version: 1,
+ introKey: 'cloudOnboarding.survey.intro',
+ fields: [
+ {
+ id: 'usage',
+ type: 'single',
+ label: 'How do you plan to use ComfyUI?',
+ required: true,
+ options: [
+ { value: 'personal', label: 'Personal use' },
+ { value: 'work', label: 'Work' }
+ ]
+ },
+ {
+ id: 'intent',
+ type: 'multi',
+ label: 'What do you want to create with ComfyUI?',
+ required: true,
+ options: [
+ { value: 'images', label: 'Images' },
+ { value: 'videos', label: 'Videos' }
+ ]
+ }
+ ]
+}
+
+describe('DynamicSurveyForm', () => {
+ it('renders the intro text and the first field options', () => {
+ renderForm(twoStepSurvey)
+
+ expect(
+ screen.getByText('Help us tailor your ComfyUI experience.')
+ ).toBeInTheDocument()
+ expect(screen.getByText('How do you plan to use ComfyUI?')).toBeVisible()
+ expect(screen.getByLabelText('Personal use')).toBeInTheDocument()
+ expect(screen.getByLabelText('Work')).toBeInTheDocument()
+ })
+
+ it('disables Next until the user selects an option, then advances', async () => {
+ const user = userEvent.setup()
+ renderForm(twoStepSurvey)
+
+ const next = screen.getByRole('button', { name: 'Next' })
+ expect(next).toBeDisabled()
+
+ await user.click(screen.getByLabelText('Personal use'))
+ expect(next).toBeEnabled()
+
+ await user.click(next)
+ await flushPromises()
+
+ expect(
+ screen.getByText('What do you want to create with ComfyUI?')
+ ).toBeVisible()
+ expect(screen.getByLabelText('Images')).toBeInTheDocument()
+ expect(screen.getByRole('button', { name: 'Back' })).toBeInTheDocument()
+ })
+
+ it('navigates back to the previous step', async () => {
+ const user = userEvent.setup()
+ renderForm(twoStepSurvey)
+
+ await user.click(screen.getByLabelText('Personal use'))
+ await user.click(screen.getByRole('button', { name: 'Next' }))
+ await flushPromises()
+ expect(
+ screen.getByText('What do you want to create with ComfyUI?')
+ ).toBeVisible()
+
+ await user.click(screen.getByRole('button', { name: 'Back' }))
+ await flushPromises()
+ expect(screen.getByText('How do you plan to use ComfyUI?')).toBeVisible()
+ })
+
+ it('resolves option and field labels via labelKey when provided', () => {
+ const localizedI18n = createI18n({
+ legacy: false,
+ locale: 'en',
+ messages: {
+ en: {
+ g: { back: 'Back', next: 'Next', submit: 'Submit' },
+ cloudOnboarding: {
+ survey: {
+ intro: 'Help us tailor your ComfyUI experience.',
+ errors: {
+ chooseAnOption: '',
+ selectAtLeastOne: '',
+ describeAnswer: ''
+ }
+ }
+ },
+ survey_label: 'Localized question?',
+ survey_a: 'Localized A',
+ survey_b: 'Localized B'
+ }
+ }
+ })
+
+ render(DynamicSurveyForm, {
+ global: { plugins: [PrimeVue, localizedI18n] },
+ props: {
+ survey: {
+ version: 1,
+ fields: [
+ {
+ id: 'q',
+ type: 'single',
+ labelKey: 'survey_label',
+ required: true,
+ options: [
+ { value: 'a', labelKey: 'survey_a' },
+ { value: 'b', labelKey: 'survey_b' }
+ ]
+ }
+ ]
+ }
+ }
+ })
+
+ expect(screen.getByText('Localized question?')).toBeVisible()
+ expect(screen.getByLabelText('Localized A')).toBeInTheDocument()
+ expect(screen.getByLabelText('Localized B')).toBeInTheDocument()
+ })
+
+ it('renders server-supplied translations from a label locale map', () => {
+ const koreanI18n = createI18n({
+ legacy: false,
+ locale: 'ko',
+ fallbackLocale: 'en',
+ messages: {
+ en: {
+ g: { back: 'Back', next: 'Next', submit: 'Submit' },
+ cloudOnboarding: {
+ survey: {
+ intro: '',
+ errors: {
+ chooseAnOption: '',
+ selectAtLeastOne: '',
+ describeAnswer: ''
+ }
+ }
+ }
+ },
+ ko: { g: { back: '뒤로', next: '다음', submit: '제출' } }
+ }
+ })
+
+ render(DynamicSurveyForm, {
+ global: { plugins: [PrimeVue, koreanI18n] },
+ props: {
+ survey: {
+ version: 1,
+ fields: [
+ {
+ id: 'usage',
+ type: 'single',
+ label: {
+ en: 'How will you use it?',
+ ko: '어떻게 사용하시겠어요?'
+ },
+ required: true,
+ options: [
+ {
+ value: 'personal',
+ label: { en: 'Personal use', ko: '개인 용도' }
+ },
+ { value: 'work', label: { en: 'Work', ko: '업무' } }
+ ]
+ }
+ ]
+ }
+ }
+ })
+
+ expect(screen.getByText('어떻게 사용하시겠어요?')).toBeVisible()
+ expect(screen.getByLabelText('개인 용도')).toBeInTheDocument()
+ expect(screen.getByLabelText('업무')).toBeInTheDocument()
+ })
+
+ it('falls back to English when current locale missing from label map', () => {
+ const fallbackI18n = createI18n({
+ legacy: false,
+ locale: 'fr',
+ fallbackLocale: 'en',
+ messages: {
+ en: {
+ g: { back: 'Back', next: 'Next', submit: 'Submit' },
+ cloudOnboarding: {
+ survey: {
+ intro: '',
+ errors: {
+ chooseAnOption: '',
+ selectAtLeastOne: '',
+ describeAnswer: ''
+ }
+ }
+ }
+ },
+ fr: {}
+ }
+ })
+
+ render(DynamicSurveyForm, {
+ global: { plugins: [PrimeVue, fallbackI18n] },
+ props: {
+ survey: {
+ version: 1,
+ fields: [
+ {
+ id: 'q',
+ type: 'single',
+ label: { en: 'English question', ko: '한국어' },
+ required: true,
+ options: [
+ { value: 'a', label: { en: 'English A', ko: '한국어 A' } }
+ ]
+ }
+ ]
+ }
+ }
+ })
+
+ // fr is not in the map → falls back to en
+ expect(screen.getByText('English question')).toBeVisible()
+ expect(screen.getByLabelText('English A')).toBeInTheDocument()
+ })
+
+ it('allows advancing past an optional field while still empty', async () => {
+ const user = userEvent.setup()
+ render(DynamicSurveyForm, {
+ global: { plugins: [PrimeVue, i18n] },
+ props: {
+ survey: {
+ version: 1,
+ fields: [
+ {
+ id: 'q1',
+ type: 'single',
+ label: 'Optional question?',
+ options: [
+ { value: 'a', label: 'A' },
+ { value: 'b', label: 'B' }
+ ]
+ // no required: true — should be skippable
+ },
+ {
+ id: 'q2',
+ type: 'single',
+ label: 'Required question?',
+ required: true,
+ options: [{ value: 'c', label: 'C' }]
+ }
+ ]
+ }
+ }
+ })
+
+ const next = screen.getByRole('button', { name: 'Next' })
+ expect(next).toBeEnabled()
+
+ await user.click(next)
+ await flushPromises()
+ expect(screen.getByText('Required question?')).toBeVisible()
+ })
+
+ it('enables Submit only after the multi-select field has at least one choice', async () => {
+ const user = userEvent.setup()
+ renderForm(twoStepSurvey)
+
+ await user.click(screen.getByLabelText('Work'))
+ await user.click(screen.getByRole('button', { name: 'Next' }))
+ await flushPromises()
+
+ const submitBtn = screen.getByRole('button', { name: 'Submit' })
+ expect(submitBtn).toBeDisabled()
+
+ await user.click(screen.getByRole('checkbox', { name: /Images/i }))
+ await flushPromises()
+ expect(submitBtn).toBeEnabled()
+ })
+})
diff --git a/src/platform/cloud/onboarding/survey/DynamicSurveyForm.vue b/src/platform/cloud/onboarding/survey/DynamicSurveyForm.vue
new file mode 100644
index 0000000000..9ed1148a72
--- /dev/null
+++ b/src/platform/cloud/onboarding/survey/DynamicSurveyForm.vue
@@ -0,0 +1,212 @@
+
+
+
+
+
diff --git a/src/platform/cloud/onboarding/survey/defaultSurveySchema.ts b/src/platform/cloud/onboarding/survey/defaultSurveySchema.ts
new file mode 100644
index 0000000000..69c05ce5e7
--- /dev/null
+++ b/src/platform/cloud/onboarding/survey/defaultSurveySchema.ts
@@ -0,0 +1,76 @@
+import type { OnboardingSurvey } from '@/platform/remoteConfig/types'
+
+const optionsFor = (
+ fieldId: string,
+ values: string[]
+): { value: string; labelKey: string }[] =>
+ values.map((value) => ({
+ value,
+ labelKey: `cloudOnboarding.survey.options.${fieldId}.${value}`
+ }))
+
+export const defaultOnboardingSurvey: OnboardingSurvey = {
+ version: 2,
+ introKey: 'cloudOnboarding.survey.intro',
+ fields: [
+ {
+ id: 'usage',
+ type: 'single',
+ labelKey: 'cloudSurvey_steps_usage',
+ required: true,
+ options: optionsFor('usage', ['personal', 'work', 'education'])
+ },
+ {
+ id: 'familiarity',
+ type: 'single',
+ labelKey: 'cloudSurvey_steps_familiarity',
+ required: true,
+ options: optionsFor('familiarity', [
+ 'new',
+ 'starting',
+ 'basics',
+ 'advanced',
+ 'expert'
+ ])
+ },
+ {
+ id: 'intent',
+ type: 'multi',
+ labelKey: 'cloudSurvey_steps_intent',
+ required: true,
+ randomize: true,
+ options: optionsFor('intent', [
+ 'workflows',
+ 'custom_nodes',
+ 'videos',
+ 'images',
+ '3d_game',
+ 'audio',
+ 'apps',
+ 'api',
+ 'not_sure'
+ ])
+ },
+ {
+ id: 'source',
+ type: 'single',
+ labelKey: 'cloudSurvey_steps_source',
+ required: true,
+ randomize: true,
+ options: optionsFor('source', [
+ 'youtube',
+ 'reddit',
+ 'twitter',
+ 'instagram',
+ 'linkedin',
+ 'friend',
+ 'search',
+ 'newsletter',
+ 'conference',
+ 'discord',
+ 'github',
+ 'other'
+ ])
+ }
+ ]
+}
diff --git a/src/platform/cloud/onboarding/survey/surveySchema.test.ts b/src/platform/cloud/onboarding/survey/surveySchema.test.ts
new file mode 100644
index 0000000000..1695c85132
--- /dev/null
+++ b/src/platform/cloud/onboarding/survey/surveySchema.test.ts
@@ -0,0 +1,248 @@
+import { describe, expect, it } from 'vitest'
+
+import type { OnboardingSurvey } from '@/platform/remoteConfig/types'
+
+import {
+ buildInitialValues,
+ buildSubmissionPayload,
+ buildZodSchema,
+ prepareSurvey,
+ visibleFields
+} from './surveySchema'
+
+const baseSurvey: OnboardingSurvey = {
+ version: 1,
+ fields: [
+ {
+ id: 'usage',
+ type: 'single',
+ required: true,
+ options: [
+ { value: 'work', label: 'Work' },
+ { value: 'personal', label: 'Personal' }
+ ]
+ },
+ {
+ id: 'role',
+ type: 'single',
+ required: true,
+ showWhen: { field: 'usage', equals: 'work' },
+ options: [{ value: 'engineer', label: 'Engineer' }]
+ },
+ {
+ id: 'industry',
+ type: 'single',
+ required: true,
+ allowOther: true,
+ otherFieldId: 'industryOther',
+ showWhen: { field: 'usage', equals: 'work' },
+ options: [
+ { value: 'tech', label: 'Tech' },
+ { value: 'other', label: 'Other' }
+ ]
+ },
+ {
+ id: 'making',
+ type: 'multi',
+ required: true,
+ options: [
+ { value: 'video', label: 'Video' },
+ { value: 'images', label: 'Images' }
+ ]
+ }
+ ]
+}
+
+describe('visibleFields', () => {
+ it('hides fields when showWhen does not match', () => {
+ const visible = visibleFields(baseSurvey, { usage: 'personal' })
+ expect(visible.map((f) => f.id)).toEqual(['usage', 'making'])
+ })
+
+ it('shows gated fields when showWhen matches', () => {
+ const visible = visibleFields(baseSurvey, { usage: 'work' })
+ expect(visible.map((f) => f.id)).toEqual([
+ 'usage',
+ 'role',
+ 'industry',
+ 'making'
+ ])
+ })
+
+ it('treats array equals as membership', () => {
+ const survey: OnboardingSurvey = {
+ version: 1,
+ fields: [
+ {
+ id: 'role',
+ type: 'single',
+ showWhen: { field: 'usage', equals: ['work', 'education'] }
+ }
+ ]
+ }
+ expect(visibleFields(survey, { usage: 'education' })).toHaveLength(1)
+ expect(visibleFields(survey, { usage: 'personal' })).toHaveLength(0)
+ })
+
+ it('intersects multi-select source values with expected set', () => {
+ const survey: OnboardingSurvey = {
+ version: 1,
+ fields: [
+ {
+ id: 'follow_up',
+ type: 'single',
+ showWhen: { field: 'making', equals: ['video', '3d'] }
+ }
+ ]
+ }
+ expect(visibleFields(survey, { making: [] })).toHaveLength(0)
+ expect(visibleFields(survey, { making: ['images'] })).toHaveLength(0)
+ expect(visibleFields(survey, { making: ['images', 'video'] })).toHaveLength(
+ 1
+ )
+ })
+})
+
+describe('buildInitialValues', () => {
+ it('initializes single fields to empty string and multi to empty array', () => {
+ expect(buildInitialValues(baseSurvey)).toMatchObject({
+ usage: '',
+ role: '',
+ industry: '',
+ industryOther: '',
+ making: []
+ })
+ })
+})
+
+describe('buildZodSchema', () => {
+ it('omits hidden fields from validation', () => {
+ const schema = buildZodSchema(baseSurvey, { usage: 'personal' })
+ const result = schema.safeParse({ usage: 'personal', making: ['video'] })
+ expect(result.success).toBe(true)
+ })
+
+ it('requires gated fields once visible', () => {
+ const schema = buildZodSchema(baseSurvey, { usage: 'work' })
+ const result = schema.safeParse({ usage: 'work', making: ['video'] })
+ expect(result.success).toBe(false)
+ })
+
+ it('requires "other" detail when option is selected', () => {
+ const schema = buildZodSchema(baseSurvey, {
+ usage: 'work',
+ role: 'engineer',
+ industry: 'other',
+ making: ['video']
+ })
+ expect(
+ schema.safeParse({
+ usage: 'work',
+ role: 'engineer',
+ industry: 'other',
+ industryOther: '',
+ making: ['video']
+ }).success
+ ).toBe(false)
+ expect(
+ schema.safeParse({
+ usage: 'work',
+ role: 'engineer',
+ industry: 'other',
+ industryOther: 'Aerospace',
+ making: ['video']
+ }).success
+ ).toBe(true)
+ })
+})
+
+describe('buildSubmissionPayload', () => {
+ it('clears hidden fields and prefers free-text "other" detail', () => {
+ const payload = buildSubmissionPayload(baseSurvey, {
+ usage: 'work',
+ role: 'engineer',
+ industry: 'other',
+ industryOther: ' Aerospace ',
+ making: ['video']
+ })
+ expect(payload).toEqual({
+ usage: 'work',
+ role: 'engineer',
+ industry: 'Aerospace',
+ making: ['video']
+ })
+ })
+
+ it('falls back to "other" when free-text is empty', () => {
+ const payload = buildSubmissionPayload(baseSurvey, {
+ usage: 'work',
+ role: 'engineer',
+ industry: 'other',
+ industryOther: '',
+ making: ['video']
+ })
+ expect(payload.industry).toBe('other')
+ })
+
+ it('zeroes out fields hidden by showWhen', () => {
+ const payload = buildSubmissionPayload(baseSurvey, {
+ usage: 'personal',
+ role: 'engineer',
+ making: ['video']
+ })
+ expect(payload).toMatchObject({
+ usage: 'personal',
+ role: '',
+ industry: '',
+ making: ['video']
+ })
+ })
+})
+
+describe('prepareSurvey', () => {
+ it('preserves option contents but may reorder when randomize=true', () => {
+ const survey: OnboardingSurvey = {
+ version: 1,
+ fields: [
+ {
+ id: 'making',
+ type: 'multi',
+ randomize: true,
+ options: [
+ { value: 'a', label: 'A' },
+ { value: 'b', label: 'B' },
+ { value: 'other', label: 'Other' }
+ ]
+ }
+ ]
+ }
+ const prepared = prepareSurvey(survey)
+ const values = prepared.fields[0]!.options!.map((o) => o.value)
+ expect(values).toContain('a')
+ expect(values).toContain('b')
+ expect(values[values.length - 1]).toBe('other')
+ })
+
+ it('pins both "other" and "not_sure" at the end while randomizing the rest', () => {
+ const survey: OnboardingSurvey = {
+ version: 1,
+ fields: [
+ {
+ id: 'intent',
+ type: 'multi',
+ randomize: true,
+ options: [
+ { value: 'a', label: 'A' },
+ { value: 'b', label: 'B' },
+ { value: 'other', label: 'Other' },
+ { value: 'not_sure', label: 'Not sure' }
+ ]
+ }
+ ]
+ }
+ const prepared = prepareSurvey(survey)
+ const values = prepared.fields[0]!.options!.map((o) => o.value)
+ expect(values.slice(-2).sort()).toEqual(['not_sure', 'other'])
+ expect(values.slice(0, -2).sort()).toEqual(['a', 'b'])
+ })
+})
diff --git a/src/platform/cloud/onboarding/survey/surveySchema.ts b/src/platform/cloud/onboarding/survey/surveySchema.ts
new file mode 100644
index 0000000000..d039d89139
--- /dev/null
+++ b/src/platform/cloud/onboarding/survey/surveySchema.ts
@@ -0,0 +1,137 @@
+import { shuffle } from 'es-toolkit'
+import { z } from 'zod'
+
+import type {
+ OnboardingSurvey,
+ OnboardingSurveyField,
+ OnboardingSurveyFieldCondition
+} from '@/platform/remoteConfig/types'
+
+export type SurveyValues = Record
+
+const hasNonEmptyValue = (current: string | string[] | undefined): boolean => {
+ if (current === undefined || current === '') return false
+ if (Array.isArray(current)) return current.length > 0
+ return true
+}
+
+const conditionMatches = (
+ condition: OnboardingSurveyFieldCondition | undefined,
+ values: SurveyValues
+): boolean => {
+ if (!condition) return true
+ const current = values[condition.field]
+ if (!hasNonEmptyValue(current)) return false
+ const expected = condition.equals
+ if (expected === undefined) return true
+ const expectedSet = Array.isArray(expected) ? expected : [expected]
+ if (Array.isArray(current)) {
+ return current.some((v) => expectedSet.includes(v))
+ }
+ return typeof current === 'string' && expectedSet.includes(current)
+}
+
+export const visibleFields = (
+ survey: OnboardingSurvey,
+ values: SurveyValues
+): OnboardingSurveyField[] =>
+ survey.fields.filter((field) => conditionMatches(field.showWhen, values))
+
+const PIN_LAST_VALUES = new Set(['other', 'not_sure'])
+
+const randomizeOptions = (field: OnboardingSurveyField) => {
+ if (!field.randomize || !field.options) return field
+ const pinned = field.options.filter((opt) => PIN_LAST_VALUES.has(opt.value))
+ const rest = field.options.filter((opt) => !PIN_LAST_VALUES.has(opt.value))
+ return {
+ ...field,
+ options: [...shuffle(rest), ...pinned]
+ }
+}
+
+export const prepareSurvey = (survey: OnboardingSurvey): OnboardingSurvey => ({
+ ...survey,
+ fields: survey.fields.map(randomizeOptions)
+})
+
+type Translator = (key: string) => string
+
+const identityTranslator: Translator = (key) => key
+
+const fieldSchema = (field: OnboardingSurveyField, t: Translator) => {
+ if (field.type === 'multi') {
+ const arr = z.array(z.string())
+ return field.required
+ ? arr.min(1, {
+ message: t('cloudOnboarding.survey.errors.selectAtLeastOne')
+ })
+ : arr.optional()
+ }
+ if (field.required) {
+ return z.string().min(1, {
+ message: t('cloudOnboarding.survey.errors.chooseAnOption')
+ })
+ }
+ return z.string().optional()
+}
+
+export const buildZodSchema = (
+ survey: OnboardingSurvey,
+ values: SurveyValues,
+ t: Translator = identityTranslator
+) => {
+ const shape: Record = {}
+ for (const field of survey.fields) {
+ if (!conditionMatches(field.showWhen, values)) continue
+ shape[field.id] = fieldSchema(field, t)
+ if (
+ field.allowOther &&
+ field.otherFieldId &&
+ values[field.id] === 'other'
+ ) {
+ shape[field.otherFieldId] = z.string().min(1, {
+ message: t('cloudOnboarding.survey.errors.describeAnswer')
+ })
+ } else if (field.otherFieldId) {
+ shape[field.otherFieldId] = z.string().optional()
+ }
+ }
+ return z.object(shape)
+}
+
+export const buildInitialValues = (survey: OnboardingSurvey): SurveyValues => {
+ const initial: SurveyValues = {}
+ for (const field of survey.fields) {
+ initial[field.id] = field.type === 'multi' ? [] : ''
+ if (field.otherFieldId) initial[field.otherFieldId] = ''
+ }
+ return initial
+}
+
+export const buildSubmissionPayload = (
+ survey: OnboardingSurvey,
+ values: SurveyValues
+): Record => {
+ const payload: Record = {}
+ for (const field of survey.fields) {
+ const visible = conditionMatches(field.showWhen, values)
+ if (!visible) {
+ payload[field.id] = field.type === 'multi' ? [] : ''
+ continue
+ }
+ const value = values[field.id]
+ const otherRaw = field.otherFieldId ? values[field.otherFieldId] : undefined
+ if (
+ field.allowOther &&
+ field.otherFieldId &&
+ value === 'other' &&
+ typeof otherRaw === 'string'
+ ) {
+ const other = otherRaw.trim()
+ payload[field.id] = other || 'other'
+ } else {
+ payload[field.id] = field.type === 'multi' ? (value ?? []) : (value ?? '')
+ }
+ }
+ return payload
+}
diff --git a/src/platform/missingMedia/missingMediaScan.test.ts b/src/platform/missingMedia/missingMediaScan.test.ts
index 867bb4d3f7..8e77aae88c 100644
--- a/src/platform/missingMedia/missingMediaScan.test.ts
+++ b/src/platform/missingMedia/missingMediaScan.test.ts
@@ -1,9 +1,11 @@
import { fromAny } from '@total-typescript/shoehorn'
-import { describe, expect, it, vi } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
import type { LGraph } from '@/lib/litegraph/src/LGraph'
import type { LGraphNode } from '@/lib/litegraph/src/LGraphNode'
import type { IComboWidget } from '@/lib/litegraph/src/types/widgets'
+import type { AssetItem } from '@/platform/assets/schemas/assetSchema'
+import type * as AssetServiceModule from '@/platform/assets/services/assetService'
import {
scanAllMediaCandidates,
scanNodeMediaCandidates,
@@ -13,6 +15,13 @@ import {
} from './missingMediaScan'
import type { MissingMediaCandidate } from './types'
+const { mockCheckAssetHash, mockGetInputAssetsIncludingPublic } = vi.hoisted(
+ () => ({
+ mockCheckAssetHash: vi.fn(),
+ mockGetInputAssetsIncludingPublic: vi.fn()
+ })
+)
+
vi.mock('@/utils/graphTraversalUtil', () => ({
collectAllNodes: (graph: { _testNodes: LGraphNode[] }) => graph._testNodes,
getExecutionIdByNode: (
@@ -21,6 +30,21 @@ vi.mock('@/utils/graphTraversalUtil', () => ({
) => node._testExecutionId ?? String(node.id)
}))
+vi.mock('@/platform/assets/services/assetService', async () => {
+ const actual = await vi.importActual(
+ '@/platform/assets/services/assetService'
+ )
+
+ return {
+ ...actual,
+ assetService: {
+ ...actual.assetService,
+ checkAssetHash: mockCheckAssetHash,
+ getInputAssetsIncludingPublic: mockGetInputAssetsIncludingPublic
+ }
+ }
+})
+
function makeCandidate(
nodeId: string,
name: string,
@@ -70,6 +94,16 @@ function makeGraph(nodes: LGraphNode[]): LGraph {
return fromAny({ _testNodes: nodes })
}
+function makeAsset(name: string, assetHash: string | null = null): AssetItem {
+ return {
+ id: name,
+ name,
+ asset_hash: assetHash,
+ mime_type: null,
+ tags: ['input']
+ }
+}
+
describe('scanNodeMediaCandidates', () => {
it('returns candidate for a LoadImage node with missing image', () => {
const graph = makeGraph([])
@@ -232,37 +266,43 @@ describe('groupCandidatesByMediaType', () => {
})
describe('verifyCloudMediaCandidates', () => {
- it('marks candidates missing when not in input assets', async () => {
+ const existingHash =
+ 'blake3:1111111111111111111111111111111111111111111111111111111111111111'
+ const missingHash =
+ 'blake3:2222222222222222222222222222222222222222222222222222222222222222'
+
+ beforeEach(() => {
+ vi.clearAllMocks()
+ mockCheckAssetHash.mockResolvedValue('missing')
+ mockGetInputAssetsIncludingPublic.mockResolvedValue([])
+ })
+
+ it('marks candidates missing when the asset hash is not found', async () => {
const candidates = [
- makeCandidate('1', 'abc123.png', { isMissing: undefined }),
- makeCandidate('2', 'def456.png', { isMissing: undefined })
+ makeCandidate('1', missingHash, { isMissing: undefined }),
+ makeCandidate('2', existingHash, { isMissing: undefined })
]
- const mockStore = {
- updateInputs: async () => {},
- inputAssets: [{ asset_hash: 'def456.png', name: 'my-photo.png' }]
- }
+ const checkAssetHash = vi.fn(async (assetHash: string) =>
+ assetHash === existingHash ? ('exists' as const) : ('missing' as const)
+ )
- await verifyCloudMediaCandidates(candidates, undefined, mockStore)
+ await verifyCloudMediaCandidates(candidates, undefined, checkAssetHash)
expect(candidates[0].isMissing).toBe(true)
expect(candidates[1].isMissing).toBe(false)
})
- it('calls updateInputs before checking assets', async () => {
- let updateCalled = false
- const candidates = [makeCandidate('1', 'abc.png', { isMissing: undefined })]
+ it('uses assetService.checkAssetHash by default', async () => {
+ const candidates = [
+ makeCandidate('1', existingHash, { isMissing: undefined })
+ ]
+ mockCheckAssetHash.mockResolvedValue('exists')
- const mockStore = {
- updateInputs: async () => {
- updateCalled = true
- },
- inputAssets: []
- }
+ await verifyCloudMediaCandidates(candidates)
- await verifyCloudMediaCandidates(candidates, undefined, mockStore)
-
- expect(updateCalled).toBe(true)
+ expect(candidates[0].isMissing).toBe(false)
+ expect(mockCheckAssetHash).toHaveBeenCalledWith(existingHash, undefined)
})
it('respects abort signal before execution', async () => {
@@ -270,69 +310,221 @@ describe('verifyCloudMediaCandidates', () => {
controller.abort()
const candidates = [
- makeCandidate('1', 'abc123.png', { isMissing: undefined })
+ makeCandidate('1', missingHash, { isMissing: undefined })
]
await verifyCloudMediaCandidates(candidates, controller.signal)
expect(candidates[0].isMissing).toBeUndefined()
+ expect(mockCheckAssetHash).not.toHaveBeenCalled()
})
- it('respects abort signal after updateInputs', async () => {
+ it('respects abort signal after hash verification', async () => {
const controller = new AbortController()
- const candidates = [makeCandidate('1', 'abc.png', { isMissing: undefined })]
+ const candidates = [
+ makeCandidate('1', existingHash, { isMissing: undefined })
+ ]
+ const checkAssetHash = vi.fn(async () => {
+ controller.abort()
+ return 'exists' as const
+ })
- const mockStore = {
- updateInputs: async () => {
- controller.abort()
- },
- inputAssets: [{ asset_hash: 'abc.png', name: 'photo.png' }]
- }
-
- await verifyCloudMediaCandidates(candidates, controller.signal, mockStore)
+ await verifyCloudMediaCandidates(
+ candidates,
+ controller.signal,
+ checkAssetHash
+ )
expect(candidates[0].isMissing).toBeUndefined()
})
it('skips candidates already resolved as true', async () => {
- const candidates = [makeCandidate('1', 'abc.png', { isMissing: true })]
+ const candidates = [makeCandidate('1', missingHash, { isMissing: true })]
- const mockStore = {
- updateInputs: async () => {},
- inputAssets: []
- }
-
- await verifyCloudMediaCandidates(candidates, undefined, mockStore)
+ await verifyCloudMediaCandidates(candidates)
expect(candidates[0].isMissing).toBe(true)
+ expect(mockCheckAssetHash).not.toHaveBeenCalled()
})
it('skips candidates already resolved as false', async () => {
- const candidates = [makeCandidate('1', 'abc.png', { isMissing: false })]
+ const candidates = [makeCandidate('1', existingHash, { isMissing: false })]
- const mockStore = {
- updateInputs: async () => {},
- inputAssets: []
- }
-
- await verifyCloudMediaCandidates(candidates, undefined, mockStore)
+ await verifyCloudMediaCandidates(candidates)
expect(candidates[0].isMissing).toBe(false)
+ expect(mockCheckAssetHash).not.toHaveBeenCalled()
})
it('skips entirely when no pending candidates', async () => {
- let updateCalled = false
- const candidates = [makeCandidate('1', 'abc.png', { isMissing: true })]
+ const candidates = [makeCandidate('1', missingHash, { isMissing: true })]
- const mockStore = {
- updateInputs: async () => {
- updateCalled = true
- },
- inputAssets: []
- }
+ await verifyCloudMediaCandidates(candidates)
- await verifyCloudMediaCandidates(candidates, undefined, mockStore)
+ expect(mockCheckAssetHash).not.toHaveBeenCalled()
+ })
- expect(updateCalled).toBe(false)
+ it('falls back to input assets for non-blake3 candidate names', async () => {
+ const candidates = [
+ makeCandidate('1', 'photo.png', { isMissing: undefined }),
+ makeCandidate('2', 'missing.png', { isMissing: undefined })
+ ]
+ const fetchInputAssets = vi.fn(async () => [
+ makeAsset('stored-photo.png', 'photo.png')
+ ])
+
+ await verifyCloudMediaCandidates(
+ candidates,
+ undefined,
+ undefined,
+ fetchInputAssets
+ )
+
+ expect(mockCheckAssetHash).not.toHaveBeenCalled()
+ expect(fetchInputAssets).toHaveBeenCalledOnce()
+ expect(candidates[0].isMissing).toBe(false)
+ expect(candidates[1].isMissing).toBe(true)
+ })
+
+ it('uses public input assets for default legacy fallback', async () => {
+ const candidates = [
+ makeCandidate('1', 'public-photo.png', { isMissing: undefined })
+ ]
+ const inputAssets = Array.from({ length: 500 }, (_, index) =>
+ makeAsset(`asset-${index}.png`)
+ )
+ inputAssets[42] = makeAsset('public-asset-record', 'public-photo.png')
+ mockGetInputAssetsIncludingPublic.mockResolvedValue(inputAssets)
+
+ await verifyCloudMediaCandidates(candidates)
+
+ expect(mockGetInputAssetsIncludingPublic).toHaveBeenCalledWith(undefined)
+ expect(candidates[0].isMissing).toBe(false)
+ })
+
+ it('silences aborts while loading legacy fallback input assets', async () => {
+ const abortError = new Error('aborted')
+ abortError.name = 'AbortError'
+ const controller = new AbortController()
+ const candidates = [
+ makeCandidate('1', 'photo.png', { isMissing: undefined })
+ ]
+ const fetchInputAssets = vi.fn(async () => {
+ controller.abort()
+ throw abortError
+ })
+
+ await expect(
+ verifyCloudMediaCandidates(
+ candidates,
+ controller.signal,
+ undefined,
+ fetchInputAssets
+ )
+ ).resolves.toBeUndefined()
+
+ expect(candidates[0].isMissing).toBeUndefined()
+ })
+
+ it('silences aborts from the default legacy fallback input asset store path', async () => {
+ const abortError = new Error('aborted')
+ abortError.name = 'AbortError'
+ const controller = new AbortController()
+ const candidates = [
+ makeCandidate('1', 'photo.png', { isMissing: undefined })
+ ]
+ mockGetInputAssetsIncludingPublic.mockImplementationOnce(async () => {
+ controller.abort()
+ throw abortError
+ })
+
+ await expect(
+ verifyCloudMediaCandidates(candidates, controller.signal)
+ ).resolves.toBeUndefined()
+
+ expect(mockGetInputAssetsIncludingPublic).toHaveBeenCalledWith(
+ controller.signal
+ )
+ expect(candidates[0].isMissing).toBeUndefined()
+ })
+
+ it('falls back to input assets when the hash endpoint returns 400', async () => {
+ const candidates = [
+ makeCandidate('1', existingHash, { isMissing: undefined })
+ ]
+ mockCheckAssetHash.mockResolvedValue('invalid')
+ const fetchInputAssets = vi.fn(async () => [
+ makeAsset('photo.png', existingHash)
+ ])
+
+ await verifyCloudMediaCandidates(
+ candidates,
+ undefined,
+ undefined,
+ fetchInputAssets
+ )
+
+ expect(mockCheckAssetHash).toHaveBeenCalledWith(existingHash, undefined)
+ expect(fetchInputAssets).toHaveBeenCalledOnce()
+ expect(candidates[0].isMissing).toBe(false)
+ })
+
+ it('falls back to input assets when hash verification fails', async () => {
+ const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+ const candidates = [
+ makeCandidate('1', existingHash, { isMissing: undefined })
+ ]
+ const checkAssetHash = vi.fn(async () => {
+ throw new Error('network failed')
+ })
+ const fetchInputAssets = vi.fn(async () => [
+ makeAsset('photo.png', existingHash)
+ ])
+
+ await verifyCloudMediaCandidates(
+ candidates,
+ undefined,
+ checkAssetHash,
+ fetchInputAssets
+ )
+
+ expect(fetchInputAssets).toHaveBeenCalledOnce()
+ expect(candidates[0].isMissing).toBe(false)
+ expect(warn).toHaveBeenCalledOnce()
+ warn.mockRestore()
+ })
+
+ it('does not call the hash endpoint for malformed blake3-looking values', async () => {
+ const malformedHash = 'blake3:abc'
+ const candidates = [
+ makeCandidate('1', malformedHash, { isMissing: undefined })
+ ]
+ const fetchInputAssets = vi.fn(async () => [
+ makeAsset('legacy.png', malformedHash)
+ ])
+
+ await verifyCloudMediaCandidates(
+ candidates,
+ undefined,
+ undefined,
+ fetchInputAssets
+ )
+
+ expect(mockCheckAssetHash).not.toHaveBeenCalled()
+ expect(fetchInputAssets).toHaveBeenCalledOnce()
+ expect(candidates[0].isMissing).toBe(false)
+ })
+
+ it('deduplicates checks for repeated candidate names', async () => {
+ const candidates = [
+ makeCandidate('1', missingHash, { isMissing: undefined }),
+ makeCandidate('2', missingHash, { isMissing: undefined })
+ ]
+
+ await verifyCloudMediaCandidates(candidates)
+
+ expect(mockCheckAssetHash).toHaveBeenCalledOnce()
+ expect(candidates[0].isMissing).toBe(true)
+ expect(candidates[1].isMissing).toBe(true)
})
})
diff --git a/src/platform/missingMedia/missingMediaScan.ts b/src/platform/missingMedia/missingMediaScan.ts
index 7b4592768b..5050996e06 100644
--- a/src/platform/missingMedia/missingMediaScan.ts
+++ b/src/platform/missingMedia/missingMediaScan.ts
@@ -18,6 +18,12 @@ import {
} from '@/utils/graphTraversalUtil'
import { LGraphEventMode } from '@/lib/litegraph/src/types/globalEnums'
import { resolveComboValues } from '@/utils/litegraphUtil'
+import type { AssetItem } from '@/platform/assets/schemas/assetSchema'
+import type { AssetHashStatus } from '@/platform/assets/services/assetService'
+import {
+ assetService,
+ isBlake3AssetHash
+} from '@/platform/assets/services/assetService'
/** Map of node types to their media widget name and media type. */
const MEDIA_NODE_WIDGETS: Record<
@@ -106,41 +112,130 @@ export function scanNodeMediaCandidates(
return candidates
}
-interface InputVerifier {
- updateInputs: () => Promise
- inputAssets: Array<{ asset_hash?: string | null; name: string }>
+type AssetHashVerifier = (
+ assetHash: string,
+ signal?: AbortSignal
+) => Promise
+
+type InputAssetFetcher = (signal?: AbortSignal) => Promise
+
+function groupCandidatesForHashLookup(candidates: MissingMediaCandidate[]): {
+ candidatesByHash: Map
+ legacyCandidates: MissingMediaCandidate[]
+} {
+ const candidatesByHash = new Map()
+ const legacyCandidates: MissingMediaCandidate[] = []
+
+ for (const candidate of candidates) {
+ if (!isBlake3AssetHash(candidate.name)) {
+ legacyCandidates.push(candidate)
+ continue
+ }
+
+ const hashCandidates = candidatesByHash.get(candidate.name)
+ if (hashCandidates) hashCandidates.push(candidate)
+ else candidatesByHash.set(candidate.name, [candidate])
+ }
+
+ return { candidatesByHash, legacyCandidates }
+}
+
+async function verifyCandidatesByHash(
+ candidatesByHash: Map,
+ legacyCandidates: MissingMediaCandidate[],
+ signal: AbortSignal | undefined,
+ checkAssetHash: AssetHashVerifier
+): Promise {
+ await Promise.all(
+ Array.from(candidatesByHash, async ([assetHash, hashCandidates]) => {
+ if (signal?.aborted) return
+
+ let status: AssetHashStatus
+ try {
+ status = await checkAssetHash(assetHash, signal)
+ if (signal?.aborted) return
+ } catch (err) {
+ if (signal?.aborted || isAbortError(err)) return
+ console.warn(
+ '[Missing Media Pipeline] Failed to verify asset hash:',
+ err
+ )
+ legacyCandidates.push(...hashCandidates)
+ return
+ }
+
+ if (status === 'invalid') {
+ legacyCandidates.push(...hashCandidates)
+ return
+ }
+
+ for (const candidate of hashCandidates) {
+ candidate.isMissing = status === 'missing'
+ }
+ })
+ )
}
/**
- * Verify cloud media candidates against the input assets fetched from the
- * assets store. Mutates candidates' `isMissing` in place.
+ * Verify cloud media candidates by probing the asset hash endpoint first.
+ * Invalid hash values fall back to the legacy input asset list check.
*/
export async function verifyCloudMediaCandidates(
candidates: MissingMediaCandidate[],
signal?: AbortSignal,
- assetsStore?: InputVerifier
+ checkAssetHash: AssetHashVerifier = assetService.checkAssetHash,
+ fetchInputAssets: InputAssetFetcher = fetchMissingInputAssets
): Promise {
if (signal?.aborted) return
const pending = candidates.filter((c) => c.isMissing === undefined)
if (pending.length === 0) return
- const store =
- assetsStore ?? (await import('@/stores/assetsStore')).useAssetsStore()
+ const { candidatesByHash, legacyCandidates } =
+ groupCandidatesForHashLookup(pending)
+ await verifyCandidatesByHash(
+ candidatesByHash,
+ legacyCandidates,
+ signal,
+ checkAssetHash
+ )
- await store.updateInputs()
+ if (signal?.aborted || legacyCandidates.length === 0) return
+
+ let inputAssets: AssetItem[]
+ try {
+ inputAssets = await fetchInputAssets(signal)
+ } catch (err) {
+ if (signal?.aborted || isAbortError(err)) return
+ throw err
+ }
if (signal?.aborted) return
const assetHashes = new Set(
- store.inputAssets.map((a) => a.asset_hash).filter((h): h is string => !!h)
+ inputAssets.map((a) => a.asset_hash).filter((h): h is string => !!h)
)
- for (const c of pending) {
- c.isMissing = !assetHashes.has(c.name)
+ for (const candidate of legacyCandidates) {
+ candidate.isMissing = !assetHashes.has(candidate.name)
}
}
+async function fetchMissingInputAssets(
+ signal?: AbortSignal
+): Promise {
+ return await assetService.getInputAssetsIncludingPublic(signal)
+}
+
+function isAbortError(err: unknown): boolean {
+ return (
+ typeof err === 'object' &&
+ err !== null &&
+ 'name' in err &&
+ err.name === 'AbortError'
+ )
+}
+
/** Group confirmed-missing candidates by file name into view models. */
export function groupCandidatesByName(
candidates: MissingMediaCandidate[]
diff --git a/src/platform/missingModel/missingModelScan.test.ts b/src/platform/missingModel/missingModelScan.test.ts
index cc26dbc609..05326f8bb0 100644
--- a/src/platform/missingModel/missingModelScan.test.ts
+++ b/src/platform/missingModel/missingModelScan.test.ts
@@ -19,6 +19,11 @@ import activeSubgraphUnmatchedModel from '@/platform/missingModel/__fixtures__/a
import bypassedSubgraphUnmatchedModel from '@/platform/missingModel/__fixtures__/bypassedSubgraphUnmatchedModel.json' with { type: 'json' }
import type { MissingModelCandidate } from '@/platform/missingModel/types'
import type { ComfyWorkflowJSON } from '@/platform/workflow/validation/schemas/workflowSchema'
+import type * as AssetServiceModule from '@/platform/assets/services/assetService'
+
+const { mockCheckAssetHash } = vi.hoisted(() => ({
+ mockCheckAssetHash: vi.fn()
+}))
vi.mock('@/utils/graphTraversalUtil', () => ({
collectAllNodes: (graph: { _testNodes: LGraphNode[] }) => graph._testNodes,
@@ -28,6 +33,20 @@ vi.mock('@/utils/graphTraversalUtil', () => ({
) => node._testExecutionId ?? String(node.id)
}))
+vi.mock('@/platform/assets/services/assetService', async () => {
+ const actual = await vi.importActual(
+ '@/platform/assets/services/assetService'
+ )
+
+ return {
+ ...actual,
+ assetService: {
+ ...actual.assetService,
+ checkAssetHash: mockCheckAssetHash
+ }
+ }
+})
+
/** Helper: create a combo widget mock */
function makeComboWidget(
name: string,
@@ -43,7 +62,7 @@ function makeComboWidget(
}
/** Helper: create an asset widget mock (Cloud combo replacement) */
-function makeAssetWidget(name: string, value: string): IBaseWidget {
+function makeAssetWidget(name: string, value: unknown): IBaseWidget {
return fromAny({
type: 'asset',
name,
@@ -551,6 +570,16 @@ describe('scanAllModelCandidates', () => {
expect(result).toEqual([])
})
+ it('should skip asset widgets with non-string values', () => {
+ const graph = makeGraph([
+ makeNode(1, 'SomeNode', [makeAssetWidget('ckpt_name', 123)])
+ ])
+
+ const result = scanAllModelCandidates(graph, noAssetSupport)
+
+ expect(result).toEqual([])
+ })
+
it('should scan both combo and asset widgets on the same node', () => {
const graph = makeGraph([
makeNode(1, 'DualLoaderNode', [
@@ -1411,6 +1440,7 @@ function makeAssetCandidate(
describe('verifyAssetSupportedCandidates', () => {
beforeEach(() => {
vi.clearAllMocks()
+ mockCheckAssetHash.mockResolvedValue('missing')
mockIsModelLoading.mockReturnValue(false)
mockHasMore.mockReturnValue(false)
mockGetAssets.mockReturnValue([])
@@ -1428,6 +1458,125 @@ describe('verifyAssetSupportedCandidates', () => {
)
})
+ it('should resolve isMissing=false when the blake3 hash endpoint finds the asset', async () => {
+ const hash =
+ '1111111111111111111111111111111111111111111111111111111111111111'
+ const candidates = [
+ makeAssetCandidate('model.safetensors', {
+ hash,
+ hashType: 'blake3'
+ })
+ ]
+ mockCheckAssetHash.mockResolvedValue('exists')
+
+ await verifyAssetSupportedCandidates(candidates)
+
+ expect(candidates[0].isMissing).toBe(false)
+ expect(mockCheckAssetHash).toHaveBeenCalledWith(`blake3:${hash}`, undefined)
+ expect(mockUpdateModelsForNodeType).not.toHaveBeenCalled()
+ })
+
+ it('should fall back to asset store matching when the blake3 hash is not found', async () => {
+ const hash =
+ '2222222222222222222222222222222222222222222222222222222222222222'
+ const candidates = [
+ makeAssetCandidate('my_model.safetensors', {
+ hash,
+ hashType: 'blake3'
+ })
+ ]
+ mockCheckAssetHash.mockResolvedValue('missing')
+ mockGetAssets.mockReturnValue([
+ {
+ id: '1',
+ name: 'my_model.safetensors',
+ asset_hash: null,
+ metadata: { filename: 'my_model.safetensors' }
+ }
+ ])
+
+ await verifyAssetSupportedCandidates(candidates)
+
+ expect(candidates[0].isMissing).toBe(false)
+ expect(mockUpdateModelsForNodeType).toHaveBeenCalledWith(
+ 'CheckpointLoaderSimple'
+ )
+ })
+
+ it('should fall back to asset store matching when hash verification fails', async () => {
+ const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+ const hash =
+ '3333333333333333333333333333333333333333333333333333333333333333'
+ const candidates = [
+ makeAssetCandidate('my_model.safetensors', {
+ hash,
+ hashType: 'blake3'
+ })
+ ]
+ mockCheckAssetHash.mockRejectedValue(new Error('network failed'))
+ mockGetAssets.mockReturnValue([
+ {
+ id: '1',
+ name: 'my_model.safetensors',
+ asset_hash: null,
+ metadata: { filename: 'my_model.safetensors' }
+ }
+ ])
+
+ await verifyAssetSupportedCandidates(candidates)
+
+ expect(candidates[0].isMissing).toBe(false)
+ expect(mockUpdateModelsForNodeType).toHaveBeenCalledWith(
+ 'CheckpointLoaderSimple'
+ )
+ expect(warn).toHaveBeenCalledOnce()
+ warn.mockRestore()
+ })
+
+ it('should skip malformed blake3 hashes and use asset store matching', async () => {
+ const candidates = [
+ makeAssetCandidate('my_model.safetensors', {
+ hash: 'abc123',
+ hashType: 'blake3'
+ })
+ ]
+ mockGetAssets.mockReturnValue([
+ {
+ id: '1',
+ name: 'my_model.safetensors',
+ asset_hash: null,
+ metadata: { filename: 'my_model.safetensors' }
+ }
+ ])
+
+ await verifyAssetSupportedCandidates(candidates)
+
+ expect(mockCheckAssetHash).not.toHaveBeenCalled()
+ expect(candidates[0].isMissing).toBe(false)
+ })
+
+ it('should not warn or fall back when hash verification is aborted', async () => {
+ const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+ const abortError = new Error('aborted')
+ abortError.name = 'AbortError'
+ const hash =
+ '4444444444444444444444444444444444444444444444444444444444444444'
+ const candidates = [
+ makeAssetCandidate('my_model.safetensors', {
+ hash,
+ hashType: 'blake3'
+ })
+ ]
+ mockCheckAssetHash.mockRejectedValue(abortError)
+
+ await verifyAssetSupportedCandidates(candidates)
+
+ expect(candidates[0].isMissing).toBeUndefined()
+ expect(mockUpdateModelsForNodeType).not.toHaveBeenCalled()
+ expect(warn).not.toHaveBeenCalled()
+ warn.mockRestore()
+ })
+
it('should resolve isMissing=false when asset with matching hash exists', async () => {
const candidates = [
makeAssetCandidate('model.safetensors', {
@@ -1442,6 +1591,7 @@ describe('verifyAssetSupportedCandidates', () => {
await verifyAssetSupportedCandidates(candidates)
expect(candidates[0].isMissing).toBe(false)
+ expect(mockCheckAssetHash).not.toHaveBeenCalled()
})
it('should resolve isMissing=false when asset with matching filename exists', async () => {
diff --git a/src/platform/missingModel/missingModelScan.ts b/src/platform/missingModel/missingModelScan.ts
index 11302154bc..bef803112a 100644
--- a/src/platform/missingModel/missingModelScan.ts
+++ b/src/platform/missingModel/missingModelScan.ts
@@ -24,6 +24,11 @@ import {
} from '@/utils/graphTraversalUtil'
import { LGraphEventMode } from '@/lib/litegraph/src/types/globalEnums'
import { resolveComboValues } from '@/utils/litegraphUtil'
+import type { AssetHashStatus } from '@/platform/assets/services/assetService'
+import {
+ assetService,
+ toBlake3AssetHash
+} from '@/platform/assets/services/assetService'
export type MissingModelWorkflowData = FlattenableWorkflowGraph & {
models?: ModelFile[]
@@ -177,7 +182,7 @@ function scanAssetWidget(
getDirectory: ((nodeType: string) => string | undefined) | undefined
): MissingModelCandidate | null {
const value = widget.value
- if (!value.trim()) return null
+ if (typeof value !== 'string' || !value.trim()) return null
if (!isModelFileName(value)) return null
return {
@@ -445,20 +450,68 @@ interface AssetVerifier {
getAssets: (nodeType: string) => AssetItem[] | undefined
}
+type AssetHashVerifier = (
+ assetHash: string,
+ signal?: AbortSignal
+) => Promise
+
export async function verifyAssetSupportedCandidates(
candidates: MissingModelCandidate[],
signal?: AbortSignal,
- assetsStore?: AssetVerifier
+ assetsStore?: AssetVerifier,
+ checkAssetHash: AssetHashVerifier = assetService.checkAssetHash
): Promise {
if (signal?.aborted) return
+ const pendingCandidates = candidates.filter(
+ (c) => c.isAssetSupported && c.isMissing === undefined
+ )
+ if (pendingCandidates.length === 0) return
+
const pendingNodeTypes = new Set()
- for (const c of candidates) {
- if (c.isAssetSupported && c.isMissing === undefined) {
- pendingNodeTypes.add(c.nodeType)
+ const candidatesByHash = new Map()
+
+ for (const candidate of pendingCandidates) {
+ const assetHash = getBlake3AssetHash(candidate)
+ if (!assetHash) {
+ pendingNodeTypes.add(candidate.nodeType)
+ continue
}
+
+ const hashCandidates = candidatesByHash.get(assetHash)
+ if (hashCandidates) hashCandidates.push(candidate)
+ else candidatesByHash.set(assetHash, [candidate])
}
+ await Promise.all(
+ Array.from(candidatesByHash, async ([assetHash, hashCandidates]) => {
+ if (signal?.aborted) return
+
+ try {
+ const status = await checkAssetHash(assetHash, signal)
+ if (signal?.aborted) return
+
+ if (status === 'exists') {
+ for (const candidate of hashCandidates) {
+ candidate.isMissing = false
+ }
+ return
+ }
+ } catch (err) {
+ if (signal?.aborted || isAbortError(err)) return
+ console.warn(
+ '[Missing Model Pipeline] Failed to verify asset hash:',
+ err
+ )
+ }
+
+ for (const candidate of hashCandidates) {
+ pendingNodeTypes.add(candidate.nodeType)
+ }
+ })
+ )
+
+ if (signal?.aborted) return
if (pendingNodeTypes.size === 0) return
const store =
@@ -491,6 +544,20 @@ export async function verifyAssetSupportedCandidates(
}
}
+function getBlake3AssetHash(candidate: MissingModelCandidate): string | null {
+ if (candidate.hashType?.toLowerCase() !== 'blake3') return null
+ return toBlake3AssetHash(candidate.hash)
+}
+
+function isAbortError(err: unknown): boolean {
+ return (
+ typeof err === 'object' &&
+ err !== null &&
+ 'name' in err &&
+ err.name === 'AbortError'
+ )
+}
+
function normalizePath(path: string): string {
return path.replace(/\\/g, '/')
}
diff --git a/src/platform/remoteConfig/types.ts b/src/platform/remoteConfig/types.ts
index fbae538fdf..f2134aa513 100644
--- a/src/platform/remoteConfig/types.ts
+++ b/src/platform/remoteConfig/types.ts
@@ -23,6 +23,54 @@ type FirebaseRuntimeConfig = {
measurementId?: string
}
+/**
+ * Server-driven onboarding survey schema.
+ *
+ * The backend ships the entire form definition so onboarding questions can
+ * be tweaked without a frontend release. Field types map 1:1 to a component
+ * in our internal UI library — see `DynamicSurveyField.vue`.
+ */
+export type OnboardingSurveyFieldType = 'single' | 'multi' | 'text'
+
+/**
+ * A translatable string. Either:
+ * - a single literal (treated as the fallback in any locale), or
+ * - a locale → text map, e.g. `{ en: 'Personal use', ko: '개인 용도' }`,
+ * so the backend can ship translations without a frontend release.
+ */
+export type LocalizedString = string | Record
+
+export type OnboardingSurveyOption = {
+ value: string
+ label?: LocalizedString
+ labelKey?: string
+}
+
+export type OnboardingSurveyFieldCondition = {
+ field: string
+ equals?: string | string[]
+}
+
+export type OnboardingSurveyField = {
+ id: string
+ type: OnboardingSurveyFieldType
+ labelKey?: string
+ label?: LocalizedString
+ options?: OnboardingSurveyOption[]
+ required?: boolean
+ randomize?: boolean
+ allowOther?: boolean
+ otherFieldId?: string
+ placeholder?: string
+ showWhen?: OnboardingSurveyFieldCondition
+}
+
+export type OnboardingSurvey = {
+ version: number
+ introKey?: string
+ fields: OnboardingSurveyField[]
+}
+
/**
* Remote configuration type
* Configuration fetched from the server at runtime
@@ -45,6 +93,7 @@ export type RemoteConfig = {
asset_rename_enabled?: boolean
private_models_enabled?: boolean
onboarding_survey_enabled?: boolean
+ onboarding_survey?: OnboardingSurvey
linear_toggle_enabled?: boolean
team_workspaces_enabled?: boolean
user_secrets_enabled?: boolean
diff --git a/src/platform/telemetry/types.ts b/src/platform/telemetry/types.ts
index 2bdfbf0955..e606379eb5 100644
--- a/src/platform/telemetry/types.ts
+++ b/src/platform/telemetry/types.ts
@@ -40,6 +40,11 @@ export interface SurveyResponses {
industry?: string
useCase?: string
making?: string[]
+ role?: string
+ teamSize?: string
+ source?: string
+ usage?: string
+ intent?: string[]
}
export interface SurveyResponsesNormalized extends SurveyResponses {
diff --git a/src/platform/workspace/components/SubscriptionRequiredDialogContentWorkspace.test.ts b/src/platform/workspace/components/SubscriptionRequiredDialogContentWorkspace.test.ts
new file mode 100644
index 0000000000..680af8da60
--- /dev/null
+++ b/src/platform/workspace/components/SubscriptionRequiredDialogContentWorkspace.test.ts
@@ -0,0 +1,198 @@
+import { createTestingPinia } from '@pinia/testing'
+import { render, screen } from '@testing-library/vue'
+import userEvent from '@testing-library/user-event'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { ref } from 'vue'
+import { createI18n } from 'vue-i18n'
+
+import type { SubscriptionDialogReason } from '@/platform/cloud/subscription/composables/useSubscriptionDialog'
+
+import SubscriptionRequiredDialogContentWorkspace from './SubscriptionRequiredDialogContentWorkspace.vue'
+
+const mockHandleSubscribeClick = vi.fn()
+const mockHandleBackToPricing = vi.fn()
+const mockHandleAddCreditCard = vi.fn()
+const mockHandleConfirmTransition = vi.fn()
+const mockHandleResubscribe = vi.fn()
+const mockCheckoutStep = ref<'pricing' | 'preview'>('pricing')
+const mockPreviewData = ref<{ transition_type: string } | null>(null)
+
+vi.mock('@/platform/workspace/composables/useSubscriptionCheckout', () => ({
+ useSubscriptionCheckout: () => ({
+ checkoutStep: mockCheckoutStep,
+ isLoadingPreview: ref(false),
+ loadingTier: ref(null),
+ isSubscribing: ref(false),
+ isResubscribing: ref(false),
+ previewData: mockPreviewData,
+ selectedTierKey: ref('standard'),
+ selectedBillingCycle: ref('yearly'),
+ isPolling: ref(false),
+ handleSubscribeClick: mockHandleSubscribeClick,
+ handleBackToPricing: mockHandleBackToPricing,
+ handleAddCreditCard: mockHandleAddCreditCard,
+ handleConfirmTransition: mockHandleConfirmTransition,
+ handleResubscribe: mockHandleResubscribe
+ })
+}))
+
+const i18n = createI18n({
+ legacy: false,
+ locale: 'en',
+ messages: {
+ en: {
+ g: { back: 'Back', close: 'Close' },
+ subscription: {
+ plansForWorkspace: 'Plans for {workspace}',
+ teamWorkspace: 'Team'
+ },
+ credits: {
+ topUp: {
+ insufficientTitle: 'Insufficient Credits',
+ insufficientMessage: 'You have run out of credits.'
+ }
+ }
+ }
+ }
+})
+
+const PricingTableStub = {
+ name: 'PricingTableWorkspace',
+ template: `
+
+
+
`
+}
+
+const AddPaymentPreviewStub = {
+ name: 'SubscriptionAddPaymentPreviewWorkspace',
+ template: `
+
+
`
+}
+
+const TransitionPreviewStub = {
+ name: 'SubscriptionTransitionPreviewWorkspace',
+ template: `
+
+
`
+}
+
+function renderComponent(
+ props: { onClose?: () => void; reason?: SubscriptionDialogReason } = {}
+) {
+ return render(SubscriptionRequiredDialogContentWorkspace, {
+ props: {
+ onClose: props.onClose ?? vi.fn(),
+ ...(props.reason ? { reason: props.reason } : {})
+ },
+ global: {
+ plugins: [
+ createTestingPinia({ createSpy: vi.fn, stubActions: false }),
+ i18n
+ ],
+ stubs: {
+ PricingTableWorkspace: PricingTableStub,
+ SubscriptionAddPaymentPreviewWorkspace: AddPaymentPreviewStub,
+ SubscriptionTransitionPreviewWorkspace: TransitionPreviewStub
+ }
+ }
+ })
+}
+
+describe('SubscriptionRequiredDialogContentWorkspace', () => {
+ beforeEach(() => {
+ vi.clearAllMocks()
+ mockCheckoutStep.value = 'pricing'
+ mockPreviewData.value = null
+ })
+
+ it('shows pricing table on pricing step', () => {
+ renderComponent()
+ expect(screen.getByTestId('pricing-table')).toBeInTheDocument()
+ expect(screen.queryByTestId('add-payment-preview')).not.toBeInTheDocument()
+ expect(screen.queryByTestId('transition-preview')).not.toBeInTheDocument()
+ })
+
+ it('shows close button and hides back button on pricing step', () => {
+ renderComponent()
+ expect(screen.getByLabelText('Close')).toBeInTheDocument()
+ expect(screen.queryByLabelText('Back')).not.toBeInTheDocument()
+ })
+
+ it('calls onClose when close button is clicked', async () => {
+ const user = userEvent.setup()
+ const onClose = vi.fn()
+ renderComponent({ onClose })
+
+ await user.click(screen.getByLabelText('Close'))
+
+ expect(onClose).toHaveBeenCalledOnce()
+ })
+
+ it('shows back button on preview step', () => {
+ mockCheckoutStep.value = 'preview'
+ mockPreviewData.value = { transition_type: 'new_subscription' }
+ renderComponent()
+ expect(screen.getByLabelText('Back')).toBeInTheDocument()
+ })
+
+ it('shows insufficient credits message when reason is out_of_credits', () => {
+ renderComponent({ reason: 'out_of_credits' })
+ expect(screen.getByText('Insufficient Credits')).toBeInTheDocument()
+ expect(screen.getByText('You have run out of credits.')).toBeInTheDocument()
+ })
+
+ it('does not show insufficient credits message without reason', () => {
+ renderComponent()
+ expect(screen.queryByText('Insufficient Credits')).not.toBeInTheDocument()
+ })
+
+ it('shows new subscription preview when transition_type is new_subscription', () => {
+ mockCheckoutStep.value = 'preview'
+ mockPreviewData.value = { transition_type: 'new_subscription' }
+ renderComponent()
+ expect(screen.getByTestId('add-payment-preview')).toBeInTheDocument()
+ expect(screen.queryByTestId('transition-preview')).not.toBeInTheDocument()
+ })
+
+ it('shows transition preview when transition_type is upgrade', () => {
+ mockCheckoutStep.value = 'preview'
+ mockPreviewData.value = { transition_type: 'upgrade' }
+ renderComponent()
+ expect(screen.getByTestId('transition-preview')).toBeInTheDocument()
+ expect(screen.queryByTestId('add-payment-preview')).not.toBeInTheDocument()
+ })
+
+ it('wires subscribe event to handleSubscribeClick', async () => {
+ const user = userEvent.setup()
+ renderComponent()
+
+ await user.click(screen.getByTestId('subscribe-btn'))
+
+ expect(mockHandleSubscribeClick).toHaveBeenCalledWith({
+ tierKey: 'standard',
+ billingCycle: 'yearly'
+ })
+ })
+
+ it('wires resubscribe event to handleResubscribe', async () => {
+ const user = userEvent.setup()
+ renderComponent()
+
+ await user.click(screen.getByTestId('resubscribe-btn'))
+
+ expect(mockHandleResubscribe).toHaveBeenCalled()
+ })
+
+ it('wires back button to handleBackToPricing', async () => {
+ const user = userEvent.setup()
+ mockCheckoutStep.value = 'preview'
+ mockPreviewData.value = { transition_type: 'new_subscription' }
+ renderComponent()
+
+ await user.click(screen.getByLabelText('Back'))
+
+ expect(mockHandleBackToPricing).toHaveBeenCalled()
+ })
+})
diff --git a/src/platform/workspace/components/SubscriptionRequiredDialogContentWorkspace.vue b/src/platform/workspace/components/SubscriptionRequiredDialogContentWorkspace.vue
index bbceecd5b4..f8a815ac37 100644
--- a/src/platform/workspace/components/SubscriptionRequiredDialogContentWorkspace.vue
+++ b/src/platform/workspace/components/SubscriptionRequiredDialogContentWorkspace.vue
@@ -18,7 +18,7 @@
variant="muted-textonly"
class="absolute top-2.5 right-2.5 shrink-0 rounded-full text-text-secondary hover:bg-white/10"
:aria-label="$t('g.close')"
- @click="handleClose"
+ @click="onClose"
>
@@ -94,28 +94,14 @@