@dinoxx/dinox-cli 2.13.1 → 2.15.0

package/dist/daemon/pid.js

@@ -5,6 +5,7 @@ import { join } from 'node:path';
 import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from 'node:fs';
 import { getDataDir } from '../config/paths.js';
 import { acquireExclusiveSqliteLease } from '../utils/sqliteLease.js';
+import { SUPERVISOR_STOP_MARKER } from './supervisor.js';
 const DAEMON_START_LOCK_TIMEOUT_MS = 10_000;
 const LEGACY_DAEMON_UPTIME_TOLERANCE_MS = 60_000;
 const execFileAsync = promisify(execFile);
@@ -190,3 +191,22 @@ export async function acquireDaemonStartLock(timeoutMs = DAEMON_START_LOCK_TIMEO
         createBusyError: () => new Error('Timed out waiting for daemon start lock'),
     });
 }
+/** Present while `dino daemon stop` wants the Windows supervisor to stay down. */
+export function getSupervisorStopMarkerPath() {
+    return join(getDaemonDir(), SUPERVISOR_STOP_MARKER);
+}
+/**
+ * Held by a command that needs the PowerSync database in-process, from before
+ * it stops the daemon until it has closed the database. A daemon the service
+ * manager respawns in between waits for it (see waitForDaemonExclusiveIntent).
+ */
+export async function acquireDaemonExclusiveIntentLock(timeoutMs = 30_000) {
+    ensureDaemonDir();
+    return acquireExclusiveSqliteLease({
+        lockPath: join(getDaemonDir(), 'daemon.exclusive.lock'),
+        timeoutMs,
+        maxWaitMs: timeoutMs,
+        pollIntervalMs: 50,
+        createBusyError: () => Object.assign(new Error('Timed out waiting for daemon exclusive intent lock'), { code: 'DAEMON_EXCLUSIVE_BUSY' }),
+    });
+}

package/dist/daemon/route.js

@@ -1,6 +1,7 @@
 import { sendDaemonRequest } from './client.js';
 import { ensureDaemonRunning } from './ensure.js';
 import { DinoxError } from '../utils/errors.js';
