} from "./live-agent-probes.js";

import { restoreLiveEnv, snapshotLiveEnv, type LiveEnvSnapshot } from "./live-env-test-helpers.js";

import { renderSolidColorPngBase64 } from "./live-image-probe.js";

import type { EventFrame } from "./protocol/index.js";

const LIVE = isLiveTestEnabled();

const CODEX_HARNESS_LIVE = isTruthyEnvValue(process.env.OPENCLAW_LIVE_CODEX_HARNESS);

async function requestCodexCommandText(params: {

client: GatewayClient;

command: string;

events: EventFrame[];

expectedText: string | string[];

isExpectedText?: (text: string) => boolean;

sessionKey: string;

}): Promise<string> {

const { extractPayloadText } = await import("./test-helpers.agent-results.js");

const payload = await params.client.request(

"agent",

const runId = `idem-${randomUUID()}-codex-command`;

const started = await params.client.request(

"chat.send",

{

sessionKey: params.sessionKey,

idempotencyKey: `idem-${randomUUID()}-codex-command`,

idempotencyKey: runId,

message: params.command,

deliver: false,

thinking: "low",

timeout: CODEX_HARNESS_AGENT_TIMEOUT_SECONDS,

},

{ expectFinal: true, timeoutMs: CODEX_HARNESS_REQUEST_TIMEOUT_MS },

{ timeoutMs: CODEX_HARNESS_REQUEST_TIMEOUT_MS },

);

if (payload?.status !== "ok") {

if (started?.status !== "started") {

throw new Error(

`codex command ${params.command} failed: status=${String(payload?.status)} payload=${JSON.stringify(payload)}`,

`codex command ${params.command} did not start correctly: ${JSON.stringify(started)}`,

);

}

const text = extractPayloadText(payload.result);

const text = await waitForChatFinalText({

events: params.events,

runId,

timeoutMs: CODEX_HARNESS_REQUEST_TIMEOUT_MS,

});

const expectedTexts = Array.isArray(params.expectedText)

? params.expectedText

: [params.expectedText];

return text;

}

async function waitForChatFinalText(params: {

events: EventFrame[];

runId: string;

timeoutMs: number;

}): Promise<string> {

const deadline = Date.now() + params.timeoutMs;

while (Date.now() < deadline) {

const text = params.events

.map((event) => extractChatFinalText(event, params.runId))

.find(Boolean);

if (text) {

return text;

}

await delay(50);

}

throw new Error(`timed out waiting for chat final for ${params.runId}`);

}

function extractChatFinalText(event: EventFrame, runId: string): string | undefined {

if (event.event !== "chat") {

return undefined;

}

const payload = event.payload;

if (!payload || typeof payload !== "object") {

return undefined;

}

const record = payload as Record<string, unknown>;

if (record.runId !== runId || record.state !== "final") {

return undefined;

}

const message = record.message;

if (!message || typeof message !== "object") {

return undefined;

}

const messageRecord = message as Record<string, unknown>;

if (typeof messageRecord.text === "string" && messageRecord.text.trim()) {

return messageRecord.text;

}

const content = Array.isArray(messageRecord.content) ? messageRecord.content : [];

return content

.map((entry) =>

entry && typeof entry === "object" ? (entry as Record<string, unknown>).text : undefined,

)

.filter((entry): entry is string => typeof entry === "string" && entry.trim().length > 0)

.join("\n")

.trim();

}

async function verifyCodexImageProbe(params: {

client: GatewayClient;

sessionKey: string;

const deviceIdentity = await ensurePairedTestGatewayClientIdentity({

displayName: "vitest-codex-harness-live",

});

const gatewayEvents: EventFrame[] = [];

logCodexLiveStep("config-written", { configPath, modelKey, port });

const server = await startGatewayServer(port, {

timeoutMs: GATEWAY_CONNECT_TIMEOUT_MS,

requestTimeoutMs: CODEX_HARNESS_REQUEST_TIMEOUT_MS,

clientDisplayName: "vitest-codex-harness-live",

onEvent: (event) => {

gatewayEvents.push(event);

},

});

logCodexLiveStep("client-connected");

const statusText = await requestCodexCommandText({

client,

events: gatewayEvents,

sessionKey,

command: "/codex status",

expectedText: [...EXPECTED_CODEX_STATUS_COMMAND_TEXT],

const modelsText = await requestCodexCommandText({

client,

events: gatewayEvents,

sessionKey,

command: "/codex models",

expectedText: [...EXPECTED_CODEX_MODELS_COMMAND_TEXT],