MailUI4Agents/plugins/pi-mail-bridge/test/turn-cwd.test.mjs

import assert from 'node:assert/strict';
import test from 'node:test';
import { readFileSync } from 'node:fs';
import { fileURLToPath } from 'node:url';
import { dirname, join, resolve } from 'node:path';
import { homedir } from 'node:os';

import { resolveTurnCwd } from '../src/turn-cwd.mjs';
import { piMailFallback } from '../src/paths.mjs';
import { resolveWorkspaceCwd } from '../lib/workspace.js';
import { sandboxWritePaths } from '../lib/sandbox.js';

const HERE = dirname(fileURLToPath(import.meta.url));
const ROOT = resolve(HERE, '..');
const HOME = homedir();

const call = (o) => resolveTurnCwd({
  fallback: piMailFallback, resolve: resolveWorkspaceCwd, ...o,
});

/**
 * 这一组补的是 pi 评审 2026-09-15 用探针实测出来的**输入**分叉：
 *
 *   父进程：`resolveWorkspaceCwd(to_workspace, …)`        ← 来源：**这封信的地址**
 *   子进程：`job.session.cwd || resolveWorkspaceCwd(…)`   ← 来源：**会话上次实际用的 cwd**
 *
 * 原先那条"父子同源"判据断言的是**函数**同源（两边 import 同一个 `piMailFallback`），
 * 它**测不出输入分叉** —— 所以这里改成断言一条**等式**：
 * "`--rw` 的 cwd（父进程算） === worker 会用的 cwd"。
 */

test('★ 复用会话时：cwd 取 state.cwd，而不是按这封信的地址重算', () => {
  // 实测场景：会话 d042cc4c 的 state.cwd = /home/program/agentmail，
  // 此时来一封写给 `pi@.<会话>`（不带 path）的信。
  const r = call({
    sessionReused: true,
    storedCwd: '/home/program/agentmail',
    toWorkspace: undefined,                       // 地址不带 path ⇒ 按地址算会得到兜底目录
    sessionKey: 'sess-x',
  });
  assert.equal(r.cwd, '/home/program/agentmail',
    '复用会话时必须用会话上次实际用的 cwd —— 按地址重算就是 rw 与 worker 分叉');
  assert.equal(r.source, 'reused');
  // 对照：按地址算会得到兜底目录，与 state.cwd 不同 ⇒ 如果不修，rw 就是错的
  const byAddress = resolveWorkspaceCwd(undefined, piMailFallback('sess-x'));
  assert.notEqual(byAddress.cwd, r.cwd, '两种来源确实不同名 —— 这正是分叉的成因');
});

test('★ 等式：--rw 里必须有 worker 会用的那个 cwd', () => {
  // 这是 pi 要的那条可断言等式。用真 sandboxWritePaths 算 rw，
  // 断言 worker 实际会用的 cwd **在 rw 里**。
  const stored = '/home/program/agentmail';
  const r = call({ sessionReused: true, storedCwd: stored, toWorkspace: undefined, sessionKey: 'sess-x' });

  const exists = (p) => [stored, '/tmp', `${HOME}/.pi/agent`, `${HOME}/.pi/agent/sessions`,
    `${HOME}/.agentmail-pi`, '/dev/null'].includes(p);
  const { dirs } = sandboxWritePaths({ cwd: r.cwd, env: { TMPDIR: '/tmp', HOME }, exists, home: HOME });

  assert.ok(dirs.includes(r.cwd),
    `--rw 里必须有 worker 会用的 cwd（${r.cwd}）：rw=${dirs.join(',')}`);
  // 反面对照：如果不改（按地址算），rw 里就没有那个目录 —— 证明这条判据有区分力
  const wrong = call({ sessionReused: false, toWorkspace: undefined, sessionKey: 'sess-x' });
  const wrongDirs = sandboxWritePaths({ cwd: wrong.cwd, env: { TMPDIR: '/tmp', HOME }, exists, home: HOME }).dirs;
  assert.ok(!wrongDirs.includes(stored),
    '按地址算出来的 rw 不该含 state.cwd —— 这就是修复前的错位状态');
});

test('没有复用时仍按地址算（不能一律取 state.cwd）', () => {
  const r = call({ sessionReused: false, storedCwd: '/home/program/agentmail', toWorkspace: '/home/program/agentmail', sessionKey: 'k' });
  assert.equal(r.source, 'address', '没复用就该按地址算');
  assert.equal(r.cwd, '/home/program/agentmail');
});

test('复用了但 state.cwd 为空 ⇒ 退回按地址算（老状态没有 cwd）', () => {
  const r = call({ sessionReused: true, storedCwd: '', toWorkspace: '/tmp', sessionKey: 'k' });
  assert.equal(r.source, 'address');
});

test('★ 结构判据：pool 算 launch 与 worker 取值必须来自同一个决定', () => {
  const pool = readFileSync(join(ROOT, 'src', 'pool.mjs'), 'utf8');
  assert.match(pool, /resolveTurnCwd\(/, 'pool 必须用这个纯函数决定 cwd');
  assert.match(pool, /cwd: turnCwd\.cwd/, 'pool 必须把该决定交给 workerLaunch（--rw 按它算）');
  assert.match(pool, /resolvedCwd: turnCwd\.cwd/, 'pool 必须把该决定注入 job 给 worker');

  // worker 侧：★ 这条断言改过一版，因为**第一版不具区分力**（我自己变异测出来的）。
  //   第一版只断言"文件里出现 `job.session?.resolvedCwd`" —— 把消费那一支删掉、
  //   退回 `job.session.cwd`，那条正则**仍然匹配得上**（因为别处还留着它），
  //   于是变异后测试依旧全绿 ⇒ 这条判据护不住它声称要护的东西。
  //   现在断言的是**优先级**：每一处取 cwd 的表达式都必须先看 `resolvedCwd`。
  const worker = readFileSync(join(ROOT, 'src', 'worker.mjs'), 'utf8');
  const cwdExprs = [...worker.matchAll(/const cwd = ([^;]+);/g)].map((m) => m[1]);
  assert.ok(cwdExprs.length >= 1, '应当至少有一处取 cwd 的表达式');
  for (const expr of cwdExprs) {
    assert.ok(expr.includes('resolvedCwd'),
      `取 cwd 的表达式必须先看父进程的决定（resolvedCwd），实际是：${expr.trim()}`);
  }
  // 新建分支那处同样是"父进程优先"
  assert.match(worker, /const turnCwd = job\.session\?\.resolvedCwd \|\| cwd/,
    '新建分支也必须以父进程的决定为准');
});