ReturnType<typeof acquireQaCredentialLease<WhatsAppQaRuntimeEnv>>

>;

type WhatsAppCredentialHeartbeat = ReturnType<typeof startQaCredentialLeaseHeartbeat>;

type WhatsAppQaPreScenarioPhase =

| "auth archive unpack"

| "credential heartbeat start"

| "credential lease acquisition"

| "driver session start"

| "scenario execution";

const WHATSAPP_QA_CAPTURE_CONTENT_ENV = "OPENCLAW_QA_WHATSAPP_CAPTURE_CONTENT";

const QA_REDACT_PUBLIC_METADATA_ENV = "OPENCLAW_QA_REDACT_PUBLIC_METADATA";

const SAFE_WHATSAPP_DRIVER_DIAGNOSTICS_PATTERN =

/observed \d+ WhatsApp driver message\(s\) after (?:(?:pending|resolved) approval )?wait lower bound(?:: [-A-Za-z0-9_#:=()., +;/]+)?/u;

const SAFE_WHATSAPP_PRE_SCENARIO_FAILURE_PATTERN =

/^WhatsApp QA failed during (?:auth archive unpack|credential heartbeat start|credential lease acquisition|driver session start|scenario execution)$/u;

function formatWhatsAppPreScenarioFailureLabel(phase: WhatsAppQaPreScenarioPhase) {

return `WhatsApp QA failed during ${phase}`;

}

function isRedactionSafeWhatsAppScenarioDetailSegment(segment: string) {

return (

function redactWhatsAppQaScenarioDetails(details: string) {

const normalized = details.trim();

const firstLine = normalized.split(/\r?\n/u, 1)[0] ?? "";

const separatorIndex = firstLine.indexOf(":");

const preScenarioFailureLabel =

separatorIndex < 0 ? firstLine.trim() : firstLine.slice(0, separatorIndex).trim();

if (SAFE_WHATSAPP_PRE_SCENARIO_FAILURE_PATTERN.test(preScenarioFailureLabel)) {

return preScenarioFailureLabel;

}

const safeDriverDiagnostics = normalized.match(SAFE_WHATSAPP_DRIVER_DIAGNOSTICS_PATTERN);

if (safeDriverDiagnostics) {

return safeDriverDiagnostics[0];

let runtimeEnv: WhatsAppQaRuntimeEnv | undefined;

let tempAuthRoot: string | undefined;

let closeDriverSession: (() => Promise<void>) | undefined;

let preScenarioPhase: WhatsAppQaPreScenarioPhase = "credential lease acquisition";

try {

credentialLease = await acquireQaCredentialLease({

resolveEnvPayload: () => resolveWhatsAppQaRuntimeEnv(),

parsePayload: parseWhatsAppQaCredentialPayload,

});

preScenarioPhase = "credential heartbeat start";

leaseHeartbeat = startQaCredentialLeaseHeartbeat(credentialLease);

const assertLeaseHealthy = () => {

leaseHeartbeat?.throwIfFailed();

tempAuthRoot = await fs.mkdtemp(

path.join(resolvePreferredOpenClawTmpDir(), "openclaw-whatsapp-qa-"),

);

preScenarioPhase = "auth archive unpack";

const [driverAuthDir, sutAuthDir] = await Promise.all([

unpackWhatsAppAuthArchive({

archiveBase64: runtimeEnv.driverAuthArchiveBase64,

parentDir: tempAuthRoot,

}),

]);

preScenarioPhase = "driver session start";

let activeDriver = await startWhatsAppQaDriverSessionWithRetry({ authDir: driverAuthDir });

closeDriverSession = () => activeDriver.close();

preScenarioPhase = "scenario execution";

for (const [scenarioIndex, scenario] of scenarios.entries()) {

const progressIndex = scenarioIndex + 1;

}

}

} catch (error) {

appendLiveLaneIssue(cleanupIssues, "WhatsApp QA failed before scenario completion", error);

const failureLabel = formatWhatsAppPreScenarioFailureLabel(preScenarioPhase);

appendLiveLaneIssue(cleanupIssues, failureLabel, error);

appendPreScenarioFailureResults({

details: formatErrorMessage(error),

details: `${failureLabel}: ${formatErrorMessage(error)}`,

scenarioResults,

scenarios,

});

findUnexpectedWhatsAppNoReplyMessage,

formatWhatsAppApprovalWaitDiagnostics,

formatWhatsAppBatchMessageDiagnostics,

formatWhatsAppPreScenarioFailureLabel,

formatWhatsAppScenarioProgressDetails,

formatWhatsAppScenarioProgressLine,

fingerprintWhatsAppCredentialId: fingerprintQaCredentialId,