Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
/**
* newMakerDraft.test.ts
* ---------------------------------------------------------------------------
* 回归 state/newMakerDraft.ts 的核心约定:
* 1. 默认 vendor='cc',workingDir=null,lastByVendor 各 vendor 的硬默认填齐
* 2. localStorage 持久化:patch 后 reload(模拟 app 重启)→ 状态恢复
* 3. switchVendor:把当前 vendor 的 prefs 落进 lastByVendor[oldVendor]
* 4. patchCurrentVendorPrefs:仅修当前 vendor 的 prefs,不影响另一个 vendor
* 5. Fast Mode 按模型记忆,缺省 false
* 6. schema 损坏的 localStorage 入参 → 静默回退默认,不抛错
*
* 项目 vitest env=node,无 window。这里用 vi.stubGlobal 注入最小 localStorage
* 实现,避免新增 jsdom/happy-dom 依赖。
*/
import { describe, it, expect, beforeEach, vi } from 'vitest';
class MemLocalStorage {
private store = new Map<string, string>();
getItem(k: string): string | null {
return this.store.has(k) ? (this.store.get(k) as string) : null;
}
setItem(k: string, v: string): void {
this.store.set(k, v);
}
removeItem(k: string): void {
this.store.delete(k);
}
clear(): void {
this.store.clear();
}
}
let memStorage: MemLocalStorage;
beforeEach(() => {
memStorage = new MemLocalStorage();
vi.stubGlobal('window', { localStorage: memStorage });
vi.stubGlobal('localStorage', memStorage);
vi.resetModules();
});
async function loadModule() {
return await import('@/state/newMakerDraft');
}
describe('newMakerDraft store', () => {
it('默认状态:vendor=cc,workingDir=null,lastByVendor 各 vendor 的硬默认填齐', async () => {
const { getDraft } = await loadModule();
const d = getDraft();
expect(d.vendor).toBe('cc');
expect(d.workingDir).toBeNull();
expect(d.lastByVendor.cc.permissionMode).toBe('auto');
expect(d.lastByVendor.cc.effort).toBe('medium');
expect(d.lastByVendor.cc.model.length).toBeGreaterThan(0);
expect(d.lastByVendor.codex.permissionMode).toBe('auto');
expect(d.lastByVendor.codex.effort).toBe('high');
expect(d.lastByVendor.pi.permissionMode).toBe('auto');
// 种子模型不再写死在 store 里(原先是 'gpt-5.4',与 modelDefinitions 写死的 'gpt-5.5'
// 漂移,且两者在目录里都是默认隐藏的模型)。现在统一从 getDefaultModelForVendor 取,
// capabilities 未加载时它给冷启动占位 id —— 这里只锁「非空且与那个入口同源」。
const { coldStartModelIdForVendor } = await import('@/lib/modelDefinitions');
expect(d.lastByVendor.codex.model).toBe(coldStartModelIdForVendor('codex'));
expect(d.lastByVendor.cc.model).toBe(coldStartModelIdForVendor('cc'));
expect(d.fastModeByModel).toEqual({});
expect(d.effortByModel).toEqual({});
expect(d.worktreeEnabled).toBe(false);
expect(d.worktreePreferenceCustomized).toBe(false);
expect(d.defaultTupleCustomized).toBe(false);
expect(d.defaultTupleSelectionCustomized).toBe(false);
});
it('产品默认原子写入完整组合,但不伪装成用户显式选模', async () => {
const { applySuggestedDefaultTuple, getDraft } = await loadModule();
expect(
applySuggestedDefaultTuple({
vendor: 'codex',
providerId: 'openai',
model: 'chatgpt/gpt-5.6-sol',
effort: 'high',
}),
).toBe(true);
expect(getDraft()).toMatchObject({
vendor: 'codex',
defaultTupleCustomized: false,
lastByVendor: {
codex: {
providerId: 'openai',
model: 'chatgpt/gpt-5.6-sol',
effort: 'high',
},
},
});
expect(getDraft().modelChosenByVendor.codex).toBeUndefined();
vi.resetModules();
const reloaded = await loadModule();
expect(reloaded.getDraft().defaultTupleCustomized).toBe(false);
});
it.each([false, true])('Gateway 后到不抢订阅,Codex 后到只更新未自定义草稿(手动选择=%s)', async (customized) => {
const { resolveNewMakerDefaultTuple } = await import('@/lib/newMakerDefaultTuple');
const { applySuggestedDefaultTuple, getDraft, markDefaultTupleCustomized } = await loadModule();
const sources: import('@cindy/model-providers').ProviderView[] = [
{
id: 'anthropic',
name: 'Claude',
source: 'builtin',
connected: true,
agents: ['claude-code'],
auth: { method: 'oauth' },
access: { kind: 'subscription', product: 'Claude' },
routing: {},
models: {
'claude-code': [
{
id: 'claude-opus-5-5',
name: 'Opus',
contextWindow: 272000,
efforts: ['high'],
defaultEffort: 'high',
},
],
},
},
];
const resolve = () =>
resolveNewMakerDefaultTuple({
providers: sources,
providersLoading: false,
availableAgents: new Set(['cc', 'codex', 'pi']),
availableAgentsLoaded: true,
})!;
expect(applySuggestedDefaultTuple(resolve())).toBe(true);
expect(getDraft().vendor).toBe('cc');
if (customized) markDefaultTupleCustomized();
sources.push({
id: 'xd',
name: 'Cindy AI',
source: 'builtin',
connected: true,
agents: ['pi'],
auth: { method: 'managed' },
access: { kind: 'managed' },
routing: {},
models: {
pi: [
{
id: 'auto',
name: 'Auto',
contextWindow: 200000,
efforts: ['high'],
defaultEffort: 'high',
newSessionDefault: ['pi'],
modalities: { input: ['text', 'image'], output: ['text'] },
},
],
},
});
expect(applySuggestedDefaultTuple(resolve())).toBe(false);
expect(getDraft().vendor).toBe('cc');
sources.push({ ...sources[0]!, id: 'openai', agents: ['codex'],
access: { kind: 'subscription', product: 'ChatGPT' },
models: { codex: [{ id: 'gpt-6.1-sol', name: 'Sol', contextWindow: 272000, efforts: ['high'], defaultEffort: 'high' }] },
});
expect(applySuggestedDefaultTuple(resolve())).toBe(!customized);
const draft = getDraft();
expect(draft.vendor).toBe(customized ? 'cc' : 'codex');
expect(draft.lastByVendor[draft.vendor].providerId).toBe(customized ? 'anthropic' : 'openai');
expect(draft.defaultTupleCustomized).toBe(customized);
expect(applySuggestedDefaultTuple(resolve())).toBe(false);
});
it('用户明确改过组合后,登录态变化不再覆盖', async () => {
const { applySuggestedDefaultTuple, getDraft, markDefaultTupleCustomized } = await loadModule();
markDefaultTupleCustomized();
expect(
applySuggestedDefaultTuple({
vendor: 'pi',
providerId: 'xai',
model: 'grok-4.6',
effort: 'high',
}),
).toBe(false);
expect(getDraft().vendor).toBe('cc');
expect(getDraft().defaultTupleCustomized).toBe(true);
expect(getDraft().defaultTupleSelectionCustomized).toBe(true);
});
it('恢复推荐只撤销 effort/Fast 调档,不清除模型/来源/Harness 选择', async () => {
const tuningOnly = await loadModule();
tuningOnly.markDefaultTupleCustomized(false);
expect(tuningOnly.getDraft()).toMatchObject({
defaultTupleCustomized: true,
defaultTupleSelectionCustomized: false,
});
tuningOnly.clearDefaultTupleTuningCustomization({
modelId: 'claude-sonnet-4-6',
hasExternalOverrides: false,
});
expect(tuningOnly.getDraft().defaultTupleCustomized).toBe(false);
tuningOnly.markDefaultTupleCustomized();
tuningOnly.markDefaultTupleCustomized(false);
tuningOnly.clearDefaultTupleTuningCustomization({
modelId: 'claude-sonnet-4-6',
hasExternalOverrides: false,
});
expect(tuningOnly.getDraft()).toMatchObject({
defaultTupleCustomized: true,
defaultTupleSelectionCustomized: true,
});
});
it.each(['effort', 'fast'] as const)(
'当前默认模型只改 %s 时,恢复推荐清空旧记忆并允许后续默认变化',
async (kind) => {
const modelId = 'claude-sonnet-4-6';
const draft = await loadModule();
draft.markDefaultTupleCustomized(false);
if (kind === 'effort') draft.setEffortForModel(modelId, 'high');
else draft.setFastModeForModel(modelId, true);
draft.clearDefaultTupleTuningCustomization({
modelId,
hasExternalOverrides: false,
});
expect(draft.getDraft()).toMatchObject({
defaultTupleCustomized: false,
defaultTupleSelectionCustomized: false,
effortByModel: {},
fastModeByModel: {},
});
expect(
draft.applySuggestedDefaultTuple({
vendor: 'pi',
providerId: 'xai',
model: 'grok-4.6',
effort: 'high',
}),
).toBe(true);
vi.resetModules();
const reloaded = await loadModule();
expect(reloaded.getDraft()).toMatchObject({
defaultTupleCustomized: false,
effortByModel: {},
fastModeByModel: {},
});
},
);
it('恢复当前项后仍有其它草稿或外部 override 时继续保护默认组合', async () => {
const draft = await loadModule();
draft.markDefaultTupleCustomized(false);
draft.setEffortForModel('claude-sonnet-4-6', 'high');
draft.setFastModeForModel('gpt-5.5', true);
draft.clearDefaultTupleTuningCustomization({
modelId: 'claude-sonnet-4-6',
hasExternalOverrides: false,
});
expect(draft.getDraft()).toMatchObject({
defaultTupleCustomized: true,
effortByModel: {},
fastModeByModel: { 'gpt-5.5': true },
});
draft.clearDefaultTupleTuningCustomization({
modelId: 'gpt-5.5',
hasExternalOverrides: true,
});
expect(draft.getDraft()).toMatchObject({
defaultTupleCustomized: true,
effortByModel: {},
fastModeByModel: {},
});
});
it('只改权限不把模型组合误标成用户自定义', async () => {
const { getDraft, patchCurrentVendorPrefs } = await loadModule();
patchCurrentVendorPrefs({ permissionMode: 'bypassPermissions' });
expect(getDraft().defaultTupleCustomized).toBe(false);
});
it('旧草稿的模型、来源、思考深度或 Fast 选择会迁移成已自定义', async () => {
for (const saved of [
{ vendor: 'cc', modelChosenByVendor: { cc: true } },
{ vendor: 'cc', lastByVendor: { cc: { model: 'claude-opus-4-8' } } },
{ vendor: 'cc', lastByVendor: { cc: { providerId: 'anthropic' } } },
{ vendor: 'cc', effortByModel: { 'claude-opus-5': 'high' } },
{ vendor: 'cc', fastModeByModel: { 'claude-opus-5': true } },
]) {
memStorage.setItem('xdt:newMakerDraft:v1', JSON.stringify(saved));
vi.resetModules();
const { getDraft } = await loadModule();
expect(getDraft().defaultTupleCustomized).toBe(true);
}
});
it('旧 preserving 路径仅留下 cc.model 时仍保护旧模型', async () => {
memStorage.setItem(
'xdt:newMakerDraft:v1',
JSON.stringify({ vendor: 'cc', lastByVendor: { cc: { model: 'claude-opus-4-8' } } }),
);
vi.resetModules();
const { applySuggestedDefaultTuple, getDraft } = await loadModule();
expect(getDraft().defaultTupleCustomized).toBe(true);
expect(
applySuggestedDefaultTuple({
vendor: 'pi',
providerId: 'xai',
model: 'grok-4.6',
effort: 'high',
}),
).toBe(false);
expect(getDraft().vendor).toBe('cc');
expect(getDraft().lastByVendor.cc.model).toBe('claude-opus-4-8');
});
it('旧 device-link preserving 完整快照与空 marker 仍保护 cc 旧模型', async () => {
memStorage.setItem(
'xdt:newMakerDraft:v1',
JSON.stringify({
vendor: 'cc',
modelChosenByVendor: {},
lastByVendor: {
cc: {
model: 'claude-opus-4-8',
providerId: null,
effort: 'medium',
permissionMode: 'auto',
planMode: false,
},
codex: { model: 'gpt-5.5', providerId: null, effort: 'high' },
pi: { model: 'claude-sonnet-5', providerId: null, effort: 'high' },
orca: { model: 'claude-sonnet-4-6', providerId: null, effort: 'medium' },
},
}),
);
vi.resetModules();
const { applySuggestedDefaultTuple, getDraft } = await loadModule();
expect(getDraft()).toMatchObject({
vendor: 'cc',
defaultTupleCustomized: true,
defaultTupleSelectionCustomized: true,
lastByVendor: { cc: { model: 'claude-opus-4-8', providerId: null, effort: 'medium' } },
});
expect(
applySuggestedDefaultTuple({
vendor: 'pi',
providerId: 'xai',
model: 'grok-4.6',
effort: 'high',
}),
).toBe(false);
expect(getDraft().lastByVendor.cc.model).toBe('claude-opus-4-8');
});
it('旧完整快照里的 cc 种子模型不误判成用户自定义', async () => {
memStorage.setItem(
'xdt:newMakerDraft:v1',
JSON.stringify({
vendor: 'cc',
workingDir: '/tmp/project',
lastByVendor: {
cc: { model: 'claude-sonnet-4-6' },
codex: { model: 'gpt-5.5' },
pi: { model: 'claude-sonnet-5' },
orca: { model: 'claude-sonnet-4-6' },
},
}),
);
vi.resetModules();
const { applySuggestedDefaultTuple, getDraft } = await loadModule();
expect(getDraft().defaultTupleCustomized).toBe(false);
expect(
applySuggestedDefaultTuple({
vendor: 'pi',
providerId: 'xai',
model: 'grok-4.6',
effort: 'high',
}),
).toBe(true);
expect(getDraft()).toMatchObject({
vendor: 'pi',
lastByVendor: { pi: { providerId: 'xai', model: 'grok-4.6', effort: 'high' } },
});
});
it('旧 head 已标明系统默认时,不因 Gateway 来源反推成用户选择', async () => {
memStorage.setItem(
'xdt:newMakerDraft:v1',
JSON.stringify({
vendor: 'pi',
defaultTupleCustomized: false,
modelChosenByVendor: {},
lastByVendor: {
cc: { model: 'claude-sonnet-4-6' },
codex: { model: 'gpt-5.5' },
pi: { model: 'grok-4.6', providerId: 'xai', effort: 'high' },
},
}),
);
vi.resetModules();
const { getDraft } = await loadModule();
expect(getDraft()).toMatchObject({
defaultTupleCustomized: false,
defaultTupleSelectionCustomized: false,
});
});
it('旧 head 已标明自定义时,从显式模型证据补出 selection marker', async () => {
memStorage.setItem(
'xdt:newMakerDraft:v1',
JSON.stringify({
vendor: 'cc',
defaultTupleCustomized: true,
modelChosenByVendor: { cc: true },
lastByVendor: { cc: { model: 'claude-opus-4-8' } },
}),
);
vi.resetModules();
const { getDraft } = await loadModule();
expect(getDraft()).toMatchObject({
defaultTupleCustomized: true,
defaultTupleSelectionCustomized: true,
});
});
it('旧 head 的 Gateway 默认来源加调档,不误补成 selection marker', async () => {
memStorage.setItem(
'xdt:newMakerDraft:v1',
JSON.stringify({
vendor: 'pi',
defaultTupleCustomized: true,
modelChosenByVendor: {},
effortByModel: { 'grok-4.6': 'medium' },
lastByVendor: {
cc: { model: 'claude-sonnet-4-6' },
codex: { model: 'gpt-5.5' },
pi: { model: 'grok-4.6', providerId: 'xai', effort: 'medium' },
},
}),
);
vi.resetModules();
const { clearDefaultTupleTuningCustomization, getDraft } = await loadModule();
expect(getDraft()).toMatchObject({
defaultTupleCustomized: true,
defaultTupleSelectionCustomized: false,
});
clearDefaultTupleTuningCustomization({
modelId: 'grok-4.6',
hasExternalOverrides: false,
});
expect(getDraft().defaultTupleCustomized).toBe(false);
});
it('旧 head 只换来源时,即使没有 modelChosen marker 也保护真实来源选择', async () => {
memStorage.setItem(
'xdt:newMakerDraft:v1',
JSON.stringify({
vendor: 'pi',
defaultTupleCustomized: true,
modelChosenByVendor: {},
lastByVendor: {
cc: { model: 'claude-sonnet-4-6' },
codex: { model: 'gpt-5.5' },
pi: { model: 'grok-4.6', providerId: 'openrouter', effort: 'high' },
},
}),
);
vi.resetModules();
const { clearDefaultTupleTuningCustomization, getDraft } = await loadModule();
expect(getDraft()).toMatchObject({
defaultTupleCustomized: true,
defaultTupleSelectionCustomized: true,
});
clearDefaultTupleTuningCustomization({
modelId: 'grok-4.6',
hasExternalOverrides: false,
});
expect(getDraft().defaultTupleCustomized).toBe(true);
});
it('旧版系统可用性 fallback 不迁移成用户自定义', async () => {
for (const vendor of ['codex', 'pi'] as const) {
memStorage.setItem('xdt:newMakerDraft:v1', JSON.stringify({ vendor }));
vi.resetModules();
const { applySuggestedDefaultTuple, getDraft } = await loadModule();
expect(getDraft().defaultTupleCustomized).toBe(false);
expect(
applySuggestedDefaultTuple({
vendor: 'pi',
providerId: 'xai',
model: 'grok-4.6',
effort: 'high',
}),
).toBe(true);
expect(getDraft()).toMatchObject({
vendor: 'pi',
defaultTupleCustomized: false,
lastByVendor: { pi: { providerId: 'xai', model: 'grok-4.6', effort: 'high' } },
});
}
});
it('默认组合先落 Pi 后,可用性回退读取实时草稿且不被旧 cc 闭包覆盖', async () => {
const { applySuggestedDefaultTuple, fallbackUnavailableVendor, getDraft } = await loadModule();
expect(
applySuggestedDefaultTuple({
vendor: 'pi',
providerId: 'xai',
model: 'grok-4.6',
effort: 'high',
}),
).toBe(true);
expect(fallbackUnavailableVendor(new Set(['codex', 'pi']))).toBe(false);
expect(getDraft()).toMatchObject({
vendor: 'pi',
defaultTupleCustomized: false,
lastByVendor: { pi: { providerId: 'xai', model: 'grok-4.6', effort: 'high' } },
});
});
it('系统可用性回退本身不标记用户自定义', async () => {
const { fallbackUnavailableVendor, getDraft } = await loadModule();
expect(fallbackUnavailableVendor(new Set(['codex', 'pi']))).toBe(true);
expect(getDraft().vendor).toBe('codex');
expect(getDraft().defaultTupleCustomized).toBe(false);
});
it('persists an explicit Pi model choice across reload', async () => {
const m1 = await loadModule();
m1.patchVendorPrefs('pi', { model: 'chatgpt/gpt-5.6' });
vi.resetModules();
const m2 = await loadModule();
expect(m2.getDraft().modelChosenByVendor.pi).toBe(true);
expect(m2.getPersistedVendorModel('pi')).toBe('chatgpt/gpt-5.6');
});
it('Effort 按模型记忆:get/set + 同值短路 + 持久化', async () => {
const m1 = await loadModule();
expect(m1.getEffortForModel('claude-opus-4-7')).toBeUndefined();
m1.setEffortForModel('claude-opus-4-7', 'xhigh');
m1.setEffortForModel('claude-haiku-4-5', 'low');
expect(m1.getEffortForModel('claude-opus-4-7')).toBe('xhigh');
expect(m1.getEffortForModel('claude-haiku-4-5')).toBe('low');
expect(m1.getDraft().effortByModel).toEqual({
'claude-opus-4-7': 'xhigh',
'claude-haiku-4-5': 'low',
});
// 同值写入应短路 (此处只能间接断言不抛错; 持久化层面无外部信号)
m1.setEffortForModel('claude-opus-4-7', 'xhigh');
expect(m1.getEffortForModel('claude-opus-4-7')).toBe('xhigh');
// 模拟 app 重启 → 仍按模型恢复
vi.resetModules();
const m2 = await loadModule();
expect(m2.getEffortForModel('claude-opus-4-7')).toBe('xhigh');
expect(m2.getEffortForModel('claude-haiku-4-5')).toBe('low');
expect(m2.getEffortForModel('not-recorded')).toBeUndefined();
});
it('Effort 按模型记忆:老版本 localStorage 无该字段 → 空对象兜底, 不抛', async () => {
memStorage.setItem(
'xdt:newMakerDraft:v1',
JSON.stringify({ vendor: 'cc' /* 无 effortByModel */ }),
);
vi.resetModules();
const { getDraft, getEffortForModel } = await loadModule();
expect(getDraft().effortByModel).toEqual({});
expect(getEffortForModel('claude-opus-4-7')).toBeUndefined();
});
it('Effort 按模型记忆:脏数据 (非 string value / 空 key) 被过滤', async () => {
memStorage.setItem(
'xdt:newMakerDraft:v1',
JSON.stringify({
effortByModel: {
'claude-opus-4-7': 'high',
'': 'low',
'claude-haiku-4-5': 42,
'gpt-5.5': null,
'gpt-5.4': '',
},
}),
);
vi.resetModules();
const { getDraft } = await loadModule();
expect(getDraft().effortByModel).toEqual({ 'claude-opus-4-7': 'high' });
});
it('patchDraft + 重新加载 module → 持久化生效(模拟 app 重启)', async () => {
const m1 = await loadModule();
m1.patchDraft({ workingDir: 'E:/projects/foo' });
// scheduleWrite 改成同步落盘后, patch 完应立刻可见
expect(memStorage.getItem(m1.__STORAGE_KEY)).not.toBeNull();
// 模拟"app 重启"——重置 module cache,重新 import 后从 localStorage 恢复
vi.resetModules();
const m2 = await loadModule();
expect(m2.getDraft().workingDir).toBe('E:/projects/foo');
});
it('extraDirs 不跨重启还原:运行内生效,重启后一律空(引用目录=单次草稿授权)', async () => {
const m1 = await loadModule();
m1.patchDraft({ workingDir: 'E:/projects/foo', extraDirs: ['E:/projects/shared-lib'] });
// 同一次运行内:内存态生效
expect(m1.getDraft().extraDirs).toEqual(['E:/projects/shared-lib']);
// 模拟 app 重启 → workingDir 等偏好保留,extraDirs 清空(sanitize 一律置空)
vi.resetModules();
const m2 = await loadModule();
expect(m2.getDraft().workingDir).toBe('E:/projects/foo');
expect(m2.getDraft().extraDirs).toEqual([]);
});
it('collab.workerConfig 跨重启保留耐久字段,丢弃一次性 initialTask(codex P2)', async () => {
const m1 = await loadModule();
m1.patchDraft({
workingDir: '/projects/foo',
collab: {
enabled: true,
worker: 'cc',
workerConfig: {
role: 'developer',
model: 'claude-opus-4-7',
effort: 'high',
fast: true,
workerPermissionMode: 'bypassPermissions',
initialTask: '先跑一遍测试',
},
},
});
// 当前运行内 initialTask 可用(Send/New Goal 立即消费)
expect(m1.getDraft().collab.workerConfig?.initialTask).toBe('先跑一遍测试');
// 模拟 app 重启:耐久选择(role/model/effort/fast)恢复,一次性任务不复活——
// 否则重启后 Send 会静默把过期任务当 delegateTask 派给 Worker,而收起态
// pill 无从看见/编辑。
vi.resetModules();
const m2 = await loadModule();
const wc = m2.getDraft().collab.workerConfig;
expect(wc).toMatchObject({
role: 'developer',
model: 'claude-opus-4-7',
effort: 'high',
fast: true,
workerPermissionMode: 'bypassPermissions',
});
expect(wc?.initialTask).toBeUndefined();
});
it('另起干净任务时只关闭协同,不覆盖 Worker 创建偏好', async () => {
const { getDraft, patchDraft, resetDraftWorkspaceTargets } = await loadModule();
patchDraft({
collab: {
enabled: true,
worker: 'codex',
workerConfig: {
role: 'developer',
model: 'gpt-5.5',
workerPermissionMode: 'bypassPermissions',
},
},
});
resetDraftWorkspaceTargets();
expect(getDraft().collab.enabled).toBe(false);
expect(getDraft().collab.workerConfig).toMatchObject({
role: 'developer',
model: 'gpt-5.5',
workerPermissionMode: 'bypassPermissions',
});
});
it('patchDraft: Cindy worktree 路径会折回项目根目录', async () => {
const { getDraft, patchDraft } = await loadModule();
patchDraft({ workingDir: 'E:/projects/foo/.cindy-worktrees/auto-abc' });
expect(getDraft().workingDir).toBe('E:/projects/foo');
});
it('patchDraft: 普通 Windows 路径归一成 POSIX 分隔符,worktree 路径继续折回', async () => {
const { getDraft, patchDraft } = await loadModule();
patchDraft({ workingDir: 'E:\\projects\\foo' });
expect(getDraft().workingDir).toBe('E:/projects/foo');
patchDraft({ workingDir: 'E:\\projects\\foo\\.cindy-worktrees\\auto-abc\\src' });
expect(getDraft().workingDir).toBe('E:/projects/foo');
});
it('patchDraft: Windows 盘符根目录下的 worktree 会折回盘符根目录', async () => {
const { getDraft, patchDraft } = await loadModule();
patchDraft({ workingDir: 'E:\\.cindy-worktrees\\auto-abc\\src' });
expect(getDraft().workingDir).toBe('E:/');
});
it('localStorage 历史残留:旧 xdt worktree 路径读取时迁移回项目根目录', async () => {
memStorage.setItem(
'xdt:newMakerDraft:v1',
JSON.stringify({
vendor: 'cc',
workingDir: 'E:/projects/foo/.xdt-worktrees/auto-abc/src',
}),
);
vi.resetModules();
const { getDraft } = await loadModule();
expect(getDraft().workingDir).toBe('E:/projects/foo');
});
it('patchDraft: 不折叠用户手选的非 xdt worktree 目录', async () => {
const { getDraft, patchDraft } = await loadModule();
patchDraft({ workingDir: 'E:/projects/foo/.worktrees/auto-abc/src' });
expect(getDraft().workingDir).toBe('E:/projects/foo/.worktrees/auto-abc/src');
patchDraft({ workingDir: 'E:/projects/foo/.claude/worktrees/auto-abc/src' });
expect(getDraft().workingDir).toBe('E:/projects/foo/.claude/worktrees/auto-abc/src');
});
it('switchVendor:保留已同步的当前 vendor prefs 后再切到目标 vendor', async () => {
const { getDraft, patchCurrentVendorPrefs, switchVendor } = await loadModule();
patchCurrentVendorPrefs({
model: 'claude-opus-4-7',
effort: 'high',
permissionMode: 'bypassPermissions',
});
switchVendor('codex');
const d = getDraft();
expect(d.vendor).toBe('codex');
// 旧 vendor(cc)的 prefs 被落地为传入的值
expect(d.lastByVendor.cc.model).toBe('claude-opus-4-7');
expect(d.lastByVendor.cc.effort).toBe('high');
expect(d.lastByVendor.cc.permissionMode).toBe('bypassPermissions');
// 新 vendor(codex)的 prefs 不变(等待用户在 codex 下继续操作)
expect(d.lastByVendor.codex.permissionMode).toBe('auto');
});
it('switchVendor:选中的引擎跨重启保留(模拟 app 重启后仍是上次选的)', async () => {
const m1 = await loadModule();
expect(m1.getDraft().vendor).toBe('cc');
m1.switchVendor('codex');
expect(m1.getDraft().vendor).toBe('codex');
vi.resetModules();
const m2 = await loadModule();
expect(m2.getDraft().vendor).toBe('codex');
});
it('sanitize:引擎白名单按 SELECTABLE_VENDORS 校验,表内的值一律保留', async () => {
const { SELECTABLE_VENDORS } = await import('@/lib/agentVendors');
for (const vendor of SELECTABLE_VENDORS) {
memStorage.setItem('xdt:newMakerDraft:v1', JSON.stringify({ vendor }));
vi.resetModules();
const { getDraft } = await loadModule();
// 逐个写死白名单时,新上线的引擎在这里会被静默重置回 'cc' —— 用户选中后重启就丢。
expect(getDraft().vendor).toBe(vendor);
}
});
it("sanitize:表外的引擎值(历史 'orca' / 未知 / 非字符串)回退默认", async () => {
for (const vendor of ['orca', 'unknown-engine', '', 42, null]) {
memStorage.setItem('xdt:newMakerDraft:v1', JSON.stringify({ vendor }));
vi.resetModules();
const { getDraft } = await loadModule();
expect(getDraft().vendor).toBe('cc');
}
});
it('switchVendor:相同 vendor 不变(no-op,避免误覆盖)', async () => {
const { getDraft, switchVendor } = await loadModule();
const before = getDraft().lastByVendor.cc;
switchVendor('cc');
expect(getDraft().lastByVendor.cc).toEqual(before);
});
it('patchCurrentVendorPrefs:只改当前 vendor,不影响另一个', async () => {
const { getDraft, patchCurrentVendorPrefs } = await loadModule();
const codexBefore = getDraft().lastByVendor.codex;
patchCurrentVendorPrefs({ effort: 'xhigh', model: 'claude-opus-4-7' });
const d = getDraft();
expect(d.lastByVendor.cc.effort).toBe('xhigh');
expect(d.lastByVendor.cc.model).toBe('claude-opus-4-7');
expect(d.lastByVendor.codex).toEqual(codexBefore);
});
it('modelChosenByVendor:显式选 model 打标记并持久化;只改 effort 不打;种子默认不算选择', async () => {
const m1 = await loadModule();
// 初始:没有任何显式选择 → getPersistedVendorModel 返回 ''
//(即使 patchDraft 已把含种子默认 model 的快照落盘)
m1.patchDraft({ workingDir: '/foo' });
expect(m1.getDraft().modelChosenByVendor).toEqual({});
expect(m1.getPersistedVendorModel('cc')).toBe('');
// 只改 effort → 仍不算选过 model
m1.patchCurrentVendorPrefs({ effort: 'xhigh' });
expect(m1.getPersistedVendorModel('cc')).toBe('');
// 显式选 model → 打标记,getPersistedVendorModel 返回该值
m1.patchCurrentVendorPrefs({ model: 'claude-opus-4-8' });
expect(m1.getDraft().modelChosenByVendor).toEqual({ cc: true });
expect(m1.getPersistedVendorModel('cc')).toBe('claude-opus-4-8');
expect(m1.getPersistedVendorModel('codex')).toBe('');
// 模拟 app 重启 → 标记与值都恢复
vi.resetModules();
const m2 = await loadModule();
expect(m2.getDraft().modelChosenByVendor).toEqual({ cc: true });
expect(m2.getPersistedVendorModel('cc')).toBe('claude-opus-4-8');
});
it('patchVendorPrefsFromTaskModelSwitch:新建默认在另一个来源上时,任务内只换模型不改写', async () => {
const m1 = await loadModule();
m1.patchVendorPrefs('cc', { model: 'claude-opus-5-5', providerId: 'anthropic', effort: 'high' });
const written = m1.patchVendorPrefsFromTaskModelSwitch(
'cc',
{ model: 'anthropic/claude-sonnet-5-5', providerId: 'xd', effort: 'medium' },
'xd',
);
expect(written).toBe(false);
expect(m1.getDraft().lastByVendor.cc).toMatchObject({
model: 'claude-opus-5-5',
providerId: 'anthropic',
effort: 'high',
});
});
it('patchVendorPrefsFromTaskModelSwitch:来源一致时照常写回并打标', async () => {
const m1 = await loadModule();
m1.patchVendorPrefs('cc', { model: 'claude-opus-5-5', providerId: 'anthropic' });
const written = m1.patchVendorPrefsFromTaskModelSwitch(
'cc',
{ model: 'claude-sonnet-5-5', providerId: 'anthropic', effort: 'xhigh' },
'anthropic',
);
expect(written).toBe(true);
expect(m1.getDraft().lastByVendor.cc).toMatchObject({
model: 'claude-sonnet-5-5',
providerId: 'anthropic',
effort: 'xhigh',
});
expect(m1.getDraft().modelChosenByVendor).toEqual({ cc: true });
});
it('patchVendorPrefsFromTaskModelSwitch:存着的来源已被搬走时按实际路由比较', async () => {
const m1 = await loadModule();
m1.patchVendorPrefs('cc', { model: 'auto/pool', providerId: 'org-pool' });
// 服务端把该 Auto 搬到了 xd:实际来源是 xd,不是存着的 org-pool。
const moved = () => 'xd';
expect(
m1.patchVendorPrefsFromTaskModelSwitch(
'cc',
{ model: 'auto/pool', providerId: 'org-pool' },
'org-pool',
moved,
),
).toBe(false);
expect(m1.getDraft().lastByVendor.cc.providerId).toBe('org-pool');
// 解析不出来时回退用存着的来源比较。
expect(
m1.patchVendorPrefsFromTaskModelSwitch(
'cc',
{ model: 'auto/pool', providerId: 'org-pool' },
'org-pool',
() => null,
),
).toBe(true);
});
it('patchVendorPrefsFromTaskModelSwitch:保留的草稿来源对新模型已失效时改写入任务实际来源', async () => {
const m1 = await loadModule();
m1.patchVendorPrefs('cc', { model: 'auto/pool', providerId: 'org-pool' });
// Auto 已搬到 xd:旧 org-pool 对任何模型都解析不到,实际落点是 xd。
const resolve = (prefs: { model: string; providerId?: string | null }) =>
prefs.model === 'auto/pool'
? 'xd'
: prefs.providerId === 'org-pool'
? null
: (prefs.providerId ?? null);
const written = m1.patchVendorPrefsFromTaskModelSwitch(
'cc',
{ model: 'plain-model', providerId: null },
'xd',
resolve,
);
expect(written).toBe(true);
expect(m1.getDraft().lastByVendor.cc).toMatchObject({
model: 'plain-model',
providerId: 'xd',
});
});
it('patchVendorPrefsFromTaskModelSwitch:旧来源搬走后即使仍能提供新模型也不复活', async () => {
const m1 = await loadModule();
m1.patchVendorPrefs('cc', { model: 'auto/pool', providerId: 'org-pool' });
// Auto 已搬到 xd:存着的 org-pool 实际落点是 xd;org-pool 对普通模型仍然能提供。
const resolve = (prefs: { model: string; providerId?: string | null }) =>
prefs.model === 'auto/pool' ? 'xd' : (prefs.providerId ?? null);
expect(
m1.patchVendorPrefsFromTaskModelSwitch(
'cc',
{ model: 'plain-model', providerId: null },
'xd',
resolve,
),
).toBe(true);
expect(m1.getDraft().lastByVendor.cc).toMatchObject({
model: 'plain-model',
providerId: 'xd',
});
});
it('patchVendorPrefsFromTaskModelSwitch:patch 里带着过期来源时仍写入已确认的任务来源', async () => {
const m1 = await loadModule();
m1.patchVendorPrefs('cc', { model: 'auto/pool', providerId: 'org-pool' });
const resolve = (prefs: { model: string; providerId?: string | null }) =>
prefs.model === 'auto/pool' ? 'xd' : (prefs.providerId ?? null);
expect(
m1.patchVendorPrefsFromTaskModelSwitch(
'cc',
{ model: 'plain-model', providerId: 'org-pool' },
'xd',
resolve,
),
).toBe(true);
expect(m1.getDraft().lastByVendor.cc.providerId).toBe('xd');
});
it('patchVendorPrefsFromTaskModelSwitch:草稿本来跟随默认路由时保持跟随', async () => {
const m1 = await loadModule();
m1.patchVendorPrefs('cc', { model: 'claude-opus-5-5', providerId: null });
expect(
m1.patchVendorPrefsFromTaskModelSwitch(
'cc',
{ model: 'claude-sonnet-5-5', providerId: 'anthropic' },
'anthropic',
() => 'anthropic',
),
).toBe(true);
expect(m1.getDraft().lastByVendor.cc).toMatchObject({
model: 'claude-sonnet-5-5',
providerId: null,
});
});
it('patchVendorPrefsFromTaskModelSwitch:任务跟随默认路由时保留草稿显式选过的同一来源', async () => {
const m1 = await loadModule();
m1.patchVendorPrefs('cc', { model: 'claude-opus-5-5', providerId: 'anthropic' });
const written = m1.patchVendorPrefsFromTaskModelSwitch(
'cc',
{ model: 'claude-sonnet-5-5', providerId: null },
'anthropic',
);
expect(written).toBe(true);
expect(m1.getDraft().lastByVendor.cc).toMatchObject({
model: 'claude-sonnet-5-5',
providerId: 'anthropic',
});
});
it('patchVendorPrefsFromTaskModelSwitch:跟随默认路由的新建默认按解析出的来源比较', async () => {
const m1 = await loadModule();
m1.patchVendorPrefs('cc', { model: 'claude-opus-5-5', providerId: null });
const resolve = (prefs: { model: string }) =>
prefs.model === 'claude-opus-5-5' ? 'anthropic' : null;
expect(
m1.patchVendorPrefsFromTaskModelSwitch(
'cc',
{ model: 'anthropic/claude-opus-5-5', providerId: 'xd' },
'xd',
resolve,
),
).toBe(false);
expect(m1.getDraft().lastByVendor.cc).toMatchObject({ model: 'claude-opus-5-5', providerId: null });
// 新建默认的来源解析不出来(目录未就绪等)时不能放行,否则会绕过保护把默认搬到任务的来源。
expect(
m1.patchVendorPrefsFromTaskModelSwitch(
'cc',
{ model: 'anthropic/claude-opus-5-5', providerId: 'xd' },
'xd',
() => null,
),
).toBe(false);
expect(m1.patchVendorPrefsFromTaskModelSwitch('cc', { model: 'x', providerId: 'xd' }, 'xd')).toBe(
false,
);
expect(m1.getDraft().lastByVendor.cc).toMatchObject({ model: 'claude-opus-5-5', providerId: null });
});
it('patchVendorPrefsFromTaskModelSwitch:先吸收另一窗口刚保存的默认再比较来源', async () => {
const m1 = await loadModule();
m1.patchVendorPrefs('cc', { model: 'claude-opus-5-5', providerId: 'xd' });
// 另一窗口把新建默认改成 anthropic,本窗口的 storage 事件还没送达。
const stored = JSON.parse(memStorage.getItem([...(memStorage as any).store.keys()][0]) as string);
stored.lastByVendor.cc = { ...stored.lastByVendor.cc, model: 'claude-opus-5-5', providerId: 'anthropic' };
stored.modelChosenByVendor = { cc: true };
stored.defaultTupleCustomized = true;
stored.defaultTupleSelectionCustomized = true;
memStorage.setItem([...(memStorage as any).store.keys()][0], JSON.stringify(stored));
const written = m1.patchVendorPrefsFromTaskModelSwitch(
'cc',
{ model: 'anthropic/claude-sonnet-5-5', providerId: 'xd' },
'xd',
);
expect(written).toBe(false);
expect(m1.getDraft().lastByVendor.cc.providerId).toBe('anthropic');
});
it('patchVendorPrefsPreservingModelChoice:只改思考档不打显式选择标记', async () => {
const m1 = await loadModule();
m1.patchVendorPrefsPreservingModelChoice('cc', {
effort: 'high',
});
expect(m1.getDraft().lastByVendor.cc.effort).toBe('high');
expect(m1.getDraft().modelChosenByVendor).toEqual({});
expect(m1.getPersistedVendorModel('cc')).toBe('');
m1.patchVendorPrefs('cc', { model: 'claude-opus-4-8' });
expect(m1.getDraft().modelChosenByVendor).toEqual({ cc: true });
expect(m1.getPersistedVendorModel('cc')).toBe('claude-opus-4-8');
});
it('patchVendorPrefsPreservingModelChoice:已有任务换模后只改思考档不得清掉选模标记', async () => {
const m1 = await loadModule();
m1.patchVendorPrefs('cc', { model: 'claude-sonnet-4-6' });
expect(m1.getDraft().modelChosenByVendor).toEqual({ cc: true });
expect(m1.getPersistedVendorModel('cc')).toBe('claude-sonnet-4-6');
m1.patchVendorPrefsPreservingModelChoice('cc', {
model: 'claude-sonnet-4-6',
effort: 'high',
});
expect(m1.getDraft().lastByVendor.cc.model).toBe('claude-sonnet-4-6');
expect(m1.getDraft().lastByVendor.cc.effort).toBe('high');
expect(m1.getDraft().modelChosenByVendor).toEqual({ cc: true });
expect(m1.getPersistedVendorModel('cc')).toBe('claude-sonnet-4-6');
});
it('patchVendorPrefsPreservingModelChoice:可写回活动模型但不打标也不清标', async () => {
const m1 = await loadModule();
m1.patchVendorPrefsPreservingModelChoice('cc', {
model: 'claude-opus-4-8',
effort: 'high',
});
expect(m1.getDraft().lastByVendor.cc.model).toBe('claude-opus-4-8');
expect(m1.getDraft().modelChosenByVendor).toEqual({});
expect(m1.getPersistedVendorModel('cc')).toBe('');
m1.patchVendorPrefs('cc', { model: 'claude-sonnet-4-6', effort: 'medium' });
expect(m1.getDraft().modelChosenByVendor).toEqual({ cc: true });
m1.patchVendorPrefsPreservingModelChoice('cc', {
model: 'claude-opus-4-8',
providerId: 'anthropic',
effort: 'high',
});
expect(m1.getDraft().lastByVendor.cc.model).toBe('claude-sonnet-4-6');
expect(m1.getDraft().lastByVendor.cc.providerId).toBeNull();
expect(m1.getDraft().lastByVendor.cc.effort).toBe('medium');
expect(m1.getDraft().modelChosenByVendor).toEqual({ cc: true });
expect(m1.getPersistedVendorModel('cc')).toBe('claude-sonnet-4-6');
});
it('patchVendorPrefsPreservingModelChoice:已打标且活动模型一致时才更新思考档', async () => {
const m1 = await loadModule();
m1.patchVendorPrefs('cc', { model: 'claude-sonnet-4-6', effort: 'medium' });
m1.patchVendorPrefsPreservingModelChoice('cc', {
effort: 'high',
});
expect(m1.getDraft().lastByVendor.cc.model).toBe('claude-sonnet-4-6');
expect(m1.getDraft().lastByVendor.cc.effort).toBe('high');
expect(m1.getDraft().modelChosenByVendor).toEqual({ cc: true });
});
it('patchVendorPrefsPreservingModelChoice:未打标且不带 model 时不得改活动模型', async () => {
const m1 = await loadModule();
const seedModel = m1.getDraft().lastByVendor.cc.model;
m1.patchVendorPrefsPreservingModelChoice('cc', {
effort: 'high',
});
expect(m1.getDraft().lastByVendor.cc.model).toBe(seedModel);
expect(m1.getDraft().lastByVendor.cc.effort).toBe('high');
expect(m1.getDraft().modelChosenByVendor).toEqual({});
expect(m1.getPersistedVendorModel('cc')).toBe('');
});
it('patchVendorPrefsPreservingModelChoice:未打标时仍可写回活动模型与来源', async () => {
const m1 = await loadModule();
m1.patchVendorPrefsPreservingModelChoice('cc', {
model: 'claude-opus-4-8',
providerId: 'anthropic',
effort: 'high',
});
expect(m1.getDraft().lastByVendor.cc.model).toBe('claude-opus-4-8');
expect(m1.getDraft().lastByVendor.cc.providerId).toBe('anthropic');
expect(m1.getDraft().lastByVendor.cc.effort).toBe('high');
expect(m1.getDraft().modelChosenByVendor).toEqual({});
expect(m1.getPersistedVendorModel('cc')).toBe('');
});
it('已有任务换模走 patchVendorPrefs,下次新建跟随这次选择', async () => {
const m1 = await loadModule();
m1.patchVendorPrefs('cc', { model: 'claude-sonnet-4-6' });
m1.patchVendorPrefs('cc', { model: 'claude-opus-4-8', effort: 'high' });
expect(m1.getDraft().lastByVendor.cc.model).toBe('claude-opus-4-8');
expect(m1.getDraft().lastByVendor.cc.effort).toBe('high');
expect(m1.getDraft().modelChosenByVendor).toEqual({ cc: true });
expect(m1.getPersistedVendorModel('cc')).toBe('claude-opus-4-8');
});
it('clearDraft → 回到初始默认', async () => {
const { getDraft, patchDraft, clearDraft } = await loadModule();
patchDraft({ workingDir: '/foo' });
expect(getDraft().workingDir).toBe('/foo');
clearDraft();
expect(getDraft().workingDir).toBeNull();
expect(getDraft().vendor).toBe('cc');
});
it('Fast Mode:按模型记忆,缺省 false', async () => {
const { getDraft, getFastModeForModel, setFastModeForModel } = await loadModule();
expect(getFastModeForModel('gpt-5.5')).toBe(false);
setFastModeForModel('gpt-5.5', true);
expect(getFastModeForModel('gpt-5.5')).toBe(true);
expect(getFastModeForModel('gpt-5.4')).toBe(false);
expect(getDraft().fastModeByModel).toEqual({ 'gpt-5.5': true });
setFastModeForModel('gpt-5.5', false);
expect(getFastModeForModel('gpt-5.5')).toBe(false);
});
it('Fast Mode:持久化后重新加载仍按模型恢复', async () => {
const m1 = await loadModule();
m1.setFastModeForModel('gpt-5.5', true);
vi.resetModules();
const m2 = await loadModule();
expect(m2.getFastModeForModel('gpt-5.5')).toBe(true);
expect(m2.getFastModeForModel('claude-opus-4-7')).toBe(false);
});
it('schema 损坏的 localStorage 入参 → 静默回退默认,不抛错', async () => {
memStorage.setItem('xdt:newMakerDraft:v1', '{"vendor":"unknown","oops":true,broken json');
vi.resetModules();
const { getDraft } = await loadModule();
const d = getDraft();
expect(d.vendor).toBe('cc');
expect(d.workingDir).toBeNull();
});
it("历史草稿 permissionMode='plan' → 迁移为 planMode=true + vendor 默认权限档", async () => {
memStorage.setItem(
'xdt:newMakerDraft:v1',
JSON.stringify({
vendor: 'cc',
lastByVendor: {
cc: { model: 'claude-opus-4-7', effort: 'high', permissionMode: 'plan' },
codex: { model: 'gpt-5.4', effort: 'high', permissionMode: 'auto', planMode: true },
},
}),
);
vi.resetModules();
const { getDraft } = await loadModule();
const d = getDraft();
// legacy 'plan' 档 → planMode 开关 + 回落该 vendor 默认权限档(与 DB 迁移同语义)
expect(d.lastByVendor.cc.permissionMode).toBe('auto');
expect(d.lastByVendor.cc.planMode).toBe(true);
// 显式 planMode 布尔原样保留
expect(d.lastByVendor.codex.permissionMode).toBe('auto');
expect(d.lastByVendor.codex.planMode).toBe(true);
});
it('schema 部分缺失的 localStorage 入参 → 缺字段补默认', async () => {
memStorage.setItem(
'xdt:newMakerDraft:v1',
JSON.stringify({ vendor: 'codex' /* workingDir / lastByVendor 都缺 */ }),
);
vi.resetModules();
const { getDraft } = await loadModule();
const d = getDraft();
expect(d.vendor).toBe('codex');
expect(d.workingDir).toBeNull();
expect(d.lastByVendor.cc.permissionMode).toBe('auto');
expect(d.lastByVendor.codex.effort).toBe('high');
expect(d.lastByVendor.codex.permissionMode).toBe('auto');
expect(d.fastModeByModel).toEqual({});
});
it('schema:legacy wt* root 字段仍被忽略,不迁移进 worktreeEnabled', async () => {
// 2026-07-28「勾选状态保存在工作端」上线后 worktree 记忆走新字段 worktreeEnabled;
// 历史残留的 wtEnabled/wtName/wtSourceBranch/wtBaseRepo(更早的持久化实验)继续
// 丢弃,且不从旧值猜测用户意图做迁移(configuration-and-overrides 规则)。
memStorage.setItem(
'xdt:newMakerDraft:v1',
JSON.stringify({
vendor: 'cc',
wtEnabled: true,
wtName: 'foo',
wtSourceBranch: 'main',
wtBaseRepo: '/x',
}),
);
vi.resetModules();
const { getDraft } = await loadModule();
const d = getDraft();
expect(d).not.toHaveProperty('wtEnabled');
expect(d).not.toHaveProperty('wtName');
expect(d).not.toHaveProperty('wtSourceBranch');
expect(d).not.toHaveProperty('wtBaseRepo');
expect(d.worktreeEnabled).toBe(false);
});
it('schema:worktree 偏好以显式 override 持久化,脏值/缺字段跟随系统默认', async () => {
// 勾选记忆是「工作端一份」的显式 override:专用 setter 写入 → 重载后恢复。
vi.resetModules();
{
const { getDraft, setWorktreePreference } = await loadModule();
expect(getDraft().worktreeEnabled).toBe(false); // 出厂默认不勾选(防误操作)
expect(getDraft().worktreePreferenceCustomized).toBe(false);
setWorktreePreference(true);
expect(getDraft().worktreeEnabled).toBe(true);
expect(getDraft().worktreePreferenceCustomized).toBe(true);
}
vi.resetModules();
{
const { getDraft } = await loadModule();
expect(getDraft().worktreeEnabled).toBe(true);
expect(getDraft().worktreePreferenceCustomized).toBe(true);
}
// 脏值(非布尔 true)一律归一 false
memStorage.setItem(
'xdt:newMakerDraft:v1',
JSON.stringify({ vendor: 'cc', worktreeEnabled: 'yes' }),
);
vi.resetModules();
{
const { getDraft } = await loadModule();
expect(getDraft().worktreeEnabled).toBe(false);
expect(getDraft().worktreePreferenceCustomized).toBe(false);
}
});
it('通用草稿 patch 不能改动 worktree 偏好', async () => {
vi.resetModules();
const { getDraft, patchDraft, setWorktreePreference } = await loadModule();
patchDraft({ worktreeEnabled: true, worktreePreferenceCustomized: true });
expect(getDraft().worktreeEnabled).toBe(false);
expect(getDraft().worktreePreferenceCustomized).toBe(false);
setWorktreePreference(true);
patchDraft({ worktreeEnabled: false, worktreePreferenceCustomized: false });
expect(getDraft().worktreeEnabled).toBe(true);
expect(getDraft().worktreePreferenceCustomized).toBe(true);
});
it('旧 false 快照不固化默认,旧 true 迁移为显式 override', async () => {
memStorage.setItem(
'xdt:newMakerDraft:v1',
JSON.stringify({ vendor: 'cc', worktreeEnabled: false }),
);
vi.resetModules();
{
const { getDraft, patchDraft } = await loadModule();
expect(getDraft().worktreeEnabled).toBe(false);
expect(getDraft().worktreePreferenceCustomized).toBe(false);
patchDraft({ workingDir: '/projects/default-following' });
expect(
JSON.parse(memStorage.getItem('xdt:newMakerDraft:v1') ?? '{}'),
).toMatchObject({
worktreeEnabled: false,
worktreePreferenceCustomized: false,
});
}
memStorage.setItem(
'xdt:newMakerDraft:v1',
JSON.stringify({ vendor: 'cc', worktreeEnabled: true }),
);
vi.resetModules();
{
const { getDraft } = await loadModule();
expect(getDraft().worktreeEnabled).toBe(true);
expect(getDraft().worktreePreferenceCustomized).toBe(true);
}
});
it('customized=false 时忽略旧快照布尔并重新采用系统默认', async () => {
memStorage.setItem(
'xdt:newMakerDraft:v1',
JSON.stringify({
vendor: 'cc',
worktreeEnabled: true,
worktreePreferenceCustomized: false,
}),
);
vi.resetModules();
const { getDraft } = await loadModule();
expect(getDraft().worktreeEnabled).toBe(false);
expect(getDraft().worktreePreferenceCustomized).toBe(false);
});
it('附属窗口的过期草稿写入不会覆盖另一个窗口刚保存的 worktree 偏好', async () => {
// 两次 import 模拟两个 Electron renderer:模块内存独立,localStorage 共享。
const staleWindow = await loadModule();
vi.resetModules();
const activeWindow = await loadModule();
activeWindow.setWorktreePreference(true);
expect(staleWindow.getDraft().worktreeEnabled).toBe(false);
// storage event 尚未送达时,旧窗口修改任意其它字段;写入前必须从共享持久值
// rebase worktreeEnabled,不能把旧 false 随完整草稿快照覆盖回去。
staleWindow.patchVendorPrefs('cc', { effort: 'high' });
expect(staleWindow.getDraft().worktreeEnabled).toBe(true);
expect(
JSON.parse(memStorage.getItem(staleWindow.__STORAGE_KEY) ?? '{}'),
).toMatchObject({
worktreeEnabled: true,
worktreePreferenceCustomized: true,
});
});
it('旧窗口的完整草稿写入不会覆盖另一窗口刚保存的默认模型组合', async () => {
// 两个 renderer 的模块内存独立;旧窗口仍停在未自定义的 cc 草稿。
const staleWindow = await loadModule();
vi.resetModules();
const activeWindow = await loadModule();
activeWindow.markDefaultTupleCustomized();
activeWindow.switchVendor('pi');
activeWindow.patchVendorPrefs('pi', {
model: 'grok-4.6',
providerId: 'xai',
effort: 'high',
});
activeWindow.setEffortForModel('grok-4.6', 'high');
activeWindow.setFastModeForModel('grok-4.6', true);
expect(staleWindow.getDraft().defaultTupleCustomized).toBe(false);
// storage event 尚未送达时,旧窗口只改无关的工作目录。完整写入前必须把用户组合
// 整体 rebase,不能只保住 marker 而丢 Harness / 来源 / 模型 / 深度 / Fast。
staleWindow.patchDraft({ workingDir: '/projects/stale-window' });
const expectedTuple = {
vendor: 'pi',
defaultTupleCustomized: true,
defaultTupleSelectionCustomized: true,
modelChosenByVendor: { pi: true },
effortByModel: { 'grok-4.6': 'high' },
fastModeByModel: { 'grok-4.6': true },
lastByVendor: {
pi: expect.objectContaining({
model: 'grok-4.6',
providerId: 'xai',
effort: 'high',
}),
},
};
expect(staleWindow.getDraft()).toMatchObject(expectedTuple);
expect(staleWindow.getDraft().workingDir).toBe('/projects/stale-window');
expect(
JSON.parse(memStorage.getItem(staleWindow.__STORAGE_KEY) ?? '{}'),
).toMatchObject(expectedTuple);
});
it('旧窗口的无关写入不会复活另一窗口已恢复推荐的 tuple', async () => {
const activeWindow = await loadModule();
activeWindow.setEffortForModel('legacy-model', 'high');
activeWindow.markDefaultTupleCustomized(false);
vi.resetModules();
const staleWindow = await loadModule();
expect(staleWindow.getDraft().defaultTupleCustomized).toBe(true);
activeWindow.clearDefaultTupleTuningCustomization({
modelId: 'legacy-model',
hasExternalOverrides: false,
});
const restoredTuple = {
vendor: activeWindow.getDraft().vendor,
defaultTupleCustomized: false,
defaultTupleSelectionCustomized: false,
modelChosenByVendor: {},
effortByModel: {},
fastModeByModel: {},
lastByVendor: activeWindow.getDraft().lastByVendor,
};
// storage event 尚未到达 B;仅改工作目录时必须采用 A 已写入的完整恢复结果。
staleWindow.patchDraft({ workingDir: '/projects/after-restore' });
expect(staleWindow.getDraft()).toMatchObject(restoredTuple);
expect(staleWindow.getDraft().workingDir).toBe('/projects/after-restore');
expect(JSON.parse(memStorage.getItem(staleWindow.__STORAGE_KEY) ?? '{}')).toMatchObject(
restoredTuple,
);
});
it('旧窗口在恢复推荐后明确选模时,只写入这次新的 tuple 意图', async () => {
const activeWindow = await loadModule();
activeWindow.setEffortForModel('legacy-model', 'high');
activeWindow.markDefaultTupleCustomized(false);
vi.resetModules();
const staleWindow = await loadModule();
activeWindow.clearDefaultTupleTuningCustomization({
modelId: 'legacy-model',
hasExternalOverrides: false,
});
staleWindow.patchVendorPrefs('cc', {
model: 'claude-new-choice',
providerId: 'anthropic',
effort: 'xhigh',
});
expect(staleWindow.getDraft()).toMatchObject({
defaultTupleCustomized: true,
defaultTupleSelectionCustomized: true,
modelChosenByVendor: { cc: true },
effortByModel: {},
fastModeByModel: {},
lastByVendor: {
cc: expect.objectContaining({
model: 'claude-new-choice',
providerId: 'anthropic',
effort: 'xhigh',
}),
},
});
});
it('旧窗口在恢复推荐后切 Harness 时,不用旧闭包污染最新来源槽', async () => {
const activeWindow = await loadModule();
activeWindow.setEffortForModel('legacy-model', 'high');
activeWindow.markDefaultTupleCustomized(false);
vi.resetModules();
const staleWindow = await loadModule();
activeWindow.clearDefaultTupleTuningCustomization({
modelId: 'legacy-model',
hasExternalOverrides: false,
});
activeWindow.applySuggestedDefaultTuple({
vendor: 'pi',
model: 'z-ai/glm-5.3-flash',
providerId: 'xd',
effort: 'medium',
});
// B 仍渲染着旧 cc tuple,但这次明确意图只有“切到 Codex”。切换前必须采用 A 的
// 最新 Pi tuple,不能把旧 cc prefs 填进 Pi 槽。
staleWindow.markDefaultTupleCustomized();
staleWindow.switchVendor('codex');
const expected = {
vendor: 'codex',
defaultTupleCustomized: true,
lastByVendor: {
pi: expect.objectContaining({
model: 'z-ai/glm-5.3-flash',
providerId: 'xd',
effort: 'medium',
}),
},
};
expect(staleWindow.getDraft()).toMatchObject(expected);
expect(JSON.parse(memStorage.getItem(staleWindow.__STORAGE_KEY) ?? '{}')).toMatchObject(
expected,
);
});
it('旧窗口选择界面所示 Harness 时,仍按最新持久状态执行切换', async () => {
const activeWindow = await loadModule();
activeWindow.setEffortForModel('legacy-model', 'high');
activeWindow.markDefaultTupleCustomized(false);
vi.resetModules();
const staleWindow = await loadModule();
expect(staleWindow.getDraft().vendor).toBe('cc');
activeWindow.clearDefaultTupleTuningCustomization({
modelId: 'legacy-model',
hasExternalOverrides: false,
});
activeWindow.applySuggestedDefaultTuple({
vendor: 'pi',
model: 'z-ai/glm-5.3-flash',
providerId: 'xd',
effort: 'medium',
});
// B 仍显示 cc,用户明确点 cc。调用方必须始终进入 switchVendor,让它先看到真实 Pi
// 再切回 cc;若用旧 draft.vendor 预判,这次明确意图会被错误跳过。
staleWindow.switchVendor('cc');
staleWindow.patchVendorPrefs('cc', {
model: 'claude-new-choice',
providerId: 'anthropic',
effort: 'high',
});
expect(staleWindow.getDraft()).toMatchObject({
vendor: 'cc',
defaultTupleCustomized: true,
modelChosenByVendor: { cc: true },
lastByVendor: {
cc: expect.objectContaining({
model: 'claude-new-choice',
providerId: 'anthropic',
}),
pi: expect.objectContaining({
model: 'z-ai/glm-5.3-flash',
providerId: 'xd',
}),
},
});
});
it('旧窗口的内联控件按界面 Harness 写入,不串到最新持久 Harness', async () => {
const activeWindow = await loadModule();
activeWindow.setEffortForModel('legacy-model', 'high');
activeWindow.markDefaultTupleCustomized(false);
vi.resetModules();
const staleWindow = await loadModule();
const renderedVendor = staleWindow.getDraft().vendor;
expect(renderedVendor).toBe('cc');
activeWindow.clearDefaultTupleTuningCustomization({
modelId: 'legacy-model',
hasExternalOverrides: false,
});
activeWindow.applySuggestedDefaultTuple({
vendor: 'pi',
model: 'z-ai/glm-5.3-flash',
providerId: 'xd',
effort: 'medium',
});
// 模拟 classic/inline 回调:marker 会先 rebase 到 Pi,但后续必须按渲染时捕获的 cc
// 执行切换并写 cc 槽,不能用 rebase 后的 currentDraft.vendor 把值串进 Pi。
staleWindow.markDefaultTupleCustomized();
staleWindow.switchVendor(renderedVendor);
staleWindow.patchVendorPrefs(renderedVendor, {
model: 'claude-inline-choice',
providerId: 'anthropic',
effort: 'xhigh',
});
expect(staleWindow.getDraft()).toMatchObject({
vendor: 'cc',
defaultTupleCustomized: true,
modelChosenByVendor: { cc: true },
lastByVendor: {
cc: expect.objectContaining({
model: 'claude-inline-choice',
providerId: 'anthropic',
effort: 'xhigh',
}),
pi: expect.objectContaining({
model: 'z-ai/glm-5.3-flash',
providerId: 'xd',
effort: 'medium',
}),
},
});
});
it('旧窗口切 Fast 时回到界面 Harness,并保留最新 Pi 默认', async () => {
const activeWindow = await loadModule();
activeWindow.setEffortForModel('legacy-model', 'high');
activeWindow.markDefaultTupleCustomized(false);
vi.resetModules();
const staleWindow = await loadModule();
const renderedVendor = staleWindow.getDraft().vendor;
activeWindow.clearDefaultTupleTuningCustomization({
modelId: 'legacy-model',
hasExternalOverrides: false,
});
activeWindow.applySuggestedDefaultTuple({
vendor: 'pi',
model: 'z-ai/glm-5.3-flash',
providerId: 'xd',
effort: 'medium',
});
// 模拟 Fast handler:先标记调档,再确保当前 Harness 是用户仍看见的 cc,最后写模型记忆。
staleWindow.markDefaultTupleCustomized(false);
staleWindow.switchVendor(renderedVendor);
staleWindow.setFastModeForModel('claude-visible-model', true);
expect(staleWindow.getDraft()).toMatchObject({
vendor: 'cc',
defaultTupleCustomized: true,
fastModeByModel: { 'claude-visible-model': true },
lastByVendor: {
pi: expect.objectContaining({
model: 'z-ai/glm-5.3-flash',
providerId: 'xd',
}),
},
});
});
it('旧窗口改权限等非 tuple 字段时,只更新界面 Harness 槽', async () => {
const activeWindow = await loadModule();
activeWindow.setEffortForModel('legacy-model', 'high');
activeWindow.markDefaultTupleCustomized(false);
vi.resetModules();
const staleWindow = await loadModule();
activeWindow.clearDefaultTupleTuningCustomization({
modelId: 'legacy-model',
hasExternalOverrides: false,
});
activeWindow.applySuggestedDefaultTuple({
vendor: 'pi',
model: 'z-ai/glm-5.3-flash',
providerId: 'xd',
effort: 'medium',
});
staleWindow.patchVendorPrefs('cc', { permissionMode: 'bypassPermissions' });
expect(staleWindow.getDraft()).toMatchObject({
vendor: 'pi',
defaultTupleCustomized: false,
lastByVendor: {
cc: expect.objectContaining({ permissionMode: 'bypassPermissions' }),
pi: expect.objectContaining({
model: 'z-ai/glm-5.3-flash',
providerId: 'xd',
}),
},
});
});
it('preserving 活动同步基于恢复后的 tuple,不带回旧 marker 和调档', async () => {
const activeWindow = await loadModule();
activeWindow.setEffortForModel('legacy-model', 'high');
activeWindow.markDefaultTupleCustomized(false);
vi.resetModules();
const staleWindow = await loadModule();
activeWindow.clearDefaultTupleTuningCustomization({
modelId: 'legacy-model',
hasExternalOverrides: false,
});
staleWindow.patchVendorPrefsPreservingModelChoice('cc', { effort: 'medium' });
expect(staleWindow.getDraft()).toMatchObject({
defaultTupleCustomized: false,
defaultTupleSelectionCustomized: false,
modelChosenByVendor: {},
effortByModel: {},
fastModeByModel: {},
lastByVendor: {
cc: expect.objectContaining({ effort: 'medium' }),
},
});
});
it('旧窗口只清调档但未解锁时仍保住另一窗口的新默认组合', async () => {
const staleWindow = await loadModule();
staleWindow.setEffortForModel('legacy-model', 'high');
vi.resetModules();
const activeWindow = await loadModule();
activeWindow.markDefaultTupleCustomized();
activeWindow.switchVendor('pi');
activeWindow.patchVendorPrefs('pi', {
model: 'grok-4.6',
providerId: 'xai',
effort: 'high',
});
// staleWindow 自己仍是 false,所以这不是合法的 true → false 解锁;清理写入也必须 rebase。
staleWindow.clearDefaultTupleTuningCustomization({
modelId: 'legacy-model',
hasExternalOverrides: true,
});
expect(staleWindow.getDraft()).toMatchObject({
vendor: 'pi',
defaultTupleCustomized: true,
defaultTupleSelectionCustomized: true,
modelChosenByVendor: { pi: true },
lastByVendor: {
pi: expect.objectContaining({ model: 'grok-4.6', providerId: 'xai' }),
},
});
});
it('远程 worktree 广播不会让旧窗口回滚持久草稿或 main 偏好镜像', async () => {
// 先让附属窗口持有旧的模型/目录,再由活跃窗口保存新值;两个模块实例模拟两个 renderer。
const staleWindow = await loadModule();
staleWindow.patchDraft({ workingDir: '/projects/stale' });
staleWindow.patchVendorPrefs('cc', { model: 'claude-stale' });
vi.resetModules();
const activeWindow = await loadModule();
activeWindow.patchDraft({ workingDir: '/projects/current' });
activeWindow.patchVendorPrefs('cc', { model: 'claude-current' });
expect(staleWindow.getDraft().workingDir).toBe('/projects/stale');
expect(staleWindow.getDraft().lastByVendor.cc.model).toBe('claude-stale');
// main 广播会让所有窗口依次执行 setter。每个窗口都只能基于共享持久对象合并布尔字段,
// 不能把各自完整 currentDraft 写回。
activeWindow.setWorktreePreference(true);
staleWindow.setWorktreePreference(true);
const persisted = JSON.parse(
memStorage.getItem(staleWindow.__STORAGE_KEY) ?? '{}',
) as {
workingDir?: string;
worktreeEnabled?: boolean;
worktreePreferenceCustomized?: boolean;
lastByVendor?: { cc?: { model?: string } };
};
expect(persisted.workingDir).toBe('/projects/current');
expect(persisted.lastByVendor?.cc?.model).toBe('claude-current');
expect(persisted.worktreeEnabled).toBe(true);
expect(persisted.worktreePreferenceCustomized).toBe(true);
// 旧窗口的临时内存仍可保持不同,但 App 向 main 同步时必须读取同一份持久真相。
expect(staleWindow.getDraft().workingDir).toBe('/projects/stale');
expect(staleWindow.getDraftForPreferenceSync().workingDir).toBe('/projects/current');
expect(staleWindow.getDraftForPreferenceSync().lastByVendor.cc.model).toBe(
'claude-current',
);
expect(activeWindow.getDraftForPreferenceSync()).toEqual(
staleWindow.getDraftForPreferenceSync(),
);
});
it('worktree 单字段落盘失败时 main 只回退该布尔,不回退旧窗口整份草稿', async () => {
const staleWindow = await loadModule();
staleWindow.patchDraft({ workingDir: '/projects/stale' });
staleWindow.patchVendorPrefs('cc', { model: 'claude-stale' });
vi.resetModules();
const activeWindow = await loadModule();
activeWindow.patchDraft({ workingDir: '/projects/current' });
activeWindow.patchVendorPrefs('cc', { model: 'claude-current' });
vi.spyOn(memStorage, 'setItem').mockImplementationOnce(() => {
throw new Error('quota exceeded');
});
staleWindow.setWorktreePreference(true);
const syncDraft = staleWindow.getDraftForPreferenceSync();
expect(syncDraft.worktreeEnabled).toBe(true);
expect(syncDraft.worktreePreferenceCustomized).toBe(true);
expect(syncDraft.workingDir).toBe('/projects/current');
expect(syncDraft.lastByVendor.cc.model).toBe('claude-current');
expect(staleWindow.getDraft().workingDir).toBe('/projects/stale');
});
it('storage event 会把其它窗口保存的 worktree 偏好同步进当前 store 并通知订阅者', async () => {
let onStorage: ((event: StorageEvent) => void) | undefined;
const removeEventListener = vi.fn();
vi.stubGlobal('window', {
localStorage: memStorage,
addEventListener: (
type: string,
listener: EventListenerOrEventListenerObject,
) => {
if (type === 'storage' && typeof listener === 'function') {
onStorage = listener as (event: StorageEvent) => void;
}
},
removeEventListener,
});
vi.resetModules();
const draftStore = await loadModule();
const subscriber = vi.fn();
draftStore.subscribeDraft(subscriber);
const serialized = JSON.stringify({
...draftStore.getDraft(),
worktreeEnabled: true,
worktreePreferenceCustomized: true,
vendor: 'pi',
defaultTupleCustomized: true,
defaultTupleSelectionCustomized: true,
modelChosenByVendor: { pi: true },
effortByModel: { 'grok-4.6': 'high' },
fastModeByModel: { 'grok-4.6': true },
lastByVendor: {
...draftStore.getDraft().lastByVendor,
pi: {
...draftStore.getDraft().lastByVendor.pi,
model: 'grok-4.6',
providerId: 'xai',
effort: 'high',
},
},
});
memStorage.setItem(draftStore.__STORAGE_KEY, serialized);
onStorage?.({
key: draftStore.__STORAGE_KEY,
newValue: serialized,
} as StorageEvent);
expect(draftStore.getDraft().worktreeEnabled).toBe(true);
expect(draftStore.getDraft().worktreePreferenceCustomized).toBe(true);
expect(draftStore.getDraft()).toMatchObject({
vendor: 'pi',
defaultTupleCustomized: true,
defaultTupleSelectionCustomized: true,
modelChosenByVendor: { pi: true },
effortByModel: { 'grok-4.6': 'high' },
fastModeByModel: { 'grok-4.6': true },
lastByVendor: {
pi: expect.objectContaining({
model: 'grok-4.6',
providerId: 'xai',
effort: 'high',
}),
},
});
expect(subscriber).toHaveBeenCalledTimes(1);
// 旧 false 事件若迟到,当前 localStorage 的 true 仍是权威值,不得回滚内存或 main 镜像。
subscriber.mockClear();
onStorage?.({
key: draftStore.__STORAGE_KEY,
newValue: JSON.stringify({
...draftStore.getDraft(),
worktreeEnabled: false,
worktreePreferenceCustomized: true,
}),
} as StorageEvent);
expect(draftStore.getDraft().worktreeEnabled).toBe(true);
expect(subscriber).not.toHaveBeenCalled();
});
it('vendor 字段非合法值(非 cc/codex)→ 回退 cc', async () => {
memStorage.setItem('xdt:newMakerDraft:v1', JSON.stringify({ vendor: 'gemini' }));
vi.resetModules();
const { getDraft } = await loadModule();
expect(getDraft().vendor).toBe('cc');
});
it('schema:fastModeByModel 只把 true 当作 enabled,其余值归一为 false', async () => {
memStorage.setItem(
'xdt:newMakerDraft:v1',
JSON.stringify({
fastModeByModel: {
'gpt-5.5': true,
'gpt-5.4': 'true',
'claude-opus-4-7': 1,
},
}),
);
vi.resetModules();
const { getDraft, getFastModeForModel } = await loadModule();
expect(getFastModeForModel('gpt-5.5')).toBe(true);
expect(getFastModeForModel('gpt-5.4')).toBe(false);
expect(getFastModeForModel('claude-opus-4-7')).toBe(false);
expect(getDraft().fastModeByModel).toEqual({
'gpt-5.5': true,
'gpt-5.4': false,
'claude-opus-4-7': false,
});
});
// #807:设备是独立于 workingDir 的一级维度。原先「workingDir 变 null 就无条件清设备」的
// 不变量会把「选设备」这个动作本身打死 —— 选设备传的正是 { deviceId, workingDir: null }。
describe('device-link 设备字段与 workingDir 的关系', () => {
it('显式带设备 + workingDir=null(选设备)→ 设备必须保留', async () => {
const { getDraft, patchDraft } = await loadModule();
patchDraft({
deviceLinkDeviceId: 'dev-a',
deviceLinkDeviceName: 'Studio Mac',
workingDir: null,
});
expect(getDraft().deviceLinkDeviceId).toBe('dev-a');
expect(getDraft().deviceLinkDeviceName).toBe('Studio Mac');
expect(getDraft().workingDir).toBeNull();
});
it('显式带设备 + 具体 workingDir(选该设备上的项目)→ 两者都保留', async () => {
const { getDraft, patchDraft } = await loadModule();
patchDraft({ deviceLinkDeviceId: 'dev-a', deviceLinkDeviceName: 'Studio Mac', workingDir: '/host/proj' });
expect(getDraft().deviceLinkDeviceId).toBe('dev-a');
expect(getDraft().workingDir).toBe('/host/proj');
});
it('改 workingDir 但不带设备字段 → 仍按老规则清设备(防本地项目被误当远程)', async () => {
const { getDraft, patchDraft } = await loadModule();
patchDraft({
deviceLinkDeviceId: 'dev-a',
deviceLinkDeviceName: 'Studio Mac',
workingDir: '/host/proj',
});
patchDraft({ workingDir: '/local/proj' });
expect(getDraft().deviceLinkDeviceId).toBeNull();
expect(getDraft().deviceLinkDeviceName).toBeNull();
});
it('清空 workingDir 且不带设备字段(发送后重置)→ 设备一并清掉', async () => {
const { getDraft, patchDraft } = await loadModule();
patchDraft({ deviceLinkDeviceId: 'dev-a', deviceLinkDeviceName: 'Studio Mac', workingDir: null });
patchDraft({ workingDir: null, extraDirs: [] });
expect(getDraft().deviceLinkDeviceId).toBeNull();
});
it('显式把设备清成 null(回落本机)→ 照常生效', async () => {
const { getDraft, patchDraft } = await loadModule();
patchDraft({ deviceLinkDeviceId: 'dev-a', deviceLinkDeviceName: 'Studio Mac', workingDir: null });
patchDraft({ deviceLinkDeviceId: null, deviceLinkDeviceName: null, workingDir: null });
expect(getDraft().deviceLinkDeviceId).toBeNull();
expect(getDraft().deviceLinkDeviceName).toBeNull();
});
// 协同与项目/对话形态正交:切设备后落到该设备的对话态也不能静默关掉用户选择。
it('选设备但没选项目(对话模式)→ 协同开关保留', async () => {
const { getDraft, patchDraft } = await loadModule();
patchDraft({ workingDir: '/local/proj' });
patchDraft({ collab: { enabled: true, worker: 'cc' } });
patchDraft({ deviceLinkDeviceId: 'dev-a', deviceLinkDeviceName: 'Studio Mac', workingDir: null });
expect(getDraft().collab.enabled).toBe(true);
});
it('选设备上的项目 → 协同开关保留(不再被 device-link 一刀切关掉)', async () => {
const { getDraft, patchDraft } = await loadModule();
patchDraft({ workingDir: '/local/proj' });
patchDraft({ collab: { enabled: true, worker: 'cc' } });
patchDraft({
deviceLinkDeviceId: 'dev-a',
deviceLinkDeviceName: 'Studio Mac',
workingDir: '/host/proj',
});
expect(getDraft().collab.enabled).toBe(true);
expect(getDraft().collab.worker).toBe('cc');
});
// model / providerId / effort / fast 都是设备作用域:原样带到另一台机器会撞被控端的
// 精确 preflight,协同静默降级成单会话 —— 正是 #1170 抱怨的「入口能点但走不完」。
it('换目标设备 → 清掉 Worker 富配置,但保留协同开关与 worker 类型', async () => {
const { getDraft, patchDraft } = await loadModule();
patchDraft({ workingDir: '/local/proj' });
patchDraft({
collab: {
enabled: true,
worker: 'codex',
workerConfig: {
role: 'developer',
model: 'codex/gpt-5.5',
effort: 'high',
fast: false,
providerId: 'prov-local',
initialTask: '先跑一遍测试',
},
},
});
patchDraft({
deviceLinkDeviceId: 'dev-a',
deviceLinkDeviceName: 'Studio Mac',
workingDir: '/host/proj',
});
expect(getDraft().collab.enabled).toBe(true);
expect(getDraft().collab.worker).toBe('codex');
expect(getDraft().collab.workerConfig).toBeUndefined();
});
it('本机 → 设备 A → 设备 B 的每一跳都清 Worker 配置', async () => {
const { getDraft, patchDraft, patchCollab } = await loadModule();
patchDraft({
deviceLinkDeviceId: 'dev-a',
deviceLinkDeviceName: 'Studio Mac',
workingDir: '/host-a/proj',
});
patchCollab({
enabled: true,
worker: 'cc',
workerConfig: { role: 'reviewer', model: 'claude-opus-4-7' },
});
expect(getDraft().collab.workerConfig?.model).toBe('claude-opus-4-7');
patchDraft({
deviceLinkDeviceId: 'dev-b',
deviceLinkDeviceName: 'Laptop',
workingDir: '/host-b/proj',
});
expect(getDraft().collab.workerConfig).toBeUndefined();
expect(getDraft().collab.enabled).toBe(true);
});
it('同一台设备内换项目 → Worker 配置保留(模型目录没变)', async () => {
const { getDraft, patchDraft, patchCollab } = await loadModule();
patchDraft({
deviceLinkDeviceId: 'dev-a',
deviceLinkDeviceName: 'Studio Mac',
workingDir: '/host-a/proj',
});
patchCollab({
enabled: true,
worker: 'cc',
workerConfig: { role: 'reviewer', model: 'claude-opus-4-7' },
});
patchDraft({ deviceLinkDeviceId: 'dev-a', deviceLinkDeviceName: 'Studio Mac', workingDir: '/host-a/other' });
expect(getDraft().collab.workerConfig?.model).toBe('claude-opus-4-7');
});
});
});
it('does not stamp a prior owner draft during the synchronous auth handoff', async () => {
const { setNewMakerDraftOwner, getDraftForOwnerPreferenceSync, patchCurrentVendorPrefs } = await loadModule();
setNewMakerDraftOwner('A');
patchCurrentVendorPrefs({ model: 'owner-a-model' });
expect(getDraftForOwnerPreferenceSync('B')).toBeNull();
setNewMakerDraftOwner('B');
expect(getDraftForOwnerPreferenceSync('B')?.lastByVendor.cc.model).not.toBe('owner-a-model');
expect(getDraftForOwnerPreferenceSync('A')).toBeNull();
});
describe('Bot default model write-through', () => {
async function setup() {
const store = await loadModule();
const owner = await import('@/contexts/dataOwnerGeneration');
owner.setDataOwnerGeneration('bot-owner', 8);
store.setNewMakerDraftOwner('bot-owner');
store.patchVendorPrefs('codex', { model: 'luna', providerId: 'openai', effort: 'medium' });
store.switchVendor('codex');
const route = { harness: 'codex' as const, providerId: 'openai', model: 'luna', effort: 'medium', fastMode: false };
return { store, selection: { requestId: "test-default-selection", route: { ...route, effort: 'low' }, expectedRoute: route,
ownerStamp: { dataOwnerId: 'bot-owner', ownerGeneration: 8 }, expiresAt: Date.now() + 5000 } };
}
it('persists the same default used by new tasks and survives reloading', async () => {
const { store, selection } = await setup();
expect(store.applyAppDefaultModelSelection(selection)).toBe(true);
vi.resetModules();
const reloaded = await loadModule();
reloaded.setNewMakerDraftOwner('bot-owner');
expect(reloaded.getDraft().lastByVendor.codex).toMatchObject({ model: 'luna', effort: 'low', providerId: 'openai' });
expect(reloaded.getDraft().vendor).toBe('codex');
expect(reloaded.getDraft().defaultTupleSelectionCustomized).toBe(true);
});
it.each(['owner', 'expiry', 'selection', 'disk'] as const)('refuses %s changes without reporting success', async reason => {
const { store, selection } = await setup();
if (reason === 'owner') selection.ownerStamp.ownerGeneration = 7;
if (reason === 'expiry') selection.expiresAt = Date.now() - 1;
if (reason === 'selection') store.patchVendorPrefs('codex', { model: 'a-new-user-choice' });
if (reason === 'disk') vi.spyOn(memStorage, 'setItem').mockImplementation(() => { throw new Error('full'); });
const before = store.getDraft();
expect(store.applyAppDefaultModelSelection(selection)).toBe(false);
expect(store.getDraft()).toEqual(before);
});
});
// Agent 在同账号另一台电脑运行:任务、项目与命令仍在本机,只记下运行 Agent 的电脑。
describe('newMakerDraft agent computer', () => {
it('keeps the agent computer across local folder changes and clears it for remote tasks', async () => {
const { getDraft, patchDraft } = await loadModule();
patchDraft({ agentDeviceId: ' dev-b ', agentDeviceName: 'Office Mac' });
expect(getDraft().agentDeviceId).toBe('dev-b');
// 换本机项目:Agent 仍在那台。
patchDraft({ workingDir: '/local/proj' });
expect(getDraft()).toMatchObject({ agentDeviceId: 'dev-b', agentDeviceName: 'Office Mac', workingDir: '/local/proj' });
// 任务改建到远程设备或 SSH 主机时不成立。
patchDraft({ deviceLinkDeviceId: 'dev-a', deviceLinkDeviceName: 'Studio', workingDir: null });
expect(getDraft()).toMatchObject({ agentDeviceId: null, agentDeviceName: null });
patchDraft({ deviceLinkDeviceId: null, deviceLinkDeviceName: null, workingDir: null });
patchDraft({ agentDeviceId: 'dev-b', agentDeviceName: 'Office Mac' });
patchDraft({ workingDir: '/remote/proj', remoteHostId: 'ssh-1' });
expect(getDraft()).toMatchObject({ agentDeviceId: null, remoteHostId: 'ssh-1' });
});
// 远程控制下新建任务:任务建到被控电脑 dev-a,Agent 在第三台电脑 dev-c。
it('keeps the agent computer for a task on a controlled computer until that computer changes', async () => {
const { getDraft, patchDraft } = await loadModule();
patchDraft({ deviceLinkDeviceId: 'dev-a', deviceLinkDeviceName: 'Studio', workingDir: null });
patchDraft({ agentDeviceId: 'dev-c', agentDeviceName: 'Office Mac' });
expect(getDraft()).toMatchObject({ deviceLinkDeviceId: 'dev-a', agentDeviceId: 'dev-c' });
// 同一台被控电脑上换项目(设备字段照样显式带上):Agent 仍在那台。
patchDraft({ deviceLinkDeviceId: 'dev-a', deviceLinkDeviceName: 'Studio', workingDir: '/a/proj' });
expect(getDraft()).toMatchObject({ agentDeviceId: 'dev-c', agentDeviceName: 'Office Mac' });
// 换到另一台被控电脑 / 回到本机:上一台的选择不再适用。
patchDraft({ deviceLinkDeviceId: 'dev-d', deviceLinkDeviceName: 'Lab', workingDir: null });
expect(getDraft()).toMatchObject({ agentDeviceId: null, agentDeviceName: null });
patchDraft({ deviceLinkDeviceId: 'dev-a', deviceLinkDeviceName: 'Studio', workingDir: null });
patchDraft({ agentDeviceId: 'dev-c', agentDeviceName: 'Office Mac' });
patchDraft({ deviceLinkDeviceId: null, deviceLinkDeviceName: null, workingDir: null });
expect(getDraft()).toMatchObject({ agentDeviceId: null, agentDeviceName: null });
});
it('never lets the agent computer be the computer the task is on', async () => {
const { getDraft, patchDraft } = await loadModule();
patchDraft({ deviceLinkDeviceId: 'dev-a', deviceLinkDeviceName: 'Studio', workingDir: null });
patchDraft({ agentDeviceId: 'dev-a', agentDeviceName: 'Studio' });
expect(getDraft()).toMatchObject({ deviceLinkDeviceId: 'dev-a', agentDeviceId: null, agentDeviceName: null });
});
it('does not restore the agent computer after a restart', async () => {
let mod = await loadModule();
mod.patchDraft({ workingDir: '/local/proj', agentDeviceId: 'dev-b', agentDeviceName: 'Office Mac' });
await new Promise((resolve) => setTimeout(resolve, 600));
vi.resetModules();
mod = await loadModule();
expect(mod.getDraft()).toMatchObject({ workingDir: '/local/proj', agentDeviceId: null, agentDeviceName: null });
});
});
// Standard: the new-task preference must survive owner reload without becoming a picker override.
it('persists the default, preserves explicit permissions, isolates owners and restores auto', async () => {
const m = await loadModule();
m.setNewMakerDraftOwner('permission-owner');
m.patchVendorPrefs('cc', { permissionMode: 'acceptEdits' });
m.setNewChatDefaultPermissionMode('bypassPermissions');
expect(m.getDraft().lastByVendor.cc.permissionMode).toBe('acceptEdits');
expect(m.getDraft().lastByVendor.pi.permissionMode).toBe('bypassPermissions');
m.setNewMakerDraftOwner('another-owner');
expect(m.getDraft().lastByVendor.pi.permissionMode).toBe('auto');
m.setNewMakerDraftOwner('permission-owner');
expect(m.getDraft().newChatDefaultPermissionMode).toBe('bypassPermissions');
m.setNewChatDefaultPermissionMode(null);
expect(m.getDraft().lastByVendor.pi.permissionMode).toBe('auto');
expect(m.getDraft().lastByVendor.cc.permissionMode).toBe('acceptEdits');
m.setNewMakerDraftOwner('another-owner');
m.setNewMakerDraftOwner('permission-owner');
expect(m.getDraft().newChatDefaultPermissionMode).toBeNull();
expect(m.getDraft().lastByVendor.pi.permissionMode).toBe('auto');
});