let settled = false;

let canceled = false;

let killTimer;

let killDeadlineAt = 0;

const stdoutWriter = createPrefixedOutputWriter(label, process.stdout);

const stderrWriter = createPrefixedOutputWriter(label, process.stderr);

const killNodeStep = (signal) => signalNodeStep(child, signal);

const processGroupAlive = () => {

if (process.platform === "win32" || !child.pid) {

return false;

}

try {

process.kill(-child.pid, 0);

return true;

} catch (error) {

return Boolean(error && error.code === "EPERM");

}

};

const waitForProcessGroupExit = async (waitMs) => {

const deadlineAt = Date.now() + waitMs;

while (Date.now() < deadlineAt) {

if (!processGroupAlive()) {

return true;

}

await new Promise((resolvePoll) => {

setTimeout(resolvePoll, 25);

});

}

return !processGroupAlive();

};

const waitForCanceledStepTeardown = async () => {

const remainingGraceMs = Math.max(0, killDeadlineAt - Date.now());

if (remainingGraceMs > 0) {

await waitForProcessGroupExit(remainingGraceMs);

}

if (processGroupAlive()) {

killNodeStep("SIGKILL");

await waitForProcessGroupExit(100);

}

};

ACTIVE_NODE_STEP_KILLERS.add(killNodeStep);

const abortStep = () => {

if (settled || canceled) {

return;

}

canceled = true;

killNodeStep("SIGTERM");

killDeadlineAt = Date.now() + NODE_STEP_ABORT_KILL_GRACE_MS;

killTimer = setTimeout(() => {

killTimer = undefined;

killNodeStep("SIGKILL");

if (settled) {

return;

}

settled = true;

stdoutWriter.flush();

stderrWriter.flush();

if (exitingAfterParentSignal) {

killNodeStep("SIGKILL");

cleanup();

return;

}

if (canceled) {

killNodeStep("SIGKILL");

void (async () => {

settled = true;

stdoutWriter.flush();

stderrWriter.flush();

if (exitingAfterParentSignal) {

killNodeStep("SIGKILL");

cleanup();

return;

}

if (canceled) {

await waitForCanceledStepTeardown();

cleanup();

rejectPromise(new Error(`${label} canceled after sibling failure`));

return;

}

cleanup();

rejectPromise(new Error(`${label} canceled after sibling failure`));

return;

}

cleanup();

if (code === 0) {

resolvePromise();

return;

}

abortSiblingSteps(abortController);

rejectPromise(new Error(`${label} failed with exit code ${code ?? 1}`));

if (code === 0) {

resolvePromise();

return;

}

abortSiblingSteps(abortController);

rejectPromise(new Error(`${label} failed with exit code ${code ?? 1}`));

})();

});

});

}

runNodeSteps,

runNodeStepsInParallel,

} from "../../scripts/prepare-extension-package-boundary-artifacts.mjs";

import { makeTempDir } from "../helpers/temp-dir.js";

const tempRoots = new Set<string>();

},

);

it.runIf(process.platform !== "win32")(

"lets aborted sibling descendants drain during kill grace",

async () => {

const rootDir = makeTempDir(tempRoots, "openclaw-boundary-abort-drain-");

const readyPath = path.join(rootDir, "descendant.ready");

const drainedPath = path.join(rootDir, "descendant.drained");

const descendantScript = [

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

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

" setTimeout(() => {",

` fs.writeFileSync(${JSON.stringify(drainedPath)}, 'drained');`,

" process.exit(0);",

" }, 50);",

"});",

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

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

].join("\n");

const parentScript = [

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

`spawn(process.execPath, ["--eval", ${JSON.stringify(descendantScript)}], { stdio: "ignore" });`,

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

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

].join("\n");

const command = runNodeStepsInParallel([

{

label: "delayed-fail",

args: ["--eval", "setTimeout(() => process.exit(2), 150)"],

timeoutMs: 5_000,

},

{

label: "abort-group-drain",

args: ["--eval", parentScript],

timeoutMs: 60_000,

},

]);

await waitForFile(readyPath, 1_000);

await expect(command).rejects.toThrow("delayed-fail failed with exit code 2");

expect(fs.readFileSync(drainedPath, "utf8")).toBe("drained");

},

);

it("hard-kills timed out prep steps", async () => {

const signals: Array<NodeJS.Signals | number | undefined> = [];

const child = new EventEmitter() as EventEmitter & {