@namzu/cli 35.0.0 → 36.1.0

package/dist/chunks/service-YBU5VTKQ.js

@@ -0,0 +1,1633 @@
+import { createRequire as __namzuCreateRequire } from 'node:module';
+const require = __namzuCreateRequire(import.meta.url);
+import {
+  EXIT_STOP_REQUESTED,
+  ScheduleDaemon,
+  daemonLogPath,
+  daemonLogSink,
+  installedFingerprint,
+  isFinal,
+  parseFireArgs,
+  readRunResult,
+  requestStop,
+  runFire,
+  spawnFireProcess,
+  stopRequestPath,
+  writeRunResult
+} from "./chunk-THZXXVHM.js";
+import "./chunk-KCWUQRZV.js";
+import "./chunk-E5VLANCO.js";
+import "./chunk-EIYM6TY7.js";
+import {
+  parkedRunWords,
+  resumeCommand
+} from "./chunk-HQM2WSQT.js";
+import {
+  readState
+} from "./chunk-J72CRUNX.js";
+import {
+  flag,
+  has,
+  parseArgs,
+  parseMs,
+  pathsFor
+} from "./chunk-UDBEU2FR.js";
+import {
+  callEndpoint,
+  readEndpoint
+} from "./chunk-6YG7D7U4.js";
+import "./chunk-WHODOMXA.js";
+import "./chunk-HPMWYIBY.js";
+import {
+  readManifest,
+  removeManifest,
+  writeManifest
+} from "./chunk-AK2U3N2A.js";
+import {
+  listJobs,
+  sanitizeLine
+} from "./chunk-SKKWMMFP.js";
+import "./chunk-OEW7CJKK.js";
+import "./chunk-A22MBIYU.js";
+import {
+  loadBootstrapConfigWithProvenance
+} from "./chunk-RC6X3ZY6.js";
+import "./chunk-KONYGNG6.js";
+import "./chunk-KU3W6IHV.js";
+import {
+  CLI_VERSION
+} from "./chunk-HE7WUOX2.js";
+import "./chunk-CHIEVVQ2.js";
+import "./chunk-K76WV7TN.js";
+import "./chunk-US5ZFPAU.js";
+import {
+  detectWsl,
+  readWslMountRoot,
+  wslSystem32
+} from "./chunk-2A37JQKY.js";
+import "./chunk-6LLJQ3KY.js";
+import {
+  EXIT_NO_CONFIG,
+  EXIT_OK,
+  EXIT_UNAVAILABLE,
+  EXIT_USAGE
+} from "./chunk-Y7B67G22.js";
+import "./chunk-XEUQN4JC.js";
+import "./chunk-Q5YM2GCX.js";
+import "./chunk-WM2JEUGV.js";
+import {
+  cliLogger,
+  installCliLogging
+} from "./chunk-HBBB2CAC.js";
+import "./chunk-EEDZOGV4.js";
+import "./chunk-AHIDYIRB.js";
+import "./chunk-GIXSS6KW.js";
+import "./chunk-TIGWWAJI.js";
+import "./chunk-H6B6AROX.js";
+import "./chunk-A5UXODFL.js";
+import "./chunk-OLPOM3DR.js";
+import "./chunk-CG65NUSJ.js";
+import "./chunk-JORONMD3.js";
+import "./chunk-Q24K7536.js";
+import "./chunk-NQY5P2EB.js";
+import "./chunk-EWKJGHRO.js";
+import {
+  __name
+} from "./chunk-76FLAFCG.js";
+
+// src/schedule/commands/service.ts
+import { randomUUID } from "node:crypto";
+import { existsSync as existsSync5, readFileSync as readFileSync2, realpathSync, rmSync as rmSync4 } from "node:fs";
+import { dirname as dirname3, join as join6 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/integrations/notifications/desktop.ts
+import { execFile } from "node:child_process";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+// src/integrations/notifications/desktop/freedesktop.ts
+function gvariantString(text) {
+  return `'${text.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
+}
+__name(gvariantString, "gvariantString");
+function notifySendArguments(title, body) {
+  return ["--app-name=namzu", "--", title, body];
+}
+__name(notifySendArguments, "notifySendArguments");
+function gdbusArguments(title, body) {
+  return [
+    "call",
+    "--session",
+    "--dest",
+    "org.freedesktop.Notifications",
+    "--object-path",
+    "/org/freedesktop/Notifications",
+    "--method",
+    "org.freedesktop.Notifications.Notify",
+    gvariantString("namzu"),
+    "0",
+    gvariantString(""),
+    gvariantString(title),
+    gvariantString(body),
+    "[]",
+    "{}",
+    "10000"
+  ];
+}
+__name(gdbusArguments, "gdbusArguments");
+
+// src/integrations/notifications/desktop/macos.ts
+function osascriptArguments(title, body) {
+  return [
+    "-e",
+    "on run argv",
+    "-e",
+    "display notification (item 2 of argv) with title (item 1 of argv)",
+    "-e",
+    "end run",
+    title,
+    body
+  ];
+}
+__name(osascriptArguments, "osascriptArguments");
+
+// src/integrations/notifications/desktop/windows-toast.ts
+var TOAST_SCRIPT = [
+  "$ErrorActionPreference = 'Stop'",
+  "[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null",
+  "[Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom.XmlDocument, ContentType = WindowsRuntime] | Out-Null",
+  "$title = [Security.SecurityElement]::Escape([string]$env:NAMZU_NOTIFY_TITLE)",
+  "$body = [Security.SecurityElement]::Escape([string]$env:NAMZU_NOTIFY_BODY)",
+  "$xml = New-Object Windows.Data.Xml.Dom.XmlDocument",
+  `$xml.LoadXml('<toast><visual><binding template="ToastGeneric"><text>' + $title + '</text><text>' + $body + '</text></binding></visual></toast>')`,
+  "$app = '{1AC14E77-02E7-4E5D-B744-2EB1AE5198B7}\\WindowsPowerShell\\v1.0\\powershell.exe'",
+  "[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier($app).Show([Windows.UI.Notifications.ToastNotification]::new($xml))"
+].join("\n");
+function encodedToastScript() {
+  return Buffer.from(TOAST_SCRIPT, "utf16le").toString("base64");
+}
+__name(encodedToastScript, "encodedToastScript");
+function toastArguments() {
+  return [
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-EncodedCommand",
+    encodedToastScript()
+  ];
+}
+__name(toastArguments, "toastArguments");
+function toastEnvironment(base, title, body, wsl) {
+  const env = { ...base, NAMZU_NOTIFY_TITLE: title, NAMZU_NOTIFY_BODY: body };
+  if (wsl) {
+    const existing = (base.WSLENV ?? "").split(":").filter((v) => v && !v.startsWith("NAMZU_NOTIFY_"));
+    env.WSLENV = [...existing, "NAMZU_NOTIFY_TITLE", "NAMZU_NOTIFY_BODY"].join(":");
+  }
+  return env;
+}
+__name(toastEnvironment, "toastEnvironment");
+
+// src/integrations/notifications/desktop.ts
+function readOsRelease() {
+  try {
+    return readFileSync("/proc/sys/kernel/osrelease", "utf8");
+  } catch {
+    return void 0;
+  }
+}
+__name(readOsRelease, "readOsRelease");
+function whichOnPath(env, exists) {
+  return (name) => {
+    for (const dir of (env.PATH ?? "").split(":")) {
+      if (!dir || dir.startsWith("/mnt/")) continue;
+      const candidate = join(dir, name);
+      if (exists(candidate)) return candidate;
+    }
+    return void 0;
+  };
+}
+__name(whichOnPath, "whichOnPath");
+var WSL_RUN_DIR = "/run/WSL";
+function listInteropSockets() {
+  const sockets = [];
+  let names;
+  try {
+    names = readdirSync(WSL_RUN_DIR);
+  } catch {
+    return sockets;
+  }
+  for (const name of names) {
+    if (!/^\d+_interop$/.test(name)) continue;
+    const path = join(WSL_RUN_DIR, name);
+    try {
+      const stat = statSync(path);
+      if (stat.isSocket()) sockets.push({ path, mtimeMs: stat.mtimeMs });
+    } catch {
+    }
+  }
+  return sockets;
+}
+__name(listInteropSockets, "listInteropSockets");
+function findInteropSocket(sockets) {
+  const stable = sockets.find((socket) => socket.path === join(WSL_RUN_DIR, "1_interop"));
+  if (stable) return stable.path;
+  return [...sockets].sort((a, b) => b.mtimeMs - a.mtimeMs)[0]?.path;
+}
+__name(findInteropSocket, "findInteropSocket");
+function selectDesktopBackend(probe = {}) {
+  const platform = probe.platform ?? process.platform;
+  const env = probe.env ?? process.env;
+  const exists = probe.exists ?? existsSync;
+  const which = probe.which ?? whichOnPath(env, exists);
+  if (platform === "darwin") {
+    return {
+      kind: "macos",
+      detail: "osascript",
+      command: "/usr/bin/osascript",
+      args: osascriptArguments
+    };
+  }
+  if (platform === "win32") {
+    return {
+      kind: "windows-toast",
+      detail: "powershell.exe",
+      command: "powershell.exe",
+      args: /* @__PURE__ */ __name(() => toastArguments(), "args"),
+      env: /* @__PURE__ */ __name((base, title, body) => toastEnvironment(base, title, body, false), "env")
+    };
+  }
+  const mountRoot = probe.mountRoot ?? readWslMountRoot();
+  const wsl = detectWsl(env, { exists, list: /* @__PURE__ */ __name(() => [], "list"), mountRoot });
+  const wslKernel = !wsl && /microsoft/i.test((probe.osRelease ?? readOsRelease)() ?? "");
+  if (wsl || wslKernel) {
+    const enabled = wsl?.interop ?? exists("/proc/sys/fs/binfmt_misc/WSLInterop");
+    const socket = enabled ? env.WSL_INTEROP || findInteropSocket((probe.interopSockets ?? listInteropSockets)()) : void 0;
+    if (!socket) {
+      return {
+        kind: "none",
+        detail: enabled ? "WSL interop is not available to this process (no WSL_INTEROP and no interop socket under /run/WSL), so Windows notifications cannot be shown" : "WSL interop is disabled ([interop] enabled=false in /etc/wsl.conf), so Windows notifications cannot be shown"
+      };
+    }
+    const powershell = probe.powershell ?? `${wslSystem32(mountRoot)}/WindowsPowerShell/v1.0/powershell.exe`;
+    if (!exists(powershell)) return { kind: "none", detail: `${powershell} was not found` };
+    const found = env.WSL_INTEROP ? void 0 : socket;
+    return {
+      kind: "wsl-toast",
+      detail: found ? `${powershell} (interop through ${found})` : powershell,
+      command: powershell,
+      args: /* @__PURE__ */ __name(() => toastArguments(), "args"),
+      env: /* @__PURE__ */ __name((base, title, body) => ({
+        ...toastEnvironment(base, title, body, true),
+        ...found ? { WSL_INTEROP: found } : {}
+      }), "env"),
+      cwd: `${mountRoot}c`
+    };
+  }
+  const bus = env.DBUS_SESSION_BUS_ADDRESS || (env.XDG_RUNTIME_DIR && exists(join(env.XDG_RUNTIME_DIR, "bus")) ? "runtime-bus" : "");
+  if (!bus)
+    return { kind: "none", detail: "no desktop session bus (DBUS_SESSION_BUS_ADDRESS is unset)" };
+  const notifySend = which("notify-send");
+  if (notifySend)
+    return {
+      kind: "freedesktop",
+      detail: notifySend,
+      command: notifySend,
+      args: notifySendArguments
+    };
+  const gdbus = which("gdbus");
+  if (gdbus) return { kind: "freedesktop", detail: gdbus, command: gdbus, args: gdbusArguments };
+  return { kind: "none", detail: "neither notify-send nor gdbus is installed" };
+}
+__name(selectDesktopBackend, "selectDesktopBackend");
+var defaultSpawn = /* @__PURE__ */ __name((command, args, options) => new Promise((resolve2) => {
+  execFile(
+    command,
+    [...args],
+    {
+      env: options.env,
+      ...options.cwd ? { cwd: options.cwd } : {},
+      timeout: options.timeoutMs,
+      windowsHide: true
+    },
+    (error, _stdout, stderr) => {
+      const code = error ? typeof error.code === "number" ? error.code : 1 : 0;
+      resolve2({ code, stderr: String(stderr ?? "").slice(0, 500) });
+    }
+  );
+}), "defaultSpawn");
+async function sendDesktopNotification(backend, notification, options = {}) {
+  if (backend.kind === "none" || !backend.command || !backend.args) {
+    return { kind: "unavailable", detail: backend.detail };
+  }
+  const title = sanitizeLine(notification.title, 64);
+  const body = sanitizeLine(notification.body, 200);
+  const base = options.env ?? process.env;
+  const env = backend.env ? backend.env(base, title, body) : base;
+  try {
+    const result = await (options.spawn ?? defaultSpawn)(
+      backend.command,
+      backend.args(title, body),
+      {
+        env,
+        ...backend.cwd ? { cwd: backend.cwd } : {},
+        timeoutMs: 15e3
+      }
+    );
+    return result.code === 0 ? { kind: "sent" } : { kind: "failed", detail: result.stderr || `exit ${String(result.code)}` };
+  } catch (error) {
+    return { kind: "failed", detail: error instanceof Error ? error.message : String(error) };
+  }
+}
+__name(sendDesktopNotification, "sendDesktopNotification");
+
+// src/schedule/service/detect.ts
+function detectPlatform(options = {}) {
+  const platform = options.platform ?? process.platform;
+  if (platform === "darwin") return { platform: "launchd" };
+  if (platform === "win32") return { platform: "windows-task" };
+  if (platform === "linux") {
+    if (detectWsl(options.env ?? process.env)) return { platform: "wsl-windows-task" };
+    if (options.systemdUser) return { platform: "systemd-user" };
+    return {
+      platform: null,
+      reason: "no systemd user manager answers here; run `namzu schedule daemon` under a supervisor of your own"
+    };
+  }
+  return { platform: null, reason: `${platform} has no supported supervisor` };
+}
+__name(detectPlatform, "detectPlatform");
+
+// src/schedule/service/index.ts
+import { mkdirSync as mkdirSync3, rmSync as rmSync3, rmdirSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { userInfo } from "node:os";
+import { isAbsolute, join as join4 } from "node:path";
+
+// src/schedule/service/launchd.ts
+import { existsSync as existsSync2, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join as join2 } from "node:path";
+
+// src/schedule/service/quote.ts
+function systemdWord(text) {
+  const escaped = text.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("%", "%%").replaceAll("$", "$$$$");
+  return `"${escaped}"`;
+}
+__name(systemdWord, "systemdWord");
+function systemdAssignment(key, value) {
+  return systemdWord(`${key}=${value}`);
+}
+__name(systemdAssignment, "systemdAssignment");
+function xmlText(text) {
+  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+__name(xmlText, "xmlText");
+function windowsArgument(text) {
+  if (text !== "" && !/[\s"]/.test(text)) return text;
+  let out = '"';
+  let slashes = 0;
+  for (const ch of text) {
+    if (ch === "\\") {
+      slashes++;
+      continue;
+    }
+    if (ch === '"') {
+      out += `${"\\".repeat(slashes * 2 + 1)}"`;
+    } else {
+      out += "\\".repeat(slashes) + ch;
+    }
+    slashes = 0;
+  }
+  return `${out}${"\\".repeat(slashes * 2)}"`;
+}
+__name(windowsArgument, "windowsArgument");
+var WSL_SAFE_PATH = /^[A-Za-z0-9._/@+-]+$/;
+function checkWslPath(label, path) {
+  if (!WSL_SAFE_PATH.test(path)) {
+    throw new Error(
+      `${label} ${path} contains characters wsl.exe would re-read (only letters, digits and . _ / @ + - are passed through safely); install node and namzu under a plain path, or use --platform systemd-user`
+    );
+  }
+  return path;
+}
+__name(checkWslPath, "checkWslPath");
+
+// src/schedule/service/launchd.ts
+function launchdLabel(name) {
+  return name === "namzu-scheduler" ? "com.namzu.scheduler" : `com.namzu.${name.replace(/^namzu-/, "")}`;
+}
+__name(launchdLabel, "launchdLabel");
+function launchdPlistPath(label, home = homedir()) {
+  return join2(home, "Library", "LaunchAgents", `${label}.plist`);
+}
+__name(launchdPlistPath, "launchdPlistPath");
+function launchdPlist(label, program2) {
+  const args = [program2.node, program2.bin, "schedule", "daemon", "--home", program2.namzuHome];
+  const log = join2(program2.namzuHome, "schedule", "daemon");
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+    '<plist version="1.0">',
+    "<dict>",
+    "	<key>Label</key>",
+    `	<string>${xmlText(label)}</string>`,
+    "	<key>ProgramArguments</key>",
+    "	<array>",
+    ...args.map((a) => `		<string>${xmlText(a)}</string>`),
+    "	</array>",
+    "	<key>EnvironmentVariables</key>",
+    "	<dict>",
+    "		<key>NAMZU_HOME</key>",
+    `		<string>${xmlText(program2.namzuHome)}</string>`,
+    "	</dict>",
+    "	<key>RunAtLoad</key>",
+    "	<true/>",
+    "	<key>KeepAlive</key>",
+    "	<true/>",
+    "	<key>ThrottleInterval</key>",
+    "	<integer>10</integer>",
+    "	<key>ProcessType</key>",
+    "	<string>Background</string>",
+    "	<key>AbandonProcessGroup</key>",
+    "	<true/>",
+    "	<key>LimitLoadToSessionType</key>",
+    "	<string>Aqua</string>",
+    "	<key>StandardOutPath</key>",
+    `	<string>${xmlText(join2(log, "launchd.out.log"))}</string>`,
+    "	<key>StandardErrorPath</key>",
+    `	<string>${xmlText(join2(log, "launchd.err.log"))}</string>`,
+    "</dict>",
+    "</plist>",
+    ""
+  ].join("\n");
+}
+__name(launchdPlist, "launchdPlist");
+async function installLaunchd(label, program2, steps, plistPath = launchdPlistPath(label)) {
+  mkdirSync(dirname(plistPath), { recursive: true });
+  writeFileSync(plistPath, launchdPlist(label, program2), { mode: 420 });
+  for (const domain of [`gui/${steps.uid}`, `user/${steps.uid}`]) {
+    await steps.run("launchctl", ["bootout", `${domain}/${label}`]);
+    const result = await steps.run("launchctl", ["bootstrap", domain, plistPath]);
+    if (result.code === 0) return { domain, problems: [] };
+  }
+  return { domain: `gui/${steps.uid}`, problems: [`launchctl bootstrap failed for ${plistPath}`] };
+}
+__name(installLaunchd, "installLaunchd");
+async function uninstallLaunchd(label, domain, steps, plistPath = launchdPlistPath(label)) {
+  await steps.run("launchctl", ["bootout", `${domain}/${label}`]);
+  rmSync(plistPath, { force: true });
+  const problems = [];
+  if (existsSync2(plistPath)) problems.push(`${plistPath} is still there`);
+  const printed = await steps.run("launchctl", ["print", `${domain}/${label}`]);
+  if (printed.code === 0) problems.push(`${label} is still loaded in ${domain}`);
+  return problems;
+}
+__name(uninstallLaunchd, "uninstallLaunchd");
+
+// src/schedule/service/systemd.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, join as join3 } from "node:path";
+function systemdUnitPath(name, env = process.env, home = homedir2()) {
+  const config = env.XDG_CONFIG_HOME || join3(home, ".config");
+  return join3(config, "systemd", "user", `${name}.service`);
+}
+__name(systemdUnitPath, "systemdUnitPath");
+function systemdUnit(program2) {
+  return [
+    "[Unit]",
+    `Description=namzu scheduler (NAMZU_HOME=${program2.namzuHome.replaceAll("%", "%%")})`,
+    "Documentation=https://github.com/cogitave/namzu/blob/main/docs/cli/scheduler-service.md",
+    "StartLimitIntervalSec=0",
+    "",
+    "[Service]",
+    "Type=simple",
+    `ExecStart=${[program2.node, program2.bin, "schedule", "daemon", "--home", program2.namzuHome].map(systemdWord).join(" ")}`,
+    `Environment=${systemdAssignment("NAMZU_HOME", program2.namzuHome)}`,
+    "Restart=always",
+    "RestartSec=10",
+    `SuccessExitStatus=${EXIT_STOP_REQUESTED}`,
+    `RestartPreventExitStatus=${EXIT_STOP_REQUESTED}`,
+    "KillMode=process",
+    "TimeoutStopSec=20",
+    "",
+    "[Install]",
+    "WantedBy=default.target",
+    ""
+  ].join("\n");
+}
+__name(systemdUnit, "systemdUnit");
+async function systemctl(steps, ...args) {
+  return steps.run(steps.systemctl ?? "systemctl", ["--user", ...args]);
+}
+__name(systemctl, "systemctl");
+async function installSystemd(name, program2, steps, unitPath = systemdUnitPath(name)) {
+  mkdirSync2(dirname2(unitPath), { recursive: true });
+  writeFileSync2(unitPath, systemdUnit(program2), { mode: 420 });
+  const problems = [];
+  for (const args of [["daemon-reload"], ["enable", "--now", `${name}.service`]]) {
+    const result = await systemctl(steps, ...args);
+    if (result.code !== 0)
+      problems.push(
+        `systemctl --user ${args.join(" ")}: ${result.stderr.trim() || `exit ${result.code}`}`
+      );
+  }
+  return problems;
+}
+__name(installSystemd, "installSystemd");
+async function uninstallSystemd(name, steps, unitPath = systemdUnitPath(name)) {
+  const problems = [];
+  await systemctl(steps, "disable", "--now", `${name}.service`);
+  rmSync2(unitPath, { force: true });
+  await systemctl(steps, "daemon-reload");
+  await systemctl(steps, "reset-failed", `${name}.service`);
+  if (existsSync3(unitPath)) problems.push(`${unitPath} is still there`);
+  const shown = await systemctl(steps, "show", `${name}.service`, "--property=LoadState");
+  if (shown.code === 0 && /LoadState=loaded/.test(shown.stdout))
+    problems.push(`${name}.service is still loaded`);
+  return problems;
+}
+__name(uninstallSystemd, "uninstallSystemd");
+async function systemdState(name, steps) {
+  const result = await systemctl(steps, "is-active", `${name}.service`);
+  return result.stdout.trim() || result.stderr.trim() || "unknown";
+}
+__name(systemdState, "systemdState");
+async function startSystemd(name, steps) {
+  const result = await systemctl(steps, "enable", "--now", `${name}.service`);
+  return result.code === 0 ? [] : [result.stderr.trim() || `exit ${result.code}`];
+}
+__name(startSystemd, "startSystemd");
+async function stopSystemd(name, steps) {
+  const result = await systemctl(steps, "disable", "--now", `${name}.service`);
+  return result.code === 0 ? [] : [result.stderr.trim() || `exit ${result.code}`];
+}
+__name(stopSystemd, "stopSystemd");
+async function systemdUserAvailable(steps) {
+  if (!existsSync3("/run/systemd/system")) return false;
+  const result = await systemctl(steps, "show-environment");
+  return result.code === 0;
+}
+__name(systemdUserAvailable, "systemdUserAvailable");
+
+// src/schedule/service/windows-task.ts
+function taskXml(task) {
+  const start = task.startBoundary ?? "2026-01-01T00:00:00";
+  return [
+    '<?xml version="1.0" encoding="UTF-16"?>',
+    '<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">',
+    "  <RegistrationInfo>",
+    `    <Description>${xmlText(task.description)}</Description>`,
+    `    <Author>${xmlText(task.userId)}</Author>`,
+    "  </RegistrationInfo>",
+    "  <Triggers>",
+    "    <LogonTrigger>",
+    "      <Enabled>true</Enabled>",
+    `      <UserId>${xmlText(task.userId)}</UserId>`,
+    "    </LogonTrigger>",
+    "    <TimeTrigger>",
+    "      <Repetition>",
+    "        <Interval>PT5M</Interval>",
+    "        <StopAtDurationEnd>false</StopAtDurationEnd>",
+    "      </Repetition>",
+    `      <StartBoundary>${xmlText(start)}</StartBoundary>`,
+    "      <Enabled>true</Enabled>",
+    "    </TimeTrigger>",
+    "  </Triggers>",
+    "  <Principals>",
+    '    <Principal id="Author">',
+    `      <UserId>${xmlText(task.userId)}</UserId>`,
+    "      <LogonType>InteractiveToken</LogonType>",
+    "      <RunLevel>LeastPrivilege</RunLevel>",
+    "    </Principal>",
+    "  </Principals>",
+    "  <Settings>",
+    "    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>",
+    "    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>",
+    "    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>",
+    "    <AllowHardTerminate>true</AllowHardTerminate>",
+    "    <StartWhenAvailable>true</StartWhenAvailable>",
+    "    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>",
+    "    <IdleSettings>",
+    "      <StopOnIdleEnd>false</StopOnIdleEnd>",
+    "      <RestartOnIdle>false</RestartOnIdle>",
+    "    </IdleSettings>",
+    "    <AllowStartOnDemand>true</AllowStartOnDemand>",
+    "    <Enabled>true</Enabled>",
+    "    <Hidden>false</Hidden>",
+    "    <RunOnlyIfIdle>false</RunOnlyIfIdle>",
+    "    <WakeToRun>false</WakeToRun>",
+    "    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>",
+    "    <Priority>7</Priority>",
+    "  </Settings>",
+    '  <Actions Context="Author">',
+    "    <Exec>",
+    `      <Command>${xmlText(task.command)}</Command>`,
+    `      <Arguments>${xmlText(task.args.map(windowsArgument).join(" "))}</Arguments>`,
+    "    </Exec>",
+    "  </Actions>",
+    "</Task>",
+    ""
+  ].join("\r\n");
+}
+__name(taskXml, "taskXml");
+function taskXmlBytes(xml) {
+  return Buffer.concat([Buffer.from([255, 254]), Buffer.from(xml, "utf16le")]);
+}
+__name(taskXmlBytes, "taskXmlBytes");
+function taskPath(name) {
+  return `\\namzu\\${name}`;
+}
+__name(taskPath, "taskPath");
+var REMOVE_EMPTY_TASK_FOLDER_SCRIPT = [
+  "$ErrorActionPreference = 'Stop'",
+  "$s = New-Object -ComObject Schedule.Service",
+  "$s.Connect()",
+  "try { $f = $s.GetFolder('\\namzu') } catch { exit 0 }",
+  "if ($f.GetTasks(1).Count -gt 0 -or $f.GetFolders(0).Count -gt 0) { exit 0 }",
+  "try { $s.GetFolder('\\').DeleteFolder('namzu', 0) } catch { exit 1 }",
+  "exit 0"
+].join("; ");
+function removeEmptyTaskFolderArguments() {
+  return [
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-EncodedCommand",
+    Buffer.from(REMOVE_EMPTY_TASK_FOLDER_SCRIPT, "utf16le").toString("base64")
+  ];
+}
+__name(removeEmptyTaskFolderArguments, "removeEmptyTaskFolderArguments");
+var TASK_RESULTS = /* @__PURE__ */ new Map([
+  [0, "succeeded"],
+  [267008, "ready to run"],
+  [267009, "running"],
+  [267010, "disabled"],
+  [267011, "not run yet"],
+  [267012, "no more runs scheduled"],
+  [267014, "ended by a person or a stop"],
+  [267015, "no trigger is enabled"],
+  [2147750687, "an instance was already running, so a new one was not started"],
+  // IgnoreNew answers the five-minute re-check this way while the
+  // scheduler runs: the expected result, not a failure.
+  [
+    2147946720,
+    "an instance was already running, so a new one was not started; expected, since the task checks every five minutes"
+  ],
+  [2147750694, "the task is disabled"],
+  [2147942402, "the program was not found"],
+  [2147942405, "access was denied"],
+  [2147942667, "the start folder is not valid"],
+  [2147943645, "the user was not logged on"],
+  [3221225786, "ended when its console closed"],
+  [1073807364, "ended by a sign-out or shutdown"]
+]);
+var DAEMON_EXITS = /* @__PURE__ */ new Map([
+  [1, "the program exited with an error; see namzu schedule logs"],
+  [75, "the scheduler exited: another one owns this NAMZU_HOME"],
+  [EXIT_STOP_REQUESTED, "the scheduler exited: namzu schedule stop asked it to"]
+]);
+function describeTaskResult(raw) {
+  const text = raw.trim();
+  let value;
+  if (/^0x[0-9a-f]{1,8}$/i.test(text)) value = Number.parseInt(text.slice(2), 16);
+  else if (/^-?\d{1,10}$/.test(text)) value = Number(text);
+  else return text;
+  const code = value >>> 0;
+  const hex = `0x${code.toString(16).toUpperCase()}`;
+  const number = code < 256 || /^0x/i.test(text) ? text : `${text}, ${hex}`;
+  const words = TASK_RESULTS.get(code) ?? DAEMON_EXITS.get(code) ?? (code < 256 ? "the program exited" : void 0);
+  if (words !== void 0) return `${words} (${number})`;
+  return number === text ? text : `${text} (${hex})`;
+}
+__name(describeTaskResult, "describeTaskResult");
+function parseTaskQuery(output) {
+  const field = /* @__PURE__ */ __name((label) => {
+    for (const line of output.split(/\r?\n/)) {
+      const match = /^([^:]+):\s*(.*)$/.exec(line);
+      if (match && label.test((match[1] ?? "").trim())) return (match[2] ?? "").trim();
+    }
+    return void 0;
+  }, "field");
+  const status = field(/^Status$/i);
+  const state = field(/^Scheduled Task State$/i);
+  const lastResult = field(/^Last Result$/i);
+  return {
+    ...status !== void 0 ? { status } : {},
+    ...state !== void 0 ? { state } : {},
+    ...lastResult !== void 0 ? { lastResult } : {}
+  };
+}
+__name(parseTaskQuery, "parseTaskQuery");
+
+// src/schedule/service/wsl.ts
+import { existsSync as existsSync4 } from "node:fs";
+var DEFAULT_SYSTEM32 = wslSystem32();
+function windowsTools(system32 = wslSystem32(readWslMountRoot())) {
+  const systemRoot = system32.replace(/\/System32$/i, "");
+  const drive = systemRoot.replace(/\/Windows$/i, "");
+  return {
+    mountRoot: drive.replace(/[^/]+$/, ""),
+    drive,
+    systemRoot,
+    cmd: `${system32}/cmd.exe`,
+    schtasks: `${system32}/schtasks.exe`,
+    powershell: `${system32}/WindowsPowerShell/v1.0/powershell.exe`,
+    whoami: `${system32}/whoami.exe`,
+    conhost: `${system32}/conhost.exe`,
+    wsl: `${system32}/wsl.exe`
+  };
+}
+__name(windowsTools, "windowsTools");
+async function probeInterop(run, tools, env = process.env) {
+  if (!existsSync4(tools.cmd))
+    return { ok: false, reason: `${tools.cmd} was not found (is C: mounted at ${tools.drive}?)` };
+  if (!env.WSL_INTEROP && !existsSync4("/proc/sys/fs/binfmt_misc/WSLInterop")) {
+    return {
+      ok: false,
+      reason: "WSL interop is disabled ([interop] enabled=false in /etc/wsl.conf)"
+    };
+  }
+  const result = await run(tools.cmd, ["/d", "/c", "ver"], { timeoutMs: 2e4, cwd: tools.drive });
+  return result.code === 0 ? { ok: true } : {
+    ok: false,
+    reason: `a Windows program did not start through interop (${result.stderr.trim() || `exit ${result.code}`})`
+  };
+}
+__name(probeInterop, "probeInterop");
+async function windowsUser(run, tools) {
+  const result = await run(tools.whoami, [], { timeoutMs: 2e4, cwd: tools.drive });
+  const user = result.stdout.trim();
+  if (result.code !== 0 || !/^[^\\\s]+\\[^\\\s]+$/.test(user)) {
+    throw new Error(
+      `could not read the Windows user from whoami.exe (${result.stderr.trim() || user || `exit ${result.code}`})`
+    );
+  }
+  return user;
+}
+__name(windowsUser, "windowsUser");
+async function toWindowsPath(run, path) {
+  const result = await run("wslpath", ["-w", path], { timeoutMs: 1e4 });
+  if (result.code !== 0 || !result.stdout.trim()) throw new Error(`wslpath -w ${path} failed`);
+  return result.stdout.trim();
+}
+__name(toWindowsPath, "toWindowsPath");
+function isEphemeralBin(bin) {
+  return /[\\/]_npx[\\/]/.test(bin) || /[\\/]\.npm[\\/]_cacache[\\/]/.test(bin);
+}
+__name(isEphemeralBin, "isEphemeralBin");
+function wslTaskName(name, distro) {
+  return `${name}-wsl-${distro.replace(/[^A-Za-z0-9._-]/g, "_")}`;
+}
+__name(wslTaskName, "wslTaskName");
+function wslTaskDefinition(options) {
+  checkWslPath("node", options.node);
+  checkWslPath("the namzu CLI", options.bin);
+  checkWslPath("NAMZU_HOME", options.namzuHome);
+  if (!/^[A-Za-z0-9._-]+$/.test(options.distro))
+    throw new Error(`unusual WSL distro name: ${options.distro}`);
+  if (!/^[a-z_][a-z0-9_-]*\$?$/i.test(options.linuxUser))
+    throw new Error(`unusual Linux user name: ${options.linuxUser}`);
+  const root = options.systemRoot ?? "C:\\Windows";
+  return {
+    userId: options.userId,
+    description: `namzu scheduler for NAMZU_HOME=${options.namzuHome} in WSL ${options.distro}`,
+    command: `${root}\\System32\\conhost.exe`,
+    args: [
+      "--headless",
+      `${root}\\System32\\wsl.exe`,
+      "-d",
+      options.distro,
+      "-u",
+      options.linuxUser,
+      "--cd",
+      "/",
+      "--exec",
+      "/usr/bin/env",
+      `NAMZU_HOME=${options.namzuHome}`,
+      options.node,
+      options.bin,
+      "schedule",
+      "daemon",
+      "--home",
+      options.namzuHome
+    ]
+  };
+}
+__name(wslTaskDefinition, "wslTaskDefinition");
+
+// src/schedule/service/index.ts
+function windowsCwd(ctx, manifest) {
+  return manifest.platform === "wsl-windows-task" ? { cwd: (ctx.tools ?? windowsTools()).drive } : {};
+}
+__name(windowsCwd, "windowsCwd");
+var ServiceRefusal = class extends Error {
+  static {
+    __name(this, "ServiceRefusal");
+  }
+  name = "ServiceRefusal";
+};
+function refuseUnsafeProgram(program2) {
+  if (!isAbsolute(program2.node) && !/^[A-Za-z]:\\/.test(program2.node)) {
+    throw new ServiceRefusal(`node must be an absolute path, got ${program2.node}`);
+  }
+  if (isEphemeralBin(program2.bin)) {
+    throw new ServiceRefusal(
+      `namzu is running from the npx cache (${program2.bin}), which is not kept; install it (npm i -g @namzu/cli) and run schedule install from that`
+    );
+  }
+}
+__name(refuseUnsafeProgram, "refuseUnsafeProgram");
+async function lingerEnabled(run, user) {
+  const result = await run("loginctl", ["show-user", user, "-p", "Linger"]);
+  return /Linger=yes/.test(result.stdout);
+}
+__name(lingerEnabled, "lingerEnabled");
+async function installService(ctx, request) {
+  refuseUnsafeProgram(request.program);
+  const { paths, run } = ctx;
+  const notes = [];
+  const base = {
+    v: 1,
+    kind: "schedule-service",
+    platform: request.platform,
+    name: request.name,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    cliVersion: ctx.version,
+    nodePath: request.program.node,
+    binPath: request.program.bin,
+    namzuHome: request.program.namzuHome
+  };
+  switch (request.platform) {
+    case "systemd-user": {
+      const unit = systemdUnitPath(request.name, ctx.env);
+      const problems = await installSystemd(request.name, request.program, { run }, unit);
+      let enabledLinger = false;
+      if (request.atBoot) {
+        const user = userInfo().username;
+        if (!await lingerEnabled(run, user)) {
+          const result = await run("loginctl", ["enable-linger", user]);
+          if (result.code === 0) enabledLinger = true;
+          else
+            problems.push(
+              `loginctl enable-linger ${user}: ${result.stderr.trim() || `exit ${result.code}`}`
+            );
+        }
+      } else {
+        notes.push(
+          "The daemon starts when you log in; --at-boot keeps it running without a login (linger)."
+        );
+      }
+      const manifest = {
+        ...base,
+        enabledLinger,
+        artifacts: [
+          { type: "file", path: unit },
+          { type: "systemd-unit", name: `${request.name}.service` }
+        ]
+      };
+      writeManifest(paths, manifest);
+      return { manifest, problems, notes };
+    }
+    case "launchd": {
+      const label = launchdLabel(request.name);
+      const plist = launchdPlistPath(label);
+      const { domain, problems } = await installLaunchd(
+        label,
+        request.program,
+        {
+          run,
+          uid: process.getuid?.() ?? 501
+        },
+        plist
+      );
+      const manifest = {
+        ...base,
+        artifacts: [
+          { type: "file", path: plist },
+          { type: "launchd-agent", label, domain }
+        ]
+      };
+      writeManifest(paths, manifest);
+      notes.push("A LaunchAgent starts at login, not at boot.");
+      return { manifest, problems, notes };
+    }
+    case "windows-task": {
+      const root = ctx.env.SystemRoot ?? "C:\\Windows";
+      const schtasks = `${root}\\System32\\schtasks.exe`;
+      const who = await run(`${root}\\System32\\whoami.exe`, []);
+      const userId = who.stdout.trim();
+      if (who.code !== 0 || !userId.includes("\\"))
+        throw new ServiceRefusal("could not read the Windows user from whoami.exe");
+      const path = taskPath(request.name);
+      const xml = taskXml({
+        userId,
+        description: `namzu scheduler for NAMZU_HOME=${request.program.namzuHome}`,
+        command: `${root}\\System32\\conhost.exe`,
+        args: [
+          "--headless",
+          request.program.node,
+          request.program.bin,
+          "schedule",
+          "daemon",
+          "--home",
+          request.program.namzuHome
+        ]
+      });
+      const file = join4(paths.daemon, `${request.name}.task.xml`);
+      mkdirSync3(paths.daemon, { recursive: true });
+      writeFileSync3(file, taskXmlBytes(xml));
+      const problems = [];
+      try {
+        const created = await run(schtasks, ["/Create", "/TN", path, "/XML", file, "/F"]);
+        if (created.code !== 0)
+          problems.push(`schtasks /Create: ${created.stderr.trim() || created.stdout.trim()}`);
+        else await run(schtasks, ["/Run", "/TN", path]);
+      } finally {
+        rmSync3(file, { force: true });
+      }
+      const manifest = {
+        ...base,
+        artifacts: [{ type: "windows-task", taskPath: path }],
+        windows: { taskPath: path, schtasks }
+      };
+      writeManifest(paths, manifest);
+      notes.push("The task starts at logon; jobs run while you are logged on.");
+      return { manifest, problems, notes };
+    }
+    case "wsl-windows-task": {
+      const tools = ctx.tools ?? windowsTools();
+      const interop = await probeInterop(run, tools, ctx.env);
+      if (!interop.ok)
+        throw new ServiceRefusal(
+          `WSL interop is not usable: ${interop.reason}. Use --platform systemd-user instead.`
+        );
+      const distro = ctx.env.WSL_DISTRO_NAME;
+      if (!distro)
+        throw new ServiceRefusal("WSL_DISTRO_NAME is not set; cannot name the distro for wsl.exe");
+      const userId = await windowsUser(run, tools);
+      const definition = wslTaskDefinition({
+        userId,
+        distro,
+        linuxUser: userInfo().username,
+        node: request.program.node,
+        bin: request.program.bin,
+        namzuHome: request.program.namzuHome
+      });
+      const name = wslTaskName(request.name, distro);
+      const path = taskPath(name);
+      const localAppData = (await run(tools.cmd, ["/d", "/c", "echo", "%LOCALAPPDATA%"], { cwd: tools.drive })).stdout.trim();
+      if (!/^[A-Za-z]:\\/.test(localAppData))
+        throw new ServiceRefusal("could not resolve %LOCALAPPDATA% through interop");
+      const linuxDir = (await run("wslpath", ["-u", `${localAppData}\\namzu`])).stdout.trim();
+      if (!linuxDir.startsWith(tools.mountRoot))
+        throw new ServiceRefusal(`could not map ${localAppData} into WSL`);
+      mkdirSync3(linuxDir, { recursive: true });
+      const linuxFile = join4(linuxDir, `${name}.xml`);
+      writeFileSync3(linuxFile, taskXmlBytes(taskXml(definition)));
+      const problems = [];
+      try {
+        const windowsFile = await toWindowsPath(run, linuxFile);
+        const created = await run(
+          tools.schtasks,
+          ["/Create", "/TN", path, "/XML", windowsFile, "/F"],
+          { cwd: tools.drive }
+        );
+        if (created.code !== 0)
+          problems.push(`schtasks.exe /Create: ${created.stderr.trim() || created.stdout.trim()}`);
+        else {
+          const started = await run(tools.schtasks, ["/Run", "/TN", path], { cwd: tools.drive });
+          if (started.code !== 0)
+            problems.push(`schtasks.exe /Run: ${started.stderr.trim() || started.stdout.trim()}`);
+        }
+      } finally {
+        rmSync3(linuxFile, { force: true });
+        try {
+          rmdirSync(linuxDir);
+        } catch {
+        }
+      }
+      const manifest = {
+        ...base,
+        name,
+        artifacts: [{ type: "windows-task", taskPath: path }],
+        windows: {
+          taskPath: path,
+          schtasks: tools.schtasks,
+          powershell: tools.powershell,
+          distro,
+          user: userId
+        }
+      };
+      writeManifest(paths, manifest);
+      notes.push(
+        "Windows Task Scheduler starts the daemon in this distro at logon and re-checks it every 5 minutes; jobs run while you are logged on to Windows."
+      );
+      return { manifest, problems, notes };
+    }
+  }
+}
+__name(installService, "installService");
+async function removeArtifact(ctx, manifest, artifact) {
+  switch (artifact.type) {
+    case "file":
+      rmSync3(artifact.path, { force: true });
+      return [];
+    case "systemd-unit": {
+      const unitFile = manifest.artifacts.find((a) => a.type === "file");
+      return uninstallSystemd(
+        artifact.name.replace(/\.service$/, ""),
+        { run: ctx.run },
+        unitFile?.type === "file" ? unitFile.path : systemdUnitPath(manifest.name, ctx.env)
+      );
+    }
+    case "launchd-agent":
+      return uninstallLaunchd(artifact.label, artifact.domain, {
+        run: ctx.run,
+        uid: process.getuid?.() ?? 501
+      });
+    case "windows-task": {
+      const schtasks = manifest.windows?.schtasks ?? "schtasks.exe";
+      const cwd = windowsCwd(ctx, manifest);
+      await ctx.run(schtasks, ["/End", "/TN", artifact.taskPath], cwd);
+      await ctx.run(schtasks, ["/Delete", "/TN", artifact.taskPath, "/F"], cwd);
+      const queried = await ctx.run(schtasks, ["/Query", "/TN", artifact.taskPath], cwd);
+      if (queried.code === 0) return [`task ${artifact.taskPath} is still registered`];
+      const powershell = manifest.windows?.powershell ?? (manifest.platform === "wsl-windows-task" ? (ctx.tools ?? windowsTools()).powershell : `${ctx.env.SystemRoot ?? "C:\\Windows"}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`);
+      const folder = await ctx.run(powershell, removeEmptyTaskFolderArguments(), cwd);
+      return folder.code === 0 ? [] : ["the empty Task Scheduler folder \\namzu is still there; delete it in Task Scheduler"];
+    }
+  }
+}
+__name(removeArtifact, "removeArtifact");
+async function uninstallService(ctx) {
+  const manifest = readManifest(ctx.paths);
+  if (!manifest) return { problems: [] };
+  const problems = [];
+  const ordered = [...manifest.artifacts].sort(
+    (a, b) => (a.type === "file" ? 1 : 0) - (b.type === "file" ? 1 : 0)
+  );
+  for (const artifact of ordered) problems.push(...await removeArtifact(ctx, manifest, artifact));
+  if (manifest.enabledLinger) {
+    const result = await ctx.run("loginctl", ["disable-linger", userInfo().username]);
+    if (result.code !== 0) problems.push("loginctl disable-linger failed (install had enabled it)");
+  }
+  if (problems.length === 0) removeManifest(ctx.paths);
+  return { problems, manifest };
+}
+__name(uninstallService, "uninstallService");
+async function serviceState(ctx, manifest) {
+  switch (manifest.platform) {
+    case "systemd-user":
+      return `systemd: ${await systemdState(manifest.name, { run: ctx.run })}`;
+    case "launchd": {
+      const agent = manifest.artifacts.find((a) => a.type === "launchd-agent");
+      if (agent?.type !== "launchd-agent") return "launchd: unknown";
+      const printed = await ctx.run("launchctl", ["print", `${agent.domain}/${agent.label}`]);
+      return printed.code === 0 ? `launchd: loaded (${/state = (\w+)/.exec(printed.stdout)?.[1] ?? "unknown"})` : "launchd: not loaded";
+    }
+    case "windows-task":
+    case "wsl-windows-task": {
+      const schtasks = manifest.windows?.schtasks ?? "schtasks.exe";
+      const cwd = windowsCwd(ctx, manifest);
+      const queried = await ctx.run(
+        schtasks,
+        ["/Query", "/TN", manifest.windows?.taskPath ?? "", "/FO", "LIST", "/V"],
+        cwd
+      );
+      if (queried.code !== 0) return "Task Scheduler: task not found";
+      const fields = parseTaskQuery(queried.stdout);
+      return `Task Scheduler: ${fields.status ?? "unknown"}${fields.state ? `, ${fields.state.toLowerCase()}` : ""}${fields.lastResult ? `, last result: ${describeTaskResult(fields.lastResult)}` : ""}`;
+    }
+  }
+}
+__name(serviceState, "serviceState");
+async function startService(ctx, manifest) {
+  switch (manifest.platform) {
+    case "systemd-user":
+      return startSystemd(manifest.name, { run: ctx.run });
+    case "launchd": {
+      const agent = manifest.artifacts.find((a) => a.type === "launchd-agent");
+      if (agent?.type !== "launchd-agent") return ["no launchd agent in the manifest"];
+      const plist = manifest.artifacts.find((a) => a.type === "file");
+      await ctx.run("launchctl", ["enable", `${agent.domain}/${agent.label}`]);
+      const booted = await ctx.run("launchctl", [
+        "bootstrap",
+        agent.domain,
+        plist?.type === "file" ? plist.path : ""
+      ]);
+      if (booted.code === 0) return [];
+      const kicked = await ctx.run("launchctl", ["kickstart", `${agent.domain}/${agent.label}`]);
+      return kicked.code === 0 ? [] : [kicked.stderr.trim() || "launchctl kickstart failed"];
+    }
+    case "windows-task":
+    case "wsl-windows-task": {
+      const schtasks = manifest.windows?.schtasks ?? "schtasks.exe";
+      const cwd = windowsCwd(ctx, manifest);
+      const task = manifest.windows?.taskPath ?? "";
+      const enabled = await ctx.run(schtasks, ["/Change", "/TN", task, "/ENABLE"], cwd);
+      if (enabled.code !== 0) return [enabled.stderr.trim() || "schtasks /Change /ENABLE failed"];
+      const ran = await ctx.run(schtasks, ["/Run", "/TN", task], cwd);
+      return ran.code === 0 ? [] : [ran.stderr.trim() || "schtasks /Run failed"];
+    }
+  }
+}
+__name(startService, "startService");
+async function stopService(ctx, manifest) {
+  switch (manifest.platform) {
+    case "systemd-user":
+      return stopSystemd(manifest.name, { run: ctx.run });
+    case "launchd": {
+      const agent = manifest.artifacts.find((a) => a.type === "launchd-agent");
+      if (agent?.type !== "launchd-agent") return ["no launchd agent in the manifest"];
+      const disabled = await ctx.run("launchctl", ["disable", `${agent.domain}/${agent.label}`]);
+      const out = await ctx.run("launchctl", ["bootout", `${agent.domain}/${agent.label}`]);
+      if (disabled.code !== 0) return [disabled.stderr.trim() || "launchctl disable failed"];
+      return out.code === 0 ? [] : [out.stderr.trim() || "launchctl bootout failed"];
+    }
+    case "windows-task":
+    case "wsl-windows-task": {
+      const schtasks = manifest.windows?.schtasks ?? "schtasks.exe";
+      const cwd = windowsCwd(ctx, manifest);
+      const task = manifest.windows?.taskPath ?? "";
+      const disabled = await ctx.run(schtasks, ["/Change", "/TN", task, "/DISABLE"], cwd);
+      await ctx.run(schtasks, ["/End", "/TN", task], cwd);
+      return disabled.code === 0 ? [] : [disabled.stderr.trim() || "schtasks /Change /DISABLE failed"];
+    }
+  }
+}
+__name(stopService, "stopService");
+
+// src/schedule/service/names.ts
+import { createHash } from "node:crypto";
+import { homedir as homedir3 } from "node:os";
+import { join as join5, resolve } from "node:path";
+var SERVICE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,62}$/;
+function defaultServiceName(namzuHome, osHome = homedir3()) {
+  if (resolve(namzuHome) === resolve(join5(osHome, ".namzu"))) return "namzu-scheduler";
+  const h8 = createHash("sha256").update(resolve(namzuHome)).digest("hex").slice(0, 8);
+  return `namzu-scheduler-${h8}`;
+}
+__name(defaultServiceName, "defaultServiceName");
+function checkServiceName(name) {
+  if (!SERVICE_NAME.test(name)) {
+    throw new Error(
+      `"${name}" is not a service name: letters, digits, dot, dash and underscore only`
+    );
+  }
+  return name;
+}
+__name(checkServiceName, "checkServiceName");
+
+// src/schedule/service/runner.ts
+import { execFile as execFile2 } from "node:child_process";
+var runCommand = /* @__PURE__ */ __name((command, args, options = {}) => new Promise((resolve2) => {
+  execFile2(
+    command,
+    [...args],
+    {
+      timeout: options.timeoutMs ?? 3e4,
+      windowsHide: true,
+      maxBuffer: 4 * 1024 * 1024,
+      ...options.cwd ? { cwd: options.cwd } : {},
+      ...options.env ? { env: options.env } : {},
+      encoding: "buffer"
+    },
+    (error, stdout, stderr) => {
+      const code = error ? typeof error.code === "number" ? error.code : 127 : 0;
+      resolve2({ code, stdout: decode(stdout), stderr: decode(stderr) });
+    }
+  );
+}), "runCommand");
+function decode(buffer) {
+  if (typeof buffer === "string") return buffer;
+  if (buffer.length >= 2 && buffer[0] === 255 && buffer[1] === 254)
+    return buffer.subarray(2).toString("utf16le");
+  if (buffer.length >= 4 && buffer[1] === 0 && buffer[3] === 0) return buffer.toString("utf16le");
+  return buffer.toString("utf8");
+}
+__name(decode, "decode");
+
+// src/schedule/commands/service.ts
+var PLATFORMS = [
+  "auto",
+  "systemd-user",
+  "launchd",
+  "windows-task",
+  "wsl-windows-task"
+];
+function installedBin() {
+  const here = dirname3(fileURLToPath(new URL("../", import.meta.url).href + "schedule/commands/service.js"));
+  const candidate = join6(here, "..", "..", "bin.js");
+  try {
+    return realpathSync(candidate);
+  } catch {
+    return realpathSync(process.argv[1] ?? candidate);
+  }
+}
+__name(installedBin, "installedBin");
+function program(paths) {
+  return { node: realpathSync(process.execPath), bin: installedBin(), namzuHome: paths.home };
+}
+__name(program, "program");
+async function installCommand(ctx, argv) {
+  const args = parseArgs(argv, ["home", "platform", "name", "at-boot!", "dry-run!"]);
+  const platformFlag = flag(args, "platform") ?? "auto";
+  if (args.unknown.length > 0 || !PLATFORMS.includes(platformFlag)) {
+    ctx.formatter.error({
+      message: `usage: namzu schedule install [--platform ${PLATFORMS.join("|")}] [--name <n>] [--at-boot] [--dry-run]`
+    });
+    return EXIT_USAGE;
+  }
+  const paths = pathsFor(args);
+  let platform;
+  if (platformFlag === "auto") {
+    const detected = detectPlatform({
+      systemdUser: await systemdUserAvailable({ run: runCommand })
+    });
+    if (!detected.platform) {
+      ctx.formatter.error({ message: detected.reason });
+      return EXIT_UNAVAILABLE;
+    }
+    platform = detected.platform;
+  } else platform = platformFlag;
+  const name = checkServiceName(flag(args, "name") ?? defaultServiceName(paths.home));
+  const prog = program(paths);
+  if (has(args, "dry-run")) {
+    let text;
+    switch (platform) {
+      case "systemd-user":
+        text = systemdUnit(prog);
+        break;
+      case "launchd":
+        text = launchdPlist(launchdLabel(name), prog);
+        break;
+      case "windows-task":
+        text = taskXml({
+          userId: "DOMAIN\\user",
+          description: "namzu scheduler",
+          command: "C:\\Windows\\System32\\conhost.exe",
+          args: ["--headless", prog.node, prog.bin, "schedule", "daemon", "--home", prog.namzuHome]
+        });
+        break;
+      case "wsl-windows-task":
+        text = taskXml(
+          wslTaskDefinition({
+            userId: "DOMAIN\\user",
+            distro: process.env.WSL_DISTRO_NAME ?? "distro",
+            linuxUser: process.env.USER ?? "user",
+            ...prog
+          })
+        );
+        break;
+    }
+    ctx.formatter.print({ text, platform, name });
+    return EXIT_OK;
+  }
+  const existing = readManifest(paths);
+  if (existing && existing.name !== name && existing.platform !== platform) {
+    ctx.formatter.error({
+      message: `a scheduler service (${existing.name}, ${existing.platform}) is already installed for this home; uninstall it first`
+    });
+    return 1;
+  }
+  try {
+    requestStop(paths, false);
+    const { manifest, problems, notes } = await installService(
+      { paths, run: runCommand, env: process.env, version: CLI_VERSION },
+      { platform, name, program: prog, atBoot: has(args, "at-boot") }
+    );
+    for (const note of notes) ctx.formatter.info(note);
+    if (problems.length > 0) {
+      ctx.formatter.error({ message: `installed with problems:
+${problems.join("\n")}` });
+      return 1;
+    }
+    ctx.formatter.print({
+      text: `Installed ${manifest.name} (${manifest.platform}). Check it with \`namzu schedule status\`.`,
+      platform: manifest.platform,
+      name: manifest.name
+    });
+    return EXIT_OK;
+  } catch (error) {
+    ctx.formatter.error({ message: error instanceof Error ? error.message : String(error) });
+    return error instanceof ServiceRefusal ? EXIT_UNAVAILABLE : 1;
+  }
+}
+__name(installCommand, "installCommand");
+function runsInFlight(paths) {
+  let n = 0;
+  for (const job of listJobs(paths).jobs) {
+    const run = readState(paths, job.id).activeRun;
+    if (run?.status === "running" && !isFinal(readRunResult(paths, job.id, run.runId))) n++;
+  }
+  return n;
+}
+__name(runsInFlight, "runsInFlight");
+async function uninstallCommand(ctx, argv) {
+  const args = parseArgs(argv, ["home", "keep-data!", "purge-data!", "wait", "interrupt-runs!"]);
+  if (args.unknown.length > 0 || has(args, "keep-data") && has(args, "purge-data")) {
+    ctx.formatter.error({
+      message: "usage: namzu schedule uninstall [--keep-data | --purge-data] [--wait 10m | --interrupt-runs]"
+    });
+    return EXIT_USAGE;
+  }
+  const paths = pathsFor(args);
+  const manifest = readManifest(paths);
+  const endpoint = readEndpoint(paths.endpoint);
+  requestStop(paths, true);
+  if (endpoint) await callEndpoint(endpoint, "stop");
+  if (manifest)
+    await stopService({ paths, run: runCommand, env: process.env, version: CLI_VERSION }, manifest);
+  if (!has(args, "interrupt-runs")) {
+    const waitMs = parseMs("--wait", flag(args, "wait")) ?? 10 * 6e4;
+    const deadline = Date.now() + waitMs;
+    while (runsInFlight(paths) > 0 && Date.now() < deadline) {
+      ctx.formatter.info(`waiting for ${runsInFlight(paths)} run(s) in progress to finish\u2026`);
+      await new Promise((r) => setTimeout(r, 5e3));
+    }
+  }
+  const inFlight = runsInFlight(paths);
+  if (inFlight > 0)
+    ctx.formatter.info(`${inFlight} run(s) are still in progress; they finish on their own.`);
+  const { problems } = await uninstallService({
+    paths,
+    run: runCommand,
+    env: process.env,
+    version: CLI_VERSION
+  });
+  if (problems.length > 0) {
+    ctx.formatter.error({ message: `could not remove everything:
+${problems.join("\n")}` });
+    return 1;
+  }
+  if (has(args, "purge-data")) rmSync4(paths.root, { recursive: true, force: true });
+  ctx.formatter.print({
+    text: manifest ? `Removed ${manifest.name}.${has(args, "purge-data") ? " Scheduler data deleted." : " Jobs and history are kept."}` : `No scheduler service was installed for ${paths.home}.${has(args, "purge-data") ? " Scheduler data deleted." : ""}`
+  });
+  return EXIT_OK;
+}
+__name(uninstallCommand, "uninstallCommand");
+function readHeartbeat(paths) {
+  try {
+    return JSON.parse(readFileSync2(paths.heartbeat, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+__name(readHeartbeat, "readHeartbeat");
+function daemonNotifications(heartbeat, live) {
+  const reported = typeof live?.notifications === "string" ? live.notifications : heartbeat?.notifications;
+  if (!reported || reported === "unknown") return void 0;
+  const at = reported.indexOf(": ");
+  return at < 0 ? { kind: reported, detail: "" } : { kind: reported.slice(0, at), detail: reported.slice(at + 2) };
+}
+__name(daemonNotifications, "daemonNotifications");
+async function statusCommand(ctx, argv) {
+  const args = parseArgs(argv, ["home", "json!"]);
+  if (args.unknown.length > 0) {
+    ctx.formatter.error({ message: `unknown option: ${args.unknown.join(", ")}` });
+    return EXIT_USAGE;
+  }
+  const paths = pathsFor(args);
+  const manifest = readManifest(paths);
+  const heartbeat = readHeartbeat(paths);
+  const endpoint = readEndpoint(paths.endpoint);
+  const live = endpoint ? await callEndpoint(endpoint, "status") : void 0;
+  const age = heartbeat ? Date.now() - Date.parse(heartbeat.at) : void 0;
+  const supervisor = manifest ? await serviceState(
+    { paths, run: runCommand, env: process.env, version: CLI_VERSION },
+    manifest
+  ) : "not installed";
+  const jobs = listJobs(paths).jobs;
+  const backend = daemonNotifications(heartbeat, live) ?? {
+    ...selectDesktopBackend(
+      manifest?.windows?.powershell ? { powershell: manifest.windows.powershell } : {}
+    ),
+    guessed: true
+  };
+  const pathProblems = [];
+  if (manifest) {
+    for (const [label, path] of [
+      ["node", manifest.nodePath],
+      ["namzu", manifest.binPath]
+    ]) {
+      try {
+        realpathSync(path);
+      } catch {
+        pathProblems.push(`${label} ${path} no longer exists; run namzu schedule install again`);
+      }
+    }
+    if (manifest.cliVersion !== CLI_VERSION)
+      pathProblems.push(
+        `installed by namzu ${manifest.cliVersion}, this is ${CLI_VERSION}; the daemon restarts on the new code by itself`
+      );
+  }
+  const healthy = Boolean(live) || age !== void 0 && age < 9e4;
+  const awaitingApproval = jobs.flatMap((job) => {
+    const run = readState(paths, job.id).activeRun;
+    return run?.status === "awaiting-approval" && run.sessionId ? [
+      {
+        job: job.name,
+        sessionId: run.sessionId,
+        resumeCommand: resumeCommand(job, run.sessionId),
+        ...run.handoff ? { handoff: { reason: run.handoff.reason } } : {},
+        waitingFor: parkedRunWords(run)
+      }
+    ] : [];
+  });
+  const payload = {
+    v: 1,
+    installed: Boolean(manifest),
+    platform: manifest?.platform ?? null,
+    name: manifest?.name ?? null,
+    supervisor,
+    daemon: live ? { responding: true, ...live } : heartbeat ? {
+      responding: false,
+      lastSeen: heartbeat.at,
+      standby: heartbeat.standby,
+      pid: heartbeat.pid,
+      version: heartbeat.version
+    } : null,
+    notifications: `${backend.kind} (${backend.detail})${"guessed" in backend ? " \u2014 the daemon has not reported, so this is what this shell would pick" : ""}`,
+    jobs: { total: jobs.length, active: jobs.filter((j) => j.state === "active").length },
+    runsInFlight: runsInFlight(paths),
+    awaitingApproval,
+    problems: pathProblems,
+    log: daemonLogPath(paths.daemonLog)
+  };
+  if (has(args, "json") || ctx.formatter.name !== "text") {
+    ctx.formatter.print(ctx.formatter.name === "text" ? JSON.stringify(payload, null, 2) : payload);
+  } else {
+    ctx.formatter.print(
+      [
+        `Service        ${manifest ? `${manifest.name} (${manifest.platform})` : "not installed \u2014 namzu schedule install"}`,
+        `Supervisor     ${supervisor}`,
+        `Daemon         ${live ? `running, pid ${String(live.pid)}, version ${String(live.version)}${live.standby ? ", on standby" : ""}${live.draining ? ", draining for a restart" : ""}` : heartbeat ? `not answering; last seen ${Math.round((age ?? 0) / 1e3)} s ago${heartbeat.standby ? " (on standby)" : ""}` : "never started"}`,
+        `Notifications  ${backend.kind}${backend.kind === "none" ? ` \u2014 ${backend.detail}` : ""}${"guessed" in backend ? " (not reported by the daemon yet; this shell would pick it)" : ""}`,
+        `Jobs           ${payload.jobs.active} active of ${payload.jobs.total}; ${payload.runsInFlight} run(s) in progress`,
+        ...awaitingApproval.map(
+          (w) => w.handoff ? `Waiting        ${w.job} ${w.waitingFor}; when that is done: ${w.resumeCommand}` : `Waiting        ${w.job} needs your approval: ${w.resumeCommand}`
+        ),
+        `Log            ${payload.log}`,
+        ...pathProblems.map((p) => `Warning        ${p}`)
+      ].join("\n")
+    );
+  }
+  if (!manifest && !live) return EXIT_NO_CONFIG;
+  return healthy ? EXIT_OK : EXIT_UNAVAILABLE;
+}
+__name(statusCommand, "statusCommand");
+async function startStopCommand(ctx, argv, verb) {
+  const args = parseArgs(argv, ["home"]);
+  const paths = pathsFor(args);
+  const manifest = readManifest(paths);
+  if (!manifest) {
+    ctx.formatter.error({
+      message: "no scheduler service is installed for this home; namzu schedule install"
+    });
+    return EXIT_NO_CONFIG;
+  }
+  const context = { paths, run: runCommand, env: process.env, version: CLI_VERSION };
+  requestStop(paths, verb === "stop");
+  const problems = verb === "start" ? await startService(context, manifest) : await stopService(context, manifest);
+  if (verb === "stop") {
+    const endpoint = readEndpoint(paths.endpoint);
+    if (endpoint) await callEndpoint(endpoint, "stop");
+  }
+  if (problems.length > 0) {
+    ctx.formatter.error({ message: problems.join("\n") });
+    return 1;
+  }
+  ctx.formatter.print({
+    text: verb === "start" ? `Started ${manifest.name}.` : `Stopped ${manifest.name}; it stays stopped until namzu schedule start.`
+  });
+  return EXIT_OK;
+}
+__name(startStopCommand, "startStopCommand");
+async function daemonCommand(ctx, argv) {
+  const args = parseArgs(argv, ["home", "foreground!", "once-or-exit!"]);
+  if (args.unknown.length > 0) {
+    ctx.formatter.error({ message: `unknown option: ${args.unknown.join(", ")}` });
+    return EXIT_USAGE;
+  }
+  const paths = pathsFor(args);
+  process.env.NAMZU_HOME = paths.home;
+  const config = (() => {
+    try {
+      return loadBootstrapConfigWithProvenance({ env: process.env }).config;
+    } catch {
+      return ctx.config;
+    }
+  })();
+  installCliLogging(daemonLogSink(paths.daemonLog), "info");
+  const log = cliLogger();
+  const manifest = (() => {
+    try {
+      return readManifest(paths);
+    } catch {
+      return void 0;
+    }
+  })();
+  const backend = selectDesktopBackend(
+    manifest?.windows?.powershell ? { powershell: manifest.windows.powershell } : {}
+  );
+  const bin = installedBin();
+  if (existsSync5(stopRequestPath(paths))) {
+    ctx.formatter.error({
+      message: `the scheduler for ${paths.home} was stopped with \`namzu schedule stop\`; \`namzu schedule start\` lets it run again`
+    });
+    return EXIT_STOP_REQUESTED;
+  }
+  const daemon = new ScheduleDaemon({
+    paths,
+    log,
+    version: CLI_VERSION,
+    epoch: randomUUID(),
+    maxConcurrentRuns: config.schedule?.maxConcurrentRuns ?? 2,
+    notifications: config.schedule?.notifications ?? true,
+    notificationBackend: `${backend.kind}: ${backend.detail}`,
+    spawnFire: spawnFireProcess({ node: process.execPath, bin, paths, env: process.env }),
+    notify: /* @__PURE__ */ __name(async (notice) => {
+      const result = await sendDesktopNotification(backend, notice);
+      if (result.kind !== "sent") {
+        log.warn("scheduled run notification not shown", {
+          "namzu.schedule.job_id": notice.jobId,
+          "namzu.schedule.notify_result": result.kind
+        });
+      }
+    }, "notify"),
+    fingerprint: installedFingerprint(bin),
+    onceOrExit: has(args, "once-or-exit")
+  });
+  const stop = /* @__PURE__ */ __name(() => daemon.stop(), "stop");
+  process.on("SIGTERM", stop);
+  process.on("SIGINT", stop);
+  process.on("SIGHUP", stop);
+  log.info("scheduler starting", {
+    "namzu.schedule.home": paths.home,
+    "namzu.schedule.version": CLI_VERSION
+  });
+  try {
+    const code = await daemon.run();
+    if (code === 75) {
+      const endpoint = readEndpoint(paths.endpoint);
+      ctx.formatter.error({
+        message: `another scheduler owns ${paths.home}${endpoint ? ` (pid ${endpoint.pid})` : ""}`
+      });
+    }
+    return code;
+  } finally {
+    process.removeListener("SIGTERM", stop);
+    process.removeListener("SIGINT", stop);
+    process.removeListener("SIGHUP", stop);
+  }
+}
+__name(daemonCommand, "daemonCommand");
+async function fireCommand(ctx, argv, termination) {
+  const args = parseArgs(argv, [
+    "home",
+    "job",
+    "run",
+    "key",
+    "revision",
+    "trigger",
+    "scheduled-for",
+    "epoch"
+  ]);
+  const parsed = parseFireArgs(argv);
+  if ("error" in parsed || args.unknown.length > 0) {
+    ctx.formatter.error({
+      message: "error" in parsed ? parsed.error : `unknown option: ${args.unknown.join(", ")}`
+    });
+    return EXIT_USAGE;
+  }
+  const paths = pathsFor(args);
+  const fire = parsed;
+  termination?.onTerminate(async (signal) => {
+    const current = readRunResult(paths, fire.jobId, fire.runId);
+    if (current && current.status === "running") {
+      writeRunResult(paths, {
+        ...current,
+        status: "interrupted",
+        exitCode: 1,
+        reason: `stopped by ${signal}`,
+        endedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  });
+  return runFire(ctx, paths, fire);
+}
+__name(fireCommand, "fireCommand");
+export {
+  daemonCommand,
+  fireCommand,
+  installCommand,
+  installedBin,
+  startStopCommand,
+  statusCommand,
+  uninstallCommand
+};
+//# sourceMappingURL=service-YBU5VTKQ.js.map