import fs from "node:fs";

import os from "node:os";

import path from "node:path";

import { pathToFileURL } from "node:url";

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

import {

acquireBoundaryCheckLock,

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

}

function waitForChildClose(

child: ReturnType<typeof spawn>,

timeoutMs = 5_000,

): Promise<{ code: number | null; signal: NodeJS.Signals | null }> {

return new Promise((resolve, reject) => {

const timeout = setTimeout(() => {

reject(new Error("child did not close before timeout"));

}, timeoutMs);

child.once("close", (code, signal) => {

clearTimeout(timeout);

resolve({ code, signal });

});

});

}

afterEach(() => {

for (const rootDir of tempRoots) {

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

},

);

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

"cleans active async node step descendants before forwarding parent SIGTERM",

async () => {

const root = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-extension-tsc-signal-"));

tempRoots.add(root);

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

const readyPath = path.join(root, "child.ready");

const scriptUrl = pathToFileURL(

path.resolve("scripts/check-extension-package-tsc-boundary.mjs"),

).href;

let childPid = 0;

let runner: ReturnType<typeof spawn> | undefined;

const childScript = [

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

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

`fs.writeFileSync(${JSON.stringify(childPidPath)}, String(process.pid));`,

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

].join("");

const parentScript = [

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

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

`require('node:fs').writeFileSync(${JSON.stringify(readyPath)}, 'ready');`,

"process.on('SIGTERM', () => process.exit(0));",

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

].join("");

const runnerScript = [

`import { runNodeStepAsync } from ${JSON.stringify(scriptUrl)};`,

`await runNodeStepAsync('parent-signal-step-group', ['--eval', ${JSON.stringify(

parentScript,

)}], 60_000);`,

].join("\n");

try {

runner = spawn(process.execPath, ["--input-type=module", "-e", runnerScript], {

cwd: process.cwd(),

stdio: ["ignore", "ignore", "pipe"],

});

await waitForFile(readyPath, 2_000);

await waitForFile(childPidPath, 2_000);

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

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

runner.kill("SIGTERM");

await expect(waitForChildClose(runner)).resolves.toEqual({

code: null,

signal: "SIGTERM",

});

await waitForDead(childPid, 2_000);

} finally {

if (runner?.pid && isProcessAlive(runner.pid)) {

runner.kill("SIGKILL");

}

if (childPid && isProcessAlive(childPid)) {

process.kill(childPid, "SIGKILL");

}

}

},

);

it("passes successful step timing metadata to onSuccess handlers", async () => {

const elapsedTimes: number[] = [];