const COMMAND_STDOUT_CAPTURE_MAX_CHARS = 8 * 1024 * 1024;

const COMMAND_STDERR_CAPTURE_MAX_CHARS = 128 * 1024;

const COMMAND_TIMEOUT_KILL_AFTER_MS = 5_000;

const COMMAND_PROCESS_TREE_EXIT_POLL_MS = 50;

const ACTIVE_CHILD_KILLERS = new Set();

const SIGNAL_EXIT_CODES = {

SIGHUP: 129,

});

let timedOut = false;

let killTimer;

let timeoutReject;

let forceKillAt;

const killChild = (signal) => {

if (useProcessGroup && child.pid) {

try {

};

const terminateChild = () => {

killChild("SIGTERM");

const killAfterMs = options.killAfterMs ?? COMMAND_TIMEOUT_KILL_AFTER_MS;

forceKillAt = Date.now() + killAfterMs;

killTimer = setTimeout(() => {

killTimer = undefined;

forceKillAt = undefined;

killChild("SIGKILL");

timeoutReject?.();

}, options.killAfterMs ?? COMMAND_TIMEOUT_KILL_AFTER_MS);

}, killAfterMs);

};

const timeout =

options.timeoutMs === undefined

}

if (killTimer && !timedOut) {

clearTimeout(killTimer);

forceKillAt = undefined;

}

ACTIVE_CHILD_KILLERS.delete(killChild);

if (

`${command} ${args.join(" ")} timed out after ${options.timeoutMs}ms`,

);

if (killTimer) {

timeoutReject = () => reject(timeoutError);

void finishTimedOutProcessTree(child, {

forceKillAt,

killChild,

killTimer,

killAfterMs: options.killAfterMs ?? COMMAND_TIMEOUT_KILL_AFTER_MS,

useProcessGroup,

}).then(() => reject(timeoutError), reject);

return;

}

reject(timeoutError);

});

}

async function finishTimedOutProcessTree(

child,

{ forceKillAt, killAfterMs, killChild, killTimer, useProcessGroup },

) {

const graceRemainingMs =

forceKillAt === undefined ? killAfterMs : Math.max(0, forceKillAt - Date.now());

if (graceRemainingMs > 0) {

await waitForProcessTreeExit(child, graceRemainingMs, useProcessGroup);

}

clearTimeout(killTimer);

if (processTreeIsAlive(child, useProcessGroup)) {

killChild("SIGKILL");

await waitForProcessTreeExit(child, killAfterMs, useProcessGroup);

}

}

function childHasExited(child) {

return child.exitCode !== null || child.signalCode !== null;

}

function processTreeIsAlive(child, useProcessGroup) {

if (!child || typeof child.pid !== "number") {

return false;

}

if (!useProcessGroup) {

return !childHasExited(child);

}

try {

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

return true;

} catch (error) {

return error?.code === "EPERM";

}

}

async function waitForProcessTreeExit(child, timeoutMs, useProcessGroup) {

const deadlineAt = Date.now() + timeoutMs;

while (Date.now() < deadlineAt) {

if (!processTreeIsAlive(child, useProcessGroup)) {

return true;

}

await new Promise((resolvePoll) => {

setTimeout(resolvePoll, COMMAND_PROCESS_TREE_EXIT_POLL_MS);

});

}

return !processTreeIsAlive(child, useProcessGroup);

}

function appendBoundedCommandOutput(buffer, chunk, maxChars) {

const nextText = buffer.text + String(chunk);

if (nextText.length <= maxChars) {