return value.replace(/[<>:"/\\|?*]/g, "_").replace(/\p{Cc}/gu, "_");

}

function resolveStartupEntryPath(env: GatewayServiceEnv): string {

function resolveStartupEntryPath(env: GatewayServiceEnv, extension?: "cmd" | "vbs"): string {

const taskName = resolveTaskName(env);

return path.join(resolveWindowsStartupDir(env), `${sanitizeWindowsFilename(taskName)}.cmd`);

const entryExtension = extension ?? (shouldUseHiddenWindowsTaskLauncher(env) ? "vbs" : "cmd");

return path.join(

resolveWindowsStartupDir(env),

`${sanitizeWindowsFilename(taskName)}.${entryExtension}`,

);

}

function resolveStartupEntryPaths(env: GatewayServiceEnv): string[] {

const primaryPath = resolveStartupEntryPath(env);

const legacyCmdPath = resolveStartupEntryPath(env, "cmd");

return Array.from(new Set([primaryPath, legacyCmdPath]));

}

// `/TR` is parsed by schtasks itself, while the generated `gateway.cmd` line is parsed by cmd.exe.

return username;

}

function shouldUseHiddenWindowsTaskLauncher(env: GatewayServiceEnv): boolean {

const value = normalizeLowercaseStringOrEmpty(env.OPENCLAW_WINDOWS_TASK_HIDDEN_LAUNCHER);

return value === "1" || value === "true" || value === "yes";

}

function resolveTaskLauncherScriptPath(env: GatewayServiceEnv, scriptPath: string): string {

if (!shouldUseHiddenWindowsTaskLauncher(env)) {

return scriptPath;

}

const parsed = path.parse(scriptPath);

return path.join(parsed.dir, `${parsed.name}.vbs`);

}

export async function readScheduledTaskCommand(

env: GatewayServiceEnv,

): Promise<GatewayServiceCommandConfig | null> {

return `${lines.join("\r\n")}\r\n`;

}

function quoteVbsString(value: string): string {

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

}

function quoteVbsRunCommand(scriptPath: string): string {

return quoteVbsString(`"${scriptPath}"`);

}

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

const lines = [];

const trimmedDescription = params.description?.trim();

if (trimmedDescription) {

assertNoCmdLineBreak(trimmedDescription, "Hidden launcher description");

lines.push(`' ${trimmedDescription}`);

}

lines.push(

`CreateObject("WScript.Shell").Run ${quoteVbsRunCommand(params.scriptPath)}, 0, False`,

);

return `${lines.join("\r\n")}\r\n`;

}

async function assertSchtasksAvailable() {

const res = await execSchtasks(["/Query"]);

if (res.code === 0) {

}

async function isStartupEntryInstalled(env: GatewayServiceEnv): Promise<boolean> {

try {

await fs.access(resolveStartupEntryPath(env));

return true;

} catch {

return false;

for (const startupEntryPath of resolveStartupEntryPaths(env)) {

try {

await fs.access(startupEntryPath);

return true;

} catch {}

}

return false;

}

async function isRegisteredScheduledTask(env: GatewayServiceEnv): Promise<boolean> {

description,

}: Omit<GatewayServiceInstallArgs, "stdout">): Promise<{

scriptPath: string;

taskLaunchPath: string;

taskDescription: string;

}> {

await assertSchtasksAvailable().catch(() => undefined);

const scriptPath = resolveTaskScriptPath(env);

const taskLaunchPath = resolveTaskLauncherScriptPath(env, scriptPath);

await fs.mkdir(path.dirname(scriptPath), { recursive: true });

const taskDescription = resolveGatewayServiceDescription({ env, environment, description });

const script = buildTaskScript({

environment,

});

await fs.writeFile(scriptPath, script, "utf8");

return { scriptPath, taskDescription };

if (taskLaunchPath !== scriptPath) {

const launcher = buildHiddenLauncherScript({

description: taskDescription,

scriptPath,

});

await fs.writeFile(taskLaunchPath, launcher, "utf8");

}

return { scriptPath, taskLaunchPath, taskDescription };

}

export async function stageScheduledTask({

env: GatewayServiceEnv;

stdout: NodeJS.WritableStream;

taskName: string;

quotedScript: string;

quotedLaunchPath: string;

scriptPath: string;

}): Promise<boolean> {

if (!(await isRegisteredScheduledTask(params.env))) {

"/TN",

params.taskName,

"/TR",

params.quotedScript,

params.quotedLaunchPath,

]);

if (change.code !== 0) {

return false;

env: GatewayServiceEnv;

stdout: NodeJS.WritableStream;

scriptPath: string;

taskLaunchPath: string;

description?: string;

}) {

const taskDescription = params.description ?? "OpenClaw Gateway";

const taskName = resolveTaskName(params.env);

const quotedScript = quoteSchtasksArg(params.scriptPath);

const quotedLaunchPath = quoteSchtasksArg(params.taskLaunchPath);

if (await updateExistingScheduledTask({ ...params, taskName, quotedScript })) {

if (await updateExistingScheduledTask({ ...params, taskName, quotedLaunchPath })) {

return;

}

"/TN",

taskName,

"/TR",

quotedScript,

quotedLaunchPath,

];

const taskUser = resolveTaskUser(params.env);

const taskUserArgs = taskUser ? ["/RU", taskUser, "/NP", "/IT"] : [];

let create = await execSchtasks(

taskUser ? [...baseArgs, "/RU", taskUser, "/NP", "/IT"] : baseArgs,

taskUserArgs.length > 0 ? [...baseArgs, ...taskUserArgs] : baseArgs,

);

if (create.code !== 0 && taskUser) {

create = await execSchtasks(baseArgs);

if (shouldFallbackToStartupEntry({ code: create.code, detail })) {

const startupEntryPath = resolveStartupEntryPath(params.env);

await fs.mkdir(path.dirname(startupEntryPath), { recursive: true });

const launcher = buildStartupLauncherScript({

description: taskDescription,

scriptPath: params.scriptPath,

});

const launcher = shouldUseHiddenWindowsTaskLauncher(params.env)

? buildHiddenLauncherScript({

description: taskDescription,

scriptPath: params.scriptPath,

})

: buildStartupLauncherScript({

description: taskDescription,

scriptPath: params.scriptPath,

});

await fs.writeFile(startupEntryPath, launcher, "utf8");

await launchFallbackTaskScript(params.env);

writeFormattedLines(

env: args.env,

stdout: args.stdout,

scriptPath: staged.scriptPath,

taskLaunchPath: staged.taskLaunchPath,

description: staged.taskDescription,

});

return { scriptPath: staged.scriptPath };

await execSchtasks(["/Delete", "/F", "/TN", taskName]);

}

const startupEntryPath = resolveStartupEntryPath(env);

try {

await fs.unlink(startupEntryPath);

stdout.write(`${formatLine("Removed Windows login item", startupEntryPath)}\n`);

} catch {}

for (const startupEntryPath of resolveStartupEntryPaths(env)) {

try {

await fs.unlink(startupEntryPath);

stdout.write(`${formatLine("Removed Windows login item", startupEntryPath)}\n`);

} catch {}

}

const scriptPath = resolveTaskScriptPath(env);

const launcherPath = resolveTaskLauncherScriptPath(env, scriptPath);

if (launcherPath !== scriptPath) {

try {

await fs.unlink(launcherPath);

stdout.write(`${formatLine("Removed task launcher", launcherPath)}\n`);

} catch {}

}

try {

await fs.unlink(scriptPath);

stdout.write(`${formatLine("Removed task script", scriptPath)}\n`);