metona-ai-desktop/electron/services/__tests__/mcp-security-and-slo.test.ts

/**
 * MCP 命令安全面 + SLO 监控契约测试（v0.7.0 覆盖补齐）
 *
 * mcp-manager 的三个安全纯函数此前零测试（命令白名单/参数元字符检测/
 * env 敏感变量剥离），是 MCP 攻击面的第一道防线 —— 逐条表测锁定。
 * HealthChecker/SLOMonitor 此前为"活代码无契约"，本文件锁定其健康判定与
 * SLO 指标计算（percentile/burnRate/violated/窗口淘汰）。
 */

import { describe, it, expect, vi } from 'vitest';

vi.mock('electron-log', () => ({
  default: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
}));

import {
  safeParseArgs,
  safeParseHeaders,
  validateMcpCommand,
  buildSafeEnv,
  isSensitiveHeaderKey,
  serializeHeadersForStorage,
  parseStoredHeaders,
} from '../mcp-manager.service';
import { SLOMonitor, HealthChecker } from '../../utils/slo';

// ===== MCP：safeParseArgs =====

describe('safeParseArgs — JSON args 解析', () => {
  it('合法 JSON 数组 → string[]', () => {
    expect(safeParseArgs('["--flag","value"]')).toEqual(['--flag', 'value']);
  });

  it('非数组/坏 JSON/空输入 → 空数组兜底', () => {
    expect(safeParseArgs('{"a":1}')).toEqual([]);
    expect(safeParseArgs('not json')).toEqual([]);
    expect(safeParseArgs('')).toEqual([]);
  });
});

// ===== MCP：safeParseHeaders（v0.7.2 P2-8 headers 列接线） =====

describe('safeParseHeaders — headers 列解析', () => {
  it('合法 JSON 对象（键值均为字符串）→ Record<string,string>', () => {
    expect(safeParseHeaders('{"Authorization":"Bearer t1","X-Route":"a"}')).toEqual({
      Authorization: 'Bearer t1',
      'X-Route': 'a',
    });
  });

  it('空输入（null/undefined/空串）→ undefined（匿名连接）', () => {
    expect(safeParseHeaders(null)).toBeUndefined();
    expect(safeParseHeaders(undefined)).toBeUndefined();
    expect(safeParseHeaders('')).toBeUndefined();
  });

  it('非对象/数组/坏 JSON → undefined（不阻断 server 连接）', () => {
    expect(safeParseHeaders('["a","b"]')).toBeUndefined();
    expect(safeParseHeaders('"plain"')).toBeUndefined();
    expect(safeParseHeaders('not json')).toBeUndefined();
    expect(safeParseHeaders('{}')).toBeUndefined(); // 空对象等价匿名
  });

  it('非字符串值逐项丢弃，字符串项保留（部分损坏只损失损坏项）', () => {
    expect(safeParseHeaders('{"ok":"v1","bad":123,"worse":{"x":1}}')).toEqual({ ok: 'v1' });
  });
});

// ===== v0.7.4 P2-5: MCP headers 敏感值加密落库 =====

describe('MCP headers 敏感值加密（P2-5）', () => {
  it('isSensitiveHeaderKey 识别鉴权类键', () => {
    expect(isSensitiveHeaderKey('Authorization')).toBe(true);
    expect(isSensitiveHeaderKey('authorization')).toBe(true);
    expect(isSensitiveHeaderKey('X-API-Key')).toBe(true);
    expect(isSensitiveHeaderKey('Proxy-Authorization')).toBe(true);
    expect(isSensitiveHeaderKey('x-auth-token')).toBe(true);
    expect(isSensitiveHeaderKey('Accept')).toBe(false);
    expect(isSensitiveHeaderKey('Content-Type')).toBe(false);
    expect(isSensitiveHeaderKey('X-Route')).toBe(false);
  });

  it('serializeHeadersForStorage 加密敏感值、普通值明文', () => {
    const stored = JSON.parse(
      serializeHeadersForStorage({
        Authorization: 'Bearer secret-token',
        'X-Route': 'gateway',
      }),
    ) as Record<string, string>;
    // 敏感值带加密前缀（safeStorage 在测试环境不可用则明文 + WARN —— 兼容两种）
    if (stored.Authorization !== 'Bearer secret-token') {
      expect(String(stored.Authorization)).toMatch(/^metona-enc:v1:/);
    }
    expect(stored['X-Route']).toBe('gateway');
  });

  it('parseStoredHeaders 解密加密值、透传明文（历史兼容）', () => {
    // 明文历史数据原样透传
    expect(parseStoredHeaders('{"Authorization":"Bearer plain"}')).toEqual({
      Authorization: 'Bearer plain',
    });
    // 加密值解密还原（若 safeStorage 可用）
    const stored = JSON.parse(serializeHeadersForStorage({ 'X-API-Key': 'k-123456' })) as Record<
      string,
      string
    >;
    const parsed = parseStoredHeaders(JSON.stringify(stored));
    if (String(stored['X-API-Key']).startsWith('metona-enc:v1:')) {
      expect(parsed?.['X-API-Key']).toBe('k-123456');
    } else {
      // safeStorage 不可用时明文存储 —— 行为与 encryptConfigValue 降级一致
      expect(parsed?.['X-API-Key']).toBe('k-123456');
    }
  });
});

