import fs from "node:fs/promises";

import path from "node:path";

import { afterEach, describe, expect, it } from "vitest";

import type { EventFrame } from "../../packages/gateway-protocol/src/index.js";

import { isLiveTestEnabled } from "../agents/live-test-helpers.js";

import type { OpenClawConfig } from "../config/config.js";

import { extractFirstTextBlock } from "../shared/chat-message-content.js";

restoreLiveEnv(snapshot);

}

async function removeLiveTempDir(dir: string): Promise<void> {

let lastError: unknown;

for (let attempt = 0; attempt < 100; attempt += 1) {

try {

await fs.rm(dir, { recursive: true, force: true });

return;

} catch (error) {

lastError = error;

const code = (error as { code?: unknown } | null)?.code;

if (code !== "EBUSY" && code !== "ENOTEMPTY" && code !== "EPERM" && code !== "EACCES") {

throw error;

}

await new Promise((resolve) => {

setTimeout(resolve, 100);

});

}

}

await fs.rm(dir, { recursive: true, force: true });

void lastError;

}

async function writeLiveGatewayConfig(params: {

configPath: string;

modelKey: string;

}

async function connectGatewayClient(params: {

onEvent?: (event: EventFrame) => void;

url: string;

token: string;

}): Promise<GatewayClient> {

requestTimeoutMs: 60_000,

tickWatchTimeoutMs: AGENT_REQUEST_TIMEOUT_MS + 120_000,

clientDisplayName: "trajectory-live",

onEvent: params.onEvent,

});

return client;

}

throw new Error(`timed out waiting for ${filePath}`);

}

function extractAssistantTexts(messages: unknown[]): string[] {

const texts: string[] = [];

for (const entry of messages) {

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

continue;

}

if ((entry as { role?: unknown }).role !== "assistant") {

continue;

}

const text = extractFirstTextBlock(entry);

if (typeof text === "string" && text.trim().length > 0) {

texts.push(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 new Promise((resolve) => {

setTimeout(resolve, 50);

});

}

return texts;

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

}

function formatAssistantTextPreview(texts: string[], maxChars = 800): string {

const combined = texts.join("\n\n").trim();

if (!combined) {

return "<none>";

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;

}

return combined.length > maxChars ? `${combined.slice(0, maxChars)}...` : combined;

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 waitForAssistantText(params: {

client: GatewayClient;

contains: string;

sessionKey: string;

timeoutMs?: number;

}): Promise<string> {

const timeoutMs = params.timeoutMs ?? 60_000;

async function approveTrajectoryExport(client: GatewayClient): Promise<string> {

const startedAt = Date.now();

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

const history: { messages?: unknown[] } = await params.client.request("chat.history", {

sessionKey: params.sessionKey,

limit: 24,

});

const assistantTexts = extractAssistantTexts(history.messages ?? []);

const matched = assistantTexts.find((text) => text.includes(params.contains));

if (matched) {

return matched;

let approval:

| {

id?: string;

request?: {

command?: string;

};

}

| undefined;

while (Date.now() - startedAt < 60_000) {

const approvals = (await client.request(

"exec.approval.list",

{},

{ timeoutMs: 10_000 },

)) as Array<{

id?: string;

request?: {

command?: string;

};

}>;

approval = approvals.find((entry) =>

entry.request?.command?.includes("sessions export-trajectory"),

);

if (approval) {

break;

}

await new Promise((resolve) => {

setTimeout(resolve, 500);

});

}

const finalHistory: { messages?: unknown[] } = await params.client.request("chat.history", {

sessionKey: params.sessionKey,

limit: 24,

});

throw new Error(

`timed out waiting for assistant text containing ${params.contains}: ${formatAssistantTextPreview(

extractAssistantTexts(finalHistory.messages ?? []),

)}`,

);

}

async function approveTrajectoryExport(client: GatewayClient): Promise<string> {

const approvals = (await client.request(

"exec.approval.list",

{},

{ timeoutMs: 10_000 },

)) as Array<{

id?: string;

request?: {

command?: string;

};

}>;

const approval = approvals.find((entry) =>

entry.request?.command?.includes("sessions export-trajectory"),

);

expect(typeof approval?.id).toBe("string");

expect(approval?.request?.command).toContain("sessions export-trajectory");

if (!approval?.id) {

cleanup.push(async () => {

restoreEnv(previousEnv);

clearRuntimeConfigSnapshot();

await fs.rm(tempDir, { recursive: true, force: true });

await removeLiveTempDir(tempDir);

});

const stateDir = path.join(tempDir, "state");

await server.close();

});

const gatewayEvents: EventFrame[] = [];

const client = await connectGatewayClient({

url: `ws://127.0.0.1:${port}`,

token,

onEvent: (event) => {

gatewayEvents.push(event);

},

});

logLiveStep("client-connected");

cleanup.push(async () => {

const finalText =

typeof exportResponse?.message === "object"

? extractFirstTextBlock(exportResponse.message)

: await waitForAssistantText({

client,

sessionKey,

contains: "Trajectory exports can include",

: await waitForChatFinalText({

events: gatewayEvents,

runId: exportRunId,

timeoutMs: 60_000,

});

expect(finalText).toContain("Trajectory exports can include");

logLiveStep("export:approved", { approvalId });

await waitForPath(path.join(bundleDir, "events.jsonl"), 60_000);

logLiveStep("export:done", { finalText });

if (finalText) {

expect(finalText).toContain("Approve once");

}

expect(finalText).toContain("Approve once");

const bundleNames = await listDirectoryNames(bundleDir);

for (const expectedName of [

"artifacts.json",