@dinoxx/dinox-cli 2.13.1 → 2.14.0

package/dist/daemon/launch.js

@@ -1,4 +1,5 @@
 import { spawn } from 'node:child_process';
+import { existsSync, realpathSync } from 'node:fs';
 import os from 'node:os';
 import { loadConfig } from '../config/store.js';
 import { DINOX_TOKEN_ENV_VAR, normalizeAuthToken, readEnvAuthToken } from '../utils/authToken.js';
@@ -52,6 +53,32 @@ export async function usableDaemonService() {
         return null;
     return service;
 }
+function samePath(a, b) {
+    const resolve = (value) => {
+        try {
+            return realpathSync(value);
+        }
+        catch {
+            return value;
+        }
+    };
+    return resolve(a) === resolve(b);
+}
+/**
+ * The entrypoint of another dino install (e.g. a global install next to a
+ * source checkout) that the service definition runs, or null when it runs
+ * this CLI or an install that no longer exists. Automatic paths must not
+ * rewrite or restart a service another install owns: each install would
+ * otherwise keep switching it to its own version.
+ */
+export function foreignServiceOwner(service, entrypoint = process.argv[1]) {
+    const command = service.installedCommand();
+    const daemonIndex = command?.indexOf('daemon') ?? -1;
+    const owner = daemonIndex > 0 ? command[daemonIndex - 1] : null;
+    if (!owner || !entrypoint || samePath(owner, entrypoint) || !existsSync(owner))
+        return null;
+    return owner;
+}
 function spawnDetached(port) {
     const { program, args } = daemonCommandLine(port);
     const log = openDaemonLogForChild();
@@ -76,14 +103,16 @@ function spawnDetached(port) {
  * stale daemon. Uses the installed service when there is one (refreshing its
  * definition if this CLI's program, arguments or environment changed, e.g.
  * after `dino update`), otherwise a detached child with a clean environment.
+ * A service another install owns is only started, never rewritten, unless
+ * `takeover` is set by an explicit `dino daemon start/restart`.
  */
-export async function launchDaemon(port) {
+export async function launchDaemon(port, options = {}) {
     const service = await usableDaemonService();
     if (!service)
         return spawnDetached(port);
     ensureDaemonDir();
     const spec = daemonServiceSpec(service, port);
-    if (!service.isCurrent(spec)) {
+    if (!service.isCurrent(spec) && (options.takeover || !foreignServiceOwner(service))) {
         await service.install(spec);
     }
     else {

package/dist/daemon/lifecycle.d.ts

@@ -3,7 +3,7 @@ import { printHumanReadableWarning } from '../utils/output.js';
 import { getPackageVersion } from '../utils/version.js';
 import { getDaemonInfo, shutdownDaemonForExclusiveAccess } from './client.js';
 import { startDaemonLocked } from './index.js';
-import { acquireDaemonStartLock, readPid, type DaemonPidInfo } from './pid.js';
+import { acquireDaemonStartLock, acquireDaemonExclusiveIntentLock, readPid, type DaemonPidInfo } from './pid.js';
 import { type DaemonPingResult } from './types.js';
 export type DaemonSnapshot = {
     info: DaemonPingResult | null;
@@ -21,10 +21,12 @@ export type DaemonExclusiveAccessControl = {
 };
 type DaemonLifecycleDependencies = {
     acquireStartLock: typeof acquireDaemonStartLock;
+    acquireIntentLock: typeof acquireDaemonExclusiveIntentLock;
     getDaemonInfo: typeof getDaemonInfo;
     readPid: typeof readPid;
     shutdownDaemon: typeof shutdownDaemonForExclusiveAccess;
     startDaemonLocked: typeof startDaemonLocked;
+    startInstalledService: () => Promise<boolean>;
     getPackageVersion: typeof getPackageVersion;
     printWarning: typeof printHumanReadableWarning;
 };

package/dist/daemon/lifecycle.js

@@ -6,15 +6,27 @@ import { DinoxError } from '../utils/errors.js';
 import { printHumanReadableWarning } from '../utils/output.js';
 import { getPackageVersion } from '../utils/version.js';
 import { getDaemonInfo, isDaemonFresh, shutdownDaemonForExclusiveAccess, } from './client.js';
+import { getDaemonService } from './supervisor.js';
 import { startDaemonLocked } from './index.js';
-import { acquireDaemonStartLock, getDaemonSocketPath, readPid, } from './pid.js';
+import { acquireDaemonStartLock, acquireDaemonExclusiveIntentLock, getDaemonSocketPath, readPid, } from './pid.js';
 import { DEFAULT_DAEMON_PORT } from './types.js';
+/** Matches the service readiness budget; a cold daemon start takes a few seconds. */
+const DAEMON_RESTORE_TIMEOUT_MS = 20_000;
 const daemonLifecycleDependencies = {
     acquireStartLock: acquireDaemonStartLock,
+    acquireIntentLock: acquireDaemonExclusiveIntentLock,
     getDaemonInfo,
     readPid,
     shutdownDaemon: shutdownDaemonForExclusiveAccess,
     startDaemonLocked,
+    async startInstalledService() {
+        const service = getDaemonService();
+        if (!service?.isInstalled())
+            return false;
+        // Not restart(): the manager may already be bringing it back.
+        await service.start();
+        return true;
+    },
     getPackageVersion,
     printWarning: printHumanReadableWarning,
 };
@@ -78,13 +90,17 @@ export async function suspendDaemonForExclusiveAccessLocked(config, timeoutMs, o
 }
 /** Caller must hold the daemon start lock. */
 export async function restoreSuspendedDaemonLocked(suspended, overrides = {}, options = {}) {
-    if (!suspended.wasStopped || !suspended.wasFresh) {
+    if (!suspended.wasStopped) {
         return false;
     }
     const deps = dependencies(overrides);
+    if (!suspended.wasFresh) {
+        return Boolean(suspended.snapshot.info?.supervisor && await deps.startInstalledService());
+    }
     await deps.startDaemonLocked(suspended.port, true, {
         quiet: true,
-        timeoutMs: options.timeoutMs,
+        // Restoring a background process must not consume the default five-minute sync budget.
+        timeoutMs: Math.min(options.timeoutMs ?? DAEMON_RESTORE_TIMEOUT_MS, DAEMON_RESTORE_TIMEOUT_MS),
     });
     return true;
 }
@@ -94,6 +110,7 @@ export async function withDaemonExclusiveAccess(config, timeoutMs, run, override
     const remainingOperationTimeoutMs = (phase, action) => requireRemainingDeadlineMs(operationDeadlineAtMs, timeoutMs, phase, action);
     const remainingCleanupTimeoutMs = () => Math.max(1, remainingDeadlineMs(options.deadlineAtMs, timeoutMs));
     const releaseStartLock = await deps.acquireStartLock(remainingOperationTimeoutMs('daemon-lock-acquire', 'acquiring the daemon lifecycle lock'));
+    let releaseIntent;
     let suspended = null;
     let restoreAllowed = true;
     let cleanupError;
@@ -104,6 +121,7 @@ export async function withDaemonExclusiveAccess(config, timeoutMs, run, override
         },
     };
     try {
+        releaseIntent = await deps.acquireIntentLock(remainingOperationTimeoutMs('daemon-intent-lock', 'acquiring exclusive intent'));
         suspended = await suspendDaemonForExclusiveAccessLocked(config, remainingOperationTimeoutMs('daemon-suspend', 'suspending the background daemon'), {
             deadlineAtMs: operationDeadlineAtMs,
             dependencies: deps,
@@ -119,6 +137,12 @@ export async function withDaemonExclusiveAccess(config, timeoutMs, run, override
         outcome = { ok: false, error };
     }
     finally {
+        try {
+            await releaseIntent?.();
+        }
+        catch (error) {
+            cleanupError = error;
+        }
         if (suspended && restoreAllowed) {
             const suspendedDaemon = suspended;
             try {

package/dist/daemon/pid.d.ts

@@ -21,3 +21,11 @@ export declare function removePid(expectedInstanceId?: string, options?: {
 export declare function isProcessRunning(pid: number): boolean;
 export declare function isLegacyDaemonProcess(pid: number, daemonUptimeMs: number, timeoutMs?: number): Promise<boolean>;
 export declare function acquireDaemonStartLock(timeoutMs?: number): Promise<() => Promise<void>>;
+/** Present while `dino daemon stop` wants the Windows supervisor to stay down. */
+export declare function getSupervisorStopMarkerPath(): string;
+/**
+ * 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 declare function acquireDaemonExclusiveIntentLock(timeoutMs?: number): Promise<() => Promise<void>>;

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>;
     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;
@@ -66,6 +75,8 @@ function validateLocalRequest(req) {
     return { ok: true };
 }
 export class DaemonServer {
+    options;
+    config = null;
     db = null;
     server = null;
     startTime = Date.now();
@@ -78,14 +89,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 +121,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.
@@ -117,6 +151,43 @@ export class DaemonServer {
             }
             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,
+                        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 +220,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 } };
@@ -318,7 +391,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 +502,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 {