dsh-dashcam 0.0.0-stage → 2.0.0

package/test/observe.test.js

@@ -0,0 +1,169 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { tempDir, createPlugin, cleanup } = require('./helpers/fixtures');
+const { Ledger } = require('../src/runtime/ledger');
+const { LocalHost } = require('../src/host/local-host');
+const { createGuardChain } = require('../src/runtime/guards');
+const { runInstallPipeline } = require('../src/gates/index');
+
+function writePlugin(dir, { id = 'com.example.observe', source }) {
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, 'manifest.json'), JSON.stringify({
+    id,
+    name: 'Observe',
+    version: '1.0.0',
+    entry: 'index.js',
+    dashcam: {
+      spec: 'dsh-dashcam/1',
+      capabilities: { requests: [] },
+      content: null,
+    },
+  }, null, 2));
+  fs.writeFileSync(path.join(dir, 'index.js'), source);
+  return dir;
+}
+
+test('守卫链：observe 窗口内记 deny 但不抛出，窗口结束后恢复 fail-closed', () => {
+  const ledger = { append() { return { seq: 1 }; } };
+  const guard = createGuardChain({
+    manifest: { id: 'p', name: 'P', version: '1.0.0', entry: 'i.js', kind: 'dashcam', dashcam: { spec: 'dsh-dashcam/1', requests: [], content: null } },
+    grants: [],
+    ledger,
+  });
+
+  guard.beginObserve();
+  try {
+    const decision = guard.enforce('fs.read', { path: '/tmp/secret' });
+    assert.equal(decision.allowed, true);
+    assert.equal(decision.observed, true);
+    assert.equal(decision.observedCode, 'not_declared');
+  } finally {
+    guard.endObserve();
+  }
+
+  assert.equal(guard.isObserving(), false);
+  assert.throws(() => guard.enforce('fs.read', { path: '/tmp/secret' }), /未声明|manifest/);
+  assert.equal(guard.stats.observed, 1);
+});
+
+test('装载窗口：顶层代码的越界读取被记账，但不阻断安装', async () => {
+  const dir = tempDir('observe-host-');
+  const outsideDir = tempDir('observe-out-');
+  const outside = path.join(outsideDir, 'secret.txt');
+  fs.writeFileSync(outside, 'TOP-SECRET');
+
+  const pluginDir = writePlugin(path.join(dir, 'plugin'), {
+    source: [
+      "'use strict';",
+      "const fs = require('node:fs');",
+      'let stolen = null;',
+      'try { stolen = fs.readFileSync(' + JSON.stringify(outside) + ", 'utf8'); } catch (error) { stolen = 'DENIED'; }",
+      'module.exports = { stolen, activate() {}, invoke() { return { stolen }; }, deactivate() {} };',
+    ].join('\n'),
+  });
+
+  const ledgerPath = path.join(dir, 'ledger.jsonl');
+  const host = new LocalHost({ ledgerPath });
+  try {
+    await host.install(pluginDir);
+    await host.register('com.example.observe');
+
+    const module = host.modules.get('com.example.observe');
+    assert.equal(module.stolen, 'TOP-SECRET', '装载窗口内不阻断（否则 legacy 插件根本装不上）');
+
+    const records = new Ledger(ledgerPath).records();
+    const intercepted = records.filter((record) => record.intercepted === true);
+    assert.ok(intercepted.length >= 1, '窗口内的越界读取必须留下记录');
+    assert.ok(intercepted.some((record) => record.ruleId === 'not_declared'));
+
+    // 窗口已经关闭：同样的调用现在必须被拒绝
+    assert.throws(
+      () => host.active.guard.enforce('fs.read', { path: outside }),
+      /未声明|manifest/,
+    );
+  } finally {
+    try { await host.uninstall('com.example.observe'); } catch {}
+    cleanup(dir);
+    cleanup(outsideDir);
+  }
+});
+
+test('装载窗口：不把加载器自己的读文件记成插件行为', async () => {
+  const dir = tempDir('observe-entry-');
+  const pluginDir = writePlugin(path.join(dir, 'plugin'), {
+    source: "'use strict';\nmodule.exports = { activate() {}, invoke() { return { ok: true }; }, deactivate() {} };\n",
+  });
+  const ledgerPath = path.join(dir, 'ledger.jsonl');
+  const host = new LocalHost({ ledgerPath });
+  try {
+    await host.install(pluginDir);
+    await host.register('com.example.observe');
+    const records = new Ledger(ledgerPath).records();
+    const entryRead = records.some((record) => JSON.stringify(record.scope || '').includes('index.js'));
+    assert.equal(entryRead, false, '入口文件的读取是宿主行为，不该记在插件账上');
+  } finally {
+    try { await host.uninstall('com.example.observe'); } catch {}
+    cleanup(dir);
+  }
+});
+
+test('LocalHost：admitting 是私有字段，外部写不进去也绕不过去', () => {
+  const dir = tempDir('observe-private-');
+  const host = new LocalHost({ ledgerPath: path.join(dir, 'ledger.jsonl') });
+  assert.equal('admitting' in host, false);
+  assert.equal(Object.getOwnPropertyNames(host).includes('admitting'), false);
+  host.admitting = true;
+  assert.equal('admitting' in host, true);
+  assert.equal(host.admitting, true);
+  cleanup(dir);
+});
+
+test('strict 模式：前置门禁未通过时不执行插件代码', async () => {
+  const dir = tempDir('observe-strict-');
+  const marker = path.join(dir, 'executed.txt');
+  const pluginDir = writePlugin(path.join(dir, 'plugin'), {
+    source: [
+      "'use strict';",
+      "require('node:fs').writeFileSync(" + JSON.stringify(marker) + ", 'executed');",
+      'module.exports = { activate() {}, invoke() { return { ok: true }; }, deactivate() {} };',
+    ].join('\n'),
+  });
+
+  const host = new LocalHost({ ledgerPath: path.join(dir, 'ledger.jsonl'), channel: 'enterprise' });
+  const report = await runInstallPipeline({
+    pluginDir,
+    trust: null,
+    channel: 'enterprise',
+    host,
+  });
+
+  assert.equal(report.ok, false);
+  assert.equal(fs.existsSync(marker), false, '验签没过就不该执行插件代码');
+  const loadStage = report.stages.find((stage) => stage.name === 'loadability');
+  assert.equal(loadStage.status, 'warn');
+  assert.ok(loadStage.labels.some((item) => item.code === 'loadability_skipped'));
+  cleanup(dir);
+});
+
+test('coverage：Hook 装好之后 guard.coverage() 能给出受控入口清单', () => {
+  const guard = createGuardChain({
+    manifest: { id: 'p', name: 'P', version: '1.0.0', entry: 'i.js', kind: 'dashcam', dashcam: { spec: 'dsh-dashcam/1', requests: [], content: null } },
+    grants: [],
+  });
+  const before = guard.coverage();
+  assert.equal(before.entries, 0);
+  assert.ok(before.knownGaps.length >= 1);
+
+  const hooks = guard.installNativeHooks();
+  try {
+    const after = guard.coverage();
+    assert.ok(after.entries > 50);
+    assert.ok(after.guarded.includes('fs.openSync'));
+  } finally {
+    hooks.uninstall();
+  }
+});

