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, within, act } from '@testing-library/react';
import { awaitEnabled } from '../../../test/enabledBarrier.js';
// ── Mock router — capture navigate calls, no real Router needed ────────────────
const mockNavigate = vi.hoisted(() => vi.fn());
vi.mock('react-router', async (importOriginal) => ({
...(await importOriginal()),
useNavigate: () => mockNavigate,
}));
import { MemoryRouter, useLocation } from 'react-router';
// ── Mock toast ────────────────────────────────────────────────────────────────
const mockToast = vi.hoisted(() => Object.assign(vi.fn(), { success: vi.fn(), error: vi.fn(), loading: vi.fn(), dismiss: vi.fn() }));
vi.mock('../../ui/Toast', () => ({ default: mockToast }));
// ── Mock API ──────────────────────────────────────────────────────────────────
const api = vi.hoisted(() => ({
getAppTaskTypes: vi.fn(),
getCosSchedule: vi.fn(),
getCosStatus: vi.fn(),
getProviders: vi.fn(),
updateAppTaskTypeOverride: vi.fn(),
toggleAllAppTaskTypes: vi.fn(),
triggerCosOnDemandTask: vi.fn(),
resumeCos: vi.fn(),
// Consumed by the nested CustomTasksSection on mount.
getCosJobs: vi.fn(),
createCosJob: vi.fn(),
updateCosJob: vi.fn(),
toggleCosJob: vi.fn(),
triggerCosJob: vi.fn(),
deleteCosJob: vi.fn(),
getSettings: vi.fn(),
}));
vi.mock('../../../services/api', () => api);
const AutomationTab = (await import('./AutomationTab')).default;
const SCHEDULE = {
tasks: {
// Every row honors a per-app provider/model pin (#4783); the task's own pin
// is what a row inherits when the app pins nothing.
'layered-intelligence': { type: 'daily', taskMetadata: {}, providerId: 'global-claude' },
'app-improvement': { type: 'rotation', taskMetadata: {} },
security: { type: 'weekly', taskMetadata: { fileIssues: false }, fileIssuesCapable: true, defaultFileIssues: false },
},
};
const PROVIDERS = {
providers: [
{ id: 'claude-cli', name: 'Claude Code', type: 'cli', enabled: true, models: ['opus', 'sonnet'] },
{ id: 'global-claude', name: 'Global Claude', type: 'api', enabled: true, models: ['gpt-5.5'] },
{ id: 'disabled-one', name: 'Disabled', type: 'api', enabled: false, models: [] },
],
};
let currentSearch = '';
const LocationProbe = () => { currentSearch = useLocation().search; return null; };
const mountTab = (entry = '/?show=all') => render(
<MemoryRouter initialEntries={[entry]}>
<LocationProbe />
<AutomationTab appId="app-1" appName="MyApp" />
</MemoryRouter>
);
const renderTab = async (overrides = {}, entry) => {
api.getAppTaskTypes.mockResolvedValue({ taskTypeOverrides: overrides });
api.getCosSchedule.mockResolvedValue(SCHEDULE);
api.getCosStatus.mockResolvedValue({ paused: false });
api.getProviders.mockResolvedValue(PROVIDERS);
api.getCosJobs.mockResolvedValue({ jobs: [] });
api.getSettings.mockResolvedValue({ timezone: 'UTC' });
api.updateAppTaskTypeOverride.mockResolvedValue({ success: true });
mountTab(entry);
await screen.findByRole('group', { name: 'Task visibility' });
// Drain the remaining mount fetches (CustomTasksSection's getCosJobs etc.)
// inside act — the schedule findByText above can win before they land.
await act(async () => {});
};
// Find the task-row card that contains the given task-type label.
const rowFor = (taskType) => screen.getByText(taskType).closest('.bg-port-card');
beforeEach(() => {
vi.clearAllMocks();
});
describe('AutomationTab per-app options', () => {
it('acknowledges a slow run immediately, prevents duplicate clicks, and retains the queued receipt', async () => {
await renderTab({ security: { enabled: true } });
let resolveRun;
api.triggerCosOnDemandTask.mockReturnValueOnce(new Promise(resolve => { resolveRun = resolve; }));
mockToast.loading.mockReturnValueOnce('run-toast');
const row = rowFor('security');
fireEvent.click(within(row).getByRole('button', { name: 'Run Now' }));
expect(mockToast.loading).toHaveBeenCalledWith('Sending security request for MyApp…');
const sending = within(row).getByRole('button', { name: 'Sending…' });
expect(sending).toBeDisabled();
fireEvent.click(sending);
expect(api.triggerCosOnDemandTask).toHaveBeenCalledTimes(1);
expect(mockToast.success).not.toHaveBeenCalled();
await act(async () => resolveRun({ success: true, request: { id: 'request-1' } }));
expect(mockToast.dismiss).toHaveBeenCalledWith('run-toast');
expect(mockToast.success).toHaveBeenCalledWith(expect.stringContaining('Queued security request for MyApp'));
expect(within(row).getByText('Request queued')).toBeVisible();
expect(within(row).getByRole('button', { name: 'Run Now' })).toBeEnabled();
});
it('clears sending feedback on rejection without claiming the run was queued', async () => {
await renderTab({ security: { enabled: true } });
api.triggerCosOnDemandTask.mockRejectedValueOnce(new Error('CoS unavailable'));
mockToast.loading.mockReturnValueOnce('failed-run-toast');
const row = rowFor('security');
fireEvent.click(within(row).getByRole('button', { name: 'Run Now' }));
await waitFor(() => expect(mockToast.dismiss).toHaveBeenCalledWith('failed-run-toast'));
expect(mockToast.error).toHaveBeenCalledWith('CoS unavailable');
expect(mockToast.success).not.toHaveBeenCalled();
expect(within(row).queryByText('Request queued')).toBeNull();
expect(within(row).getByRole('button', { name: 'Run Now' })).toBeEnabled();
});
it('lets the task cards use the full desktop width instead of a narrow column', async () => {
api.getAppTaskTypes.mockResolvedValue({ taskTypeOverrides: {} });
api.getCosSchedule.mockResolvedValue(SCHEDULE);
api.getCosStatus.mockResolvedValue({ paused: false });
api.getProviders.mockResolvedValue(PROVIDERS);
api.getCosJobs.mockResolvedValue({ jobs: [] });
api.getSettings.mockResolvedValue({ timezone: 'UTC' });
const { container } = mountTab();
await screen.findByText('layered-intelligence');
await act(async () => {});
// The tab used to cap itself well below the window, leaving the right of a
// desktop screen empty. Only the cap is asserted — which breakpoints the
// card grid uses is a retune anyone should be free to make.
expect(container.querySelector('.max-w-5xl')).toBeNull();
});
it('puts custom automations before the shared schedule cards and shows app cadence', async () => {
await renderTab({ security: { enabled: true, interval: 'on-demand' } });
const custom = screen.getByText('Custom Tasks');
const scheduled = screen.getByText('Scheduled Task Options');
expect(custom.compareDocumentPosition(scheduled) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy();
const row = rowFor('security');
expect(within(row).getByRole('button', { name: 'Run Now' })).toBeEnabled();
expect(within(row).queryByText('Never run')).toBeNull();
expect(within(row).queryByText('App coverage')).toBeNull();
expect(within(row).getByText('on-demand')).toBeInTheDocument();
});
it('saves the selected app toggle before permitting a run and preserves state on failure', async () => {
await renderTab();
const row = rowFor('security');
let rejectSave;
api.updateAppTaskTypeOverride.mockReturnValueOnce(new Promise((_resolve, reject) => { rejectSave = reject; }));
fireEvent.click(within(row).getByRole('switch', { name: 'security enabled for this app: off' }));
expect(api.updateAppTaskTypeOverride).toHaveBeenCalledWith('app-1', 'security', { enabled: true }, { silent: true });
// In-flight save gates Run Now.
expect(within(row).getByRole('button', { name: 'Run Now' })).toBeDisabled();
await act(async () => rejectSave(new Error('Save failed')));
expect(within(row).getByRole('switch', { name: 'security enabled for this app: off' })).toHaveAttribute('aria-checked', 'false');
fireEvent.click(within(row).getByRole('switch', { name: 'security enabled for this app: off' }));
api.updateAppTaskTypeOverride.mockResolvedValue({ success: true });
await awaitEnabled(() => within(row).getByRole('button', { name: 'Run Now' }));
api.triggerCosOnDemandTask.mockResolvedValue({ success: true });
fireEvent.click(within(row).getByRole('button', { name: 'Run Now' }));
await waitFor(() => expect(api.triggerCosOnDemandTask).toHaveBeenCalledWith('security', 'app-1', { silent: true }));
});
it('Run Now sends the app id while the per-app switch stays off', async () => {
await renderTab();
const row = rowFor('security');
expect(within(row).getByRole('switch', { name: 'security enabled for this app: off' })).toBeInTheDocument();
api.triggerCosOnDemandTask.mockResolvedValue({ success: true });
const run = within(row).getByRole('button', { name: 'Run Now' });
expect(run).toBeEnabled();
fireEvent.click(run);
await waitFor(() => expect(api.triggerCosOnDemandTask).toHaveBeenCalledWith('security', 'app-1', { silent: true }));
expect(api.updateAppTaskTypeOverride).not.toHaveBeenCalled();
expect(within(row).getByRole('switch', { name: 'security enabled for this app: off' })).toBeInTheDocument();
});
it('Configure toggle expands the provider override panel', async () => {
await renderTab();
const row = rowFor('layered-intelligence');
const configureBtn = within(row).getByRole('button', { name: /show provider and model options/i });
expect(configureBtn).toHaveAttribute('aria-expanded', 'false');
// Provider selector is not rendered until expanded.
expect(within(row).queryByLabelText('Provider override')).toBeNull();
fireEvent.click(configureBtn);
expect(configureBtn).toHaveAttribute('aria-expanded', 'true');
expect(within(row).getByLabelText('Provider override')).toBeInTheDocument();
});
it('flags a provider override that diverges from the schedule pin, collapsed', async () => {
// Schedule pins layered-intelligence to 'global-claude'; the app overrides
// it to a DIFFERENT provider — the exact silent-shadowing scenario #4783
// documents. Must be visible without expanding Configure.
await renderTab({ 'layered-intelligence': { providerId: 'claude-cli' } });
const row = rowFor('layered-intelligence');
expect(within(row).getByText('Provider override')).toBeInTheDocument();
});
it('does not flag an override that matches the schedule pin', async () => {
await renderTab({ 'layered-intelligence': { providerId: 'global-claude' } });
const row = rowFor('layered-intelligence');
expect(within(row).queryByText('Provider override')).toBeNull();
});
it('does not flag a task type with no app override', async () => {
await renderTab();
const row = rowFor('layered-intelligence');
expect(within(row).queryByText('Provider override')).toBeNull();
});
it('changing the provider PATCHes updateAppTaskTypeOverride with providerId + cleared model', async () => {
await renderTab();
const row = rowFor('layered-intelligence');
fireEvent.click(within(row).getByRole('button', { name: /show provider and model options/i }));
const providerSelect = within(row).getByLabelText('Provider override');
fireEvent.change(providerSelect, { target: { value: 'claude-cli' } });
await waitFor(() => expect(api.updateAppTaskTypeOverride).toHaveBeenCalled());
expect(api.updateAppTaskTypeOverride).toHaveBeenCalledWith(
'app-1',
'layered-intelligence',
{ providerId: 'claude-cli', model: null },
{ silent: true }
);
});
it('changing the model PATCHes updateAppTaskTypeOverride with the model', async () => {
await renderTab({ 'layered-intelligence': { providerId: 'claude-cli' } });
const row = rowFor('layered-intelligence');
fireEvent.click(within(row).getByRole('button', { name: /show provider and model options/i }));
fireEvent.change(within(row).getByLabelText('Model'), { target: { value: 'sonnet' } });
await waitFor(() => expect(api.updateAppTaskTypeOverride).toHaveBeenCalledWith(
'app-1',
'layered-intelligence',
{ providerId: 'claude-cli', model: 'sonnet' },
{ silent: true }
));
});
it('excludes disabled providers from the picker', async () => {
await renderTab();
const row = rowFor('layered-intelligence');
fireEvent.click(within(row).getByRole('button', { name: /show provider and model options/i }));
const providerSelect = within(row).getByLabelText('Provider override');
expect(within(providerSelect).queryByText('Disabled')).toBeNull();
expect(within(providerSelect).getByText('Claude Code')).toBeInTheDocument();
});
it('layered-intelligence row shows a behavior link that deep-links to the Intelligence tab', async () => {
await renderTab();
const row = rowFor('layered-intelligence');
fireEvent.click(within(row).getByRole('button', { name: /show provider and model options/i }));
const link = within(row).getByRole('button', { name: /configure behavior/i });
fireEvent.click(link);
expect(mockNavigate).toHaveBeenCalledWith('/apps/app-1?edit=1&appTab=intelligence');
});
// The pin reaches the spawn for EVERY task type now (#4783), so the picker is
// offered on every row rather than only where a buildTaskInput hook read it.
it('offers the same provider picker on a task type with no hook', async () => {
await renderTab();
const row = rowFor('app-improvement');
fireEvent.click(within(row).getByRole('button', { name: /show provider and model options/i }));
expect(within(row).getByLabelText('Provider override')).toBeInTheDocument();
});
it('clearing the provider sends explicit nulls, matching the other pin surfaces', async () => {
await renderTab({ 'app-improvement': { providerId: 'claude-cli', model: 'opus' } });
const row = rowFor('app-improvement');
fireEvent.click(within(row).getByRole('button', { name: /show provider and model options/i }));
fireEvent.change(within(row).getByLabelText('Provider override'), { target: { value: '' } });
await waitFor(() => expect(api.updateAppTaskTypeOverride).toHaveBeenCalledWith(
'app-1',
'app-improvement',
{ providerId: null, model: null },
{ silent: true }
));
});
it('Iss toggle PATCHes fileIssues on and forces the no-code posture', async () => {
await renderTab();
const row = rowFor('security');
fireEvent.click(within(row).getByRole('button', { name: /File issues only/i }));
await waitFor(() => expect(api.updateAppTaskTypeOverride).toHaveBeenCalledWith(
'app-1',
'security',
{ taskMetadata: { fileIssues: true, useWorktree: false, openPR: false, simplify: false } },
{ silent: true }
));
});
});
describe('AutomationTab task visibility filter', () => {
const cardOrder = () => ['layered-intelligence', 'app-improvement', 'security']
.map(t => [t, screen.queryByText(t)])
.filter(([, el]) => el)
.sort(([, a], [, b]) => (a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1))
.map(([t]) => t);
it('opens on the switched-on tasks when any are on, and keeps the full count on All', async () => {
await renderTab({ security: { enabled: true } }, '/');
expect(cardOrder()).toEqual(['security']);
expect(screen.getByRole('button', { name: 'On for this app (1)' })).toHaveAttribute('aria-pressed', 'true');
expect(screen.getByRole('button', { name: 'All (3)' })).toBeInTheDocument();
});
it('opens on All when nothing is switched on', async () => {
await renderTab({}, '/');
expect(cardOrder()).toHaveLength(3);
expect(screen.getByRole('button', { name: 'All (3)' })).toHaveAttribute('aria-pressed', 'true');
});
it('lists switched-on tasks first on All, then alphabetical', async () => {
await renderTab({ security: { enabled: true } }, '/?show=all');
expect(cardOrder()).toEqual(['security', 'app-improvement', 'layered-intelligence']);
});
it('keeps show and q in the URL, dropping each at its default', async () => {
await renderTab({ security: { enabled: true } }, '/');
fireEvent.click(screen.getByRole('button', { name: 'All (3)' }));
expect(currentSearch).toBe('?show=all');
fireEvent.change(screen.getByRole('searchbox', { name: 'Search tasks' }), { target: { value: 'app' } });
expect(currentSearch).toBe('?show=all&q=app');
expect(cardOrder()).toEqual(['app-improvement']);
fireEvent.click(screen.getByRole('button', { name: 'On for this app (1)' }));
fireEvent.change(screen.getByRole('searchbox', { name: 'Search tasks' }), { target: { value: '' } });
expect(currentSearch).toBe('');
});
it('shows a zero-match empty state that resets to all tasks', async () => {
await renderTab({ security: { enabled: true } }, '/?q=zzz');
expect(screen.getByText(/No tasks match/)).toHaveTextContent('“On for this app” and “zzz”');
fireEvent.click(screen.getByRole('button', { name: 'Show all tasks' }));
expect(currentSearch).toBe('?show=all');
expect(cardOrder()).toHaveLength(3);
});
});
describe('AutomationTab read failures', () => {
const primeOthers = () => {
api.getCosStatus.mockResolvedValue({ paused: false });
api.getProviders.mockResolvedValue(PROVIDERS);
api.getCosJobs.mockResolvedValue({ jobs: [] });
api.getSettings.mockResolvedValue({ timezone: 'UTC' });
};
it('does not render per-app or master switches over an unknown overrides state, and recovers on Retry', async () => {
primeOthers();
api.getCosSchedule.mockResolvedValue(SCHEDULE);
api.getAppTaskTypes.mockRejectedValueOnce(new Error('overrides down'));
mountTab();
const alert = await screen.findByText(/Could not load this app's automation settings/);
expect(alert).toBeInTheDocument();
expect(screen.queryByRole('switch')).toBeNull();
expect(screen.queryByRole('group', { name: 'Task visibility' })).toBeNull();
expect(screen.queryByText('layered-intelligence')).toBeNull();
api.getAppTaskTypes.mockResolvedValue({ taskTypeOverrides: { security: { enabled: true } } });
fireEvent.click(screen.getByRole('button', { name: 'Retry' }));
await screen.findByRole('group', { name: 'Task visibility' });
expect(screen.queryByText(/Could not load/)).toBeNull();
expect(screen.getByText('On for this app (1)', { exact: false })).toBeInTheDocument();
});
it('shows a schedule error instead of "No task types configured", and recovers on Retry', async () => {
primeOthers();
api.getAppTaskTypes.mockResolvedValue({ taskTypeOverrides: {} });
api.getCosSchedule.mockRejectedValueOnce(new Error('schedule down'));
mountTab();
expect(await screen.findByText(/Could not load the task schedule/)).toBeInTheDocument();
expect(screen.queryByText(/No task types configured/)).toBeNull();
api.getCosSchedule.mockResolvedValue(SCHEDULE);
fireEvent.click(screen.getByRole('button', { name: 'Retry' }));
await screen.findByRole('group', { name: 'Task visibility' });
});
it('still renders the empty copy when the schedule loads with no task types', async () => {
primeOthers();
api.getAppTaskTypes.mockResolvedValue({ taskTypeOverrides: {} });
api.getCosSchedule.mockResolvedValue({ tasks: {} });
mountTab();
expect(await screen.findByText(/No task types configured/)).toBeInTheDocument();
expect(screen.queryByText(/Could not load/)).toBeNull();
});
it('shows a provider list error row instead of an empty provider catalogue', async () => {
primeOthers();
api.getAppTaskTypes.mockResolvedValue({ taskTypeOverrides: {} });
api.getCosSchedule.mockResolvedValue(SCHEDULE);
api.getProviders.mockRejectedValueOnce(new Error('providers down'));
mountTab();
expect(await screen.findByText(/Could not load the provider list/)).toBeInTheDocument();
});
});