validateCliArgs,

waitForGatewayReady,

} from "../../scripts/e2e/kitchen-sink-rpc-walk.mjs";

import { resolveWindowsTaskkillPath } from "../../scripts/lib/windows-taskkill.mjs";

import {

resolveWindowsPowerShellPath,

resolveWindowsSystem32Path,

resolveWindowsTaskkillPath,

} from "../../scripts/lib/windows-taskkill.mjs";

import { cleanupTempDirs, makeTempDir } from "../helpers/temp-dir.js";

const posixIt = process.platform === "win32" ? it.skip : it;

return resolveWindowsTaskkillPath();

}

function expectedWindowsSystem32Path(executableName: string): string {

return resolveWindowsSystem32Path(executableName);

}

function expectedPowerShellPath(): string {

return resolveWindowsPowerShellPath();

}

afterEach(() => {

vi.restoreAllMocks();

vi.useRealTimers();

});

describe("kitchen-sink RPC process sampling", () => {

it("rejects unsafe Windows System32 executable names", () => {

expect(() => resolveWindowsSystem32Path("..\\netstat.exe")).toThrow(

/Invalid Windows System32 executable name/u,

);

expect(() => resolveWindowsSystem32Path("netstat")).toThrow(

/Invalid Windows System32 executable name/u,

);

});

it("samples RSS on Windows instead of silently disabling the resource guard", async () => {

const calls: Array<{ command: string; args: string[] }> = [];

const sample = await sampleProcess(1234, {

processId: 5678,

rssMiB: 256,

});

expect(calls[0]?.command).toBe("powershell.exe");

expect(calls[0]?.command).toBe(expectedPowerShellPath());

expect(calls[0]?.args.join(" ")).toContain("$rootPid = 1234");

expect(calls[0]?.args.join(" ")).toContain("ParentProcessId");

});

expect(command).toContain("Sort-Object WorkingSet64 -Descending");

});

it("falls back to the legacy powershell command name on Windows", async () => {

it("does not fall back to a PATH-resolved powershell command on Windows", async () => {

const commands: string[] = [];

const sample = await sampleProcess(1234, {

platform: "win32",

runCommand: async (command: string) => {

commands.push(command);

if (command === "powershell.exe") {

throw new Error("missing powershell.exe");

}

return { stdout: `${96 * 1024 * 1024} 0 1234`, stderr: "" };

throw new Error("trusted powershell unavailable");

},

});

expect(commands).toEqual(["powershell.exe", "powershell"]);

expect(sample?.rssMiB).toBe(96);

expect(sample?.aggregateRssMiB).toBe(96);

expect(commands).toEqual([expectedPowerShellPath()]);

expect(sample).toBeNull();

});

it("does not truncate malformed Windows PowerShell CPU or id samples", async () => {

const sample = await sampleWindowsProcessByPort(19675, {

runCommand: async (command: string, args: string[]) => {

calls.push({ command, args });

if (command === "netstat.exe") {

if (command === expectedWindowsSystem32Path("netstat.exe")) {

return {

stdout: [

" Proto Local Address Foreign Address State PID",

stderr: "",

};

}

if (command === "powershell.exe") {

if (command === expectedPowerShellPath()) {

return { stdout: `${384 * 1024 * 1024} 2.25 6789 ${512 * 1024 * 1024}`, stderr: "" };

}

throw new Error(`unexpected command ${command}`);

rssMiB: 384,

});

expect(calls).toEqual([

{ command: "netstat.exe", args: ["-ano", "-p", "tcp"] },

{ command: expectedWindowsSystem32Path("netstat.exe"), args: ["-ano", "-p", "tcp"] },

{

command: "powershell.exe",

command: expectedPowerShellPath(),

args: expect.arrayContaining(["-Command", expect.stringContaining("$rootPid = 6789")]),

},

]);

const sample = await sampleWindowsProcessByPort(19675, {

runCommand: async (command: string) => {

calls.push(command);

if (command === "netstat.exe") {

if (command === expectedWindowsSystem32Path("netstat.exe")) {

return {

stdout: [

" Proto Local Address Foreign Address State PID",

stderr: "",

};

}

if (command === "powershell.exe" || command === "powershell") {

if (command === expectedPowerShellPath()) {

throw new Error("powershell unavailable");

}

if (command === "tasklist.exe") {

if (command === expectedWindowsSystem32Path("tasklist.exe")) {

return {

stdout: '"node.exe","6789","Console","1","262,144 K"',

stderr: "",

processId: 6789,

rssMiB: 256,

});

expect(calls).toEqual(["netstat.exe", "powershell.exe", "powershell", "tasklist.exe"]);

expect(calls).toEqual([

expectedWindowsSystem32Path("netstat.exe"),

expectedPowerShellPath(),

expectedWindowsSystem32Path("tasklist.exe"),

]);

});

it("falls back to the known Windows pid when tasklist reports malformed pid text", async () => {

const sample = await sampleWindowsProcessByPort(19675, {

runCommand: async (command: string) => {

if (command === "netstat.exe") {

if (command === expectedWindowsSystem32Path("netstat.exe")) {

return {

stdout: [

" Proto Local Address Foreign Address State PID",

stderr: "",

};

}

if (command === "powershell.exe" || command === "powershell") {

if (command === expectedPowerShellPath()) {

throw new Error("powershell unavailable");

}

if (command === "tasklist.exe") {

if (command === expectedWindowsSystem32Path("tasklist.exe")) {

return {

stdout: '"node.exe","9999x","Console","1","262,144 K"',

stderr: "",

it("rejects malformed tasklist RSS instead of stripping digits", async () => {

const sample = await sampleWindowsProcessByPort(19675, {

runCommand: async (command: string) => {

if (command === "netstat.exe") {

if (command === expectedWindowsSystem32Path("netstat.exe")) {

return {

stdout: [

" Proto Local Address Foreign Address State PID",

stderr: "",

};

}

if (command === "powershell.exe" || command === "powershell") {

if (command === expectedPowerShellPath()) {

throw new Error("powershell unavailable");

}

if (command === "tasklist.exe") {

if (command === expectedWindowsSystem32Path("tasklist.exe")) {

return {

stdout: '"node.exe","6789","Console","1","262x144 K"',

stderr: "",