@actiondock/testing 2.2.2 → 2.4.0

package/dist/process-driver.js

@@ -0,0 +1,376 @@
+import { randomUUID } from "node:crypto";
+/**
+ * 确定性测试专用进程驱动桩。
+ * 遵循《ActionDock Managed Process 设计 v2》第 11、12 节契约：
+ * - 支持确定性模拟输出（emitOutput）
+ * - 支持确定性模拟退出（emitExit）
+ * - 支持确定性模拟输出关闭（emitOutputClosed）
+ * - 支持确定性模拟故障注入（emitFault）
+ * - 记录完整写入（writes）、EOF 调用、resize 与 terminate 操作历史
+ * - 支持模拟各阶段操作失败注入用于健壮性测试
+ */
+export class FakeProcessDriver {
+    capabilities;
+    handles = new Map();
+    /** 记录所有派生调用 */
+    spawnCalls = [];
+    /** 记录所有写入调用 */
+    writes = [];
+    /** 记录所有 EOF 调用 */
+    eofCalls = [];
+    /** 记录所有前台中断调用 */
+    interruptCalls = [];
+    /** 记录所有调整尺寸调用 */
+    resizeCalls = [];
+    /** 记录所有终止调用 */
+    terminateCalls = [];
+    /** 记录所有销毁调用 */
+    disposeCalls = [];
+    /** 故障注入：下一次派生将抛出的异常 */
+    nextSpawnError;
+    /** 故障注入：写入时将抛出的异常 */
+    nextWriteError;
+    /** 故障注入：调整尺寸时将抛出的异常 */
+    nextResizeError;
+    /** 故障注入：终止时将抛出的异常 */
+    nextTerminateError;
+    /** 自动响应回调：在进程派生后触发 */
+    onSpawn;
+    constructor(capabilities) {
+        this.capabilities = {
+            pty: true,
+            resize: true,
+            inputEOF: true,
+            interruptForeground: true,
+            terminationScope: "process-tree",
+            ...capabilities,
+        };
+    }
+    /**
+     * 获取驱动能力集合。
+     */
+    getCapabilities() {
+        return { ...this.capabilities };
+    }
+    /**
+     * 覆盖驱动能力集合。
+     */
+    setCapabilities(caps) {
+        this.capabilities = { ...this.capabilities, ...caps };
+    }
+    async spawn(specOrProcessId, observerOrSpec, maybeCallbacks) {
+        if (typeof specOrProcessId === "string") {
+            const processId = specOrProcessId;
+            const spec = observerOrSpec;
+            const callbacks = maybeCallbacks;
+            return this.spawnLegacy(processId, spec, callbacks);
+        }
+        const spec = specOrProcessId;
+        const observer = observerOrSpec;
+        return this.spawnStandard(spec, observer);
+    }
+    /**
+     * 标准接口实现派生新进程。
+     */
+    async spawnStandard(spec, observer, customId) {
+        if (this.nextSpawnError) {
+            const err = this.nextSpawnError;
+            this.nextSpawnError = undefined;
+            // 与 NodeProcessDriver 的 spawn 失败契约对齐：fault + exited（spawn 失败语义）+ outputClosed 三件套
+            observer.fault?.(err);
+            observer.exited({ code: null, signal: null });
+            observer.outputClosed("natural");
+            throw err;
+        }
+        const id = customId ?? randomUUID();
+        const pid = Math.floor(10000 + Math.random() * 90000);
+        const internalHandle = {
+            id,
+            pid,
+            spec,
+            observer,
+            disposed: false,
+            write: (data) => this.write(internalHandle, data),
+            sendInputEOF: () => this.inputEOF(internalHandle),
+            interruptForeground: () => this.interruptForeground(internalHandle),
+            resize: (cols, rows) => this.resize(internalHandle, cols, rows),
+            terminate: (graceMs) => this.terminate(internalHandle, graceMs),
+            emitOutput: (stream, data) => this.emitOutput(id, stream, data),
+            emitExit: (result) => this.emitExit(id, result),
+            emitOutputClosed: (reason) => this.emitOutputClosed(id, reason),
+            emitFault: (err) => this.emitFault(id, err),
+        };
+        this.handles.set(id, internalHandle);
+        const recorded = {
+            handle: internalHandle,
+            spec,
+            observer,
+            timestamp: Date.now(),
+        };
+        this.spawnCalls.push(recorded);
+        if (this.onSpawn) {
+            this.onSpawn(internalHandle, spec, observer);
+        }
+        return internalHandle;
+    }
+    /**
+     * 模拟写入数据并记录历史。
+     */
+    async write(handle, data) {
+        if (this.nextWriteError) {
+            const err = this.nextWriteError;
+            this.nextWriteError = undefined;
+            throw err;
+        }
+        const copy = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        this.writes.push({
+            handle,
+            data: copy,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * 模拟输入流关闭并记录历史。
+     */
+    async inputEOF(handle) {
+        this.eofCalls.push({
+            handle,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * 模拟中断前台作业并记录历史。
+     */
+    async interruptForeground(handle) {
+        this.interruptCalls.push({
+            handle,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * 模拟调整终端尺寸并记录历史。
+     */
+    async resize(handle, cols, rows) {
+        if (this.nextResizeError) {
+            const err = this.nextResizeError;
+            this.nextResizeError = undefined;
+            throw err;
+        }
+        this.resizeCalls.push({
+            handle,
+            cols,
+            rows,
+            timestamp: Date.now(),
+        });
+    }
+    async terminate(handleOrId, graceMs) {
+        if (this.nextTerminateError) {
+            const err = this.nextTerminateError;
+            this.nextTerminateError = undefined;
+            throw err;
+        }
+        const targetHandle = typeof handleOrId === "string" ? this.handles.get(handleOrId) : handleOrId;
+        if (targetHandle) {
+            this.terminateCalls.push({
+                handle: targetHandle,
+                graceMs,
+                timestamp: Date.now(),
+            });
+            // 终止即退出：以 SIGTERM 语义通知观察者，保证上层等待链路收敛
+            this.emitExit(targetHandle, { code: null, signal: "SIGTERM" });
+        }
+    }
+    /**
+     * 模拟销毁进程并记录历史。
+     */
+    async dispose(handle) {
+        const internal = this.handles.get(handle.id);
+        if (internal) {
+            internal.disposed = true;
+        }
+        this.disposeCalls.push({
+            handle,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * 确定性模拟向观察者发送输出。
+     */
+    emitOutput(handleOrId, stream, data) {
+        const internal = this.resolveInternal(handleOrId);
+        const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+        internal.observer.output(stream, bytes);
+    }
+    /**
+     * 确定性模拟进程退出事件。
+     */
+    emitExit(handleOrId, result) {
+        const internal = this.resolveInternal(handleOrId);
+        let code = 0;
+        let signal = null;
+        if (typeof result === "number") {
+            code = result;
+        }
+        else if (result) {
+            code = result.code !== undefined ? result.code : 0;
+            signal = result.signal ?? null;
+        }
+        internal.observer.exited({ code, signal });
+    }
+    /**
+     * 确定性模拟输出流彻底关闭事件。
+     */
+    emitOutputClosed(handleOrId, reason = "natural") {
+        const internal = this.resolveInternal(handleOrId);
+        internal.observer.outputClosed(reason);
+    }
+    /**
+     * 确定性模拟驱动故障通知。
+     */
+    emitFault(handleOrId, error) {
+        const internal = this.resolveInternal(handleOrId);
+        internal.observer.fault?.(error);
+    }
+    /**
+     * 注入下一次 spawn 故障异常。
+     */
+    simulateSpawnFailure(error) {
+        this.nextSpawnError = error;
+    }
+    /**
+     * 注入下一次 write 故障异常。
+     */
+    simulateWriteFailure(error) {
+        this.nextWriteError = error;
+    }
+    /**
+     * 注入下一次 resize 故障异常。
+     */
+    simulateResizeFailure(error) {
+        this.nextResizeError = error;
+    }
+    /**
+     * 注入下一次 terminate 故障异常。
+     */
+    simulateTerminateFailure(error) {
+        this.nextTerminateError = error;
+    }
+    /**
+     * 获取最近创建的进程句柄。
+     */
+    getLastHandle() {
+        const last = this.spawnCalls[this.spawnCalls.length - 1];
+        return last?.handle;
+    }
+    /**
+     * 查询指定句柄标识对应的句柄实例。
+     */
+    getHandle(handleOrId) {
+        const id = typeof handleOrId === "string" ? handleOrId : handleOrId.id;
+        return this.handles.get(id);
+    }
+    /**
+     * 查询指定句柄对应的观察者。
+     */
+    getObserver(handleOrId) {
+        const id = typeof handleOrId === "string" ? handleOrId : handleOrId.id;
+        return this.handles.get(id)?.observer;
+    }
+    /**
+     * 获取针对指定句柄（或全部句柄）的写入字节切片列表。
+     */
+    getWrites(handleOrId) {
+        if (!handleOrId) {
+            return this.writes.map((w) => w.data);
+        }
+        const id = typeof handleOrId === "string" ? handleOrId : handleOrId.id;
+        return this.writes.filter((w) => w.handle.id === id).map((w) => w.data);
+    }
+    /**
+     * 获取针对指定句柄（或全部句柄）写入的 UTF-8 解码文本列表。
+     */
+    getWrittenStrings(handleOrId) {
+        const decoder = new TextDecoder();
+        return this.getWrites(handleOrId).map((chunk) => decoder.decode(chunk));
+    }
+    /**
+     * 判断指定句柄是否接收到了 EOF 输入结束通知。
+     */
+    hasInputEOF(handleOrId) {
+        if (!handleOrId) {
+            return this.eofCalls.length > 0;
+        }
+        const id = typeof handleOrId === "string" ? handleOrId : handleOrId.id;
+        return this.eofCalls.some((c) => c.handle.id === id);
+    }
+    /**
+     * 判断指定句柄是否接收到了前台作业中断通知。
+     */
+    hasInterrupted(handleOrId) {
+        if (!handleOrId) {
+            return this.interruptCalls.length > 0;
+        }
+        const id = typeof handleOrId === "string" ? handleOrId : handleOrId.id;
+        return this.interruptCalls.some((c) => c.handle.id === id);
+    }
+    /**
+     * 清除历史调用记录。
+     */
+    clearHistory() {
+        this.spawnCalls.length = 0;
+        this.writes.length = 0;
+        this.eofCalls.length = 0;
+        this.interruptCalls.length = 0;
+        this.resizeCalls.length = 0;
+        this.terminateCalls.length = 0;
+        this.disposeCalls.length = 0;
+    }
+    /**
+     * 重置全部句柄、模拟规则与调用历史。
+     */
+    reset() {
+        this.clearHistory();
+        this.handles.clear();
+        this.nextSpawnError = undefined;
+        this.nextWriteError = undefined;
+        this.nextResizeError = undefined;
+        this.nextTerminateError = undefined;
+        this.onSpawn = undefined;
+    }
+    /**
+     * 兼容旧版基于 processId 派生新进程。
+     */
+    async spawnLegacy(processId, spec, callbacks) {
+        const observer = {
+            output(stream, data) {
+                callbacks.onOutput(stream, data);
+            },
+            exited(result) {
+                callbacks.onExit(result);
+            },
+            outputClosed(reason) {
+                callbacks.onOutputClosed?.(reason);
+            },
+            fault(err) {
+                callbacks.onError(err);
+            },
+        };
+        const handle = await this.spawnStandard(spec, observer, processId);
+        return handle;
+    }
+    /**
+     * 内部解析指定句柄或标识。
+     */
+    resolveInternal(handleOrId) {
+        const id = typeof handleOrId === "string" ? handleOrId : handleOrId.id;
+        const handle = this.handles.get(id);
+        if (!handle) {
+            throw new Error(`FakeProcessDriver: No handle found with id '${id}'`);
+        }
+        return handle;
+    }
+}
+/**
+ * 兼容原有命名导出。
+ */
+export { FakeProcessDriver as MockProcessDriver };

package/dist/process.d.ts

@@ -1,5 +1,6 @@
-import type { ProcessExecutor } from "@actiondock/core";
-import type { ProcessExecOptions, ProcessResult, RuntimeError } from "@actiondock/sdk";
+import { ProcessManager, type ProcessDriver, type ProcessExecutor, type ProcessOwner } from "@actiondock/core";
+import { type CallOptions, type ControlGrant, type OperationReceipt, type ProcessAcquireInput, type ProcessControlInput, type ProcessExecOptions, type ProcessInfo, type ProcessListInput, type ProcessListResult, type ProcessReadInput, type ProcessResult, type ProcessRunInput, type ProcessRunResult, type ProcessStartInput, type ProcessStartResult, type ProcessStopInput, type ProcessWriteInput, type ReadResult, type RuntimeError } from "@actiondock/sdk";
+import type { Clock } from "@actiondock/core";
 /**
  * 模拟命令匹配器。
  */
@@ -54,10 +55,19 @@ export interface ProcessCall {
 export interface MockProcessExecutorOptions {
     /** 未命中任何模拟规则时是否回退到真实子进程执行（默认 false，未命中即抛错） */
     fallbackToReal?: boolean;
+    /** 可选注入的底层进程驱动（默认使用 FakeProcessDriver） */
+    driver?: ProcessDriver;
+    /** 可选注入的受管进程管理器 */
+    processManager?: ProcessManager;
+    /** 默认受管进程归属所有者 */
+    owner?: ProcessOwner;
+    /** 可选注入的时钟：提供时模拟延时 delayMs 由时钟驱动（FakeClock 可确定性推进），未提供时回退真实 setTimeout */
+    clock?: Clock;
 }
 /**
  * 模拟进程执行器实现。
- * 遵循 ProcessExecutor 接口契约，支持预设命令响应、跟踪调用历史并模拟超时与取消场景。
+ * 遵循 ProcessExecutor / ProcessAPI 接口契约，支持预设命令响应、跟踪调用历史、
+ * 并无缝接入 ProcessManager 与 FakeProcessDriver 支撑受管进程全生命周期。
  *
  * 默认不回退真实子进程执行：未命中任何模拟规则时抛出明确错误，避免测试中的拼写失误穿透到真实系统命令。
  * 如确需真实回退（例如集成本地 CLI），可显式传入 fallbackToReal: true。
@@ -67,6 +77,11 @@ export declare class MockProcessExecutor implements ProcessExecutor {
     calls: ProcessCall[];
     defaultPid: number;
     private readonly fallbackToReal;
+    /** 可选时钟：提供时 waitDelay 以 clock.sleep 驱动，保证确定性测试 */
+    private readonly clock?;
+    readonly driver: ProcessDriver;
+    readonly processManager: ProcessManager;
+    readonly owner: ProcessOwner;
     constructor(options?: MockProcessExecutorOptions);
     /**
      * 注册模拟命令匹配与返回结果。
@@ -84,6 +99,63 @@ export declare class MockProcessExecutor implements ProcessExecutor {
      */
     exec(command: string, args?: string[], options?: ProcessExecOptions): Promise<ProcessResult>;
     spawn(command: string, args?: string[], options?: ProcessExecOptions): Promise<ProcessResult>;
+    /**
+    /**
+     * 优先匹配 mock 规则运行命令，未命中时委托至 ProcessManager。
+     */
+    private runWithMock;
+    /**
+     * 一次性运行外部命令并收集输出。
+     */
+    run(input: ProcessRunInput, call?: CallOptions): Promise<ProcessRunResult>;
+    /**
+     * 启动新的受管进程资源。
+     */
+    start(input: ProcessStartInput, call?: CallOptions): Promise<ProcessStartResult>;
+    /**
+     * 查看指定受管进程资源的状态快照。
+     */
+    inspect(id: string, call?: CallOptions): Promise<ProcessInfo>;
+    /**
+     * 列出当前作用域内可见的受管进程资源。
+     */
+    list(input: ProcessListInput, call?: CallOptions): Promise<ProcessListResult>;
+    /**
+     * 申请指定受管进程的独占控制令牌。
+     */
+    acquire(id: string, input: ProcessAcquireInput, call?: CallOptions): Promise<ControlGrant>;
+    /**
+     * 延长当前有效控制令牌的存活时间。
+     */
+    renew(id: string, token: string, ttlMs: number, call?: CallOptions): Promise<ControlGrant>;
+    /**
+     * 显式释放控制令牌。
+     */
+    release(id: string, token: string, call?: CallOptions): Promise<void>;
+    /**
+     * 向受管进程输入流写入原始字节数据。
+     */
+    write(id: string, input: ProcessWriteInput, call?: CallOptions): Promise<OperationReceipt>;
+    /**
+     * 查询指定请求标识的操作执行收据。
+     */
+    operation(id: string, requestId: string, call?: CallOptions): Promise<OperationReceipt>;
+    /**
+     * 按游标读取受管进程输出流。
+     */
+    read(id: string, input: ProcessReadInput, call?: CallOptions): Promise<ReadResult>;
+    /**
+     * 向受管进程发送结构化控制指令。
+     */
+    control(id: string, input: ProcessControlInput, call?: CallOptions): Promise<OperationReceipt>;
+    /**
+     * 终止指定的受管进程资源。
+     */
+    stop(id: string, input: ProcessStopInput, call?: CallOptions): Promise<ProcessInfo>;
+    /**
+     * 绑定指定所有者身份创建上下文进程接口，保持 mock 拦截与生命周期追踪。
+     */
+    forOwner(owner: ProcessOwner, runId?: string, signal?: AbortSignal): import("@actiondock/core").ContextProcessAPI;
     /**
      * 获取指定命令的历史调用记录。
      *

package/dist/process.js

@@ -1,7 +1,11 @@
+import { PROCESS_OUTPUT_LIMIT, ProcessManager, } from "@actiondock/core";
 import { execCli } from "./cli.js";
+import { encodeBytes, } from "@actiondock/sdk";
+import { FakeProcessDriver } from "./process-driver.js";
 /**
  * 模拟进程执行器实现。
- * 遵循 ProcessExecutor 接口契约，支持预设命令响应、跟踪调用历史并模拟超时与取消场景。
+ * 遵循 ProcessExecutor / ProcessAPI 接口契约，支持预设命令响应、跟踪调用历史、
+ * 并无缝接入 ProcessManager 与 FakeProcessDriver 支撑受管进程全生命周期。
  *
  * 默认不回退真实子进程执行：未命中任何模拟规则时抛出明确错误，避免测试中的拼写失误穿透到真实系统命令。
  * 如确需真实回退（例如集成本地 CLI），可显式传入 fallbackToReal: true。
@@ -11,8 +15,23 @@ export class MockProcessExecutor {
     calls = [];
     defaultPid = 10001;
     fallbackToReal;
+    /** 可选时钟：提供时 waitDelay 以 clock.sleep 驱动，保证确定性测试 */
+    clock;
+    driver;
+    processManager;
+    owner;
     constructor(options = {}) {
         this.fallbackToReal = options.fallbackToReal ?? false;
+        this.clock = options.clock;
+        this.driver = options.driver ?? new FakeProcessDriver();
+        this.processManager =
+            options.processManager ?? new ProcessManager({ driver: this.driver });
+        this.owner = options.owner ?? {
+            tenantId: "test-tenant",
+            principalId: "test-principal",
+            packageInstanceId: "test-package",
+            generationId: "test-generation",
+        };
     }
     /**
      * 注册模拟命令匹配与返回结果。
@@ -76,6 +95,7 @@ export class MockProcessExecutor {
                     timeout: options.timeoutMs,
                     input: options.input,
                     encoding: options.encoding,
+                    maxOutputBytes: options.maxOutputBytes,
                 });
                 resolved = {
                     ok: cliRes.ok,
@@ -85,6 +105,12 @@ export class MockProcessExecutor {
                     raw: cliRes.raw,
                     timedOut: cliRes.timedOut,
                     durationMs: cliRes.durationMs,
+                    error: cliRes.truncated && !cliRes.ok
+                        ? {
+                            code: PROCESS_OUTPUT_LIMIT,
+                            message: `Process output exceeded limit of ${options.maxOutputBytes} bytes`,
+                        }
+                        : undefined,
                 };
             }
             catch (err) {
@@ -167,6 +193,141 @@ export class MockProcessExecutor {
     async spawn(command, args = [], options = {}) {
         return this.exec(command, args, options);
     }
+    /**
+    /**
+     * 优先匹配 mock 规则运行命令，未命中时委托至 ProcessManager。
+     */
+    async runWithMock(input, owner, call) {
+        const args = input.spec.args ?? [];
+        const matchedMock = this.findMock(input.spec.executable, args, {
+            cwd: input.spec.cwd,
+            env: input.spec.env?.set,
+            timeoutMs: input.timeoutMs,
+            maxOutputBytes: input.maxOutputBytes,
+            signal: call?.signal,
+        });
+        // 仅在确实命中 mock 或显式开启真实回退时走 exec 路径；
+        // 其余情况（含已注册其他 mock 但本命令未命中）一律落入受管进程路径，
+        // 避免任意 mock 注册后未命中命令被错误拦截并抛「未命中」
+        if (matchedMock || this.fallbackToReal) {
+            const res = await this.exec(input.spec.executable, args, {
+                cwd: input.spec.cwd,
+                env: input.spec.env?.set,
+                timeoutMs: input.timeoutMs,
+                maxOutputBytes: input.maxOutputBytes,
+                signal: call?.signal,
+            });
+            const chunks = [];
+            if (res.stdout) {
+                chunks.push({
+                    stream: "stdout",
+                    data: encodeBytes(res.stdout),
+                });
+            }
+            if (res.stderr) {
+                chunks.push({
+                    stream: "stderr",
+                    data: encodeBytes(res.stderr),
+                });
+            }
+            return {
+                exit: { code: res.exitCode, signal: res.signal ?? null },
+                chunks,
+                truncated: Boolean(res.error?.code === "PROCESS_OUTPUT_LIMIT"),
+            };
+        }
+        return this.processManager.run(owner, input, call);
+    }
+    /**
+     * 一次性运行外部命令并收集输出。
+     */
+    async run(input, call) {
+        return this.runWithMock(input, this.owner, call);
+    }
+    /**
+     * 启动新的受管进程资源。
+     */
+    async start(input, call) {
+        return this.processManager.start(this.owner, input, call);
+    }
+    /**
+     * 查看指定受管进程资源的状态快照。
+     */
+    async inspect(id, call) {
+        return this.processManager.inspect(this.owner, id, call);
+    }
+    /**
+     * 列出当前作用域内可见的受管进程资源。
+     */
+    async list(input, call) {
+        return this.processManager.list(this.owner, input, call);
+    }
+    /**
+     * 申请指定受管进程的独占控制令牌。
+     */
+    async acquire(id, input, call) {
+        return this.processManager.acquire(this.owner, id, input, call);
+    }
+    /**
+     * 延长当前有效控制令牌的存活时间。
+     */
+    async renew(id, token, ttlMs, call) {
+        return this.processManager.renew(this.owner, id, token, ttlMs, call);
+    }
+    /**
+     * 显式释放控制令牌。
+     */
+    async release(id, token, call) {
+        return this.processManager.release(this.owner, id, token, call);
+    }
+    /**
+     * 向受管进程输入流写入原始字节数据。
+     */
+    async write(id, input, call) {
+        return this.processManager.write(this.owner, id, input, call);
+    }
+    /**
+     * 查询指定请求标识的操作执行收据。
+     */
+    async operation(id, requestId, call) {
+        return this.processManager.operation(this.owner, id, requestId, call);
+    }
+    /**
+     * 按游标读取受管进程输出流。
+     */
+    async read(id, input, call) {
+        return this.processManager.read(this.owner, id, input, call);
+    }
+    /**
+     * 向受管进程发送结构化控制指令。
+     */
+    async control(id, input, call) {
+        return this.processManager.control(this.owner, id, input, call);
+    }
+    /**
+     * 终止指定的受管进程资源。
+     */
+    async stop(id, input, call) {
+        return this.processManager.stop(this.owner, id, input, call);
+    }
+    /**
+     * 绑定指定所有者身份创建上下文进程接口，保持 mock 拦截与生命周期追踪。
+     */
+    forOwner(owner, runId, signal) {
+        const bound = this.processManager.forOwner(owner, runId, signal);
+        return new Proxy(bound, {
+            get: (target, prop, receiver) => {
+                if (prop === "run") {
+                    return (input, call) => {
+                        const mergedSignal = call?.signal ?? signal;
+                        const effectiveCall = mergedSignal ? { ...call, signal: mergedSignal } : call;
+                        return this.runWithMock(input, owner, effectiveCall);
+                    };
+                }
+                return Reflect.get(target, prop, receiver);
+            },
+        });
+    }
     /**
      * 获取指定命令的历史调用记录。
      *
@@ -204,6 +365,9 @@ export class MockProcessExecutor {
     reset() {
         this.mocks = [];
         this.calls = [];
+        if (this.driver instanceof FakeProcessDriver) {
+            this.driver.reset();
+        }
     }
     /**
      * 渲染已注册匹配器列表，辅助定位拼写失误。
@@ -247,6 +411,11 @@ export class MockProcessExecutor {
         return undefined;
     }
     async waitDelay(delayMs, options) {
+        // 注入时钟时优先 clock.sleep：由 FakeClock.advance 确定性驱动，不占用真实时间
+        if (this.clock) {
+            await this.clock.sleep(delayMs);
+            return;
+        }
         return new Promise((resolve) => {
             let timer;
             let onAbort;