} from "./src/scenario-catalog.js";

export { createQaSelfCheckScenario } from "./src/self-check-scenario.js";

export {

isQaSelfCheckSuccessful,

type QaSelfCheckResult,

resolveQaSelfCheckOutputPath,

runQaSelfCheckAgainstState,

baseUrl: "http://127.0.0.1:58000",

runSelfCheck: vi.fn().mockResolvedValue({

outputPath: "/tmp/report.md",

report: "",

checks: [{ name: "QA self-check scenario", status: "pass" }],

scenarioResult: {

name: "QA self-check scenario",

status: "pass",

steps: [],

},

}),

stop: vi.fn(),

});

});

});

it("fails unsuccessful self-checks after stopping the lab server", async () => {

const stop = vi.fn();

startQaLabServer.mockResolvedValueOnce({

baseUrl: "http://127.0.0.1:58000",

runSelfCheck: vi.fn().mockResolvedValue({

outputPath: "/tmp/failed-report.md",

report: "",

checks: [{ name: "QA self-check scenario", status: "fail" }],

scenarioResult: {

name: "QA self-check scenario",

status: "fail",

steps: [],

},

}),

stop,

});

await expect(

runQaLabSelfCheckCommand({

repoRoot: "/tmp/openclaw-repo",

}),

).rejects.toThrow("QA self-check failed. See /tmp/failed-report.md.");

expect(stop).toHaveBeenCalledOnce();

expectWriteContains(stdoutWrite, "QA self-check report: /tmp/failed-report.md");

});

