const DEFAULT_MAX_RSS_MIB = 2048;

const DEFAULT_MAX_COMMAND_RSS_MIB = 8192;

const DEFAULT_OUTPUT_CAPTURE_CHARS = 1024 * 1024;

export const MAX_KITCHEN_SINK_TIMER_TIMEOUT_MS = 2_147_000_000;

const GATEWAY_TEARDOWN_GRACE_MS = 10000;

const GATEWAY_TEARDOWN_KILL_GRACE_MS = 2000;

const COMMAND_PARENT_SIGNAL_KILL_GRACE_MS = 2000;

return parsed;

}

export function clampKitchenSinkTimerTimeoutMs(value) {

if (!Number.isFinite(value)) {

return 1;

}

return Math.min(Math.max(1, Math.floor(value)), MAX_KITCHEN_SINK_TIMER_TIMEOUT_MS);

}

export function readPositiveTimerMs(raw, fallback, label = "value") {

return clampKitchenSinkTimerTimeoutMs(readPositiveInt(raw, fallback, label));

}

export function resolveKitchenSinkRpcConfig(env = process.env) {

const commandTimeoutMs = readPositiveInt(

const commandTimeoutMs = readPositiveTimerMs(

env.OPENCLAW_KITCHEN_SINK_RPC_COMMAND_MS,

DEFAULT_COMMAND_TIMEOUT_MS,

"OPENCLAW_KITCHEN_SINK_RPC_COMMAND_MS",

DEFAULT_FETCH_BODY_MAX_BYTES,

"OPENCLAW_KITCHEN_SINK_RPC_FETCH_BODY_BYTES",

),

fetchTimeoutMs: readPositiveInt(

fetchTimeoutMs: readPositiveTimerMs(

env.OPENCLAW_KITCHEN_SINK_RPC_FETCH_MS,

DEFAULT_FETCH_TIMEOUT_MS,

"OPENCLAW_KITCHEN_SINK_RPC_FETCH_MS",

),

installTimeoutMs: readPositiveInt(

installTimeoutMs: readPositiveTimerMs(

env.OPENCLAW_KITCHEN_SINK_RPC_INSTALL_MS,

Math.max(commandTimeoutMs, DEFAULT_INSTALL_TIMEOUT_MS),

"OPENCLAW_KITCHEN_SINK_RPC_INSTALL_MS",

DEFAULT_OUTPUT_CAPTURE_CHARS,

"OPENCLAW_KITCHEN_SINK_OUTPUT_CAPTURE_CHARS",

),

readyTimeoutMs: readPositiveInt(

readyTimeoutMs: readPositiveTimerMs(

env.OPENCLAW_KITCHEN_SINK_RPC_READY_MS,

DEFAULT_READY_TIMEOUT_MS,

"OPENCLAW_KITCHEN_SINK_RPC_READY_MS",

),

rpcTimeoutMs: readPositiveInt(

rpcTimeoutMs: readPositiveTimerMs(

env.OPENCLAW_KITCHEN_SINK_RPC_CALL_MS,

DEFAULT_RPC_TIMEOUT_MS,

"OPENCLAW_KITCHEN_SINK_RPC_CALL_MS",

timeoutMs = config.commandTimeoutMs,

...spawnOptions

} = options;

const resolvedTimeoutMs = clampKitchenSinkTimerTimeoutMs(timeoutMs);

const resolvedTimeoutKillGraceMs = clampKitchenSinkTimerTimeoutMs(timeoutKillGraceMs);

const child = childProcess.spawn(command, args, {

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

...spawnOptions,

const timer = setTimeout(() => {

timedOut = true;

signalProcessGroup(child, "SIGTERM");

forceKillAt = Date.now() + timeoutKillGraceMs;

forceKillTimer = setTimeout(() => signalProcessGroup(child, "SIGKILL"), timeoutKillGraceMs);

forceKillAt = Date.now() + resolvedTimeoutKillGraceMs;

forceKillTimer = setTimeout(

() => signalProcessGroup(child, "SIGKILL"),

resolvedTimeoutKillGraceMs,

);

forceKillTimer.unref();

}, timeoutMs);

}, resolvedTimeoutMs);

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

stdout = appendBoundedOutput(stdout, chunk, outputCaptureChars);

});

.join("\n")

.trim();

const failure = timedOut

? `timed out after ${timeoutMs}ms`

? `timed out after ${resolvedTimeoutMs}ms`

: `failed with ${signal || status}`;

reject(

Object.assign(

if (timedOut) {

void finishTimedOutCommandProcessTree(child, {

forceKillAt,

timeoutKillGraceMs,

timeoutKillGraceMs: resolvedTimeoutKillGraceMs,

}).then(finish, finish);

return;

}

return {

...options.commandResourceOptions,

resourceLabel: `gateway call ${method}`,

timeoutMs: config.rpcTimeoutMs + 30000,

timeoutMs: clampKitchenSinkTimerTimeoutMs(config.rpcTimeoutMs + 30000),

};

}

export async function fetchJson(url, options = {}) {

const config = resolveKitchenSinkRpcConfig();

const attempts = Math.max(1, options.attempts ?? 3);

const timeoutMs = Math.max(1, options.timeoutMs ?? config.fetchTimeoutMs);

const timeoutMs = clampKitchenSinkTimerTimeoutMs(options.timeoutMs ?? config.fetchTimeoutMs);

const maxBodyBytes = Math.max(1, options.maxBodyBytes ?? config.fetchBodyMaxBytes);

const externalSignal = options.signal;

let lastError;

const config = resolveKitchenSinkRpcConfig();

const started = Date.now();

let lastError = "";

const timeoutMs = Math.max(1, options.timeoutMs ?? config.readyTimeoutMs);

const timeoutMs = clampKitchenSinkTimerTimeoutMs(options.timeoutMs ?? config.readyTimeoutMs);

const pollDelayMs = Math.max(1, options.pollDelayMs ?? 250);

const logReportedReady = createGatewayReadyLogScanner(logPath);

const childExit = createChildExitPromise(child);