import os from "node:os";

import path from "node:path";

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

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

import { prepareRestartScript, runRestartScript } from "./restart-helper.js";

vi.mock("node:child_process", async () => {

await runRestartScript(scriptPath);

expect(spawn).toHaveBeenCalledWith("cmd.exe", ["/d", "/s", "/c", scriptPath], {

expect(spawn).toHaveBeenCalledWith(getWindowsCmdExePath(), ["/d", "/s", "/c", scriptPath], {

detached: true,

stdio: "ignore",

windowsHide: true,

await runRestartScript(scriptPath);

expect(spawn).toHaveBeenCalledWith("cmd.exe", ["/d", "/s", "/c", `"${scriptPath}"`], {

detached: true,

stdio: "ignore",

windowsHide: true,

});

expect(spawn).toHaveBeenCalledWith(

getWindowsCmdExePath(),

["/d", "/s", "/c", `"${scriptPath}"`],

{

detached: true,

stdio: "ignore",

windowsHide: true,

},

);

});

it("does not throw when spawn fails synchronously", async () => {

resolveGatewayRestartLogPath,

shellEscapeRestartLogValue,

} from "../../daemon/restart-logs.js";

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

/**

* Shell-escape a string for embedding in single-quoted shell arguments.

*/

export async function runRestartScript(scriptPath: string): Promise<void> {

const isWindows = process.platform === "win32";

const file = isWindows ? "cmd.exe" : "/bin/sh";

const file = isWindows ? getWindowsCmdExePath() : "/bin/sh";

const args = isWindows ? ["/d", "/s", "/c", quoteCmdScriptArg(scriptPath)] : [scriptPath];

try {

import { formatPortDiagnostics, inspectPortUsage } from "../infra/ports.js";

import { cleanStaleGatewayProcessesSync } from "../infra/restart-stale-pids.js";

import { parseTcpPort } from "../infra/tcp-port.js";

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

import {

GATEWAY_LAUNCH_AGENT_LABEL,

GATEWAY_SERVICE_KIND,

args: string[],

): Promise<{ stdout: string; stderr: string; code: number }> {

const isWindows = process.platform === "win32";

const file = isWindows ? (process.env.ComSpec ?? "cmd.exe") : "launchctl";

const file = isWindows ? getWindowsCmdExePath() : "launchctl";

const fileArgs = isWindows ? ["/d", "/s", "/c", "launchctl", ...args] : args;

return await execFileUtf8(file, fileArgs, isWindows ? { windowsHide: true } : {});

}

import path from "node:path";

import { PassThrough } from "node:stream";

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

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

import "./test-helpers/schtasks-base-mocks.js";

import {

inspectPortUsage,

const startupEntryPath = resolveStartupEntryPath(env);

const startupScript = await fs.readFile(startupEntryPath, "utf8");

expect(result.scriptPath).toBe(resolveTaskScriptPath(env));

expect(startupScript).toContain('start "" /min cmd.exe /d /c');

expect(startupScript).toContain(`start "" /min ${getWindowsCmdExePath()} /d /c`);

expect(startupScript).toContain("gateway.cmd");

expectStartupFallbackSpawn();

expect(childUnref).toHaveBeenCalled();

import { findVerifiedGatewayListenerPidsOnPortSync } from "../infra/gateway-processes.js";

import { inspectPortUsage } from "../infra/ports.js";

import { parseTcpPort } from "../infra/tcp-port.js";

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

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

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

import { sleep } from "../utils.js";

import { parseCmdScriptCommandLine, quoteCmdScriptArg } from "./cmd-argv.js";

}

function renderStartupLaunchCommand(scriptPath: string): string {

return `start "" /min cmd.exe /d /c ${quoteCmdScriptArg(scriptPath)}`;

const cmdExePath = quoteCmdScriptArg(getWindowsCmdExePath());

return `start "" /min ${cmdExePath} /d /c ${quoteCmdScriptArg(scriptPath)}`;

}

function buildStartupLauncherScript(params: { description?: string; scriptPath: string }): string {

return;

}

const child = spawn("cmd.exe", ["/d", "/c", scriptPath], {

const child = spawn(getWindowsCmdExePath(), ["/d", "/c", scriptPath], {

detached: true,

stdio: "ignore",

windowsHide: true,

// Detects and decodes Windows console output encodings.

import { spawnSync } from "node:child_process";

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

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

const WINDOWS_CODEPAGE_ENCODING_MAP: Record<number, string> = {

65001: "utf-8",

return cachedWindowsConsoleEncoding;

}

try {

const result = spawnSync("cmd.exe", ["/d", "/s", "/c", "chcp"], {

const result = spawnSync(getWindowsCmdExePath(), ["/d", "/s", "/c", "chcp"], {

windowsHide: true,

encoding: "utf8",

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

import {

privateTestApi,

resetWindowsInstallRootsForTests,

getWindowsCmdExePath,

getWindowsInstallRoots,

getWindowsProgramFilesRoots,

normalizeWindowsInstallRoot,

});

});

describe("getWindowsCmdExePath", () => {

it("resolves cmd.exe from the trusted Windows system root", () => {

expect(getWindowsCmdExePath({ SystemRoot: "D:\\Windows" })).toBe(

"D:\\Windows\\System32\\cmd.exe",

);

});

});

describe("locateWindowsRegExe", () => {

it("uses the fixed Windows system reg.exe candidate", () => {

expect(privateTestApi.getWindowsRegExeCandidates()).toEqual(["C:\\Windows\\System32\\reg.exe"]);

return result;

}

export function getWindowsCmdExePath(

env: Record<string, string | undefined> = process.env,

): string {

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

}

export function resetWindowsInstallRootsForTests(

overrides: WindowsInstallRootsTestOverrides = {},

): void {

import path from "node:path";

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

import { captureFullEnv } from "../test-utils/env.js";

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

const spawnMock = vi.hoisted(() => vi.fn());

const resolvePreferredOpenClawTmpDirMock = vi.hoisted(() => vi.fn(() => os.tmpdir()));

});

const result = relaunchGatewayScheduledTask({ OPENCLAW_PROFILE: "work" });

const cmdExePath = getWindowsCmdExePath();

expect(result.ok).toBe(true);

expect(result.method).toBe("schtasks");

expect(result.tried).toContain('schtasks /Run /TN "OpenClaw Gateway (work)"');

expect(result.tried).toContain(`cmd.exe /d /s /c ${seenCommandArg}`);

expect(result.tried).toContain(`${cmdExePath} /d /s /c ${seenCommandArg}`);

const spawnCall = requireFirstMockCall(spawnMock, "restart helper spawn");

expect(spawnCall[0]).toBe("cmd.exe");

expect(spawnCall[0]).toBe(cmdExePath);

expect(spawnCall[1]).toStrictEqual(["/d", "/s", "/c", seenCommandArg]);

expect(spawnCall[2]).toStrictEqual({

detached: true,

if (typeof commandArg !== "string") {

throw new Error("expected quoted restart helper path");

}

expect(spawnCall[0]).toBe("cmd.exe");

expect(spawnCall[0]).toBe(getWindowsCmdExePath());

expect(commandArgs).toStrictEqual(["/d", "/s", "/c", commandArg]);

expect(commandArg.startsWith('"')).toBe(true);

expect(commandArg.endsWith('"')).toBe(true);

const script = fs.readFileSync(scriptPath, "utf8");

expect(script).toContain(`schtasks /Query /TN`);

expect(script).toContain(":fallback");

expect(script).toContain(`start "" /min cmd.exe /d /c`);

expect(script).toContain(`start "" /min ${getWindowsCmdExePath()} /d /c`);

expect(script).toContain(taskScriptPath);

});

});

import { formatErrorMessage } from "./errors.js";

import type { RestartAttempt } from "./restart.types.js";

import { resolvePreferredOpenClawTmpDir } from "./tmp-openclaw-dir.js";

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

const TASK_RESTART_RETRY_LIMIT = 12;

const TASK_RESTART_RETRY_DELAY_SEC = 1;

];

if (taskScriptPath) {

const quotedScript = quoteCmdScriptArg(taskScriptPath);

lines.push(`if exist ${quotedScript} (`, ` start "" /min cmd.exe /d /c ${quotedScript}`, ")");

const quotedCmd = quoteCmdScriptArg(getWindowsCmdExePath());

lines.push(

`if exist ${quotedScript} (`,

` start "" /min ${quotedCmd} /d /c ${quotedScript}`,

")",

);

}

lines.push(

":cleanup",

})}\r\n`,

"utf8",

);

const child = spawn("cmd.exe", ["/d", "/s", "/c", quotedScriptPath], {

const cmdExePath = getWindowsCmdExePath();

const child = spawn(cmdExePath, ["/d", "/s", "/c", quotedScriptPath], {

detached: true,

stdio: "ignore",

windowsHide: true,

return {

ok: true,

method: "schtasks",

tried: [`schtasks /Run /TN "${taskName}"`, `cmd.exe /d /s /c ${quotedScriptPath}`],

tried: [`schtasks /Run /TN "${taskName}"`, `${cmdExePath} /d /s /c ${quotedScriptPath}`],

};

} catch (err) {

try {