import path from "node:path";

import process from "node:process";

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

import { fileURLToPath } from "node:url";

const TOKEN = "bundled-plugin-runtime-smoke-token";

const OUTPUT_CAPTURE_CHARS = readPositiveInt(

process.env.OPENCLAW_BUNDLED_PLUGIN_RUNTIME_OUTPUT_CHARS,

1024 * 1024,

);

const WATCHDOG_MS = readPositiveInt(process.env.OPENCLAW_BUNDLED_PLUGIN_RUNTIME_WATCHDOG_MS, 1000);

const READY_TIMEOUT_MS = readPositiveInt(

process.env.OPENCLAW_BUNDLED_PLUGIN_RUNTIME_READY_MS,

return typeof value === "string" && value.trim().length > 0;

}

export function appendBoundedOutput(buffer, chunk, maxChars = OUTPUT_CAPTURE_CHARS) {

const nextText = buffer.text + String(chunk);

if (nextText.length <= maxChars) {

return { text: nextText, truncatedChars: buffer.truncatedChars };

}

const truncatedChars = buffer.truncatedChars + nextText.length - maxChars;

return { text: nextText.slice(-maxChars), truncatedChars };

}

function formatCapturedOutput(label, buffer) {

if (!buffer.text) {

return "";

}

const prefix =

buffer.truncatedChars > 0

? `[${label} truncated ${buffer.truncatedChars} chars; showing tail]\n`

: "";

return `${prefix}${buffer.text}`;

}

function runCommand(command, args, options = {}) {

return new Promise((resolve, reject) => {

const child = childProcess.spawn(command, args, {

stdio: ["ignore", "pipe", "pipe"],

...options,

});

let stdout = "";

let stderr = "";

let stdout = { text: "", truncatedChars: 0 };

let stderr = { text: "", truncatedChars: 0 };

child.stdout?.on("data", (chunk) => {

stdout += String(chunk);

stdout = appendBoundedOutput(stdout, chunk);

});

child.stderr?.on("data", (chunk) => {

stderr += String(chunk);

stderr = appendBoundedOutput(stderr, chunk);

});

child.on("error", reject);

child.on("close", (status, signal) => {

if (status === 0) {

resolve({ stdout, stderr });

resolve({

stdout: stdout.text,

stderr: stderr.text,

stdoutTruncatedChars: stdout.truncatedChars,

stderrTruncatedChars: stderr.truncatedChars,

});

return;

}

const detail = [stdout, stderr].filter(Boolean).join("\n").trim();

const detail = [

formatCapturedOutput("stdout", stdout),

formatCapturedOutput("stderr", stderr),

]

.filter(Boolean)

.join("\n")

.trim();

reject(

new Error(

`${command} ${args.join(" ")} failed with ${signal || status}${detail ? `\n${detail}` : ""}`,

}

}

function createIsolatedStateEnv(label) {

export function createIsolatedStateEnv(label) {

const root = fs.mkdtempSync(path.join(os.tmpdir(), `openclaw-${label}-`));

const home = path.join(root, "home");

const stateDir = path.join(home, ".openclaw");

return {

...process.env,

HOME: home,

OPENCLAW_HOME: stateDir,

USERPROFILE: home,

OPENCLAW_HOME: home,

OPENCLAW_STATE_DIR: stateDir,

OPENCLAW_CONFIG_PATH: configPath,

};

return text.split(/\r?\n/u).slice(-120).join("\n");

}

const [command, pluginId, pluginDir, requiresConfigRaw, pluginIndexRaw, pluginRoot, provider] =

process.argv.slice(2);

const pluginIndex = Number.parseInt(pluginIndexRaw || "0", 10);

export async function main(argv = process.argv.slice(2)) {

const [command, pluginId, pluginDir, requiresConfigRaw, pluginIndexRaw, pluginRoot, provider] =

argv;

const pluginIndex = Number.parseInt(pluginIndexRaw || "0", 10);

if (command === "plugin") {

await smokePlugin(pluginId, pluginDir, requiresConfigRaw === "1", pluginIndex, pluginRoot);

} else if (command === "tts-global-disable") {

await smokeTtsGlobalDisable(pluginId, pluginDir, provider, pluginIndex, pluginRoot);

} else if (command === "tts-openai-live") {

await smokeOpenAiTts(pluginIndex);

} else {

throw new Error(`Unknown runtime smoke command: ${command || "(missing)"}`);

}

}

if (command === "plugin") {

await smokePlugin(pluginId, pluginDir, requiresConfigRaw === "1", pluginIndex, pluginRoot);

} else if (command === "tts-global-disable") {

await smokeTtsGlobalDisable(pluginId, pluginDir, provider, pluginIndex, pluginRoot);

} else if (command === "tts-openai-live") {

await smokeOpenAiTts(pluginIndex);

} else {

throw new Error(`Unknown runtime smoke command: ${command || "(missing)"}`);

if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {

await main();

}