Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
/**
* Alias regression coverage uses the production grouping projection: the same remote directory
* must display its host alias, retain local overrides, and avoid leaking a name across identities.
* Existing grouping tests only supplied controller-local names. Minimal input: one remote session
* and its host snapshot (or two host identities sharing a legacy group). Pure unit tier.
*/
/**
* projectGrouping — vitest unit tests
*
* 覆盖:normalize、displayName 同名消歧、groupSessions 边界。
*/
import { describe, expect, it } from 'vitest';
import {
buildPersistentLocalProjects,
deviceLinkProjectKey,
extractDisplayName,
filterPersistentLocalProjectsByLastActivity,
groupSessions,
normalizeProjectKey,
normalizeWorkingDir,
projectIdentityKey,
pinnedSessionIdsInDisplayOrder,
persistentProjectMatchesVendor,
} from '@/features/cc-agent/lib/projectGrouping';
import {
gcProjectsAgainstActive,
normalizeManualPinnedOrder,
normalizeManualProjectOrder,
} from '@/features/cc-agent/hooks/helpers/sidebarFilterCore';
import {
pinnedProjectEntryId,
pinnedSidebarEntryComparisonKey,
} from '@/features/cc-agent/lib/pinnedSidebarOrder';
import type { Session } from '@/lib/ccAgent.types';
import { findProjectRepresentativeKey } from '@/features/cc-agent/lib/sidebarProjectVisibility';
/* ---------------- helpers ---------------- */
let id = 0;
function s(partial: Partial<Session>): Session {
id += 1;
// 默认把 userSendAt 与 updatedAt 对齐 —— 表示该 session 已开聊(非草稿),
// 应按 workingDir 归类。模拟"未发过任何消息的草稿"时显式传 userSendAt: null。
const updatedAt = partial.updatedAt ?? '2026-01-01T00:00:00.000Z';
const userSendAt = partial.userSendAt !== undefined ? partial.userSendAt : updatedAt;
return {
id: partial.id ?? `s${id}`,
userId: 'u',
title: partial.title ?? `t${id}`,
workingDir: partial.workingDir ?? null,
workspaceKind: partial.workspaceKind ?? 'project',
model: 'm',
effort: 'medium' as Session['effort'],
permissionMode: 'default' as Session['permissionMode'],
sdkSessionId: null,
totalTokenUsage: 0,
totalCostUsd: 0,
contextTokens: 0,
contextWindow: 0,
fastMode: false,
clearedAt: null,
pinnedAt: partial.pinnedAt ?? null,
userSendAt,
status: partial.status ?? 'active',
agentKind: partial.agentKind ?? 'cc',
source: partial.source,
remoteHostId: partial.remoteHostId ?? null,
deviceLinkDeviceId: partial.deviceLinkDeviceId,
deviceLinkDeviceName: partial.deviceLinkDeviceName,
deviceLinkConnectionStatus: partial.deviceLinkConnectionStatus,
extraDirs: partial.extraDirs ?? [],
createdAt: partial.createdAt ?? '2026-01-01T00:00:00.000Z',
updatedAt,
_count: partial._count,
};
}
/* ============================== normalizeWorkingDir ============================== */
describe('host project alias display', () => {
it('mirrors each host independently and keeps controller-local overrides first', () => {
const sessions = [
s({ workingDir: '/repo', deviceLinkDeviceId: 'a' }),
s({ workingDir: '/repo', deviceLinkDeviceId: 'b' }),
];
const remoteProjectAliases = new Map([
['a', { platform: 'darwin', aliases: [{ projectKey: 'local:/repo', alias: 'Host A' }] }],
['b', { platform: 'darwin', aliases: [{ projectKey: 'local:/repo', alias: 'Host B' }] }],
]);
const groups = groupSessions(sessions, {
remoteProjectAliases,
projectAliases: new Map([['device:a:/repo', 'My override']]),
});
expect(groups.projects.find((project) => project.deviceLinkDeviceId === 'a')?.displayName).toBe('My override');
expect(groups.projects.find((project) => project.deviceLinkDeviceId === 'b')?.displayName).toBe('Host B');
remoteProjectAliases.set('b', { platform: 'darwin', aliases: [] });
expect(groupSessions(sessions, { remoteProjectAliases }).projects.find((project) => project.deviceLinkDeviceId === 'b')?.displayName).not.toBe('Host B');
});
it('matches Windows host aliases without changing the controller project key spelling', () => {
const groups = groupSessions([s({ workingDir: 'C:/Repo/.worktrees/branch', deviceLinkDeviceId: 'a' })], {
remoteProjectAliases: new Map([['a', {
platform: 'win32', aliases: [{ projectKey: 'local:c:/repo', alias: 'Windows project' }],
}]]),
});
expect(groups.projects[0]).toMatchObject({ projectKey: 'device:a:C:/Repo', displayName: 'Windows project' });
});
// Regression: pinning or filtering must not change a mixed remote project's identity.
it.each(['local', 'ssh'])('keeps a mixed host directory name when %s is pinned', (kind) => {
const local = s({ workingDir: '/repo', deviceLinkDeviceId: 'a', pinnedAt: kind === 'local' ? '2026-10-01' : null });
const ssh = s({ workingDir: '/repo', deviceLinkDeviceId: 'a', remoteHostId: 'ssh-a', pinnedAt: kind === 'ssh' ? '2026-10-01' : null });
const remoteProjectAliases = new Map([['a', { platform: 'darwin', aliases: [
{ projectKey: 'local:/repo', alias: 'Local alias' },
{ projectKey: 'remote:ssh-a:/repo', alias: 'SSH alias' },
] }]]);
const result = groupSessions([local, ssh], { remoteProjectAliases });
expect(result.projects[0].displayName).toBe('repo');
expect(result.projects[0].sessions).toHaveLength(1);
expect(result.pinned).toHaveLength(1);
});
it.each(['local', 'ssh'])('uses full members when status/activity filters leave only %s', (kind) => {
const local = s({ workingDir: '/repo', deviceLinkDeviceId: 'a' });
const ssh = s({ workingDir: '/repo/.worktrees/branch', deviceLinkDeviceId: 'a', remoteHostId: 'ssh-a' });
const options = { projectAliasMembers: [local, ssh], remoteProjectAliases: new Map([['a', { platform: 'darwin', aliases: [
{ projectKey: 'local:/repo', alias: 'Local alias' },
{ projectKey: 'remote:ssh-a:/repo', alias: 'SSH alias' },
] }]]) };
const visible = [kind === 'local' ? local : ssh];
const result = groupSessions(visible, options);
expect(result.projects[0].displayName).toBe('repo');
expect(result.projects[0].sessions).toEqual(visible);
const deleted: Session = { ...ssh, status: 'deleted' };
expect(groupSessions([local], { ...options, projectAliasMembers: [local, deleted] }).projects[0].displayName).toBe('Local alias');
expect(groupSessions([local], { ...options, projectAliases: new Map([['device:a:/repo', 'Override']]) }).projects[0].displayName).toBe('Override');
});
it('resolves unique SSH identities and does not borrow a name for a mixed local/SSH group', () => {
const ssh = s({ workingDir: '/repo', deviceLinkDeviceId: 'a', remoteHostId: 'ssh-a' });
const local = s({ workingDir: '/repo', deviceLinkDeviceId: 'a' });
const remoteProjectAliases = new Map([['a', {
platform: 'darwin', aliases: [
{ projectKey: 'local:/repo', alias: 'Local host project' },
{ projectKey: 'remote:ssh-a:/repo', alias: 'SSH project' },
],
}]]);
expect(groupSessions([ssh], { remoteProjectAliases }).projects[0].displayName).toBe('SSH project');
expect(groupSessions([local, ssh], { remoteProjectAliases }).projects[0].displayName).toBe('repo');
});
});
describe('normalizeWorkingDir', () => {
it('returns null for nullish / empty / whitespace', () => {
expect(normalizeWorkingDir(null)).toBeNull();
expect(normalizeWorkingDir(undefined)).toBeNull();
expect(normalizeWorkingDir('')).toBeNull();
expect(normalizeWorkingDir(' ')).toBeNull();
});
it('converts Windows backslash to POSIX', () => {
expect(normalizeWorkingDir('D:\\AIWork\\xdt-maker')).toBe('D:/AIWork/xdt-maker');
expect(normalizeWorkingDir('C:\\foo\\bar\\')).toBe('C:/foo/bar');
});
it('strips trailing slash but keeps single root', () => {
expect(normalizeWorkingDir('/foo/bar/')).toBe('/foo/bar');
expect(normalizeWorkingDir('/foo/bar///')).toBe('/foo/bar');
expect(normalizeWorkingDir('/')).toBe('/');
expect(normalizeWorkingDir('D:/')).toBe('D:/');
expect(normalizeWorkingDir('D:\\')).toBe('D:/');
});
it('leaves already-clean POSIX path unchanged', () => {
expect(normalizeWorkingDir('/Users/sam/work/xdt-maker')).toBe('/Users/sam/work/xdt-maker');
});
it('normalizes project worktree paths to the base repo for sidebar grouping', () => {
expect(normalizeWorkingDir('D:\\AI\\tl_web_agent\\.worktrees\\cx-20260526-104440')).toBe(
'D:/AI/tl_web_agent',
);
expect(normalizeWorkingDir('\\\\?\\D:\\AI\\tl_web_agent\\.worktrees\\cx-20260526-104440')).toBe(
'D:/AI/tl_web_agent',
);
expect(normalizeWorkingDir('/repo/.cindy-worktrees/auto-kypf0e/server')).toBe('/repo');
expect(normalizeWorkingDir('/repo/.xdt-worktrees/auto-kypf0e/server')).toBe('/repo');
expect(normalizeWorkingDir('/repo/.claude/worktrees/agent-a123/server')).toBe('/repo');
});
});
/* ============================== normalizeProjectKey ============================== */
describe('normalizeProjectKey', () => {
it('maps legacy bare workingDir keys to local keys', () => {
expect(normalizeProjectKey('/Users/sam/xdt-maker')).toBe('local:/Users/sam/xdt-maker');
});
it('keeps local-prefixed keys canonical', () => {
expect(normalizeProjectKey('local:/Users/sam/xdt-maker/')).toBe('local:/Users/sam/xdt-maker');
});
it('keeps remote keys canonical', () => {
expect(normalizeProjectKey('remote:host-a:/repo/')).toBe('remote:host-a:/repo');
});
});
/* ============================== extractDisplayName ============================== */
describe('extractDisplayName', () => {
it('returns 1-segment basename when no collision', () => {
const r = extractDisplayName('/Users/sam/xdt-maker', ['/Users/sam/claude-mem']);
expect(r).toEqual({ name: 'xdt-maker', segments: 1 });
});
it('uses 2 segments to disambiguate same basename', () => {
const all = ['/Users/sam/xdt-maker', '/workspace/xdt-maker'];
expect(extractDisplayName('/Users/sam/xdt-maker', all)).toEqual({
name: 'sam/xdt-maker',
segments: 2,
});
expect(extractDisplayName('/workspace/xdt-maker', all)).toEqual({
name: 'workspace/xdt-maker',
segments: 2,
});
});
it('falls back to 3 segments when 2 still collide', () => {
const all = ['/a/b/foo', '/c/b/foo'];
const r = extractDisplayName('/a/b/foo', all);
expect(r.segments).toBe(3);
expect(r.name).toBe('a/b/foo');
});
it('accepts exact duplicate residual collision as basename', () => {
const all = ['/x/a/b/foo', '/x/a/b/foo'];
const r = extractDisplayName('/x/a/b/foo', all);
expect(r.segments).toBe(1);
expect(r.name).toBe('foo');
});
it('expands beyond 3 segments when deeper same-tail paths still collide', () => {
const all = [
'D:/tl_linhengze_main/frontend/trunk/Editor/UE_game/Script/Lua',
'D:/tl_linhengze_test/frontend/trunk/Editor/UE_game/Script/Lua',
];
const r = extractDisplayName(all[0], all);
expect(r.name).toBe('tl_linhengze_main/frontend/trunk/Editor/UE_game/Script/Lua');
expect(r.segments).toBe(7);
});
it('honors project aliases before automatic display-name disambiguation', () => {
const a = s({ workingDir: '/workspace/main/frontend/trunk/Editor/UE_game/Script/Lua' });
const b = s({ workingDir: '/workspace/test/frontend/trunk/Editor/UE_game/Script/Lua' });
const r = groupSessions([a, b], {
projectAliases: new Map([
['local:/workspace/main/frontend/trunk/Editor/UE_game/Script/Lua', '主线 Lua'],
]),
});
const aliased = r.projects.find(
(p) => p.workingDir === '/workspace/main/frontend/trunk/Editor/UE_game/Script/Lua',
);
const automatic = r.projects.find(
(p) => p.workingDir === '/workspace/test/frontend/trunk/Editor/UE_game/Script/Lua',
);
expect(aliased?.displayName).toBe('主线 Lua');
expect(aliased?.segments).toBe(0);
expect(automatic?.displayName).toBe('test/frontend/trunk/Editor/UE_game/Script/Lua');
});
it('handles single-segment workingDir', () => {
// 验证:own 只有 1 段 ['projects'] 时,basename 与 '/Users/me/projects' 冲突
// → segments=1 时两边 tailJoin(1) 都是 'projects',冲突;
// → 升到 segments=2:own.tailJoin(2) 仍是 'projects'(不足 2 段取全部),
// other.tailJoin(2)='me/projects',不再冲突 → 算法返回 segments=2。
// 注意 name 仍是 'projects'(own 段数不足),但 segments 字段记 2,反映
// "在 2 段消歧层级被接受"——这是算法对单段输入的合理结果。
const r = extractDisplayName('/projects', ['/Users/me/projects']);
expect(r.segments).toBe(2);
expect(r.name).toBe('projects');
});
it('honors minSegments=2 to skip 1-segment shortcut', () => {
// 即使无冲突,也强制至少 2 段——用于"先创建保留 basename,后创建必须加 parent"
const r = extractDisplayName('/Users/sam/xdt-maker', ['/workspace/xdt-maker'], 2);
expect(r).toEqual({ name: 'sam/xdt-maker', segments: 2 });
});
});
/* ============================== groupSessions ============================== */
describe('groupSessions', () => {
it('returns empty result for empty input', () => {
expect(groupSessions([])).toEqual({
pinned: [],
dialogues: [],
bots: [],
unclassified: [],
projects: [],
});
});
it('keeps a persistent local project after its last session disappears', () => {
const r = groupSessions([], {
persistentLocalProjects: [
{
workingDir: 'D:\\AIWork\\empty-project\\',
lastUsedAt: '2026-08-12T08:00:00.000Z',
knownAgentKinds: [],
},
],
});
expect(r.projects).toEqual([
expect.objectContaining({
projectKey: 'local:D:/AIWork/empty-project',
workingDir: 'D:/AIWork/empty-project',
displayName: 'empty-project',
sessions: [],
latestActivityAt: '2026-08-12T08:00:00.000Z',
isPersistentLocal: true,
}),
]);
});
it('merges a persistent local project with its sessions instead of duplicating it', () => {
const session = s({ workingDir: 'D:\\AIWork\\Project-A' });
const r = groupSessions([session], {
persistentLocalProjects: [
{
workingDir: 'd:/aiwork/project-a/',
lastUsedAt: '2026-08-12T08:00:00.000Z',
knownAgentKinds: ['cc'],
},
],
localPlatform: 'win32',
});
expect(r.projects).toHaveLength(1);
expect(r.projects[0]).toMatchObject({
projectKey: 'local:d:/aiwork/project-a',
workingDir: 'd:/aiwork/project-a',
sessions: [session],
isPersistentLocal: true,
});
});
it('keeps stored Windows project selectors when the retained representative uses different casing', () => {
const projectKey = 'local:D:/AIWork/Project-A';
const retainedProject = {
workingDir: 'd:/aiwork/project-a',
lastUsedAt: '2026-08-12T08:00:00.000Z',
knownAgentKinds: ['cc'],
};
const aliases = new Map([[projectKey, 'Stable project']]);
const withSession = groupSessions([s({ workingDir: 'D:\\AIWork\\Project-A' })], {
persistentLocalProjects: [retainedProject],
projectAliases: aliases,
localPlatform: 'win32',
}).projects[0]!;
const afterDelete = groupSessions([], {
persistentLocalProjects: [retainedProject],
projectAliases: aliases,
localPlatform: 'win32',
}).projects[0]!;
expect(afterDelete.projectKey).toBe(withSession.projectKey);
expect(withSession.workingDir).toBe('d:/aiwork/project-a');
expect(afterDelete.displayName).toBe('Stable project');
expect(gcProjectsAgainstActive([projectKey], [afterDelete.projectKey], 'win32')).toEqual([
projectKey,
]);
expect(normalizeManualProjectOrder([projectKey], [afterDelete.projectKey], 'win32')).toEqual([
projectKey,
]);
const pinEntry = pinnedProjectEntryId(projectKey);
expect(
normalizeManualPinnedOrder(
[pinEntry],
[pinnedProjectEntryId(afterDelete.projectKey)],
(entryId) => pinnedSidebarEntryComparisonKey(entryId, 'win32'),
),
).toEqual([pinEntry]);
});
it('uses the newest stored alias when legacy Windows casing variants coexist', () => {
const project = groupSessions([], {
persistentLocalProjects: [
{
workingDir: 'd:/école/project-a',
lastUsedAt: '2026-08-12T08:00:00.000Z',
knownAgentKinds: [],
},
],
projectAliases: new Map([
['local:D:/École/Project-A', 'Newest alias'],
['local:d:/école/project-a', 'Older alias'],
]),
localPlatform: 'win32',
}).projects[0]!;
expect(project.displayName).toBe('Newest alias');
});
it('does not use directory registration time as matching task activity', () => {
const projects = [
{
workingDir: '/workspace/old',
lastUsedAt: '2026-07-01T00:00:00.000Z',
knownAgentKinds: [] as string[],
},
{
workingDir: '/workspace/recent',
lastUsedAt: '2026-08-10T00:00:00.000Z',
knownAgentKinds: [] as string[],
},
];
expect(
filterPersistentLocalProjectsByLastActivity(
projects,
Date.parse('2026-08-01T00:00:00.000Z'),
).map((project) => project.workingDir),
).toEqual([]);
expect(filterPersistentLocalProjectsByLastActivity(projects, null)).toBe(projects);
});
it('distinguishes a truly empty project from a vendor-mismatched historical project', () => {
const deletedCcSession = s({
workingDir: '/workspace/cc-only',
agentKind: 'cc',
status: 'deleted',
});
const visibleSessionsAfterDeletion = [deletedCcSession].filter(
(session) => session.status !== 'deleted',
);
const persistent = buildPersistentLocalProjects(
[
{
path: '/workspace/cc-only',
lastUsedAt: '2026-08-12T08:00:00.000Z',
knownAgentKinds: ['cc'],
},
{ path: '/workspace/truly-empty', lastUsedAt: '2026-08-12T07:00:00.000Z' },
],
visibleSessionsAfterDeletion,
'linux',
);
const grouped = groupSessions([], { persistentLocalProjects: persistent });
const ccOnly = grouped.projects.find((project) => project.workingDir.endsWith('/cc-only'))!;
const trulyEmpty = grouped.projects.find((project) =>
project.workingDir.endsWith('/truly-empty'),
)!;
expect(ccOnly.persistentLocalKnownAgentKinds).toEqual(['cc']);
expect(persistentProjectMatchesVendor(ccOnly, 'codex')).toBe(false);
expect(persistentProjectMatchesVendor(ccOnly, 'cc')).toBe(true);
expect(trulyEmpty.persistentLocalKnownAgentKinds).toEqual([]);
expect(persistentProjectMatchesVendor(trulyEmpty, 'codex')).toBe(true);
});
it('combines last-activity and vendor filtering without inventing mismatched empty shells', () => {
const persistent = buildPersistentLocalProjects(
[
{ path: '/workspace/cc-recent', lastUsedAt: '2026-08-12T08:00:00.000Z' },
{ path: '/workspace/empty-recent', lastUsedAt: '2026-08-12T07:00:00.000Z' },
{ path: '/workspace/empty-old', lastUsedAt: '2026-07-01T00:00:00.000Z' },
],
[s({ workingDir: '/workspace/cc-recent', agentKind: 'cc' })],
'linux',
);
const activityFiltered = filterPersistentLocalProjectsByLastActivity(
persistent,
Date.parse('2026-08-01T00:00:00.000Z'),
);
const visibleForCodex = groupSessions([], {
persistentLocalProjects: activityFiltered,
}).projects.filter((project) => persistentProjectMatchesVendor(project, 'codex'));
expect(visibleForCodex).toEqual([]);
});
it('retains projects introduced by matching tasks even when directory activity is old', () => {
const persistent = [
{
workingDir: '/workspace/matching',
lastUsedAt: '2026-01-01T00:00:00.000Z',
knownAgentKinds: [],
},
{
workingDir: '/workspace/empty',
lastUsedAt: '2026-08-12T00:00:00.000Z',
knownAgentKinds: [],
},
];
const task = s({ workingDir: '/workspace/matching', updatedAt: '2026-08-12T00:00:00.000Z' });
const filtered = groupSessions([task], {
persistentLocalProjects: filterPersistentLocalProjectsByLastActivity(
persistent,
Date.parse('2026-08-05T00:00:00.000Z'),
),
});
expect(filtered.projects.map((project) => project.workingDir)).toEqual(['/workspace/matching']);
expect(filtered.projects[0]?.sessions).toEqual([task]);
expect(
groupSessions([], {
persistentLocalProjects: filterPersistentLocalProjectsByLastActivity(persistent, null),
}).projects,
).toHaveLength(2);
});
it.each([
['D:/Work/Repo', 'd:/work/repo'],
['//Server/Share/École', '//server/share/école'],
])('groups Windows case variants under an activity filter: %s', (first, second) => {
const tasks = [
s({ workingDir: first, updatedAt: '2026-08-12T00:00:00.000Z' }),
s({ workingDir: second, updatedAt: '2026-08-11T00:00:00.000Z' }),
];
const persistent = [
{ workingDir: first.toUpperCase(), lastUsedAt: tasks[0].updatedAt, knownAgentKinds: [] },
];
const result = groupSessions(tasks, {
localPlatform: 'win32',
persistentLocalProjects: filterPersistentLocalProjectsByLastActivity(
persistent,
Date.parse('2026-08-05T00:00:00.000Z'),
),
});
expect(result.projects).toHaveLength(1);
expect(result.projects[0].sessions).toEqual(tasks);
expect(result.projects[0].workingDir).toBe(first);
expect(
findProjectRepresentativeKey(result.projects, `local:${first.toUpperCase()}`, 'win32'),
).toBe(result.projects[0].projectKey);
});
it('keeps POSIX casing and remote identities distinct without persistent seeds', () => {
const result = groupSessions(
[
s({ workingDir: '/Work/Repo' }),
s({ workingDir: '/work/repo' }),
s({ workingDir: '/work/repo', remoteHostId: 'host-a' }),
s({ workingDir: '/work/repo', remoteHostId: 'host-b' }),
],
{ localPlatform: 'linux' },
);
expect(result.projects).toHaveLength(4);
});
it('does not let an older session regress retained project activity', () => {
const retainedLastUsedAt = '2026-08-12T08:00:00.000Z';
const grouped = groupSessions(
[
s({
workingDir: '/workspace/project-a',
userSendAt: '2026-08-01T08:00:00.000Z',
updatedAt: '2026-08-01T08:00:00.000Z',
}),
],
{
persistentLocalProjects: [
{
workingDir: '/workspace/project-a',
lastUsedAt: retainedLastUsedAt,
knownAgentKinds: ['cc'],
},
],
},
);
expect(grouped.projects[0]?.latestActivityAt).toBe(retainedLastUsedAt);
});
it('can keep an individually pinned conversation in the project catalogue', () => {
const pinned = s({
id: 'pinned-in-project',
workingDir: '/workspace/project-a',
pinnedAt: '2026-07-01T00:00:00.000Z',
});
expect(groupSessions([pinned]).projects).toEqual([]);
const catalogue = groupSessions([pinned], { includePinnedInProjects: true });
expect(catalogue.pinned.map((session) => session.id)).toEqual(['pinned-in-project']);
expect(catalogue.projects).toHaveLength(1);
expect(catalogue.projects[0]?.projectKey).toBe('local:/workspace/project-a');
expect(catalogue.projects[0]?.sessions.map((session) => session.id)).toEqual([
'pinned-in-project',
]);
});
it('groups 1000 same-basename projects with stable display names', () => {
const many = Array.from({ length: 1000 }, (_, i) =>
s({
id: `perf-${i}`,
workingDir: `/workspace/team-${String(i).padStart(4, '0')}/app`,
createdAt: `2026-01-01T00:${String(Math.floor(i / 60)).padStart(2, '0')}:${String(i % 60).padStart(2, '0')}.000Z`,
updatedAt: `2026-01-01T00:${String(Math.floor(i / 60)).padStart(2, '0')}:${String(i % 60).padStart(2, '0')}.000Z`,
_count: { messages: 1 },
}),
);
const r = groupSessions(many);
expect(r.projects).toHaveLength(1000);
expect(r.projects.find((p) => p.workingDir === '/workspace/team-0999/app')?.displayName).toBe(
'team-0999/app',
);
expect(r.projects.find((p) => p.workingDir === '/workspace/team-0000/app')?.displayName).toBe(
'app',
);
});
it('puts pinned sessions in `pinned`, sorted by pinnedAt desc', () => {
const a = s({ title: 'a', pinnedAt: '2026-04-19T00:00:00.000Z' });
const b = s({ title: 'b', pinnedAt: '2026-04-20T00:00:00.000Z' });
const r = groupSessions([a, b]);
expect(r.pinned.map((x) => x.title)).toEqual(['b', 'a']);
expect(r.dialogues).toEqual([]);
expect(r.unclassified).toEqual([]);
expect(r.projects).toEqual([]);
});
it('puts sessions without workingDir in `unclassified`, sorted by updatedAt desc', () => {
const a = s({ title: 'a', workingDir: null, updatedAt: '2026-04-19T00:00:00.000Z' });
const b = s({ title: 'b', workingDir: ' ', updatedAt: '2026-04-20T00:00:00.000Z' });
const r = groupSessions([a, b]);
expect(r.unclassified.map((x) => x.title)).toEqual(['b', 'a']);
});
it('groups Windows slash variants under the same project identity', () => {
const registrySession = s({
title: 'registry',
workingDir: 'D:\\Project-001',
updatedAt: '2026-04-19T00:00:00.000Z',
});
const newSession = s({
title: 'new',
workingDir: 'D:/Project-001',
updatedAt: '2026-04-20T00:00:00.000Z',
});
const r = groupSessions([registrySession, newSession]);
expect(r.projects).toHaveLength(1);
expect(r.projects[0].projectKey).toBe('local:D:/Project-001');
expect(r.projects[0].workingDir).toBe('D:/Project-001');
expect(r.projects[0].sessions.map((x) => x.title)).toEqual(['new', 'registry']);
});
it('groups by normalized workingDir', () => {
const a = s({
title: 'a',
workingDir: 'D:\\AIWork\\xdt-maker',
updatedAt: '2026-04-19T00:00:00.000Z',
});
const b = s({
title: 'b',
workingDir: 'D:/AIWork/xdt-maker/',
updatedAt: '2026-04-20T00:00:00.000Z',
});
const c = s({
title: 'c',
workingDir: '/Users/me/claude-mem',
updatedAt: '2026-04-18T00:00:00.000Z',
});
const r = groupSessions([a, b, c]);
expect(r.projects.length).toBe(2);
const xdt = r.projects.find((p) => p.displayName === 'xdt-maker');
const mem = r.projects.find((p) => p.displayName === 'claude-mem');
expect(xdt?.sessions.map((x) => x.title)).toEqual(['b', 'a']); // updatedAt desc
expect(mem?.sessions.map((x) => x.title)).toEqual(['c']);
});
it('keeps remote sessions from different hosts in separate projects', () => {
const a = s({
title: 'a',
workingDir: '/repo',
remoteHostId: 'host-a',
updatedAt: '2026-04-19T00:00:00.000Z',
});
const b = s({
title: 'b',
workingDir: '/repo',
remoteHostId: 'host-b',
updatedAt: '2026-04-20T00:00:00.000Z',
});
const r = groupSessions([a, b]);
expect(r.projects).toHaveLength(2);
expect(r.projects.map((p) => p.projectKey).sort()).toEqual([
'remote:host-a:/repo',
'remote:host-b:/repo',
]);
});
it('keeps legacy bare keys readable as local projects', () => {
const a = s({
title: 'a',
workingDir: '/repo',
updatedAt: '2026-04-19T00:00:00.000Z',
});
const r = groupSessions([a]);
expect(r.projects[0]?.projectKey).toBe('local:/repo');
expect(r.projects[0]?.scope).toBe('local');
});
it('orders projects by latestActivityAt desc', () => {
const a = s({ workingDir: '/p/alpha', updatedAt: '2026-04-19T00:00:00.000Z' });
const b = s({ workingDir: '/p/beta', updatedAt: '2026-04-20T00:00:00.000Z' });
const c = s({ workingDir: '/p/gamma', updatedAt: '2026-04-18T00:00:00.000Z' });
const r = groupSessions([a, b, c]);
expect(r.projects.map((p) => p.displayName)).toEqual(['beta', 'alpha', 'gamma']);
});
it('disambiguates same-basename projects: earliest createdAt keeps basename, others get parent', () => {
// A 先创建(createdAt 更早)→ 保留纯 basename;B 后创建 → 加 parent 段
const a = s({
workingDir: '/Users/sam/xdt-maker',
createdAt: '2026-04-01T00:00:00.000Z',
updatedAt: '2026-04-20T00:00:00.000Z',
});
const b = s({
workingDir: '/workspace/xdt-maker',
createdAt: '2026-04-10T00:00:00.000Z',
updatedAt: '2026-04-19T00:00:00.000Z',
});
const r = groupSessions([a, b]);
const aNode = r.projects.find((p) => p.workingDir === '/Users/sam/xdt-maker');
const bNode = r.projects.find((p) => p.workingDir === '/workspace/xdt-maker');
expect(aNode?.displayName).toBe('xdt-maker');
expect(aNode?.segments).toBe(1);
expect(bNode?.displayName).toBe('workspace/xdt-maker');
expect(bNode?.segments).toBe(2);
});
it('same-basename: keeps the project containing the earliest-created session as the basename winner', () => {
// dir-A 包含更早的 session(4/1)→ 即便 dir-A 有别的 session 比 dir-B 晚,
// dir-A 仍获胜
const a1 = s({
workingDir: '/foo/proj',
createdAt: '2026-04-01T00:00:00.000Z',
updatedAt: '2026-04-15T00:00:00.000Z',
});
const a2 = s({
workingDir: '/foo/proj',
createdAt: '2026-04-20T00:00:00.000Z',
updatedAt: '2026-04-20T00:00:00.000Z',
});
const b = s({
workingDir: '/bar/proj',
createdAt: '2026-04-05T00:00:00.000Z',
updatedAt: '2026-04-19T00:00:00.000Z',
});
const r = groupSessions([a1, a2, b]);
const fooNode = r.projects.find((p) => p.workingDir === '/foo/proj');
const barNode = r.projects.find((p) => p.workingDir === '/bar/proj');
expect(fooNode?.displayName).toBe('proj');
expect(barNode?.displayName).toBe('bar/proj');
});
it('same-basename: createdAt tie falls back to dir lexicographic order', () => {
// 两个 dir createdAt 完全相同 → 字典序 /a/proj < /z/proj,/a/proj 获胜
const a = s({
workingDir: '/z/proj',
createdAt: '2026-04-10T00:00:00.000Z',
updatedAt: '2026-04-10T00:00:00.000Z',
});
const b = s({
workingDir: '/a/proj',
createdAt: '2026-04-10T00:00:00.000Z',
updatedAt: '2026-04-09T00:00:00.000Z',
});
const r = groupSessions([a, b]);
const aNode = r.projects.find((p) => p.workingDir === '/a/proj');
const zNode = r.projects.find((p) => p.workingDir === '/z/proj');
expect(aNode?.displayName).toBe('proj'); // 字典序更小 → 获胜
expect(zNode?.displayName).toBe('z/proj');
});
it('keeps pinned out of project groups even if workingDir present', () => {
const a = s({ workingDir: '/p/foo', pinnedAt: '2026-04-20T00:00:00.000Z' });
const b = s({ workingDir: '/p/foo', updatedAt: '2026-04-19T00:00:00.000Z' });
const r = groupSessions([a, b]);
expect(r.pinned).toHaveLength(1);
expect(r.projects).toHaveLength(1);
expect(r.projects[0].sessions).toHaveLength(1);
expect(r.projects[0].sessions[0]).toBe(b);
});
it('handles all-pinned input', () => {
const a = s({ pinnedAt: '2026-04-20T00:00:00.000Z' });
const b = s({ pinnedAt: '2026-04-19T00:00:00.000Z' });
const r = groupSessions([a, b]);
expect(r.pinned).toHaveLength(2);
expect(r.dialogues).toEqual([]);
expect(r.unclassified).toEqual([]);
expect(r.projects).toEqual([]);
});
it('keeps dialogue sessions out of project groups even when workingDir is set', () => {
const dialogue = s({
title: 'imported dialogue',
workingDir: '/Users/me/Documents/Codex/2026-05-12/new-chat',
workspaceKind: 'dialogue',
_count: { messages: 3 },
});
const project = s({
title: 'real project',
workingDir: '/Users/me/work/app',
_count: { messages: 2 },
});
const r = groupSessions([dialogue, project]);
expect(r.dialogues).toEqual([dialogue]);
expect(r.projects).toHaveLength(1);
expect(r.projects[0].sessions).toEqual([project]);
});
it('treats a project session moved to dialogue as dialogue while preserving workingDir', () => {
const moved = s({
title: 'moved session',
workingDir: '/Users/me/work/app',
workspaceKind: 'dialogue',
_count: { messages: 4 },
});
const r = groupSessions([moved]);
expect(r.dialogues).toEqual([moved]);
expect(r.dialogues[0].workingDir).toBe('/Users/me/work/app');
expect(r.unclassified).toEqual([]);
expect(r.projects).toEqual([]);
});
it('puts local no-folder dialogue sessions into the dialogue section', () => {
const dialogue = s({
title: 'local dialogue',
workingDir: null,
workspaceKind: 'dialogue',
userSendAt: '2026-04-20T00:00:00.000Z',
_count: { messages: 1 },
});
const r = groupSessions([dialogue]);
expect(r.dialogues).toEqual([dialogue]);
expect(r.unclassified).toEqual([]);
expect(r.projects).toEqual([]);
});
// 草稿判定:userSendAt == null(未真正发过消息)即便选了 folder 也留在未分类
it('keeps null-userSendAt draft in unclassified even when workingDir is set', () => {
const draft = s({ workingDir: '/p/foo', userSendAt: null });
const real = s({ workingDir: '/p/foo' }); // 默认 userSendAt = updatedAt
const r = groupSessions([draft, real]);
expect(r.unclassified).toHaveLength(1);
expect(r.unclassified[0]).toBe(draft);
expect(r.projects).toHaveLength(1);
expect(r.projects[0].sessions).toHaveLength(1);
expect(r.projects[0].sessions[0]).toBe(real);
});
// 新建页里正在输入的未发送任务:已选好项目就放在项目下,不进未分类。
it('places the new-task page\'s unsent task under its chosen project', () => {
const unsent = s({ workingDir: '/p/foo', userSendAt: null });
const otherDraft = s({ workingDir: '/p/foo', userSendAt: null });
const r = groupSessions([unsent, otherDraft], { provisionalDraftTaskId: unsent.id });
expect(r.unclassified).toEqual([otherDraft]);
expect(r.projects).toHaveLength(1);
expect(r.projects[0].sessions).toEqual([unsent]);
});
// SDK echo 失败 / 老数据 backfill 漏掉的孤儿:userSendAt 没写上但 messages
// 表里有 row 的 session 不是草稿,应入 Project,避免堆到未分类。
it('treats null-userSendAt with messages>0 as non-draft (SDK echo failure fallback)', () => {
const orphan = s({
workingDir: '/p/foo',
userSendAt: null,
_count: { messages: 3 },
});
const r = groupSessions([orphan]);
expect(r.unclassified).toHaveLength(0);
expect(r.projects).toHaveLength(1);
expect(r.projects[0].sessions[0]).toBe(orphan);
});
// scheduler / plugin 来源豁免草稿判定:零消息也落项目分组。scheduler 由
// 自动化任务显式绑定目录;plugin 是 workspace 槽建的空会话入口——零消息
// 落在项目分组正是功能本身,掉未分类则功能不成立。
it('keeps zero-message scheduler/plugin sessions in their project group (draft exemption)', () => {
const scheduler = s({ workingDir: '/p/auto', userSendAt: null, source: 'scheduler' });
const plugin = s({ workingDir: '/p/auto', userSendAt: null, source: 'plugin' });
const r = groupSessions([scheduler, plugin]);
expect(r.unclassified).toHaveLength(0);
expect(r.projects).toHaveLength(1);
expect(r.projects[0].sessions).toHaveLength(2);
});
it('allows manually imported external sessions to create standalone projects', () => {
const importedCodex = s({
id: 'codex-019dcd5a-6e54-7960-95e0-aa68117a28d1',
agentKind: 'codex',
workingDir: '/p/external-only',
_count: { messages: 3 },
});
const importedClaude = s({
id: 'claude-15356275-b340-401f-abd1-3bc2bd4824c5',
agentKind: 'cc',
workingDir: '/p/claude-only',
_count: { messages: 2 },
});
const r = groupSessions([importedCodex, importedClaude]);
expect(r.unclassified).toEqual([]);
expect(r.projects.map((p) => p.workingDir).sort()).toEqual([
'/p/claude-only',
'/p/external-only',
]);
});
it('attaches imported external sessions to an existing native project dir', () => {
const native = s({
id: 'native-session',
workingDir: '/p/xdt-maker',
updatedAt: '2026-04-20T00:00:00.000Z',
});
const imported = s({
id: 'codex-019dcd5a-6e54-7960-95e0-aa68117a28d1',
agentKind: 'codex',
workingDir: '/p/xdt-maker',
updatedAt: '2026-04-19T00:00:00.000Z',
_count: { messages: 5 },
});
const r = groupSessions([native, imported]);
expect(r.unclassified).toEqual([]);
expect(r.projects).toHaveLength(1);
expect(r.projects[0].sessions).toEqual([native, imported]);
});
it('groups imported Codex worktree sessions under the base project without changing the session cwd', () => {
const native = s({
id: 'native-session',
workingDir: 'D:\\AI\\tl_web_agent',
updatedAt: '2026-05-26T02:00:00.000Z',
});
const imported = s({
id: 'codex-019e622b-a420-78e3-8e43-a9fcf9bf2ca8',
agentKind: 'codex',
workingDir: '\\\\?\\D:\\AI\\tl_web_agent\\.worktrees\\cx-20260526-104440',
updatedAt: '2026-05-26T03:00:00.000Z',
_count: { messages: 5 },
});
const r = groupSessions([native, imported]);
expect(r.projects).toHaveLength(1);
expect(r.projects[0].workingDir).toBe('D:/AI/tl_web_agent');
expect(r.projects[0].displayName).toBe('tl_web_agent');
expect(r.projects[0].sessions).toEqual([imported, native]);
expect(r.projects[0].sessions[0].workingDir).toBe(
'\\\\?\\D:\\AI\\tl_web_agent\\.worktrees\\cx-20260526-104440',
);
});
// 兜底回落:userSendAt 缺失(老数据)时回落到 updatedAt
it('falls back to updatedAt when userSendAt is null but workingDir present', () => {
// 老数据场景:workingDir 有,userSendAt 没有,但实际有消息历史 —— 通过
// _count 表达"非草稿"在新模型里没用了,改成显式 userSendAt: null 等价于草稿。
// 这里测的是排序回落:两个 session 都有 userSendAt,但比较时混合 fallback。
const a = s({
workingDir: '/p/alpha',
userSendAt: null,
updatedAt: '2026-04-19T00:00:00.000Z',
});
// a 是 userSendAt == null → 进未分类
const b = s({
workingDir: '/p/beta',
userSendAt: '2026-04-18T00:00:00.000Z',
updatedAt: '2026-04-20T00:00:00.000Z',
});
// b 进 Project,sortTime = userSendAt = 4/18
const r = groupSessions([a, b]);
expect(r.unclassified).toHaveLength(1);
expect(r.unclassified[0]).toBe(a);
expect(r.projects).toHaveLength(1);
expect(r.projects[0].displayName).toBe('beta');
});
// 2026-04-21 Lizi: filter='all' 时 active 排在 archived 之上,同状态按时间 desc
describe('status-then-time ordering (filter=all)', () => {
it('within a project: active sessions sit above archived; each group time-sorted', () => {
// active 较旧 / 较新 + archived 较旧 / 较新 混在同一 project
const archivedNew = s({
title: 'arch-new',
workingDir: '/p/proj',
status: 'archived',
updatedAt: '2026-04-21T00:00:00.000Z',
});
const activeOld = s({
title: 'act-old',
workingDir: '/p/proj',
status: 'active',
updatedAt: '2026-04-15T00:00:00.000Z',
});
const archivedOld = s({
title: 'arch-old',
workingDir: '/p/proj',
status: 'archived',
updatedAt: '2026-04-10T00:00:00.000Z',
});
const activeNew = s({
title: 'act-new',
workingDir: '/p/proj',
status: 'active',
updatedAt: '2026-04-20T00:00:00.000Z',
});
const r = groupSessions([archivedNew, activeOld, archivedOld, activeNew]);
expect(r.projects).toHaveLength(1);
// 期望:先 active(按时间 desc),再 archived(按时间 desc)
expect(r.projects[0].sessions.map((x) => x.title)).toEqual([
'act-new',
'act-old',
'arch-new',
'arch-old',
]);
});
it('unclassified: active above archived', () => {
const a1 = s({
title: 'arch',
workingDir: null,
status: 'archived',
updatedAt: '2026-04-21T00:00:00.000Z',
});
const a2 = s({
title: 'active',
workingDir: null,
status: 'active',
updatedAt: '2026-04-15T00:00:00.000Z',
});
const r = groupSessions([a1, a2]);
expect(r.unclassified.map((x) => x.title)).toEqual(['active', 'arch']);
});
it('pinned: active above archived (same status keeps pinnedAt desc)', () => {
const a = s({
title: 'arch-pin',
status: 'archived',
pinnedAt: '2026-04-21T00:00:00.000Z',
});
const b = s({
title: 'act-pin-old',
status: 'active',
pinnedAt: '2026-04-10T00:00:00.000Z',
});
const c = s({
title: 'act-pin-new',
status: 'active',
pinnedAt: '2026-04-15T00:00:00.000Z',
});
const r = groupSessions([a, b, c]);
expect(r.pinned.map((x) => x.title)).toEqual(['act-pin-new', 'act-pin-old', 'arch-pin']);
});
it('Mac 路径与父级不同的 Windows 路径分别归为独立 project', () => {
// 模拟导入场景:同一 basename `proj` 在 Mac `/Users/foo/proj` 与 Windows
// `C:\Work\proj` 上分别有 session(不同机器的导入),分组时应该:
// 1. 反斜杠归一为正斜杠后,两条 workingDir 不相等 → 两个独立 project
// 2. 同名消歧:先创建的(Mac,createdAt=4/1)保留纯 basename `proj`,
// Windows 那条 2 段消歧得到 `Work/proj`。
const mac = s({
workingDir: '/Users/foo/proj',
createdAt: '2026-04-01T00:00:00.000Z',
updatedAt: '2026-04-19T00:00:00.000Z',
});
const win = s({
workingDir: 'C:\\Work\\proj',
createdAt: '2026-04-10T00:00:00.000Z',
updatedAt: '2026-04-20T00:00:00.000Z',
});
const r = groupSessions([mac, win]);
expect(r.projects).toHaveLength(2);
const macNode = r.projects.find((p) => p.workingDir === '/Users/foo/proj');
const winNode = r.projects.find((p) => p.workingDir === 'C:/Work/proj');
expect(macNode?.displayName).toBe('proj');
expect(macNode?.segments).toBe(1);
expect(winNode?.displayName).toBe('Work/proj');
expect(winNode?.segments).toBe(2);
});
it('Mac 路径与同尾 Windows 路径 (`/Users/foo/proj` vs `C:\\Users\\foo\\proj`) 追溯到 drive 段消歧', () => {
// 边界场景:两条路径除盘符 `C:` 段外完全相同,algorithms 的 split('/').filter(Boolean)
// 会把 `C:` 当作普通段保留,于是:
// tail2: 双方都是 `foo/proj` → 冲突
// tail3: 双方都是 `Users/foo/proj` → 仍冲突
// tail4: Win 变成 `C:/Users/foo/proj`,消歧成功
// Mac 是先创建者(winner),强制保留 basename `proj`;Win 继续向上追溯到 drive 段。
const mac = s({
workingDir: '/Users/foo/proj',
createdAt: '2026-04-01T00:00:00.000Z',
updatedAt: '2026-04-19T00:00:00.000Z',
});
const win = s({
workingDir: 'C:\\Users\\foo\\proj',
createdAt: '2026-04-10T00:00:00.000Z',
updatedAt: '2026-04-20T00:00:00.000Z',
});
const r = groupSessions([mac, win]);
expect(r.projects).toHaveLength(2);
const macNode = r.projects.find((p) => p.workingDir === '/Users/foo/proj');
const winNode = r.projects.find((p) => p.workingDir === 'C:/Users/foo/proj');
expect(macNode?.displayName).toBe('proj');
expect(macNode?.segments).toBe(1);
expect(winNode?.displayName).toBe('C:/Users/foo/proj');
expect(winNode?.segments).toBe(4);
});
it('多条全 Windows 路径 session 在同一 drive 下正常分组', () => {
// 全 Windows 路径场景:两条 session 同盘符同 basename 不同父目录 →
// 既要分到不同 project,又要按 createdAt 的同名消歧规则生成 displayName。
const a = s({
workingDir: 'C:\\Users\\foo\\proj',
createdAt: '2026-04-01T00:00:00.000Z',
updatedAt: '2026-04-20T00:00:00.000Z',
});
const b = s({
workingDir: 'C:\\workspace\\proj\\',
createdAt: '2026-04-10T00:00:00.000Z',
updatedAt: '2026-04-19T00:00:00.000Z',
});
const r = groupSessions([a, b]);
expect(r.projects).toHaveLength(2);
const aNode = r.projects.find((p) => p.workingDir === 'C:/Users/foo/proj');
const bNode = r.projects.find((p) => p.workingDir === 'C:/workspace/proj');
expect(aNode?.displayName).toBe('proj'); // 先创建者保留 basename
expect(bNode?.displayName).toBe('workspace/proj');
});
it('project-level latestUpdatedAt 仍取真实最新(不被 active-first 污染)', () => {
// Project A: active 较旧 + archived 较新 → latestUpdatedAt 应是 archived 的时间
// Project B: active 较新 → latestUpdatedAt = active 的时间
// 两 project 间排序仍按 latestUpdatedAt desc → A(4/21) > B(4/19)
const aActive = s({
workingDir: '/p/alpha',
status: 'active',
updatedAt: '2026-04-10T00:00:00.000Z',
});
const aArchived = s({
workingDir: '/p/alpha',
status: 'archived',
updatedAt: '2026-04-21T00:00:00.000Z',
});
const bActive = s({
workingDir: '/p/beta',
status: 'active',
updatedAt: '2026-04-19T00:00:00.000Z',
});
const r = groupSessions([aActive, aArchived, bActive]);
expect(r.projects.map((p) => p.displayName)).toEqual(['alpha', 'beta']);
});
});
});
/* ============================== device-link 远程项目 ============================== */
describe('device-link remote projects', () => {
it('deviceLinkProjectKey uses an isolated device: prefix and normalizes workingDir', () => {
expect(deviceLinkProjectKey('dev-B', '/Users/bob/proj/')).toBe('device:dev-B:/Users/bob/proj');
expect(deviceLinkProjectKey('dev-B', 'C:\\work\\app')).toBe('device:dev-B:C:/work/app');
// deviceId 含特殊字符要被 encodeURIComponent 编码
expect(deviceLinkProjectKey('a:b/c', '/p')).toBe('device:a%3Ab%2Fc:/p');
});
it('groups device-link sessions as remote scope with device: key, carrying device identity', () => {
const sess = s({
workingDir: '/Users/bob/proj',
deviceLinkDeviceId: 'dev-B',
deviceLinkDeviceName: 'Bob 的 Mac',
});
const r = groupSessions([sess]);
expect(r.projects).toHaveLength(1);
const p = r.projects[0];
expect(p.projectKey).toBe('device:dev-B:/Users/bob/proj');
expect(p.scope).toBe('remote');
expect(p.deviceLinkDeviceId).toBe('dev-B');
expect(p.deviceLinkDeviceName).toBe('Bob 的 Mac');
expect(p.deviceLinkConnectionStatus).toBe('connected');
expect(p.remoteHostId).toBeNull();
expect(p.displayName).toBe('proj');
});
it('carries disconnected device-link status into the project node', () => {
const sess = s({
workingDir: '/Users/bob/proj',
deviceLinkDeviceId: 'dev-B',
deviceLinkDeviceName: 'Bob 的 Mac',
deviceLinkConnectionStatus: 'disconnected',
});
const p = groupSessions([sess]).projects[0];
expect(p.deviceLinkConnectionStatus).toBe('disconnected');
});
it('does NOT collapse same workingDir across local / SSH / device-link into one project', () => {
const local = s({ workingDir: '/p/app' });
const ssh = s({ workingDir: '/p/app', remoteHostId: 'my-ssh-host' });
const devB = s({
workingDir: '/p/app',
deviceLinkDeviceId: 'dev-B',
deviceLinkDeviceName: 'B',
});
const devC = s({
workingDir: '/p/app',
deviceLinkDeviceId: 'dev-C',
deviceLinkDeviceName: 'C',
});
const r = groupSessions([local, ssh, devB, devC]);
const keys = r.projects.map((p) => p.projectKey).sort();
expect(keys).toEqual(
[
'local:/p/app',
projectIdentityKey('remote', '/p/app', 'my-ssh-host'),
'device:dev-B:/p/app',
'device:dev-C:/p/app',
].sort(),
);
// device-link 项目带设备身份、不带 SSH host;SSH 项目反之
const devProj = r.projects.find((p) => p.projectKey === 'device:dev-B:/p/app');
if (!devProj) throw new Error('expected device-link project');
expect(devProj.deviceLinkDeviceId).toBe('dev-B');
expect(devProj.remoteHostId).toBeNull();
const sshProj = r.projects.find((p) => p.remoteHostId === 'my-ssh-host');
if (!sshProj) throw new Error('expected SSH project');
expect(sshProj.deviceLinkDeviceId).toBeNull();
});
it('two device-link sessions on the same device+workdir group together', () => {
const a = s({ workingDir: '/p/app', deviceLinkDeviceId: 'dev-B', deviceLinkDeviceName: 'B' });
const b = s({ workingDir: '/p/app', deviceLinkDeviceId: 'dev-B', deviceLinkDeviceName: 'B' });
const r = groupSessions([a, b]);
expect(r.projects).toHaveLength(1);
expect(r.projects[0].sessions).toHaveLength(2);
});
it('normalizeProjectKey round-trips a device: key', () => {
expect(normalizeProjectKey('device:dev-B:/Users/bob/proj/')).toBe(
'device:dev-B:/Users/bob/proj',
);
expect(normalizeProjectKey('device:a%3Ab:/p')).toBe('device:a%3Ab:/p');
expect(normalizeProjectKey('device:dev-B')).toBeNull(); // 缺 workingDir 段
});
});
describe('pinnedSessionIdsInDisplayOrder(拖拽 baseline:与置顶段同序 status→pinnedAt desc,含归档)', () => {
it('取全部置顶(含归档,active 在前),按 status→pinnedAt desc 排,排除未置顶', () => {
const sessions = [
s({ id: 'p-old', pinnedAt: '2026-01-01T00:00:00.000Z' }),
s({ id: 'unpinned', pinnedAt: null }),
s({ id: 'p-new', pinnedAt: '2026-03-01T00:00:00.000Z' }),
s({ id: 'p-archived', pinnedAt: '2026-02-01T00:00:00.000Z', status: 'archived' }),
s({ id: 'p-mid', pinnedAt: '2026-02-15T00:00:00.000Z' }),
];
// active 段按 pinnedAt desc: p-new, p-mid, p-old;归档置顶排在所有 active 之后。
expect(pinnedSessionIdsInDisplayOrder(sessions)).toEqual([
'p-new',
'p-mid',
'p-old',
'p-archived',
]);
});
it('本地 + 远程置顶合并后统一按 pinnedAt desc 排(不分本地 / 远程)', () => {
const sessions = [
s({ id: 'local-old', pinnedAt: '2026-01-01T00:00:00.000Z' }),
s({ id: 'remote-new', pinnedAt: '2026-05-01T00:00:00.000Z', deviceLinkDeviceId: 'dev-a' }),
];
expect(pinnedSessionIdsInDisplayOrder(sessions)).toEqual(['remote-new', 'local-old']);
});
it('无置顶 → 空数组', () => {
expect(pinnedSessionIdsInDisplayOrder([s({ pinnedAt: null })])).toEqual([]);
});
});