Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
import { describe, expect, it } from 'vitest';
import {
buildDeviceListPresentation,
deviceAccessState,
deviceDisplayName,
isControllableDevice,
platformLabel,
toDeviceListItem,
toDeviceListItems,
type DeviceListDeviceLike,
visibleDeviceListItems,
} from '../deviceList.js';
function device(patch: Partial<DeviceListDeviceLike> = {}): DeviceListDeviceLike {
return {
deviceId: 'dev-1',
name: 'Mac',
platform: 'darwin',
lastSeenAt: '2026-01-01T00:00:00.000Z',
online: true,
busy: false,
remoteControlEnabled: true,
isSelf: false,
...patch,
};
}
describe('shared device list presentation model', () => {
it('requires online, remoteControlEnabled and not self', () => {
expect(isControllableDevice(device())).toBe(true);
expect(isControllableDevice(device({ busy: true }))).toBe(true);
expect(isControllableDevice(device({ online: false }))).toBe(false);
expect(isControllableDevice(device({ remoteControlEnabled: false }))).toBe(false);
expect(isControllableDevice(device({ isSelf: true }))).toBe(false);
expect(isControllableDevice(device({ platform: 'ios' }))).toBe(false);
expect(isControllableDevice(device({ platform: 'android' }))).toBe(false);
});
it('uses user-facing platform labels', () => {
expect(platformLabel('darwin')).toBe('macOS');
expect(platformLabel('win32')).toBe('Windows');
expect(platformLabel('linux')).toBe('Linux');
expect(platformLabel('ios')).toBe('iOS');
expect(platformLabel('android')).toBe('Android');
expect(platformLabel(null)).toBe('Unknown');
});
it('maps device access states without treating busy as unavailable', () => {
expect(deviceAccessState(device())).toBe('ready');
expect(deviceAccessState(device({ busy: true }))).toBe('busy');
expect(deviceAccessState(device({ deviceId: 'revoked' }), new Set(['revoked']))).toBe('access_revoked');
expect(deviceAccessState(device({ online: false }))).toBe('offline');
expect(deviceAccessState(device({ online: false, remoteControlEnabled: false }))).toBe('offline');
expect(deviceAccessState(device({ remoteControlEnabled: false }))).toBe('remote_disabled');
expect(deviceAccessState(device({ isSelf: true }))).toBe('self');
});
// Regression: the singular projection must reuse controllability so ready mobile clients cannot be opened.
// Minimal unit inputs: online, remote-enabled iOS/Android; desktop ready/busy retain their existing projection.
it('keeps ready mobile clients closed while preserving desktop ready and busy projections', () => {
expect(toDeviceListItem(device({ platform: 'ios' }))).toMatchObject({ state: 'ready', canOpen: false });
expect(toDeviceListItem(device({ platform: 'android' }))).toMatchObject({ state: 'ready', canOpen: false });
expect(toDeviceListItem(device())).toMatchObject({ state: 'ready', canOpen: true });
expect(toDeviceListItem(device({ busy: true }))).toMatchObject({ state: 'busy', canOpen: true });
});
it('omits the current mobile device and other mobile clients while keeping unavailable peers with actionable details', () => {
const now = new Date('2026-01-01T00:10:00.000Z').getTime();
const items = toDeviceListItems([
device({ deviceId: 'self', isSelf: true }),
device({ deviceId: 'phone', platform: 'ios' }),
device({ deviceId: 'tablet', platform: 'android' }),
device({ deviceId: 'disabled', name: 'Charlie', remoteControlEnabled: false }),
device({ deviceId: 'busy', name: 'Alpha', busy: true }),
device({ deviceId: 'revoked', name: 'Delta' }),
device({ deviceId: 'offline', name: 'Echo', online: false, lastSeenAt: '2026-01-01T00:00:00.000Z' }),
device({ deviceId: 'ready', name: 'Beta' }),
], now, new Set(['revoked']));
expect(items.map((item) => [item.device.deviceId, item.state, item.canOpen])).toEqual([
['busy', 'busy', true],
['ready', 'ready', true],
['disabled', 'remote_disabled', false],
['revoked', 'access_revoked', false],
['offline', 'offline', false],
]);
expect(items.find((item) => item.device.deviceId === 'ready')?.statusDetail).toBe('已允许远程控制');
expect(items.find((item) => item.device.deviceId === 'busy')?.statusDetail).toBe('电脑端正在处理任务');
expect(items.find((item) => item.device.deviceId === 'revoked')?.statusDetail).toContain('恢复');
expect(items.find((item) => item.device.deviceId === 'disabled')?.statusDetail).toContain('打开允许远程控制');
expect(items.find((item) => item.device.deviceId === 'offline')?.statusDetail).toContain('10 分钟前在线');
});
it('defaults the visible list to controllable devices while keeping unavailable diagnostics behind a toggle', () => {
const items = toDeviceListItems([
device({ deviceId: 'disabled', name: 'A disabled', remoteControlEnabled: false }),
device({ deviceId: 'busy', name: 'B busy', busy: true }),
device({ deviceId: 'offline', name: 'C offline', online: false }),
device({ deviceId: 'ready', name: 'D ready' }),
]);
expect(visibleDeviceListItems(items, false)).toMatchObject({
availableCount: 2,
hiddenUnavailableCount: 2,
unavailableCount: 2,
});
expect(visibleDeviceListItems(items, false).visibleItems.map((item) => item.device.deviceId)).toEqual([
'busy',
'ready',
]);
expect(visibleDeviceListItems(items, true).visibleItems.map((item) => item.device.deviceId)).toEqual([
'busy',
'ready',
'disabled',
'offline',
]);
});
it('shows unavailable devices by default when there is no controllable peer', () => {
const items = toDeviceListItems([
device({ deviceId: 'disabled', remoteControlEnabled: false }),
device({ deviceId: 'offline', online: false }),
]);
const visibility = visibleDeviceListItems(items, false);
expect(visibility.availableCount).toBe(0);
expect(visibility.hiddenUnavailableCount).toBe(0);
expect(visibility.visibleItems.map((item) => item.device.deviceId)).toEqual(['disabled', 'offline']);
});
it('sorts same-bucket devices by stable identity instead of lastSeenAt or caller order', () => {
const items = toDeviceListItems([
device({ deviceId: 'second', name: 'Beta', lastSeenAt: '2026-01-01T00:00:00.000Z' }),
device({ deviceId: 'first', name: 'Alpha', lastSeenAt: '2026-01-01T00:10:00.000Z' }),
]);
expect(items.map((item) => item.device.deviceId)).toEqual(['first', 'second']);
});
it('keeps bucket order stable when ready and busy states change', () => {
const readyBusy = toDeviceListItems([
device({ deviceId: 'beta', name: 'Beta', busy: false }),
device({ deviceId: 'alpha', name: 'Alpha', busy: true }),
]);
const busyReady = toDeviceListItems([
device({ deviceId: 'beta', name: 'Beta', busy: true }),
device({ deviceId: 'alpha', name: 'Alpha', busy: false }),
]);
expect(readyBusy.map((item) => [item.device.deviceId, item.state])).toEqual([
['alpha', 'busy'],
['beta', 'ready'],
]);
expect(busyReady.map((item) => [item.device.deviceId, item.state])).toEqual([
['alpha', 'ready'],
['beta', 'busy'],
]);
});
it('keeps available devices before unavailable devices while sorting within each bucket by stable identity', () => {
const items = toDeviceListItems([
device({ deviceId: 'unavailable-a', name: 'A unavailable', online: false }),
device({ deviceId: 'available-b', name: 'B available' }),
device({ deviceId: 'unavailable-c', name: 'C unavailable', remoteControlEnabled: false }),
device({ deviceId: 'available-d', name: 'D available', busy: true }),
]);
expect(items.map((item) => [item.device.deviceId, item.canOpen])).toEqual([
['available-b', true],
['available-d', true],
['unavailable-a', false],
['unavailable-c', false],
]);
});
it('builds header, filter, toggle, and empty-state copy from the same visibility model', () => {
const hiddenUnavailable = buildDeviceListPresentation({
availableCount: 2,
hiddenUnavailableCount: 3,
unavailableCount: 3,
}, false);
expect(hiddenUnavailable).toMatchObject({
headerSubtitle: '2 台电脑可控制',
filterTitle: '可控制设备',
filterMeta: '2 台可进入 · 3 台需处理',
toggleAccessibilityLabel: '显示不可用电脑',
toggleLabel: '不可用 3',
});
const shownUnavailable = buildDeviceListPresentation({
availableCount: 2,
hiddenUnavailableCount: 0,
unavailableCount: 3,
}, true);
expect(shownUnavailable).toMatchObject({
toggleAccessibilityLabel: '隐藏不可用电脑',
toggleLabel: '只看可用',
});
const empty = buildDeviceListPresentation({
availableCount: 0,
hiddenUnavailableCount: 0,
unavailableCount: 0,
}, false);
expect(empty.headerSubtitle).toBe('等待电脑端上线');
expect(empty.filterMeta).toBe('等待电脑端上线');
expect(empty.toggleLabel).toBeNull();
expect(empty.emptyTitle).toBe('还没有可显示的电脑');
});
});
// Regression: full device fingerprints crowded teammate/project labels, including cached ID-as-name values.
describe('device display names', () => {
it('recovers missing or cached ID names from the roster, otherwise uses localized copy', () => {
const id = 'eb2ad08b24c63a9e818609e29057ca8d1a4';
expect(deviceDisplayName(id, id, '未命名设备', [{ deviceId: id, name: ' Mac Studio ' }])).toBe('Mac Studio');
expect(deviceDisplayName(id, ' ', '未命名设备')).toBe('未命名设备');
expect(deviceDisplayName(id, id, '未命名设备')).toBe('未命名设备');
});
it('uses deterministic ordinals for distinct duplicate hosts without changing routing identities', () => {
const devices = [{ deviceId: 'b', name: 'Studio' }, { deviceId: 'a', name: ' studio ' }];
expect(deviceDisplayName('b', 'Studio', 'Computer', devices)).toBe('Studio (2)');
expect(deviceDisplayName('b', 'Studio', 'Computer', [...devices].reverse())).toBe('Studio (2)');
expect(deviceDisplayName('b', 'Studio', 'Computer', [devices[0], devices[0]])).toBe('Studio');
expect(devices.map((device) => device.deviceId)).toEqual(['b', 'a']);
});
});