@zhushanwen/subagent-core 0.6.0 → 0.7.0

package/src/execution/__tests__/pi-invocation.test.ts

@@ -1,166 +0,0 @@
-// src/__tests__/pi-invocation.test.ts
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-
-import { getPiInvocation } from "../engine/engines/pi/pi-invocation.ts";
-import {
-  RELAY_ENV_NODE,
-  RELAY_ENV_RECORD_ID,
-  RELAY_ENV_SCRIPT,
-  RELAY_ENV_SESSION_ID,
-  RELAY_ENV_SOCKET,
-} from "../relay-env.ts";
-
-// [验收门修复] getPiInvocation 的 relay 分支优先读宿主 RELAY env——根级 pnpm test
-// 进程若继承宿主（pi 子进程链）的 RELAY 身份，直连分支用例的 execPath/argv 断言
-// 会被改道（非自免疫，依赖 runner 环境）。文件级钩子对全部用例统一消毒：beforeEach
-// 删五键、afterEach 恢复原值——有泄漏无泄漏双向绿；第二组 relay 分支用例自设
-// RELAY_FULL 在清理之后执行，语义不受影响。
-const RELAY_ENV_KEYS = [
-  RELAY_ENV_SOCKET,
-  RELAY_ENV_NODE,
-  RELAY_ENV_SCRIPT,
-  RELAY_ENV_SESSION_ID,
-  RELAY_ENV_RECORD_ID,
-] as const;
-let savedRelayEnv: Record<string, string | undefined>;
-beforeEach(() => {
-  savedRelayEnv = {};
-  for (const key of RELAY_ENV_KEYS) savedRelayEnv[key] = process.env[key];
-  for (const key of RELAY_ENV_KEYS) delete process.env[key];
-});
-afterEach(() => {
-  for (const key of RELAY_ENV_KEYS) {
-    const value = savedRelayEnv[key];
-    if (value === undefined) delete process.env[key];
-    else process.env[key] = value;
-  }
-});
-
-describe("getPiInvocation", () => {
-  const originalArgv = process.argv;
-  const originalExecPath = process.execPath;
-  let tmpScript: string;
-
-  afterEach(() => {
-    Object.defineProperty(process, "argv", { value: originalArgv, configurable: true });
-    Object.defineProperty(process, "execPath", { value: originalExecPath, configurable: true });
-    if (tmpScript && fs.existsSync(tmpScript)) fs.unlinkSync(tmpScript);
-  });
-
-  it("真实脚本路径存在 → node <script> <userArgs>", () => {
-    // 创建真实临时脚本文件（避免 ESM spy 限制）
-    tmpScript = path.join(os.tmpdir(), `pi-inv-test-${Date.now()}.mjs`);
-    fs.writeFileSync(tmpScript, "// test");
-    Object.defineProperty(process, "argv", { value: ["node", tmpScript], configurable: true });
-    Object.defineProperty(process, "execPath", { value: "/usr/bin/node", configurable: true });
-
-    const result = getPiInvocation(["--mode", "json", "Task: x"]);
-    expect(result.command).toBe("/usr/bin/node");
-    expect(result.args).toEqual([tmpScript, "--mode", "json", "Task: x"]);
-  });
-
-  it("bun 虚拟脚本（/$bunfs/root/）→ 退化到 pi-in-PATH", () => {
-    tmpScript = "";
-    const virtualScript = "/$bunfs/root/pi";
-    Object.defineProperty(process, "argv", { value: ["bun", virtualScript], configurable: true });
-    Object.defineProperty(process, "execPath", { value: "/usr/bin/bun", configurable: true });
-
-    const result = getPiInvocation(["--mode", "json"]);
-    expect(result.command).toBe("pi");
-    expect(result.args).toEqual(["--mode", "json"]);
-  });
-
-  it("非通用 runtime（pi standalone binary）→ 直接 execPath", () => {
-    tmpScript = "";
-    Object.defineProperty(process, "argv", { value: ["/usr/bin/pi", "/nonexistent"], configurable: true });
-    Object.defineProperty(process, "execPath", { value: "/usr/local/bin/pi-binary", configurable: true });
-
-    const result = getPiInvocation(["--mode", "json"]);
-    expect(result.command).toBe("/usr/local/bin/pi-binary");
-    expect(result.args).toEqual(["--mode", "json"]);
-  });
-
-  it("node 通用 runtime + 脚本不存在 → pi-in-PATH", () => {
-    tmpScript = "";
-    Object.defineProperty(process, "argv", { value: ["node", "/nonexistent"], configurable: true });
-    Object.defineProperty(process, "execPath", { value: "/usr/bin/node", configurable: true });
-
-    const result = getPiInvocation(["--mode", "json"]);
-    expect(result.command).toBe("pi");
-    expect(result.args).toEqual(["--mode", "json"]);
-  });
-
-  it("空 userArgs 合法（仅 command + 空 args）", () => {
-    tmpScript = "";
-    Object.defineProperty(process, "argv", { value: ["node"], configurable: true });
-    Object.defineProperty(process, "execPath", { value: "/usr/bin/node", configurable: true });
-
-    const result = getPiInvocation([]);
-    expect(result.command).toBe("pi");
-    expect(result.args).toEqual([]);
-  });
-});
-
-describe("getPiInvocation relay 分支（E 方案 §5.1）", () => {
-  const originalArgv = process.argv;
-  const originalExecPath = process.execPath;
-  const RELAY_ENVS = [RELAY_ENV_SOCKET, RELAY_ENV_NODE, RELAY_ENV_SCRIPT] as const;
-  /** 三 env 齐备的基准值（改 argv/execPath 隔离直连分支，只测 relay 判定本身）。 */
-  const RELAY_FULL: Record<string, string> = {
-    [RELAY_ENV_SOCKET]: "/tmp/relay-test.sock",
-    [RELAY_ENV_NODE]: "/usr/bin/relay-node",
-    [RELAY_ENV_SCRIPT]: "/opt/relay/relay.mjs",
-  };
-
-  afterEach(() => {
-    Object.defineProperty(process, "argv", { value: originalArgv, configurable: true });
-    Object.defineProperty(process, "execPath", { value: originalExecPath, configurable: true });
-    for (const key of RELAY_ENVS) delete process.env[key];
-  });
-
-  /** 形态 1：三 env 齐备 + 默认 opts → relay invocation（command=NODE、args[0]=SCRIPT）。 */
-  it("三 env 齐备（无 opts）→ 代理形态 <NODE> <SCRIPT> <userArgs>", () => {
-    Object.assign(process.env, RELAY_FULL);
-    const result = getPiInvocation(["--mode", "rpc"]);
-    expect(result.command).toBe(RELAY_FULL[RELAY_ENV_NODE]);
-    expect(result.args).toEqual([RELAY_FULL[RELAY_ENV_SCRIPT], "--mode", "rpc"]);
-  });
-
-  /** 形态 1 变体：opts.relay === true 显式开启，行为与缺省一致。 */
-  it("三 env 齐备 + opts.relay=true → 同缺省（显式开启非必填）", () => {
-    Object.assign(process.env, RELAY_FULL);
-    const result = getPiInvocation(["--mode", "rpc"], { relay: true });
-    expect(result.command).toBe(RELAY_FULL[RELAY_ENV_NODE]);
-    expect(result.args[0]).toBe(RELAY_FULL[RELAY_ENV_SCRIPT]);
-  });
-
-  /** 形态 2：三缺一逐个枚举 → 回落现状直连（全有或全无，E-TUI 零回归）。 */
-  it("三缺一（逐个枚举）→ 现状直连分支", () => {
-    // 直连分支落到「node + 不存在脚本 → pi-in-PATH」可稳定断言（不依赖测试机 execPath 形态）
-    Object.defineProperty(process, "argv", { value: ["node", "/nonexistent"], configurable: true });
-    Object.defineProperty(process, "execPath", { value: "/usr/bin/node", configurable: true });
-    for (const missing of RELAY_ENVS) {
-      const partial = { ...RELAY_FULL };
-      delete partial[missing];
-      for (const key of RELAY_ENVS) delete process.env[key];
-      Object.assign(process.env, partial);
-      const result = getPiInvocation(["--mode", "rpc"]);
-      expect(result.command).toBe("pi"); // 分支 3：通用 runtime + 脚本不存在 → PATH
-      expect(result.args).toEqual(["--mode", "rpc"]);
-    }
-  });
-
-  /** 形态 3：probe 排除——显式 relay:false 时即便三 env 齐备也直连。 */
-  it("relay:false 强制直连（probe 语义：探 pi 本体，不探 runtime 健康）", () => {
-    Object.assign(process.env, RELAY_FULL);
-    Object.defineProperty(process, "argv", { value: ["node", "/nonexistent"], configurable: true });
-    Object.defineProperty(process, "execPath", { value: "/usr/bin/node", configurable: true });
-    const result = getPiInvocation(["--version"], { relay: false });
-    expect(result.command).toBe("pi");
-    expect(result.args).toEqual(["--version"]);
-  });
-});

