dsh-notify-say 0.4.21 → 0.4.25

package/test/wav-gain.test.mjs

@@ -0,0 +1,138 @@
+/**
+ * 语音包增益与限幅测试（v0.4.16）。
+ *
+ * ## 为什么需要增益
+ *
+ * 实测本包 247 个语音包峰值：最小 24.7%、中位 40.4%、最大 84.4%。
+ * 素材本身录得偏轻。而 Windows MCI 的 `setaudio volume to 1000`
+ * 上限**只等于原始幅度 1.0 倍**，无法超过 —— 所以 GUI 音量拉满
+ * 也只能听到原始电平的 35%~40%，听感必然偏轻。
+ *
+ * 唯一出路是**数字增益**：把样本乘一个系数。
+ *
+ * ## 为什么必须限幅
+ *
+ * 最响的文件已 84.4%，硬乘 2 倍会超过满刻度 → 削波（破音）。
+ * 所以实际系数 = min(期望倍数, 95% / 实测峰值)。
+ *
+ * 这些用例直接调用 ps1 里的函数（真跑 PowerShell，不是 mock），
+ * 因为增益涉及字节级操作，mock 测不出真问题。
+ */
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { existsSync, unlinkSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const GAIN_LIB = join(ROOT, 'lib', 'wav-gain.ps1');
+const VOICE_DIR = join(ROOT, 'sounds', 'voice-lines');
+
+/** 跑一段 PowerShell，返回 stdout。 */
+function ps(code) {
+  const dir = mkdtempSync(join(tmpdir(), 'gain-test-'));
+  const file = join(dir, 'run.ps1');
+  // 必须带 BOM：Windows PowerShell 5.1 读无 BOM 的 UTF-8 会按 ANSI 解释，
+  // 中文全变乱码并报语法错（本项目踩过）。
+  writeFileSync(file, '\uFEFF' + code, 'utf8');
+  try {
+    return execFileSync('powershell.exe', [
+      '-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', file,
+    ], { encoding: 'utf8', timeout: 120_000 });
+  } finally {
+    try { unlinkSync(file); } catch { /* ignore */ }
+  }
+}
+
+// ── G1: 增益函数存在且能测峰值 ───────────────────────────────────────────
+test('G1: Get-WavPeakPercent 能读出峰值百分比', () => {
+  const f = join(VOICE_DIR, 'zundamon-normal.wav');
+  if (!existsSync(f)) return;   // 语音包未随仓库分发时跳过
+  const out = ps(`. '${GAIN_LIB}'; Get-WavPeakPercent -Path '${f}'`);
+  const v = Number(out.trim());
+  assert.ok(Number.isFinite(v), `应返回数值，实际: ${out}`);
+  assert.ok(v > 0 && v <= 100, `峰值应在 0~100，实际 ${v}`);
+});
+
+// ── G2: 增益确实放大，且不超过 95% 安全线 ────────────────────────────────
+test('G2: 增益生效且峰值不超过 95%（不削波）', () => {
+  const f = join(VOICE_DIR, 'zundamon-normal.wav');
+  if (!existsSync(f)) return;
+  const tmpOut = join(tmpdir(), `g2-${Date.now()}.wav`);
+  try {
+    const out = ps(`
+      . '${GAIN_LIB}'
+      $r = Invoke-WavGain -Path '${f}' -OutPath '${tmpOut}' -Gain 2.0
+      Write-Output ("{0}|{1}|{2}" -f $r.Ok, $r.PeakBefore, $r.PeakAfter)
+    `);
+    const [ok, before, after] = out.trim().split('|');
+    assert.equal(ok, 'True', '增益应成功');
+    assert.ok(Number(after) > Number(before), `放大后峰值(${after})应高于原值(${before})`);
+    assert.ok(Number(after) <= 95.5, `绝不能超过安全线，实际 ${after}%`);
+  } finally {
+    try { unlinkSync(tmpOut); } catch { /* ignore */ }
+  }
+});
+
+// ── G3: 很响的文件自动降倍（关键护栏）──────────────────────────────────
+test('G3: 本来就响的文件自动降到安全倍数，不削波', () => {
+  const f = join(VOICE_DIR, 'my-voice-ja-2.wav');
+  if (!existsSync(f)) return;
+  const tmpOut = join(tmpdir(), `g3-${Date.now()}.wav`);
+  try {
+    const out = ps(`
+      . '${GAIN_LIB}'
+      $r = Invoke-WavGain -Path '${f}' -OutPath '${tmpOut}' -Gain 2.0
+      Write-Output ("{0}|{1}|{2}" -f $r.AppliedGain, $r.PeakBefore, $r.PeakAfter)
+    `);
+    const [applied, before, after] = out.trim().split('|');
+    // 这个文件原峰值 84.4%，2 倍必然削波 -> 必须自动降倍
+    assert.ok(Number(applied) < 2.0,
+      `应为避免削波而降倍，实际倍数 ${applied}`);
+    assert.ok(Number(after) <= 95.5, `峰值 ${after}% 超过安全线`);
+    assert.ok(Number(before) > 80, `选定文件应确实很响，实际 ${before}%`);
+  } finally {
+    try { unlinkSync(tmpOut); } catch { /* ignore */ }
+  }
+});
+
+// ── G4: 非 16-bit PCM / 非 wav 不做增益，退回原样 ───────────────────────
+test('G4: 不支持的文件返回 Ok=false（调用方据此用原文件）', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'gain-bad-'));
+  const fake = join(dir, 'not-a-wav.mp3');
+  writeFileSync(fake, Buffer.from('ID3 fake mp3 content'));
+  const tmpOut = join(dir, 'out.wav');
+  try {
+    const out = ps(`
+      . '${GAIN_LIB}'
+      $r = Invoke-WavGain -Path '${fake}' -OutPath '${tmpOut}' -Gain 2.0
+      Write-Output ("{0}|{1}" -f $r.Ok, $r.Reason)
+    `);
+    const [ok, reason] = out.trim().split('|');
+    assert.equal(ok, 'False', '不是 16-bit PCM wav 时不该声称成功');
+    assert.ok(reason.length > 0, '应给出原因');
+  } finally {
+    try { unlinkSync(fake); unlinkSync(tmpOut); } catch { /* ignore */ }
+  }
+});
+
+// ── G5: Gain <= 1.0 时什么都不做 ─────────────────────────────────────────
+test('G5: Gain<=1.0 时跳过（不加倍也不写文件）', () => {
+  const f = join(VOICE_DIR, 'zundamon-normal.wav');
+  if (!existsSync(f)) return;
+  const tmpOut = join(tmpdir(), `g5-${Date.now()}.wav`);
+  try {
+    const out = ps(`
+      . '${GAIN_LIB}'
+      $r = Invoke-WavGain -Path '${f}' -OutPath '${tmpOut}' -Gain 1.0
+      Write-Output ("{0}|{1}" -f $r.Ok, $r.Reason)
+    `);
+    const [ok, reason] = out.trim().split('|');
+    assert.equal(ok, 'False');
+    assert.equal(reason, 'gain<=1');
+  } finally {
+    try { unlinkSync(tmpOut); } catch { /* ignore */ }
+  }
+});

