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 { act, cleanup, fireEvent, render, screen } from '@testing-library/react';
import { MemoryRouter } from 'react-router';
import { beforeEach, afterEach, describe, expect, it, vi } from 'vitest';
const { socket, api } = vi.hoisted(() => {
const handlers = new Map();
return {
socket: {
on: (event, fn) => { if (!handlers.has(event)) handlers.set(event, new Set()); handlers.get(event).add(fn); },
off: (event, fn) => handlers.get(event)?.delete(fn),
emit: vi.fn(),
receive: (event, data = {}) => { for (const fn of handlers.get(event) || []) fn(data); },
},
api: Object.fromEntries(['getGoals', 'getCosUpcomingTasks', 'getBackupStatus', 'getBackupSnapshots', 'getCosQuickSummary', 'getCosLearningSummary', 'getCosRecentTasks', 'getCosActivityCalendar', 'getCosDecisionSummary', 'listThreads', 'getAutoFixMetrics', 'triggerBackup'].map(name => [name, vi.fn()])),
};
});
vi.mock('../services/socket', () => ({ default: socket }));
vi.mock('../services/api', () => api);
vi.mock('./ui/Toast', () => ({ default: Object.assign(vi.fn(), { success: vi.fn(), error: vi.fn() }) }));
import GoalProgressWidget from './GoalProgressWidget';
import UpcomingTasksWidget from './UpcomingTasksWidget';
import BackupWidget from './BackupWidget';
import CosDashboardWidget from './CosDashboardWidget';
import DecisionLogWidget from './DecisionLogWidget';
import OpenThreadsWidget from './dashboard/builtins/OpenThreadsWidget';
import AutoFixMetricsWidget from './dashboard/builtins/AutoFixMetricsWidget';
const flush = () => act(async () => {});
const visible = state => {
Object.defineProperty(document, 'visibilityState', { configurable: true, value: state });
document.dispatchEvent(new Event('visibilitychange'));
};
const cases = [
{ name: 'goals', Component: GoalProgressWidget, read: 'getGoals', event: 'goals:changed',
data: title => ({ goals: [{ id: 'example', title, status: 'active', progress: 25 }] }) },
{ name: 'upcoming tasks', Component: UpcomingTasksWidget, read: 'getCosUpcomingTasks', event: 'cos:schedule:changed',
data: description => [{ taskType: 'example', description, status: 'ready' }] },
{ name: 'backup status', Component: BackupWidget, read: 'getBackupStatus', event: 'backup:changed',
data: error => ({ status: 'error', error, lastRun: new Date().toISOString() }) },
{ name: 'CoS summary', Component: CosDashboardWidget, read: 'getCosRecentTasks', event: 'cos:agent:completed',
data: description => ({ tasks: [{ id: 'example', description, taskType: 'example', success: true, completedAt: new Date().toISOString() }], summary: { total: 1, succeeded: 1 } }),
prepare: () => { fireEvent.click(screen.getByText('Recent Tasks')); } },
{ name: 'decision log', Component: DecisionLogWidget, read: 'getCosDecisionSummary', event: 'cos:decisions:changed',
data: reason => ({ hasImpactfulDecisions: true, last24Hours: { total: 1, skipped: 1 }, impactfulDecisions: [{ id: 'example', type: 'task_skipped', reason, context: {}, timestamp: new Date().toISOString() }], transparencyScore: 100 }),
prepare: () => { fireEvent.click(screen.getByText('Recent Decisions')); } },
{ name: 'open threads', Component: OpenThreadsWidget, read: 'listThreads', event: 'brain:threads:changed',
data: title => ({ threads: [{ id: 'example', title, status: 'open' }], total: 1 }) },
{ name: 'auto-fix metrics', Component: AutoFixMetricsWidget, read: 'getAutoFixMetrics', event: 'cos:tasks:changed',
data: label => ({ total: 1, overall: { resolved: 1, successRate: 1 }, byTier: [{ tier: 1, label, strategy: label, total: 1, resolved: 1, successRate: 1 }], trend: [] }) },
];
beforeEach(() => {
vi.useFakeTimers();
vi.clearAllMocks();
visible('visible');
api.getCosQuickSummary.mockResolvedValue({ today: { completed: 1 }, queue: {}, status: {} });
api.getCosLearningSummary.mockResolvedValue({});
api.getCosActivityCalendar.mockResolvedValue({ weeks: [], summary: {} });
api.getBackupStatus.mockResolvedValue({ status: 'never' });
api.getBackupSnapshots.mockResolvedValue([]);
});
afterEach(() => { cleanup(); vi.useRealTimers(); });
describe('dashboard resource subscriptions', () => {
it.each(cases)('$name updates on events, never polls, and reconciles once per reconnect/reshow', async ({ Component, read, event, data, prepare }) => {
api[read].mockResolvedValue(data('Example before'));
render(<MemoryRouter><Component /></MemoryRouter>);
await flush();
prepare?.();
expect(screen.getByText('Example before', { exact: false })).toBeInTheDocument();
expect(api[read]).toHaveBeenCalledTimes(1);
await act(async () => { await vi.advanceTimersByTimeAsync(360_000); });
expect(api[read]).toHaveBeenCalledTimes(1);
api[read].mockResolvedValue(data('Example after'));
await act(async () => socket.receive(event));
expect(screen.getByText('Example after', { exact: false })).toBeInTheDocument();
expect(api[read]).toHaveBeenCalledTimes(2);
await act(async () => socket.receive('connect'));
expect(api[read]).toHaveBeenCalledTimes(3);
await act(async () => visible('hidden'));
await act(async () => { socket.receive(event); socket.receive('connect'); });
expect(api[read]).toHaveBeenCalledTimes(3);
await act(async () => visible('visible'));
expect(api[read]).toHaveBeenCalledTimes(4);
await act(async () => visible('visible'));
expect(api[read]).toHaveBeenCalledTimes(4);
});
it('reconciles CoS day aggregates on the server midnight event', async () => {
api.getCosRecentTasks.mockResolvedValue({ tasks: [], summary: {} });
api.getCosQuickSummary.mockResolvedValue({ today: { completed: 7, succeeded: 7 }, queue: {}, status: { running: true } });
render(<MemoryRouter><CosDashboardWidget /></MemoryRouter>);
await flush();
expect(screen.getByText('7')).toBeInTheDocument();
api.getCosQuickSummary.mockResolvedValue({ today: { completed: 0, succeeded: 0 }, queue: {}, status: { running: true } });
await act(async () => socket.receive('cos:day:changed'));
expect(screen.queryByText('7')).not.toBeInTheDocument();
expect(api.getCosQuickSummary).toHaveBeenCalledTimes(2);
});
it('advances overdue coloring and schedule countdowns with no network reads', async () => {
// Local noon, not a UTC instant: the widget prints the due date in the
// machine's zone, so 12:00Z reads "Jan 2" anywhere east of UTC+12.
const now = new Date(2026, 0, 1, 12, 0, 0);
vi.setSystemTime(now);
api.listThreads.mockResolvedValue({ threads: [{ id: 'example', title: 'Example deadline', status: 'open', dueAt: new Date(now.getTime() + 30000).toISOString() }], total: 1 });
api.getCosUpcomingTasks.mockResolvedValue([{ taskType: 'example', description: 'Example task', status: 'scheduled', eligibleAt: Date.now() + 120000 }]);
render(<MemoryRouter><OpenThreadsWidget /><UpcomingTasksWidget /></MemoryRouter>);
await flush();
const dueDate = screen.getByText('Jan 1, 2026');
expect(dueDate).not.toHaveClass('text-port-error');
expect(screen.getByText('Next: in 2m')).toBeInTheDocument();
await act(async () => { await vi.advanceTimersByTimeAsync(60000); });
expect(dueDate).toHaveClass('text-port-error');
expect(screen.getByText('Next: in 1m')).toBeInTheDocument();
expect(api.listThreads).toHaveBeenCalledTimes(1);
expect(api.getCosUpcomingTasks).toHaveBeenCalledTimes(1);
});
it('refreshes the open snapshot list after backup finalization without a timer', async () => {
api.getBackupSnapshots.mockResolvedValue([{ id: 'example-before', fileCount: 1 }]);
render(<MemoryRouter><BackupWidget /></MemoryRouter>);
await flush();
fireEvent.click(screen.getByRole('button', { name: 'Snapshots' }));
await flush();
expect(screen.getByText('example-before')).toBeInTheDocument();
api.getBackupSnapshots.mockResolvedValue([{ id: 'example-after', fileCount: 2 }]);
await act(async () => socket.receive('backup:changed'));
expect(screen.getByText('example-after')).toBeInTheDocument();
await act(async () => { await vi.advanceTimersByTimeAsync(360_000); });
expect(api.getBackupSnapshots).toHaveBeenCalledTimes(2);
await act(async () => socket.receive('connect'));
expect(api.getBackupSnapshots).toHaveBeenCalledTimes(3);
await act(async () => visible('hidden'));
await act(async () => visible('visible'));
expect(api.getBackupSnapshots).toHaveBeenCalledTimes(4);
});
});