import { resolveRepoRelativeOutputDir } from "./cli-paths.js";

import {

runQaLabSelfCheckCommand,

runQaCredentialsAddCommand,

runQaDockerBuildImageCommand,

runQaDockerScaffoldCommand,

runQaDockerUpCommand,

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

});

it("rejects oversized credential payload files before broker setup", async () => {

const previousMaxBytes = process.env.OPENCLAW_QA_CREDENTIAL_PAYLOAD_MAX_BYTES;

const payloadPath = path.join(suiteArtifactsDir, "oversized-credential.json");

await fs.writeFile(payloadPath, JSON.stringify({ blob: "x".repeat(64) }), "utf8");

process.env.OPENCLAW_QA_CREDENTIAL_PAYLOAD_MAX_BYTES = "32";

try {

await expect(

runQaCredentialsAddCommand({

kind: "telegram",

payloadFile: payloadPath,

}),

).rejects.toThrow(

"Payload file exceeds OPENCLAW_QA_CREDENTIAL_PAYLOAD_MAX_BYTES (32 bytes).",

);

} finally {

if (previousMaxBytes === undefined) {

delete process.env.OPENCLAW_QA_CREDENTIAL_PAYLOAD_MAX_BYTES;

} else {

process.env.OPENCLAW_QA_CREDENTIAL_PAYLOAD_MAX_BYTES = previousMaxBytes;

}

}

});

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

await runQaDockerScaffoldCommand({

repoRoot: "/tmp/openclaw-repo",

import fs from "node:fs/promises";

import path from "node:path";

import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";

import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";

import { uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";

import {

buildQaAgenticParityComparison,

} from "./tool-coverage-report.js";

const QA_SUITE_INFRA_RETRY_LIMIT = 1;

const QA_CREDENTIAL_PAYLOAD_MAX_BYTES_ENV = "OPENCLAW_QA_CREDENTIAL_PAYLOAD_MAX_BYTES";

const DEFAULT_QA_CREDENTIAL_PAYLOAD_MAX_BYTES = 64 * 1024 * 1024;

const QA_SUITE_INFRA_RETRY_NETWORK_ERROR_CODES = new Set([

"ECONNRESET",

"ECONNREFUSED",

await new Promise(() => {});

}

function resolveQaCredentialPayloadFileMaxBytes(env: NodeJS.ProcessEnv = process.env) {

const raw = env[QA_CREDENTIAL_PAYLOAD_MAX_BYTES_ENV]?.trim();

if (!raw) {

return DEFAULT_QA_CREDENTIAL_PAYLOAD_MAX_BYTES;

}

const parsed = parseStrictPositiveInteger(raw);

if (parsed === undefined) {

throw new Error(`${QA_CREDENTIAL_PAYLOAD_MAX_BYTES_ENV} must be a positive integer.`);

}

return parsed;

}

async function readQaCredentialPayloadFile(filePath: string) {

const maxBytes = resolveQaCredentialPayloadFileMaxBytes();

const stat = await fs.stat(filePath);

if (!stat.isFile()) {

throw new Error("Payload file must be a regular JSON file.");

}

if (stat.size > maxBytes) {

throw new Error(

`Payload file exceeds ${QA_CREDENTIAL_PAYLOAD_MAX_BYTES_ENV} (${maxBytes} bytes).`,

);

}

const text = await fs.readFile(filePath, "utf8");

let payload: unknown;

try {