feat: v0.7.2 安全收口 · 断链接线 · 观测补洞 — 230 用例扩充与全量回归
CI / 类型检查 + Lint + 单元测试 (push) Failing after 5m43s
CI / 全量测试 (Electron ABI) (push) Failing after 5m25s
CI / 产物编译验证 (push) Successful in 10m1s

P1 修复面收口: /clear 全链路根治(前端清空联动 DB messages+摘要游标+TRACE 快照,
IPC 语义改"操作完成"; 流式中拒绝); web_browser open 补 SSRF 校验(Chromium 旁路关闭,
与 web_fetch/http_request 同源 validateSSRF); MCP 工具结果纳入注入扫描(mcp_* 前缀
按网络来源同级 full 模式, 收敛 resolveScanMode 单点); Trace 落库/入 store 双重瘦身
(tool_result base64/超长字段剥离, metadata 防 MB 级膨胀); 文本附件 512KB 闸门
(file.slice 首段读取+truncated 标志随消息持久化+主进程附件提示感知截断);
单实例锁(requestSingleInstanceLock + second-instance 聚焦已有窗口)

P2 安全纵深: ConfirmationHook 多窗口化(确认请求/超时提示改全窗口广播,
getAllWindows 空时回退 mainWindow, fail-closed 判定升级双通道); mcp_servers.headers
全链路接线(safeParseHeaders 容错解析+SSE/StreamableHTTP requestInit 注入+IPC 逐项
校验+设置页 JSON 输入, 远程 MCP 鉴权头可用)

P3 断链接线: llm:listModels IPC(六家 adapter 动态模型发现首次接线, 配置完整性
前置校验); Ollama pullModel IPC+设置页下载卡片(进度/取消/能力徽标, v0.7.0 死代码
激活); 后台会话运行指示(sessionRunStates 图+Sidebar 状态点, 多会话并发可见);
IR 卫生(移除 THINKING_START/END 死枚举, constraints 标注预留)

P4 质量与文档: i18n 第二阶段(确认弹框/侧栏/状态栏/AgentMonitor/终止原因出层,
外观设置 zh-CN/en-US 切换, ui.locale 持久化, 渲染时求值规避异步注册); README/D1
文档对齐(http_request 风险等级/用例数/实现状态注记); 版本号 0.7.2

测试: 507 → 737 用例(+230, 11 个新文件)。覆盖补齐: context-builder/consolidator/
orchestrator/workspace.service/session-recorder/config-layering/secure-config/
network-proxy + IPC mcp/tasks/memory/app/data 域 + 渲染层 store 与流事件管线纯函数。
测试驱动修复: workspace.appendMemory 中文分区 \b 词边界失效(JS \b 不含 CJK),
固化条目恒追加文件末尾产生重复分区头 → (?=\n|$) 前瞻断言根治

