@dinoxx/dinox-cli 2.5.2 → 2.7.0

package/dist/daemon/server.js

@@ -1,6 +1,8 @@
 import crypto from 'node:crypto';
 import { createServer } from 'http';
 import { chmodSync, existsSync } from 'node:fs';
+import { DAEMON_SERVICE_ENV } from './supervisor.js';
+import { writeDaemonLogLine } from './log.js';
 import { loadConfig } from '../config/store.js';
 import { fingerprintDaemonRuntimeConfig, resolveConfig } from '../config/resolve.js';
 import { hydrateResolvedAuthIdentity } from '../auth/userInfo.js';
@@ -17,6 +19,10 @@ import { getDaemonInfo } from './client.js';
 import { GatewayService } from '../gateway/service.js';
 import { readConversation } from '../gateway/conversationContext.js';
 const MAX_DAEMON_REQUEST_BYTES = 1 * 1024 * 1024;
+function daemonSupervisor() {
+    const value = process.env[DAEMON_SERVICE_ENV];
+    return value === 'launchd' || value === 'systemd' || value === 'schtasks' ? value : null;
+}
 const DAEMON_PROCESS_VERSION = getPackageVersion();
 async function readJsonBody(req) {
     return new Promise((resolve, reject) => {
@@ -97,7 +103,7 @@ export class DaemonServer {
                 credentialsUrl: process.env.DINOX_NATS_CREDENTIALS_URL || undefined,
             });
             await this.gateways.start().catch((error) => {
-                process.stderr.write(`[dinox-gateway] start failed: ${String(error)}\n`);
+                writeDaemonLogLine('dinox-gateway', 'start failed', { error: String(error) });
             });
         }
         // PowerSync keeps the local cache in sync continuously while connected,
@@ -125,6 +131,7 @@ export class DaemonServer {
                             tokenFingerprint: this.tokenFingerprint,
                             runtimeConfigFingerprint: this.runtimeConfigFingerprint,
                             authenticated: Boolean(this.userId && this.tokenFingerprint),
+                            supervisor: daemonSupervisor(),
                         },
                     };
                 case 'shutdown': {

package/dist/daemon/supervise.d.ts

@@ -0,0 +1,29 @@
+import { type ChildProcess } from 'node:child_process';
+/** First restart delay after a crash; doubles per consecutive crash. */
+export declare const SUPERVISE_INITIAL_BACKOFF_MS = 1000;
+export declare const SUPERVISE_MAX_BACKOFF_MS = 60000;
+/** A daemon that ran this long counts as healthy, so the next crash restarts quickly again. */
+export declare const SUPERVISE_HEALTHY_RUN_MS = 60000;
+export type SupervisedExit = {
+    code: number | null;
+    signal: NodeJS.Signals | null;
+};
+export type SuperviseDependencies = {
+    startChild: () => ChildProcess;
+    sleep: (ms: number) => Promise<void>;
+    now: () => number;
+    log: (message: string, details?: Record<string, unknown>) => void;
+    /** Registers a handler for a stop request (signal); the loop then stops the child and returns. */
+    onStopRequest: (handler: () => void) => void;
+};
+/**
+ * Keeps one daemon running, the way launchd's KeepAlive.SuccessfulExit=false
+ * and systemd's Restart=on-failure do: restarts it after a crash with an
+ * exponential backoff, and returns once it exits cleanly (exit code 0 from
+ * `dino daemon stop`, an identity restart, or a stop for exclusive DB access)
+ * or when asked to stop. Used where the service manager cannot restart the
+ * daemon itself (Windows Task Scheduler).
+ */
+export declare function superviseDaemon(deps: SuperviseDependencies): Promise<number>;
+/** Runs the supervisor for this CLI's daemon until it exits cleanly or is signalled. */
+export declare function superviseCurrentDaemon(port: number): Promise<number>;

package/dist/daemon/supervise.js

@@ -0,0 +1,98 @@
+import { spawn } from 'node:child_process';
+import { appendDaemonLogLine, closeDaemonLogFd, openDaemonLogForChild } from './log.js';
+/** First restart delay after a crash; doubles per consecutive crash. */
+export const SUPERVISE_INITIAL_BACKOFF_MS = 1_000;
+export const SUPERVISE_MAX_BACKOFF_MS = 60_000;
+/** A daemon that ran this long counts as healthy, so the next crash restarts quickly again. */
+export const SUPERVISE_HEALTHY_RUN_MS = 60_000;
+function waitForExit(child) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const settle = (exit) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(exit);
+        };
+        child.once('exit', (code, signal) => settle({ code, signal }));
+        // A child that cannot be spawned at all counts as a crash.
+        child.once('error', () => settle({ code: 1, signal: null }));
+    });
+}
+/**
+ * Keeps one daemon running, the way launchd's KeepAlive.SuccessfulExit=false
+ * and systemd's Restart=on-failure do: restarts it after a crash with an
+ * exponential backoff, and returns once it exits cleanly (exit code 0 from
+ * `dino daemon stop`, an identity restart, or a stop for exclusive DB access)
+ * or when asked to stop. Used where the service manager cannot restart the
+ * daemon itself (Windows Task Scheduler).
+ */
+export async function superviseDaemon(deps) {
+    let stopping = false;
+    let current = null;
+    let wakeSleep = null;
+    deps.onStopRequest(() => {
+        stopping = true;
+        current?.kill('SIGTERM');
+        wakeSleep?.();
+    });
+    let backoffMs = SUPERVISE_INITIAL_BACKOFF_MS;
+    while (!stopping) {
+        const startedAt = deps.now();
+        const child = deps.startChild();
+        current = child;
+        deps.log('daemon started', { pid: child.pid ?? null });
+        const exit = await waitForExit(child);
+        current = null;
+        if (stopping)
+            break;
+        if (exit.code === 0) {
+            deps.log('daemon exited cleanly; supervisor stopping');
+            return 0;
+        }
+        if (deps.now() - startedAt >= SUPERVISE_HEALTHY_RUN_MS)
+            backoffMs = SUPERVISE_INITIAL_BACKOFF_MS;
+        deps.log('daemon crashed; restarting', { code: exit.code, signal: exit.signal, delayMs: backoffMs });
+        await Promise.race([
+            deps.sleep(backoffMs),
+            new Promise((resolve) => {
+                wakeSleep = resolve;
+            }),
+        ]);
+        wakeSleep = null;
+        backoffMs = Math.min(backoffMs * 2, SUPERVISE_MAX_BACKOFF_MS);
+    }
+    deps.log('supervisor stopped on request');
+    return 0;
+}
+/** Runs the supervisor for this CLI's daemon until it exits cleanly or is signalled. */
+export async function superviseCurrentDaemon(port) {
+    const entrypoint = process.argv[1];
+    if (!entrypoint)
+        throw new Error('Cannot determine the CLI entrypoint for the daemon');
+    // Launched hidden at logon there is no console, so write to the log file directly.
+    const log = (message, details) => appendDaemonLogLine('dinox-supervisor', message, details);
+    return superviseDaemon({
+        startChild: () => {
+            const logFd = openDaemonLogForChild();
+            try {
+                return spawn(process.execPath, [...process.execArgv, entrypoint, 'daemon', 'start', '--port', String(port), '--no-detach'], 
+                // Same (already clean) environment, which carries the service marker.
+                { stdio: ['ignore', logFd, logFd], env: process.env, windowsHide: true });
+            }
+            finally {
+                closeDaemonLogFd(logFd);
+            }
+        },
+        sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+        now: () => Date.now(),
+        log,
+        onStopRequest: (handler) => {
+            for (const signal of ['SIGINT', 'SIGTERM', 'SIGBREAK']) {
+                process.on(signal, handler);
+            }
+            // Like the daemon, never stop on a hangup.
+            process.on('SIGHUP', () => undefined);
+        },
+    });
+}

