import process from "node:process";

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

import { pathToFileURL } from "node:url";

import { createPnpmRunnerSpawnSpec } from "../pnpm-runner.mjs";

const PLUGIN_SPEC =

process.env.OPENCLAW_KITCHEN_SINK_NPM_SPEC || "npm:@openclaw/kitchen-sink@latest";

}

async function runOpenClaw(runner, args, env, options = {}) {

const command = resolveOpenClawCommand(runner, args, env, {

const command = await resolveOpenClawCommand(runner, args, env, {

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

});

return runCommand(command.command, command.args, {

});

}

function resolveOpenClawCommand(runner, args, env, options = {}) {

async function resolveOpenClawCommand(runner, args, env, options = {}) {

if (runner.pnpm) {

const { createPnpmRunnerSpawnSpec } = await import("../pnpm-runner.mjs");

return createPnpmRunnerSpawnSpec({

env,

pnpmArgs: [...runner.baseArgs, ...args],

}

async function loadCallGatewayModule() {

callGatewayModulePromise ??= import(

pathToFileURL(path.join(process.cwd(), "src/gateway/call.ts"))

);

callGatewayModulePromise ??= importCallGatewayModule();

return callGatewayModulePromise;

}

async function importCallGatewayModule() {

const distDir = path.join(process.cwd(), "dist");

if (fs.existsSync(distDir)) {

const candidates = fs

.readdirSync(distDir)

.filter((name) => /^call(?:\.runtime)?-[A-Za-z0-9_-]+\.js$/u.test(name))

.toSorted((left, right) => left.localeCompare(right));

for (const name of candidates) {

const module = await import(pathToFileURL(path.join(distDir, name)).href);

if (typeof module.callGateway === "function") {

return module;

}

}

throw new Error(`unable to find callGateway export in dist (${candidates.join(", ")})`);

}

return import(pathToFileURL(path.join(process.cwd(), "src/gateway/call.ts")).href);

}

async function retryRpcCall(method, params, options) {

const started = Date.now();

let lastError;

writeJson(configPath, config);

}

function startGateway(runner, port, env, logPath) {

async function startGateway(runner, port, env, logPath) {

const log = fs.openSync(logPath, "w");

const command = resolveOpenClawCommand(

const command = await resolveOpenClawCommand(

runner,

[

"gateway",

"--port",

String(port),

"--bind",

"loopback",

"--allow-unconfigured",

],

["gateway", "--port", String(port), "--bind", "loopback", "--allow-unconfigured"],

env,

{

stdio: ["ignore", log, log],

];

assertIncludesAny(inspectProviders, EXPECTED_PROVIDERS, "plugins inspect providers");

const child = startGateway(runner, port, env, logPath);

const child = await startGateway(runner, port, env, logPath);

try {

await waitForGatewayReady(child, port, logPath);

const initialSample = await sampleProcess(child.pid);