package/test/wiring.test.mjs

@@ -0,0 +1,287 @@
+/**
+ * dsh-notify-desktop 空闲门「事件接线」集成测试。
+ *
+ * 与 idle-gate.test.mjs 的分工：那边测**纯函数**的判定逻辑；这边测 apply() 的
+ * **事件接线与挂起状态机**——即"主会话 idle 时若有子代理在跑，到底有没有挂起"。
+ *
+ * 安全性：本测试把 `process.env.SystemRoot` 指向不存在的路径，使插件解析出的
+ * POWERSHELL_EXE 无效 → spawn 只会异步 emit 'error'（不启动任何进程、不播声音）。
+ * 测试的观测量是插件的 console 日志（挂起/未挂起），不是 Toast 本身。
+ *
+ * 运行：node --test tools/plugins/dsh-notify-desktop/test/
+ */
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+// ⚠️ 必须在 import lib/index.js **之前**把 DSH_HOME 指到空目录。
+//
+// 插件启动时会读 `$DSH_HOME/storages/dsh-notify-desktop/config.json` 作为
+// 「运行时覆盖层」，其优先级**高于** apply() 传入的 config。若用真实 DSH_HOME，
+// 用户只要在 GUI 里改过任何一项（实测：把 notifyOnAborted 打开），
+// 那些假定默认值的用例就会红——那是用户配置导致的，不是代码缺陷。
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+const ISOLATED_HOME = mkdtempSync(join(tmpdir(), 'notify-test-home-'));
+process.env.DSH_HOME = ISOLATED_HOME;
+process.on('exit', () => { try { rmSync(ISOLATED_HOME, { recursive: true, force: true }); } catch { /* best effort */ } });
+
+// 必须在 import 插件之前设置：插件在模块顶层读 SystemRoot 计算 POWERSHELL_EXE。
+process.env.SystemRoot = 'Z:\\__no_such_root__';
+
+const { apply } = await import('../lib/index.js');
+
+/**
+ * 造一个最小 ctx 替身：捕获事件处理器，记录 effect/dispose。
+ * @param {{ jobs?: any, agents?: any }} services - 要注入的宿主服务。
+ */
+function mkCtx(services = {}) {
+  const handlers = new Map();
+  const effects = [];
+  return {
+    handlers,
+    effects,
+    on(name, fn) {
+      if (!handlers.has(name)) handlers.set(name, []);
+      handlers.get(name).push(fn);
+    },
+    get(name) {
+      return services[name];
+    },
+    effect(fn) {
+      const d = fn();
+      effects.push(d);
+      return () => { if (typeof d === 'function') d(); };
+    },
+    /** 触发某事件的全部处理器。 */
+    emit(name, ...args) {
+      for (const fn of handlers.get(name) || []) fn(...args);
+    },
+  };
+}
+
+/** 造一个最小 agent 替身。 */
+function mkAgent(id, { origin, parentSession, status = 'idle' } = {}) {
+  return { id, status, session: { id, header: { id, origin, parentSession } } };
+}
+
+/** 捕获插件日志（挂起路径会打 'idle-gate: 挂起完成播报'）。 */
+function captureLogs() {
+  const lines = [];
+  const origLog = console.log;
+  const origWarn = console.warn;
+  console.log = (...a) => { lines.push(a.join(' ')); };
+  console.warn = (...a) => { lines.push(a.join(' ')); };
+  return {
+    lines,
+    restore() { console.log = origLog; console.warn = origWarn; },
+    get text() { return lines.join('\n'); },
+  };
+}
+
+/** 等待若干轮微任务/定时器，让异步 spawn 的 error 事件落地。 */
+function settle() {
+  return new Promise((r) => setTimeout(r, 20));
+}
+
+test('接线：apply() 注册了 session/event、agent/status、approval/request 三个处理器', () => {
+  const ctx = mkCtx();
+  apply(ctx, {});
+  assert.ok(ctx.handlers.has('session/event'), '应注册 session/event');
+  assert.ok(ctx.handlers.has('agent/status'), '应注册 agent/status');
+  assert.ok(ctx.handlers.has('approval/request'), '应注册 approval/request');
+});
+
+test('接线：jobs 服务存在时订阅 onJobsChanged（并挂进 effect）', () => {
+  let subscribed = false;
+  const ctx = mkCtx({
+    jobs: { list: () => [], onJobsChanged: () => { subscribed = true; return () => {}; } },
+  });
+  apply(ctx, {});
+  assert.equal(subscribed, true, '应调用 jobs.onJobsChanged');
+  assert.ok(ctx.effects.length > 0, '应通过 ctx.effect 注册');
+});
+
+// ── 核心场景：主会话 idle 时子代理仍在跑 → 必须挂起，不立即播报 ─────────────
+test('空闲门：主会话 idle 但 continuable 子代理 running → 挂起（不立即播报）', () => {
+  const main = mkAgent('main-1', { status: 'running' });
+  const child = mkAgent('child-1', { origin: 'subagent', parentSession: 'main-1', status: 'running' });
+  const ctx = mkCtx({ agents: { list: () => [main, child], get: (id) => (id === 'main-1' ? main : undefined) } });
+
+  const logs = captureLogs();
+  try {
+    apply(ctx, { idleGate: true });
+    // 主会话这一轮结束：turn/end completed
+    ctx.emit('session/event', main.session, { type: 'turn/end', data: { turn: 1, reason: { kind: 'completed' } } });
+    // 主会话进入 idle（running→idle 边沿）
+    main.status = 'idle';
+    ctx.emit('agent/status', { agent: main, status: 'running' });
+    ctx.emit('agent/status', { agent: main, status: 'idle' });
+    assert.match(logs.text, /idle-gate: 挂起完成播报/, '有子代理在跑时应挂起');
+  } finally {
+    logs.restore();
+  }
+});
+
+test('空闲门：子代理结束后重估 → 兑现播报（挂起被清）', () => {
+  const main = mkAgent('main-1', { status: 'idle' });
+  const child = mkAgent('child-1', { origin: 'subagent', parentSession: 'main-1', status: 'running' });
+  const ctx = mkCtx({ agents: { list: () => [main, child], get: (id) => (id === 'main-1' ? main : undefined) } });
+
+  const logs = captureLogs();
+  try {
+    apply(ctx, { idleGate: true });
+    ctx.emit('session/event', main.session, { type: 'turn/end', data: { turn: 1, reason: { kind: 'completed' } } });
+    ctx.emit('agent/status', { agent: main, status: 'running' });
+    ctx.emit('agent/status', { agent: main, status: 'idle' });
+    assert.match(logs.text, /idle-gate: 挂起完成播报/, '前置：应先挂起');
+
+    // 子代理跑完 → 状态变化触发重估
+    child.status = 'idle';
+    ctx.emit('agent/status', { agent: child, status: 'idle' });
+    // 兑现路径不打挂起日志；用"再次重估不再有挂起"间接确认已清
+    const before = logs.lines.length;
+    ctx.emit('agent/status', { agent: child, status: 'idle' });
+    assert.equal(logs.lines.length, before, '挂起已兑现后不应再产生新的挂起日志');
+  } finally {
+    logs.restore();
+  }
+});
+
+test('空闲门：无子代理/后台任务时**不**挂起（立即播报路径）', () => {
+  const main = mkAgent('main-1', { status: 'running' });
+  const ctx = mkCtx({ agents: { list: () => [main], get: () => main } });
+
+  const logs = captureLogs();
+  try {
+    apply(ctx, { idleGate: true });
+    ctx.emit('session/event', main.session, { type: 'turn/end', data: { turn: 1, reason: { kind: 'completed' } } });
+    main.status = 'idle';
+    ctx.emit('agent/status', { agent: main, status: 'running' });
+    ctx.emit('agent/status', { agent: main, status: 'idle' });
+    assert.doesNotMatch(logs.text, /idle-gate: 挂起完成播报/, '空闲时不应挂起');
+  } finally {
+    logs.restore();
+  }
+});
+
+test('空闲门：后台 job running 也触发挂起（jobs 一路）', () => {
+  const main = mkAgent('main-1', { status: 'running' });
+  const ctx = mkCtx({
+    agents: { list: () => [main], get: () => main },
+    jobs: { list: () => [{ id: 'bash-1', label: 'sleep', status: 'running' }], onJobsChanged: () => () => {} },
+  });
+
+  const logs = captureLogs();
+  try {
+    apply(ctx, { idleGate: true });
+    ctx.emit('session/event', main.session, { type: 'turn/end', data: { turn: 1, reason: { kind: 'completed' } } });
+    main.status = 'idle';
+    ctx.emit('agent/status', { agent: main, status: 'running' });
+    ctx.emit('agent/status', { agent: main, status: 'idle' });
+    assert.match(logs.text, /idle-gate: 挂起完成播报/, '有后台 job 在跑时应挂起');
+  } finally {
+    logs.restore();
+  }
+});
+
+test('空闲门：idleGate=false 时完全不过门（回归开关可用）', () => {
+  const main = mkAgent('main-1', { status: 'running' });
+  const child = mkAgent('child-1', { origin: 'subagent', parentSession: 'main-1', status: 'running' });
+  const ctx = mkCtx({ agents: { list: () => [main, child], get: () => main } });
+
+  const logs = captureLogs();
+  try {
+    apply(ctx, { idleGate: false });
+    ctx.emit('session/event', main.session, { type: 'turn/end', data: { turn: 1, reason: { kind: 'completed' } } });
+    main.status = 'idle';
+    ctx.emit('agent/status', { agent: main, status: 'running' });
+    ctx.emit('agent/status', { agent: main, status: 'idle' });
+    assert.doesNotMatch(logs.text, /idle-gate: 挂起完成播报/, 'idleGate=false 时应照旧立即播报');
+  } finally {
+    logs.restore();
+  }
+});
+
+test('空闲门：error 分支不过门（有子代理在跑也立即播报）', () => {
+  const main = mkAgent('main-1', { status: 'running' });
+  const child = mkAgent('child-1', { origin: 'subagent', parentSession: 'main-1', status: 'running' });
+  const ctx = mkCtx({ agents: { list: () => [main, child], get: () => main } });
+
+  const logs = captureLogs();
+  try {
+    apply(ctx, { idleGate: true });
+    ctx.emit('session/event', main.session, { type: 'turn/end', data: { turn: 1, reason: { kind: 'error' } } });
+    main.status = 'idle';
+    ctx.emit('agent/status', { agent: main, status: 'running' });
+    ctx.emit('agent/status', { agent: main, status: 'idle' });
+    assert.doesNotMatch(logs.text, /idle-gate: 挂起完成播报/, 'error 需立即介入，不应被挂起');
+  } finally {
+    logs.restore();
+  }
+});
+
+test('空闲门：子代理自身的完成不播报（subagents=false 默认过滤仍生效）', () => {
+  const child = mkAgent('child-1', { origin: 'subagent', parentSession: 'main-1', status: 'running' });
+  const ctx = mkCtx({ agents: { list: () => [child], get: () => undefined } });
+
+  const logs = captureLogs();
+  try {
+    apply(ctx, { idleGate: true, subagents: false });
+    ctx.emit('session/event', child.session, { type: 'turn/end', data: { turn: 1, reason: { kind: 'completed' } } });
+    child.status = 'idle';
+    ctx.emit('agent/status', { agent: child, status: 'running' });
+    ctx.emit('agent/status', { agent: child, status: 'idle' });
+    assert.doesNotMatch(logs.text, /idle-gate: 挂起完成播报/, '子代理自身完成不应触发主会话播报');
+  } finally {
+    logs.restore();
+  }
+});
+
+test('空闲门：宿主服务全部缺失时退化为立即播报（fail-visible，不静默）', async () => {
+  const main = mkAgent('main-1', { status: 'running' });
+  const ctx = mkCtx(); // 无 jobs、无 agents
+
+  const logs = captureLogs();
+  try {
+    apply(ctx, { idleGate: true });
+    ctx.emit('session/event', main.session, { type: 'turn/end', data: { turn: 1, reason: { kind: 'completed' } } });
+    main.status = 'idle';
+    ctx.emit('agent/status', { agent: main, status: 'running' });
+    ctx.emit('agent/status', { agent: main, status: 'idle' });
+    assert.doesNotMatch(logs.text, /idle-gate: 挂起完成播报/, '服务不可读时应退化为立即播报（宁可多报不静默）');
+  } finally {
+    logs.restore();
+  }
+  await settle();
+});
+
+test('空闲门：jobs.list 抛异常时不崩、退化为立即播报', () => {
+  const main = mkAgent('main-1', { status: 'running' });
+  const ctx = mkCtx({
+    agents: { list: () => [main], get: () => main },
+    jobs: { list: () => { throw new Error('boom'); }, onJobsChanged: () => () => {} },
+  });
+
+  const logs = captureLogs();
+  try {
+    apply(ctx, { idleGate: true });
+    ctx.emit('session/event', main.session, { type: 'turn/end', data: { turn: 1, reason: { kind: 'completed' } } });
+    main.status = 'idle';
+    ctx.emit('agent/status', { agent: main, status: 'running' });
+    ctx.emit('agent/status', { agent: main, status: 'idle' });
+    assert.match(logs.text, /jobs\.list failed/, '应记录 jobs.list 失败');
+    assert.doesNotMatch(logs.text, /idle-gate: 挂起完成播报/, '读取失败应退化为立即播报');
+  } finally {
+    logs.restore();
+  }
+});
+
+test('审批 waterfall：始终 next() 放行并透传返回值（绝不阻断）', () => {
+  const ctx = mkCtx();
+  apply(ctx, {});
+  const handler = (ctx.handlers.get('approval/request') || [])[0];
+  assert.ok(handler, '应有 approval/request 处理器');
+  const sentinel = { decision: 'allow' };
+  const got = handler({ agent: mkAgent('main-1'), toolName: 'pwsh' }, () => sentinel);
+  assert.equal(got, sentinel, '必须透传 next() 的返回值');
+});