package/test/options.test.js

@@ -0,0 +1,174 @@
+'use strict';
+
+/**
+ * policy.limits / policy.enforcement.strictPatch 的可配置性回归。
+ * 这些值以前是各模块里写死的常量，现在必须真的能通过 policy 改。
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { tempDir, createPlugin, cleanup } = require('./helpers/fixtures');
+const { loadManifest } = require('../src/contract/manifest');
+const { normalizeGrant } = require('../src/contract/capabilities');
+const { loadPolicy, resolveLimits, DEFAULT_LIMITS } = require('../src/policy');
+const { Ledger } = require('../src/runtime/ledger');
+const { createGuardChain } = require('../src/runtime/guards');
+const { createBridge } = require('../src/runtime/bridge');
+const { createNetHandle } = require('../src/runtime/handles/net');
+const { LocalHost, resolveLedgerMacKey } = require('../src/host/local-host');
+
+const MANIFEST = {
+  id: 'com.example.options',
+  name: 'Options',
+  version: '1.0.0',
+  entry: 'index.js',
+  kind: 'dashcam',
+  dashcam: { spec: 'dsh-dashcam/1', content: null, requests: [] },
+};
+
+function runtimeFor(policy = {}) {
+  const dir = tempDir('options-');
+  const ledger = new Ledger(path.join(dir, 'ledger.jsonl'));
+  const guard = createGuardChain({
+    manifest: MANIFEST, grants: [], ledger, pluginRoot: dir, policy,
+  });
+  return { dir, ledger, guard };
+}
+
+test('limits：默认值集中在一处，未覆盖的键保持默认', () => {
+  const merged = resolveLimits({ limits: { batchTargets: 5 } });
+  assert.equal(merged.batchTargets, 5);
+  assert.equal(merged.fetchTimeoutMs, DEFAULT_LIMITS.fetchTimeoutMs);
+  assert.equal(merged.integrityEvery, DEFAULT_LIMITS.integrityEvery);
+
+  const loaded = loadPolicy({ limits: { globBatchSize: 7 } });
+  assert.equal(loaded.limits.globBatchSize, 7);
+  assert.equal(loaded.limits.batchTargets, DEFAULT_LIMITS.batchTargets);
+});
+
+test('limits.batchTargets：上限可调，超了仍然拒绝', () => {
+  const runtime = runtimeFor({ limits: { batchTargets: 2 } });
+  try {
+    const payloads = [{ path: '/tmp/a' }, { path: '/tmp/b' }, { path: '/tmp/c' }];
+    assert.throws(() => runtime.guard.enforceBatch('fs.read', payloads), /超过上限 2/);
+  } finally {
+    cleanup(runtime.dir);
+  }
+});
+
+test('limits.integrityEvery = 0 时关闭抽样校验', () => {
+  const runtime = runtimeFor({ limits: { integrityEvery: 0 } });
+  const bridge = runtime.guard.installNativeHooks();
+  const original = fs.readFileSync;
+  try {
+    fs.readFileSync = function tampered() { return 'tampered'; };
+    for (let index = 0; index < 200; index += 1) {
+      runtime.guard.check('fs.read', { path: path.join(runtime.dir, 'a.txt') });
+    }
+    assert.equal(runtime.guard.isCompromised(), false, '关掉抽样后不应该自己发现');
+  } finally {
+    fs.readFileSync = original;
+    bridge.uninstall();
+    cleanup(runtime.dir);
+  }
+});
+
+test('limits.fetchTimeoutMs：0 不注入超时，正值注入', async () => {
+  const originalFetch = globalThis.fetch;
+  const captured = [];
+  globalThis.fetch = (input, init) => { captured.push(init); return Promise.resolve({}); };
+  try {
+    const noTimeout = createNetHandle({ guard: { enforce() {} }, limits: { fetchTimeoutMs: 0 } });
+    await noTimeout.fetch('https://example.com/a');
+    assert.equal(captured[0].signal, undefined, 'fetchTimeoutMs=0 时不注入 signal');
+
+    const withTimeout = createNetHandle({ guard: { enforce() {} }, limits: { fetchTimeoutMs: 1500 } });
+    await withTimeout.fetch('https://example.com/a');
+    assert.ok(captured[1].signal instanceof AbortSignal);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('limits.minMacKeyBytes：下限只能抬高，不能降到 32 以下', () => {
+  const dir = tempDir('options-mac-');
+  try {
+    const shortKey = 'k'.repeat(8);
+    assert.throws(() => resolveLedgerMacKey({ ledgerMacKey: shortKey }), /太短/);
+    // 函数级参数也不能放宽：否则「可调」就是绕过 policy 的后门。
+    assert.throws(() => resolveLedgerMacKey({ ledgerMacKey: shortKey, minBytes: 8 }), /太短/);
+    // policy 侧不允许把下限配到 32 以下：那等于允许把 HMAC 强度关掉。
+    assert.throws(
+      () => resolveLimits({ limits: { minMacKeyBytes: 8 } }),
+      /minMacKeyBytes/,
+    );
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test('limits.globBatchSize：异步 glob 按配置分块', async (t) => {
+  if (!fs.promises || typeof fs.promises.glob !== 'function') {
+    t.skip('当前 Node 没有 fs.promises.glob');
+    return;
+  }
+  const dir = tempDir('options-glob-');
+  const scope = { paths: [dir.replace(/\\/g, '/') + '/**'] };
+  createPlugin({ dir, requests: [{ cap: 'fs.read', scope, reason: '读取自身文件' }] });
+  const { manifest } = loadManifest(dir);
+  const ledger = new Ledger(path.join(dir, 'ledger.jsonl'));
+  const grants = [normalizeGrant({ capability: 'fs.read', scope }, { pluginRoot: dir }, 0)];
+  const guard = createGuardChain({
+    manifest, grants, ledger, pluginRoot: dir, policy: { limits: { globBatchSize: 2 } },
+  });
+
+  for (let index = 0; index < 5; index += 1) {
+    fs.writeFileSync(path.join(dir, 'f' + index + '.txt'), 'x');
+  }
+
+  const bridge = createBridge({
+    guard, ledger, plugin: { id: manifest.id }, globBatchSize: 2,
+  });
+  try {
+    let seen = 0;
+    for await (const matched of fs.promises.glob('**/*.txt', { cwd: dir })) {
+      assert.ok(matched);
+      seen += 1;
+    }
+    assert.equal(seen, 5);
+    const records = ledger.records().filter((record) => record.ruleId === 'two-key-batch');
+    assert.equal(records.length, 3, '5 条结果按 2 条一块 → 3 条账本');
+  } finally {
+    bridge.uninstall();
+    cleanup(dir);
+  }
+});
+
+test('enforcement.strictPatch：补丁不完整时拒绝装载', async (t) => {
+  const descriptor = Object.getOwnPropertyDescriptor(fs, 'opendirSync');
+  if (!descriptor || descriptor.configurable === false) {
+    t.skip('fs.opendirSync 不可配置，无法构造补丁失败');
+    return;
+  }
+  const saved = fs.opendirSync;
+  delete fs.opendirSync;
+
+  const dir = tempDir('options-strict-');
+  const plugin = createPlugin({ dir, requests: [] });
+  const host = new LocalHost({
+    ledgerPath: path.join(dir, 'ledger.jsonl'),
+    policy: { enforcement: { strictPatch: true } },
+  });
+  try {
+    await host.install(dir);
+    await assert.rejects(() => host.register(plugin.manifest.id), /补丁不完整/);
+  } finally {
+    try { await host.uninstall(plugin.manifest.id); } catch {}
+    Object.defineProperty(fs, 'opendirSync', {
+      value: saved, writable: true, configurable: true, enumerable: descriptor.enumerable,
+    });
+    cleanup(dir);
+  }
+});