// ===== MCP：validateMcpCommand =====

describe('validateMcpCommand — stdio 命令白名单防线', () => {
  it('白名单内命令正常放行；目录前缀剥除后匹配 basename，但扩展名不剥除', () => {
    for (const cmd of ['npx', 'node', 'npm', 'python', 'python3', 'uv', 'uvx', 'bun', 'deno']) {
      expect(() => validateMcpCommand(cmd, [])).not.toThrow();
    }
    // 目录前缀被剥除 → basename 命中白名单
    expect(() =>
      validateMcpCommand('/usr/local/bin/npx', ['-y', '@modelcontextprotocol/server']),
    ).not.toThrow();
    // 现状锁定（比预期更严）：扩展名不参与剥除 —— 'npx.cmd' 不在名单，直接拒绝。
    // 这是当前安全基线的一部分：宁可收紧也不放过任何可执行变体。
    expect(() => validateMcpCommand('C:\tools\npx.cmd', [])).toThrow(/allowed list/);
  });

  it('白名单外命令直接拒绝', () => {
    for (const cmd of ['curl', 'bash', 'sh', 'pwsh', 'cmd', 'powershell.exe', './unknown-server']) {
      expect(() => validateMcpCommand(cmd, [])).toThrow(/not in the allowed list/);
    }
  });

  it('args 中携带 shell 元字符（; & | 反引号 $ 等）拒绝；普通参数放行', () => {
    const evil: Array<string[]> = [
      [';whoami'],
      ['a&b'],
      ['x|cat'],
      ['`id`'],
      ['$HOME'],
      ['<in'],
      ['>out'],
      ['line\nbreak'],
    ];
    for (const args of evil) {
      expect(() => validateMcpCommand('node', ['server.js', ...args])).toThrow();
    }
    expect(() => validateMcpCommand('node', ['server.js', '--port', '3000'])).not.toThrow();
  });
});

// ===== MCP：buildSafeEnv =====

describe('buildSafeEnv — 子进程环境净化', () => {
  it('命中后缀黑名单的敏感键被剔除，其余保留', () => {
    const baseEnv = {
      PATH: '/usr/bin',
      HOME: '/home/u',
      MY_API_KEY: 'sk-secret',
      ACCESS_TOKEN: 'tok',
      DB_PASSWORD: 'p@ss',
      AWS_SECRET_ACCESS_KEY2: 'k',
      DEPLOY_PRIVATE_KEY: '----', // 后缀 _PRIVATE_KEY 命中
      GITEA_CREDENTIALS: '{"u":"x"}', // 后缀 _CREDENTIALS 命中（真实 CI/部署泄漏形态）
      SAFE_NAME: 'keepme',
    };
    vi.stubGlobal('process', { ...process, env: baseEnv as NodeJS.ProcessEnv });
    const env = buildSafeEnv();
    expect(env.PATH).toBe('/usr/bin');
    expect(env.SAFE_NAME).toBe('keepme');
    expect(env.MY_API_KEY).toBeUndefined();
    expect(env.ACCESS_TOKEN).toBeUndefined();
    expect(env.DB_PASSWORD).toBeUndefined();
    expect(env.DEPLOY_PRIVATE_KEY).toBeUndefined();
    expect(env.GITEA_CREDENTIALS).toBeUndefined();
    vi.unstubAllGlobals();
  });
});

