pnpmArgs: step.pnpmArgs,

nodeExecPath: params.nodeExecPath ?? nodeBin,

npmExecPath: params.npmExecPath ?? env.npm_execpath,

comSpec: params.comSpec ?? env.ComSpec,

comSpec: params.comSpec,

platform,

});

return {

import { homedir, tmpdir } from "node:os";

import { delimiter, dirname, extname, isAbsolute, relative, resolve } from "node:path";

import { fileURLToPath } from "node:url";

import { resolvePathEnvKey } from "./windows-cmd-helpers.mjs";

import { resolvePathEnvKey, resolveWindowsCmdExePath } from "./windows-cmd-helpers.mjs";

const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");

const ignoreRepoBinary = process.env.OPENCLAW_CRABBOX_WRAPPER_IGNORE_REPO_BINARY === "1";

const extension = extname(command).toLowerCase();

if (platform === "win32" && (extension === ".cmd" || extension === ".bat")) {

return {

command: env.ComSpec ?? "cmd.exe",

command: resolveWindowsCmdExePath(env),

args: ["/d", "/s", "/c", buildBatchCommandLine(command, commandArgs)],

windowsVerbatimArguments: true,

};

import path from "node:path";

import { pathToFileURL } from "node:url";

import { parseReleaseVersion } from "../../../lib/npm-publish-plan.mjs";

import { buildCmdExeCommandLine } from "../../../windows-cmd-helpers.mjs";

import { buildCmdExeCommandLine, resolveWindowsCmdExePath } from "../../../windows-cmd-helpers.mjs";

const args = process.argv.slice(2);

const command = args.shift();

export function resolveUpgradeSurvivorOpenClawCommand(argv, params = {}) {

const platform = params.platform ?? process.platform;

if (platform === "win32") {

const comSpec = params.comSpec ?? process.env.ComSpec ?? "cmd.exe";

const comSpec = params.comSpec ?? resolveWindowsCmdExePath(params.env ?? process.env);

return {

command: comSpec,

args: ["/d", "/s", "/c", buildCmdExeCommandLine("openclaw.cmd", argv)],

import { fileURLToPath } from "node:url";

import { resolveNpmRunner } from "../../npm-runner.mjs";

import { resolvePnpmRunner } from "../../pnpm-runner.mjs";

import { buildCmdExeCommandLine } from "../../windows-cmd-helpers.mjs";

import { buildCmdExeCommandLine, resolveWindowsCmdExePath } from "../../windows-cmd-helpers.mjs";

import type { CommandResult, RunOptions } from "./types.ts";

export const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../..");

return portableBasename(command) === command && command.toLowerCase() === name;

}

function resolveEnvValue(env: NodeJS.ProcessEnv, name: string): string | undefined {

const key = Object.keys(env).find((candidate) => candidate.toLowerCase() === name.toLowerCase());

return key === undefined ? undefined : env[key];

}

export function resolveHostCommandInvocation(

command: string,

args: string[],

options: ResolveHostCommandOptions = {},

): HostCommandInvocation {

const env = options.env ?? process.env;

const platform = options.platform ?? process.platform;

const comSpec = options.comSpec ?? resolveEnvValue(env, "ComSpec") ?? "cmd.exe";

const comSpec = options.comSpec ?? resolveWindowsCmdExePath(env);

if (isBareCommand(command, "pnpm")) {

const runner = resolvePnpmRunner({

const env = options.env ?? process.env;

const targets = options.targets ?? ["chromium"];

return resolvePnpmRunner({

comSpec: options.comSpec ?? env.ComSpec ?? env.COMSPEC,

comSpec: options.comSpec,

env,

npmExecPath: env === process.env ? env.npm_execpath : (env.npm_execpath ?? ""),

platform: options.platform,

import path from "node:path";

import { pathToFileURL } from "node:url";

import { repairMintlifyAccordionIndentation } from "./lib/mintlify-accordion.mjs";

import { buildCmdExeCommandLine } from "./windows-cmd-helpers.mjs";

import { buildCmdExeCommandLine, resolveWindowsCmdExePath } from "./windows-cmd-helpers.mjs";

const ROOT = path.resolve(import.meta.dirname, "..");

const CHECK = process.argv.includes("--check");

if (existsSync(shimPath)) {

if (platform === "win32") {

const comSpec = params.comSpec ?? process.env.ComSpec ?? "cmd.exe";

const comSpec = params.comSpec ?? resolveWindowsCmdExePath(params.env ?? process.env);

return {

command: comSpec,

args: ["/d", "/s", "/c", buildCmdExeCommandLine(shimPath, args)],

platform?: NodeJS.Platform;

};

function resolveEnvValue(env: NodeJS.ProcessEnv, name: string): string | undefined {

const key = Object.keys(env).find((candidate) => candidate.toLowerCase() === name.toLowerCase());

return key === undefined ? undefined : env[key];

}

export function resolveCodexProtocolPnpmCommand(

args: string[],

options: ResolvePnpmCommandOptions = {},

): PnpmCommand {

const env = options.env ?? process.env;

const command = resolvePnpmRunner({

comSpec: options.comSpec ?? resolveEnvValue(env, "ComSpec"),

comSpec: options.comSpec,

env,

npmExecPath: options.npmExecPath ?? env.npm_execpath,

nodeExecPath: options.execPath ?? process.execPath,

// Runs child commands with process-group signal forwarding and Windows shell normalization.

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

import { constants as osConstants } from "node:os";

import { buildCmdExeCommandLine } from "../windows-cmd-helpers.mjs";

import { buildCmdExeCommandLine, resolveWindowsCmdExePath } from "../windows-cmd-helpers.mjs";

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

const FORWARDED_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];

if (platform === "win32" && shell && args.length > 0) {

return {

args: ["/d", "/s", "/c", buildCmdExeCommandLine(bin, args)],

command: comSpec ?? env?.ComSpec ?? env?.COMSPEC ?? process.env.ComSpec ?? "cmd.exe",

command: comSpec ?? resolveWindowsCmdExePath(env ?? process.env),

shell: false,

windowsVerbatimArguments: true,

};

// Resolves the Windows taskkill binary without trusting PATH.

import path from "node:path";

// Resolves Windows system binaries without trusting PATH.

import {

resolveWindowsPowerShellPath,

resolveWindowsSystem32Path,

} from "../windows-cmd-helpers.mjs";

const DEFAULT_WINDOWS_SYSTEM_ROOT = "C:\\Windows";

function getEnvValueCaseInsensitive(env, expectedKey) {

const direct = env[expectedKey];

if (direct !== undefined) {

return direct;

}

const expected = expectedKey.toUpperCase();

const actualKey = Object.keys(env).find((key) => key.toUpperCase() === expected);

return actualKey ? env[actualKey] : undefined;

}

function normalizeWindowsSystemRoot(raw) {

const trimmed = raw?.trim();

if (

!trimmed ||

trimmed.includes("\0") ||

trimmed.includes("\r") ||

trimmed.includes("\n") ||

trimmed.includes(";")

) {

return null;

}

const normalized = path.win32.normalize(trimmed);

if (!path.win32.isAbsolute(normalized) || normalized.startsWith("\\\\")) {

return null;

}

const parsed = path.win32.parse(normalized);

if (!/^[A-Za-z]:\\$/.test(parsed.root) || normalized.length <= parsed.root.length) {

return null;

}

return normalized.replace(/[\\/]+$/, "");

}

export { resolveWindowsPowerShellPath, resolveWindowsSystem32Path };

export function resolveWindowsTaskkillPath(env = process.env) {

return resolveWindowsSystem32Path("taskkill.exe", env);

}

function resolveWindowsSystemRoot(env) {

return (

normalizeWindowsSystemRoot(getEnvValueCaseInsensitive(env, "SystemRoot")) ??

normalizeWindowsSystemRoot(getEnvValueCaseInsensitive(env, "WINDIR")) ??

DEFAULT_WINDOWS_SYSTEM_ROOT

);

}

export function resolveWindowsSystem32Path(executableName, env = process.env) {

if (

path.win32.basename(executableName) !== executableName ||

!/^[A-Za-z0-9_.-]+\.exe$/u.test(executableName)

) {

throw new Error(`Invalid Windows System32 executable name: ${executableName}`);

}

const systemRoot = resolveWindowsSystemRoot(env);

return path.win32.join(systemRoot, "System32", executableName);

}

export function resolveWindowsPowerShellPath(env = process.env) {

const systemRoot = resolveWindowsSystemRoot(env);

return path.win32.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");

}

// Resolves npm commands from the active Node toolchain, especially on Windows.

import fs from "node:fs";

import path from "node:path";

import { buildCmdExeCommandLine, resolvePathEnvKey } from "./windows-cmd-helpers.mjs";

import {

buildCmdExeCommandLine,

resolvePathEnvKey,

resolveWindowsCmdExePath,

} from "./windows-cmd-helpers.mjs";

function resolveToolchainNpmRunner(params) {

const npmCliCandidates = [

const existsSync = params.existsSync ?? fs.existsSync;

const env = params.env ?? process.env;

const platform = params.platform ?? process.platform;

const comSpec = params.comSpec ?? env.ComSpec ?? "cmd.exe";

const comSpec = params.comSpec ?? (platform === "win32" ? resolveWindowsCmdExePath(env) : "");

const pathImpl = platform === "win32" ? path.win32 : path.posix;

const nodeDir = pathImpl.dirname(execPath);

const npmToolchain = resolveToolchainNpmRunner({