import { tmpdir } from "node:os";

import path from "node:path";

import { performance } from "node:perf_hooks";

import { pathToFileURL } from "node:url";

type GatewayBenchCase = {

config: Record<string, unknown>;

};

type ProbeResult = {

firstErrorKind: string | null;

firstRecoveryMs: number | null;

ms: number | null;

status: number | null;

transitions: ProbeTransition[];

};

type ProbeTransition = {

errorKind?: string;

ms: number;

status: number | null;

};

type GatewaySample = {

cpuCoreRatio: number | null;

cpuMs: number | null;

exitCode: number | null;

firstOutputMs: number | null;

gatewayReadyLogLine: string | null;

gatewayReadyLogMs: number | null;

healthz: ProbeResult;

httpListenLogLine: string | null;

httpListenLogMs: number | null;

maxRssMb: number | null;

outputTail: string;

readyLogMs: number | null;

readyz: ProbeResult;

signal: string | null;

startupTrace: Record<string, number>;

firstOutputMs: SummaryStats | null;

cpuCoreRatio: SummaryStats | null;

cpuMs: SummaryStats | null;

gatewayReadyLogMs: SummaryStats | null;

healthzMs: SummaryStats | null;

httpListenLogMs: SummaryStats | null;

maxRssMb: SummaryStats | null;

readyLogMs: SummaryStats | null;

readyzMs: SummaryStats | null;

startupTrace: Record<string, SummaryStats>;

};

};

type PluginFixtureResult = {

pluginIds: string[];

pluginsDir: string;

};

type CliOptions = {

cases: GatewayBenchCase[];

cpuProfDir?: string;

id: "fiftyPlugins",

name: "gateway, 50 manifest plugins",

env: { OPENCLAW_SKIP_CHANNELS: "1" },

pluginActivationOnStartup: true,

pluginCount: 50,

config: BASE_CONFIG,

},

.map((sample) => sample.cpuMs)

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

),

gatewayReadyLogMs: summarizeNumbers(

samples

.map((sample) => sample.gatewayReadyLogMs)

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

),

healthzMs: summarizeNumbers(

samples

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

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

),

