killed?: boolean;

};

function spawnCallAt(callIndex: number): unknown[] {

type SpawnCall = [string, string[], Record<string, unknown>];

function requireSpawnCall(callIndex: number): SpawnCall {

const call = spawnMock.mock.calls[callIndex];

if (!call) {

throw new Error(`expected spawn call ${callIndex}`);

}

return call;

return call as SpawnCall;

}

function createMockChild(params?: {

return child;

}

type SpawnCall = [string, string[], Record<string, unknown>];

type ExecCall = [

string,

string[],

Record<string, unknown>,

(err: Error | null, stdout: string, stderr: string) => void,

];

function requireExecFileCall(callIndex: number): ExecCall {

const call = execFileMock.mock.calls[callIndex];

if (!call) {

throw new Error(`expected execFile call ${callIndex}`);

}

return call as ExecCall;

}

function expectCmdWrappedInvocation(params: {

captured: SpawnCall | ExecCall | undefined;

captured: SpawnCall | ExecCall;

expectedComSpec: string;

}) {

if (!params.captured) {

throw new Error("expected command wrapper to be called");

}

expect(params.captured[0]).toBe(params.expectedComSpec);

expect(params.captured[1].slice(0, 3)).toEqual(["/d", "/s", "/c"]);

expect(params.captured[1][3]).toContain("pnpm.cmd --version");

try {

const result = await runCommandWithTimeout(["pnpm", "--version"], { timeoutMs: 1000 });

expect(result.code).toBe(0);

const captured = spawnMock.mock.calls[0] as SpawnCall | undefined;

const captured = requireSpawnCall(0);

expectCmdWrappedInvocation({ captured, expectedComSpec });

} finally {

platformSpy.mockRestore();

try {

const result = await runCommandWithTimeout(["pnpm", "--version"], { timeoutMs: 1000 });

expect(result.code).toBe(0);

const captured = spawnMock.mock.calls[0] as SpawnCall | undefined;

const captured = requireSpawnCall(0);

expectCmdWrappedInvocation({

captured,

expectedComSpec: path.win32.join("C:\\Windows", "System32", "cmd.exe"),

const result = await runCommandWithTimeout(["pnpm", "--version"], { timeoutMs: 1000 });

expect(result.code).toBe(0);

const captured = spawnMock.mock.calls[0] as SpawnCall | undefined;

const captured = requireSpawnCall(0);

expectCmdWrappedInvocation({

captured,

expectedComSpec: path.win32.join("C:\\Windows", "System32", "cmd.exe"),

try {

const result = await runCommandWithTimeout(["corepack", "--version"], { timeoutMs: 1000 });

expect(result.code).toBe(0);

const captured = spawnMock.mock.calls[0] as SpawnCall | undefined;

if (!captured) {

throw new Error("expected corepack shim spawn");

}

const captured = requireSpawnCall(0);

expect(captured[0]).toBe(expectedComSpec);

expect(captured[1].slice(0, 3)).toEqual(["/d", "/s", "/c"]);

expect(captured[1][3]).toContain("corepack.cmd --version");

try {

const result = await runCommandWithTimeout(["npm", "--version"], { timeoutMs: 1000 });

expect(result.code).toBe(0);

const captured = spawnMock.mock.calls[0] as SpawnCall | undefined;

if (!captured) {

throw new Error("expected npm shim spawn");

}

const captured = requireSpawnCall(0);

expect(captured[0]).toBe(process.execPath);

expect(captured[1][0]).toBe(

path.join(path.dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js"),

try {

const result = await runCommandWithTimeout(["npm", "--version"], { timeoutMs: 1000 });

expect(result.code).toBe(0);

const captured = spawnMock.mock.calls[0] as SpawnCall | undefined;

if (!captured) {

throw new Error("expected npm.cmd fallback spawn");

}

const captured = requireSpawnCall(0);

expect(captured[0]).toBe(expectedComSpec);

expect(captured[1].slice(0, 3)).toEqual(["/d", "/s", "/c"]);

expect(captured[1][3]).toContain("npm.cmd --version");

try {

await runExec("pnpm", ["--version"], 1000);

const captured = execFileMock.mock.calls[0] as ExecCall | undefined;

const captured = requireExecFileCall(0);

expectCmdWrappedInvocation({ captured, expectedComSpec });

} finally {

platformSpy.mockRestore();

try {

await runExec("node", ["--version"], 1000);

const captured = execFileMock.mock.calls[0] as ExecCall | undefined;

if (!captured) {

throw new Error("expected direct execFile invocation");

}

const captured = requireExecFileCall(0);

expect(captured[0]).toBe("node");

expect(captured[1]).toEqual(["--version"]);

expect(captured[2].windowsHide).toBe(true);

try {

const result = await runCommandWithTimeout(["node", "--version"], { timeoutMs: 1000 });

expect(result.code).toBe(0);

const captured = spawnMock.mock.calls[0] as SpawnCall | undefined;

if (!captured) {

throw new Error("expected direct spawn invocation");

}

const captured = requireSpawnCall(0);

expect(captured[0]).toBe("node");

expect(captured[1]).toEqual(["--version"]);

expect(captured[2].windowsHide).toBe(true);

await vi.advanceTimersByTimeAsync(81);

expect(child.kill).not.toHaveBeenCalled();

expect(spawnMock).toHaveBeenCalledTimes(2);

const taskkillCall = spawnCallAt(1);

const taskkillCall = requireSpawnCall(1);

expect(taskkillCall[0]).toBe("taskkill");

expect(taskkillCall[1]).toEqual(["/PID", "1234", "/T", "/F"]);

expect(taskkillCall[2]).toEqual({

const result = await runExec("node", ["gbk-output.js"], 1000);

expect(result.stdout).toBe("测试");

expect(result.stderr).toBe("；");

const captured = execFileMock.mock.calls[0] as ExecCall | undefined;

expect(captured?.[2].encoding).toBe("buffer");

const captured = requireExecFileCall(0);

expect(captured[2].encoding).toBe("buffer");

} finally {

platformSpy.mockRestore();

}