metona-ai-desktop/electron/ipc/__tests__/sessions-tools-config.test.ts

/**
 * 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 electron（ipcMain） =====
const ipcMainHandleMock = vi.fn();
const ipcMainOnMock = vi.fn();
vi.mock('electron', () => ({
  ipcMain: {
    handle: (...args: unknown[]) => ipcMainHandleMock(...args),
    on: (...args: unknown[]) => ipcMainOnMock(...args),
  },
}));

// ===== Mock broadcast（ipc/context，shared.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 拒绝空 title；pin/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）在写入前先清 apiKey（C-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();
  });
});