| import fs from "node:fs/promises"; |
| import path from "node:path"; |
| import { afterEach, describe, expect, it, vi } from "vitest"; |
| import { useAutoCleanupTempDirTracker } from "../../test/helpers/temp-dir.js"; |
| import { |
| recordAgentCleanupFailure, |
| createAgentCleanupScope, |
| } from "../agents/run-cleanup-timeout.js"; |
| import { acquireGatewayLock, type GatewayLockOptions } from "../infra/gateway-lock.js"; |
| import type { RuntimeEnv } from "../runtime.js"; |
| import { agentExecCommand } from "./agent-exec.js"; |
|
|
| const tempDirs = useAutoCleanupTempDirTracker(afterEach); |
|
|
| function createRuntime() { |
| const error = vi.fn(); |
| const runtime: RuntimeEnv = { log: vi.fn(), error, exit: vi.fn() }; |
| return { runtime, error }; |
| } |
|
|
| function successResult() { |
| return { |
| payloads: [{ text: "done" }], |
| meta: { |
| durationMs: 1, |
| agentMeta: { sessionId: "session-result", provider: "openai", model: "gpt-5.6-sol" }, |
| }, |
| }; |
| } |
|
|
| function createGatewayLockOptions( |
| stateDir: string, |
| overrides: Partial<GatewayLockOptions> = {}, |
| ): GatewayLockOptions { |
| return { |
| allowInTests: true, |
| env: { |
| ...process.env, |
| OPENCLAW_CONFIG_PATH: path.join(stateDir, "openclaw.json"), |
| OPENCLAW_STATE_DIR: stateDir, |
| }, |
| lockDir: path.join(stateDir, "gateway-locks"), |
| timeoutMs: 100, |
| ...overrides, |
| }; |
| } |
|
|
| function createSignalProcess() { |
| type SignalName = "SIGINT" | "SIGTERM"; |
| const listeners = new Map<SignalName, Set<() => void>>(); |
| const processLike = { |
| on(signal: SignalName, handler: () => void) { |
| const current = listeners.get(signal) ?? new Set<() => void>(); |
| current.add(handler); |
| listeners.set(signal, current); |
| return processLike; |
| }, |
| off(signal: SignalName, handler: () => void) { |
| listeners.get(signal)?.delete(handler); |
| return processLike; |
| }, |
| }; |
| return { |
| processLike, |
| emit(signal: SignalName) { |
| for (const handler of listeners.get(signal) ?? []) { |
| handler(); |
| } |
| }, |
| }; |
| } |
|
|
| describe("agent exec retained-state ownership", () => { |
| it.each([false, true])( |
| "retains state after uncertain runtime cleanup (retained=%s)", |
| async (retained) => { |
| const root = tempDirs.make("openclaw-agent-exec-uncertain-cleanup-"); |
| const lockOptions = createGatewayLockOptions(root); |
| const previousStateDir = process.env.OPENCLAW_STATE_DIR; |
| const cleanupScope = createAgentCleanupScope(); |
| let runStateDir: string | undefined; |
| try { |
| const result = await cleanupScope.run(() => |
| agentExecCommand("inspect", retained ? { stateDir: root } : {}, createRuntime().runtime, { |
| gatewayLockOptions: lockOptions, |
| runAgent: async () => { |
| runStateDir = process.env.OPENCLAW_STATE_DIR; |
| if (!runStateDir) { |
| throw new Error("Expected the command's state directory"); |
| } |
| await fs.writeFile(path.join(runStateDir, "owned-work"), "still owned"); |
| recordAgentCleanupFailure(); |
| return successResult(); |
| }, |
| }), |
| ); |
| expect.soft(result.exitCode).toBe(1); |
| expect.soft(cleanupScope.outcome).toBe("uncertain"); |
| expect.soft(process.env.OPENCLAW_STATE_DIR).toBe(previousStateDir); |
| expect(runStateDir).toBeDefined(); |
| await expect(fs.readFile(path.join(runStateDir!, "owned-work"), "utf8")).resolves.toBe( |
| "still owned", |
| ); |
| if (retained) { |
| const owner = JSON.parse( |
| await fs.readFile(path.join(lockOptions.lockDir!, "gateway.state.lock"), "utf8"), |
| ); |
| expect(owner).toMatchObject({ pid: process.pid, role: "agent-embedded" }); |
| } |
| } finally { |
| if (!retained && runStateDir) { |
| await fs.rm(runStateDir, { recursive: true, force: true }); |
| } |
| } |
| }, |
| ); |
|
|
| it("refuses a state directory owned by a live Gateway", async () => { |
| const stateDir = tempDirs.make("openclaw-agent-exec-gateway-owner-"); |
| const lockOptions = createGatewayLockOptions(stateDir, { |
| readProcessStartTime: () => 123_456, |
| }); |
| const gatewayLock = await acquireGatewayLock({ ...lockOptions, port: 28789 }); |
| expect(gatewayLock).not.toBeNull(); |
| if (!gatewayLock) { |
| throw new Error("Expected live Gateway fixture lock"); |
| } |
| const runAgent = vi.fn(async () => successResult()); |
| const { runtime, error } = createRuntime(); |
|
|
| try { |
| const result = await agentExecCommand("inspect", { stateDir }, runtime, { |
| gatewayLockOptions: lockOptions, |
| runAgent, |
| }); |
| expect(result.exitCode).toBe(1); |
| expect(runAgent).not.toHaveBeenCalled(); |
| expect(error).toHaveBeenCalledWith( |
| `A Gateway is running for this state directory (pid ${process.pid}, port 28789). Omit --state-dir to use isolated temporary state, or stop the Gateway first (openclaw gateway stop).`, |
| ); |
| } finally { |
| await gatewayLock.release(); |
| } |
| }); |
|
|
| it("holds and releases the embedded state lock around the run", async () => { |
| const stateDir = tempDirs.make("openclaw-agent-exec-lock-owner-"); |
| const lockOptions = createGatewayLockOptions(stateDir); |
| const stateLockPath = path.join(lockOptions.lockDir!, "gateway.state.lock"); |
|
|
| await agentExecCommand("inspect", { stateDir }, createRuntime().runtime, { |
| gatewayLockOptions: lockOptions, |
| runAgent: vi.fn(async () => { |
| const payload = JSON.parse(await fs.readFile(stateLockPath, "utf8")) as { |
| pid?: number; |
| role?: string; |
| }; |
| expect(payload).toMatchObject({ pid: process.pid, role: "agent-embedded" }); |
| return successResult(); |
| }), |
| }); |
|
|
| await expect(fs.stat(stateLockPath)).rejects.toMatchObject({ code: "ENOENT" }); |
| }); |
|
|
| it("releases the embedded state lock when SIGTERM aborts the run", async () => { |
| const stateDir = tempDirs.make("openclaw-agent-exec-signal-owner-"); |
| const lockOptions = createGatewayLockOptions(stateDir); |
| const stateLockPath = path.join(lockOptions.lockDir!, "gateway.state.lock"); |
| const signals = createSignalProcess(); |
| const { runtime } = createRuntime(); |
| const runAgent = vi.fn(async (opts: Record<string, unknown>) => { |
| const signal = opts.abortSignal as AbortSignal; |
| return await new Promise<ReturnType<typeof successResult>>((_, reject) => { |
| signal.addEventListener( |
| "abort", |
| () => { |
| const error = new Error("agent exec aborted"); |
| error.name = "AbortError"; |
| reject(error); |
| }, |
| { once: true }, |
| ); |
| }); |
| }); |
|
|
| const run = agentExecCommand("inspect", { stateDir }, runtime, { |
| gatewayLockOptions: lockOptions, |
| process: signals.processLike, |
| runAgent, |
| }); |
| await vi.waitFor(() => expect(runAgent).toHaveBeenCalledOnce()); |
| signals.emit("SIGTERM"); |
| await run; |
|
|
| await expect(fs.stat(stateLockPath)).rejects.toMatchObject({ code: "ENOENT" }); |
| expect(runtime.exit).toHaveBeenCalledWith(143, { resetStream: process.stderr }); |
| }); |
| }); |
|
|
