Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { render, screen, fireEvent, waitFor, act } from '@testing-library/react';
import { MemoryRouter } from 'react-router';
vi.mock('../../services/api', () => ({
getSettings: vi.fn(),
patchSettingsSlice: vi.fn(),
getImageGenStatus: vi.fn(),
getVideoGenModelContext: vi.fn(),
generateImage: vi.fn(),
registerTool: vi.fn(),
updateTool: vi.fn(),
getToolsList: vi.fn(),
saveHfToken: vi.fn(),
clearHfToken: vi.fn(),
getCredentialInventory: vi.fn(),
saveCredential: vi.fn(),
listAgyImageModels: vi.fn(),
listImageModels: vi.fn(),
getProviders: vi.fn(),
}));
vi.mock('../../hooks/useHfTokenStatus', () => ({
useHfTokenStatus: vi.fn(),
}));
vi.mock('../ui/Toast', () => ({
default: Object.assign(vi.fn(), {
success: vi.fn(), error: vi.fn(), warning: vi.fn(), info: vi.fn(),
}),
}));
// LocalSetupPanel has its own SSE/install-stream deps — stub it out; this suite
// only cares that the Local tab hosts a python-path panel.
vi.mock('./LocalSetupPanel', () => ({
default: ({ pythonPath }) => <div data-testid="local-setup-panel">{pythonPath}</div>,
}));
// The runtime card's install modal opens its own SSE stream.
vi.mock('../imageGen/Flux2InstallModal', () => ({ default: () => null }));
import {
getSettings, getToolsList, patchSettingsSlice, listAgyImageModels, listImageModels, getImageGenStatus,
getVideoGenModelContext, generateImage, getCredentialInventory, getProviders, registerTool,
} from '../../services/api';
import { useHfTokenStatus } from '../../hooks/useHfTokenStatus';
import { ImageGenTab, MEDIA_TABS } from './ImageGenTab';
import { IMAGE_GEN_MODE } from '../../lib/imageGenBackends';
// Every slice PATCH a save sent, keyed by slice path.
const sentSlices = () => Object.fromEntries(patchSettingsSlice.mock.calls.map(([slicePath, partial]) => [slicePath, partial]));
const awaitSave = () => waitFor(() => expect(patchSettingsSlice).toHaveBeenCalled());
const renderTab = async (initialEntries = ['/media/image']) => {
const view = render(
<MemoryRouter initialEntries={initialEntries}>
<ImageGenTab />
</MemoryRouter>,
);
// Cards render only after the settings fetch resolves.
await waitFor(() => expect(screen.getByRole('tablist')).toBeTruthy());
return view;
};
beforeEach(() => {
vi.clearAllMocks();
getSettings.mockResolvedValue({
imageGen: {
mode: 'external',
external: { sdapiUrl: 'http://localhost:7860' },
local: { pythonPath: '/usr/bin/python3' },
codex: { enabled: false },
expose: { a1111: false },
},
});
getToolsList.mockResolvedValue([]);
getImageGenStatus.mockResolvedValue({ connected: true, mode: 'local', readiness: 'ready', model: 'FLUX.1 Dev', modelId: 'dev' });
getVideoGenModelContext.mockResolvedValue({
models: [
{ id: 'fastmetal_5b_qad', name: 'FastMetal 5B QAD' },
{ id: 'ltx23_distilled_q4', name: 'LTX-2.3 Distilled Q4' },
],
defaultModel: 'fastmetal_5b_qad',
});
useHfTokenStatus.mockReturnValue({ present: false, source: 'none', refresh: vi.fn() });
getCredentialInventory.mockResolvedValue({
headline: '', credentials: [
{ id: 'fal', label: 'fal.ai', configured: false, source: 'none', editable: true },
{ id: 'reactor', label: 'reactor.inc', configured: false, source: 'none', editable: true },
],
});
patchSettingsSlice.mockResolvedValue({});
getProviders.mockResolvedValue({
providers: [{ id: 'codex', type: 'cli', command: 'codex', models: ['gpt-6-sol', 'gpt-6-luna', 'gpt-5.6-luna'] }],
});
listAgyImageModels.mockResolvedValue({ models: ['gemini-image', 'custom/image-v2'], error: null });
listImageModels.mockResolvedValue([
{ id: 'dev', name: 'FLUX.1 Dev' },
{ id: 'qwen-image-2.1', name: 'Qwen-Image 2.1' },
{ id: 'flux2-klein-4b', name: 'FLUX.2 Klein' },
]);
});
describe('ImageGenTab grouped tabs', () => {
// Catches persisting a second key or dropping Runway's enable/model/resolution slice.
it('configures Runway images with the shared credential and persists its own rendering settings', async () => {
await renderTab(['/media/image?mediaTab=runway']);
expect(screen.getByRole('heading', { name: 'Runway Imagegen' })).toBeTruthy();
expect(screen.getByRole('link', { name: 'Settings → Credentials' }).getAttribute('href')).toBe('/settings/credentials');
expect(screen.queryByPlaceholderText('key_...')).toBeNull();
fireEvent.click(screen.getByRole('checkbox', { name: 'Enable Runway Imagegen' }));
fireEvent.change(screen.getByLabelText('Default model'), { target: { value: 'gen4_image_turbo' } });
fireEvent.change(screen.getByLabelText('Resolution'), { target: { value: '1080p' } });
fireEvent.click(screen.getByRole('button', { name: 'Save' }));
await waitFor(() => expect(patchSettingsSlice).toHaveBeenCalledWith('imageGen.runway', expect.objectContaining({ enabled: true, model: 'gen4_image_turbo', resolution: '1080p' }), expect.anything()));
});
it.each([undefined, { min: 1, max: Number.MAX_SAFE_INTEGER, default: 1 }])(
'loads and saves render limits above ten with bounds %j', async (parallelLimitBounds) => {
getSettings.mockResolvedValue({
imageGen: {
mode: 'codex', codex: { enabled: true, parallelLimit: 25, parallelLimitBounds },
},
});
await renderTab(['/media/image?mediaTab=codex']);
// The Codex section's model list loads late (getProviders). Wait for it to
// land so its state update happens inside the waitFor, not after the edit.
await waitFor(() => expect(screen.getByRole('option', { name: 'gpt-5.6-luna' })).toBeTruthy());
const input = screen.getByLabelText('Parallel render limit');
expect(input.value).toBe('25');
fireEvent.change(input, { target: { value: '50' } });
fireEvent.blur(input);
expect(input.value).toBe('50');
fireEvent.click(screen.getByRole('button', { name: /^Save$/ }));
await awaitSave();
expect(sentSlices()['imageGen.codex'].parallelLimit).toBe(50);
},
);
it('renders a pills sub-nav with all media-settings groups', async () => {
await renderTab();
const tabs = screen.getAllByRole('tab').map((t) => t.textContent);
for (const label of ['Backend', 'External', 'Local', 'Codex CLI', 'Grok CLI', 'Agy CLI', 'Tokens', 'Expose', 'Test']) {
expect(tabs.some((t) => t.includes(label))).toBe(true);
}
});
it('defaults to the Backend tab and shows the mode cards', async () => {
await renderTab();
expect(screen.getByRole('heading', { name: 'Backend' })).toBeTruthy();
expect(screen.getByText('External SD API')).toBeTruthy();
expect(screen.getByText('Local models')).toBeTruthy();
// Sections from other tabs are not mounted in the default view.
expect(screen.queryByText('HuggingFace Token')).toBeNull();
expect(screen.queryByText('Test Render')).toBeNull();
});
it('switches to the External tab and shows only that group', async () => {
await renderTab();
fireEvent.click(screen.getByRole('tab', { name: /External/i }));
expect(screen.getByText('External AUTOMATIC1111 / Forge URL')).toBeTruthy();
// Backend mode cards are no longer mounted.
expect(screen.queryByText('External SD API')).toBeNull();
});
it('hosts the python-path panel on the Local tab regardless of active mode', async () => {
await renderTab();
fireEvent.click(screen.getByRole('tab', { name: /^Local/i }));
expect(screen.getByTestId('local-setup-panel')).toBeTruthy();
// The tab's lazy model-catalog probe resolves after the click.
await act(async () => {});
});
it.each([
['moss-image-sft-bf16', true],
['schnell', false],
])('offers a Python-free local test backend only for the native model pin %s', async (modelId, available) => {
getSettings.mockResolvedValue({ imageGen: {
mode: 'external', external: { sdapiUrl: 'http://localhost:7860' }, local: { modelId },
} });
await renderTab(['/media/image?mediaTab=test']);
const options = [...screen.getByLabelText('Backend').options].map(option => option.value);
expect(options.includes('local')).toBe(available);
});
it('registers the local image tool for a MOSS pin without a Python interpreter', async () => {
getSettings.mockResolvedValue({ imageGen: {
mode: 'external', external: { sdapiUrl: 'http://localhost:7860' }, local: { modelId: 'moss-image-sft-bf16' },
} });
await renderTab();
fireEvent.click(screen.getByRole('button', { name: /Local models/ }));
fireEvent.click(screen.getByRole('button', { name: /^Save$/ }));
await waitFor(() => expect(registerTool).toHaveBeenCalledWith(expect.objectContaining({
id: 'sdapi', enabled: true, config: expect.objectContaining({ mode: 'local', pythonPath: '' }),
}), { silent: true }));
});
it('lets the user set a default local video model separately from the backend target', async () => {
await renderTab(['/media/image?mediaTab=local']);
await act(async () => {});
const select = screen.getByLabelText('Default local video model');
expect(select.value).toBe('');
expect(screen.getByRole('option', { name: 'Install default (FastMetal 5B QAD)' })).toBeTruthy();
fireEvent.change(select, { target: { value: 'ltx23_distilled_q4' } });
fireEvent.click(screen.getByRole('button', { name: /^Save$/ }));
await awaitSave();
expect(sentSlices().videoGen).toEqual({ defaultModelId: 'ltx23_distilled_q4' });
});
it('clears the saved local video model pin to follow the install default', async () => {
getSettings.mockResolvedValue({
imageGen: { mode: 'external', external: { sdapiUrl: 'http://localhost:7860' } },
videoGen: { defaultModelId: 'ltx23_distilled_q4' },
});
await renderTab(['/media/image?mediaTab=local']);
await act(async () => {});
fireEvent.change(screen.getByLabelText('Default local video model'), { target: { value: '' } });
fireEvent.click(screen.getByRole('button', { name: /^Save$/ }));
await awaitSave();
expect(sentSlices().videoGen).toEqual({ defaultModelId: null });
});
it('keeps LocalSetupPanel mounted (hidden) after leaving the Local tab so an in-flight install stream is not torn down', async () => {
await renderTab();
// Not mounted until first visited (avoids a cold python-env probe).
expect(screen.queryByTestId('local-setup-panel')).toBeNull();
fireEvent.click(screen.getByRole('tab', { name: /^Local/i }));
await act(async () => {});
const panel = screen.getByTestId('local-setup-panel');
// Switch away — the panel must stay in the DOM (its install EventSource
// survives), just visually hidden, rather than unmounting.
fireEvent.click(screen.getByRole('tab', { name: /Backend/i }));
expect(screen.getByTestId('local-setup-panel')).toBe(panel);
expect(panel.closest('div.hidden')).not.toBeNull();
});
it('deep-links the active sub-tab from the mediaTab search param', async () => {
await renderTab(['/media/image?mediaTab=tokens']);
// The Tokens group renders immediately without a click.
expect(screen.getByRole('heading', { name: 'HuggingFace Token' })).toBeTruthy();
const tokensTab = screen.getByRole('tab', { name: /Tokens/i });
expect(tokensTab.getAttribute('aria-selected')).toBe('true');
});
it('keeps the detailed managed-token source labels while reading shared status', async () => {
useHfTokenStatus.mockReturnValue({ present: true, source: 'cli', refresh: vi.fn() });
await renderTab(['/media/image?mediaTab=tokens']);
expect(screen.getByText(/~\/\.cache\/huggingface\/token — set via `hf auth login`/i)).toBeTruthy();
});
it('keeps the global Save + Test Connection bar visible on every tab', async () => {
await renderTab();
expect(screen.getByRole('button', { name: /^Save$/ })).toBeTruthy();
expect(screen.getByRole('button', { name: /Test Connection/i })).toBeTruthy();
// Still present after switching to a non-backend tab.
fireEvent.click(screen.getByRole('tab', { name: /Expose/i }));
expect(screen.getByText('Expose as A1111 API on the Tailnet')).toBeTruthy();
expect(screen.getByRole('button', { name: /^Save$/ })).toBeTruthy();
});
it('tags every image-gen backend onto a tab, so a new backend cannot silently probe the default instead', () => {
const probed = MEDIA_TABS.map((t) => t.probeMode).filter(Boolean);
expect([...probed].sort()).toEqual([...Object.values(IMAGE_GEN_MODE)].sort());
});
it('probes the provider whose tab is open, not the saved default backend', async () => {
getImageGenStatus.mockResolvedValue({ connected: true, mode: 'agy', model: 'agy 1.2.3' });
await renderTab();
// On a provider tab the probe targets THAT provider — testing from the Agy
// tab must not report the saved default (external/codex) backend.
fireEvent.click(screen.getByRole('tab', { name: /Agy CLI/i }));
fireEvent.click(screen.getByRole('button', { name: /Test Connection/i }));
await waitFor(() => expect(getImageGenStatus).toHaveBeenCalledWith('agy'));
getImageGenStatus.mockResolvedValue({ connected: true, mode: 'grok', model: 'grok-cli 0.0.30' });
fireEvent.click(screen.getByRole('tab', { name: /Grok CLI/i }));
fireEvent.click(screen.getByRole('button', { name: /Test Connection/i }));
await waitFor(() => expect(getImageGenStatus).toHaveBeenLastCalledWith('grok'));
});
it('falls back to the saved default backend on tabs with no provider of their own', async () => {
getImageGenStatus.mockResolvedValue({ connected: true, mode: 'external', model: 'flux-v1' });
await renderTab();
fireEvent.click(screen.getByRole('button', { name: /Test Connection/i }));
await waitFor(() => expect(screen.getByText(/Ready — external — flux-v1/)).toBeTruthy());
expect(getImageGenStatus).toHaveBeenCalledWith(undefined);
});
it('hides a probe result once the user switches to another tab', async () => {
getImageGenStatus.mockResolvedValue({ connected: true, mode: 'grok', model: 'grok-cli 0.0.30' });
await renderTab();
fireEvent.click(screen.getByRole('tab', { name: /Grok CLI/i }));
fireEvent.click(screen.getByRole('button', { name: /Test Connection/i }));
await waitFor(() => expect(screen.getByText(/grok — grok-cli 0\.0\.30/)).toBeTruthy());
fireEvent.click(screen.getByRole('tab', { name: /Agy CLI/i }));
expect(screen.queryByText(/grok — grok-cli 0\.0\.30/)).toBeNull();
});
it('keeps an inconclusive local probe distinct from an unavailable runtime', async () => {
getImageGenStatus.mockResolvedValue({
connected: false,
mode: 'local',
readiness: 'unknown',
reason: 'Could not verify the configured Python runtime',
});
await renderTab();
fireEvent.click(screen.getByRole('tab', { name: /^Local/i }));
fireEvent.click(screen.getByRole('button', { name: /Test Connection/i }));
await waitFor(() => expect(screen.getByText(/Could not verify — Could not verify the configured Python runtime/)).toBeTruthy());
});
it('never shows an in-flight probe result under the tab the user switched to', async () => {
// Probe started on Grok, answered only after the user moved to Agy — the
// late response must not surface as if it described Agy.
let resolveProbe;
getImageGenStatus.mockReturnValue(new Promise((resolve) => { resolveProbe = resolve; }));
await renderTab();
fireEvent.click(screen.getByRole('tab', { name: /Grok CLI/i }));
fireEvent.click(screen.getByRole('button', { name: /Test Connection/i }));
fireEvent.click(screen.getByRole('tab', { name: /Agy CLI/i }));
resolveProbe({ connected: true, mode: 'grok', model: 'grok-cli 0.0.30' });
await waitFor(() => expect(screen.getByRole('button', { name: /Test Connection/i }).disabled).toBe(false));
expect(screen.queryByText(/grok — grok-cli 0\.0\.30/)).toBeNull();
// Going back to Grok shows the answer that was actually asked for there.
fireEvent.click(screen.getByRole('tab', { name: /Grok CLI/i }));
expect(screen.getByText(/grok — grok-cli 0\.0\.30/)).toBeTruthy();
});
it('saves only the changed fields as slice patches, so a sibling panel\'s later write survives (#12030)', async () => {
// The drawer loaded pythonPath '/usr/bin/python3'. While it is open,
// VideoGen's LocalSetupPanel patches imageGen.local.pythonPath to a new
// interpreter — a write this drawer cannot see. Its save must not carry
// a snapshot of imageGen.local (or of any slice the user did not edit).
await renderTab();
fireEvent.click(screen.getByRole('tab', { name: /External/i }));
const urlInput = screen.getByPlaceholderText('http://localhost:7860');
fireEvent.change(urlInput, { target: { value: 'http://localhost:9999' } });
const saveBtn = screen.getByRole('button', { name: /^Save$/ });
expect(saveBtn.disabled).toBe(false);
fireEvent.click(saveBtn);
await awaitSave();
// The legacy flat `imageGen.sdapiUrl` is kept populated beside the
// external slice; nothing else travels.
expect(sentSlices()).toEqual({
'imageGen.external': { sdapiUrl: 'http://localhost:9999' },
imageGen: { sdapiUrl: 'http://localhost:9999' },
});
expect(patchSettingsSlice.mock.calls.every(([, , options]) => options?.silent === true)).toBe(true);
await waitFor(() => expect(saveBtn.disabled).toBe(true));
});
it('keeps the form dirty and re-sends the same patches when a slice save fails', async () => {
patchSettingsSlice.mockRejectedValueOnce(new Error('offline'));
await renderTab();
fireEvent.click(screen.getByRole('tab', { name: /External/i }));
fireEvent.change(screen.getByPlaceholderText('http://localhost:7860'), { target: { value: 'http://localhost:9999' } });
const saveBtn = screen.getByRole('button', { name: /^Save$/ });
fireEvent.click(saveBtn);
await awaitSave();
await waitFor(() => expect(saveBtn.disabled).toBe(false));
patchSettingsSlice.mockClear();
fireEvent.click(saveBtn);
await awaitSave();
expect(sentSlices()['imageGen.external']).toEqual({ sdapiUrl: 'http://localhost:9999' });
});
it('offers the Codex provider\'s models in a picker and keeps an unlisted stored pin', async () => {
getSettings.mockResolvedValue({
imageGen: { mode: 'codex', codex: { enabled: true, model: 'gpt-retired' }, expose: { a1111: false } },
});
await renderTab(['/media/image?mediaTab=codex']);
const select = await screen.findByLabelText('Model override (optional)');
await waitFor(() => expect(screen.getByRole('option', { name: 'gpt-6-sol' })).toBeTruthy());
// A stored model the catalog no longer lists stays selected rather than
// rendering blank and being dropped on the next save.
expect(select.value).toBe('gpt-retired');
expect(screen.getByRole('option', { name: /^Default \(gpt-6-luna\)/ })).toBeTruthy();
fireEvent.change(select, { target: { value: 'gpt-6-sol' } });
fireEvent.click(screen.getByRole('button', { name: /^Save$/ }));
await awaitSave();
expect(sentSlices()['imageGen.codex']).toEqual({ model: 'gpt-6-sol' });
});
it('shows a retryable error, not a bare default-only picker, when the Codex provider read fails', async () => {
getSettings.mockResolvedValue({
imageGen: { mode: 'codex', codex: { enabled: true }, expose: { a1111: false } },
});
getProviders.mockRejectedValueOnce(new Error('providers down'));
await renderTab(['/media/image?mediaTab=codex']);
expect(await screen.findByText(/Could not load your Codex provider's models/)).toBeTruthy();
expect(screen.queryByRole('option', { name: 'gpt-6-sol' })).toBeNull();
fireEvent.click(screen.getByRole('button', { name: 'Retry' }));
expect(await screen.findByRole('option', { name: 'gpt-6-sol' })).toBeTruthy();
expect(screen.queryByText(/Could not load your Codex provider's models/)).toBeNull();
});
it('pins the install-wide default local model and saves it under imageGen.local.modelId', async () => {
await renderTab(['/media/image?mediaTab=local']);
await act(async () => {});
const select = screen.getByLabelText('Default model');
// Nothing pinned in settings — blank names what the server actually
// resolves to, not an empty option the user has to guess at.
expect(select.value).toBe('');
expect(screen.getByRole('option', { name: 'Install default (Qwen-Image 2.1)' })).toBeTruthy();
fireEvent.change(select, { target: { value: 'flux2-klein-4b' } });
fireEvent.click(screen.getByRole('button', { name: /^Save$/ }));
await awaitSave();
expect(sentSlices()['imageGen.local']).toEqual({ modelId: 'flux2-klein-4b' });
});
it('clears modelId with an explicit null when the pin is cleared, so the server default resolves again', async () => {
getSettings.mockResolvedValue({
imageGen: {
mode: 'local',
external: { sdapiUrl: '' },
local: { pythonPath: '/usr/bin/python3', modelId: 'flux2-klein-4b' },
codex: { enabled: false },
expose: { a1111: false },
},
});
await renderTab(['/media/image?mediaTab=local']);
await act(async () => {});
const select = screen.getByLabelText('Default model');
expect(select.value).toBe('flux2-klein-4b');
fireEvent.change(select, { target: { value: '' } });
fireEvent.click(screen.getByRole('button', { name: /^Save$/ }));
await awaitSave();
// null, not '' — the slice merge keeps an omitted key, so the clear must
// be a value; every consumer reads `local.modelId || DEFAULT`, and a
// persisted empty string is a value they would all have to keep coercing.
expect(sentSlices()['imageGen.local']).toEqual({ modelId: null });
});
it('keeps a pin the catalog no longer lists selectable rather than silently dropping it', async () => {
getSettings.mockResolvedValue({
imageGen: {
mode: 'local',
external: { sdapiUrl: '' },
local: { pythonPath: '/usr/bin/python3', modelId: 'retired-model' },
codex: { enabled: false },
expose: { a1111: false },
},
});
await renderTab(['/media/image?mediaTab=local']);
await act(async () => {});
// A select whose value matches no option paints blank and reads as
// "install default" — while the server is still honouring the pin.
expect(screen.getByLabelText('Default model').value).toBe('retired-model');
expect(screen.getByRole('option', { name: /retired-model \(unavailable on this machine\)/ })).toBeTruthy();
});
it('the imageGen.local save body names only the changed field, so hand-edited siblings survive', async () => {
// imageGen.local carries hand-edit-only render knobs this tab never
// renders (steps / guidance / quantize, read by fableLoom/production.js).
// The slice PATCH merges per field, so the drawer neither re-sends a
// snapshot of them nor omits them into oblivion.
getSettings.mockResolvedValue({
imageGen: {
mode: 'local',
external: { sdapiUrl: '' },
local: { pythonPath: '/usr/bin/python3', steps: 28, guidance: 4.5, quantize: '4' },
codex: { enabled: false },
expose: { a1111: false },
},
});
await renderTab(['/media/image?mediaTab=local']);
await act(async () => {});
fireEvent.change(screen.getByLabelText('Default model'), { target: { value: 'flux2-klein-4b' } });
fireEvent.click(screen.getByRole('button', { name: /^Save$/ }));
await awaitSave();
expect(sentSlices()).toEqual({ 'imageGen.local': { modelId: 'flux2-klein-4b' } });
});
it('the videoGen save body carries only the changed pin (#3231 Phase 4)', async () => {
// A Defaults-tab save that re-sent the loaded slice would overwrite a
// videoGen.defaultModelId another surface changed after this drawer
// opened. The exact wire body is pinned HERE.
getSettings.mockResolvedValue({
imageGen: { mode: 'external', external: { sdapiUrl: 'http://localhost:7860' } },
videoGen: { mode: 'grok', defaultModelId: 'ltx23_distilled_q4' },
});
await renderTab(['/media/image?mediaTab=defaults']);
const videoSelect = screen.getByLabelText(/Default video backend/i);
expect(videoSelect.value).toBe('grok');
fireEvent.change(videoSelect, { target: { value: 'local' } });
fireEvent.click(screen.getByRole('button', { name: /^Save$/ }));
await awaitSave();
// fal/reactor keys are no longer part of this save body (#8997) — they
// move through the write-only credential setter instead.
expect(sentSlices()).toEqual({ videoGen: { mode: 'local' } });
});
});
describe('ImageGenTab — Test Render backend picker (#4128)', () => {
const multiBackendSettings = {
imageGen: {
mode: 'external',
external: { sdapiUrl: 'http://localhost:7860' },
local: { pythonPath: '' },
codex: { enabled: false },
grok: { enabled: true, grokPath: 'grok' },
agy: { enabled: true, agyPath: 'agy' },
expose: { a1111: false },
},
};
it('offers every enabled backend and marks the saved default as the initial pick', async () => {
getSettings.mockResolvedValue(multiBackendSettings);
await renderTab(['/media/image?mediaTab=test']);
const select = screen.getByLabelText('Backend');
expect(select.value).toBe('external');
const options = Array.from(select.options).map((o) => o.value);
expect(options).toEqual(['grok', 'agy', 'external']);
// Local has no python path and codex is disabled — neither is renderable,
// so neither may be offered.
expect(options).not.toContain('local');
expect(options).not.toContain('codex');
expect(screen.getByText(/Send a prompt through External/)).toBeTruthy();
});
it('renders through the picked backend instead of the saved default', async () => {
getSettings.mockResolvedValue(multiBackendSettings);
generateImage.mockResolvedValue({ mode: 'grok', path: '/data/renders/test.png', filename: 'test.png' });
await renderTab(['/media/image?mediaTab=test']);
fireEvent.change(screen.getByLabelText('Backend'), { target: { value: 'grok' } });
expect(screen.getByText(/Send a prompt through Grok/)).toBeTruthy();
fireEvent.click(screen.getByRole('button', { name: /Render Test Image/i }));
await waitFor(() => expect(generateImage).toHaveBeenCalled());
expect(generateImage.mock.calls[0][0].mode).toBe('grok');
});
it('opens no render stream when the tab unmounts before the test render is acknowledged', async () => {
getSettings.mockResolvedValue(multiBackendSettings);
let acknowledge;
generateImage.mockReturnValue(new Promise((resolve) => { acknowledge = resolve; }));
const OriginalEventSource = globalThis.EventSource;
const streams = [];
globalThis.EventSource = function EventSourceStub(url) { streams.push(url); this.close = vi.fn(); };
try {
const view = await renderTab(['/media/image?mediaTab=test']);
fireEvent.click(screen.getByRole('button', { name: /Render Test Image/i }));
await waitFor(() => expect(generateImage).toHaveBeenCalled());
view.unmount();
await act(async () => { acknowledge({ mode: 'local', generationId: 'job-durable' }); });
expect(streams).toEqual([]);
} finally {
globalThis.EventSource = OriginalEventSource;
}
});
it('keeps the saved default selectable even when it is not otherwise renderable', async () => {
// External is the saved default with a blank URL: the server still routes
// the render there, so the select must not silently show a different
// backend than the button uses.
getSettings.mockResolvedValue({
imageGen: {
mode: 'external',
external: { sdapiUrl: '' },
grok: { enabled: true, grokPath: 'grok' },
},
});
generateImage.mockResolvedValue({ mode: 'external', path: '/data/renders/test.png', filename: 'test.png' });
await renderTab(['/media/image?mediaTab=test']);
const select = screen.getByLabelText('Backend');
expect(select.value).toBe('external');
expect(Array.from(select.options).map((o) => o.value)).toEqual(['external', 'grok']);
fireEvent.click(screen.getByRole('button', { name: /Render Test Image/i }));
await waitFor(() => expect(generateImage).toHaveBeenCalled());
expect(generateImage.mock.calls[0][0].mode).toBe('external');
});
it('falls a pick back to the saved default once that backend is disabled and saved', async () => {
getSettings.mockResolvedValue(multiBackendSettings);
generateImage.mockResolvedValue({ mode: 'external', path: '/data/renders/test.png', filename: 'test.png' });
await renderTab(['/media/image?mediaTab=test']);
fireEvent.change(screen.getByLabelText('Backend'), { target: { value: 'grok' } });
// Disable Grok on its own tab and save — the pick is now unrenderable.
fireEvent.click(screen.getByRole('tab', { name: /Grok CLI/i }));
fireEvent.click(screen.getByLabelText(/Enable Grok/i));
fireEvent.click(screen.getByRole('button', { name: /^Save$/ }));
await awaitSave();
fireEvent.click(screen.getByRole('tab', { name: /^Test$/i }));
const select = screen.getByLabelText('Backend');
expect(select.value).toBe('external');
expect(Array.from(select.options).map((o) => o.value)).not.toContain('grok');
fireEvent.click(screen.getByRole('button', { name: /Render Test Image/i }));
await waitFor(() => expect(generateImage).toHaveBeenCalled());
expect(generateImage.mock.calls[0][0].mode).toBe('external');
});
});
describe('ImageGenTab — Agy CLI section', () => {
it('loads installed models, allows a custom model id, and saves the Agy slice', async () => {
getSettings.mockResolvedValue({
imageGen: {
mode: 'agy',
agy: { enabled: true, agyPath: '/opt/agy', model: 'gemini-image' },
},
});
await renderTab(['/media/image?mediaTab=agy']);
await waitFor(() => expect(listAgyImageModels).toHaveBeenCalledWith({ silent: true }));
const modelInput = screen.getByLabelText(/^Agent model/);
expect(modelInput.value).toBe('gemini-image');
fireEvent.change(modelInput, { target: { value: 'custom/image-v3' } });
fireEvent.click(screen.getByRole('button', { name: /^Save$/ }));
await awaitSave();
expect(sentSlices()).toEqual({ 'imageGen.agy': { model: 'custom/image-v3' } });
});
it('render-defaults tab pins a backend + model per surface and saves the slice (#3231)', async () => {
getSettings.mockResolvedValue({
imageGen: { mode: 'local', agy: { enabled: true } },
renderDefaults: { 'universe-bible': { imageMode: 'codex' } },
});
await renderTab(['/media/image?mediaTab=defaults']);
// Existing pin loads into its select.
const bibleSelect = await screen.findByLabelText('Universe Bible & canon renders');
expect(bibleSelect.value).toBe('codex');
// Pin a model-capable backend on another surface → model input appears.
const spriteSelect = screen.getByLabelText('Sprite references & anchors');
fireEvent.change(spriteSelect, { target: { value: 'agy' } });
const modelInput = screen.getByLabelText('Sprite references & anchors model');
fireEvent.change(modelInput, { target: { value: 'gemini-3.6-flash-low' } });
fireEvent.click(screen.getByRole('button', { name: /^Save$/ }));
await awaitSave();
// The wire body carries exactly the changed target — the untouched
// universe-bible pin is not re-sent, and no 'auto' no-ops travel.
expect(sentSlices()).toEqual({
renderDefaults: { 'sprite-reference': { imageMode: 'agy', imageModel: 'gemini-3.6-flash-low' } },
});
});
it('clears a render-default pin with an explicit null entry (#12030)', async () => {
getSettings.mockResolvedValue({
imageGen: { mode: 'local' },
renderDefaults: { 'universe-bible': { imageMode: 'codex' } },
});
await renderTab(['/media/image?mediaTab=defaults']);
const bibleSelect = await screen.findByLabelText('Universe Bible & canon renders');
fireEvent.change(bibleSelect, { target: { value: '' } });
fireEvent.click(screen.getByRole('button', { name: /^Save$/ }));
await awaitSave();
expect(sentSlices()).toEqual({ renderDefaults: { 'universe-bible': null } });
});
it('grok pins never show a model input — its backend has no model knob (#3231)', async () => {
getSettings.mockResolvedValue({ imageGen: { mode: 'local' } });
await renderTab(['/media/image?mediaTab=defaults']);
const select = await screen.findByLabelText('Sprite references & anchors');
fireEvent.change(select, { target: { value: 'grok' } });
expect(screen.queryByLabelText('Sprite references & anchors model')).toBeNull();
});
it('names the fixed server-side image model as a read-only fact (#3231)', async () => {
getSettings.mockResolvedValue({
imageGen: { mode: 'agy', agy: { enabled: true } },
});
await renderTab(['/media/image?mediaTab=agy']);
await waitFor(() => expect(listAgyImageModels).toHaveBeenCalled());
// The image model is fixed by Antigravity — the section must state the
// concrete id rather than implying an imagen-* picker exists.
expect(screen.getByText('imagen-3.0-generate-002')).toBeTruthy();
expect(screen.getByText(/not selectable through the CLI/i)).toBeTruthy();
});
it('states that Agy is text-to-image only', async () => {
await renderTab(['/media/image?mediaTab=agy']);
expect(screen.getByText(/Image editing is not supported/i)).toBeTruthy();
});
});
describe('ImageGenTab — Grok CLI section (#2859)', () => {
it('shows the enable toggle and hides the config fields until enabled', async () => {
await renderTab();
fireEvent.click(screen.getByRole('tab', { name: /Grok CLI/i }));
expect(screen.getByRole('heading', { name: 'Grok CLI Imagegen' })).toBeTruthy();
const toggle = screen.getByLabelText(/Enable Grok Imagegen/i);
expect(toggle.checked).toBe(false);
expect(screen.queryByPlaceholderText('grok (uses $PATH)')).toBeNull();
fireEvent.click(toggle);
expect(screen.getByPlaceholderText('grok (uses $PATH)')).toBeTruthy();
expect(screen.getByLabelText(/Default aspect ratio/i)).toBeTruthy();
});
it('adds a Grok backend tile only when enabled, and saves the grok slice', async () => {
getSettings.mockResolvedValue({
imageGen: {
mode: 'external',
external: { sdapiUrl: 'http://localhost:7860' },
grok: { enabled: true, grokPath: '/opt/grok', aspectRatio: '16:9' },
},
});
await renderTab();
// Enabled grok surfaces a backend tile on the Backend tab (scope the
// query to the tile description — the tab bar also says "Grok CLI").
expect(screen.getByText(/Route through the Grok Build CLI/i)).toBeTruthy();
// Dirty the grok path and save — the patch carries the grok slice.
fireEvent.click(screen.getByRole('tab', { name: /Grok CLI/i }));
fireEvent.change(screen.getByPlaceholderText('grok (uses $PATH)'), { target: { value: '/usr/local/bin/grok' } });
fireEvent.click(screen.getByRole('button', { name: /^Save$/ }));
await awaitSave();
expect(sentSlices()).toEqual({ 'imageGen.grok': { grokPath: '/usr/local/bin/grok' } });
});
it('falls the mode back to local when grok is disabled while active', async () => {
getSettings.mockResolvedValue({
imageGen: {
mode: 'grok',
local: { pythonPath: '/usr/bin/python3' },
grok: { enabled: true },
},
});
await renderTab();
fireEvent.click(screen.getByRole('tab', { name: /Grok CLI/i }));
fireEvent.click(screen.getByLabelText(/Enable Grok Imagegen/i));
fireEvent.click(screen.getByRole('button', { name: /^Save$/ }));
await awaitSave();
expect(sentSlices()).toEqual({ imageGen: { mode: 'local' }, 'imageGen.grok': { enabled: false } });
});
});
describe('ImageGenTab — fal.ai section', () => {
it('points at the shared fal.ai key when none is configured', async () => {
await renderTab();
fireEvent.click(screen.getByRole('tab', { name: /fal\.ai/i }));
expect(await screen.findByText(/No fal\.ai API key — set it under the Defaults tab/i)).toBeTruthy();
fireEvent.click(screen.getByRole('button', { name: /Open Defaults/i }));
expect(screen.getByRole('tab', { name: /Defaults/i }).getAttribute('aria-selected')).toBe('true');
expect(document.getElementById('fal-api-key')).toBeTruthy();
});
it('saves the enable toggle and a catalog model under imageGen.fal, and adds a backend tile', async () => {
getCredentialInventory.mockResolvedValue({
headline: '', credentials: [{ id: 'fal', label: 'fal.ai', configured: true, source: 'settings', editable: true }],
});
await renderTab();
fireEvent.click(screen.getByRole('tab', { name: /fal\.ai/i }));
expect(await screen.findByText(/fal\.ai API key configured/i)).toBeTruthy();
fireEvent.click(screen.getByLabelText(/Enable fal\.ai Imagegen/i));
fireEvent.change(screen.getByLabelText(/Default model/i), { target: { value: 'fal-ai/bytedance/seedream/v5/lite/text-to-image' } });
fireEvent.click(screen.getByRole('button', { name: /^Save$/ }));
await awaitSave();
expect(sentSlices()['imageGen.fal']).toEqual({
enabled: true, model: 'fal-ai/bytedance/seedream/v5/lite/text-to-image',
});
fireEvent.click(screen.getByRole('tab', { name: /Backend/i }));
expect(screen.getByText(/Hosted image and reference-edit models through fal\.ai/i)).toBeTruthy();
});
});
// The packages panel above the card only ever probes the mflux interpreter, so
// on its own it told a machine whose selected default renders through the
// shared torch venv that everything was installed — while the Image Gen page
// two clicks away called the same machine unavailable.
describe('ImageGenTab local runtime card', () => {
const brokenTorchRuntime = {
readiness: 'unavailable', modelId: 'flux2-klein-4b', model: 'FLUX.2 Klein',
runtimeLabel: 'Shared torch runtime (FLUX.2 · Z-Image · ERNIE · HiDream · Qwen)',
reason: 'The shared torch image runtime is not installed or healthy (expected at /home/u/.portos/venv-flux2/bin/python3)',
remedy: { kind: 'install-torch-venv', label: 'Install runtime', venvPath: '/home/u/.portos/venv-flux2/bin/python3' },
};
it('reports the shared torch runtime the pinned model actually needs', async () => {
getImageGenStatus.mockResolvedValue(brokenTorchRuntime);
await renderTab();
fireEvent.click(screen.getByRole('tab', { name: /^Local/i }));
expect(await screen.findByText(/not installed or healthy/i)).toBeInTheDocument();
expect(screen.getByRole('button', { name: /install runtime/i })).toBeInTheDocument();
});
it('probes the runtime for the model the tab has pinned, not the install default', async () => {
await renderTab();
fireEvent.click(screen.getByRole('tab', { name: /^Local/i }));
await waitFor(() => expect(getImageGenStatus).toHaveBeenCalledWith('local', 'qwen-image-2.1', expect.anything()));
fireEvent.change(screen.getByLabelText('Default model'), { target: { value: 'flux2-klein-4b' } });
await waitFor(() => expect(getImageGenStatus).toHaveBeenCalledWith('local', 'flux2-klein-4b', expect.anything()));
});
});
vi.mock('../../services/apiRunwayCatalog.js', async (importOriginal) => ({ ...await importOriginal(), loadRunwayCatalog: vi.fn().mockResolvedValue(undefined) }));
it('hides the retired training default and leaves its saved pin untouched while editing a supported surface', async () => {
getSettings.mockResolvedValue({ imageGen: { mode: 'local' }, renderDefaults: { 'lora-dataset': { imageMode: 'grok' } } });
await renderTab(['/media/image?mediaTab=defaults']);
const live = await screen.findByLabelText('Universe Bible & canon renders');
expect(screen.queryByLabelText('LoRA training datasets')).toBeNull();
fireEvent.change(live, { target: { value: 'grok' } });
fireEvent.click(screen.getByRole('button', { name: /^Save$/ }));
await awaitSave();
expect(sentSlices()).toEqual({ renderDefaults: { 'universe-bible': { imageMode: 'grok' } } });
});