package/dist/daemon/supervisor.d.ts

@@ -0,0 +1,75 @@
+/**
+ * A service manager that owns the daemon process. Without one, the daemon is a
+ * detached child of whatever ran the first `dino` command; when that was a
+ * coding agent, the agent's host may reap it together with the session and
+ * every gateway goes offline. Under launchd / systemd the daemon belongs to
+ * the login session instead, starts at login, and is restarted after a crash.
+ *
+ * Restart policy is "on failure" only: a clean exit (`dino daemon stop`, a
+ * version/account restart, exclusive DB access for `doctor`) leaves it
+ * stopped until the CLI starts it again through the manager. launchd and
+ * systemd restart the daemon themselves; on Windows, Task Scheduler only
+ * starts `dino daemon supervise`, which restarts it (see supervise.ts).
+ */
+export type DaemonServiceKind = 'launchd' | 'systemd' | 'schtasks';
+export type DaemonServiceSpec = {
+    program: string;
+    args: string[];
+    env: Record<string, string>;
+    workingDirectory: string;
+    logPath: string;
+};
+export type ServiceCommandResult = {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+export type ServiceCommandRunner = (command: string, args: string[]) => Promise<ServiceCommandResult>;
+export type DaemonService = {
+    readonly kind: DaemonServiceKind;
+    readonly label: string;
+    readonly definitionPath: string;
+    render(spec: DaemonServiceSpec): string;
+    isInstalled(): boolean;
+    /** True when the installed definition is exactly what this CLI would write. */
+    isCurrent(spec: DaemonServiceSpec): boolean;
+    /** Writes the definition and (re)loads it, which starts the daemon. */
+    install(spec: DaemonServiceSpec): Promise<void>;
+    /** Starts the installed daemon when it is not running. */
+    start(): Promise<void>;
+    /** Stops the daemon and removes the definition; false when nothing was installed. */
+    uninstall(): Promise<boolean>;
+};
+/** Set in the service definition so the daemon can report who supervises it. */
+export declare const DAEMON_SERVICE_ENV = "DINOX_DAEMON_SUPERVISOR";
+export declare const runServiceCommand: ServiceCommandRunner;
+/**
+ * One daemon per data directory (it owns that directory's socket), so a
+ * non-default `DINOX_DATA_DIR` gets its own service.
+ */
+export declare function daemonServiceLabel(env?: NodeJS.ProcessEnv): string;
+export declare function renderLaunchdPlist(label: string, spec: DaemonServiceSpec): string;
+export declare function renderSystemdUnit(spec: DaemonServiceSpec): string;
+/** Quotes one argument the way CommandLineToArgvW (and so Node) parses it back. */
+export declare function quoteWindowsArg(value: string): string;
+/**
+ * Task Scheduler runs console programs in a visible window, so the task runs
+ * this script with wscript, which sets the daemon environment and starts the
+ * supervisor with a hidden window (the launcher pattern pm2-windows-startup
+ * uses). The supervisor then outlives the script.
+ */
+export declare function renderWindowsLauncher(spec: DaemonServiceSpec): string;
+export declare function renderWindowsTaskXml(userId: string, wscriptPath: string, launcherPath: string): string;
+export type DaemonServiceOptions = {
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+    uid?: number;
+    run?: ServiceCommandRunner;
+    /** Windows: where the launcher script lives (the daemon directory). */
+    launcherDir?: string;
+    /** Windows: `DOMAIN\\user` the logon task runs as. */
+    windowsUserId?: string;
+};
+/** The service manager for this platform, or null where none is supported. */
+export declare function getDaemonService(options?: DaemonServiceOptions): DaemonService | null;

package/dist/daemon/supervisor.js

@@ -0,0 +1,441 @@
+import crypto from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { getDataDir } from '../config/paths.js';
+import { DinoxError } from '../utils/errors.js';
+/** Set in the service definition so the daemon can report who supervises it. */
+export const DAEMON_SERVICE_ENV = 'DINOX_DAEMON_SUPERVISOR';
+const DEFAULT_LABEL = 'com.dinox.cli.daemon';
+const COMMAND_TIMEOUT_MS = 15_000;
+const LAUNCHD_BOOTSTRAP_ATTEMPTS = 5;
+const LAUNCHD_BOOTSTRAP_RETRY_MS = 300;
+export const runServiceCommand = (command, args) => new Promise((resolve) => {
+    execFile(command, args, { timeout: COMMAND_TIMEOUT_MS, encoding: 'utf8' }, (error, stdout, stderr) => {
+        const code = error ? (typeof error.code === 'number' ? error.code : 1) : 0;
+        resolve({ code, stdout: stdout ?? '', stderr: stderr ?? (error ? String(error.message) : '') });
+    });
+});
+/**
+ * One daemon per data directory (it owns that directory's socket), so a
+ * non-default `DINOX_DATA_DIR` gets its own service.
+ */
+export function daemonServiceLabel(env = process.env) {
+    if (!env.DINOX_DATA_DIR)
+        return DEFAULT_LABEL;
+    const hash = crypto.createHash('sha256').update(getDataDir(), 'utf8').digest('hex').slice(0, 8);
+    return `${DEFAULT_LABEL}.${hash}`;
+}
+function failed(kind, step, result) {
+    const output = (result.stderr || result.stdout).trim();
+    return new DinoxError(`${kind} ${step} failed${output ? `: ${output}` : ''}`, {
+        code: 'DAEMON_SERVICE_FAILED',
+        details: { service: kind, step, exitCode: result.code },
+    });
+}
+function writeDefinition(definitionPath, content) {
+    mkdirSync(path.dirname(definitionPath), { recursive: true });
+    writeFileSync(definitionPath, content, { mode: 0o644 });
+}
+function readDefinition(definitionPath, encoding = 'utf8') {
+    try {
+        return readFileSync(definitionPath, encoding);
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------- launchd
+function xmlEscape(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+export function renderLaunchdPlist(label, spec) {
+    const string = (value) => `<string>${xmlEscape(value)}</string>`;
+    const args = [spec.program, ...spec.args].map((arg) => `\t\t${string(arg)}`).join('\n');
+    const env = Object.keys(spec.env)
+        .sort()
+        .map((name) => `\t\t<key>${xmlEscape(name)}</key>\n\t\t${string(spec.env[name])}`)
+        .join('\n');
+    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>
+\t<key>Label</key>
+\t${string(label)}
+\t<key>ProgramArguments</key>
+\t<array>
+${args}
+\t</array>
+\t<key>EnvironmentVariables</key>
+\t<dict>
+${env}
+\t</dict>
+\t<key>WorkingDirectory</key>
+\t${string(spec.workingDirectory)}
+\t<key>RunAtLoad</key>
+\t<true/>
+\t<key>KeepAlive</key>
+\t<dict>
+\t\t<key>SuccessfulExit</key>
+\t\t<false/>
+\t</dict>
+\t<key>ThrottleInterval</key>
+\t<integer>30</integer>
+\t<key>StandardOutPath</key>
+\t${string(spec.logPath)}
+\t<key>StandardErrorPath</key>
+\t${string(spec.logPath)}
+</dict>
+</plist>
+`;
+}
+class LaunchdService {
+    label;
+    run;
+    kind = 'launchd';
+    definitionPath;
+    domain;
+    target;
+    constructor(label, run, homeDir, uid) {
+        this.label = label;
+        this.run = run;
+        this.definitionPath = path.join(homeDir, 'Library', 'LaunchAgents', `${label}.plist`);
+        this.domain = `gui/${uid}`;
+        this.target = `${this.domain}/${label}`;
+    }
+    render(spec) {
+        return renderLaunchdPlist(this.label, spec);
+    }
+    isInstalled() {
+        return existsSync(this.definitionPath);
+    }
+    isCurrent(spec) {
+        return readDefinition(this.definitionPath) === this.render(spec);
+    }
+    async isLoaded() {
+        return (await this.run('launchctl', ['print', this.target])).code === 0;
+    }
+    async bootstrap() {
+        // bootout returns before launchd has fully released the label, so a
+        // bootstrap right after it can fail transiently.
+        let result = null;
+        for (let attempt = 0; attempt < LAUNCHD_BOOTSTRAP_ATTEMPTS; attempt += 1) {
+            result = await this.run('launchctl', ['bootstrap', this.domain, this.definitionPath]);
+            if (result.code === 0)
+                return;
+            await new Promise((resolve) => setTimeout(resolve, LAUNCHD_BOOTSTRAP_RETRY_MS));
+        }
+        throw failed(this.kind, 'bootstrap', result);
+    }
+    async install(spec) {
+        if (await this.isLoaded())
+            await this.run('launchctl', ['bootout', this.target]);
+        writeDefinition(this.definitionPath, this.render(spec));
+        await this.bootstrap();
+    }
+    async start() {
+        if (!(await this.isLoaded())) {
+            await this.bootstrap();
+            return;
+        }
+        const result = await this.run('launchctl', ['kickstart', this.target]);
+        if (result.code !== 0)
+            throw failed(this.kind, 'kickstart', result);
+    }
+    async uninstall() {
+        const installed = this.isInstalled();
+        if (await this.isLoaded()) {
+            const result = await this.run('launchctl', ['bootout', this.target]);
+            if (result.code !== 0 && (await this.isLoaded()))
+                throw failed(this.kind, 'bootout', result);
+        }
+        if (installed)
+            unlinkSync(this.definitionPath);
+        return installed;
+    }
+}
+// ---------------------------------------------------------------- systemd
+/** Quotes one word for a systemd command line or assignment value. */
+function systemdQuote(value) {
+    const escaped = value
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/%/g, '%%')
+        .replace(/\$/g, '$$$$')
+        .replace(/\n/g, '\\n');
+    return `"${escaped}"`;
+}
+export function renderSystemdUnit(spec) {
+    const execStart = [spec.program, ...spec.args].map(systemdQuote).join(' ');
+    const env = Object.keys(spec.env)
+        .sort()
+        .map((name) => `Environment=${systemdQuote(`${name}=${spec.env[name]}`)}`)
+        .join('\n');
+    return `[Unit]
+Description=Dinox CLI daemon
+After=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${execStart}
+WorkingDirectory=${spec.workingDirectory.replace(/%/g, '%%')}
+${env}
+Restart=on-failure
+RestartSec=30
+StandardOutput=append:${spec.logPath}
+StandardError=append:${spec.logPath}
+
+[Install]
+WantedBy=default.target
+`;
+}
+class SystemdService {
+    label;
+    run;
+    kind = 'systemd';
+    definitionPath;
+    unit;
+    constructor(label, run, configHome) {
+        this.label = label;
+        this.run = run;
+        this.unit = `${label}.service`;
+        this.definitionPath = path.join(configHome, 'systemd', 'user', this.unit);
+    }
+    render(spec) {
+        return renderSystemdUnit(spec);
+    }
+    isInstalled() {
+        return existsSync(this.definitionPath);
+    }
+    isCurrent(spec) {
+        return readDefinition(this.definitionPath) === this.render(spec);
+    }
+    async systemctl(step, ...args) {
+        const result = await this.run('systemctl', ['--user', ...args]);
+        if (result.code !== 0)
+            throw failed(this.kind, step, result);
+    }
+    async install(spec) {
+        writeDefinition(this.definitionPath, this.render(spec));
+        await this.systemctl('daemon-reload', 'daemon-reload');
+        await this.systemctl('enable', 'enable', this.unit);
+        await this.systemctl('restart', 'restart', this.unit);
+    }
+    async start() {
+        await this.systemctl('start', 'start', this.unit);
+    }
+    async uninstall() {
+        if (!this.isInstalled())
+            return false;
+        await this.run('systemctl', ['--user', 'disable', '--now', this.unit]);
+        unlinkSync(this.definitionPath);
+        await this.run('systemctl', ['--user', 'daemon-reload']);
+        return true;
+    }
+}
+// ---------------------------------------------------------------- Windows
+/** Quotes one argument the way CommandLineToArgvW (and so Node) parses it back. */
+export function quoteWindowsArg(value) {
+    if (value !== '' && !/[\s"]/.test(value))
+        return value;
+    let quoted = '"';
+    let backslashes = 0;
+    for (const char of value) {
+        if (char === '\\') {
+            backslashes += 1;
+            continue;
+        }
+        if (char === '"') {
+            quoted += '\\'.repeat(backslashes * 2 + 1) + '"';
+        }
+        else {
+            quoted += '\\'.repeat(backslashes) + char;
+        }
+        backslashes = 0;
+    }
+    return `${quoted}${'\\'.repeat(backslashes * 2)}"`;
+}
+function vbsString(value) {
+    return `"${value.replace(/"/g, '""').replace(/\r?\n/g, '" & vbLf & "')}"`;
+}
+/**
+ * Task Scheduler runs console programs in a visible window, so the task runs
+ * this script with wscript, which sets the daemon environment and starts the
+ * supervisor with a hidden window (the launcher pattern pm2-windows-startup
+ * uses). The supervisor then outlives the script.
+ */
+export function renderWindowsLauncher(spec) {
+    const commandLine = [spec.program, ...spec.args].map(quoteWindowsArg).join(' ');
+    const env = Object.keys(spec.env)
+        .sort()
+        .map((name) => `env(${vbsString(name)}) = ${vbsString(spec.env[name])}`)
+        .join('\r\n');
+    return [
+        "' Generated by `dino daemon install`; rewritten when the CLI changes.",
+        'Set shell = CreateObject("WScript.Shell")',
+        'Set env = shell.Environment("Process")',
+        env,
+        `shell.CurrentDirectory = ${vbsString(spec.workingDirectory)}`,
+        `shell.Run ${vbsString(commandLine)}, 0, False`,
+        '',
+    ].join('\r\n');
+}
+export function renderWindowsTaskXml(userId, wscriptPath, launcherPath) {
+    return `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>Dinox CLI daemon (dino daemon install)</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+      <UserId>${xmlEscape(userId)}</UserId>
+    </LogonTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <UserId>${xmlEscape(userId)}</UserId>
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <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>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <Priority>7</Priority>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>${xmlEscape(wscriptPath)}</Command>
+      <Arguments>${xmlEscape(`//B //Nologo ${quoteWindowsArg(launcherPath)}`)}</Arguments>
+    </Exec>
+  </Actions>
+</Task>
+`;
+}
+/** UTF-16LE with a BOM: what schtasks /XML expects and how wscript reads non-ASCII paths. */
+function writeUtf16(filePath, content) {
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    writeFileSync(filePath, Buffer.concat([Buffer.from([0xff, 0xfe]), Buffer.from(content, 'utf16le')]));
+}
+function readUtf16(filePath) {
+    const content = readDefinition(filePath, 'utf16le');
+    return content === null ? null : content.replace(/^\uFEFF/, '');
+}
+class WindowsTaskService {
+    label;
+    run;
+    launcherDir;
+    wscriptPath;
+    userId;
+    kind = 'schtasks';
+    definitionPath;
+    taskName;
+    constructor(label, run, launcherDir, wscriptPath, userId) {
+        this.label = label;
+        this.run = run;
+        this.launcherDir = launcherDir;
+        this.wscriptPath = wscriptPath;
+        this.userId = userId;
+        this.taskName = `Dinox\\${label}`;
+        this.definitionPath = path.join(launcherDir, `${label}.vbs`);
+    }
+    render(spec) {
+        return renderWindowsLauncher(spec);
+    }
+    isInstalled() {
+        return existsSync(this.definitionPath);
+    }
+    isCurrent(spec) {
+        return readUtf16(this.definitionPath) === this.render(spec);
+    }
+    async isRegistered() {
+        return (await this.run('schtasks', ['/Query', '/TN', this.taskName])).code === 0;
+    }
+    async register() {
+        if (!existsSync(this.wscriptPath)) {
+            throw new DinoxError(`Windows Script Host (${this.wscriptPath}) is not available, so the daemon cannot start hidden at logon.`, {
+                code: 'DAEMON_SERVICE_UNSUPPORTED',
+                details: { reason: 'wscript-missing' },
+            });
+        }
+        const xmlPath = path.join(this.launcherDir, `${this.label}.task.xml`);
+        writeUtf16(xmlPath, renderWindowsTaskXml(this.userId, this.wscriptPath, this.definitionPath));
+        try {
+            const result = await this.run('schtasks', ['/Create', '/TN', this.taskName, '/XML', xmlPath, '/F']);
+            if (result.code !== 0)
+                throw failed(this.kind, 'create', result);
+        }
+        finally {
+            try {
+                unlinkSync(xmlPath);
+            }
+            catch {
+                // Already gone.
+            }
+        }
+    }
+    async runTask() {
+        const result = await this.run('schtasks', ['/Run', '/TN', this.taskName]);
+        if (result.code !== 0)
+            throw failed(this.kind, 'run', result);
+    }
+    async install(spec) {
+        writeUtf16(this.definitionPath, this.render(spec));
+        await this.register();
+        await this.runTask();
+    }
+    async start() {
+        if (!(await this.isRegistered()))
+            await this.register();
+        await this.runTask();
+    }
+    async uninstall() {
+        const installed = this.isInstalled();
+        if (await this.isRegistered()) {
+            const result = await this.run('schtasks', ['/Delete', '/TN', this.taskName, '/F']);
+            if (result.code !== 0)
+                throw failed(this.kind, 'delete', result);
+        }
+        if (installed)
+            unlinkSync(this.definitionPath);
+        return installed;
+    }
+}
+/** The service manager for this platform, or null where none is supported. */
+export function getDaemonService(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    const homeDir = options.homeDir ?? os.homedir();
+    const run = options.run ?? runServiceCommand;
+    const label = daemonServiceLabel(env);
+    if (platform === 'darwin') {
+        return new LaunchdService(label, run, homeDir, options.uid ?? process.getuid?.() ?? 0);
+    }
+    if (platform === 'linux') {
+        return new SystemdService(label, run, env.XDG_CONFIG_HOME || path.join(homeDir, '.config'));
+    }
+    if (platform === 'win32') {
+        const systemRoot = env.SystemRoot || env.SYSTEMROOT || 'C:\\Windows';
+        const user = env.USERNAME || os.userInfo().username;
+        return new WindowsTaskService(label, run, options.launcherDir ?? path.join(getDataDir(), 'daemon'), path.join(systemRoot, 'System32', 'wscript.exe'), options.windowsUserId ?? (env.USERDOMAIN ? `${env.USERDOMAIN}\\${user}` : user));
+    }
+    return null;
+}