import os from "node:os";

import path from "node:path";

import { fileURLToPath } from "node:url";

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

import { resolveWindowsTaskkillPath } from "../lib/windows-taskkill.mjs";

import { createPnpmRunnerSpawnSpec } from "../pnpm-runner.mjs";

import { readPositiveIntEnv } from "./lib/env-limits.mjs";

return parsed;

}

function resolveTelegramProofTimerTimeoutMs(value: number) {

return clampTimerTimeoutMs(value) ?? 1;

}

function parsePositiveTimerMs(value: string, label: string) {

return resolveTelegramProofTimerTimeoutMs(parsePositiveInteger(value, label));

}

function parseTcpPort(value: string, label: string) {

const parsed = parsePositiveInteger(value, label);

if (parsed > 65_535) {

} else if (arg === "--text") {

opts.text = readValue();

} else if (arg === "--timeout-ms") {

opts.timeoutMs = parsePositiveInteger(readValue(), "--timeout-ms");

opts.timeoutMs = parsePositiveTimerMs(readValue(), "--timeout-ms");

} else if (arg === "--ttl") {

opts.ttl = readValue();

} else if (arg === "--user-driver-script") {

let timeoutError: Error | null = null;

let forceKillAt: number | undefined;

let killTimer: NodeJS.Timeout | undefined;

const timeoutMs = params.timeoutMs ?? COMMAND_TIMEOUT_MS;

const timeoutKillGraceMs = params.timeoutKillGraceMs ?? COMMAND_TIMEOUT_KILL_GRACE_MS;

const timeoutMs = resolveTelegramProofTimerTimeoutMs(params.timeoutMs ?? COMMAND_TIMEOUT_MS);

const timeoutKillGraceMs = resolveTelegramProofTimerTimeoutMs(

params.timeoutKillGraceMs ?? COMMAND_TIMEOUT_KILL_GRACE_MS,

);

const clearTimers = () => {

clearTimeout(timeout);

if (killTimer) {

timeoutMs: number,

) {

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

const resolvedTimeoutMs = resolveTelegramProofTimerTimeoutMs(timeoutMs);

const timeout = setTimeout(() => {

reject(

new Error(`${label} did not become ready within ${timeoutMs}ms\n${output().slice(-4000)}`),

new Error(

`${label} did not become ready within ${resolvedTimeoutMs}ms\n${output().slice(-4000)}`,

),

);

}, timeoutMs);

}, resolvedTimeoutMs);

const onData = () => {

if (pattern.test(output())) {

cleanup();

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, describe, expect, it, vi } from "vitest";

import {

COMMAND_TIMEOUT_MS,

expect(parseArgs(["--text", "-ping"]).text).toBe("-ping");

});

it("clamps proof timeout args before they reach Node timers", () => {

expect(parseArgs(["--timeout-ms", String(MAX_TIMER_TIMEOUT_MS + 1)]).timeoutMs).toBe(

MAX_TIMER_TIMEOUT_MS,

);

});

it("reads only the requested log tail", () => {

const logPath = path.join(makeTempDir(), "gateway.log");

fs.writeFileSync(logPath, `${"old\n".repeat(2000)}ready\n`, "utf8");

expect(JSON.parse(fs.readFileSync(argvPath, "utf8"))).toContain(payload);

});

it("clamps oversized command timeouts before arming timers", async () => {

const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");

await expect(

runCommand({

args: ["--version"],

command: process.execPath,

cwd: process.cwd(),

timeoutMs: MAX_TIMER_TIMEOUT_MS + 1,

}),

).resolves.toMatchObject({ stderr: "" });

expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), MAX_TIMER_TIMEOUT_MS);

setTimeoutSpy.mockRestore();

});

posixIt("kills timed-out command process groups when the leader exits first", async () => {

const root = makeTempDir();

const scriptPath = path.join(root, "trap-term.mjs");