@dinoxx/dinox-cli 2.13.0 → 2.14.0

package/dist/daemon/index.js

@@ -1,4 +1,6 @@
-import { existsSync } from 'node:fs';
+import { existsSync, watch, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { getConfigFilePath } from '../config/paths.js';
 import { DaemonServer } from './server.js';
 import { DEFAULT_DAEMON_PORT } from './types.js';
 import { acquireDaemonStartLock, getDaemonSocketPath, isProcessRunning, readPid, removePid, } from './pid.js';
@@ -13,6 +15,7 @@ import { hydrateResolvedAuthIdentity } from '../auth/userInfo.js';
 import { withAsyncRelease } from '../utils/asyncRelease.js';
 import { remainingDeadlineMs } from '../utils/deadline.js';
 import { getPackageVersion } from '../utils/version.js';
+import { matchesRuntimeTokenBinding } from './fresh.js';
 import { DAEMON_CHILD_ENV, daemonServiceSpec, envTokenOverridesLogin, launchDaemon } from './launch.js';
 import { getDaemonLogPath, rotateDaemonLog, writeDaemonLogLine } from './log.js';
 import { DAEMON_SERVICE_ENV, getDaemonService } from './supervisor.js';
@@ -99,14 +102,6 @@ async function expectedDaemonIdentity(baseConfig, timeoutMs) {
         runtimeConfigFingerprint: fingerprintDaemonRuntimeConfig(config),
     };
 }
