const DEFAULT_MAX_RSS_WARN_MB = 1536;

const DEFAULT_QA_PLUGIN_CHUNK_SIZE = 12;

const COMMAND_OUTPUT_MAX_BUFFER_BYTES = 16 * 1024 * 1024;

const MAX_TIMER_TIMEOUT_MS = 2_147_000_000;

const ANSI_PATTERN = new RegExp(String.raw`\u001B\[[0-9;]*m`, "gu");

/**

return value.replace(ANSI_PATTERN, "");

}

function resolveTimerTimeoutMs(valueMs) {

const value = Number.isFinite(valueMs) ? Math.floor(valueMs) : MAX_TIMER_TIMEOUT_MS;

return Math.min(Math.max(value, 1), MAX_TIMER_TIMEOUT_MS);

}

function resolveOptionalTimerTimeoutMs(valueMs) {

return valueMs === undefined || valueMs <= 0 ? null : resolveTimerTimeoutMs(valueMs);

}

function writeCommandLog(params) {

const { logDir, label, stdout, stderr } = params;

fs.mkdirSync(logDir, { recursive: true });

let parentTerminationSignal = null;

const maxBufferBytes = params.maxBufferBytes ?? COMMAND_OUTPUT_MAX_BUFFER_BYTES;

const maxRelayBytes = params.consoleOutputMaxBytes ?? maxBufferBytes;

const timeoutKillGraceMs = params.timeoutKillGraceMs ?? 5_000;

const timeoutMs = resolveOptionalTimerTimeoutMs(params.timeoutMs);

const timeoutKillGraceMs = resolveTimerTimeoutMs(params.timeoutKillGraceMs ?? 5_000);

const spawnOptions = mode === "none" ? (params.spawnOptions ?? {}) : {};

const useProcessGroup =

process.platform !== "win32" &&

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

}

};

const waitForProcessGroupExit = async (timeoutMs) => {

const deadlineAt = Date.now() + timeoutMs;

const waitForProcessGroupExit = async (timeoutBudgetMs) => {

const deadlineAt = Date.now() + timeoutBudgetMs;

while (Date.now() < deadlineAt) {

if (!processGroupAlive()) {

return true;

child.stdout?.on("data", (chunk) => appendOutput("stdout", chunk));

child.stderr?.on("data", (chunk) => appendOutput("stderr", chunk));

const timeout =

params.timeoutMs > 0

timeoutMs !== null

? setTimeout(() => {

timedOut = true;

spawnError = {

code: "ETIMEDOUT",

message: `Command timed out after ${params.timeoutMs}ms`,

message: `Command timed out after ${timeoutMs}ms`,

};

killMeasuredProcess();

scheduleForceKill();

}, params.timeoutMs)

}, timeoutMs)

: null;

timeout?.unref?.();

const finish = (status, signal) => {

import path from "node:path";

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

import { pathToFileURL } from "node:url";

import { MAX_TIMER_TIMEOUT_MS } from "@openclaw/normalization-core/number-coercion";

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

import {

buildObservationGuardFailures,

await expect(fs.readFile(row.logPath, "utf8")).resolves.toContain("[spawn error] ENOENT");

});

it("clamps oversized measured command timers before scheduling", async () => {

const logDir = path.join(repoRoot, "logs");

const row = await runMeasuredCommandLive({

cwd: repoRoot,

env: process.env,

logDir,

command: process.execPath,

args: ["-e", "setTimeout(() => process.exit(0), 25)"],

label: "oversized-timeout",

phase: "probe",

timeoutKillGraceMs: MAX_TIMER_TIMEOUT_MS + 1,

timeoutMs: MAX_TIMER_TIMEOUT_MS + 1,

timeMode: "none",

});

expect(row.status).toBe(0);

expect(row.timedOut).toBe(false);

await expect(fs.readFile(row.logPath, "utf8")).resolves.not.toContain("ETIMEDOUT");

});

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

"kills timed-out measured command process groups when the leader exits first",

async () => {