it("resolves docker scaffold paths relative to the explicit repo root", async () => {

await runQaDockerScaffoldCommand({

repoRoot: "/tmp/openclaw-repo",

type QaScorecardCategoryCoverageReport,

type QaScorecardEvidenceMode,

} from "./scorecard-taxonomy.js";

import { isQaSelfCheckSuccessful } from "./self-check.js";

import { runQaFlowSuiteFromRuntime, runQaSuite } from "./suite-launch.runtime.js";

import { scenarioMatchesQaProviderLane } from "./suite-planning.js";

import { readQaSuiteFailedOrSkippedScenarioCountFromFile } from "./suite-summary.js";

try {

const result = await server.runSelfCheck();

process.stdout.write(`QA self-check report: ${result.outputPath}\n`);

if (!isQaSelfCheckSuccessful(result)) {

throw new Error(`QA self-check failed. See ${result.outputPath}.`);

}

} finally {

await server.stop();

}

// Qa Lab tests cover self check plugin behavior.

import path from "node:path";

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

import { resolveQaSelfCheckOutputPath } from "./self-check.js";

import type { QaSelfCheckResult } from "./self-check.js";

import { isQaSelfCheckSuccessful, resolveQaSelfCheckOutputPath } from "./self-check.js";

function makeSelfCheckResult(params: {

scenarioStatus: "pass" | "fail";

checkStatuses: Array<"pass" | "fail">;

}): QaSelfCheckResult {

return {

outputPath: "/tmp/qa-self-check.md",

report: "",

checks: params.checkStatuses.map((status, index) => ({

name: `check ${String(index + 1)}`,

status,

})),

scenarioResult: {

name: "QA self-check scenario",

status: params.scenarioStatus,

steps: [],

},

};

}

describe("isQaSelfCheckSuccessful", () => {

it("requires the scenario and every check to pass", () => {

expect(

isQaSelfCheckSuccessful(

makeSelfCheckResult({ scenarioStatus: "pass", checkStatuses: ["pass"] }),

),

).toBe(true);

expect(

isQaSelfCheckSuccessful(

makeSelfCheckResult({ scenarioStatus: "fail", checkStatuses: ["pass"] }),

),

).toBe(false);

expect(

isQaSelfCheckSuccessful(

makeSelfCheckResult({ scenarioStatus: "pass", checkStatuses: ["pass", "fail"] }),

),

).toBe(false);

});

});

describe("resolveQaSelfCheckOutputPath", () => {

it("keeps explicit output paths untouched", () => {

scenarioResult: QaScenarioResult;

};

export function isQaSelfCheckSuccessful(result: QaSelfCheckResult): boolean {

return (

result.scenarioResult.status === "pass" &&

result.checks.every((check) => check.status === "pass")

);

}

export function resolveQaSelfCheckOutputPath(params?: { outputPath?: string; repoRoot?: string }) {

if (params?.outputPath) {

return params.outputPath;

// Qa E2E script supports OpenClaw repository automation.

import { pathToFileURL } from "node:url";

type QaE2eRuntime = Pick<

typeof import("../extensions/qa-lab/api.js"),

"isQaSelfCheckSuccessful" | "runQaE2eSelfCheck"

>;

type QaE2eDeps = {

env?: NodeJS.ProcessEnv;

loadRuntime?: () => Promise<QaE2eRuntime>;

writeStdout?: (text: string) => void;

};

async function loadQaE2eRuntime(): Promise<QaE2eRuntime> {

return await import("../extensions/qa-lab/api.js");

}

export function enablePrivateQaScriptEnv(env: NodeJS.ProcessEnv = process.env) {

env.OPENCLAW_BUILD_PRIVATE_QA = "1";

env.OPENCLAW_ENABLE_PRIVATE_QA_CLI = "1";

return argv[0]?.trim() || ".artifacts/qa-e2e/self-check.md";

}

export async function main(argv: readonly string[] = process.argv.slice(2)) {

enablePrivateQaScriptEnv();

const { runQaE2eSelfCheck } = await import("../extensions/qa-lab/api.js");

export async function main(

argv: readonly string[] = process.argv.slice(2),

deps: QaE2eDeps = {},

): Promise<number> {

enablePrivateQaScriptEnv(deps.env ?? process.env);

const { isQaSelfCheckSuccessful, runQaE2eSelfCheck } = await (

deps.loadRuntime ?? loadQaE2eRuntime

)();

const result = await runQaE2eSelfCheck({ outputPath: resolveQaE2eOutputPath(argv) });

process.stdout.write(`QA self-check report: ${result.outputPath}\n`);

(deps.writeStdout ?? ((text: string) => process.stdout.write(text)))(

`QA self-check report: ${result.outputPath}\n`,

);

return isQaSelfCheckSuccessful(result) ? 0 : 1;

}

function isMainModule() {

}

if (isMainModule()) {

await main();

process.exitCode = await main();

}

// Qa E2E tests cover qa e2e script behavior.

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

import { enablePrivateQaScriptEnv, resolveQaE2eOutputPath } from "../../scripts/qa-e2e.js";

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

import type { QaSelfCheckResult } from "../../extensions/qa-lab/api.js";

import { enablePrivateQaScriptEnv, main, resolveQaE2eOutputPath } from "../../scripts/qa-e2e.js";

function makeSelfCheckResult(status: "pass" | "fail"): QaSelfCheckResult {

return {

outputPath: "/tmp/qa-self-check.md",

report: "",

checks: [{ name: "QA self-check scenario", status }],

scenarioResult: {

name: "QA self-check scenario",

status,

steps: [],

},

};

}

describe("qa-e2e script", () => {

it("enables private QA plugin SDK subpaths before loading QA Lab", () => {

expect(resolveQaE2eOutputPath([])).toBe(".artifacts/qa-e2e/self-check.md");

expect(resolveQaE2eOutputPath([".artifacts/custom.md"])).toBe(".artifacts/custom.md");

});

it.each([

{ status: "pass" as const, exitCode: 0 },

{ status: "fail" as const, exitCode: 1 },

])("exits with $exitCode when the self-check status is $status", async ({ status, exitCode }) => {

const result = makeSelfCheckResult(status);

const runQaE2eSelfCheck = vi.fn(async () => result);

const isQaSelfCheckSuccessful = vi.fn(() => status === "pass");

const writeStdout = vi.fn();

const env: NodeJS.ProcessEnv = {};

await expect(

main([".artifacts/custom.md"], {

env,

loadRuntime: async () => ({

isQaSelfCheckSuccessful,

runQaE2eSelfCheck,

}),

writeStdout,

}),

).resolves.toBe(exitCode);

expect(runQaE2eSelfCheck).toHaveBeenCalledWith({ outputPath: ".artifacts/custom.md" });

expect(isQaSelfCheckSuccessful).toHaveBeenCalledWith(result);

expect(writeStdout).toHaveBeenCalledWith("QA self-check report: /tmp/qa-self-check.md\n");

expect(env.OPENCLAW_BUILD_PRIVATE_QA).toBe("1");

});

});