import path from "node:path";

import { finished } from "node:stream/promises";

import { fileURLToPath } from "node:url";

import {

addTimerTimeoutGraceMs,

clampTimerTimeoutMs,

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

import { resolveNpmRunner } from "../../npm-runner.mjs";

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

import { buildCmdExeCommandLine, resolveWindowsCmdExePath } from "../../windows-cmd-helpers.mjs";

return portableBasename(command) === command && command.toLowerCase() === name;

}

function resolveHostCommandTimeoutMs(timeoutMs: number): number {

return clampTimerTimeoutMs(timeoutMs) ?? 1;

}

function resolveOptionalHostCommandTimeoutMs(timeoutMs: number | undefined): number | undefined {

return timeoutMs === undefined ? undefined : resolveHostCommandTimeoutMs(timeoutMs);

}

export function resolveHostCommandInvocation(

command: string,

args: string[],

export function run(command: string, args: string[], options: RunOptions = {}): CommandResult {

const env = { ...process.env, ...options.env };

const invocation = resolveHostCommandInvocation(command, args, { env });

const usesPosixTimedWrapper = process.platform !== "win32" && options.timeoutMs !== undefined;

const timeoutMs = resolveOptionalHostCommandTimeoutMs(options.timeoutMs);

const usesPosixTimedWrapper = process.platform !== "win32" && timeoutMs !== undefined;

const result = usesPosixTimedWrapper

? runPosixTimedCommandSync(invocation, env, options)

? runPosixTimedCommandSync(invocation, env, options, timeoutMs)

: spawnSync(invocation.command, invocation.args, {

cwd: options.cwd ?? repoRoot,

encoding: "utf8",

maxBuffer: HOST_COMMAND_MAX_BUFFER_BYTES,

stdio: options.quiet ? ["pipe", "pipe", "pipe"] : ["pipe", "pipe", "pipe"],

shell: invocation.shell,

timeout: options.timeoutMs,

timeout: timeoutMs,

windowsVerbatimArguments: invocation.windowsVerbatimArguments,

});

wrapperTimedOut || (result.error as NodeJS.ErrnoException | undefined)?.code === "ETIMEDOUT";

if (wrapperTimedOut && options.check !== false) {

const error = new Error(

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

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

) as NodeJS.ErrnoException;

error.code = "ETIMEDOUT";

throw error;

invocation: HostCommandInvocation,

env: NodeJS.ProcessEnv,

options: RunOptions,

timeoutMs: number,

): SpawnSyncReturns<string> {

const wrapperTimeoutMs = addTimerTimeoutGraceMs(timeoutMs, HOST_COMMAND_WRAPPER_BACKSTOP_MS) ?? 1;

const payload = JSON.stringify({

args: invocation.args,

command: invocation.command,

maxBufferBytes: HOST_COMMAND_MAX_BUFFER_BYTES,

shell: invocation.shell,

timeoutKillGraceMs: HOST_COMMAND_TIMEOUT_KILL_GRACE_MS,

timeoutMs: options.timeoutMs,

timeoutMs,

});

return spawnSync(process.execPath, ["-e", POSIX_TIMEOUT_WRAPPER], {

cwd: options.cwd ?? repoRoot,

killSignal: "SIGKILL",

maxBuffer: HOST_COMMAND_MAX_BUFFER_BYTES * 2 + HOST_COMMAND_WRAPPER_EXTRA_BUFFER_BYTES,

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

timeout: (options.timeoutMs ?? 0) + HOST_COMMAND_WRAPPER_BACKSTOP_MS,

timeout: wrapperTimeoutMs,

});

}

return await new Promise((resolve, reject) => {

const env = { ...process.env, ...options.env };

const invocation = resolveHostCommandInvocation(command, args, { env });

const timeoutMs = resolveOptionalHostCommandTimeoutMs(options.timeoutMs);

const logStream = options.logPath

? createWriteStream(options.logPath, { encoding: "utf8", flags: "w" })

: undefined;

let logStreamError: Error | undefined;

const detached = process.platform !== "win32" && options.timeoutMs != null;

const detached = process.platform !== "win32" && timeoutMs !== undefined;

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

cwd: options.cwd ?? repoRoot,

detached,

return (error as NodeJS.ErrnoException).code === "EPERM";

}

};

const waitForStreamingProcessGroupExit = async (timeoutMs: number): Promise<boolean> => {

const deadlineAt = Date.now() + timeoutMs;

const waitForStreamingProcessGroupExit = async (timeoutBudgetMs: number): Promise<boolean> => {

const deadlineAt = Date.now() + timeoutBudgetMs;

while (Date.now() < deadlineAt) {

if (!streamingProcessGroupAlive()) {

return true;

}

}, HOST_COMMAND_TIMEOUT_KILL_GRACE_MS);

};

if (process.platform !== "win32" && options.timeoutMs != null) {

if (process.platform !== "win32" && timeoutMs !== undefined) {

for (const signal of ["SIGHUP", "SIGINT", "SIGTERM"] as const) {

const handler = (): void => {

forwardedParentSignal ??= signal;

}

};

const timer =

options.timeoutMs == null

timeoutMs === undefined

? undefined

: setTimeout(() => {

timedOut = true;

HOST_COMMAND_STREAMING_TIMEOUT_KILL_GRACE_MS,

);

killTimer.unref();

}, options.timeoutMs);

}, timeoutMs);

child.on("error", (error) => {

if (timer) {