package/test/portrait-labels.test.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { tempDir, createPlugin, cleanup } = require('./helpers/fixtures');
+const { loadManifest } = require('../src/contract/manifest');
+const { buildPortrait, renderPortrait } = require('../src/portrait/portrait');
+const { computeMetrics } = require('../src/governance/metrics');
+
+test('画像卡：安全标签按 label 去重，首屏只报去重后的数量', () => {
+  const portrait = buildPortrait({
+    manifest: { id: 'com.example.labels', dashcam: { requests: [] } },
+    labels: [
+      { gate: 'signature', code: 'trust_missing', label: 'Untrusted', reason: '未提供信任表，无法验签' },
+      { gate: 'safety', code: 'network_egress', label: 'ReviewRequired', reason: '出网范围需要人工复核' },
+      { gate: 'sieve', code: 'quarantined', label: 'Untrusted', reason: '重复分档不应重复计数' },
+    ],
+  });
+  assert.deepEqual(portrait.securityLabels, ['Untrusted', 'ReviewRequired']);
+  assert.equal(portrait.firstScreen.labelCount, 2);
+  // labels 原文保留，去重只作用于首屏展示用的 securityLabels。
+  assert.equal(portrait.labels.length, 3);
+});
+
+test('画像卡：首屏直出安全标签与隔离档两行', () => {
+  const dir = tempDir('portrait-labels-');
+  createPlugin({ dir, legacy: true });
+  const { manifest } = loadManifest(dir);
+  cleanup(dir);
+
+  const portrait = buildPortrait({
+    manifest,
+    labels: [
+      { gate: 'signature', code: 'signature_skipped', label: 'SignatureSkipped', reason: '调用方跳过验签' },
+      { gate: 'sieve', code: 'quarantined', label: 'Quarantined', reason: 'legacy 插件按 deny-all 隔离' },
+    ],
+  });
+  assert.equal(portrait.quarantine, true);
+
+  const rendered = renderPortrait(portrait);
+  assert.ok(rendered.includes('安全标签：SignatureSkipped / Quarantined'));
+  assert.ok(rendered.includes('隔离档：无 dashcam 声明，运行时 deny-all'));
+});
+
+test('画像卡：隔离档判定统一走 isQuarantined', () => {
+  // dashcam.quarantine 为真、顶层字段缺失时也应判定为隔离档。
+  const fromDashcam = buildPortrait({
+    manifest: { id: 'com.example.quarantined', dashcam: { requests: [], quarantine: true } },
+  });
+  assert.equal(fromDashcam.quarantine, true);
+
+  const plain = buildPortrait({ manifest: { dashcam: { requests: [] } } });
+  assert.equal(plain.quarantine, false);
+  assert.equal(buildPortrait({}).quarantine, false);
+});
+
+test('治理度量：未声明越权与 grant 拒绝分开计数', () => {
+  const ledgerRecords = [
+    { ts: '2026-10-01T10:00:00.000Z', decision: 'allow', ruleId: 'two-key', intercepted: false },
+    { ts: '2026-10-01T10:01:00.000Z', decision: 'deny', ruleId: 'not_declared', intercepted: true },
+    { ts: '2026-10-01T10:02:00.000Z', decision: 'deny', ruleId: 'not_granted', intercepted: false },
+  ];
+  const metrics = computeMetrics({ ledgerRecords });
+
+  assert.equal(metrics.requests, 3);
+  assert.equal(metrics.allows, 1);
+  assert.equal(metrics.denies, 2);
+  assert.equal(metrics.undeclaredInterceptions, 1);
+  assert.equal(metrics.undeclaredInterceptionRate, 1 / 3);
+  assert.equal(metrics.grantDenials, 1);
+  assert.equal(metrics.grantDenialRate, 0.5);
+});

