Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
// @vitest-environment jsdom
import { act, cleanup, renderHook } from '@testing-library/react';
import { afterEach, expect, it, vi } from 'vitest';
import { useRemoteSessionSync } from '../features/cc-agent/hooks/useRemoteSessionSync';
const mocks = vi.hoisted(() => ({ reconcile: vi.fn(async () => true), running: false }));
vi.mock('@/lib/makerChatStore', () => ({
makerChatStore: {
reconcileRemoteMessages: mocks.reconcile,
getSnapshot: () => ({ agentStatus: { isRunning: mocks.running } }),
subscribe: () => () => {},
getLastInboundEventAt: () => Date.now(),
},
}));
vi.mock('@/lib/logger', () => ({
createLogger: () => ({ info: vi.fn(), debug: vi.fn(), warn: vi.fn() }),
}));
vi.mock('@/lib/makerTransport', () => ({ isSessionTurnRunningFor: async () => true }));
vi.mock('@/features/device-link/remoteProjectsStore', () => ({
remoteProjectsStore: { getDeviceIds: () => ['host', 'neighbor'], getDeviceName: () => 'host', subscribe: () => () => {} },
}));
vi.mock('@/features/device-link/refreshRemoteSessions', () => ({
refreshRemoteDeviceSessions: vi.fn(),
}));
afterEach(() => {
cleanup();
vi.useRealTimers();
vi.unstubAllGlobals();
});
function recoveryEvents() {
function event<T>() {
const listeners = new Set<(payload: T) => void>();
return {
on: (cb: (payload: T) => void) => { listeners.add(cb); return () => { listeners.delete(cb); }; },
emit: (payload: T) => listeners.forEach((cb) => cb(payload)),
};
}
const status = event<{ status: string }>();
const presence = event<{ deviceId: string; online: boolean; remoteControlEnabled: boolean }>();
const responsiveness = event<{ deviceId: string; unresponsive: boolean; recovered: boolean }>();
const subscribe = vi.fn(async () => {});
vi.stubGlobal('electronAPI', { deviceLink: {
subscribe, unsubscribe: async () => {},
onStatusChanged: status.on,
onPresenceChanged: presence.on,
onResponsivenessChanged: responsiveness.on,
} });
mocks.running = false;
mocks.reconcile.mockResolvedValue(true);
return { status, presence, responsiveness, subscribe };
}
it.each(['focus', 'manual', 'presence', 'relay', 'response'])('allows %s recovery after a terminal reply clears the breaker', async (trigger) => {
vi.useFakeTimers();
const events = recoveryEvents();
const hook = renderHook(() => useRemoteSessionSync('session', 'host'));
const neighbor = renderHook(() => useRemoteSessionSync('neighbor-session', 'neighbor'));
await act(async () => {
events.status.emit({ status: 'online' });
await vi.advanceTimersByTimeAsync(250);
});
expect(hook.result.current.contentState).toBe('ready');
const callsBeforeClear = events.subscribe.mock.calls.length;
await act(async () => {
events.responsiveness.emit({ deviceId: 'host', unresponsive: true, recovered: false });
events.responsiveness.emit({ deviceId: 'host', unresponsive: false, recovered: false });
await vi.advanceTimersByTimeAsync(60_000);
});
expect(hook.result.current.contentState).toBe('syncing');
expect(neighbor.result.current.contentState).toBe('ready');
expect(events.subscribe).toHaveBeenCalledTimes(callsBeforeClear);
await act(async () => {
if (trigger === 'focus') window.dispatchEvent(new Event('focus'));
else if (trigger === 'manual') hook.result.current.resync();
else if (trigger === 'presence') events.presence.emit({ deviceId: 'host', online: true, remoteControlEnabled: true });
else if (trigger === 'relay') events.status.emit({ status: 'online' });
else events.responsiveness.emit({ deviceId: 'host', unresponsive: false, recovered: true });
await vi.advanceTimersByTimeAsync(250);
});
expect(hook.result.current.contentState).toBe('ready');
expect(neighbor.result.current.contentState).toBe('ready');
hook.unmount();
neighbor.unmount();
});
it.each(['relay', 'peer', 'disabled', 'unresponsive'])('does not resume cleared history while %s is unavailable', async (reason) => {
vi.useFakeTimers();
const events = recoveryEvents();
const hook = renderHook(() => useRemoteSessionSync('session', 'host'));
await act(async () => { await vi.advanceTimersByTimeAsync(250); });
const callsBeforeClear = events.subscribe.mock.calls.length;
await act(async () => {
events.responsiveness.emit({ deviceId: 'host', unresponsive: true, recovered: false });
events.responsiveness.emit({ deviceId: 'host', unresponsive: false, recovered: false });
if (reason === 'relay') events.status.emit({ status: 'offline' });
else if (reason === 'unresponsive') events.responsiveness.emit({ deviceId: 'host', unresponsive: true, recovered: false });
else events.presence.emit({ deviceId: 'host', online: reason !== 'peer', remoteControlEnabled: reason !== 'disabled' });
hook.result.current.resync();
window.dispatchEvent(new Event('focus'));
await vi.advanceTimersByTimeAsync(60_000);
});
expect(events.subscribe).toHaveBeenCalledTimes(callsBeforeClear);
expect(hook.result.current.contentState).toBe('syncing');
await act(async () => {
if (reason === 'relay') events.status.emit({ status: 'online' });
else if (reason === 'unresponsive') events.responsiveness.emit({ deviceId: 'host', unresponsive: false, recovered: true });
else events.presence.emit({ deviceId: 'host', online: true, remoteControlEnabled: true });
await vi.advanceTimersByTimeAsync(250);
});
expect(hook.result.current.contentState).toBe('ready');
hook.unmount();
});
it('requires a fresh ACK and snapshot after peer-only resets without invalidating neighbors', async () => {
vi.useFakeTimers();
const resets = new Set<(payload: { deviceId: string }) => void>();
const subscribe = vi.fn(async () => {});
vi.stubGlobal('electronAPI', {
deviceLink: {
subscribe,
unsubscribe: async () => {},
onStatusChanged: () => () => {},
onPresenceChanged: () => () => {},
onResponsivenessChanged: () => () => {},
onPeerLinkReset: (cb: (payload: { deviceId: string }) => void) => {
resets.add(cb);
return () => resets.delete(cb);
},
},
});
mocks.running = false;
mocks.reconcile.mockResolvedValue(true);
const affected = renderHook(() => useRemoteSessionSync('session', 'host'));
const neighbor = renderHook(() => useRemoteSessionSync('neighbor-session', 'neighbor'));
await act(async () => {
await vi.advanceTimersByTimeAsync(0);
});
expect(affected.result.current.contentState).toBe('ready');
expect(mocks.reconcile).toHaveBeenCalledWith('session', { freshHistory: true });
expect(neighbor.result.current.contentState).toBe('ready');
let ack!: () => void;
let oldSnapshot!: (value: boolean) => void;
let newSnapshot!: (value: boolean) => void;
subscribe.mockImplementationOnce(
() =>
new Promise<void>((resolve) => {
ack = resolve;
}),
);
mocks.reconcile
.mockImplementationOnce(
() =>
new Promise<boolean>((resolve) => {
oldSnapshot = resolve;
}),
)
.mockImplementationOnce(
() =>
new Promise<boolean>((resolve) => {
newSnapshot = resolve;
}),
);
const callsBeforeReset = mocks.reconcile.mock.calls.length;
await act(async () => {
resets.forEach((cb) => cb({ deviceId: 'host' }));
await vi.advanceTimersByTimeAsync(0);
});
expect(affected.result.current.contentState).toBe('syncing');
expect(neighbor.result.current.contentState).toBe('ready');
expect(mocks.reconcile).toHaveBeenCalledTimes(callsBeforeReset);
await act(async () => {
ack();
await vi.advanceTimersByTimeAsync(0);
});
expect(affected.result.current.contentState).toBe('syncing');
await act(async () => {
resets.forEach((cb) => cb({ deviceId: 'host' }));
await vi.advanceTimersByTimeAsync(0);
});
await act(async () => {
oldSnapshot(true);
await vi.advanceTimersByTimeAsync(0);
});
expect(affected.result.current.contentState).toBe('syncing');
expect(neighbor.result.current.contentState).toBe('ready');
await act(async () => {
newSnapshot(true);
await vi.advanceTimersByTimeAsync(0);
});
expect(affected.result.current.contentState).toBe('ready');
affected.unmount();
neighbor.unmount();
expect(resets.size).toBe(0);
});
it('does not reset a recovered mounted task on its first busy presence update', async () => {
vi.useFakeTimers();
let presence!: (snapshot: {
deviceId: string;
online: boolean;
remoteControlEnabled: boolean;
busy: boolean;
}) => void;
vi.stubGlobal('electronAPI', undefined);
Object.defineProperty(window, 'electronAPI', {
configurable: true,
value: {
deviceLink: {
subscribe: async () => {},
unsubscribe: async () => {},
onStatusChanged: () => () => {},
onPresenceChanged: (cb: typeof presence) => {
presence = cb;
return () => {};
},
onResponsivenessChanged: () => () => {},
},
},
});
mocks.running = false;
mocks.reconcile.mockResolvedValue(true);
const hook = renderHook(() => useRemoteSessionSync('session', 'host'));
await act(async () => {
await vi.advanceTimersByTimeAsync(0);
});
expect(hook.result.current.contentState).toBe('ready');
mocks.running = true;
mocks.reconcile.mockResolvedValue(false);
act(() => presence({ deviceId: 'host', online: true, remoteControlEnabled: true, busy: true }));
await act(async () => {
await vi.advanceTimersByTimeAsync(250);
});
expect(hook.result.current.contentState).toBe('ready');
act(() => presence({ deviceId: 'host', online: false, remoteControlEnabled: true, busy: true }));
expect(hook.result.current.contentState).toBe('syncing');
act(() => presence({ deviceId: 'host', online: true, remoteControlEnabled: true, busy: true }));
await act(async () => {
await vi.advanceTimersByTimeAsync(250);
});
expect(hook.result.current.contentState).toBe('syncing');
hook.unmount();
});
it.each(['relay', 'peer', 'disabled', 'unresponsive'])('releases the local topic on offline unmount (%s)', async (reason) => {
vi.useFakeTimers();
const unsubscribe = vi.fn(async () => {});
let status!: (value: { status: string }) => void;
let presence!: (value: { deviceId: string; online: boolean; remoteControlEnabled: boolean }) => void;
let responsiveness!: (value: { deviceId: string; unresponsive: boolean }) => void;
vi.stubGlobal('electronAPI', {
deviceLink: {
subscribe: vi.fn(async () => {}), unsubscribe,
onStatusChanged: (cb: typeof status) => { status = cb; return () => {}; },
onPresenceChanged: (cb: typeof presence) => { presence = cb; return () => {}; },
onResponsivenessChanged: (cb: typeof responsiveness) => { responsiveness = cb; return () => {}; },
},
});
mocks.running = false;
mocks.reconcile.mockResolvedValue(true);
const hook = renderHook(() => useRemoteSessionSync('session', 'host'));
await act(async () => { await vi.advanceTimersByTimeAsync(0); });
act(() => {
if (reason === 'relay') status({ status: 'offline' });
else if (reason === 'unresponsive') responsiveness({ deviceId: 'host', unresponsive: true });
else presence({ deviceId: 'host', online: reason !== 'peer', remoteControlEnabled: reason !== 'disabled' });
});
hook.unmount();
expect(unsubscribe).toHaveBeenCalledExactlyOnceWith('host', ['session:session']);
});