maxRssMb: summarizeNumbers(

httpListenLogMs: summarizeNumbers(

samples

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

.map((sample) => sample.httpListenLogMs)

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

),

readyLogMs: summarizeNumbers(

maxRssMb: summarizeNumbers(

samples

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

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

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

),

readyzMs: summarizeNumbers(

port: number;

startAt: number;

}): Promise<ProbeResult> {

let firstErrorKind: string | null = null;

let firstRecoveryMs: number | null = null;

let lastStatus: number | null = null;

let lastStateKey: string | null = null;

let sawUnreadyState = false;

const transitions: ProbeTransition[] = [];

while (performance.now() < params.deadlineAt) {

if (params.isDone?.()) {

break;

}

const status = await requestStatus(params.port, params.path).catch(() => null);

lastStatus = status;

if (status === 200) {

return { ms: performance.now() - params.startAt, status };

const attempt = await requestProbeStatus(params.port, params.path);

const now = performance.now();

const elapsedMs = now - params.startAt;

lastStatus = attempt.status;

const stateKey = `${attempt.status ?? "none"}:${attempt.errorKind ?? "ok"}`;

if (stateKey !== lastStateKey) {

transitions.push({

ms: elapsedMs,

status: attempt.status,

...(attempt.errorKind ? { errorKind: attempt.errorKind } : {}),

});

lastStateKey = stateKey;

}

if (attempt.errorKind && firstErrorKind == null) {

firstErrorKind = attempt.errorKind;

}

if (attempt.status !== 200) {

sawUnreadyState = true;

}

if (attempt.status === 200) {

if (sawUnreadyState && firstRecoveryMs == null) {

firstRecoveryMs = elapsedMs;

}

return {

firstErrorKind,

firstRecoveryMs,

ms: elapsedMs,

status: attempt.status,

transitions,

};

}

await delay(25);

}

return { ms: null, status: lastStatus };

return { firstErrorKind, firstRecoveryMs, ms: null, status: lastStatus, transitions };

}

async function requestProbeStatus(

port: number,

pathname: string,

): Promise<{ errorKind: string | null; status: number | null }> {

try {

const status = await requestStatus(port, pathname);

return {

errorKind: status === 200 ? null : `http-${status}`,

status,

};

} catch (error) {

return {

errorKind: classifyProbeErrorKind(error),

status: null,

};

}

}

function classifyProbeErrorKind(error: unknown): string {

if (typeof error === "object" && error !== null) {

const code = (error as { code?: unknown }).code;

if (typeof code === "string" && code.trim()) {

return code.trim().toLowerCase();

}

const message = (error as { message?: unknown }).message;

if (typeof message === "string" && /probe timeout/iu.test(message)) {

return "timeout";

}

const name = (error as { name?: unknown }).name;

if (typeof name === "string" && name.trim()) {

return name.trim().toLowerCase();

}

}

return "error";

}

function requestStatus(port: number, pathname: string): Promise<number> {

return new Promise((resolve) => setTimeout(resolve, ms));

}

function writePluginFixtures(root: string, count: number, activationOnStartup?: boolean): string[] {

const files: string[] = [];

function writePluginFixtures(

root: string,

count: number,

activationOnStartup?: boolean,

): PluginFixtureResult {

const pluginIds: string[] = [];

const pluginsDir = path.join(root, "plugins");

mkdirSync(pluginsDir, { recursive: true });

for (let index = 0; index < count; index += 1) {

const id = `bench-plugin-${String(index + 1).padStart(2, "0")}`;

pluginIds.push(id);

const pluginDir = path.join(pluginsDir, id);

mkdirSync(pluginDir, { recursive: true });

const entry = path.join(pluginDir, "index.cjs");

2,

)}\n`,

);

files.push(entry);

}

return files;

return { pluginIds, pluginsDir };

}

function writeConfig(root: string, benchCase: GatewayBenchCase): string {

const pluginPaths = benchCase.pluginCount

const pluginFixtures = benchCase.pluginCount

? writePluginFixtures(root, benchCase.pluginCount, benchCase.pluginActivationOnStartup)

: [];

: null;

const config = {

...benchCase.config,

plugins: {

...(benchCase.config.plugins as Record<string, unknown> | undefined),

...(pluginPaths.length > 0

...(pluginFixtures

? {

load: { paths: pluginPaths },

allow: pluginPaths.map((file) => path.basename(path.dirname(file))),

load: { paths: [pluginFixtures.pluginsDir] },

allow: pluginFixtures.pluginIds,

}

: {}),

},

}

}

function hasGatewayReadyLog(line: string): boolean {

return /\[gateway\] (?:http server listening|ready \()/.test(line);

function classifyGatewayReadyLog(line: string): "gateway-ready" | "http-listen" | null {

if (/\[gateway\] http server listening \(/.test(line)) {

return "http-listen";

}

if (/\[gateway\] ready(?:\s*\(|\s*$)/.test(line)) {

return "gateway-ready";

}

return null;

}

function parseStartupTraceMetrics(raw: string): Array<{ key: string; value: number }> {

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

const output: string[] = [];

let firstOutputMs: number | null = null;

let gatewayReadyLogLine: string | null = null;

let gatewayReadyLogMs: number | null = null;

let httpListenLogLine: string | null = null;

let httpListenLogMs: number | null = null;

let maxRssMb: number | null = null;

let readyLogMs: number | null = null;

let childExited = false;

const childArgs = [

output.splice(0, output.length - 20);

}

for (const line of text.split(/\r?\n/u)) {

if (hasGatewayReadyLog(line) && readyLogMs == null) {

readyLogMs = performance.now() - startAt;

const readyLogKind = classifyGatewayReadyLog(line);

if (readyLogKind === "http-listen" && httpListenLogMs == null) {

httpListenLogMs = performance.now() - startAt;

httpListenLogLine = line;

}

if (readyLogKind === "gateway-ready" && gatewayReadyLogMs == null) {

gatewayReadyLogMs = performance.now() - startAt;

gatewayReadyLogLine = line;

}

collectStartupTrace(line, startupTrace);

}

cpuMs,

exitCode: exit.exitCode,

firstOutputMs,

gatewayReadyLogLine,

gatewayReadyLogMs,

healthz,

httpListenLogLine,

httpListenLogMs,

maxRssMb,

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

readyLogMs,

readyz,

signal: exit.signal,

startupTrace,

samples.push(sample);

const heapUsedMb = sample.startupTrace["memory.ready.heapUsedMb"] ?? null;

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)} cpu=${formatMs(sample.cpuMs)} cpuCore=${formatRatio(sample.cpuCoreRatio)} rss=${formatMb(sample.maxRssMb)} heap=${formatMb(heapUsedMb)}`,

`[gateway-startup-bench] ${options.benchCase.id} run ${samples.length}/${options.runs}: healthz=${formatMs(sample.healthz.ms)} readyz=${formatMs(sample.readyz.ms)} httpListen=${formatMs(sample.httpListenLogMs)} gatewayReady=${formatMs(sample.gatewayReadyLogMs)} cpu=${formatMs(sample.cpuMs)} cpuCore=${formatRatio(sample.cpuCoreRatio)} rss=${formatMb(sample.maxRssMb)} heap=${formatMb(heapUsedMb)}`,

);

} else {

const heapUsedMb = sample.startupTrace["memory.ready.heapUsedMb"] ?? null;

console.log(` CPU: ${formatStats(result.summary.cpuMs)}`);

console.log(` CPU core: ${formatRatioStats(result.summary.cpuCoreRatio)}`);

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

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

console.log(` http listen: ${formatStats(result.summary.httpListenLogMs)}`);

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

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

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

console.log(

}

}

main().catch((err) => {

console.error(err instanceof Error ? err.stack : String(err));

process.exitCode = 1;

});

export const __testing = {

classifyGatewayReadyLog,

classifyProbeErrorKind,

collectStartupTrace,

summarizeCase,

waitForProbe,

writeConfig,

};

if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {

main().catch((err) => {

console.error(err instanceof Error ? err.stack : String(err));

process.exitCode = 1;

});

}