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 { MemoryRouter } from 'react-router';
import * as api from '../services/api';
import socket from '../services/socket';
import { TailcatServeProvider } from '../components/instances/TailcatServeProvider';
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { render as renderUI, screen, within, fireEvent, waitFor, act } from '@testing-library/react';
import TailcatServePanel from '../components/instances/TailcatServePanel';
import Instances, { AddPeerForm, PeerCard } from './Instances.jsx';
import { DEFAULT_TAILCAT_REMOTE_PORT } from '../lib/ports.js';
import { DEFAULT_PEER_PORT, DEFAULT_TAILCAT_LOCAL_PORT } from '../lib/ports.js';
import { addPeer, addTailcatPeer, startTailcatServe, getTailcatServe, stopTailcatServe, removePeer, listPeerSubscriptions, getPeerFullSyncCoverage, syncPeer } from '../services/api';
vi.mock('../services/api', () => ({
getInstances: vi.fn(),
getSettings: vi.fn().mockResolvedValue({}),
updateSettings: vi.fn(),
getCosJob: vi.fn().mockResolvedValue(null),
updateSelfInstance: vi.fn(),
addPeer: vi.fn(),
addTailcatPeer: vi.fn(),
updatePeer: vi.fn(),
removePeer: vi.fn(),
connectPeer: vi.fn(),
reciprocatePeer: vi.fn(),
probePeer: vi.fn(),
syncPeer: vi.fn(),
getTailnetInfo: vi.fn(),
getNetworkExposure: vi.fn(),
listPeerSubscriptions: vi.fn(),
getPeerFullSyncCoverage: vi.fn(),
getBrainParityReports: vi.fn(),
getTailcatForwards: vi.fn().mockResolvedValue({ forwards: [] }),
retryTailcatForward: vi.fn(),
forgetTailcatForward: vi.fn(),
getTailcatServe: vi.fn().mockResolvedValue({
enabled: false, status: 'stopped', live: false, localPort: 5555,
keyName: 'portos-api', tcAddress: null, tcAddressRedacted: null, hasAddress: false,
}),
startTailcatServe: vi.fn(),
retryTailcatServe: vi.fn(),
stopTailcatServe: vi.fn(),
}));
vi.mock('../services/socket', () => ({ default: { connected: true, on: vi.fn(), off: vi.fn(), emit: vi.fn() } }));
describe('AddPeerForm port default', () => {
beforeEach(() => {
vi.clearAllMocks();
addPeer.mockResolvedValue({ id: 'peer-1' });
});
// Regression: the placeholder advertised :5554 (the Vite dev port) while the
// field defaulted to the API port, so clearing the field suggested a port
// PortOS never serves the API on.
it('advertises the same port in the placeholder as it defaults to', async () => {
render(<AddPeerForm onAdd={() => {}} />);
await act(async () => {});
const portInput = screen.getByLabelText('Peer port');
expect(portInput).toHaveValue(DEFAULT_PEER_PORT);
expect(portInput.getAttribute('placeholder')).toBe(String(DEFAULT_PEER_PORT));
});
it('falls back to the default port when the field is cleared', async () => {
render(<AddPeerForm onAdd={() => {}} />);
fireEvent.change(screen.getByLabelText('Peer address'), { target: { value: '192.0.2.10' } });
fireEvent.change(screen.getByLabelText('Peer port'), { target: { value: '' } });
fireEvent.click(screen.getByRole('button', { name: 'Add' }));
await waitFor(() => expect(addPeer).toHaveBeenCalledWith({
address: '192.0.2.10',
port: DEFAULT_PEER_PORT,
}));
});
});
describe('AddPeerForm tailcat path', () => {
beforeEach(() => {
vi.clearAllMocks();
addPeer.mockResolvedValue({ id: 'peer-1' });
addTailcatPeer.mockResolvedValue({ id: 'peer-tc', port: DEFAULT_TAILCAT_LOCAL_PORT, transport: 'tailcat' });
});
it('submits a pasted tc address through addTailcatPeer (not classic addPeer)', async () => {
render(<AddPeerForm onAdd={() => {}} />);
fireEvent.click(screen.getByRole('button', { name: 'Tailcat' }));
const tc = 'tcEXAMPLE' + 'B'.repeat(40);
fireEvent.change(screen.getByLabelText('Tailcat address'), { target: { value: tc } });
fireEvent.click(screen.getByRole('button', { name: 'Add via tailcat' }));
await waitFor(() => expect(addTailcatPeer).toHaveBeenCalledWith({ tcAddress: tc, remotePort: DEFAULT_TAILCAT_REMOTE_PORT }));
expect(addPeer).not.toHaveBeenCalled();
});
it('sends HTTPS selection for a remote TLS install', async () => {
render(<AddPeerForm onAdd={() => {}} />);
fireEvent.click(screen.getByRole('button', { name: 'Tailcat' }));
const tc = 'tcEXAMPLE' + 'B'.repeat(40);
fireEvent.change(screen.getByLabelText('Tailcat address'), { target: { value: tc } });
fireEvent.click(screen.getByLabelText('Remote PortOS uses HTTPS'));
fireEvent.click(screen.getByRole('button', { name: 'Add via tailcat' }));
await waitFor(() => expect(addTailcatPeer).toHaveBeenCalledWith({ tcAddress: tc, protocol: 'https', remotePort: DEFAULT_TAILCAT_REMOTE_PORT }));
});
it('keeps classic host/port add working' , async () => {
render(<AddPeerForm onAdd={() => {}} />);
fireEvent.change(screen.getByLabelText('Peer address'), { target: { value: '192.0.2.10' } });
fireEvent.click(screen.getByRole('button', { name: 'Add' }));
await waitFor(() => expect(addPeer).toHaveBeenCalledWith({
address: '192.0.2.10',
port: DEFAULT_PEER_PORT,
}));
expect(addTailcatPeer).not.toHaveBeenCalled();
});
it('documents the 15555 local forward standard in the tailcat hint', async () => {
render(<AddPeerForm onAdd={() => {}} />);
fireEvent.click(screen.getByRole('button', { name: 'Tailcat' }));
// Settling the silent getTailcatServe from switching into Tailcat mode.
await waitFor(() => expect(getTailcatServe).toHaveBeenCalled());
expect(screen.getAllByText(new RegExp(String(DEFAULT_TAILCAT_LOCAL_PORT))).length).toBeGreaterThan(0);
});
});
// Regression: on a phone the mode toggles, fields, disclosure and submit measured
// 17-38px high. jsdom has no layout, so pin the 44px touch floor (`min-h-11`) on
// every interactive control in each mode instead of a pixel measurement.
describe('AddPeerForm touch targets', () => {
beforeEach(() => {
vi.clearAllMocks();
getTailcatServe.mockResolvedValue({
enabled: false, status: 'stopped', live: false, localPort: 5555,
keyName: 'portos-api', tcAddress: null, tcAddressRedacted: null, hasAddress: false,
});
});
it.each([
['classic host/port', () => {}],
['tailcat dial them', () => fireEvent.click(screen.getByRole('button', { name: 'Tailcat' }))],
['tailcat they dial us', () => {
fireEvent.click(screen.getByRole('button', { name: 'Tailcat' }));
fireEvent.click(screen.getByRole('button', { name: 'They dial us' }));
}],
])('gives every interactive Add Peer control a 44px touch height in %s mode', async (_label, selectMode) => {
const { container } = render(<AddPeerForm onAdd={() => {}} />);
selectMode();
fireEvent.click(screen.getByRole('button', { name: /Add credentials|Hide credentials/ }));
await waitFor(() => expect(getTailcatServe).toHaveBeenCalled());
const controls = [...container.querySelectorAll('form button, form input:not([type="checkbox"]), form label')];
expect(controls.length).toBeGreaterThan(0);
for (const control of controls) {
expect(control.className, control.outerHTML.slice(0, 120)).toMatch(/\bmin-h-11\b/);
}
});
});
describe('AddPeerForm dial direction', () => {
beforeEach(() => {
vi.clearAllMocks();
addTailcatPeer.mockResolvedValue({ id: 'peer-tc', port: DEFAULT_TAILCAT_LOCAL_PORT, transport: 'tailcat' });
getTailcatServe.mockResolvedValue({
enabled: false, status: 'stopped', live: false, localPort: 5555,
keyName: 'portos-api', tcAddress: null, tcAddressRedacted: null, hasAddress: false,
});
startTailcatServe.mockResolvedValue({
enabled: true, status: 'active', live: true, localPort: 5555,
keyName: 'portos-api',
tcAddress: 'tcEXAMPLE' + 'D'.repeat(40),
tcAddressRedacted: 'tcEX…DDDD',
hasAddress: true,
});
});
it('defaults to Dial them and still submits a pasted address', async () => {
render(<AddPeerForm onAdd={() => {}} />);
fireEvent.click(screen.getByRole('button', { name: 'Tailcat' }));
expect(screen.getByRole('button', { name: 'Dial them' })).toHaveAttribute('aria-pressed', 'true');
const tc = 'tcEXAMPLE' + 'B'.repeat(40);
fireEvent.change(screen.getByLabelText('Tailcat address'), { target: { value: tc } });
fireEvent.click(screen.getByRole('button', { name: 'Add via tailcat' }));
await waitFor(() => expect(addTailcatPeer).toHaveBeenCalledWith({ tcAddress: tc, remotePort: DEFAULT_TAILCAT_REMOTE_PORT }));
});
it('switches to They dial us and starts serve instead of pasting', async () => {
render(<AddPeerForm onAdd={() => {}} />);
fireEvent.click(screen.getByRole('button', { name: 'Tailcat' }));
fireEvent.click(screen.getByRole('button', { name: 'They dial us' }));
expect(screen.queryByLabelText('Tailcat address')).not.toBeInTheDocument();
fireEvent.click(screen.getByRole('button', { name: 'Start serve' }));
await waitFor(() => expect(startTailcatServe).toHaveBeenCalled());
expect(addTailcatPeer).not.toHaveBeenCalled();
});
});
function render(ui) { return renderUI(<TailcatServeProvider>{ui}</TailcatServeProvider>); }
it('shares start and stop receipts between both serve controls', async () => {
getTailcatServe.mockResolvedValue({ live: false, enabled: false, status: 'stopped' });
startTailcatServe.mockResolvedValue({ live: true, enabled: true, status: 'active' });
stopTailcatServe.mockResolvedValue({ live: false, enabled: false, status: 'stopped' });
render(<><AddPeerForm onAdd={() => {}} /><TailcatServePanel /></>);
await act(async () => {});
fireEvent.click(screen.getByRole('button', { name: 'Tailcat' }));
fireEvent.click(screen.getByRole('button', { name: 'They dial us' }));
fireEvent.click(screen.getAllByRole('button', { name: 'Start serve' })[0]);
expect(await screen.findByRole('button', { name: 'Serve running' })).toBeDisabled();
fireEvent.click(await screen.findByRole('button', { name: 'Stop' }));
await waitFor(() => expect(screen.getAllByRole('button', { name: 'Start serve' })).toHaveLength(2));
expect(screen.queryByRole('button', { name: 'Serve running' })).not.toBeInTheDocument();
});
describe('PeerCard removal confirmation', () => {
it('uses explicit, peer-specific confirmation actions', async () => {
const onRefresh = vi.fn();
removePeer.mockResolvedValue({ ok: true });
listPeerSubscriptions.mockResolvedValue({ subscriptions: [] });
render(
<PeerCard
peer={{
id: 'peer-1',
name: 'Living Room',
address: '192.0.2.10',
port: 5555,
status: 'offline',
enabled: true,
directions: [],
lastSeen: new Date().toISOString(),
consecutiveFailures: 0,
}}
onRefresh={onRefresh}
/>,
);
fireEvent.click(screen.getByRole('button', { name: 'Remove peer' }));
expect(screen.queryByRole('button', { name: 'Yes' })).not.toBeInTheDocument();
expect(screen.queryByRole('button', { name: 'No' })).not.toBeInTheDocument();
expect(screen.getByText('Remove peer "Living Room"?')).toBeInTheDocument();
expect(screen.getByRole('button', { name: 'Confirm removing peer Living Room' })).toHaveClass('text-port-error');
expect(screen.getByRole('button', { name: 'Cancel removing peer Living Room' })).toBeInTheDocument();
fireEvent.click(screen.getByRole('button', { name: 'Confirm removing peer Living Room' }));
await waitFor(() => expect(removePeer).toHaveBeenCalledWith('peer-1'));
});
});
describe('PeerCard snapshot progress', () => {
const peer = {
id: 'peer-snapshot', instanceId: 'remote-snapshot', name: 'Snapshot peer',
address: '192.0.2.20', port: 5555, status: 'online', enabled: true,
directions: ['outbound'], syncCategories: { universe: true, pipeline: true },
remoteSyncSeqs: { checksums: { universe: 'new', pipeline: 'same' } },
};
const syncStatus = {
cursors: { 'remote-snapshot': { checksums: { universe: 'old', pipeline: 'same' } } },
};
const subscriptions = [
{ recordKind: 'universe', recordId: 'universe-1', peerId: peer.instanceId },
{ recordKind: 'series', recordId: 'series-1', peerId: peer.instanceId },
];
const badge = label => within(screen.getByText(label + ':').parentElement);
beforeEach(() => {
listPeerSubscriptions.mockResolvedValue({ subscriptions });
getPeerFullSyncCoverage.mockResolvedValue({ fullyMirrored: true, total: 2 });
});
// Outbound delivery coverage must never replace inbound snapshot progress.
it('uses checksums with loaded subscriptions and independent full-sync coverage', async () => {
const props = { peer: { ...peer, fullSync: true }, syncStatus, onRefresh: vi.fn() };
const view = renderUI(<PeerCard {...props} />);
fireEvent.click(screen.getByRole('button', { name: /sync categories/i }));
expect(await screen.findByText('Fully mirrored · 2 records')).toBeInTheDocument();
await act(async () => {});
expect(badge('Universe').getByText('behind')).toBeInTheDocument();
expect(badge('Pipeline').getByText('synced')).toBeInTheDocument();
expect(screen.queryByText('live-push')).not.toBeInTheDocument();
view.rerender(<PeerCard {...props} syncStatus={{
cursors: { [peer.instanceId]: { checksums: { universe: 'new', pipeline: 'old' } } },
}} />);
expect(badge('Universe').getByText('synced')).toBeInTheDocument();
expect(badge('Pipeline').getByText('behind')).toBeInTheDocument();
view.rerender(<PeerCard {...props}
peer={{ ...props.peer, remoteSyncSeqs: { checksums: { universe: 'new' } } }}
syncStatus={{ cursors: { [peer.instanceId]: { checksums: { pipeline: 'same' } } } }}
/>);
expect(badge('Universe').getByText('pending')).toBeInTheDocument();
expect(badge('Pipeline').getByText('pending')).toBeInTheDocument();
});
it('shows unavailable for degraded coverage, request failure, and recovers on refresh', async () => {
getPeerFullSyncCoverage.mockResolvedValue({
available: false, partial: true, fullyMirrored: false, total: 2, confirmed: 2, pending: 0,
});
const props = { peer: { ...peer, fullSync: true, lastSeen: 'first' }, syncStatus, onRefresh: vi.fn() };
const view = renderUI(<PeerCard {...props} />);
fireEvent.click(screen.getByRole('button', { name: /sync categories/i }));
expect(await screen.findByText('Coverage unavailable')).toHaveClass('text-port-warning');
expect(screen.queryByText(/Fully mirrored/)).not.toBeInTheDocument();
expect(screen.getByText('Coverage unavailable')).toHaveAttribute('title', expect.stringContaining('partial'));
getPeerFullSyncCoverage.mockRejectedValue(new Error('Request failed'));
view.rerender(<PeerCard {...props} peer={{ ...props.peer, lastSeen: 'second' }} />);
await waitFor(() => expect(getPeerFullSyncCoverage).toHaveBeenCalledTimes(2));
expect(await screen.findByText('Coverage unavailable')).toBeInTheDocument();
expect(screen.queryByText('checking coverage…')).not.toBeInTheDocument();
getPeerFullSyncCoverage.mockResolvedValue({ fullyMirrored: false, total: 3, confirmed: 2, pending: 1 });
view.rerender(<PeerCard {...props} peer={{ ...props.peer, lastSeen: 'third' }} />);
expect(await screen.findByText('1 pending · 2/3 mirrored')).toBeInTheDocument();
expect(screen.queryByText('Coverage unavailable')).not.toBeInTheDocument();
});
// #7943: a cycle in which every category failed leaves lastSyncAt at its
// previous value and records lastSyncError. Without rendering it, the card
// showed "synced N minutes ago" for a peer that had been broken for weeks.
it('renders lastSyncError beside the timestamp, and nothing when the cycle was clean', async () => {
const failed = {
cursors: {
[peer.instanceId]: {
checksums: { universe: 'old', pipeline: 'same' },
lastSyncAt: '2026-01-01T00:00:00.000Z',
lastSyncError: 'universe: peer DB was rebuilt',
},
},
};
const view = renderUI(<PeerCard peer={peer} syncStatus={failed} onRefresh={vi.fn()} />);
await act(async () => {});
expect(screen.getByText(/Last sync failed: universe: peer DB was rebuilt/)).toBeInTheDocument();
view.rerender(<PeerCard peer={peer} syncStatus={syncStatus} onRefresh={vi.fn()} />);
expect(screen.queryByText(/Last sync failed/)).not.toBeInTheDocument();
});
// A failed cycle applies nothing, so a totalApplied-only refetch gate would
// never pull the new error string onto the card.
it('refetches on a complete event that carries an error but applied nothing', async () => {
const onRefresh = vi.fn();
renderUI(<PeerCard peer={peer} syncStatus={syncStatus} onRefresh={onRefresh} />);
await act(async () => {});
const [, handleProgress] = socket.on.mock.calls.find(([event]) => event === 'sync:progress');
await act(async () => handleProgress({ phase: 'complete', peerId: peer.instanceId, totalApplied: 0, error: null }));
expect(onRefresh).not.toHaveBeenCalled();
await act(async () => handleProgress({
phase: 'complete', peerId: peer.instanceId, totalApplied: 0, error: 'universe: peer DB was rebuilt',
}));
expect(onRefresh).toHaveBeenCalledTimes(1);
});
// A slow or failed subscription endpoint must not hide a known mismatch.
it('shows known status while subscriptions are unresolved and after they fail', async () => {
let rejectSubscriptions;
listPeerSubscriptions.mockReturnValue(new Promise((_, reject) => { rejectSubscriptions = reject; }));
renderUI(<PeerCard peer={peer} syncStatus={syncStatus} onRefresh={vi.fn()} />);
expect(badge('Universe').getByText('behind')).toBeInTheDocument();
expect(badge('Pipeline').getByText('synced')).toBeInTheDocument();
await act(async () => { rejectSubscriptions(new Error('Subscriptions unavailable')); });
expect(badge('Universe').getByText('behind')).toBeInTheDocument();
expect(badge('Pipeline').getByText('synced')).toBeInTheDocument();
});
it('flags a failed subscription read with Retry instead of hiding schema warnings, then shows the gap after Retry', async () => {
listPeerSubscriptions.mockRejectedValueOnce(new Error('Subscriptions unavailable'));
renderUI(<PeerCard peer={peer} syncStatus={syncStatus} onRefresh={vi.fn()} />);
expect(await screen.findByRole('alert')).toHaveTextContent('Subscriptions unavailable');
expect(screen.queryByText('Schema version mismatch')).not.toBeInTheDocument();
listPeerSubscriptions.mockResolvedValueOnce({
subscriptions: [{
recordKind: 'universe', recordId: 'universe-1', peerId: peer.instanceId,
blockedBySchema: { ahead: [], behind: ['universe'], peerPortosVersion: '1.0.0' },
}],
});
fireEvent.click(screen.getByRole('button', { name: 'Retry' }));
expect(await screen.findByText('Schema version mismatch')).toBeInTheDocument();
expect(screen.queryByRole('alert')).not.toBeInTheDocument();
});
// Active sync takes precedence until the user-triggered request completes.
it('shows syncing ahead of checksum status and restores status on completion', async () => {
let resolveSync;
syncPeer.mockReturnValue(new Promise(resolve => { resolveSync = resolve; }));
renderUI(<PeerCard peer={peer} syncStatus={syncStatus} onRefresh={vi.fn()} />);
await act(async () => {});
fireEvent.click(screen.getByRole('button', { name: /sync now/i }));
expect(badge('Universe').getByText('syncing…')).toBeInTheDocument();
expect(badge('Pipeline').getByText('syncing…')).toBeInTheDocument();
await act(async () => { resolveSync({}); });
expect(badge('Universe').getByText('behind')).toBeInTheDocument();
expect(badge('Pipeline').getByText('synced')).toBeInTheDocument();
});
});
describe('Instances page connection drawers', () => {
const peer = { id: 'page-peer', name: 'Office', status: 'online', enabled: true, address: '192.0.2.10', port: 5555 };
beforeEach(() => {
api.getInstances.mockResolvedValue({ self: { name: 'Home' }, peers: [peer] });
api.getTailnetInfo.mockResolvedValue({ suffix: 'example', self: 'home' });
api.getNetworkExposure.mockResolvedValue({ setup: { complete: true } });
api.getBrainParityReports.mockResolvedValue({ reports: {} });
api.getSettings.mockResolvedValue({});
api.getTailcatForwards.mockResolvedValue({ forwards: [] });
api.getTailcatServe.mockResolvedValue({ status: 'stopped', live: false });
api.listPeerSubscriptions.mockResolvedValue({ subscriptions: [] });
});
it('recovers an unavailable snapshot through the drawer and preserves data on refresh failure', async () => {
api.getInstances.mockRejectedValueOnce(new Error('Unavailable'));
renderUI(<MemoryRouter><Instances /></MemoryRouter>);
expect(await screen.findByRole('alert')).toHaveTextContent('Instance snapshot unavailable');
expect(screen.queryByText('No peers registered yet')).not.toBeInTheDocument();
fireEvent.click(screen.getByRole('button', { name: 'Connection settings' }));
expect(screen.getByText('This instance settings are unavailable until the instance snapshot loads.')).toBeInTheDocument();
const updatePeers = socket.on.mock.calls.find(([event]) => event === 'instances:peers:updated')[1];
act(() => updatePeers([]));
expect(screen.getByRole('alert')).toBeInTheDocument();
fireEvent.click(screen.getByRole('button', { name: 'Retry instance settings' }));
expect(await within(screen.getByRole('dialog')).findByRole('button', { name: 'Edit', exact: true })).toBeEnabled();
expect(screen.queryByRole('alert')).not.toBeInTheDocument();
expect(screen.getByRole('button', { name: 'Sync now' })).toBeEnabled();
expect(api.getInstances).toHaveBeenLastCalledWith({ silent: true });
api.getInstances.mockRejectedValueOnce(new Error('Refresh failed'));
const connectHandler = socket.on.mock.calls.find(([event]) => event === 'connect')[1];
await act(async () => connectHandler());
expect(await screen.findByRole('alert')).toHaveTextContent('Showing last loaded data');
expect(screen.getByRole('button', { name: 'Sync now' })).toBeEnabled();
expect(within(screen.getByRole('dialog')).getByRole('button', { name: 'Edit', exact: true })).toBeEnabled();
api.getInstances.mockResolvedValueOnce({ self: { name: 'Recovered' }, peers: [], syncStatus: { cursors: {} } });
fireEvent.click(screen.getByRole('button', { name: 'Retry snapshot' }));
expect(await screen.findByText('No peers registered yet')).toBeInTheDocument();
expect(screen.queryByRole('alert')).not.toBeInTheDocument();
expect(screen.getAllByText('Recovered').length).toBeGreaterThan(0);
});
// Regression: the full setup stack displaced peer actions, and moving it to
// remounting drawers could discard drafts or accidentally start networking.
it('prioritizes peers and retains drafts across drawer sections and failed adds', async () => {
renderUI(<MemoryRouter><Instances /></MemoryRouter>);
expect(await screen.findByRole('button', { name: 'Sync now' })).toBeEnabled();
expect(screen.getByRole('button', { name: 'Probe now' })).toBeEnabled();
expect(screen.queryByLabelText('Peer address')).not.toBeInTheDocument();
fireEvent.click(screen.getByRole('button', { name: 'Add peer' }));
expect(screen.getByLabelText('Peer address')).toHaveFocus();
fireEvent.change(screen.getByLabelText('Peer address'), { target: { value: '192.0.2.30' } });
api.addPeer.mockRejectedValueOnce(new Error('Unavailable'));
fireEvent.click(screen.getByRole('button', { name: 'Add', exact: true }));
await waitFor(() => expect(api.addPeer).toHaveBeenCalled());
expect(screen.getByLabelText('Peer address')).toHaveValue('192.0.2.30');
// The rejected addPeer call keeps the mode buttons disabled (adding=true)
// until its catch/finally settles — wait for that before switching modes,
// or a slow microtask under load leaves this click a no-op (#7978).
await waitFor(() => expect(screen.getByRole('button', { name: 'Tailcat', exact: true })).not.toBeDisabled());
fireEvent.click(screen.getByRole('button', { name: 'Tailcat', exact: true }));
fireEvent.change(screen.getByLabelText('Tailcat address'), { target: { value: 'tcEXAMPLE' } });
fireEvent.click(screen.getByRole('button', { name: 'They dial us' }));
fireEvent.click(screen.getByRole('button', { name: 'Close add peer' }));
fireEvent.click(screen.getByRole('button', { name: 'Connection settings', exact: true }));
const dialog = screen.getByRole('dialog');
fireEvent.click(within(dialog).getByRole('button', { name: 'Edit', exact: true }));
fireEvent.change(screen.getByLabelText('Instance name'), { target: { value: 'Draft name' } });
const sections = () => within(screen.getByRole('tablist', { name: 'Connection settings sections' }));
fireEvent.click(sections().getByRole('tab', { name: 'Tailcat' }));
fireEvent.click(sections().getByRole('tab', { name: 'This instance' }));
expect(screen.getByLabelText('Instance name')).toHaveValue('Draft name');
fireEvent.click(screen.getByRole('button', { name: 'Close settings' }));
fireEvent.click(screen.getByRole('button', { name: 'Add peer' }));
expect(screen.getByRole('button', { name: 'They dial us' })).toHaveAttribute('aria-pressed', 'true');
fireEvent.click(screen.getByRole('button', { name: 'Dial them' }));
expect(screen.getByLabelText('Tailcat address')).toHaveValue('tcEXAMPLE');
fireEvent.click(screen.getByRole('button', { name: 'Host / port' }));
expect(screen.getByLabelText('Peer address')).toHaveValue('192.0.2.30');
expect(api.startTailcatServe).not.toHaveBeenCalled();
expect(api.syncPeer).not.toHaveBeenCalled();
expect(api.probePeer).not.toHaveBeenCalled();
expect(api.updateSettings).not.toHaveBeenCalled();
});
// #8110: the server rebuilds an empty per-socket subscriber Set on every
// reconnect (restart, self-update, sleep, a network blip). Without a
// reconnect-driven re-subscribe, peer updates and sync progress go silent
// for the rest of the tab's life after the first reconnect.
it('re-subscribes instances:* and refetches peers on a socket reconnect', async () => {
renderUI(<MemoryRouter><Instances /></MemoryRouter>);
await screen.findByRole('button', { name: 'Sync now' });
expect(socket.emit).toHaveBeenCalledWith('instances:subscribe');
const getInstancesCalls = api.getInstances.mock.calls.length;
const connectHandler = socket.on.mock.calls.find(([event]) => event === 'connect')?.[1];
expect(connectHandler).toBeTypeOf('function');
socket.emit.mockClear();
await act(async () => connectHandler());
expect(socket.emit).toHaveBeenCalledWith('instances:subscribe');
await waitFor(() => expect(api.getInstances.mock.calls.length).toBeGreaterThan(getInstancesCalls));
});
// Regression: removing the last peer must not hide orphan/serve recovery or
// the saved route that would keep unattended rendering pointed at that peer.
it('keeps actionable recovery and the add CTA after the last peer disappears', async () => {
api.getTailcatForwards.mockResolvedValue({ forwards: [{ id: 'orphan', peerId: peer.id, name: 'Saved forward', status: 'failed', remotePort: 5558 }] });
api.getTailcatServe.mockResolvedValue({ status: 'failed', live: false });
api.getSettings.mockResolvedValue({ federation: { mediaRouting: { image: { peerId: peer.id, engine: 'comfy', modelId: 'old-model' } } } });
renderUI(<MemoryRouter><Instances /></MemoryRouter>);
await screen.findByRole('button', { name: 'Sync now' });
const updatePeers = socket.on.mock.calls.find(([event]) => event === 'instances:peers:updated')[1];
act(() => updatePeers([]));
fireEvent.click(await screen.findByRole('button', { name: /Tailcat needs attention/ }));
expect(await screen.findByText('Saved forward')).toBeInTheDocument();
expect(screen.getAllByRole('button', { name: 'Retry', exact: true })).toHaveLength(2);
fireEvent.click(screen.getByRole('button', { name: 'Close settings' }));
fireEvent.click(screen.getByRole('button', { name: /render routing needs attention/ }));
const select = screen.getByLabelText('Image');
expect(select).toBeEnabled();
api.updateSettings.mockImplementation(async (patch) => patch);
api.getSettings.mockResolvedValue({ federation: { mediaRouting: { image: { peerId: peer.id, engine: 'comfy', modelId: 'old-model' } } } });
fireEvent.change(select, { target: { value: '' } });
await waitFor(() => expect(api.updateSettings).toHaveBeenCalledWith({ federation: { mediaRouting: { image: null } } }, { silent: true }));
fireEvent.click(screen.getByRole('button', { name: 'Close settings' }));
expect(screen.queryByRole('button', { name: /render routing needs attention/ })).not.toBeInTheDocument();
fireEvent.click(screen.getByRole('button', { name: 'Add your first peer' }));
expect(screen.getByRole('dialog', { name: 'Add peer' })).toBeInTheDocument();
expect(screen.getByLabelText('Peer address')).toHaveFocus();
});
});