package/src/execution/__tests__/recursive-visibility-env.test.ts

@@ -1,149 +0,0 @@
-// src/__tests__/recursive-visibility-env.test.ts
-//
-// 递归 subagent 跨层可见性：env 身份贯穿验证（设计 docs/design/recursive-subagent-visibility.md 场景 1b）。
-//
-// 验证 runSpawn 构造的 childEnv 含 4 个 PI_SUBAGENT_* 身份 env，值 = ctx.sessionRootId /
-// record.id / String(record.depth) / ctx.rootCwd（[MF-3] 第 4 个：ROOT cwd，落盘目录编码键）。覆盖 opts.fork=true 与 opts.fork=false 两种（决策 2 无条件注入）。
-//
-// 这是场景 1（端到端三层嵌套全树可见）的「env 传递机制」确定性验证——不依赖 LLM 配合，
-// mock spawn 拦截 childEnv 直接断言。端到端可见性由场景 1（真实 pi CLI + recursive-worker agent）覆盖。
-//
-// mock 块与 fixture 收敛 __tests__/helpers/spawn-mock.ts（vi.mock 工厂 await import 转发，
-// 单源共享）；vi.mocked 取回与收尾装配来自 helpers/session-runner-mocks.ts。
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import { getSubagentSessionDir } from "../path-encoding.ts";
-
-// ── mock modules（同 session-runner-schema-env.test.ts 模式，工厂单源在 spawn-mock.ts）──
-
-vi.mock("node:child_process", async () =>
-  (await import("./helpers/spawn-mock.ts")).childProcessModule());
-vi.mock("node:fs", async () => (await import("./helpers/spawn-mock.ts")).fsModule());
-vi.mock("../alive-store.ts", async () =>
-  (await import("./helpers/spawn-mock.ts")).aliveStoreModule());
-vi.mock("../engine/engines/pi/temp-prompt.ts", async () =>
-  (await import("./helpers/spawn-mock.ts")).tempPromptModule());
-
-import { runSpawn } from "../engine/engines/pi/session-runner.ts";
-import {
-  getLastSpawnEnv,
-  makeRunOpts,
-  makeVisibilityCtx,
-  makeVisibilityRecord,
-  waitForSpawn,
-} from "./helpers/spawn-mock.ts";
-import { closeLastChildAndAwait, takeSessionRunnerMocks } from "./helpers/session-runner-mocks.ts";
-
-const { mockSpawn, mockExistsSync } = takeSessionRunnerMocks();
-
-/** runSpawn 前奏装配：启动、等 spawn 落位、取回 childEnv（断言留在各用例）。 */
-async function spawnAndCaptureEnv(
-  record: ReturnType<typeof makeVisibilityRecord>,
-  task: string,
-  opts: ReturnType<typeof makeRunOpts>,
-  ctx: ReturnType<typeof makeVisibilityCtx>,
-): Promise<{ resultPromise: Promise<unknown>; childEnv: Record<string, string | undefined> }> {
-  const resultPromise = runSpawn(record, task, opts, ctx);
-  await waitForSpawn(mockSpawn);
-  return { resultPromise, childEnv: getLastSpawnEnv(mockSpawn) };
-}
-
-// ── runSpawn childEnv 身份 env 注入（场景 1b）──
-
-describe("runSpawn 跨进程身份 env 注入（递归可见性场景 1b）", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockExistsSync.mockReturnValue(false);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("非 fork（fork=false/undefined）：无条件注入 4 个身份 env（决策 2）", async () => {
-    const record = makeVisibilityRecord({ id: "sa-aaa", depth: 0 });
-    const ctx = makeVisibilityCtx({ sessionRootId: "root-main" });
-    const opts = makeRunOpts({ fork: false });
-
-    const { resultPromise, childEnv } = await spawnAndCaptureEnv(record, "test task", opts, ctx);
-
-    expect(childEnv.PI_SUBAGENT_ROOT_SESSION_ID).toBe("root-main");
-    expect(childEnv.PI_SUBAGENT_SELF_RECORD_ID).toBe("sa-aaa");
-    expect(childEnv.PI_SUBAGENT_DEPTH).toBe("0");
-    // [MF-3] 第 4 个贯穿 env：ROOT cwd（子进程落盘目录编码键）
-    expect(childEnv.PI_SUBAGENT_ROOT_CWD).toBe("/fake/cwd");
-    // fork=false 不注入 fork depth env（与既有行为一致，本测试不改变它）
-    expect(childEnv.PI_SUBAGENT_FORK_DEPTH).toBeUndefined();
-
-    await closeLastChildAndAwait(resultPromise);
-  });
-
-  it("fork=true：4 个身份 env 与 fork depth env 共存（决策 2 无条件注入不依赖 fork）", async () => {
-    const record = makeVisibilityRecord({ id: "sa-bbb", depth: 2 });
-    const ctx = makeVisibilityCtx({ sessionRootId: "root-main" });
-    const opts = makeRunOpts({ fork: true, parentForkDepth: 1 });
-
-    const { resultPromise, childEnv } = await spawnAndCaptureEnv(record, "test task", opts, ctx);
-
-    // 身份 env 无条件存在（决策 2）
-    expect(childEnv.PI_SUBAGENT_ROOT_SESSION_ID).toBe("root-main");
-    expect(childEnv.PI_SUBAGENT_SELF_RECORD_ID).toBe("sa-bbb");
-    expect(childEnv.PI_SUBAGENT_DEPTH).toBe("2");
-    expect(childEnv.PI_SUBAGENT_ROOT_CWD).toBe("/fake/cwd");
-    // fork depth env 同时存在（fork=true + parentForkDepth=1 → 2）
-    expect(childEnv.PI_SUBAGENT_FORK_DEPTH).toBe("2");
-
-    await closeLastChildAndAwait(resultPromise);
-  });
-
-  it("深层 record（depth=3）：DEPTH env = String(record.depth)，正确贯穿嵌套层级", async () => {
-    const record = makeVisibilityRecord({ id: "sa-deep", depth: 3 });
-    const ctx = makeVisibilityCtx({ sessionRootId: "root-topmost" });
-
-    const { resultPromise, childEnv } = await spawnAndCaptureEnv(record, "test task", makeRunOpts(), ctx);
-
-    expect(childEnv.PI_SUBAGENT_DEPTH).toBe("3");
-    expect(childEnv.PI_SUBAGENT_SELF_RECORD_ID).toBe("sa-deep");
-    expect(childEnv.PI_SUBAGENT_ROOT_SESSION_ID).toBe("root-topmost");
-
-    await closeLastChildAndAwait(resultPromise);
-  });
-
-  it("ROOT_SESSION_ID 恒等于 ctx.sessionRootId（贯穿真 ROOT，非 record.rootSessionId）", async () => {
-    // record.rootSessionId 是 createRecord 时写入的值（可能来自旧逻辑），但 env 注入用的是
-    // ctx.sessionRootId（经 buildSessionRunnerContext 从 this.sessionRootId 透传，贯穿真 ROOT）。
-    // 这保证深层 subagent 的子进程仍归顶层 ROOT（设计决策 1/3）。
-    const record = makeVisibilityRecord({ id: "sa-ccc" }); // record.rootSessionId = fixture 默认值
-    const ctx = makeVisibilityCtx({ sessionRootId: "real-root-session" });
-
-    const { resultPromise, childEnv } = await spawnAndCaptureEnv(record, "test task", makeRunOpts(), ctx);
-
-    // env 用 ctx.sessionRootId，不是 record.rootSessionId
-    expect(childEnv.PI_SUBAGENT_ROOT_SESSION_ID).toBe("real-root-session");
-    expect(childEnv.PI_SUBAGENT_ROOT_SESSION_ID).not.toBe(record.rootSessionId);
-
-    await closeLastChildAndAwait(resultPromise);
-  });
-
-  it("[MF-3 回归] worktree 模式（mainCwd=checkout ≠ rootCwd）：sessionDir 用 ROOT cwd 编码，深层 record 落盘到 ROOT 可扫描段", async () => {
-    // 模拟 B（worktree 子进程）spawn C：ctx.cwd/mainCwd = checkout 路径，rootCwd = 真 ROOT cwd。
-    // 旧实现 sessionDir 用 ctx.mainCwd 编码 → enc(checkout) 段，ROOT 磁盘重建扫不到（MF-3）。
-    const rootCwd = "/root/project";
-    const checkoutPath = "/var/folders/worktree/pi-subagents/--root-project--/branch";
-    const agentDir = "/fake/agent";
-    const record = makeVisibilityRecord({ id: "sa-deep", depth: 2 });
-    const ctx = makeVisibilityCtx({ cwd: checkoutPath, mainCwd: checkoutPath, rootCwd, agentDir });
-
-    const { resultPromise, childEnv } = await spawnAndCaptureEnv(record, "test task", makeRunOpts(), ctx);
-    const spawnArgs = mockSpawn.mock.calls.at(-1)?.[1] as string[];
-
-    // 第 4 个 env 贯穿 ROOT cwd
-    expect(childEnv.PI_SUBAGENT_ROOT_CWD).toBe(rootCwd);
-    // spawn --session-dir 指向 enc(ROOT cwd)（非 enc(checkout)）
-    expect(spawnArgs).toContain(getSubagentSessionDir(agentDir, rootCwd));
-    expect(spawnArgs).not.toContain(getSubagentSessionDir(agentDir, checkoutPath));
-
-    await closeLastChildAndAwait(resultPromise);
-  });
-});