+import { localCommandExecution, requestContext } from '../utils/requestContext.js';
 /**
  * Default online reads use the long-lived daemon as the canonical DB owner. The
  * process-local path is only for explicit modes that require opening the cache here:
@@ -17,7 +18,7 @@ export function shouldUseDaemon(globals) {
  * receives a thin sender bound to the daemon; `localRun` opens its own db/sync path.
  */
 export async function routeRead(globals, daemonMethod, daemonParams, localRun) {
-    if (!shouldUseDaemon(globals)) {
+    if (requestContext.getStore()?.daemon || localCommandExecution.getStore() || !shouldUseDaemon(globals)) {
         return localRun();
     }
     try {

package/dist/daemon/server.d.ts

@@ -1,5 +1,14 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
 import type { DaemonRequest, DaemonResponse } from './types.js';
+import { type ConnectivityChange } from './connectivity.js';
+import type { ResolvedDinoxConfig } from '../config/types.js';
+import { connectPowerSync } from '../powersync/runtime.js';
+import { acquireDaemonExclusiveIntentLock } from './pid.js';
+/** EX_TEMPFAIL: the service manager restarts the daemon. */
+export declare const DAEMON_RESTART_EXIT_CODE = 75;
 export declare class DaemonServer {
+    private readonly options;
+    private config;
     private db;
     private server;
     private startTime;
@@ -12,11 +21,46 @@ export declare class DaemonServer {
     private ownsArtifacts;
     private releaseOwner;
     private stopPromise;
+    private healthTimer;
+    private connectivityTimer;
+    private reconnect;
+    private reconnecting;
+    private syncUnconfirmedSince;
     private gateways;
+    constructor(options?: {
+        runtime?: {
+            db: AbstractPowerSyncDatabase;
+            config: ResolvedDinoxConfig;
+        };
+        acquireIntentLock?: typeof acquireDaemonExclusiveIntentLock;
+        connect?: typeof connectPowerSync;
+        onStopRequested?: (reason: string, details?: Record<string, unknown>) => void | Promise<void>;
+    });
     initialize(): Promise<void>;
-    handleRequest(req: DaemonRequest): Promise<DaemonResponse>;
+    handleRequest(req: DaemonRequest, onProgress?: (text: string) => void): Promise<DaemonResponse>;
     private isCacheStale;
     start(port: number): Promise<void>;
     stop(): Promise<void>;
+    /**
+     * PowerSync reconnects on its own; a connection that stays failed for this
+     * long usually needs a fresh process (for example a rotated credential), so
+     * exit for the service manager to restart it.
+     */
+    private startHealthCheck;
+    private startConnectivityWatch;
+    /**
+     * After a wake from sleep or a network change the stream may be a dead
+     * connection that still reports "connected". Reconnect, and treat the cache
+     * as unconfirmed until a checkpoint completes on the new stream.
+     */
+    handleConnectivityChange(change: ConnectivityChange): Promise<void>;
+    /** The reconnect time while no checkpoint has completed since; null once confirmed. */
+    currentSyncUnconfirmedSince(): string | null;
     private stopInternal;
 }
+/**
+ * Blocks until no exclusive command holds the intent lock. A respawned
+ * daemon must not take the database from the command that just stopped it;
+ * the lease is released by the OS if that command dies.
+ */
+export declare function waitForDaemonExclusiveIntent(acquire?: typeof acquireDaemonExclusiveIntentLock): Promise<void>;

package/dist/daemon/server.js

@@ -2,6 +2,8 @@ import crypto from 'node:crypto';
 import { createServer } from 'http';
 import { chmodSync, existsSync } from 'node:fs';
 import path from 'node:path';
+import { CONNECTIVITY_CHECK_INTERVAL_MS, createConnectivityWatcher } from './connectivity.js';
+import { commandExecutionTarget } from './forward.js';
 import { DAEMON_SERVICE_ENV } from './supervisor.js';
 import { writeDaemonLogLine } from './log.js';
 import { loadConfig } from '../config/store.js';
@@ -12,14 +14,21 @@ import { executeNoteSearch } from '../commands/notes/repo.js';
 import { getNoteDetail } from '../commands/notes/repo/read.js';
 import { getBacklinks, getGraphStats, getOutlinks, getRelatedNotes } from '../commands/graph/repo.js';
 import { executeTodoSearch } from '../commands/todo/repo.js';
-import { ensureDaemonDir, getDaemonSocketPath, isProcessRunning, readPid, removePid, savePid, } from './pid.js';
+import { acquireDaemonExclusiveIntentLock, ensureDaemonDir, getDaemonSocketPath, isProcessRunning, readPid, removePid, savePid, } from './pid.js';
 import { getPackageVersion } from '../utils/version.js';
 import { syncNoteTokenIndex } from '../powersync/tokenIndex.js';
 import { buildStructuredErrorPayload, DinoxError } from '../utils/errors.js';
+import { requestContext } from '../utils/requestContext.js';
+import { runWithRequestId } from '../requests/store.js';
 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;
+const DAEMON_HEALTH_CHECK_INTERVAL_MS = 60_000;
+const DAEMON_STUCK_SYNC_RESTART_MS = 15 * 60_000;
+const DAEMON_INTENT_WAIT_CHUNK_MS = 30_000;
+/** EX_TEMPFAIL: the service manager restarts the daemon. */
+export const DAEMON_RESTART_EXIT_CODE = 75;
 function daemonSupervisor() {
     const value = process.env[DAEMON_SERVICE_ENV];
     return value === 'launchd' || value === 'systemd' || value === 'schtasks' ? value : null;
@@ -65,7 +74,12 @@ function validateLocalRequest(req) {
     }
     return { ok: true };
 }
+function isStreamedCommand(request) {
+    return request?.method === 'command.execute' && request.params?.stream === true;
+}
 export class DaemonServer {
+    options;
+    config = null;
     db = null;
     server = null;
     startTime = Date.now();
@@ -78,14 +92,30 @@ export class DaemonServer {
     ownsArtifacts = false;
     releaseOwner = null;
     stopPromise = null;
+    healthTimer = null;
+    connectivityTimer = null;
+    reconnect = null;
+    reconnecting = false;
+    syncUnconfirmedSince = null;
     gateways = null;
+    constructor(options = {}) {
+        this.options = options;
+        if (options.runtime) {
+            this.db = options.runtime.db;
+            this.config = options.runtime.config;
+        }
+    }
     async initialize() {
+        // Before reading config: an exclusive command (e.g. `auth login`) may be
+        // changing the saved identity while this respawned daemon waits.
+        await waitForDaemonExclusiveIntent(this.options.acquireIntentLock);
         const baseConfig = resolveConfig(await loadConfig());
         const { config } = await hydrateResolvedAuthIdentity(baseConfig, { timeoutMs: baseConfig.sync.timeoutMs });
+        this.config = config;
         this.userId = config.auth.userId ?? null;
         this.tokenFingerprint = config.auth.tokenFingerprint ?? null;
         this.runtimeConfigFingerprint = fingerprintDaemonRuntimeConfig(config);
-        const { db, releaseOwner } = await connectPowerSync({
+        const { db, releaseOwner, reconnect } = await (this.options.connect ?? connectPowerSync)({
             config,
             offline: false,
             timeoutMs: config.sync.timeoutMs,
@@ -94,6 +124,13 @@ export class DaemonServer {
         });
         this.db = db;
         this.releaseOwner = releaseOwner;
+        this.reconnect = reconnect ?? null;
+        if (process.env[DAEMON_SERVICE_ENV]) {
+            this.startHealthCheck(db);
+        }
+        if (this.reconnect) {
+            this.startConnectivityWatch();
+        }
         if (config.auth.userId && config.auth.authorization) {
             // Agent gateways share the daemon's PowerSync connection; a gateway
             // failure must never take the daemon down.
@@ -110,13 +147,51 @@ export class DaemonServer {
         // PowerSync keeps the local cache in sync continuously while connected,
         // so no background polling loop is needed here.
     }
-    async handleRequest(req) {
+    async handleRequest(req, onProgress) {
         try {
             if (!this.db) {
                 throw new Error('Database not initialized');
             }
             const { method, params } = req;
             switch (method) {
+                case 'command.execute': {
+                    const input = params;
+                    const valid = Boolean(input)
+                        && Array.isArray(input.argv)
+                        && input.argv.every((arg) => typeof arg === 'string')
+                        && typeof input.cwd === 'string'
+                        && path.isAbsolute(input.cwd)
+                        && typeof input.clientVersion === 'string'
+                        && commandExecutionTarget(input.argv) === 'daemon';
+                    if (!valid) {
+                        throw new DinoxError('Command cannot run inside the daemon.', { code: 'DAEMON_COMMAND_NOT_FORWARDABLE' });
+                    }
+                    if (!this.config)
+                        throw new Error('Daemon config not initialized');
+                    const context = {
+                        stdout: [],
+                        stderr: [],
+                        format: null,
+                        noticeProvider: null,
+                        cwd: input.cwd,
+                        ...(onProgress ? { onProgress } : {}),
+                        daemon: {
+                            db: this.db,
+                            config: this.config,
+                            syncUnconfirmedSince: () => this.currentSyncUnconfirmedSince(),
+                        },
+                    };
+                    const execute = async () => {
+                        // Load the command tree only when the request is not a replay.
+                        const { runCli } = await import('../runCli.js');
+                        const exitCode = await requestContext.run(context, () => runCli(input.argv));
+                        return { stdout: context.stdout.join(''), stderr: context.stderr.join(''), exitCode };
+                    };
+                    const result = input.requestId === undefined
+                        ? await execute()
+                        : await runWithRequestId(input.requestId, input.argv, execute);
+                    return { id: req.id, ok: true, result };
+                }
                 case 'ping':
                     return {
                         id: req.id,
@@ -149,7 +224,9 @@ export class DaemonServer {
                         });
                     }
                     const timer = setTimeout(() => {
-                        void this.stop().catch(() => undefined);
+                        void Promise.resolve().then(() => this.options.onStopRequested
+                            ? this.options.onStopRequested('shutdown-request', { requester: shutdownParams.requester })
+                            : this.stop()).catch(() => undefined);
                     }, 10);
                     timer.unref?.();
                     return { id: req.id, ok: true, result: { stopping: true, instanceId: this.instanceId } };
@@ -243,12 +320,24 @@ export class DaemonServer {
                 }
                 try {
                     const daemonReq = await readJsonBody(req);
+                    if (isStreamedCommand(daemonReq)) {
+                        res.writeHead(200, { 'Content-Type': 'application/x-ndjson' });
+                        const daemonRes = await this.handleRequest(daemonReq, (progress) => {
+                            res.write(`${JSON.stringify({ progress })}\n`);
+                        });
+                        res.end(JSON.stringify(daemonRes));
+                        return;
+                    }
                     const daemonRes = await this.handleRequest(daemonReq);
                     res.writeHead(200, { 'Content-Type': 'application/json' });
                     res.end(JSON.stringify(daemonRes));
                 }
                 catch (error) {
                     const message = error instanceof Error ? error.message : String(error);
+                    if (res.headersSent) {
+                        res.end(JSON.stringify({ ok: false, error: message }));
+                        return;
+                    }
                     const statusCode = message.includes('too large') ? 413 : 400;
                     res.writeHead(statusCode, { 'Content-Type': 'application/json' });
                     res.end(JSON.stringify({ ok: false, error: message }));
@@ -318,7 +407,83 @@ export class DaemonServer {
             }
         }
     }
+    /**
+     * PowerSync reconnects on its own; a connection that stays failed for this
+     * long usually needs a fresh process (for example a rotated credential), so
+     * exit for the service manager to restart it.
+     */
+    startHealthCheck(db) {
+        let stuckSince = null;
+        this.healthTimer = setInterval(() => {
+            const status = getStatusSnapshot(db);
+            const failing = !status.connected
+                && Boolean(status.dataFlowStatus.downloadError || status.dataFlowStatus.uploadError);
+            if (!failing) {
+                stuckSince = null;
+                return;
+            }
+            stuckSince ??= Date.now();
+            if (Date.now() - stuckSince < DAEMON_STUCK_SYNC_RESTART_MS)
+                return;
+            if (this.healthTimer)
+                clearInterval(this.healthTimer);
+            this.healthTimer = null;
+            void Promise.resolve(this.options.onStopRequested?.('powersync-stuck', { exitCode: DAEMON_RESTART_EXIT_CODE }))
+                .catch(() => undefined);
+        }, DAEMON_HEALTH_CHECK_INTERVAL_MS);
+        this.healthTimer.unref();
+    }
+    startConnectivityWatch() {
+        const watcher = createConnectivityWatcher({
+            onChange: (change) => void this.handleConnectivityChange(change),
+        });
+        this.connectivityTimer = setInterval(() => watcher.tick(), CONNECTIVITY_CHECK_INTERVAL_MS);
+        this.connectivityTimer.unref();
+    }
+    /**
+     * After a wake from sleep or a network change the stream may be a dead
+     * connection that still reports "connected". Reconnect, and treat the cache
+     * as unconfirmed until a checkpoint completes on the new stream.
+     */
+    async handleConnectivityChange(change) {
+        if (!this.reconnect || this.reconnecting)
+            return;
+        this.reconnecting = true;
+        this.syncUnconfirmedSince = new Date().toISOString();
+        writeDaemonLogLine('dinox-daemon', 'reconnecting sync stream', { reason: change });
+        try {
+            await this.reconnect();
+        }
+        catch (error) {
+            writeDaemonLogLine('dinox-daemon', 'reconnect failed', {
+                reason: change,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        finally {
+            this.reconnecting = false;
+        }
+    }
+    /** The reconnect time while no checkpoint has completed since; null once confirmed. */
+    currentSyncUnconfirmedSince() {
+        const since = this.syncUnconfirmedSince;
+        if (!since || !this.db)
+            return since;
+        const status = getStatusSnapshot(this.db);
+        // PowerSync reports checkpoint times with whole-second precision.
+        const sinceMs = Math.floor(Date.parse(since) / 1_000) * 1_000;
+        if (!this.reconnecting && status.connected && status.lastSyncedAt && Date.parse(status.lastSyncedAt) >= sinceMs) {
+            this.syncUnconfirmedSince = null;
+        }
+        return this.syncUnconfirmedSince;
+    }
     async stopInternal() {
+        if (this.healthTimer)
+            clearInterval(this.healthTimer);
+        this.healthTimer = null;
+        if (this.connectivityTimer)
+            clearInterval(this.connectivityTimer);
+        this.connectivityTimer = null;
         const gateways = this.gateways;
         this.gateways = null;
         await gateways?.stop().catch(() => undefined);
@@ -353,3 +518,26 @@ export class DaemonServer {
         }
     }
 }
+/**
+ * Blocks until no exclusive command holds the intent lock. A respawned
+ * daemon must not take the database from the command that just stopped it;
+ * the lease is released by the OS if that command dies.
+ */
+export async function waitForDaemonExclusiveIntent(acquire = acquireDaemonExclusiveIntentLock) {
+    let logged = false;
+    for (;;) {
+        try {
+            const release = await acquire(DAEMON_INTENT_WAIT_CHUNK_MS);
+            await release();
+            return;
+        }
+        catch (error) {
+            if (error.code !== 'DAEMON_EXCLUSIVE_BUSY')
+                throw error;
+            if (!logged) {
+                writeDaemonLogLine('dinox-daemon', 'waiting for exclusive Dinox command to finish');
+                logged = true;
+            }
+        }
+    }
+}

package/dist/daemon/supervise.d.ts

@@ -10,6 +10,7 @@ export type SupervisedExit = {
 };
 export type SuperviseDependencies = {
     startChild: () => ChildProcess;
+    isStopRequested: () => boolean;
     sleep: (ms: number) => Promise<void>;
     now: () => number;
     log: (message: string, details?: Record<string, unknown>) => void;
@@ -17,12 +18,11 @@ export type SuperviseDependencies = {
     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).
+ * Keeps one daemon running the way launchd's KeepAlive and systemd's
+ * Restart=always do: restarts it after every exit, with an exponential
+ * backoff for repeated crashes, until `dino daemon stop` leaves the stop
+ * marker or the supervisor is signalled. 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. */

package/dist/daemon/supervise.js

@@ -1,5 +1,7 @@
 import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
 import { appendDaemonLogLine, closeDaemonLogFd, openDaemonLogForChild } from './log.js';
+import { getSupervisorStopMarkerPath } from './pid.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;
@@ -20,12 +22,11 @@ function waitForExit(child) {
     });
 }
 /**
- * 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).
+ * Keeps one daemon running the way launchd's KeepAlive and systemd's
+ * Restart=always do: restarts it after every exit, with an exponential
+ * backoff for repeated crashes, until `dino daemon stop` leaves the stop
+ * marker or the supervisor is signalled. Used where the service manager
+ * cannot restart the daemon itself (Windows Task Scheduler).
  */
 export async function superviseDaemon(deps) {
     let stopping = false;
@@ -37,7 +38,7 @@ export async function superviseDaemon(deps) {
         wakeSleep?.();
     });
     let backoffMs = SUPERVISE_INITIAL_BACKOFF_MS;
-    while (!stopping) {
+    while (!stopping && !deps.isStopRequested()) {
         const startedAt = deps.now();
         const child = deps.startChild();
         current = child;
@@ -46,13 +47,13 @@ export async function superviseDaemon(deps) {
         current = null;
         if (stopping)
             break;
-        if (exit.code === 0) {
-            deps.log('daemon exited cleanly; supervisor stopping');
+        if (deps.isStopRequested()) {
+            deps.log('stop marker found; 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 });
+        deps.log('daemon exited; restarting', { code: exit.code, signal: exit.signal, delayMs: backoffMs });
         await Promise.race([
             deps.sleep(backoffMs),
             new Promise((resolve) => {
@@ -73,6 +74,7 @@ export async function superviseCurrentDaemon(port) {
     // 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({
+        isStopRequested: () => existsSync(getSupervisorStopMarkerPath()),
         startChild: () => {
             const logFd = openDaemonLogForChild();
             try {

package/dist/daemon/supervisor.d.ts

@@ -5,11 +5,11 @@
  * 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).
+ * Restart policy is "always": launchd KeepAlive, systemd Restart=always, and
+ * on Windows `dino daemon supervise` (Task Scheduler only starts it; see
+ * supervise.ts) bring the daemon back after any exit, including a clean one
+ * for exclusive DB access or a crash. Only `dino daemon stop` / `uninstall`,
+ * which go through stop() / uninstall() here, leave it down.
  */
 export type DaemonServiceKind = 'launchd' | 'systemd' | 'schtasks';
 export type DaemonServiceSpec = {
@@ -33,25 +33,41 @@ export type DaemonService = {
     isInstalled(): boolean;
     /** True when the installed definition is exactly what this CLI would write. */
     isCurrent(spec: DaemonServiceSpec): boolean;
+    /** The program and arguments the installed definition runs, or null when there is none. */
+    installedCommand(): string[] | null;
     /** 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 keeps it stopped until start() (or the next login). */
+    stop(): Promise<void>;
+    /** Restarts it now, skipping restart throttling. Windows: the caller then stops it through the socket. */
+    restart(): 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";
+/** Windows: file in the daemon directory telling the supervisor not to restart. */
+export declare const SUPERVISOR_STOP_MARKER = "supervisor.stop";
 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;
+/** ProgramArguments of a plist written by renderLaunchdPlist. */
+export declare function parseLaunchdProgramArguments(plist: string): string[] | null;
 export declare function renderLaunchdPlist(label: string, spec: DaemonServiceSpec): string;
+/** The words of an ExecStart line written by renderSystemdUnit. */
+export declare function parseSystemdExecStart(unit: string): string[] | null;
 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;
+/** Splits a command line the way the Windows C runtime does (the inverse of quoteWindowsArg). */
+export declare function splitWindowsCommandLine(commandLine: string): string[];
+/** The command line of a launcher written by renderWindowsLauncher. */
+export declare function parseWindowsLauncherCommand(launcher: string): string[] | null;
 /**
  * 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