return undefined;

}

const value = process.argv[idx + 1];

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

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

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

}

return value;

function parseRepeatableFlag(flag: string): string[] {

const values: string[] = [];

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

if (process.argv[i] === flag && process.argv[i + 1]) {

const value = process.argv[i + 1];

if (process.argv[i] === flag && value && !value.startsWith("-")) {

values.push(process.argv[i + 1]);

}

}

const arg = argv[index];

if (VALUE_FLAGS.has(arg)) {

const value = argv[index + 1];

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

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

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

}

index += 1;

}

async function main(): Promise<void> {

validateCliArgs();

if (hasFlag("--help")) {

printUsage();

return;

}

validateCliArgs();

const options = parseOptions();

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

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

function readValue(argv: string[], index: number, flag: string): string {

const value = argv[index + 1]?.trim() ?? "";

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

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

throw new CliArgumentError(`${flag} requires a value`);

}

return value;

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

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

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

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

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

}

return value;

}

function isHelpRequest(argv: readonly string[]) {

return argv.length === 1 && (argv[0] === "--help" || argv[0] === "-h");

}

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

let artifactBase = "";

let repoRoot = process.cwd();

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

(async () => {

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

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

if (isHelpRequest(cliArgs)) {

console.log(usage());

return;

}

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

});

it("rejects short flag values before running benchmarks", () => {

expect(() => testing.validateCliArgs(["--output", "-h"])).toThrow("--output requires a value");

expect(() => testing.validateCliArgs(["--case", "-h"])).toThrow("--case requires a value");

const result = spawnSync(

process.execPath,

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

{

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

encoding: "utf8",

},

);

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

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

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

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

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

});

it.runIf(process.platform !== "win32")(

"cleans timed-out benchmark process groups when the leader exits first",

() => {

const tempDirs = createTempDirTracker();

const tmpDir = tempDirs.make("openclaw-cli-startup-timeout-group-");

const entryPath = join(tmpDir, "entry.mjs");

const childPidPath = join(tmpDir, "child.pid");

let childPid = 0;

let childPid: number | undefined;

try {

writeFileSync(

entryPath,

expect(result.stderr).toContain("version sample 1: timed out");

expect(isProcessAlive(childPid)).toBe(false);

} finally {

if (childPid && isProcessAlive(childPid)) {

if (childPid !== undefined && isProcessAlive(childPid)) {

process.kill(childPid, "SIGKILL");

}

tempDirs.cleanup();

expect(result.stderr).not.toContain("Missing ANTHROPIC_API_KEY");

});

it("rejects short flag values before checking provider credentials", () => {

expect(() => testing.parseArgs(["--prompt", "-h"])).toThrow("--prompt requires a value");

expect(() => testing.parseArgs(["--runs", "-h"])).toThrow("--runs requires a value");

const result = runBenchModel(["--prompt", "-h"]);

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

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

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

expect(result.stderr).not.toContain("Missing ANTHROPIC_API_KEY");

});

it("prints help without checking provider credentials", () => {

const result = runBenchModel(["--help"]);

expectNoNodeStack(result.stderr);

});

it("reports short flag values without treating them as help", () => {

const artifactBaseResult = runCli("--artifact-base", "-h");

const repoRootResult = runCli("--artifact-base", "/tmp/openclaw-ux-test", "--repo-root", "-h");

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

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

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

expectNoNodeStack(artifactBaseResult.stderr);

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

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

expect(repoRootResult.stderr.trim()).toBe("--repo-root requires a value");

expectNoNodeStack(repoRootResult.stderr);

});

it("sanitizes local checkout paths from generated evidence artifacts", () => {

const artifactBase = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-ux-evidence-test-"));

const fakeRepoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-ux-repo-test-"));