package/src/execution/__tests__/rpc-mode.test.ts

@@ -1,89 +0,0 @@
-// src/__tests__/rpc-mode.test.ts
-//
-// RPC 模式相关功能
-// 1. buildSpawnArgs 返回 --mode rpc（而非 json）
-// 2. parseSpawnLine 正确解析 Pi 原生 RpcResponse（type:response + command + success + data|error）
-
-import { describe, expect, it } from "vitest";
-
-import { buildSpawnArgs } from "../engine/engines/pi/session-runner.ts";
-import { parseSpawnLine } from "../engine/engines/pi/spawn-event-adapter.ts";
-
-describe("buildSpawnArgs - RPC mode", () => {
-  const baseParams = {
-    modelRef: { provider: "openai", id: "gpt-4" },
-    thinkingLevel: undefined,
-    agentTools: undefined,
-    appendSystemPromptPath: undefined,
-    sessionDir: "/tmp/sessions",
-    forkSource: undefined,
-    skillPaths: undefined,
-  };
-
-  it("生成 --mode rpc 参数（非 json）", () => {
-    const args = buildSpawnArgs(baseParams);
-    // 应包含 --mode rpc
-    expect(args).toContain("--mode");
-    const modeIdx = args.indexOf("--mode");
-    expect(args[modeIdx + 1]).toBe("rpc");
-  });
-
-  it("不包含 --mode json", () => {
-    const args = buildSpawnArgs(baseParams);
-    const modeIdx = args.indexOf("--mode");
-    expect(args[modeIdx + 1]).not.toBe("json");
-  });
-});
-
-describe("parseSpawnLine - RpcResponse", () => {
-  // Pi 原生 RpcResponse 格式（rpc-types.ts）：{type:"response", id?, command, success, data?, error?}
-  // W1 修复后 isRpcResponse 判 type:response + command:string + success:boolean（SR-1 根因 1b）
-
-  it("解析 Pi 原生 success response（kind=response）", () => {
-    const rpcResponse = JSON.stringify({
-      type: "response",
-      id: "req-123",
-      command: "run",
-      success: true,
-      data: { answers: [{ question: "Q1", answer: "A1" }] },
-    });
-    const result = parseSpawnLine(rpcResponse);
-    expect(result?.kind).toBe("response");
-    if (result?.kind === "response") {
-      expect(result.id).toBe("req-123");
-      expect(result.command).toBe("run");
-      expect(result.success).toBe(true);
-      expect(result.data).toEqual({ answers: [{ question: "Q1", answer: "A1" }] });
-    }
-  });
-
-  it("解析 Pi 原生 error response（kind=response）", () => {
-    const rpcError = JSON.stringify({
-      type: "response",
-      id: "req-456",
-      command: "run",
-      success: false,
-      error: "task failed: timeout",
-    });
-    const result = parseSpawnLine(rpcError);
-    expect(result?.kind).toBe("response");
-    if (result?.kind === "response") {
-      expect(result.id).toBe("req-456");
-      expect(result.success).toBe(false);
-      expect(result.error).toBe("task failed: timeout");
-    }
-  });
-
-  it("旧 JSON-RPC 2.0 格式不再归类为 response（W1 废弃）", () => {
-    // SR-1: 旧 {jsonrpc:"2.0", id, result} 无 type:response 字段，应落入 invalid
-    const oldRpc = JSON.stringify({ jsonrpc: "2.0", id: "req-old", result: { x: 1 } });
-    const result = parseSpawnLine(oldRpc);
-    expect(result?.kind).not.toBe("response");
-  });
-
-  it("非 response 类型的 JSON 不归类为 response", () => {
-    const normalEvent = JSON.stringify({ type: "tool_execution_start", toolName: "bash" });
-    const result = parseSpawnLine(normalEvent);
-    expect(result?.kind).not.toBe("response");
-  });
-});