#!/usr/bin/env node

import { spawnSync } from "node:child_process";

import { spawn, spawnSync } from "node:child_process";

import fs from "node:fs";

import os from "node:os";

import path from "node:path";

const DEFAULT_HOT_WALL_WARN_MS = 30_000;

const DEFAULT_MAX_RSS_WARN_MB = 1536;

const DEFAULT_QA_PLUGIN_CHUNK_SIZE = 12;

const COMMAND_OUTPUT_MAX_BUFFER_BYTES = 16 * 1024 * 1024;

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

function parseArgs(argv) {

env: params.env,

encoding: "utf8",

timeout: params.timeoutMs,

maxBuffer: 16 * 1024 * 1024,

maxBuffer: params.maxBufferBytes ?? COMMAND_OUTPUT_MAX_BUFFER_BYTES,

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

});

const wallMs = performance.now() - started;

};

}

export function runMeasuredCommandLive(params) {

const { command, args, mode } =

params.timeMode === "none"

? { command: params.command, args: params.args, mode: "none" }

: timeWrapperArgs(params.command, params.args);

const started = performance.now();

return new Promise((resolve) => {

let stdout = "";

let stderr = "";

let stdoutBytes = 0;

let stderrBytes = 0;

let stdoutTruncated = false;

let stderrTruncated = false;

let spawnError = null;

let timedOut = false;

let settled = false;

const maxBufferBytes = params.maxBufferBytes ?? COMMAND_OUTPUT_MAX_BUFFER_BYTES;

const child = spawn(command, args, {

cwd: params.cwd,

env: params.env,

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

});

const appendCapturedOutput = (streamName, chunk) => {

const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);

const currentBytes = streamName === "stdout" ? stdoutBytes : stderrBytes;

const alreadyTruncated = streamName === "stdout" ? stdoutTruncated : stderrTruncated;

if (alreadyTruncated) {

return;

}

const remainingBytes = maxBufferBytes - currentBytes;

const appendTruncation = () => {

const message = `\n[${streamName} truncated after ${maxBufferBytes} bytes]\n`;

if (streamName === "stdout") {

stdout += message;

stdoutTruncated = true;

} else {

stderr += message;

stderrTruncated = true;

}

};

if (remainingBytes <= 0) {

appendTruncation();

return;

}

const capturedBuffer =

buffer.length > remainingBytes ? buffer.subarray(0, remainingBytes) : buffer;

if (streamName === "stdout") {

stdout += capturedBuffer.toString("utf8");

stdoutBytes += capturedBuffer.length;

} else {

stderr += capturedBuffer.toString("utf8");

stderrBytes += capturedBuffer.length;

}

if (buffer.length > remainingBytes) {

appendTruncation();

}

};

const appendOutput = (streamName, chunk) => {

const text = chunk.toString("utf8");

if (streamName === "stdout") {

process.stdout.write(text);

} else {

process.stderr.write(text);

}

appendCapturedOutput(streamName, chunk);

};

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

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

const timeout =

params.timeoutMs > 0

? setTimeout(() => {

timedOut = true;

spawnError = {

code: "ETIMEDOUT",

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

};

child.kill();

}, params.timeoutMs)

: null;

timeout?.unref?.();

const finish = (status, signal) => {

if (settled) {

return;

}

settled = true;

if (timeout) {

clearTimeout(timeout);

}

const wallMs = performance.now() - started;

const finalStatus = status ?? (signal || spawnError ? 1 : 0);

const finalStderr = [

stderr,

spawnError ? `[spawn error] ${spawnError.code ?? "unknown"} ${spawnError.message}` : "",

]

.filter(Boolean)

.join("\n");

const diagnosticFailure = detectCommandDiagnosticFailure(stdout, finalStderr);

const logPath = writeCommandLog({

logDir: params.logDir,

label: params.label,

command: [params.command, ...params.args],

stdout,

stderr: finalStderr,

});

resolve({

label: params.label,

phase: params.phase,

pluginId: params.pluginId ?? null,

status: finalStatus,

diagnosticFailure,

signal: signal ?? null,

timedOut,

spawnError,

logPath,

...parseTimedMetrics(finalStderr, wallMs, mode),

});

};

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

spawnError = {

code: typeof error.code === "string" ? error.code : null,

message: error.message,

};

finish(null, null);

});

child.on("close", (status, signal) => finish(status, signal));

});

}

function runPluginLifecycle(params) {

for (const plugin of params.plugins) {

const commands = [

const prebuildEnv = buildGauntletPrebuildEnv(env, { includePrivateQa: !options.skipQa });

const prebuildCommand = createGauntletPrebuildCommand(repoRoot);

rows.push(

runMeasuredCommand({

await runMeasuredCommandLive({

cwd: repoRoot,

env: prebuildEnv,

logDir: path.join(options.outputDir, "logs", "prebuild"),