return null;

}

if (platform === "win32") {

return sampleWindowsProcess(pid, run);

return sampleWindowsProcess(pid, run, options.windowsCommandLineNeedles);

}

return samplePosixProcess(pid, run);

}

}

}

async function sampleWindowsProcess(pid, run) {

function parseTasklistCsvLine(line) {

const values = [];

let current = "";

let inQuotes = false;

for (let index = 0; index < line.length; index += 1) {

const char = line[index];

if (char === '"') {

if (inQuotes && line[index + 1] === '"') {

current += '"';

index += 1;

} else {

inQuotes = !inQuotes;

}

continue;

}

if (char === "," && !inQuotes) {

values.push(current);

current = "";

continue;

}

current += char;

}

values.push(current);

return values;

}

async function sampleWindowsPidWithTasklist(pid, run) {

const safePid = Number(pid);

if (!Number.isInteger(safePid) || safePid <= 0) {

return null;

}

try {

const { stdout } = await run(

"tasklist.exe",

["/FI", `PID eq ${safePid}`, "/FO", "CSV", "/NH"],

{ timeoutMs: 15000 },

);

const line = stdout

.split(/\r?\n/u)

.map((entry) => entry.trim())

.find((entry) => entry.startsWith('"'));

if (!line) {

return null;

}

const [, processIdRaw, , , memoryRaw] = parseTasklistCsvLine(line);

const processId = Number.parseInt(processIdRaw ?? "", 10);

const memoryKiB = Number.parseInt((memoryRaw ?? "").replace(/[^\d]/gu, ""), 10);

if (!Number.isFinite(memoryKiB)) {

return null;

}

return {

rssMiB: Math.round((memoryKiB / 1024) * 10) / 10,

cpuPercent: null,

cpuSeconds: null,

processId: Number.isFinite(processId) ? processId : safePid,

};

} catch {

return null;

}

}

export async function sampleWindowsProcessByPort(port, options = {}) {

const safePort = Number(port);

if (!Number.isInteger(safePort) || safePort <= 0) {

return null;

}

const run = options.runCommand ?? runCommand;

try {

const { stdout } = await run("netstat.exe", ["-ano", "-p", "tcp"], { timeoutMs: 15000 });

const pid = stdout

.split(/\r?\n/u)

.map((line) => line.trim())

.filter((line) => line.includes(`:${safePort}`) && /\bLISTENING\b/iu.test(line))

.map((line) => Number.parseInt(line.split(/\s+/u).at(-1) ?? "", 10))

.find((candidate) => Number.isInteger(candidate) && candidate > 0);

if (!pid) {

return null;

}

return (await sampleWindowsProcess(pid, run)) ?? sampleWindowsPidWithTasklist(pid, run);

} catch {

return null;

}

}

function powershellSingleQuoted(value) {

return `'${String(value).replace(/'/gu, "''")}'`;

}

async function sampleWindowsProcess(pid, run, commandLineNeedles = []) {

const safePid = Number(pid);

if (!Number.isInteger(safePid) || safePid <= 0) {

return null;

}

const command = [

"$ErrorActionPreference = 'Stop'",

`$process = Get-Process -Id ${safePid} -ErrorAction Stop`,

"$cpu = 0",

"if ($null -ne $process.CPU) { $cpu = $process.CPU }",

"[Console]::Out.Write(('{0} {1}' -f $process.WorkingSet64, $cpu))",

].join("; ");

const needles = commandLineNeedles

.map((needle) => String(needle ?? "").trim())

.filter((needle) => needle.length > 0);

const powershellNeedles = `@(${needles.map(powershellSingleQuoted).join(", ")})`;

const command =

needles.length === 0

? [

"$ErrorActionPreference = 'Stop'",

`$process = Get-Process -Id ${safePid} -ErrorAction Stop`,

"$cpu = 0",

"if ($null -ne $process.CPU) { $cpu = $process.CPU }",

"[Console]::Out.Write(('{0} {1} {2}' -f $process.WorkingSet64, $cpu, $process.Id))",

].join("; ")

: [

"$ErrorActionPreference = 'Stop'",

`$rootPid = ${safePid}`,

`$commandLineNeedles = ${powershellNeedles}`,

"$ids = [System.Collections.Generic.HashSet[int]]::new()",

"[void]$ids.Add($rootPid)",

'if ($commandLineNeedles.Count -gt 0) { $queryNeedle = $commandLineNeedles[$commandLineNeedles.Count - 1].Replace("\'", "\'\'"); $candidates = Get-CimInstance Win32_Process -Filter "CommandLine LIKE \'%$queryNeedle%\'" | Select-Object ProcessId, CommandLine; foreach ($process in $candidates) { if ([int]$process.ProcessId -eq $PID) { continue }; $line = [string]$process.CommandLine; $matches = $true; foreach ($needle in $commandLineNeedles) { if ($line.IndexOf($needle, [StringComparison]::OrdinalIgnoreCase) -lt 0) { $matches = $false; break } }; if ($matches) { [void]$ids.Add([int]$process.ProcessId) } } }',

"if ($ids.Count -le 1) { $processes = Get-CimInstance Win32_Process | Select-Object ProcessId, ParentProcessId; $changed = $true; while ($changed) { $changed = $false; foreach ($process in $processes) { if ($ids.Contains([int]$process.ParentProcessId) -and -not $ids.Contains([int]$process.ProcessId)) { [void]$ids.Add([int]$process.ProcessId); $changed = $true } } } }",

"$samples = foreach ($id in $ids) { try { Get-Process -Id $id -ErrorAction Stop } catch {} }",

"$process = $samples | Sort-Object WorkingSet64 -Descending | Select-Object -First 1",

"if ($null -eq $process) { exit 2 }",

"$cpu = 0",

"if ($null -ne $process.CPU) { $cpu = $process.CPU }",

"[Console]::Out.Write(('{0} {1} {2}' -f $process.WorkingSet64, $cpu, $process.Id))",

].join("; ");

for (const powershell of ["powershell.exe", "powershell"]) {

try {

const { stdout } = await run(

powershell,

["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", command],

{ timeoutMs: 5000 },

{ timeoutMs: 15000 },

);

const [workingSetBytesRaw, cpuSecondsRaw] = stdout.trim().split(/\s+/u);

const [workingSetBytesRaw, cpuSecondsRaw, processIdRaw] = stdout.trim().split(/\s+/u);

const workingSetBytes = Number.parseInt(workingSetBytesRaw ?? "", 10);

const cpuSeconds = Number.parseFloat(cpuSecondsRaw ?? "");

const processId = Number.parseInt(processIdRaw ?? "", 10);

if (!Number.isFinite(workingSetBytes)) {

return null;

}

return {

rssMiB: Math.round((workingSetBytes / 1024 / 1024) * 10) / 10,

cpuPercent: null,

cpuSeconds: Number.isFinite(cpuSeconds) ? cpuSeconds : null,

processId: Number.isFinite(processId) ? processId : safePid,

};

} catch {

// Try the next Windows PowerShell command name.

}

export async function main() {

const runner = resolveOpenClawRunner();

let runner = resolveOpenClawRunner();

const port = readPositiveInt(process.env.OPENCLAW_KITCHEN_SINK_RPC_PORT, DEFAULT_PORT);

const { root, env } = makeEnv();

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

await runOpenClaw(runner, ["plugins", "install", PLUGIN_SPEC], env, {

timeoutMs: INSTALL_TIMEOUT_MS,

});

runner = resolveOpenClawRunner();

console.log(`Kitchen Sink RPC runtime runner: ${runner.label}`);

configureKitchenSink(env, port);

await runOpenClaw(runner, ["plugins", "enable", PLUGIN_ID], env, { timeoutMs: 60000 });

const inspect = parseJsonOutput(

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

const processSamples = [];

const sampleGateway = async () => {

const sample = await sampleProcess(child.pid);

const windowsSampleOptions = runner.pnpm

? { windowsCommandLineNeedles: ["gateway", "--port", String(port)] }

: {};

let sample = await sampleProcess(child.pid, windowsSampleOptions);

if (!sample && process.platform === "win32") {

sample = await sampleWindowsProcessByPort(port);

}

if (sample) {

processSamples.push(sample);

}

return sample;

};

let sampleInFlight = null;

const collectTimedSample = () => {

sampleInFlight ??= sampleGateway().finally(() => {

sampleInFlight = null;

});

return sampleInFlight;

};

let sampleTimer;

try {

await waitForGatewayReady(child, port, logPath);

const initialSample = await sampleGateway();

sampleTimer = setInterval(() => {

void sampleGateway().catch(() => {});

void collectTimedSample().catch(() => {});

}, 1000);

sampleTimer.unref?.();

const healthz = await fetchJson(`http://127.0.0.1:${port}/healthz`);

);

}

await retryRpcCall("diagnostics.stability", {}, { runner, port, env });

await sampleInFlight?.catch(() => {});

const finalSample = await sampleGateway();

assertResourceCeiling(finalSample);

const peakSample = summarizeProcessSamples(processSamples);