import { spawn, spawnSync, type ChildProcessWithoutNullStreams } from "node:child_process";

import { randomUUID } from "node:crypto";

import path from "node:path";

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

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

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

import {

readQaChildOutput,

} from "./child-output.js";

import { QaSuiteInfraError } from "./errors.js";

import { extractGatewayMessageText } from "./gateway-log-sentinel.js";

import { resolveQaNodeExecPath } from "./node-exec.js";

import { liveTurnTimeoutMs } from "./suite-runtime-agent-common.js";

import { waitForGatewayHealthy, waitForTransportReady } from "./suite-runtime-gateway.js";

state?: { nextRunAtMs?: number };

};

type QaChatHistoryResponse = {

messages?: unknown[];

};

const ANSI_ESCAPE_PATTERN = new RegExp(String.raw`\x1B\[[0-?]*[ -/]*[@-~]`, "g");

const MANAGED_DREAMING_CRON_MARKER = "[managed-by=memory-core.short-term-promotion]";

const MANAGED_DREAMING_CRON_NAME = "Memory Dreaming Promotion";

const MANAGED_DREAMING_PROMPT = "__openclaw_memory_core_short_term_promotion_dream__";

function isRecord(value: unknown): value is Record<string, unknown> {

return typeof value === "object" && value !== null && !Array.isArray(value);

}

function stripAnsiCodes(text: string) {

return text.replace(ANSI_ESCAPE_PATTERN, "");

}

}

}

function readLatestAssistantTextFromHistory(history: QaChatHistoryResponse | undefined) {

for (const message of [...(history?.messages ?? [])].reverse()) {

if (!isRecord(message) || message.role !== "assistant") {

continue;

}

const text = extractGatewayMessageText(message);

if (text) {

return text;

}

}

return undefined;

}

async function readLatestAgentHistoryReply(

env: Pick<QaSuiteRuntimeEnv, "gateway">,

sessionKey: string,

) {

const history = (await env.gateway.call(

"chat.history",

{

sessionKey,

limit: 12,

},

{

timeoutMs: 10_000,

},

)) as QaChatHistoryResponse | undefined;

return readLatestAssistantTextFromHistory(history);

}

async function waitForAgentHistoryReply(

env: Pick<QaSuiteRuntimeEnv, "gateway">,

sessionKey: string,

predicate: (text: string) => boolean | Promise<boolean>,

timeoutMs = 30_000,

intervalMs = 250,

) {

const startedAt = Date.now();

while (Date.now() - startedAt < timeoutMs) {

const text = await readLatestAgentHistoryReply(env, sessionKey);

if (text && (await predicate(text))) {

return { text };

}

const remainingMs = timeoutMs - (Date.now() - startedAt);

if (remainingMs <= 0) {

break;

}

await sleep(Math.min(intervalMs, remainingMs));

}

throw new Error(`timed out after ${timeoutMs}ms`);

}

async function listCronJobs(env: Pick<QaSuiteRuntimeEnv, "gateway">) {

const payload = (await env.gateway.call(

"cron.list",

runAgentPrompt,

runQaCli,

startAgentRun,

waitForAgentHistoryReply,

waitForMemorySearchMatch,

waitForAgentRun,

};