@zhushanwen/pi-subagent-workflow 8.5.0 → 8.7.0

package/src/execution/__tests__/subagent-service-parent-guard.test.ts

@@ -1,180 +0,0 @@
-// src/execution/__tests__/subagent-service-parent-guard.test.ts
-//
-// [v4 A-5 / P7] getRecordForAction 直接父校验单元测试。
-//
-// 背景：递归 subagent 场景下，孙级 record（parentRecordId = 某子进程的 self recordId）
-// 的子进程句柄只存在于其直接父进程内存。SP-8 后全树 record 的 rootSessionId 贯穿真 ROOT，
-// 旧实现 getRecordForAction 仅校验 rootSessionId → 主进程可凭 rootSessionId 通过 message 孙级，
-// 但孙级 B 的子进程句柄只在 A 进程里 → 主进程走冷路径重新 spawn → 双写同一 session 文件（P7）。
-//
-// 修复：rootSessionId 校验之后增加直接父校验——record.parentRecordId 必须等于本进程
-// execCtxBaseline.recordId（主进程 baseline=null → 只能操作根层 record）。
-//
-// 本测试 mock execCtxBaseline 三种身份（undefined=主进程 / sa-A=直接父 / sa-B=兄弟进程），
-// 断言对 record B（parentRecordId=sa-A）及顶层 record 的操作权限矩阵。
-
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-// mock logger（import 链需要 getLogger 存在）
-const { loggerMock } = vi.hoisted(() => ({
-  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn(), info: vi.fn() },
-}));
-vi.mock("@zhushanwen/pi-extension-logger", () => ({ getLogger: () => loggerMock }));
-
-// mock session-runner（import 链需要 runSpawn/killAllSpawnedChildren/getChildByRecord 存在）
-vi.mock("../session-runner.ts", () => ({
-  runSpawn: vi.fn(),
-  killAllSpawnedChildren: vi.fn(),
-  getChildByRecord: vi.fn(() => undefined),
-}));
-
-import { createRecord } from "../execution-record.ts";
-import { ModelConfigService } from "../model-config-service.ts";
-import { RecordStore } from "../record-store.ts";
-import { SubagentService } from "../subagent-service.ts";
-import type { PiLike } from "../subagent-service.ts";
-import type { ExecutionRecord } from "../types.ts";
-
-type Baseline = { recordId: string | undefined; depth: number } | null;
-const MAIN_PROCESS: Baseline = null;
-const PARENT_A: Baseline = { recordId: "sa-A", depth: 1 };
-const SIBLING_B: Baseline = { recordId: "sa-B", depth: 1 };
-
-function makeTmpAgentDir(): string {
-  return fs.mkdtempSync(path.join(os.tmpdir(), "parent-guard-"));
-}
-
-function makePi(): PiLike {
-  return {
-    appendEntry: vi.fn(),
-    events: { emit: vi.fn() },
-    sendMessage: vi.fn(),
-  } as unknown as PiLike;
-}
-
-/** 暴露私有字段供测试注入身份。 */
-interface ServiceInternals {
-  store: RecordStore;
-  sessionRootId: string | null;
-  execCtxBaseline: { recordId: string | undefined; depth: number } | null;
-}
-
-/** 构造一个 chatMode idle record（message/close action 的典型目标态）。 */
-function makeRecord(
-  id: string,
-  sessionRootId: string,
-  overrides: Partial<ExecutionRecord> = {},
-): ExecutionRecord {
-  return createRecord(id, {
-    agent: "general-purpose",
-    model: "test/model",
-    mode: "background",
-    task: "test",
-    slug: "test",
-    startedAt: 1000,
-    rootSessionId: sessionRootId,
-    chatMode: true,
-    controller: new AbortController(),
-    ...overrides,
-  });
-}
-
-describe("[v4 A-5 / P7] getRecordForAction 直接父校验", () => {
-  let agentDir: string;
-  let service: SubagentService;
-  let store: RecordStore;
-  let sessionRootId: string;
-  let internals: ServiceInternals;
-
-  beforeEach(() => {
-    agentDir = makeTmpAgentDir();
-    const modelService = new ModelConfigService({ agentDir });
-    service = new SubagentService({ cwd: agentDir, modelService });
-    // initSession 建立 sessionRootId=sessionId（本 session 树的根）。execCtxBaseline 的
-    // 真实值由 initSession 从 env 读取（见 recursive-visibility-baseline.test.ts），但本测试
-    // 聚焦守卫逻辑，故每例直接注入身份（mock），不依赖进程 env（测试进程可能继承 subagent env）。
-    service.initSession({ pi: makePi(), sessionId: "root-session" });
-    internals = service as unknown as ServiceInternals;
-    store = internals.store;
-    sessionRootId = internals.sessionRootId!;
-  });
-
-  afterEach(() => {
-    service.dispose();
-    fs.rmSync(agentDir, { recursive: true, force: true });
-  });
-
-  // ---------- 身份 sa-A：直接父，放行孙级 B ----------
-
-  it("身份=sa-A（直接父）→ 放行操作孙级 record B（parentRecordId=sa-A）", () => {
-    const recordB = makeRecord("sa-B", sessionRootId, { parentRecordId: "sa-A", depth: 2, status: "idle" });
-    store.register(recordB);
-    internals.execCtxBaseline = PARENT_A;
-
-    expect(service.getRecordForAction("sa-B")).toBe(recordB);
-  });
-
-  // ---------- 身份 undefined（主进程）：拒绝孙级，放行根层 ----------
-
-  it("身份=undefined（主进程）拒绝孙级 record B，错误含 'direct parent' + 'parent=sa-A'", () => {
-    const recordB = makeRecord("sa-B", sessionRootId, { parentRecordId: "sa-A", depth: 2, status: "idle" });
-    store.register(recordB);
-    internals.execCtxBaseline = MAIN_PROCESS;
-
-    expect(() => service.getRecordForAction("sa-B")).toThrow(/direct parent/);
-    expect(() => service.getRecordForAction("sa-B")).toThrow(/see \/subagents list, parent=sa-A/);
-  });
-
-  it("身份=undefined（主进程）放行顶层 record（parentRecordId=undefined 视为根层）", () => {
-    const topRecord = makeRecord("sa-top", sessionRootId, { parentRecordId: undefined, depth: 0, status: "idle" });
-    store.register(topRecord);
-    internals.execCtxBaseline = MAIN_PROCESS;
-
-    expect(service.getRecordForAction("sa-top")).toBe(topRecord);
-  });
-
-  // ---------- 身份 sa-B（兄弟进程）：拒绝孙级 ----------
-
-  it("身份=sa-B（兄弟进程）拒绝孙级 record B（parentRecordId=sa-A ≠ baseline sa-B）", () => {
-    const recordB = makeRecord("sa-B", sessionRootId, { parentRecordId: "sa-A", depth: 2, status: "idle" });
-    store.register(recordB);
-    internals.execCtxBaseline = SIBLING_B;
-
-    expect(() => service.getRecordForAction("sa-B")).toThrow(/direct parent/);
-    expect(() => service.getRecordForAction("sa-B")).toThrow(/see \/subagents list, parent=sa-A/);
-  });
-
-  // ---------- 身份缺省语义 + 更深递归 ----------
-
-  it("子进程（baseline=sa-A）拒绝顶层 record（身份缺省视为根层，仅主进程可操作）", () => {
-    const topRecord = makeRecord("sa-top", sessionRootId, { parentRecordId: undefined, depth: 0, status: "idle" });
-    store.register(topRecord);
-    internals.execCtxBaseline = PARENT_A;
-
-    expect(() => service.getRecordForAction("sa-top")).toThrow(/direct parent/);
-  });
-
-  it("P7 场景：主进程拒绝曾孙 record C（parentRecordId=sa-B），错误含 baseline=root + parent=sa-B", () => {
-    const recordC = makeRecord("sa-C", sessionRootId, { parentRecordId: "sa-B", depth: 3, status: "idle" });
-    store.register(recordC);
-    internals.execCtxBaseline = MAIN_PROCESS;
-
-    const fn = () => service.getRecordForAction("sa-C");
-    expect(fn).toThrow(/direct parent/);
-    expect(fn).toThrow(/see \/subagents list, parent=sa-B/);
-    expect(fn).toThrow(/baseline=\(root\)/);
-  });
-
-  it("rootSessionId 不匹配仍优先拒绝（直接父校验在 rootSessionId 校验之后，不绕过归属守卫）", () => {
-    // 跨 session 树的 record：rootSessionId 不匹配 → 走首个 throw（not found or not owned）
-    const foreignRecord = makeRecord("sa-foreign", "other-session", { parentRecordId: "sa-A", depth: 2, status: "idle" });
-    store.register(foreignRecord);
-    internals.execCtxBaseline = PARENT_A;
-
-    expect(() => service.getRecordForAction("sa-foreign")).toThrow(/not found or not owned/);
-  });
-});