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

import fs from "node:fs";

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

import { request } from "node:http";

import { createServer } from "node:net";

import { tmpdir } from "node:os";

import path from "node:path";

import { performance } from "node:perf_hooks";

import { pathToFileURL } from "node:url";

import { parseStrictIntegerOption } from "./lib/dev-tooling-safety.ts";

import { delay, stopChild, type StopChildResult } from "./lib/gateway-bench-child.ts";

import {

classifyProbeErrorKind,

getFreePort,

parseProcessRssKb,

readProcessRssMb,

readProcessTreeCpuMs,

requestProbeStatus,

} from "./lib/gateway-bench-probes.ts";

type GatewayBenchCase = {

config: Record<string, unknown>;

};

}

async function getFreePort(): Promise<number> {

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

const server = createServer();

server.on("error", reject);

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

const address = server.address();

if (!address || typeof address === "string") {

server.close(() => reject(new Error("failed to allocate port")));

return;

}

const { port } = address;

server.close(() => resolve(port));

});

});

}

async function waitForProbeReady(params: {

deadlineAt: number;

isDone?: () => boolean;

};

}

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" && message.toLowerCase().includes("probe timeout")) {

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, reject) => {

const req = request(

{ host: "127.0.0.1", method: "GET", path: pathname, port, timeout: 100 },

(res) => {

res.resume();

res.on("end", () => resolve(res.statusCode ?? 0));

},

);

req.on("error", reject);

req.on("timeout", () => {

req.destroy(new Error("probe timeout"));

});

req.end();

});

}

function writePluginFixtures(

root: string,

count: number,

}

}

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 = parseProcessRssKb(result.stdout);

return rssKb === null ? null : rssKb / 1024;

}

function parseProcessRssKb(raw: string): number | null {

const value = raw.trim();

if (!/^[1-9][0-9]*$/u.test(value)) {

return null;

}

const rssKb = Number(value);

return Number.isSafeInteger(rssKb) ? rssKb : null;

}

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

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

return null;

return count;

}

function parsePsCpuTimeMs(raw: string): number | null {

const parts = raw.trim().split(":").map(Number);

if (parts.some((part) => !Number.isFinite(part) || part < 0)) {

return null;

}

if (parts.length === 2) {

return Math.round((parts[0] * 60 + parts[1]) * 1000);

}

if (parts.length === 3) {

return Math.round((parts[0] * 60 * 60 + parts[1] * 60 + parts[2]) * 1000);

}

return null;

}

function readProcessTreeCpuMs(rootPid: number | undefined): number | null {

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

return null;

}

const result = spawnSync("ps", ["-eo", "pid=,ppid=,time="], {

encoding: "utf8",

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

});

if (result.status !== 0) {

return null;

}

const childrenByParent = new Map<number, number[]>();

const cpuByPid = new Map<number, number>();

for (const line of result.stdout.split("\n")) {

const match = line.trim().match(/^(\d+)\s+(\d+)\s+(\S+)$/u);

if (!match) {

continue;

}

const pid = Number(match[1]);

const ppid = Number(match[2]);

const cpuMs = parsePsCpuTimeMs(match[3]);

if (!Number.isInteger(pid) || !Number.isInteger(ppid) || cpuMs === null) {

continue;

}

cpuByPid.set(pid, cpuMs);

const children = childrenByParent.get(ppid) ?? [];

children.push(pid);

childrenByParent.set(ppid, children);

}

if (!cpuByPid.has(rootPid)) {

return null;

}

let totalCpuMs = 0;

const seen = new Set<number>();

const stack = [rootPid];

while (stack.length > 0) {

const pid = stack.pop();

if (!pid || seen.has(pid)) {

continue;

}

seen.add(pid);

totalCpuMs += cpuByPid.get(pid) ?? 0;

for (const childPid of childrenByParent.get(pid) ?? []) {

stack.push(childPid);

}

}

return totalCpuMs;

}

function snapshotResources(

child: ChildProcessWithoutNullStreams,

sampleStartAt: number,