const DEFAULT_TIMEOUT_MS = 30_000;

const DEFAULT_ENTRY = "openclaw.mjs";

const MAX_RSS_MARKER = "__OPENCLAW_MAX_RSS_KB__=";

const VALUE_FLAGS = new Set([

"--case",

"--compare-baseline",

"--compare-candidate",

"--cpu-prof-dir",

"--entry",

"--entry-primary",

"--entry-secondary",

"--heap-prof-dir",

"--output",

"--preset",

"--runs",

"--timeout-ms",

"--warmup",

]);

const BOOLEAN_FLAGS = new Set(["--help", "--json"]);

const COMMAND_CASES: readonly CommandCase[] = [

{

return values;

}

function validateCliArgs(argv: readonly string[] = process.argv.slice(2)): void {

for (let index = 0; index < argv.length; index += 1) {

const arg = argv[index];

if (VALUE_FLAGS.has(arg)) {

const value = argv[index + 1];

if (!value || value.startsWith("--")) {

throw new Error(`${arg} requires a value`);

}

index += 1;

continue;

}

if (BOOLEAN_FLAGS.has(arg)) {

continue;

}

throw new Error(`Unknown argument: ${arg}`);

}

}

function parsePositiveInt(raw: string | undefined, fallback: number, label = "value"): number {

return parseStrictIntegerOption({ fallback, label, min: 1, raw });

}

return;

}

validateCliArgs();

const options = parseOptions();

if (options.compareBaseline || options.compareCandidate) {

if (!options.compareBaseline || !options.compareCandidate) {

parseNonNegativeInt,

parsePositiveInt,

readBenchmarkComparison: readBenchmarkComparisonForTesting,

validateCliArgs,

writeJsonOutput,

};

if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {

await main().catch((error: unknown) => {

console.error(error instanceof Error ? error.stack : String(error));

console.error(error instanceof Error ? error.message : String(error));

process.exit(1);

});

}

skipVisualProof: boolean;

};

function usage() {

return `Usage: node --import tsx scripts/qa/ux-matrix-evidence-producer.ts --artifact-base <dir> [options]

Produces a QA Lab UX Matrix evidence bundle.

Options:

--artifact-base <dir> Evidence artifact directory

--repo-root <dir> Repository root

--skip-visual-proof Use fixture visual evidence instead of Playwright screenshots

-h, --help Show this help

`;

}

function readOptionValue(argv: readonly string[], index: number, arg: string) {

const value = argv[index + 1] ?? "";

if (!value || value.startsWith("--")) {

throw new Error(`${arg} requires a value`);

}

return value;

}

function parseOptions(argv: readonly string[]): ProducerOptions {

let artifactBase = "";

let repoRoot = process.cwd();

let skipVisualProof = false;

for (let index = 0; index < argv.length; index += 1) {

const arg = argv[index];

if (arg === "--artifact-base") {

artifactBase = argv[index + 1] ?? "";

artifactBase = readOptionValue(argv, index, arg);

index += 1;

continue;

}

if (arg === "--repo-root") {

repoRoot = argv[index + 1] ?? "";

repoRoot = readOptionValue(argv, index, arg);

index += 1;

continue;

}

}

if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {

runUxMatrixEvidenceProducer(parseOptions(process.argv.slice(2)))

.then((result) => {

console.log(`UX Matrix evidence: ${path.join(result.artifactBase, QA_EVIDENCE_FILENAME)}`);

console.log(`UX Matrix entries: ${result.evidence.entries.length}`);

(async () => {

const cliArgs = process.argv.slice(2);

if (cliArgs.includes("--help") || cliArgs.includes("-h")) {

console.log(usage());

return;

}

const result = await runUxMatrixEvidenceProducer(parseOptions(cliArgs));

console.log(`UX Matrix evidence: ${path.join(result.artifactBase, QA_EVIDENCE_FILENAME)}`);

console.log(`UX Matrix entries: ${result.evidence.entries.length}`);

})()

.then(() => {

process.exitCode = 0;

})

.catch((error: unknown) => {

console.error(error instanceof Error ? error.stack || error.message : String(error));

console.error(error instanceof Error ? error.message : String(error));

process.exitCode = 1;

});

}

// Bench Cli Startup tests cover bench cli startup script behavior.

import { spawnSync } from "node:child_process";

import { existsSync, readFileSync, writeFileSync } from "node:fs";

import { join } from "node:path";

import { describe, expect, it } from "vitest";

}

describe("bench-cli-startup", () => {

it("rejects unknown CLI options before running benchmarks", () => {

expect(() => testing.validateCliArgs(["--wat"])).toThrow("Unknown argument: --wat");

const result = spawnSync(

process.execPath,

["--import", "tsx", "scripts/bench-cli-startup.ts", "--wat"],

{

cwd: join(__dirname, "../.."),

encoding: "utf8",

},

);

expect(result.status).toBe(1);

expect(result.stdout).toBe("");

expect(result.stderr.trim()).toBe("Unknown argument: --wat");

expect(result.stderr).not.toContain("Node.js");

expect(result.stderr).not.toContain("\n at ");

});

it("writes compare-mode JSON output and creates parent directories", () => {

const tempDirs = createTempDirTracker();

const tmpDir = tempDirs.make("openclaw-cli-startup-compare-output-");

// QA UX Matrix evidence producer tests cover operator-facing CLI behavior.

import { spawnSync } from "node:child_process";

import path from "node:path";

import { describe, expect, it } from "vitest";

function runCli(...args: string[]) {

return spawnSync(

process.execPath,

["--import", "tsx", "scripts/qa/ux-matrix-evidence-producer.ts", ...args],

{

cwd: path.resolve(__dirname, "../.."),

encoding: "utf8",

},

);

}

function expectNoNodeStack(stderr: string) {

expect(stderr).not.toContain("Node.js");

expect(stderr).not.toContain("\n at ");

}

describe("QA UX Matrix evidence producer CLI", () => {

it("prints help without generating evidence", () => {

const result = runCli("--help");

expect(result.status).toBe(0);

expect(result.stdout).toContain(

"Usage: node --import tsx scripts/qa/ux-matrix-evidence-producer.ts",

);

expect(result.stderr).toBe("");

});

it("reports invalid args without a Node stack trace", () => {

const result = runCli("--wat");

expect(result.status).toBe(1);

expect(result.stdout).toBe("");

expect(result.stderr.trim()).toBe("unsupported UX Matrix producer arg: --wat");

expectNoNodeStack(result.stderr);

});

it("reports missing valued args without a Node stack trace", () => {

const result = runCli("--artifact-base", "--repo-root", ".");

expect(result.status).toBe(1);

expect(result.stdout).toBe("");

expect(result.stderr.trim()).toBe("--artifact-base requires a value");

expectNoNodeStack(result.stderr);

});

});