package/test/portrait.test.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { tempDir, createPlugin, cleanup } = require('./helpers/fixtures');
+const { loadManifest } = require('../src/contract/manifest');
+const { scanPlugin } = require('../src/gates/safety');
+const { loadPolicy } = require('../src/policy');
+const { buildPortrait, renderPortrait, CAVEAT } = require('../src/portrait/portrait');
+
+function portraitFor(requests, code) {
+  const dir = tempDir('portrait-');
+  createPlugin({ dir, requests, code });
+  const { manifest } = loadManifest(dir);
+  const scanResult = scanPlugin(dir, { policy: loadPolicy({}), manifest });
+  const portrait = buildPortrait({ manifest, scan: scanResult.scan });
+  cleanup(dir);
+  return portrait;
+}
+
+test('画像卡：高风险项触发高红档，首屏不泄露细节', () => {
+  const portrait = portraitFor([
+    { cap: 'fs.read', scope: { paths: ['$PLUGIN/**'] }, reason: '读取缓存' },
+    { cap: 'cred.read', scope: { targets: ['env:PLATFORM_KEY'] }, reason: '读取平台密钥' },
+  ]);
+  assert.equal(portrait.tier, 'high');
+  assert.equal(portrait.firstScreen.highRiskCount, 1);
+  assert.equal(portrait.firstScreen.groupCounts.cred, 1);
+  assert.equal(portrait.firstScreen.caveat, CAVEAT);
+  const firstScreen = JSON.stringify(portrait.firstScreen);
+  assert.equal(firstScreen.includes('读取平台密钥'), false);
+  assert.equal(firstScreen.includes('读取缓存'), false);
+  assert.equal(portrait.rejectionReason, null);
+
+  const rendered = renderPortrait(portrait);
+  assert.ok(rendered.includes('[!] cred.read'));
+  assert.ok(rendered.includes('需强制确认'));
+  assert.ok(rendered.includes(CAVEAT));
+});
+
+test('画像卡：中风险展开勾选，低风险折叠', () => {
+  const medium = portraitFor([
+    { cap: 'net.outbound', scope: { hosts: ['api.example.com:443'] }, reason: '调用 API' },
+    { cap: 'fs.read', scope: { paths: ['$PLUGIN/**'] }, reason: '读取缓存' },
+  ]);
+  assert.equal(medium.tier, 'medium');
+  assert.ok(renderPortrait(medium).includes('[ ] net.outbound'));
+
+  const low = portraitFor([
+    { cap: 'fs.read', scope: { paths: ['$PLUGIN/a/**'] }, reason: '读取 A' },
+    { cap: 'fs.read', scope: { paths: ['$PLUGIN/b/**'] }, reason: '读取 B' },
+  ]);
+  assert.equal(low.tier, 'low');
+  assert.ok(renderPortrait(low).includes('已折叠 2 项'));
+});
+
+test('画像卡：拒绝原因直出原文，不包装', () => {
+  const dir = tempDir('portrait-reject-');
+  createPlugin({ dir, requests: [{ cap: 'proc.spawn', scope: { commands: ['node'] }, reason: '原始拒绝原因' }] });
+  const { manifest } = loadManifest(dir);
+  const portrait = buildPortrait({ manifest, rejection: { reason: '原始拒绝原因' } });
+  const rendered = renderPortrait(portrait);
+  assert.ok(rendered.includes('拒绝原因：原始拒绝原因'));
+  cleanup(dir);
+});

