import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";

import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";

import { tmpdir } from "node:os";

import path from "node:path";

import { setTimeout as delay } from "node:timers/promises";

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

import {

appendBoundedOutput,

fetchJson,

findDistCallGatewayModuleFiles,

makeEnv,

runCommand,

sampleProcess,

sampleWindowsProcessByPort,

summarizeProcessSamples,

usesBuiltOpenClawEntry,

} from "../../scripts/e2e/kitchen-sink-rpc-walk.mjs";

const posixIt = process.platform === "win32" ? it.skip : it;

describe("kitchen-sink RPC isolated state", () => {

it("cleans up the generated temporary home tree", async () => {

const { root, env } = makeEnv();

const second = appendBoundedOutput(first, "ghij", 5);

expect(second).toEqual({ text: "fghij", truncatedChars: 5 });

});

posixIt("kills timed command process groups", async () => {

const root = mkdtempSync(path.join(tmpdir(), "openclaw-kitchen-rpc-timeout-"));

const scriptPath = path.join(root, "trap-term.mjs");

const grandchildPidPath = path.join(root, "grandchild.pid");

let grandchildPid = 0;

writeFileSync(

scriptPath,

`

import { spawn } from "node:child_process";

import fs from "node:fs";

const grandchild = spawn(process.execPath, [

"-e",

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

], { stdio: "ignore" });

fs.writeFileSync(process.argv[2], String(grandchild.pid));

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

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

`,

"utf8",

);

const runPromise = runCommand(process.execPath, [scriptPath, grandchildPidPath], {

detached: undefined,

timeoutKillGraceMs: 50,

timeoutMs: 2000,

});

try {

await waitFor(() => existsSync(grandchildPidPath));

grandchildPid = Number.parseInt(readText(grandchildPidPath), 10);

expect(Number.isInteger(grandchildPid)).toBe(true);

expect(isProcessAlive(grandchildPid)).toBe(true);

await expect(runPromise).rejects.toThrow("timed out after 2000ms");

await waitFor(() => !isProcessAlive(grandchildPid), 5_000);

} finally {

await runPromise.catch(() => {});

if (grandchildPid && isProcessAlive(grandchildPid)) {

process.kill(grandchildPid, "SIGKILL");

}

rmSync(root, { recursive: true, force: true });

}

});

});

describe("kitchen-sink RPC caller loading", () => {

expect(() => assertResourceCeiling(null)).toThrow("gateway RSS sample was not captured");

});

});

function readText(file: string) {

return readFileSync(file, "utf8");

}

async function waitFor(condition: () => boolean, timeoutMs = 3_000) {

const startedAt = Date.now();

while (!condition()) {

if (Date.now() - startedAt > timeoutMs) {

throw new Error("timed out waiting for condition");

}

await delay(25);

}

}

function isProcessAlive(pid: number) {

try {

process.kill(pid, 0);

return true;

} catch {

return false;

}

}