// ===== SLOMonitor =====

describe('SLOMonitor — 窗口指标 / 分位数 / 燃烧率', () => {
  function makeMonitor(): SLOMonitor {
    return new SLOMonitor({
      target: 0.99,
      windowMs: 60_000,
      latencyPercentiles: [0.5, 0.95],
      latencyThresholdMs: 5_000,
    });
  }

  it('空窗口：totalRequests=0、errorRate=0、violated=false、burnRate=0', () => {
    const s = makeMonitor().getStatus();
    expect(s.totalRequests).toBe(0);
    expect(s.errorRate).toBe(0);
    expect(s.violated).toBe(false);
    expect(s.burnRate).toBe(0);
  });

  it('统计请求成功率/平均延迟/吞吐量、分位数字段齐全且单调', async () => {
    const m = makeMonitor();
    const t0 = Date.now();
    const latencies = [100, 200, 400, 800, 1600]; // 全成功
    latencies.forEach((ms, i) => {
      m.recordRequest(ms, true);
      void i;
    });
    void t0;
    const s = m.getStatus();
    expect(s.totalRequests).toBe(5);
    expect(s.errorRequests).toBe(0);
    expect(s.avgLatencyMs).toBe(620);
    expect(Object.keys(s.percentiles)).toEqual(['P50', 'P95']);
    expect(s.percentiles['P50']).toBeGreaterThanOrEqual(200);
    expect(s.percentiles['P95']).toBeLessThanOrEqual(1600);
    expect(s.burnRate).toBe(0);
    expect(s.target).toBeCloseTo(0.99);
    expect(s.errorBudget).toBeCloseTo(0.01);
  });

  it('错误率超预算 → burnRate>1 且 violated=true（全错样本：burnRate=100）', async () => {
    const m = new SLOMonitor({
      target: 0.99,
      windowMs: 60_000,
      latencyPercentiles: [0.5],
      latencyThresholdMs: 10_000,
    });
    for (let i = 0; i < 4; i++) m.recordRequest(50 + i, false);
    const s = m.getStatus();
    expect(s.errorRate).toBe(1);
    expect(s.burnRate).toBeGreaterThan(1);
    expect(s.violated).toBe(true);
  });

  it('窗口外记录被淘汰：回到基线 totalRequests=0（真实短窗口计时）', async () => {
    const m = new SLOMonitor({
      target: 0.99,
      windowMs: 50,
      latencyPercentiles: [0.5],
      latencyThresholdMs: 10_000,
    });
    m.recordRequest(100, true);
    m.recordRequest(120, false);
    expect(m.getStatus().totalRequests).toBe(2);

    // 越过 50ms 窗口后读取
    await new Promise((r) => setTimeout(r, 70));
    expect(m.getStatus().totalRequests).toBe(0);
  });
});

// ===== HealthChecker =====

describe('HealthChecker — 三项健康检查（v0.7.4 移除多余 skipIf）', () => {
  // v0.7.4 回归修复: 本套件用注入的 broken DB，不依赖 better-sqlite3 ABI，
  // 原 skipIf(!dbAvailable) 使系统 Node 下整个套件被跳过（与 slo.test.ts 的
  // 无门控 HealthChecker 套件门控不一致）。移除门控后双轨均执行。
  // 注：真实库连通性由 database-migration.test.ts（PRAGMA user_version 套件）以
  // 完整 DatabaseService.initialize() 覆盖；此处仅保留纯依赖注入的确定性用例。

  it('DB ping 失败 → database check 不健康、healthy=false', async () => {
    const broken = {
      prepare: () => {
        throw new Error('disk I/O error');
      },
    } as unknown as import('better-sqlite3').Database;
    const hc = new HealthChecker(() => broken, ':memory:');
    const report = await hc.check();
    const dbCheck = report.checks.find((c) => c.name === 'database');
    expect(dbCheck?.healthy).toBe(false);
    expect(String(dbCheck?.error ?? '')).toContain('I/O');
    expect(report.healthy).toBe(false);
  });
});