decodeWindowsOutputBuffer,

resolveWindowsConsoleEncoding,

} from "../infra/windows-encoding.js";

import { getWindowsInstallRoots } from "../infra/windows-install-roots.js";

import { logDebug, logError } from "../logger.js";

import { killProcessTree as terminateProcessTree } from "./kill-tree.js";

import { resolveCommandStdio } from "./spawn-utils.js";

import { resolveWindowsCommandShim } from "./windows-command.js";

import {

buildWindowsCmdExeCommandLine,

isWindowsBatchCommand,

resolveTrustedWindowsCmdExe,

resolveWindowsCommandShim,

} from "./windows-command.js";

const execFileAsync = promisify(execFile);

const WINDOWS_UNSAFE_CMD_CHARS_RE = /[&|<>^%\r\n]/;

function isWindowsBatchCommand(resolvedCommand: string): boolean {

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

return false;

}

const ext = normalizeLowercaseStringOrEmpty(path.extname(resolvedCommand));

return ext === ".cmd" || ext === ".bat";

}

function escapeForCmdExe(arg: string): string {

// Reject cmd metacharacters to avoid injection when we must pass a single command line.

if (WINDOWS_UNSAFE_CMD_CHARS_RE.test(arg)) {

throw new Error(

`Unsafe Windows cmd.exe argument detected: ${JSON.stringify(arg)}. ` +

"Pass an explicit shell-wrapper argv at the call site instead.",

);

}

// Quote when needed; double inner quotes for cmd parsing.

if (!arg.includes(" ") && !arg.includes('"')) {

return arg;

}

return `"${arg.replace(/"/g, '""')}"`;

}

function buildCmdExeCommandLine(resolvedCommand: string, args: string[]): string {

return [escapeForCmdExe(resolvedCommand), ...args.map(escapeForCmdExe)].join(" ");

}

function resolveTrustedWindowsCmdExe(): string {

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

return "cmd.exe";

}

return path.win32.join(getWindowsInstallRoots().systemRoot, "System32", "cmd.exe");

}

