// Run Additional Boundary Checks tests cover run additional boundary checks script behavior.

import fs from "node:fs";

import os from "node:os";

import path from "node:path";

import { describe, expect, it } from "vitest";

import {

BOUNDARY_CHECKS,

};

}

function isProcessAlive(pid: number): boolean {

try {

process.kill(pid, 0);

return true;

} catch {

return false;

}

}

async function sleep(ms: number): Promise<void> {

await new Promise((resolve) => {

setTimeout(resolve, ms);

});

}

async function waitForFile(filePath: string, timeoutMs: number): Promise<void> {

const deadlineAt = Date.now() + timeoutMs;

while (Date.now() < deadlineAt) {

if (fs.existsSync(filePath)) {

return;

}

await sleep(25);

}

throw new Error(`timeout waiting for ${filePath}`);

}

async function waitForDead(pid: number, timeoutMs: number): Promise<void> {

const deadlineAt = Date.now() + timeoutMs;

while (Date.now() < deadlineAt) {

if (!isProcessAlive(pid)) {

return;

}

await sleep(25);

}

throw new Error(`process still alive: ${pid}`);

}

describe("run-additional-boundary-checks", () => {

it("runs prompt snapshot drift checks in CI", () => {

expect(BOUNDARY_CHECKS[0]).toEqual({

expect(result.timedOut).toBe(true);

expect(result.output).toContain("timed out after 50ms");

});

it.skipIf(process.platform === "win32")(

"waits for timed-out process groups after the wrapper exits",

async () => {

const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-boundary-timeout-"));

const childPidPath = path.join(tempDir, "child.pid");

let childPid = 0;

try {

const childScript = [

"process.on('SIGTERM', () => {});",

"setInterval(() => {}, 1000);",

].join("");

const parentScript = [

"const { spawn } = require('node:child_process');",

"const fs = require('node:fs');",

`const child = spawn(process.execPath, ['-e', ${JSON.stringify(childScript)}], { stdio: 'ignore' });`,

"fs.writeFileSync(process.env.OPENCLAW_TEST_CHILD_PID, String(child.pid));",

"setInterval(() => {}, 1000);",

].join("");

const resultPromise = runSingleCheck(

{

label: "wrapper-exits",

command: process.execPath,

args: ["-e", parentScript],

},

{

checkTimeoutMs: 100,

cwd: process.cwd(),

env: { ...process.env, OPENCLAW_TEST_CHILD_PID: childPidPath },

outputMaxBytes: 4096,

},

);

await waitForFile(childPidPath, 2000);

childPid = Number(fs.readFileSync(childPidPath, "utf8"));

const result = await resultPromise;

expect(result.code).toBe(1);

expect(result.timedOut).toBe(true);

await waitForDead(childPid, 2000);

} finally {

if (childPid && isProcessAlive(childPid)) {

process.kill(childPid, "SIGKILL");

}

fs.rmSync(tempDir, { force: true, recursive: true });

}

},

);

});