Skip to content

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

28.5 KB
Raw Blame
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();
  });
});