-function matchesRuntimeTokenBinding(info, version, config) {
-    return Boolean(config.auth.authorization
-        && info.authenticated
-        && info.version === version
-        && info.tokenFingerprint === (config.auth.tokenFingerprint ?? null)
-        && info.runtimeConfigFingerprint === fingerprintDaemonRuntimeConfig(config)
-        && (!config.auth.userId || info.userId === config.auth.userId));
-}
 export async function startDaemonLocked(port, detached, options = {}) {
     const maximumTimeoutMs = options.timeoutMs === undefined
         ? undefined
@@ -142,7 +137,7 @@ export async function startDaemonLocked(port, detached, options = {}) {
     }
     const expected = await expectedDaemonIdentity(baseConfig, remainingStartTimeoutMs('auth-hydration'));
     if (detached) {
-        const launch = await launchDaemon(port);
+        const launch = await launchDaemon(port, { takeover: options.takeover });
         const ready = await waitForFreshDaemon(expected.version, expected.userId, expected.tokenFingerprint, expected.runtimeConfigFingerprint, remainingStartTimeoutMs('ready-poll'));
         if (!ready) {
             launch.abort();
@@ -172,7 +167,16 @@ async function serveDaemonInForeground(port, options) {
     if (!options.quiet) {
         printHumanReadableLine(`Starting daemon on ${getDaemonSocketPath()}...`);
     }
-    const server = new DaemonServer();
+    const stopAndExit = async (reason, exitCode, details) => {
+        writeDaemonLogLine('dinox-daemon', 'stopping', { reason, ...details });
+        const forceExit = setTimeout(() => process.exit(exitCode), DAEMON_CRASH_STOP_TIMEOUT_MS);
+        forceExit.unref();
+        await server.stop().catch(() => undefined);
+        process.exit(exitCode);
+    };
+    const server = new DaemonServer({
+        onStopRequested: (reason, details) => stopAndExit(reason, typeof details?.exitCode === 'number' ? details.exitCode : 0, details),
+    });
     try {
         await server.initialize();
         await server.start(port);
@@ -189,13 +193,6 @@ async function serveDaemonInForeground(port, options) {
         version: getPackageVersion(),
         supervisor: process.env[DAEMON_SERVICE_ENV] ?? null,
     });
-    const stopAndExit = async (reason, exitCode) => {
-        writeDaemonLogLine('dinox-daemon', 'stopping', { reason });
-        const forceExit = setTimeout(() => process.exit(exitCode), DAEMON_CRASH_STOP_TIMEOUT_MS);
-        forceExit.unref();
-        await server.stop().catch(() => undefined);
-        process.exit(exitCode);
-    };
     process.on('SIGINT', () => {
         if (!options.quiet) {
             printHumanReadableLine('');
@@ -247,11 +244,17 @@ export async function stopDaemonLocked() {
         await shutdownLegacyDaemon(info, DAEMON_STOP_TIMEOUT_MS);
         return { stopped: true, wasRunning: true, stalePidFile: false };
     }
+    const service = getDaemonService();
+    const supervised = Boolean(service?.isInstalled() && info.supervisor === service.kind);
     try {
-        await requestDaemonShutdown(info.instanceId, 2_000);
+        // Through the manager: with KeepAlive a plain socket shutdown is respawned.
+        if (supervised)
+            await service.stop();
+        if (!supervised || service.kind === 'schtasks')
+            await requestDaemonShutdown(info.instanceId, 2_000);
     }
     catch (error) {
-        throw new DinoxError(`Failed to stop daemon through its private socket: ${error.message}`, {
+        throw new DinoxError(`Failed to stop daemon ${supervised ? `through ${service.kind}` : 'through its private socket'}: ${error.message}`, {
             code: 'DAEMON_STOP_FAILED',
             suggestion: 'The daemon PID was not signaled because its process identity could not be verified safely.',
         });
@@ -317,6 +320,20 @@ async function daemonStatus() {
     }
 }
 export async function restartDaemonLocked(port = DEFAULT_DAEMON_PORT, options = {}) {
+    const info = await getDaemonInfo();
+    const service = getDaemonService();
+    if (info && service?.isInstalled() && info.supervisor === service.kind
+        && service.isCurrent(daemonServiceSpec(service, port))) {
+        const expected = await expectedDaemonIdentity();
+        await service.restart();
+        if (service.kind === 'schtasks')
+            await requestDaemonShutdown(info.instanceId, 2_000);
+        const ready = await waitForFreshDaemon(expected.version, expected.userId, expected.tokenFingerprint, expected.runtimeConfigFingerprint, DAEMON_SERVICE_READY_TIMEOUT_MS);
+        if (!ready)
+            throw new DinoxError('Restarted service did not become ready', { code: 'DAEMON_START_FAILED' });
+        return { stopped: true, running: true, port, socketPath: getDaemonSocketPath(), transport: 'socket',
+            detached: true, alreadyRunning: false, service: service.kind };
+    }
     const stopResult = await stopDaemonLocked();
     await new Promise((resolve) => setTimeout(resolve, 1000));
     const startResult = await startDaemonLocked(port, true, options);
@@ -388,6 +405,8 @@ export async function uninstallDaemonService() {
             const info = await getDaemonInfo();
             if (info?.supervisor === service.kind)
                 await stopDaemonLocked();
+            else
+                await service.stop();
         }
         return {
             uninstalled: await service.uninstall(),
@@ -456,17 +475,63 @@ function printDaemonUninstallResult(result) {
         ? `Removed ${result.service} service; the daemon is stopped.`
         : 'The daemon service is not installed.');
 }
+export async function waitForSavedDaemonLogin(overrides = {}) {
+    const hasAuth = overrides.hasAuth ?? (async () => Boolean(normalizeAuthToken((await loadConfig()).auth?.authorization)));
+    const exit = overrides.exit ?? ((code) => process.exit(code));
+    const onSignal = overrides.onSignal ?? ((handler) => {
+        process.on('SIGTERM', handler);
+        process.on('SIGINT', handler);
+        return () => { process.off('SIGTERM', handler); process.off('SIGINT', handler); };
+    });
+    const watchConfig = overrides.watchConfig ?? ((check) => {
+        const dir = path.dirname(getConfigFilePath());
+        mkdirSync(dir, { recursive: true });
+        try {
+            const watcher = watch(dir, check);
+            return () => watcher.close();
+        }
+        catch {
+            return () => undefined;
+        }
+    });
+    writeDaemonLogLine('dinox-daemon', 'not signed in; waiting for saved login');
+    await new Promise((resolve) => {
+        let done = false;
+        let closeWatch = () => undefined;
+        let closeSignals = () => undefined;
+        const finish = (code) => {
+            if (done)
+                return;
+            done = true;
+            clearInterval(timer);
+            closeWatch();
+            closeSignals();
+            exit(code);
+            resolve();
+        };
+        const check = () => {
+            void hasAuth().then((authorized) => {
+                if (authorized && !done) {
+                    writeDaemonLogLine('dinox-daemon', 'saved login found; restarting');
+                    finish(75);
+                }
+            }).catch(() => undefined);
+        };
+        const timer = setInterval(check, overrides.pollMs ?? 60_000);
+        closeWatch = watchConfig(check);
+        closeSignals = onSignal(() => finish(0));
+        check();
+    });
+}
 async function runDaemonStart(context) {
     const port = parsePort(context.options.port);
     const structured = Boolean(getRequestedStructuredOutputFormat());
     if (context.options.detach === false && process.env[DAEMON_SERVICE_ENV]
         && !resolveConfig(await loadConfig()).auth.authorization) {
-        // Started at login by the service while signed out: exit cleanly so the
-        // service does not retry; the next command after `dino auth login` starts it.
-        writeDaemonLogLine('dinox-daemon', 'not signed in; staying stopped until `dino auth login`');
+        await waitForSavedDaemonLogin();
         return;
     }
-    const result = await startDaemon(port, context.options.detach !== false, { quiet: structured });
+    const result = await startDaemon(port, context.options.detach !== false, { quiet: structured, takeover: true });
     if (!result.running) {
         throw new DinoxError('Failed to start daemon', { code: 'DAEMON_START_FAILED' });
     }
@@ -513,7 +578,7 @@ async function runDaemonUninstall() {
 }
 async function runDaemonRestart(context) {
     const structured = Boolean(getRequestedStructuredOutputFormat());
-    const result = await restartDaemon(parsePort(context.options.port), { quiet: structured });
+    const result = await restartDaemon(parsePort(context.options.port), { quiet: structured, takeover: true });
     if (structured) {
         printSuccess(result);
         return;

package/dist/daemon/launch.d.ts

@@ -22,10 +22,22 @@ export declare function envTokenOverridesLogin(raw: DinoxConfig, env?: NodeJS.Pr
 export declare function daemonServiceSpec(service: DaemonService, port: number): DaemonServiceSpec;
 /** The installed service when this caller can use it, else null. */
 export declare function usableDaemonService(): Promise<DaemonService | null>;
+/**
+ * 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 declare function foreignServiceOwner(service: DaemonService, entrypoint?: string | undefined): string | null;
 /**
  * Starts a daemon. Caller must hold the daemon start lock and have stopped any
  * 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 declare function launchDaemon(port: number): Promise<DaemonLaunch>;
+export declare function launchDaemon(port: number, options?: {
+    takeover?: boolean;
+}): Promise<DaemonLaunch>;

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>;