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, beforeEach, vi } from 'vitest';
import { render, screen, fireEvent, waitFor, act } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import FableLoomHostedJoin from './FableLoomHostedJoin';
// Mock socket.io-client
const mockSocket = {
on: vi.fn(),
emit: vi.fn(),
disconnect: vi.fn(),
};
vi.mock('socket.io-client', () => ({
io: vi.fn(() => mockSocket),
}));
describe('FableLoomHostedJoin', () => {
beforeEach(() => {
vi.clearAllMocks();
window.location.hash = '';
});
it('renders error when hash credentials are missing', () => {
window.location.hash = '';
render(<FableLoomHostedJoin />);
expect(screen.getByText('Hosted Play Error')).toBeInTheDocument();
expect(screen.getByText(/Invalid or missing join credentials/i)).toBeInTheDocument();
const shell = screen.getByRole('main');
expect(shell).toContainElement(screen.getByRole('heading', { name: 'Hosted Play Error' }));
expect(shell).toHaveClass('h-dvh-screen');
expect(shell).not.toHaveClass('min-h-screen');
});
it('connects to /fableloom-hosted when hash credentials are provided', async () => {
window.location.hash = '#session=sess-123&token=tok-abc';
const { io } = await import('socket.io-client');
render(<FableLoomHostedJoin />);
expect(io).toHaveBeenCalledWith('/fableloom-hosted', expect.objectContaining({
auth: { sessionId: 'sess-123', token: 'tok-abc', role: 'audience' },
}));
expect(screen.getByText('FableLoom Play')).toBeInTheDocument();
expect(screen.getByText('Audience Microphone UI')).toBeInTheDocument();
});
it('keeps the transcript as the only inner scroll region of the dynamic shell', () => {
window.location.hash = '#session=sess-123&token=tok-abc';
render(<FableLoomHostedJoin />);
const shell = screen.getByRole('main');
expect(shell).toHaveClass('h-dvh-screen', 'overflow-y-auto');
expect(shell).not.toHaveClass('overflow-hidden');
expect(shell).not.toHaveClass('min-h-screen');
const scrollRegions = shell.querySelectorAll('.overflow-y-auto');
expect(scrollRegions).toHaveLength(1);
expect(scrollRegions[0]).toHaveClass('flex-1', 'min-h-[8rem]');
const header = shell.querySelector('header');
expect(header).toHaveClass('shrink-0');
expect(header.nextElementSibling).toHaveClass('shrink-0');
expect(screen.getByPlaceholderText('Or type a message…').closest('form').parentElement).toHaveClass('shrink-0');
});
it('sends text input fallback when submitted', async () => {
window.location.hash = '#session=sess-123&token=tok-abc';
render(<FableLoomHostedJoin />);
const input = screen.getByPlaceholderText('Or type a message…');
fireEvent.change(input, { target: { value: ' Look around the room ' } });
const sendButton = screen.getByRole('button', { name: 'Send message' });
expect(sendButton).toBeInTheDocument();
expect(sendButton).toHaveClass(
'min-w-[44px]',
'min-h-[44px]',
'flex',
'items-center',
'justify-center',
);
fireEvent.submit(input.closest('form'));
expect(mockSocket.emit).toHaveBeenCalledWith('hosted:turn:text', { text: ' Look around the room ' });
});
it('preserves an over-limit paste, refuses to send, and lets the guest shorten the message', async () => {
window.location.hash = '#session=sess-123&token=tok-abc';
const user = userEvent.setup();
render(<FableLoomHostedJoin />);
const input = screen.getByRole('textbox', { name: 'Message protagonist' });
expect(input).not.toHaveAttribute('maxlength');
expect(input).toHaveAccessibleDescription('0 / 1,000 characters');
await user.click(input);
await user.paste('x'.repeat(1001));
expect(input).toHaveValue('x'.repeat(1001));
expect(input).toHaveAccessibleDescription('1,001 / 1,000 characters Message exceeds 1,000 characters. Shorten it before sending.');
expect(screen.getByRole('alert')).toHaveTextContent('Shorten it before sending.');
expect(screen.getByRole('button', { name: 'Send message' })).toBeDisabled();
fireEvent.submit(input.closest('form'));
expect(mockSocket.emit).not.toHaveBeenCalled();
input.setSelectionRange(1000, 1001);
await user.keyboard('{Backspace}');
expect(input).toHaveValue('x'.repeat(1000));
expect(screen.queryByRole('alert')).not.toBeInTheDocument();
expect(input).toHaveAccessibleDescription('1,000 / 1,000 characters');
await user.click(screen.getByRole('button', { name: 'Send message' }));
expect(mockSocket.emit).toHaveBeenCalledWith('hosted:turn:text', { text: 'x'.repeat(1000) });
expect(input).toHaveAccessibleDescription('0 / 1,000 characters');
});
it('refuses over-limit typed input without cutting or clearing it', () => {
window.location.hash = '#session=sess-123&token=tok-abc';
render(<FableLoomHostedJoin />);
const input = screen.getByRole('textbox', { name: 'Message protagonist' });
const text = 'x'.repeat(1001);
fireEvent.change(input, { target: { value: text } });
fireEvent.submit(input.closest('form'));
expect(mockSocket.emit).not.toHaveBeenCalled();
expect(input).toHaveValue(text);
expect(input).toHaveAccessibleDescription('1,001 / 1,000 characters Message exceeds 1,000 characters. Shorten it before sending.');
});
it('releases a mic opened after push-to-talk was released', async () => {
window.location.hash = '#session=sess-123&token=tok-abc';
let resolveMic;
const track = { stop: vi.fn() };
const getUserMedia = vi.fn(() => new Promise((resolve) => { resolveMic = resolve; }));
Object.defineProperty(navigator, 'mediaDevices', { configurable: true, value: { getUserMedia } });
const recorder = vi.fn();
vi.stubGlobal('MediaRecorder', recorder);
render(<FableLoomHostedJoin />);
const button = screen.getByRole('button', { name: /hold talk/i });
fireEvent.pointerDown(button);
fireEvent.pointerUp(button);
await act(async () => { resolveMic({ getTracks: () => [track] }); });
expect(track.stop).toHaveBeenCalledOnce();
expect(recorder).not.toHaveBeenCalled();
expect(mockSocket.emit).not.toHaveBeenCalledWith('hosted:mic:start');
vi.unstubAllGlobals();
});
it('stops the recorder and tracks on unmount', async () => {
window.location.hash = '#session=sess-123&token=tok-abc';
const track = { stop: vi.fn() };
Object.defineProperty(navigator, 'mediaDevices', {
configurable: true, value: { getUserMedia: vi.fn().mockResolvedValue({ getTracks: () => [track] }) },
});
const recorder = { state: 'recording', start: vi.fn(), stop: vi.fn(), mimeType: 'audio/webm' };
vi.stubGlobal('MediaRecorder', class { constructor() { return recorder; } });
const { unmount } = render(<FableLoomHostedJoin />);
fireEvent.pointerDown(screen.getByRole('button', { name: /hold talk/i }));
await waitFor(() => expect(recorder.start).toHaveBeenCalledOnce());
unmount();
expect(recorder.stop).toHaveBeenCalledOnce();
expect(track.stop).toHaveBeenCalledOnce();
vi.unstubAllGlobals();
});
it('closes the mic on release while preserving the recorder final chunk', async () => {
window.location.hash = '#session=sess-123&token=tok-abc';
const track = { stop: vi.fn() };
Object.defineProperty(navigator, 'mediaDevices', {
configurable: true,
value: { getUserMedia: vi.fn().mockResolvedValue({ getTracks: () => [track] }) },
});
let recorder;
vi.stubGlobal('MediaRecorder', class {
constructor() { this.state = 'inactive'; this.mimeType = 'audio/webm'; recorder = this; }
start() { this.state = 'recording'; }
stop() {
this.state = 'inactive';
queueMicrotask(() => {
this.ondataavailable?.({ data: new Blob(['last']) });
this.onstop?.();
});
}
});
render(<FableLoomHostedJoin />);
const button = screen.getByRole('button', { name: /hold talk/i });
fireEvent.pointerDown(button);
await waitFor(() => expect(recorder?.state).toBe('recording'));
fireEvent.pointerUp(button);
expect(track.stop).toHaveBeenCalledOnce();
await waitFor(() => expect(mockSocket.emit).toHaveBeenCalledWith('hosted:mic:stop', expect.any(Uint8Array)));
const bytes = mockSocket.emit.mock.calls.find(([event]) => event === 'hosted:mic:stop')[1];
expect(new TextDecoder().decode(bytes)).toBe('last');
expect(track.stop).toHaveBeenCalledOnce();
vi.unstubAllGlobals();
});
it('shows an over-cap recording refusal, aborts the turn, and keeps the guest connected', async () => {
const { MAX_VOICE_AUDIO_BYTES, RECORDING_TOO_LONG_MESSAGE } = await import('../lib/audioRecorder.js');
window.location.hash = '#session=sess-123&token=tok-abc';
const track = { stop: vi.fn() };
Object.defineProperty(navigator, 'mediaDevices', {
configurable: true,
value: { getUserMedia: vi.fn().mockResolvedValue({ getTracks: () => [track] }) },
});
let recorder;
vi.stubGlobal('MediaRecorder', class {
constructor() { this.state = 'inactive'; this.mimeType = 'audio/webm'; recorder = this; }
start() { this.state = 'recording'; }
stop() { this.state = 'inactive'; this.onstop?.(); }
});
try {
render(<FableLoomHostedJoin />);
const button = screen.getByRole('button', { name: /hold talk/i });
fireEvent.pointerDown(button);
await waitFor(() => expect(recorder?.state).toBe('recording'));
recorder.ondataavailable({ data: new Blob([new Uint8Array(MAX_VOICE_AUDIO_BYTES + 1)]) });
fireEvent.pointerUp(button);
expect(screen.getByRole('alert')).toHaveTextContent(RECORDING_TOO_LONG_MESSAGE);
expect(mockSocket.emit).not.toHaveBeenCalledWith('hosted:mic:stop', expect.anything());
expect(mockSocket.emit).toHaveBeenCalledWith('hosted:turn:abort');
expect(mockSocket.disconnect).not.toHaveBeenCalled();
expect(track.stop).toHaveBeenCalledOnce();
} finally {
vi.unstubAllGlobals();
}
});
it('ignores an old oversized stop callback after a newer recording starts', async () => {
const { MAX_VOICE_AUDIO_BYTES } = await import('../lib/audioRecorder.js');
window.location.hash = '#session=sess-123&token=tok-abc';
Object.defineProperty(navigator, 'mediaDevices', {
configurable: true,
value: { getUserMedia: vi.fn(async () => ({ getTracks: () => [{ stop: vi.fn() }] })) },
});
const recorders = [];
vi.stubGlobal('MediaRecorder', class {
constructor() { this.state = 'inactive'; this.mimeType = 'audio/webm'; recorders.push(this); }
start() { this.state = 'recording'; }
stop() { this.state = 'inactive'; }
});
try {
render(<FableLoomHostedJoin />);
const button = screen.getByRole('button', { name: /hold talk/i });
fireEvent.pointerDown(button);
await waitFor(() => expect(recorders).toHaveLength(1));
recorders[0].ondataavailable({ data: new Blob([new Uint8Array(MAX_VOICE_AUDIO_BYTES + 1)]) });
fireEvent.pointerUp(button);
fireEvent.pointerDown(button);
await waitFor(() => expect(recorders).toHaveLength(2));
act(() => recorders[0].onstop());
expect(mockSocket.emit).not.toHaveBeenCalledWith('hosted:turn:abort');
expect(screen.queryByRole('alert')).not.toBeInTheDocument();
recorders[1].ondataavailable({ data: new Blob(['new recording']) });
fireEvent.pointerUp(button);
act(() => recorders[1].onstop());
await waitFor(() => expect(mockSocket.emit).toHaveBeenCalledWith('hosted:mic:stop', expect.any(Uint8Array)));
const bytes = mockSocket.emit.mock.calls.find(([event]) => event === 'hosted:mic:stop')[1];
expect(new TextDecoder().decode(bytes)).toBe('new recording');
} finally {
vi.unstubAllGlobals();
}
});
it('keeps audio chunks separate across two press and release cycles', async () => {
window.location.hash = '#session=sess-123&token=tok-abc';
const tracks = [{ stop: vi.fn() }, { stop: vi.fn() }];
let streamIndex = 0;
Object.defineProperty(navigator, 'mediaDevices', {
configurable: true,
value: { getUserMedia: vi.fn(() => {
const track = tracks[streamIndex++];
return Promise.resolve({ getTracks: () => [track] });
}) },
});
const recorders = [];
vi.stubGlobal('MediaRecorder', class {
constructor() {
this.state = 'inactive';
this.mimeType = 'audio/webm';
recorders.push(this);
}
start() { this.state = 'recording'; }
stop() { this.state = 'inactive'; this.onstop?.(); }
});
render(<FableLoomHostedJoin />);
const button = screen.getByRole('button', { name: /hold talk/i });
fireEvent.pointerDown(button);
await waitFor(() => expect(recorders).toHaveLength(1));
recorders[0].ondataavailable({ data: new Blob(['first']) });
fireEvent.pointerUp(button);
await waitFor(() => expect(mockSocket.emit).toHaveBeenCalledWith('hosted:mic:stop', expect.any(Uint8Array)));
fireEvent.pointerDown(button);
await waitFor(() => expect(recorders).toHaveLength(2));
recorders[1].ondataavailable({ data: new Blob(['second']) });
fireEvent.pointerUp(button);
await waitFor(() => expect(mockSocket.emit.mock.calls.filter(([event]) => event === 'hosted:mic:stop')).toHaveLength(2));
const payloads = mockSocket.emit.mock.calls.filter(([event]) => event === 'hosted:mic:stop').map(([, bytes]) => new TextDecoder().decode(bytes));
expect(payloads).toEqual(['first', 'second']);
expect(tracks.every((track) => track.stop.mock.calls.length === 1)).toBe(true);
vi.unstubAllGlobals();
});
const socketHandler = (event) => mockSocket.on.mock.calls.find(([name]) => name === event)?.[1];
it('discards an in-progress recording and shows the mapped message when the mic is refused', async () => {
window.location.hash = '#session=sess-123&token=tok-abc';
const track = { stop: vi.fn() };
Object.defineProperty(navigator, 'mediaDevices', {
configurable: true,
value: { getUserMedia: vi.fn().mockResolvedValue({ getTracks: () => [track] }) },
});
let recorder;
vi.stubGlobal('MediaRecorder', class {
constructor() { this.state = 'inactive'; this.mimeType = 'audio/webm'; recorder = this; }
start() { this.state = 'recording'; }
stop() { this.state = 'inactive'; queueMicrotask(() => this.onstop?.()); }
});
render(<FableLoomHostedJoin />);
fireEvent.pointerDown(screen.getByRole('button', { name: /hold talk/i }));
await waitFor(() => expect(recorder?.state).toBe('recording'));
expect(screen.getByText(/release when done/i)).toBeInTheDocument();
act(() => { socketHandler('hosted:error')({ code: 'PROTAGONIST_ONSCREEN', message: 'raw server text' }); });
expect(recorder.state).toBe('inactive');
expect(track.stop).toHaveBeenCalled();
expect(screen.queryByText(/release when done/i)).not.toBeInTheDocument();
expect(screen.getByRole('alert')).toHaveTextContent(/protagonist is on screen/i);
await act(async () => { await Promise.resolve(); });
expect(mockSocket.emit).not.toHaveBeenCalledWith('hosted:mic:stop', expect.anything());
vi.unstubAllGlobals();
});
it('falls back to the server message and re-enables input after a failed turn returns to idle', () => {
window.location.hash = '#session=sess-123&token=tok-abc';
render(<FableLoomHostedJoin />);
act(() => { socketHandler('hosted:turn:phase')({ phase: 'thinking' }); });
expect(screen.getByRole('button', { name: /hold talk/i })).toBeDisabled();
expect(screen.getByPlaceholderText('Or type a message…')).toBeDisabled();
act(() => {
socketHandler('hosted:error')({ code: 'TURN_FAILED', message: 'loom read failed' });
socketHandler('hosted:turn:phase')({ phase: 'idle' });
});
expect(screen.getByRole('alert')).toHaveTextContent('loom read failed');
expect(screen.getByRole('button', { name: /hold talk/i })).not.toBeDisabled();
expect(screen.getByPlaceholderText('Or type a message…')).not.toBeDisabled();
});
it('reports audience playback completion, failure, and cancellation', async () => {
window.location.hash = '#session=sess-123&token=tok-abc';
const play = vi.spyOn(HTMLMediaElement.prototype, 'play').mockResolvedValue(undefined);
render(<FableLoomHostedJoin />);
const handler = (event) => mockSocket.on.mock.calls.filter(([name]) => name === event).at(-1)?.[1];
const audio = document.querySelector('audio');
const audienceTurn = '22222222-2222-4222-8222-222222222222';
await act(async () => {
handler('hosted:turn:tts')({
target: 'host', audio: 'QQ==', mimeType: 'audio/wav', turnId: '11111111-1111-4111-8111-111111111111',
});
});
expect(mockSocket.emit).not.toHaveBeenCalledWith('hosted:speech:done', expect.anything());
await act(async () => {
handler('hosted:turn:tts')({ target: 'audience', audio: 'QQ==', mimeType: 'audio/wav', turnId: audienceTurn });
await Promise.resolve();
});
expect(play).toHaveBeenCalled();
await act(async () => { audio.onended(); });
expect(mockSocket.emit).toHaveBeenCalledWith('hosted:speech:done', { turnId: audienceTurn, status: 'ended' });
play.mockRejectedValueOnce(new Error('blocked'));
const failedTurn = '33333333-3333-4333-8333-333333333333';
await act(async () => {
handler('hosted:turn:tts')({ target: 'audience', audio: 'QQ==', mimeType: 'audio/wav', turnId: failedTurn });
await Promise.resolve();
});
expect(mockSocket.emit).toHaveBeenCalledWith('hosted:speech:done', { turnId: failedTurn, status: 'failed' });
const droppedTurn = '55555555-5555-4555-8555-555555555555';
play.mockResolvedValue(undefined);
const pause = vi.spyOn(HTMLMediaElement.prototype, 'pause').mockImplementation(() => {});
await act(async () => {
handler('hosted:turn:tts')({ target: 'audience', audio: 'QQ==', mimeType: 'audio/wav', turnId: droppedTurn });
});
await act(async () => {
handler('hosted:turn:phase')({ phase: 'idle', turnId: audienceTurn, reason: 'speech_timeout' });
});
expect(mockSocket.emit).not.toHaveBeenCalledWith('hosted:speech:done', { turnId: droppedTurn, status: 'aborted' });
await act(async () => {
handler('hosted:turn:phase')({ phase: 'listening', turnId: droppedTurn });
});
expect(mockSocket.emit).not.toHaveBeenCalledWith('hosted:speech:done', { turnId: droppedTurn, status: 'aborted' });
await act(async () => {
handler('hosted:turn:phase')({ phase: 'idle', turnId: droppedTurn, reason: 'speech_timeout' });
});
expect(pause).toHaveBeenCalled();
expect(mockSocket.emit).toHaveBeenCalledWith('hosted:speech:done', { turnId: droppedTurn, status: 'aborted' });
pause.mockRestore();
const cancelledTurn = '44444444-4444-4444-8444-444444444444';
await act(async () => {
handler('hosted:turn:tts')({ target: 'audience', audio: 'QQ==', mimeType: 'audio/wav', turnId: cancelledTurn });
});
await act(async () => { handler('hosted:session:ended')({ reason: 'host_ended' }); });
expect(mockSocket.emit).toHaveBeenCalledWith('hosted:speech:done', { turnId: cancelledTurn, status: 'aborted' });
play.mockRestore();
});
});