function assignChildEnvValue(params: {

env: NodeJS.ProcessEnv;

key: string;

return {

command: useCmdWrapper ? resolveTrustedWindowsCmdExe() : resolvedCommand,

args: useCmdWrapper

? ["/d", "/s", "/c", buildCmdExeCommandLine(resolvedCommand, finalArgv.slice(1))]

? ["/d", "/s", "/c", buildWindowsCmdExeCommandLine(resolvedCommand, finalArgv.slice(1))]

: finalArgv.slice(1),

usesWindowsExitCodeShim:

process.platform === "win32" && (useCmdWrapper || finalArgv !== params.argv),

} else {

killIssuedByAbort = true;

}

if (

killProcessTree &&

typeof child.pid === "number" &&

child.pid > 0

) {

if (killProcessTree && typeof child.pid === "number" && child.pid > 0) {

if (process.platform === "win32") {

try {

spawn("taskkill", ["/PID", String(child.pid), "/T"], {

});

});

it("escapes caret arguments in Windows command wrappers", async () => {

spawnMock.mockImplementation(

(_command: string, _args: string[], _options: Record<string, unknown>) => createMockChild(),

);

await withMockedWindowsPlatform(async () => {

const result = await runCommandWithTimeout(

["pnpm", "exec", "vitest", "-t", "@scope/pkg@^1.2.3"],

{ timeoutMs: 1000 },

);

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

const captured = requireSpawnCall(0);

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

expect(captured[1][3]).toBe("pnpm.cmd exec vitest -t @scope/pkg@^^1.2.3");

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

});

});

it("keeps child exitCode when close reports null on Windows npm shims", async () => {

const child = createMockChild({ closeCode: null, exitCode: 0 });

});

});

it("wraps spaced .cmd command paths in an outer cmd.exe command line", async () => {

const expectedComSpec = expectedTrustedCmdExe();

execFileMock.mockImplementation(

(

_command: string,

_args: string[],

_options: Record<string, unknown>,

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

) => {

cb(null, "ok", "");

},

);

await withMockedWindowsPlatform(async () => {

await runExec("C:\\Program Files\\pnpm\\pnpm.cmd", ["--version"], 1000);

const captured = requireExecFileCall(0);

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

expect(captured[1]).toEqual([

"/d",

"/s",

"/c",

'""C:\\Program Files\\pnpm\\pnpm.cmd" --version"',

]);

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

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

});

});

it("sets windowsHide on direct runExec invocations too", async () => {

execFileMock.mockImplementation(

(

// Child adapter tests cover adapting child processes to supervisor runs.

import type { ChildProcess } from "node:child_process";

import { EventEmitter } from "node:events";

import path from "node:path";

import { PassThrough } from "node:stream";

import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";

import {

getWindowsInstallRoots,

resetWindowsInstallRootsForTests,

} from "../../../infra/windows-install-roots.js";

import {

expectRealExitWinsOverSigkillFallback,

expectWaitStaysPendingUntilSigkillFallback,

detached?: boolean;

env?: NodeJS.ProcessEnv | Record<string, string>;

stdio?: string[];

windowsHide?: boolean;

windowsVerbatimArguments?: boolean;

};

fallbacks?: Array<{ options?: { detached?: boolean } }>;

};

return call[0];

}

function expectedTrustedCmdExe(): string {

return path.win32.join(getWindowsInstallRoots().systemRoot, "System32", "cmd.exe");

}

describe("createChildAdapter", () => {

const originalServiceMarker = process.env.OPENCLAW_SERVICE_MARKER;

const originalPlatformDescriptor = Object.getOwnPropertyDescriptor(process, "platform");

});

beforeEach(() => {

resetWindowsInstallRootsForTests({ queryRegistryValue: () => null });

spawnWithFallbackMock.mockClear();

signalProcessTreeMock.mockClear();

createWindowsOutputDecoderMock.mockClear();

expect(spawnArgs.options?.env).toBeUndefined();

});

it("wraps Windows command shims through trusted cmd.exe", async () => {

setPlatform("win32");

await createAdapterHarness({

pid: 3335,

argv: ["pnpm", "--version"],

});

const spawnArgs = firstSpawnWithFallbackParams();

expect(spawnArgs.argv).toEqual([

expectedTrustedCmdExe(),

"/d",

"/s",

"/c",

"pnpm.cmd --version",

]);

expect(spawnArgs.options?.detached).toBe(false);

expect(spawnArgs.options?.windowsHide).toBe(true);

expect(spawnArgs.options?.windowsVerbatimArguments).toBe(true);

expect(spawnArgs.fallbacks).toStrictEqual([]);

});

it("wraps Linux child spawns and strips shell-init env", async () => {

const originalBashEnv = process.env.BASH_ENV;

const originalEnv = process.env.ENV;

import { signalProcessTree } from "../../kill-tree.js";

import { prepareOomScoreAdjustedSpawn } from "../../linux-oom-score.js";

import { spawnWithFallback } from "../../spawn-utils.js";

import { resolveWindowsCommandShim } from "../../windows-command.js";

import {

buildWindowsCmdExeCommandLine,

isWindowsBatchCommand,

resolveTrustedWindowsCmdExe,

resolveWindowsCommandShim,

} from "../../windows-command.js";

import type { ManagedRunStdin, SpawnProcessAdapter } from "../types.js";

import { toStringEnv } from "./env.js";

});

}

function resolveChildInvocation(params: { argv: string[]; windowsVerbatimArguments?: boolean }): {

args: string[];

command: string;

windowsVerbatimArguments?: boolean;

} {

const resolvedCommand = resolveCommand(params.argv[0] ?? "");

const args = params.argv.slice(1);

if (!isWindowsBatchCommand(resolvedCommand)) {

return {

command: resolvedCommand,

args,

windowsVerbatimArguments: params.windowsVerbatimArguments,

};

}

return {

command: resolveTrustedWindowsCmdExe(),

args: ["/d", "/s", "/c", buildWindowsCmdExeCommandLine(resolvedCommand, args)],

windowsVerbatimArguments: true,

};

}

export type ChildAdapter = SpawnProcessAdapter<NodeJS.Signals | null>;

function isServiceManagedRuntime(): boolean {

input?: string;

stdinMode?: "inherit" | "pipe-open" | "pipe-closed";

}): Promise<ChildAdapter> {

const resolvedArgv = [...params.argv];

resolvedArgv[0] = resolveCommand(resolvedArgv[0] ?? "");

const invocation = resolveChildInvocation({

argv: params.argv,

windowsVerbatimArguments: params.windowsVerbatimArguments,

});

const baseEnv = params.env ? toStringEnv(params.env) : undefined;

const preparedSpawn = prepareOomScoreAdjustedSpawn(resolvedArgv[0] ?? "", resolvedArgv.slice(1), {

const preparedSpawn = prepareOomScoreAdjustedSpawn(invocation.command, invocation.args, {

env: baseEnv,

});

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

detached: useDetached,

windowsHide: true,

windowsVerbatimArguments: params.windowsVerbatimArguments,

windowsVerbatimArguments: invocation.windowsVerbatimArguments,

};

if (stdinMode === "inherit") {

options.stdio = ["inherit", "pipe", "pipe"];

import path from "node:path";

import process from "node:process";

import { normalizeLowercaseStringOrEmpty } from "@openclaw/normalization-core/string-coerce";

import { getWindowsInstallRoots } from "../infra/windows-install-roots.js";

const WINDOWS_UNSAFE_CMD_CHARS_RE = /[&|<>%\r\n]/;

export function isWindowsBatchCommand(

resolvedCommand: string,

platform: NodeJS.Platform = process.platform,

): boolean {

if (platform !== "win32") {

return false;

}

const ext = normalizeLowercaseStringOrEmpty(path.extname(resolvedCommand));

return ext === ".cmd" || ext === ".bat";

}

function escapeForWindowsCmdExe(arg: string): string {

if (WINDOWS_UNSAFE_CMD_CHARS_RE.test(arg)) {

throw new Error(

`Unsafe Windows cmd.exe argument detected: ${JSON.stringify(arg)}. ` +

"Pass an explicit shell-wrapper argv at the call site instead.",

);

}

const escaped = arg.replace(/\^/g, "^^");

if (!escaped.includes(" ") && !escaped.includes('"')) {

return escaped;

}

return `"${escaped.replace(/"/g, '""')}"`;

}

export function buildWindowsCmdExeCommandLine(command: string, args: readonly string[]): string {

const escapedCommand = escapeForWindowsCmdExe(command);

const commandLine = [escapedCommand, ...args.map(escapeForWindowsCmdExe)].join(" ");

return escapedCommand.startsWith('"') ? `"${commandLine}"` : commandLine;

}

export function resolveTrustedWindowsCmdExe(platform: NodeJS.Platform = process.platform): string {

if (platform !== "win32") {

return "cmd.exe";

}

return path.win32.join(getWindowsInstallRoots().systemRoot, "System32", "cmd.exe");

}

/**

* Resolve package-manager commands that Windows exposes through .cmd shims.