import path from "node:path";

import { describe, it } from "vitest";

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

import type { ChannelOutboundContext } from "../channels/plugins/types.public.js";

import { clearConfigCache, clearRuntimeConfigSnapshot } from "../config/config.js";

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

import { isTruthyEnvValue } from "../infra/env.js";

const CODEX_BIND_REQUEST_TIMEOUT_MS = 180_000;

const DEFAULT_CODEX_BIND_MODEL = "gpt-5.4";

function createSlackCurrentConversationBindingRegistry() {

type CapturedOutboundReply = {

accountId?: string;

text: string;

threadId?: string | number;

to: string;

};

function createSlackCurrentConversationBindingRegistry(outboundReplies: CapturedOutboundReply[]) {

return createTestRegistry([

{

pluginId: "slack",

conversationBindings: {

supportsCurrentConversationBinding: true,

},

outbound: {

deliveryMode: "direct",

sendText: async ({ accountId, text, threadId, to }: ChannelOutboundContext) => {

outboundReplies.push({

...(accountId ? { accountId } : {}),

text,

...(threadId != null ? { threadId } : {}),

to,

});

return { channel: "slack", messageId: `slack-${outboundReplies.length}` };

},

},

bindings: {

compileConfiguredBinding: () => null,

matchInboundConversation: () => null,

return combined.length <= maxChars ? combined : combined.slice(-maxChars);

}

async function waitForOutboundText(params: {

replies: CapturedOutboundReply[];

contains: string;

minReplyCount?: number;

timeoutMs?: number;

}): Promise<{ outboundTexts: string[]; matchedText: string }> {

const timeoutMs = params.timeoutMs ?? 60_000;

const startedAt = Date.now();

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

const outboundTexts = params.replies

.map((reply) => reply.text)

.filter((value) => value.trim().length > 0);

const minReplyCount = params.minReplyCount ?? 1;

const matchedText = outboundTexts

.slice(Math.max(0, minReplyCount - 1))

.find((text) => text.includes(params.contains));

if (outboundTexts.length >= minReplyCount && matchedText) {

return { outboundTexts, matchedText };

}

await sleep(500);

}

throw new Error(

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

params.replies.map((reply) => reply.text),

)}`,

);

}

function restoreEnvVar(name: string, value: string | undefined): void {

if (value === undefined) {

delete process.env[name];

const conversationId = `user:${slackUserId}`;

const bindModel =

process.env.OPENCLAW_LIVE_CODEX_BIND_MODEL?.trim() || DEFAULT_CODEX_BIND_MODEL;

const outboundReplies: CapturedOutboundReply[] = [];

await fs.mkdir(workspace, { recursive: true });

await fs.writeFile(

requestTimeoutMs: CODEX_BIND_REQUEST_TIMEOUT_MS,

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

});

const channelRegistry = createSlackCurrentConversationBindingRegistry();

const channelRegistry = createSlackCurrentConversationBindingRegistry(outboundReplies);

pinActivePluginChannelRegistry(channelRegistry);

try {

originatingTo: conversationId,

originatingAccountId: accountId,

});

const bindHistory = await waitForAssistantText({

client,

sessionKey,

const bindReply = await waitForOutboundText({

replies: outboundReplies,

contains: "Bound this conversation to Codex thread",

timeoutMs: CODEX_BIND_REQUEST_TIMEOUT_MS,

});

accountId,

conversationId,

});

let commandAssistantCount = bindHistory.assistantTexts.length;

let commandReplyCount = bindReply.outboundTexts.length;

const sendCodexCommand = async (message: string, contains: string, timeoutMs = 60_000) => {

await sendChatAndWait({

originatingTo: conversationId,

originatingAccountId: accountId,

});

const result = await waitForAssistantText({

client,

sessionKey,

const result = await waitForOutboundText({

replies: outboundReplies,

contains,

minAssistantCount: commandAssistantCount + 1,

minReplyCount: commandReplyCount + 1,

timeoutMs,

});

commandAssistantCount = result.assistantTexts.length;

commandReplyCount = result.outboundTexts.length;

return result;

};

await sendCodexCommand("/codex stop", "No active Codex run to stop.");

const bindingStatus = await sendCodexCommand("/codex binding", "- Fast: on");

if (!bindingStatus.matchedAssistantText.includes("- Permissions: default")) {

if (!bindingStatus.matchedText.includes("- Permissions: default")) {

throw new Error(

`binding status did not include default permissions: ${bindingStatus.matchedAssistantText}`,

`binding status did not include default permissions: ${bindingStatus.matchedText}`,

);

}