import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";

import { spawn, spawnSync, type ChildProcessWithoutNullStreams } from "node:child_process";

import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";

import { request } from "node:http";

import { createServer } from "node:net";

exitCode: number | null;

firstOutputMs: number | null;

healthz: ProbeResult;

maxRssMb: number | null;

outputTail: string;

readyLogMs: number | null;

readyz: ProbeResult;

summary: {

firstOutputMs: SummaryStats | null;

healthzMs: SummaryStats | null;

maxRssMb: SummaryStats | null;

readyLogMs: SummaryStats | null;

readyzMs: SummaryStats | null;

startupTrace: Record<string, SummaryStats>;

.map((sample) => sample.healthz.ms)

.filter((value): value is number => typeof value === "number"),

),

maxRssMb: summarizeNumbers(

samples

.map((sample) => sample.maxRssMb)

.filter((value): value is number => typeof value === "number"),

),

readyLogMs: summarizeNumbers(

samples

.map((sample) => sample.readyLogMs)

return `${value.toFixed(1)}ms`;

}

function formatMb(value: number | null): string {

if (value == null) {

return "n/a";

}

return `${value.toFixed(1)}MB`;

}

function formatStats(stats: SummaryStats | null): string {

if (!stats) {

return "n/a";

}

return `p50=${formatMs(stats.p50)} avg=${formatMs(stats.avg)} min=${formatMs(stats.min)} max=${formatMs(stats.max)}`;

}

function formatMemoryStats(stats: SummaryStats | null): string {

if (!stats) {

return "n/a";

}

return `p50=${formatMb(stats.p50)} avg=${formatMb(stats.avg)} min=${formatMb(stats.min)} max=${formatMb(stats.max)}`;

}

async function getFreePort(): Promise<number> {

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

const server = createServer();

OPENCLAW_GATEWAY_STARTUP_TRACE: "1",

OPENCLAW_HOME: root,

OPENCLAW_LOCAL_CHECK: "0",

OPENCLAW_NO_RESPAWN: "1",

OPENCLAW_STATE_DIR: path.join(root, "state"),

OPENCLAW_TEST_DISABLE_UPDATE_CHECK: "1",

...benchCase.env,

return metrics;

}

function readProcessRssMb(pid: number | undefined): number | null {

if (!pid || process.platform === "win32") {

return null;

}

const result = spawnSync("ps", ["-o", "rss=", "-p", String(pid)], {

encoding: "utf8",

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

});

if (result.status !== 0) {

return null;

}

const rssKb = Number.parseInt(result.stdout.trim(), 10);

return Number.isFinite(rssKb) && rssKb > 0 ? rssKb / 1024 : null;

}

async function runGatewaySample(options: {

benchCase: GatewayBenchCase;

entry: string;

const startupTrace: Record<string, number> = {};

const output: string[] = [];

let firstOutputMs: number | null = null;

let maxRssMb: number | null = null;

let readyLogMs: number | null = null;

let childExited = false;

],

{ cwd: process.cwd(), detached: process.platform !== "win32", env },

);

const sampleRss = () => {

const rssMb = readProcessRssMb(child.pid);

if (rssMb != null) {

maxRssMb = maxRssMb == null ? rssMb : Math.max(maxRssMb, rssMb);

}

};

sampleRss();

const rssTimer = setInterval(sampleRss, 100);

rssTimer.unref?.();

const childExitPromise = new Promise<{ exitCode: number | null; signal: string | null }>(

(resolve) => {

child.once("exit", (exitCode, signal) => {

}),

]);

const exit = await stopChild(child);

clearInterval(rssTimer);

sampleRss();

await childExitPromise.catch(() => null);

rmSync(root, { force: true, maxRetries: 3, recursive: true, retryDelay: 100 });

return {

exitCode: exit.exitCode,

firstOutputMs,

healthz,

maxRssMb,

outputTail: output.join("").split(/\r?\n/u).slice(-20).join("\n"),

readyLogMs,

readyz,

if (index >= options.warmup) {

samples.push(sample);

console.log(

`[gateway-startup-bench] ${options.benchCase.id} run ${samples.length}/${options.runs}: healthz=${formatMs(sample.healthz.ms)} readyz=${formatMs(sample.readyz.ms)} readyLog=${formatMs(sample.readyLogMs)}`,

`[gateway-startup-bench] ${options.benchCase.id} run ${samples.length}/${options.runs}: healthz=${formatMs(sample.healthz.ms)} readyz=${formatMs(sample.readyz.ms)} readyLog=${formatMs(sample.readyLogMs)} rss=${formatMb(sample.maxRssMb)}`,

);

} else {

console.log(

`[gateway-startup-bench] ${options.benchCase.id} warmup ${index + 1}/${options.warmup}: healthz=${formatMs(sample.healthz.ms)} readyz=${formatMs(sample.readyz.ms)}`,

`[gateway-startup-bench] ${options.benchCase.id} warmup ${index + 1}/${options.warmup}: healthz=${formatMs(sample.healthz.ms)} readyz=${formatMs(sample.readyz.ms)} rss=${formatMb(sample.maxRssMb)}`,

);

}

}

console.log(` /healthz: ${formatStats(result.summary.healthzMs)}`);

console.log(` ready log: ${formatStats(result.summary.readyLogMs)}`);

console.log(` /readyz: ${formatStats(result.summary.readyzMs)}`);

console.log(` max RSS: ${formatMemoryStats(result.summary.maxRssMb)}`);

const trace = Object.entries(result.summary.startupTrace)

.filter(([name]) => !name.endsWith(".total"))

.toSorted((a, b) => (b[1].avg ?? 0) - (a[1].avg ?? 0))