The all-in-one local AI studio for your desktop: chat, image and video generation and a coding agent in one free, open source app. Windows and Linux. No Docker, no terminal, no cloud required.
TypeScript agentai-chatai-studioall-in-onecoding-agentdesktop-appfluximage-generationlinuxllmlocal-ailocal-llmopen-sourceprivacyself-hostedstable-diffusionuncensoreduncensored-aivideo-generationwindows
import { describe, it, expect } from 'vitest'
import { validateWorkflowJson, extractSearchTerms, autoDetectParameterMap, injectParameters, parseImportedWorkflow, } from '../workflows'
import type { ModelType, VideoParams } from '../comfyui'
describe('workflows — pure functions', () => {
// ─── validateWorkflowJson ───
describe('validateWorkflowJson', () => {
it('accepts valid API format (nodes with class_type)', () => {
const wf = {
'1': { class_type: 'CheckpointLoaderSimple', inputs: { ckpt_name: 'model.safetensors' } },
'2': { class_type: 'KSampler', inputs: { seed: 42 } },
}
expect(validateWorkflowJson(wf)).toBe(true)
})
it('R2-32: rejects Web/UI canvas format (nodes array with type), no caller reads that shape', () => {
const wf = {
nodes: [
{ id: 1, type: 'CheckpointLoaderSimple', widgets_values: [] },
{ id: 2, type: 'KSampler', widgets_values: [] },
],
links: [],
}
expect(validateWorkflowJson(wf)).toBe(false)
})
it('rejects object with no nodes (no class_type or nodes array)', () => {
expect(validateWorkflowJson({ foo: 'bar', baz: 123 })).toBe(false)
})
it('rejects empty object', () => {
expect(validateWorkflowJson({})).toBe(false)
})
it('rejects null', () => {
expect(validateWorkflowJson(null)).toBe(false)
})
it('rejects a string', () => {
expect(validateWorkflowJson('hello')).toBe(false)
})
it('rejects an array', () => {
expect(validateWorkflowJson([1, 2, 3])).toBe(false)
})
it('rejects undefined', () => {
expect(validateWorkflowJson(undefined)).toBe(false)
})
it('R2-32: rejects web format even without links key (still not API shape)', () => {
const wf = {
nodes: [{ id: 1, type: 'SaveImage' }],
}
expect(validateWorkflowJson(wf)).toBe(false)
})
it('rejects nodes array with objects missing type field', () => {
const wf = {
nodes: [{ id: 1, name: 'nottype' }],
}
expect(validateWorkflowJson(wf)).toBe(false)
})
})
it('injects LU dimensions into a legacy ImageResizeKJv2 workflow', async () => {
const wf = {
'10': {
class_type: 'LoadImage',
inputs: {
image: 'placeholder.png',
},
},
'16': {
class_type: 'ImageResizeKJv2',
inputs: {
width: 512,
height: 512,
image: ['10', 0],
},
},
'9': {
class_type: 'WanImageToVideo',
inputs: {
width: ['16', 1],
height: ['16', 2],
start_image: ['16', 0],
},
},
}
const injected = await injectParameters(
wf,
{},
{
prompt: 'test',
negativePrompt: '',
model: 'test.safetensors',
sampler: 'euler',
scheduler: 'normal',
steps: 20,
cfgScale: 5,
width: 832,
height: 480,
seed: 1,
batchSize: 1,
frames: 81,
fps: 16,
inputImage: 'source.png',
},
'wan',
)
expect(injected['16'].inputs?.width).toBe(832)
expect(injected['16'].inputs?.height).toBe(480)
// WanImageToVideo must remain connected to the resize node.
expect(injected['9'].inputs?.width).toEqual(['16', 1])
expect(injected['9'].inputs?.height).toEqual(['16', 2])
})
describe('injectParameters — source image', () => {
// Als VideoParams deklariert statt am Aufruf gecastet: fehlte hier ein
// Pflichtfeld, hat der Cast es durchgelassen und die Injektion lief gegen
// eine unvollstaendige Eingabe.
const videoParams: VideoParams = {
model: 'wan2.2_i2v.safetensors',
prompt: 'gentle camera movement',
negativePrompt: '',
sampler: 'euler',
scheduler: 'simple',
steps: 20,
cfgScale: 5,
width: 832,
height: 480,
seed: 7,
batchSize: 1,
frames: 33,
fps: 16,
inputImage: 'lu-selected-image.png',
}
it('injects the LU image into the mapped LoadImage node', async () => {
const workflow = {
'12': {
class_type: 'LoadImage',
inputs: {
image: 'placeholder.png',
},
},
}
const parameterMap = autoDetectParameterMap(workflow)
const result = await injectParameters(
workflow,
parameterMap,
videoParams,
'wan' as ModelType,
)
expect(result['12'].inputs?.image).toBe(
'lu-selected-image.png',
)
// Injection works on a cloned workflow.
expect(workflow['12'].inputs?.image).toBe(
'placeholder.png',
)
})
it('supports older saved maps without inputImage metadata', async () => {
const workflow = {
'27': {
class_type: 'LoadImage',
inputs: {
image: 'old-image.png',
},
},
}
const result = await injectParameters(
workflow,
{},
videoParams,
'wan' as ModelType,
)
expect(result['27'].inputs?.image).toBe(
'lu-selected-image.png',
)
})
})
// ─── extractSearchTerms ───
describe('extractSearchTerms', () => {
it('returns type-specific terms for flux', () => {
const result = extractSearchTerms('flux1-schnell-fp8.safetensors', 'flux' as ModelType)
expect(result).toBe('flux comfyui workflow')
})
it('returns type-specific terms for sdxl', () => {
const result = extractSearchTerms('juggernaut.safetensors', 'sdxl' as ModelType)
expect(result).toBe('sdxl comfyui workflow')
})
it('returns type-specific terms for sd15', () => {
const result = extractSearchTerms('realisticVision.safetensors', 'sd15' as ModelType)
expect(result).toBe('sd 1.5 comfyui workflow')
})
it('returns type-specific terms for flux2', () => {
const result = extractSearchTerms('flux2.safetensors', 'flux2' as ModelType)
expect(result).toBe('flux 2 comfyui workflow')
})
it('returns type-specific terms for wan', () => {
const result = extractSearchTerms('wan2.1_t2v.safetensors', 'wan' as ModelType)
expect(result).toBe('wan comfyui workflow')
})
it('returns type-specific terms for hunyuan', () => {
const result = extractSearchTerms('hunyuanvideo.safetensors', 'hunyuan' as ModelType)
expect(result).toBe('hunyuan comfyui workflow')
})
it('strips extensions and noise words for unknown type', () => {
const result = extractSearchTerms('my-cool-model_fp16.safetensors', 'unknown' as ModelType)
expect(result).toContain('comfyui workflow')
expect(result).not.toContain('fp16')
expect(result).not.toContain('safetensors')
})
it('keeps only first 3 meaningful words for unknown type', () => {
const result = extractSearchTerms('very-long-model-name-with-many-parts.safetensors', 'unknown' as ModelType)
const parts = result.replace(' comfyui workflow', '').split(' ')
expect(parts.length).toBeLessThanOrEqual(3)
})
it('returns generic fallback for empty-ish model name', () => {
const result = extractSearchTerms('.safetensors', 'unknown' as ModelType)
expect(result).toBe('comfyui workflow')
})
})
// ─── autoDetectParameterMap ───
it('detects ImageResizeKJv2 dimensions for custom I2V workflows', () => {
const wf = {
'10': {
class_type: 'LoadImage',
inputs: {
image: 'placeholder.png',
},
},
'16': {
class_type: 'ImageResizeKJv2',
inputs: {
width: 512,
height: 512,
image: ['10', 0],
},
},
'9': {
class_type: 'WanImageToVideo',
inputs: {
width: ['16', 1],
height: ['16', 2],
start_image: ['16', 0],
},
},
}
const map = autoDetectParameterMap(wf)
expect(map.width).toEqual({
nodeId: '16',
inputKey: 'width',
})
expect(map.height).toEqual({
nodeId: '16',
inputKey: 'height',
})
})
describe('autoDetectParameterMap', () => {
it('detects KSampler parameters (seed, steps, cfg, sampler, scheduler)', () => {
const wf = {
'1': { class_type: 'KSampler', inputs: { seed: 0, steps: 20, cfg: 7, sampler_name: 'euler', scheduler: 'normal', positive: null, negative: null } },
}
const map = autoDetectParameterMap(wf)
expect(map.seed).toEqual({ nodeId: '1', inputKey: 'seed' })
expect(map.steps).toEqual({ nodeId: '1', inputKey: 'steps' })
expect(map.cfgScale).toEqual({ nodeId: '1', inputKey: 'cfg' })
expect(map.sampler).toEqual({ nodeId: '1', inputKey: 'sampler_name' })
expect(map.scheduler).toEqual({ nodeId: '1', inputKey: 'scheduler' })
})
it('detects KSamplerAdvanced the same way', () => {
const wf = {
'1': { class_type: 'KSamplerAdvanced', inputs: { noise_seed: 0, steps: 30, cfg: 5, sampler_name: 'dpmpp_2m', scheduler: 'karras', positive: null, negative: null } },
}
const map = autoDetectParameterMap(wf)
expect(map.seed).toBeDefined()
expect(map.steps).toBeDefined()
})
it('detects EmptyLatentImage (width, height, batchSize)', () => {
const wf = {
'1': { class_type: 'EmptyLatentImage', inputs: { width: 1024, height: 1024, batch_size: 1 } },
}
const map = autoDetectParameterMap(wf)
expect(map.width).toEqual({ nodeId: '1', inputKey: 'width' })
expect(map.height).toEqual({ nodeId: '1', inputKey: 'height' })
expect(map.batchSize).toEqual({ nodeId: '1', inputKey: 'batch_size' })
})
it('detects EmptySD3LatentImage as well', () => {
const wf = {
'1': { class_type: 'EmptySD3LatentImage', inputs: { width: 1024, height: 1024, batch_size: 1 } },
}
const map = autoDetectParameterMap(wf)
expect(map.width).toBeDefined()
expect(map.height).toBeDefined()
})
it('detects EmptyHunyuanLatentVideo (frames, fps via SaveAnimatedWEBP)', () => {
const wf = {
'1': { class_type: 'EmptyHunyuanLatentVideo', inputs: { width: 848, height: 480, length: 24 } },
'2': { class_type: 'SaveAnimatedWEBP', inputs: { fps: 8 } },
}
const map = autoDetectParameterMap(wf)
expect(map.frames).toEqual({ nodeId: '1', inputKey: 'length' })
expect(map.fps).toEqual({ nodeId: '2', inputKey: 'fps' })
})
it('detects VHS_VideoCombine for fps (frame_rate)', () => {
const wf = {
'1': { class_type: 'VHS_VideoCombine', inputs: { frame_rate: 24 } },
}
const map = autoDetectParameterMap(wf)
expect(map.fps).toEqual({ nodeId: '1', inputKey: 'frame_rate' })
})
it('detects CLIPTextEncode for prompt via KSampler positive connection', () => {
const wf = {
'1': { class_type: 'CLIPTextEncode', inputs: { text: '' } },
'2': { class_type: 'CLIPTextEncode', inputs: { text: '' } },
'3': {
class_type: 'KSampler',
inputs: {
positive: ['1', 0],
negative: ['2', 0],
seed: 0, steps: 20, cfg: 7, sampler_name: 'euler', scheduler: 'normal',
},
},
}
const map = autoDetectParameterMap(wf)
expect(map.positivePrompt).toEqual({ nodeId: '1', inputKey: 'text' })
expect(map.negativePrompt).toEqual({ nodeId: '2', inputKey: 'text' })
})
it('falls back to first CLIPTextEncode when no KSampler connection', () => {
const wf = {
'10': { class_type: 'CLIPTextEncode', inputs: { text: 'prompt1' } },
'11': { class_type: 'CLIPTextEncode', inputs: { text: 'prompt2' } },
}
const map = autoDetectParameterMap(wf)
expect(map.positivePrompt).toBeDefined()
})
it('detects CheckpointLoaderSimple for model', () => {
const wf = {
'1': { class_type: 'CheckpointLoaderSimple', inputs: { ckpt_name: 'model.safetensors' } },
}
const map = autoDetectParameterMap(wf)
expect(map.model).toEqual({ nodeId: '1', inputKey: 'ckpt_name', loaderType: 'checkpoint' })
})
it('detects UNETLoader for model', () => {
const wf = {
'1': { class_type: 'UNETLoader', inputs: { unet_name: 'flux.safetensors' } },
}
const map = autoDetectParameterMap(wf)
expect(map.model).toEqual({ nodeId: '1', inputKey: 'unet_name', loaderType: 'unet' })
})
it('returns empty map for workflow with no recognized nodes', () => {
const wf = {
'1': { class_type: 'SomeCustomNode', inputs: { foo: 'bar' } },
}
const map = autoDetectParameterMap(wf)
expect(map.seed).toBeUndefined()
expect(map.steps).toBeUndefined()
expect(map.model).toBeUndefined()
})
})
// ─── parseImportedWorkflow ───
describe('parseImportedWorkflow', () => {
it('wraps a workflow into a template structure', () => {
const wf = {
'1': { class_type: 'CheckpointLoaderSimple', inputs: { ckpt_name: 'test.safetensors' } },
'2': { class_type: 'EmptyLatentImage', inputs: { width: 512, height: 512, batch_size: 1 } },
'3': { class_type: 'KSampler', inputs: { seed: 0, steps: 20, cfg: 7, sampler_name: 'euler', scheduler: 'normal', positive: null, negative: null } },
'4': { class_type: 'SaveImage', inputs: { images: ['3', 0] } },
}
const result = parseImportedWorkflow('My Workflow', wf)
expect(result.name).toBe('My Workflow')
expect(result.workflow).toBe(wf)
expect(result.source).toBe('manual')
expect(result.mode).toBe('image')
})
it('detects video mode from EmptyHunyuanLatentVideo', () => {
const wf = {
'1': { class_type: 'UNETLoader', inputs: {} },
'2': { class_type: 'EmptyHunyuanLatentVideo', inputs: { width: 848, height: 480, length: 24 } },
'3': { class_type: 'SaveAnimatedWEBP', inputs: {} },
}
const result = parseImportedWorkflow('Video WF', wf)
expect(result.mode).toBe('video')
})
it('detects model types from CheckpointLoaderSimple', () => {
const wf = {
'1': { class_type: 'CheckpointLoaderSimple', inputs: { ckpt_name: 'model.safetensors' } },
'2': { class_type: 'SaveImage', inputs: {} },
}
const result = parseImportedWorkflow('Test', wf)
expect(result.modelTypes).toContain('sdxl')
expect(result.modelTypes).toContain('sd15')
})
it('auto-detects parameter map', () => {
const wf = {
'1': { class_type: 'KSampler', inputs: { seed: 0, steps: 20, cfg: 7, sampler_name: 'euler', scheduler: 'normal', positive: null, negative: null } },
}
const result = parseImportedWorkflow('Test', wf)
expect(result.parameterMap.seed).toBeDefined()
expect(result.parameterMap.steps).toBeDefined()
})
it('uses provided source and sourceUrl', () => {
const wf = { '1': { class_type: 'SaveImage', inputs: {} } }
const result = parseImportedWorkflow('Test', wf, 'civitai', 'https://civitai.com/models/123')
expect(result.source).toBe('civitai')
expect(result.sourceUrl).toBe('https://civitai.com/models/123')
})
})
})