#!/usr/bin/env node

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

import { spawn } from "node:child_process";

import fs from "node:fs";

import os from "node:os";

import path from "node:path";

return logPath;

}

export function runMeasuredCommand(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();

const result = spawnSync(command, args, {

cwd: params.cwd,

env: params.env,

encoding: "utf8",

timeout: params.timeoutMs,

maxBuffer: params.maxBufferBytes ?? COMMAND_OUTPUT_MAX_BUFFER_BYTES,

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

});

const wallMs = performance.now() - started;

const spawnError = result.error

? {

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

message: result.error.message,

}

: null;

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

const stdout = result.stdout ?? "";

const stderr = [

result.stderr ?? "",

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

]

.filter(Boolean)

.join("\n");

const diagnosticFailure = detectCommandDiagnosticFailure(stdout, stderr);

const logPath = writeCommandLog({

logDir: params.logDir,

label: params.label,

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

stdout,

stderr,

});

return {

label: params.label,

phase: params.phase,

pluginId: params.pluginId ?? null,

status,

diagnosticFailure,

signal: result.signal ?? null,

timedOut: spawnError?.code === "ETIMEDOUT",

spawnError,

logPath,

...parseTimedMetrics(stderr, wallMs, mode),

};

export async function runMeasuredCommand(params) {

return await runMeasuredCommandLive(params);

}

export function runMeasuredCommandLive(params) {

return rows.some((row) => row.phase !== "prebuild");

}

function runPluginLifecycle(params) {

async function runPluginLifecycle(params) {

for (const plugin of params.plugins) {

const commands = [

{

for (const { phase, args } of commands) {

process.stderr.write(`[plugin-gauntlet] ${plugin.id} ${phase}\n`);

params.rows.push(

runMeasuredCommand({

await runMeasuredCommand({

cwd: params.repoRoot,

env: params.env,

logDir: path.join(params.outputDir, "logs", "lifecycle"),

}

}

function runSlashHelpProbes(params) {

async function runSlashHelpProbes(params) {

for (const plugin of params.plugins) {

for (const alias of plugin.cliCommandAliases) {

const command = alias.cliCommand ?? alias.name;

process.stderr.write(`[plugin-gauntlet] ${plugin.id} slash-help /${alias.name}\n`);

params.rows.push(

runMeasuredCommand({

await runMeasuredCommand({

cwd: params.repoRoot,

env: params.env,

logDir: path.join(params.outputDir, "logs", "slash-help"),

}

}

function runQaChunks(params) {

async function runQaChunks(params) {

const chunks = [

...(params.qaBaseline ? [{ label: "baseline", plugins: [] }] : []),

...chunkArray(params.plugins, params.qaPluginChunkSize).map((plugins, index) => ({

process.stderr.write(

`[plugin-gauntlet] qa chunk ${index + 1}/${chunks.length}: ${pluginIdLabel}\n`,

);

const row = runMeasuredCommand({

const row = await runMeasuredCommand({

cwd: params.repoRoot,

env: params.env,

logDir: path.join(params.outputDir, "logs", "qa-suite"),

(row) => row.phase === "prebuild" && (row.status !== 0 || row.timedOut),

);

if (!prebuildFailed && !options.skipLifecycle) {

runPluginLifecycle({

await runPluginLifecycle({

repoRoot,

outputDir: options.outputDir,

env: commandEnv,

});

}

if (!prebuildFailed && !options.skipSlashHelp) {

runSlashHelpProbes({

await runSlashHelpProbes({

repoRoot,

outputDir: options.outputDir,

env: commandEnv,

const qaSummaries =

options.skipQa || prebuildFailed

? []

: runQaChunks({

: await runQaChunks({

repoRoot,

outputDir: options.outputDir,

env: commandEnv,