@parall/daemon 1.43.0 → 1.45.0

package/dist/supervisor.js

@@ -1799,7 +1799,10 @@ export class DaemonSupervisor {
         child.once('error', (err) => {
             if (err.code === 'ENOENT') {
                 if (adapter.args.length > 0) {
-                    this.log.error(`Node runtime "${adapter.bin}" not found — is the Desktop app installed?`);
+                    // Overlay / entry-sibling resolution: bin is the node executable
+                    // and args[0] is the bridge bundle js that just resolved on disk.
+                    this.log.error(`Node runtime "${adapter.bin}" not found while launching ${adapter.args[0]} — ` +
+                        `reinstall the daemon (npm install -g @parall/daemon) or the Desktop app`);
                 }
                 else {
                     const pkg = RUNTIME_PACKAGES[state.runtimeType] ?? `@parall/${state.runtimeType}-agent`;

package/dist/win-lifecycle.d.ts

@@ -0,0 +1,96 @@
+import { type WinServicePaths } from './win-service.js';
+/**
+ * Windows service lifecycle operations (stop / uninstall / probes) with
+ * injected command execution and filesystem, so every failure mode —
+ * CIM query failure, access denied, kill failure, task-delete failure —
+ * unit-tests on any platform. cli.ts binds the real execFileSync/fs.
+ *
+ * Fail-closed contract (PR #1876 round 2): tracking state (pidfile,
+ * daemon-running marker) and service artifacts are removed ONLY after the
+ * relevant facts are POSITIVELY confirmed — task disabled/deleted, process
+ * exited. Any indeterminate probe (query failed, unreadable identity)
+ * keeps the state on disk and surfaces as a problem + non-zero exit;
+ * "could not check" is never treated as "gone".
+ */
+/** One external command execution; implementations must never throw. */
+export interface WinCmdResult {
+    /** Process exit code; null = the command could not be spawned at all. */
+    code: number | null;
+    stdout: string;
+    spawnError?: string;
+}
+export type WinCmdRunner = (file: string, args: string[]) => WinCmdResult;
+export interface WinFsOps {
+    /** null on any read error (missing file included). */
+    readFile(p: string): string | null;
+    /** true when the file is gone afterwards (missing counts); false on failure. */
+    unlink(p: string): boolean;
+}
+export interface WinLifecycleDeps {
+    run: WinCmdRunner;
+    fs: WinFsOps;
+    paths: WinServicePaths;
+    sleep(ms: number): void;
+    now(): number;
+}
+export interface WinOpResult {
+    ok: boolean;
+    problems: string[];
+}
+/**
+ * Three-state process identity:
+ * - 'daemon'        — pid exists AND is a Node process running our launcher
+ * - 'not-daemon'    — pid does not exist, or verifiably belongs to something
+ *                     else (our tracked process has therefore exited)
+ * - 'indeterminate' — the question could not be answered (query failed, or
+ *                     the process exists but its identity is unreadable) —
+ *                     callers MUST fail closed on this
+ */
+export type PidIdentity = 'daemon' | 'not-daemon' | 'indeterminate';
+export declare function probePidIdentity(deps: WinLifecycleDeps, pid: number): PidIdentity;
+export declare function readTrackedPid(deps: WinLifecycleDeps): number | null;
+/**
+ * Task registration state, three-state and locale-safe.
+ *
+ * NOT schtasks: `schtasks /Query` exits non-zero for "no such task" AND for
+ * access-denied / RPC-unavailable alike, and its error text is localized — so
+ * an exit-code probe silently reads a permissions failure as "not installed",
+ * which would let stop skip the disable guard and let uninstall wipe tracking
+ * state for a task that is still very much registered. That is a fail-open
+ * hole in a module whose whole contract is fail-closed.
+ *
+ * Get-ScheduledTask raises a typed ObjectNotFound error for a missing task and
+ * a different category for everything else, so the three states are actually
+ * distinguishable. Emitted as an ASCII token, never parsed from a message.
+ */
+export declare function queryTaskExists(deps: WinLifecycleDeps): boolean | 'indeterminate';
+/**
+ * Disabled-state readback from /Query /XML — tag names are English on every
+ * locale. Our generated triggers are always <Enabled>true</Enabled>, so any
+ * false Enabled means the task itself is disabled.
+ */
+export declare function queryTaskDisabled(deps: WinLifecycleDeps): boolean | 'indeterminate';
+/**
+ * Stop: disable the task (so no trigger resurrects it), confirm the disabled
+ * readback, best-effort /End, then positively confirm the tracked process is
+ * gone. Tracking files are removed only when every fact is confirmed.
+ *
+ * Disabling is a GUARD, not a step — so every one of its failure modes aborts
+ * immediately, before anything is terminated (same contract as uninstall). If
+ * the task state cannot be read, the /Change fails (access denied), or the
+ * readback is not `disabled`, then a trigger — the hourly revival one, or the
+ * logon one — is still free to relaunch the daemon. Killing the process in
+ * that state would make a failed stop destructive: it could interrupt the
+ * daemon while leaving the task armed to relaunch it. Fail closed and leave
+ * tracking state untouched instead.
+ */
+export declare function stopDaemonWindows(deps: WinLifecycleDeps): WinOpResult;
+/**
+ * Uninstall: full stop semantics first — DISABLE (so no trigger can relaunch
+ * the daemon between the process-exit confirmation and /Delete, which would
+ * strand an orphan with no task left to manage it), /End, confirmed process
+ * exit — then /Delete with a confirmed disappearance readback, then artifact
+ * cleanup. Any unconfirmed step aborts before state is destroyed.
+ */
+export declare function uninstallDaemonWindows(deps: WinLifecycleDeps): WinOpResult;
+//# sourceMappingURL=win-lifecycle.d.ts.map

package/dist/win-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"win-lifecycle.d.ts","sourceRoot":"","sources":["../src/win-lifecycle.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEvE;;;;;;;;;;;;GAYG;AAEH,wEAAwE;AACxE,MAAM,WAAW,YAAY;IAC3B,yEAAyE;IACzE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AACD,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,YAAY,CAAC;AAE1E,MAAM,WAAW,QAAQ;IACvB,sDAAsD;IACtD,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACnC,gFAAgF;IAChF,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,YAAY,CAAC;IAClB,EAAE,EAAE,QAAQ,CAAC;IACb,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,GAAG,IAAI,MAAM,CAAC;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,OAAO,CAAC;IACZ,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,YAAY,GAAG,eAAe,CAAC;AAEpE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,gBAAgB,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,CAwBjF;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,gBAAgB,GAAG,MAAM,GAAG,IAAI,CAKpE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,GAAG,eAAe,CAUjF;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,GAAG,eAAe,CAInF;AAkDD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,gBAAgB,GAAG,WAAW,CAoCrE;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,gBAAgB,GAAG,WAAW,CA+D1E"}

package/dist/win-lifecycle.js

@@ -0,0 +1,229 @@
+import * as path from 'node:path';
+import { WIN_TASK_NAME } from './win-service.js';
+export function probePidIdentity(deps, pid) {
+    // pid comes from readPidFile (validated positive integer) — safe to
+    // interpolate. [char]9 = TAB without backtick-escape pitfalls.
+    const script = `$p = Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}'; ` +
+        `if ($null -eq $p) { 'ABSENT' } else { 'PRESENT' + [char]9 + $p.Name + [char]9 + "$($p.CommandLine)" }`;
+    const r = deps.run('powershell.exe', ['-NoProfile', '-Command', script]);
+    if (r.code !== 0 || r.spawnError)
+        return 'indeterminate';
+    const out = r.stdout.trim();
+    if (out === 'ABSENT')
+        return 'not-daemon';
+    if (!out.startsWith('PRESENT\t'))
+        return 'indeterminate';
+    const [, name = '', ...rest] = out.split('\t');
+    const commandLine = rest.join('\t').trim();
+    // Identity = expected image name AND our launcher path on the command
+    // line. The extension-less needle covers the current .cjs launcher and the
+    // legacy .js one (pre-.cjs installs may still be running).
+    if (!/node/i.test(name))
+        return 'not-daemon';
+    if (!commandLine) {
+        // Node-named process whose command line we cannot read (e.g. access
+        // denied on an elevated process): could be ours — fail closed.
+        return 'indeterminate';
+    }
+    const launcherNeedle = path.join(deps.paths.serviceDir, 'parall-daemon-launcher').toLowerCase();
+    return commandLine.toLowerCase().includes(launcherNeedle) ? 'daemon' : 'not-daemon';
+}
+export function readTrackedPid(deps) {
+    const raw = deps.fs.readFile(deps.paths.pidFile);
+    if (raw === null)
+        return null;
+    const pid = Number(raw.trim());
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+}
+/**
+ * Task registration state, three-state and locale-safe.
+ *
+ * NOT schtasks: `schtasks /Query` exits non-zero for "no such task" AND for
+ * access-denied / RPC-unavailable alike, and its error text is localized — so
+ * an exit-code probe silently reads a permissions failure as "not installed",
+ * which would let stop skip the disable guard and let uninstall wipe tracking
+ * state for a task that is still very much registered. That is a fail-open
+ * hole in a module whose whole contract is fail-closed.
+ *
+ * Get-ScheduledTask raises a typed ObjectNotFound error for a missing task and
+ * a different category for everything else, so the three states are actually
+ * distinguishable. Emitted as an ASCII token, never parsed from a message.
+ */
+export function queryTaskExists(deps) {
+    const script = `try { Get-ScheduledTask -TaskName '${WIN_TASK_NAME}' -ErrorAction Stop | Out-Null; 'PRESENT' } ` +
+        `catch { if ($_.CategoryInfo.Category -eq 'ObjectNotFound') { 'ABSENT' } else { 'ERROR' } }`;
+    const r = deps.run('powershell.exe', ['-NoProfile', '-Command', script]);
+    if (r.code !== 0 || r.spawnError)
+        return 'indeterminate';
+    const out = r.stdout.trim();
+    if (out === 'PRESENT')
+        return true;
+    if (out === 'ABSENT')
+        return false;
+    return 'indeterminate';
+}
+/**
+ * Disabled-state readback from /Query /XML — tag names are English on every
+ * locale. Our generated triggers are always <Enabled>true</Enabled>, so any
+ * false Enabled means the task itself is disabled.
+ */
+export function queryTaskDisabled(deps) {
+    const r = deps.run('schtasks', ['/Query', '/TN', WIN_TASK_NAME, '/XML']);
+    if (r.code !== 0 || r.spawnError)
+        return 'indeterminate';
+    return /<Enabled>\s*false\s*<\/Enabled>/i.test(r.stdout);
+}
+const PROCESS_EXIT_TIMEOUT_MS = 5_000;
+const PROCESS_EXIT_POLL_MS = 200;
+/**
+ * Confirm the tracked process is gone, killing it first when it is
+ * positively ours. Appends to `problems` and returns false on anything
+ * indeterminate — the caller must then keep the pidfile.
+ */
+function confirmProcessGone(deps, problems) {
+    const pid = readTrackedPid(deps);
+    if (pid === null)
+        return true; // nothing tracked
+    let identity = probePidIdentity(deps, pid);
+    if (identity === 'not-daemon')
+        return true; // stale pidfile — daemon already exited
+    if (identity === 'indeterminate') {
+        problems.push(`cannot verify ownership of pid ${pid} (process query failed) — leaving the pidfile in place`);
+        return false;
+    }
+    const kill = deps.run('taskkill', ['/T', '/F', '/PID', String(pid)]);
+    const deadline = deps.now() + PROCESS_EXIT_TIMEOUT_MS;
+    for (;;) {
+        identity = probePidIdentity(deps, pid);
+        if (identity === 'not-daemon')
+            return true;
+        if (identity === 'indeterminate') {
+            problems.push(`process query failed while confirming pid ${pid} exited`);
+            return false;
+        }
+        if (deps.now() >= deadline) {
+            problems.push(`daemon process ${pid} is still running after taskkill` +
+                (kill.code !== 0 ? ` (taskkill exit ${kill.code ?? 'spawn-failed'})` : ''));
+            return false;
+        }
+        deps.sleep(PROCESS_EXIT_POLL_MS);
+    }
+}
+function cleanupTracking(deps, problems) {
+    if (!deps.fs.unlink(deps.paths.pidFile)) {
+        problems.push(`could not remove pidfile ${deps.paths.pidFile}`);
+    }
+    if (!deps.fs.unlink(deps.paths.runningMarker)) {
+        problems.push(`could not remove crash marker ${deps.paths.runningMarker}`);
+    }
+}
+/**
+ * Stop: disable the task (so no trigger resurrects it), confirm the disabled
+ * readback, best-effort /End, then positively confirm the tracked process is
+ * gone. Tracking files are removed only when every fact is confirmed.
+ *
+ * Disabling is a GUARD, not a step — so every one of its failure modes aborts
+ * immediately, before anything is terminated (same contract as uninstall). If
+ * the task state cannot be read, the /Change fails (access denied), or the
+ * readback is not `disabled`, then a trigger — the hourly revival one, or the
+ * logon one — is still free to relaunch the daemon. Killing the process in
+ * that state would make a failed stop destructive: it could interrupt the
+ * daemon while leaving the task armed to relaunch it. Fail closed and leave
+ * tracking state untouched instead.
+ */
+export function stopDaemonWindows(deps) {
+    const problems = [];
+    const exists = queryTaskExists(deps);
+    if (exists === 'indeterminate') {
+        problems.push('schtasks could not be executed to query the task');
+        return { ok: false, problems };
+    }
+    if (exists) {
+        const disable = deps.run('schtasks', ['/Change', '/TN', WIN_TASK_NAME, '/DISABLE']);
+        if (disable.code !== 0) {
+            problems.push(`could not disable the task (schtasks /Change exit ${disable.code ?? 'spawn-failed'})`);
+            return { ok: false, problems };
+        }
+        const disabled = queryTaskDisabled(deps);
+        if (disabled !== true) {
+            problems.push(disabled === 'indeterminate'
+                ? 'could not read back the task state after disabling'
+                : 'task did not read back as disabled');
+            return { ok: false, problems };
+        }
+        // Best-effort accelerator only: its failure modes ("no running
+        // instance" vs anything else) are locale-dependent text, and process
+        // exit is independently confirmed below — so the result is ignored.
+        deps.run('schtasks', ['/End', '/TN', WIN_TASK_NAME]);
+    }
+    // Task confirmed absent or confirmed disabled: nothing can relaunch the
+    // daemon behind us, so terminating the tracked process is safe.
+    if (!confirmProcessGone(deps, problems)) {
+        return { ok: false, problems };
+    }
+    cleanupTracking(deps, problems);
+    return { ok: problems.length === 0, problems };
+}
+/**
+ * Uninstall: full stop semantics first — DISABLE (so no trigger can relaunch
+ * the daemon between the process-exit confirmation and /Delete, which would
+ * strand an orphan with no task left to manage it), /End, confirmed process
+ * exit — then /Delete with a confirmed disappearance readback, then artifact
+ * cleanup. Any unconfirmed step aborts before state is destroyed.
+ */
+export function uninstallDaemonWindows(deps) {
+    const problems = [];
+    const exists = queryTaskExists(deps);
+    if (exists === 'indeterminate') {
+        problems.push('schtasks could not be executed to query the task');
+        return { ok: false, problems };
+    }
+    if (exists) {
+        // Disable BEFORE terminating: the hourly revival TimeTrigger (and the
+        // logon trigger) would otherwise be free to start a fresh instance in
+        // the gap between the exit confirmation below and /Delete — a daemon the
+        // deleted task can no longer stop.
+        const disable = deps.run('schtasks', ['/Change', '/TN', WIN_TASK_NAME, '/DISABLE']);
+        if (disable.code !== 0) {
+            problems.push(`could not disable the task before uninstalling (schtasks /Change exit ${disable.code ?? 'spawn-failed'})`);
+            return { ok: false, problems };
+        }
+        const disabled = queryTaskDisabled(deps);
+        if (disabled !== true) {
+            problems.push(disabled === 'indeterminate'
+                ? 'could not read back the task state after disabling'
+                : 'task did not read back as disabled before uninstall');
+            return { ok: false, problems };
+        }
+        deps.run('schtasks', ['/End', '/TN', WIN_TASK_NAME]); // best-effort, see stop
+    }
+    if (!confirmProcessGone(deps, problems)) {
+        return { ok: false, problems };
+    }
+    if (exists) {
+        const del = deps.run('schtasks', ['/Delete', '/TN', WIN_TASK_NAME, '/F']);
+        if (del.code !== 0) {
+            problems.push(`could not delete the task (schtasks /Delete exit ${del.code ?? 'spawn-failed'})`);
+            return { ok: false, problems };
+        }
+        const stillThere = queryTaskExists(deps);
+        if (stillThere !== false) {
+            problems.push(stillThere === 'indeterminate'
+                ? 'could not confirm the task was deleted'
+                : 'task is still registered after /Delete');
+            return { ok: false, problems };
+        }
+    }
+    cleanupTracking(deps, problems);
+    for (const artifact of [
+        deps.paths.launcherCjs,
+        deps.paths.legacyLauncherJs,
+        deps.paths.launcherVbs,
+        deps.paths.taskXml,
+    ]) {
+        if (!deps.fs.unlink(artifact)) {
+            problems.push(`could not remove ${artifact}`);
+        }
+    }
+    return { ok: problems.length === 0, problems };
+}

package/dist/win-service.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Windows service (Task Scheduler) artifact generation. Everything here is a
+ * pure function from paths to strings so the whole surface unit-tests on any
+ * platform; cli.ts owns filesystem writes and schtasks invocations.
+ *
+ * The chain at run time:
+ *   Task Scheduler → wscript.exe //B launcher.vbs
+ *     → vbs Run("node.exe launcher.js", 0, True)   — window hidden, waits,
+ *       propagates the exit code via WScript.Quit
+ *       → launcher.js sets PRLL_DAEMON_MANAGED=1, writes the pidfile,
+ *         redirects stdio to the log file, then imports the daemon bundle
+ *         IN-PROCESS (overlay-first) — so the pid in the pidfile IS the
+ *         daemon and a self-update exit(42) is the task's own exit code,
+ *         which RestartOnFailure turns into a restart on the new overlay.
+ */
+export declare const WIN_TASK_NAME = "ParallDaemon";
+export interface WinServicePaths {
+    serviceDir: string;
+    /**
+     * .cjs, deliberately: the launcher is CommonJS (require) and a package.json
+     * with "type": "module" anywhere up the tree (e.g. a user's ~/package.json)
+     * would flip a .js file into ESM scope and break require() at startup.
+     * .cjs is CommonJS regardless of ancestor package.json files.
+     */
+    launcherCjs: string;
+    /** Pre-.cjs installs wrote this name; install/uninstall clean it up. */
+    legacyLauncherJs: string;
+    launcherVbs: string;
+    taskXml: string;
+    pidFile: string;
+    logDir: string;
+    logFile: string;
+    /**
+     * Canonical single-env overlay entry (~/.parall-daemon/bundle/current/...).
+     * Deliberately NOT PRLL_DAEMON_CONFIG_DIR-aware — the CLI service installer
+     * is single-env by design, mirroring the launchd/systemd wrappers (see
+     * ts/daemon/AGENTS.md, config-dir scope caveat).
+     */
+    overlayEntry: string;
+    /** Crash marker the bootstrap writes; intentional stops must clear it. */
+    runningMarker: string;
+}
+export declare function winServicePaths(home: string): WinServicePaths;
+/**
+ * VBScript string literal: wrap in quotes, escape embedded quotes by
+ * doubling. NTFS forbids `"` in file names, so real paths never exercise
+ * the escape — it exists as defense-in-depth for arbitrary strings.
+ */
+export declare function vbsQuote(value: string): string;
+/**
+ * Encode a generated artifact as UTF-16LE with a BOM. wscript reads BOM-less
+ * files in the ANSI codepage (mangling non-ASCII profile paths) and schtasks'
+ * canonical XML form is UTF-16 — both .vbs and task.xml go through this.
+ */
+export declare function encodeUtf16LeBom(content: string): Buffer;
+export declare function xmlEscape(value: string): string;
+/**
+ * The hidden-window launcher. `Run(cmd, 0, True)`: 0 hides the console
+ * window (a console app started by an interactive scheduled task would
+ * otherwise flash/persist one), True waits and yields the exit code, and
+ * WScript.Quit hands that code to Task Scheduler so RestartOnFailure sees
+ * daemon crashes and self-update exit(42)s.
+ *
+ * Caller must write this file as UTF-16LE with a BOM: wscript reads BOM-less
+ * files in the ANSI codepage, which mangles non-ASCII (e.g. Chinese
+ * user-profile) paths.
+ */
+export declare function buildLauncherVbs(p: {
+    nodeExe: string;
+    launcherCjs: string;
+}): string;
+/**
+ * The in-process daemon launcher. Embedded paths go through JSON.stringify,
+ * which handles backslashes and quotes; the file itself is plain UTF-8 (Node
+ * always reads JS as UTF-8, so non-ASCII paths round-trip).
+ *
+ * The content is CommonJS and the artifact is written as `.cjs` so an
+ * ancestor package.json with "type": "module" (users do npm-init their home
+ * directories) can never flip it into ESM scope.
+ */
+export declare function buildLauncherCjs(p: {
+    npmEntry: string;
+    overlayEntry: string;
+    pidFile: string;
+    logFile: string;
+}): string;
+/**
+ * Task Scheduler task definition.
+ *
+ * Element-order ground rules (Microsoft Task Scheduler schema docs):
+ * - trigger children (triggerBaseType) are an xs:sequence and MUST appear as
+ *   StartBoundary → EndBoundary → Enabled → Repetition → ExecutionTimeLimit
+ *   (learn.microsoft.com .../taskschedulerschema-timetrigger-triggergroup-element);
+ * - Settings children (settingsType) are an xs:all — order-insensitive;
+ * - RestartOnFailure Count is xs:unsignedByte (1–255)
+ *   (.../taskschedulerschema-count-restarttype-element).
+ *
+ * - LogonTrigger: start at user logon (no admin, no stored password:
+ *   InteractiveToken + omitted UserId registers for the calling user).
+ * - TimeTrigger PT1H: revival tick (StartBoundary is a fixed date safely in
+ *   the past — a boundary in the future would silently disarm the trigger on
+ *   a machine whose clock is behind) — if RestartOnFailure's count is ever
+ *   exhausted the daemon still comes back within the hour; IgnoreNew makes
+ *   it a no-op while an instance is running. `stop` disables the whole task,
+ *   so this trigger never resurrects an intentionally stopped daemon.
+ * - ExecutionTimeLimit PT0S: no 72h default kill.
+ * - RestartOnFailure PT1M/99: crash or self-update exit(42) restarts in
+ *   ~1 minute (PT1M is the schema minimum interval; 99 stays well inside the
+ *   unsignedByte cap). Note this makes Windows self-update restarts ~1min,
+ *   vs ~5s under launchd.
+ *
+ * Caller must write this as UTF-16LE with BOM to match the declared
+ * encoding — the canonical form schtasks itself produces on export.
+ */
+export declare function buildTaskXml(p: {
+    wscriptExe: string;
+    launcherVbs: string;
+}): string;
+//# sourceMappingURL=win-service.d.ts.map

package/dist/win-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"win-service.d.ts","sourceRoot":"","sources":["../src/win-service.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,aAAa,iBAAiB,CAAC;AAE5C,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB,wEAAwE;IACxE,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB,0EAA0E;IAC1E,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAgB7D;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAO/C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CASpF;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG,MAAM,CA6DT;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CA+CnF"}