回归: typecheck 双端 0 错误; ESLint 0/0; 系统 Node 687 通过 50 跳过;
Electron ABI 全量 737/737 零跳过
This commit is contained in:
2026-08-30 00:09:25 +08:00
parent 36e4b28d93
commit 26169b7be4
55 changed files with 5673 additions and 434 deletions
@@ -0,0 +1,411 @@
/**
* IPC 域 Handler 测试(v0.7.2 P4-14 覆盖补齐)
*
* sessions / tools / config 三个域此前零测试。本文件锁定三类契约:
* 1. 参数校验矩阵(M-34/M-35/M-42 系列修复的回归防线)—— 非法输入被拒绝
* 且不触达 service 层
* 2. v0.7.2 A1 语义修正 —— sessions:clearMessages 的成功判定是"操作完成"
* 而非"有行被删除"(空会话清空同样 success:true
* 3. tools:toggle / setAutoExecute 的未知工具拒绝(防配置 key 污染)与
* config:set/setBatch 的类型校验、敏感值脱敏审计
*/
import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest';
// ===== Mock electronipcMain =====
const ipcMainHandleMock = vi.fn();
const ipcMainOnMock = vi.fn();
vi.mock('electron', () => ({
ipcMain: {
handle: (...args: unknown[]) => ipcMainHandleMock(...args),
on: (...args: unknown[]) => ipcMainOnMock(...args),
},
}));
// ===== Mock broadcastipc/contextshared.ts 的 config:changed 广播) =====
const broadcastMock = vi.fn();
vi.mock('../context', () => ({
broadcast: (...args: unknown[]) => broadcastMock(...args),
}));
import { registerSessionHandlers } from '../sessions';
import { registerToolHandlers } from '../tools';
import { registerConfigHandlers } from '../config';
import type { IPCContext } from '../context';
function getHandler(channel: string): (...args: unknown[]) => Promise<unknown> {
const call = ipcMainHandleMock.mock.calls.find(([ch]) => ch === channel);
if (!call) throw new Error(`IPC handler not registered: ${channel}`);
return call[1] as (...args: unknown[]) => Promise<unknown>;
}
function getListener(channel: string): (...args: unknown[]) => void {
const call = ipcMainOnMock.mock.calls.find(([ch]) => ch === channel);
if (!call) throw new Error(`IPC listener not registered: ${channel}`);
// ipcMain.on 处理器签名 (event, ...args) —— 返回宽松签名以便按双参调用
return call[1] as (...args: unknown[]) => void;
}
beforeEach(() => {
ipcMainHandleMock.mockClear();
ipcMainOnMock.mockClear();
broadcastMock.mockClear();
});
// ===== sessions 域 =====
describe('sessions 域 — 参数校验矩阵', () => {
function makeCtx(): { ctx: IPCContext; raw: Record<string, unknown> } {
const raw = {
sessionService: {
list: vi.fn(() => []),
create: vi.fn(),
rename: vi.fn(() => true),
delete: vi.fn(() => true),
getMessages: vi.fn(() => []),
pin: vi.fn(() => true),
archive: vi.fn(() => true),
deleteMessage: vi.fn(() => true),
clearMessages: vi.fn(),
truncateMessagesAfter: vi.fn(() => true),
searchMessages: vi.fn(() => []),
saveTraceData: vi.fn(),
getTraceData: vi.fn(() => null),
},
};
return { ctx: raw as unknown as IPCContext, raw };
}
it('rename / delete / pin / archive 对非法 sessionId 拒绝且不触达 service', async () => {
const { ctx, raw } = makeCtx();
registerSessionHandlers(ctx);
const svc = raw.sessionService as Record<string, Mock>;
for (const bad of [null, undefined, 123, '', 'x'.repeat(201)]) {
expect(await getHandler('sessions:rename')(null, bad, 't')).toMatchObject({ success: false });
expect(await getHandler('sessions:delete')(null, bad)).toMatchObject({ success: false });
expect(await getHandler('sessions:pin')(null, bad, true)).toMatchObject({ success: false });
expect(await getHandler('sessions:archive')(null, bad, true)).toMatchObject({
success: false,
});
}
expect(svc.rename).not.toHaveBeenCalled();
expect(svc.delete).not.toHaveBeenCalled();
expect(svc.pin).not.toHaveBeenCalled();
expect(svc.archive).not.toHaveBeenCalled();
});
it('rename 拒绝空 titlepin/archive 拒绝非布尔', async () => {
const { ctx, raw } = makeCtx();
registerSessionHandlers(ctx);
const svc = raw.sessionService as Record<string, Mock>;
expect(await getHandler('sessions:rename')(null, 's1', ' ')).toMatchObject({ success: false });
expect(await getHandler('sessions:pin')(null, 's1', 'yes')).toMatchObject({ success: false });
expect(await getHandler('sessions:archive')(null, 's1', 1)).toMatchObject({ success: false });
expect(svc.rename).not.toHaveBeenCalled();
expect(svc.pin).not.toHaveBeenCalled();
expect(svc.archive).not.toHaveBeenCalled();
});
it('getMessages 对非法 sessionId 返回空数组;合法调用透传', async () => {
const { ctx, raw } = makeCtx();
registerSessionHandlers(ctx);
const svc = raw.sessionService as Record<string, Mock>;
expect(await getHandler('sessions:getMessages')(null, 42)).toEqual([]);
await getHandler('sessions:getMessages')(null, 's1');
expect(svc.getMessages).toHaveBeenCalledWith('s1');
});
it('saveTrace 严格校验:traceSteps 必须为数组且 tokenUsage 必填', async () => {
const { ctx, raw } = makeCtx();
registerSessionHandlers(ctx);
const svc = raw.sessionService as Record<string, Mock>;
expect(await getHandler('sessions:saveTrace')(null, 's1', null)).toMatchObject({
success: false,
});
expect(await getHandler('sessions:saveTrace')(null, 's1', { tokenUsage: {} })).toMatchObject({
success: false,
});
expect(await getHandler('sessions:saveTrace')(null, 's1', { traceSteps: 'x' })).toMatchObject({
success: false,
});
expect(svc.saveTraceData).not.toHaveBeenCalled();
await getHandler('sessions:saveTrace')(null, 's1', {
traceSteps: [],
tokenUsage: { totalTokens: 0 },
});
expect(svc.saveTraceData).toHaveBeenCalledWith('s1', {
traceSteps: [],
tokenUsage: { totalTokens: 0 },
});
});
});
describe('sessions:clearMessages — v0.7.2 A1 语义修正', () => {
function makeCtx(): IPCContext {
return {
sessionService: { clearMessages: vi.fn() },
} as unknown as IPCContext;
}
it('操作完成即 success:true(空会话 / 0 行删除同样是成功)', async () => {
registerSessionHandlers(makeCtx());
const result = await getHandler('sessions:clearMessages')(null, 's1');
expect(result).toEqual({ success: true });
});
it('service 抛错 → success:false + 错误信息', async () => {
const ctx = {
sessionService: {
clearMessages: vi.fn(() => {
throw new Error('db locked');
}),
},
} as unknown as IPCContext;
registerSessionHandlers(ctx);
const result = await getHandler('sessions:clearMessages')(null, 's1');
expect(result).toEqual({ success: false, error: 'db locked' });
});
it('非法 sessionId 拒绝且不触达 service', async () => {
const ctx = makeCtx();
registerSessionHandlers(ctx);
const result = await getHandler('sessions:clearMessages')(null, '');
expect(result).toMatchObject({ success: false });
expect(
(ctx.sessionService as unknown as { clearMessages: Mock }).clearMessages,
).not.toHaveBeenCalled();
});
});
// ===== tools 域 =====
describe('tools 域 — 工具开关与确认链路', () => {
const TOOL_A = {
name: 'write_file',
description: 'd',
category: 'filesystem',
riskLevel: 'medium',
requiresPermission: true,
enabled: true,
};
const TOOL_B = { ...TOOL_A, name: 'run_command', riskLevel: 'high' };
function makeCtx(): { ctx: IPCContext; raw: Record<string, unknown> } {
const raw = {
toolRegistry: {
listAllTools: vi.fn(() => [TOOL_A, TOOL_B]),
listTools: vi.fn(() => [TOOL_A, TOOL_B]),
setToolEnabled: vi.fn(),
},
confirmationHook: {
resolveConfirmation: vi.fn(),
resolveConfirmationsBatch: vi.fn(() => ['tc_1']),
getPendingConfirmations: vi.fn(() => []),
getRememberedDenials: vi.fn(() => []),
resetRememberedDenial: vi.fn(() => true),
setAutoExecute: vi.fn(),
getAutoExecuteList: vi.fn(() => []),
},
agentEngineManager: { setToolsAll: vi.fn() },
configService: { set: vi.fn() },
toolsReadyRef: { ready: true, toolCount: 2 },
};
return { ctx: raw as unknown as IPCContext, raw };
}
it('tools:list 透传字段', async () => {
const { ctx } = makeCtx();
registerToolHandlers(ctx);
const list = (await getHandler('tools:list')(null)) as Array<Record<string, unknown>>;
expect(list).toHaveLength(2);
expect(list[0]).toMatchObject({ name: 'write_file', riskLevel: 'medium', enabled: true });
});
it('tools:toggle 未知工具拒绝(防配置 key 污染)且不触达 registry/config', async () => {
const { ctx, raw } = makeCtx();
registerToolHandlers(ctx);
const r = await getHandler('tools:toggle')(null, 'not_a_tool', true);
expect(r).toMatchObject({ success: false });
expect((raw.configService as { set: Mock }).set).not.toHaveBeenCalled();
expect((raw.toolRegistry as { setToolEnabled: Mock }).setToolEnabled).not.toHaveBeenCalled();
});
it('tools:toggle 合法路径:持久化配置 + registry + 引擎工具列表三处同步', async () => {
const { ctx, raw } = makeCtx();
registerToolHandlers(ctx);
const r = await getHandler('tools:toggle')(null, 'write_file', false);
expect(r).toEqual({ success: true });
expect((raw.configService as { set: Mock }).set).toHaveBeenCalledWith(
'tools.write_file.enabled',
false,
);
expect((raw.toolRegistry as { setToolEnabled: Mock }).setToolEnabled).toHaveBeenCalledWith(
'write_file',
false,
);
expect((raw.agentEngineManager as { setToolsAll: Mock }).setToolsAll).toHaveBeenCalled();
});
it('tools:isReady 读取共享就绪引用', async () => {
const { ctx } = makeCtx();
registerToolHandlers(ctx);
expect(await getHandler('tools:isReady')(null)).toEqual({ ready: true, toolCount: 2 });
});
it('tool:confirmationResponse 校验结构(无效载荷被忽略)', async () => {
const { ctx, raw } = makeCtx();
registerToolHandlers(ctx);
const listener = getListener('tool:confirmationResponse');
// 处理器签名 (event, data) —— 首参为 event,载荷在第二参
listener(null, null);
listener(null, { approved: true });
listener(null, { toolCallId: 'tc_1', approved: 'yes' });
const hook = (raw.confirmationHook as { resolveConfirmation: Mock }).resolveConfirmation;
expect(hook).not.toHaveBeenCalled();
listener(null, { toolCallId: 'tc_1', approved: true, remember: true, autoExecute: false });
expect(hook).toHaveBeenCalledWith('tc_1', true, true, false);
});
it('tool:confirmationResponseBatch 校验 toolCallIds 数组', async () => {
const { ctx, raw } = makeCtx();
registerToolHandlers(ctx);
const listener = getListener('tool:confirmationResponseBatch');
const hook = (raw.confirmationHook as { resolveConfirmationsBatch: Mock })
.resolveConfirmationsBatch;
listener(null, { toolCallIds: 'tc_1', approved: true });
listener(null, { toolCallIds: [], approved: true });
listener(null, { toolCallIds: ['tc_1', 42], approved: true });
expect(hook).not.toHaveBeenCalled();
listener(null, { toolCallIds: ['tc_1', 'tc_2'], approved: false, remember: true });
expect(hook).toHaveBeenCalledWith(['tc_1', 'tc_2'], false, true, false);
});
it('tool:setAutoExecute 未知工具拒绝;拒绝记忆接口透传 sessionId', async () => {
const { ctx, raw } = makeCtx();
registerToolHandlers(ctx);
expect(await getHandler('tool:setAutoExecute')(null, 'nope', true)).toMatchObject({
success: false,
});
expect(await getHandler('tool:setAutoExecute')(null, 'write_file', 'yes')).toMatchObject({
success: false,
});
expect(await getHandler('tool:setAutoExecute')(null, 'write_file', true)).toEqual({
success: true,
});
await getHandler('tool:getRememberedDenials')(null, 'sess-9');
expect(
(raw.confirmationHook as { getRememberedDenials: Mock }).getRememberedDenials,
).toHaveBeenCalledWith('sess-9');
});
});
// ===== config 域 =====
describe('config 域 — 配置写入与审计', () => {
function makeCtx(overrides: Record<string, unknown> = {}): {
ctx: IPCContext;
raw: Record<string, unknown>;
} {
const raw = {
configService: {
get: vi.fn((key: string) => (key === 'llm.provider' ? 'deepseek' : null)),
set: vi.fn(),
},
auditService: { log: vi.fn() },
agentEngineManager: { updateConfigAll: vi.fn() },
orchestrator: { updateDefaultConfig: vi.fn() },
confirmationHook: { setConfirmationTimeout: vi.fn() },
reloadAdapter: vi.fn(() => true),
...overrides,
};
return { ctx: raw as unknown as IPCContext, raw };
}
it('config:get / config:set 类型校验矩阵', async () => {
const { ctx, raw } = makeCtx();
registerConfigHandlers(ctx);
await getHandler('config:get')(null, 'ui.theme');
expect((raw.configService as { get: Mock }).get).toHaveBeenCalledWith('ui.theme');
expect(await getHandler('config:set')(null, '', 'x')).toMatchObject({ success: false });
expect(await getHandler('config:set')(null, 'k', { nested: true })).toMatchObject({
success: false,
});
expect((raw.configService as { set: Mock }).set).not.toHaveBeenCalled();
});
it('config:set 敏感值脱敏入审计(明文 API Key 不落审计日志)', async () => {
const { ctx, raw } = makeCtx();
registerConfigHandlers(ctx);
await getHandler('config:set')(null, 'llm.apiKey', 'sk-test-1234567890');
const auditCall = (raw.auditService as { log: Mock }).log.mock.calls[0][0] as {
target: string;
details: { value: unknown };
};
expect(auditCall.target).toBe('llm.apiKey');
expect(auditCall.details.value).toBe('***7890');
});
it('config:setBatch 非法载荷整体拒绝(非数组 / 空 / 坏 key / 坏值类型)', async () => {
const { ctx, raw } = makeCtx();
registerConfigHandlers(ctx);
for (const bad of [null, [], [{ key: '', value: 1 }], [{ key: 'k', value: {} }]]) {
expect(await getHandler('config:setBatch')(null, bad)).toMatchObject({ success: false });
}
expect((raw.configService as { set: Mock }).set).not.toHaveBeenCalled();
});
it('config:setBatch 合法路径:逐条写入 + 审计 + 广播;Provider 变更先清 apiKey', async () => {
const { ctx, raw } = makeCtx();
registerConfigHandlers(ctx);
const r = await getHandler('config:setBatch')(null, [
{ key: 'ui.theme', value: 'light' },
{ key: 'llm.provider', value: 'ollama' },
{ key: 'llm.model', value: 'qwen3:8b' },
]);
expect(r).toEqual({ success: true });
const set = (raw.configService as { set: Mock }).set;
// Provider 变更(deepseek → ollama)在写入前先清 apiKeyC-1 契约)
expect(set).toHaveBeenCalledWith('llm.apiKey', '');
expect(set).toHaveBeenCalledWith('ui.theme', 'light');
expect(set).toHaveBeenCalledWith('llm.provider', 'ollama');
expect(set).toHaveBeenCalledWith('llm.model', 'qwen3:8b');
// 每条写入都有审计记录
expect((raw.auditService as { log: Mock }).log).toHaveBeenCalledTimes(3);
// 配置变更广播到渲染进程(前端 store 实时更新)
const broadcastKeys = broadcastMock.mock.calls
.filter(([ch]) => ch === 'config:changed')
.map(([, payload]) => (payload as { key: string }).key);
expect(broadcastKeys).toEqual(
expect.arrayContaining(['ui.theme', 'llm.provider', 'llm.model']),
);
});
it('config:setBatch 中 LLM key 变更触发 reloadAdapter;失败时整体报错', async () => {
const { ctx, raw } = makeCtx({ reloadAdapter: vi.fn(() => false) });
registerConfigHandlers(ctx);
const r = await getHandler('config:setBatch')(null, [{ key: 'llm.model', value: 'm' }]);
expect(r).toMatchObject({ success: false });
expect(raw.reloadAdapter as Mock).toHaveBeenCalled();
});
});