import { setTimeout as sleep } from "node:timers/promises";

import type { OpenClawConfig } from "openclaw/plugin-sdk/config-contracts";

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

import { redactSensitiveText } from "openclaw/plugin-sdk/logging-core";

import {

parseStrictPositiveInteger,

resolveTimerTimeoutMs,

const DEFAULT_MATRIX_QA_RUN_TIMEOUT_MS = 30 * 60_000;

const DEFAULT_MATRIX_QA_CLEANUP_TIMEOUT_MS = 90_000;

const DEFAULT_MATRIX_QA_CANARY_TIMEOUT_MS = 45_000;

const MATRIX_QA_GATEWAY_STDERR_LOG = "gateway.stderr.log";

const MATRIX_QA_GATEWAY_DEBUG_MAX_LINES = 6;

const MATRIX_QA_GATEWAY_DEBUG_MAX_LINE_CHARS = 700;

type MatrixQaLiveLaneGatewayHarness = {

gateway: MatrixQaGatewayChild;

process.stderr.write(`[matrix-qa] ${message}\n`);

}

function isMatrixQaGatewayDebugRelevantLine(line: string) {

return /\b(?:auth|authorization|unauthorized|forbidden|missing|error|fail(?:ed|ure)?|exception|provider|api[-_ ]?key|token|denied|rejected|timeout)\b/iu.test(

line,

);

}

function trimMatrixQaGatewayDebugLine(line: string) {

const redacted = redactSensitiveText(line.trim());

return redacted.length > MATRIX_QA_GATEWAY_DEBUG_MAX_LINE_CHARS

? `${redacted.slice(0, MATRIX_QA_GATEWAY_DEBUG_MAX_LINE_CHARS)}...`

: redacted;

}

function summarizeMatrixQaGatewayStderrLog(stderrText: string) {

const lines = stderrText.split(/\r?\n/u).map(trimMatrixQaGatewayDebugLine).filter(Boolean);

if (lines.length === 0) {

return undefined;

}

const relevantLines = lines.filter(isMatrixQaGatewayDebugRelevantLine);

const selectedLines = (relevantLines.length > 0 ? relevantLines : lines).slice(

-MATRIX_QA_GATEWAY_DEBUG_MAX_LINES,

);

return ["gateway stderr tail:", ...selectedLines.map((line) => `- ${line}`)].join("\n");

}

async function readMatrixQaGatewayDebugSummary(debugDirPath: string) {

const stderrText = await fs

.readFile(path.join(debugDirPath, MATRIX_QA_GATEWAY_STDERR_LOG), "utf8")

.catch((error: unknown) => {

if ((error as NodeJS.ErrnoException).code === "ENOENT") {

return "";

}

throw error;

});

return summarizeMatrixQaGatewayStderrLog(stderrText);

}

function parsePositiveMatrixQaEnvMs(name: string, fallback: number) {

const raw = process.env[name];

if (raw === undefined) {

details: cleanupErrors.join("\n"),

});

}

const gatewayDebugSummary = preservedGatewayDebugDirPath

? await readMatrixQaGatewayDebugSummary(preservedGatewayDebugDirPath)

: undefined;

if (preservedGatewayDebugDirPath) {

checks.push({

name: "Matrix gateway debug logs",

status: "pass",

details: `preserved at: ${preservedGatewayDebugDirPath}`,

details: [`preserved at: ${preservedGatewayDebugDirPath}`, gatewayDebugSummary]

.filter(Boolean)

.join("\n"),

});

}

details: [

...failedChecks.map((check) => `check ${check.name}: ${check.details ?? "failed"}`),

...failedScenarios.map((scenario) => `scenario ${scenario.id}: ${scenario.details}`),

...(gatewayDebugSummary ? [`gateway debug: ${gatewayDebugSummary}`] : []),

...cleanupErrors.map((error) => `cleanup: ${error}`),

],

artifacts: artifactPaths,

resolveMatrixQaCanaryTimeoutMs,

resolveMatrixQaModels,

shouldWriteMatrixQaProgress,

summarizeMatrixQaGatewayStderrLog,

summarizeMatrixQaConfigSnapshot,

waitForMatrixChannelReady,

withMatrixQaRunDeadline,