import childProcess from "node:child_process";

import { createHash } from "node:crypto";

import fs from "node:fs";

import net from "node:net";

import os from "node:os";

import path from "node:path";

import process from "node:process";

const DEFAULT_OUTPUT_CAPTURE_CHARS = 1024 * 1024;

const GATEWAY_TEARDOWN_GRACE_MS = 10000;

const GATEWAY_TEARDOWN_KILL_GRACE_MS = 2000;

const DEFAULT_PORT = 19000 + Math.floor(Math.random() * 1000);

const LOG_SCAN_CHUNK_BYTES = 64 * 1024;

const LOG_SCAN_MAX_LINE_CHARS = 16 * 1024;

const LOG_TAIL_BYTES = 256 * 1024;

OPENCLAW_ENTRY Built OpenClaw entrypoint. Defaults to dist/index.mjs or dist/index.js.

OPENCLAW_KITCHEN_SINK_NPM_SPEC Plugin package spec. Default: npm:@openclaw/kitchen-sink@latest.

OPENCLAW_KITCHEN_SINK_PLUGIN_ID Plugin id. Default: openclaw-kitchen-sink-fixture.

OPENCLAW_KITCHEN_SINK_PERSONALITY Plugin fixture personality. Default: conformance.

OPENCLAW_KITCHEN_SINK_RPC_PORT Gateway loopback port. Default: OS-selected free port.

OPENCLAW_KITCHEN_SINK_RPC_READY_MS Gateway readiness timeout.

OPENCLAW_KITCHEN_SINK_RPC_COMMAND_MS OpenClaw command timeout.

OPENCLAW_KITCHEN_SINK_RPC_INSTALL_MS Plugin install timeout.

OPENCLAW_KITCHEN_SINK_RPC_CALL_MS RPC call timeout.

OPENCLAW_KITCHEN_SINK_RPC_FETCH_MS HTTP readiness probe timeout.

OPENCLAW_KITCHEN_SINK_RPC_FETCH_BODY_BYTES HTTP readiness probe response ceiling.

OPENCLAW_KITCHEN_SINK_MAX_RSS_MIB Gateway RSS ceiling.

OPENCLAW_KITCHEN_SINK_COMMAND_MAX_RSS_MIB Install/CLI command RSS ceiling.

OPENCLAW_KITCHEN_SINK_OUTPUT_CAPTURE_CHARS Per-command stdout/stderr capture ceiling.

OPENCLAW_KITCHEN_SINK_KEEP_TMP=1 Preserve the isolated temp home.

`;

}

};

}

export async function findAvailableLoopbackPort(options = {}) {

const createServer = options.createServer ?? (() => net.createServer());

const server = createServer();

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

const fail = (error) => {

server.close?.(() => {});

reject(toLintErrorObject(error, "Unable to reserve Kitchen Sink RPC loopback port"));

};

server.once("error", fail);

server.listen(0, "127.0.0.1", () => {

server.off?.("error", fail);

const address = server.address();

const port = typeof address === "object" && address ? address.port : 0;

server.close((error) => {

if (error) {

reject(toLintErrorObject(error, "Unable to close Kitchen Sink RPC loopback port"));

return;

}

if (!Number.isSafeInteger(port) || port <= 0) {

reject(new Error(`unable to reserve Kitchen Sink RPC loopback port: ${String(port)}`));

return;

}

resolve(port);

});

});

});

}

export async function resolveKitchenSinkRpcPort(env = process.env, options = {}) {

const rawPort = (env.OPENCLAW_KITCHEN_SINK_RPC_PORT || "").trim();

if (rawPort) {

return readPositiveInt(rawPort, 0, "OPENCLAW_KITCHEN_SINK_RPC_PORT");

}

return await (options.findAvailablePort ?? findAvailableLoopbackPort)();

}

function resolveOpenClawRunner() {

if (process.env.OPENCLAW_ENTRY) {

return {

export async function main() {

const config = resolveKitchenSinkRpcConfig();

let runner = resolveOpenClawRunner();

const port = readPositiveInt(

process.env.OPENCLAW_KITCHEN_SINK_RPC_PORT,

DEFAULT_PORT,

"OPENCLAW_KITCHEN_SINK_RPC_PORT",

);

const port = await resolveKitchenSinkRpcPort();

const { root, env } = makeEnv();

const logPath = path.join(root, "gateway.log");

const keepTmp = process.env.OPENCLAW_KITCHEN_SINK_KEEP_TMP === "1";