package/test/protocol.test.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const protocol = require('../src/runtime/ipc/protocol.js');
+
+test('导出契约精确（OPS / CONTROL_OPS / 函数）', () => {
+  assert.deepEqual(protocol.OPS, ['fs.read', 'fs.readMany', 'fs.write', 'net.outbound', 'ping']);
+  assert.deepEqual(protocol.CONTROL_OPS, ['invoke']);
+  assert.ok(Object.isFrozen(protocol.OPS));
+  assert.ok(Object.isFrozen(protocol.CONTROL_OPS));
+  for (const fn of ['makeRequest', 'makeResponse', 'isValidRequest', 'isValidResponse']) {
+    assert.equal(typeof protocol[fn], 'function', fn);
+  }
+});
+
+test('makeRequest：payload 缺省为空对象', () => {
+  assert.deepEqual(protocol.makeRequest(1, 'ping', { x: 1 }), {
+    id: 1, kind: 'request', op: 'ping', payload: { x: 1 },
+  });
+  assert.deepEqual(protocol.makeRequest('s', 'fs.read'), {
+    id: 's', kind: 'request', op: 'fs.read', payload: {},
+  });
+});
+
+test('makeResponse：ok 强转布尔、value/error 归一化', () => {
+  assert.deepEqual(protocol.makeResponse('a', true, 42, null), {
+    id: 'a', kind: 'response', ok: true, value: 42, error: null,
+  });
+  assert.deepEqual(protocol.makeResponse('a', false, undefined, { code: 'E1', message: 'x' }), {
+    id: 'a', kind: 'response', ok: false, value: null, error: { code: 'E1', message: 'x' },
+  });
+  assert.equal(protocol.makeResponse('a', 0, 1, null).ok, false);
+});
+
+test('isValidRequest：合法请求通过', () => {
+  assert.equal(protocol.isValidRequest({ id: 1, kind: 'request', op: 'ping', payload: {} }), true);
+  assert.equal(protocol.isValidRequest({ id: 's', kind: 'request', op: 'fs.read' }), true); // payload 省略
+  assert.equal(protocol.isValidRequest({ id: 0, kind: 'request', op: 'ping', payload: undefined }), true);
+});
+
+test('isValidRequest：畸形/恶意输入全部 false 且不抛', () => {
+  const bad = [
+    null,
+    undefined,
+    42,
+    'str',
+    true,
+    [],
+    {},
+    { id: 1, kind: 'request', op: {}, payload: {} },        // op 是对象
+    { id: 1, kind: 'request', op: '', payload: {} },         // op 空串
+    { id: 1, kind: 'request', op: 7, payload: {} },          // op 非字符串
+    { id: 1, kind: 'request', op: 'ping', payload: [] },     // payload 数组
+    { id: 1, kind: 'request', op: 'ping', payload: 'x' },    // payload 非对象
+    { id: 1, kind: 'request', op: 'ping', payload: 42 },
+    { id: 1, kind: 'request', op: 'ping', payload: new Date() }, // 非纯对象
+    { id: {}, kind: 'request', op: 'ping', payload: {} },    // id 是对象
+    { id: null, kind: 'request', op: 'ping', payload: {} },
+    { id: true, kind: 'request', op: 'ping', payload: {} },
+    { kind: 'request', op: 'ping', payload: {} },            // 缺 id
+    { id: 1, op: 'ping', payload: {} },                      // 缺 kind
+    { id: 1, kind: 'req', op: 'ping', payload: {} },         // kind 错
+    { id: 1, kind: 'request', payload: {} },                 // 缺 op
+  ];
+  for (const m of bad) {
+    assert.equal(protocol.isValidRequest(m), false, JSON.stringify(m));
+  }
+});
+
+test('isValidResponse：合法响应通过', () => {
+  assert.equal(protocol.isValidResponse({ id: 1, kind: 'response', ok: true, value: 1, error: null }), true);
+  assert.equal(protocol.isValidResponse({ id: 'x', kind: 'response', ok: false, value: null, error: { code: 'E' } }), true);
+  assert.equal(protocol.isValidResponse({ id: 1, kind: 'response', ok: false, value: null, error: undefined }), true);
+});
+
+test('isValidResponse：畸形/恶意输入全部 false 且不抛', () => {
+  const bad = [
+    null,
+    undefined,
+    [],
+    {},
+    { id: 1, kind: 'response', ok: 'yes', value: 1, error: null }, // ok 非布尔
+    { id: 1, kind: 'response', ok: 1, value: 1, error: null },
+    { id: 1, kind: 'response', ok: true, value: 1, error: { code: 1 } }, // code 非字符串
+    { id: 1, kind: 'response', ok: true, value: 1, error: {} },          // 缺 code
+    { id: 1, kind: 'response', ok: true, value: 1, error: [] },          // error 数组
+    { id: 1, kind: 'response', ok: true, value: 1, error: 'x' },
+    { id: {}, kind: 'response', ok: true, value: 1, error: null },       // id 对象
+    { kind: 'response', ok: true, value: 1, error: null },               // 缺 id
+    { id: 1, ok: true, value: 1, error: null },                          // 缺 kind
+    { id: 1, kind: 'resp', ok: true, value: 1, error: null },            // kind 错
+  ];
+  for (const m of bad) {
+    assert.equal(protocol.isValidResponse(m), false, JSON.stringify(m));
+  }
+});
+
+test('恶意 getter 抛异常也不让校验函数抛错', () => {
+  const evil = {};
+  Object.defineProperty(evil, 'kind', { get() { throw new Error('boom'); } });
+  assert.equal(protocol.isValidRequest(evil), false);
+  assert.equal(protocol.isValidResponse(evil), false);
+});