@dinoxx/dinox-cli 1.1.1 → 2.0.0

package/dist/constants/links.d.ts

@@ -1 +1,18 @@
-export declare const SKILLS_REPO_URL = "https://github.com/ryzencool/dinox-cli/tree/main/skills";
+export declare const SKILLS_REPO_SLUG = "ryzencool/dinox-cli-skills";
+export declare const SKILLS_REPO_URL = "https://github.com/ryzencool/dinox-cli-skills";
+export declare const SKILLS_INSTALLER_NAME = "skills";
+export declare const SKILLS_INSTALLER_VERSION = "1.5.16";
+export declare const SKILLS_INSTALL_AGENTS: readonly ["codex", "claude-code", "hermes-agent", "openclaw"];
+export type SkillsInstallerMetadata = {
+    name: typeof SKILLS_INSTALLER_NAME;
+    version: typeof SKILLS_INSTALLER_VERSION;
+};
+export type SkillsReleaseMetadata = {
+    repository: string;
+    version: string;
+    tag: string;
+    release: string;
+    installer: SkillsInstallerMetadata;
+    installCommand: string;
+};
+export declare function getSkillsReleaseMetadata(version: string): SkillsReleaseMetadata;

package/dist/constants/links.js

@@ -1 +1,26 @@
-export const SKILLS_REPO_URL = 'https://github.com/ryzencool/dinox-cli/tree/main/skills';
+export const SKILLS_REPO_SLUG = 'ryzencool/dinox-cli-skills';
+export const SKILLS_REPO_URL = `https://github.com/${SKILLS_REPO_SLUG}`;
+export const SKILLS_INSTALLER_NAME = 'skills';
+export const SKILLS_INSTALLER_VERSION = '1.5.16';
+export const SKILLS_INSTALL_AGENTS = Object.freeze([
+    'codex',
+    'claude-code',
+    'hermes-agent',
+    'openclaw',
+]);
+export function getSkillsReleaseMetadata(version) {
+    const normalizedVersion = version.trim();
+    const tag = `v${normalizedVersion}`;
+    const agentFlags = SKILLS_INSTALL_AGENTS.map((agent) => `-a ${agent}`).join(' ');
+    return {
+        repository: SKILLS_REPO_URL,
+        version: normalizedVersion,
+        tag,
+        release: `${SKILLS_REPO_URL}/tree/${encodeURIComponent(tag)}`,
+        installer: {
+            name: SKILLS_INSTALLER_NAME,
+            version: SKILLS_INSTALLER_VERSION,
+        },
+        installCommand: `npx --yes ${SKILLS_INSTALLER_NAME}@${SKILLS_INSTALLER_VERSION} add ${SKILLS_REPO_SLUG}#${tag} -g ${agentFlags} --skill '*' -y`,
+    };
+}

package/dist/daemon/client.d.ts

@@ -2,13 +2,13 @@ import type { DaemonPingResult, DaemonShutdownResult } from './types.js';
 export declare function sendDaemonRequest(method: string, params?: unknown, requestOptions?: {
     timeoutMs?: number;
 }): Promise<unknown>;
-export declare function isDaemonRunning(): Promise<boolean>;
+export declare function isDaemonRunning(timeoutMs?: number): Promise<boolean>;
 /**
  * Ping the daemon and return its handshake payload (version + connected identity),
  * or null when no daemon is reachable. Callers use this to detect a stale daemon
  * (wrong version or wrong account) rather than only "running / not running".
  */
-export declare function getDaemonInfo(): Promise<DaemonPingResult | null>;
+export declare function getDaemonInfo(timeoutMs?: number): Promise<DaemonPingResult | null>;
 /**
  * Whether a reachable daemon matches the current CLI version and signed-in account.
  * A mismatch means the daemon was started by an older build or a different user and

package/dist/daemon/client.js

@@ -1,10 +1,32 @@
 import { request as httpRequest } from 'node:http';
 import { existsSync } from 'node:fs';
 import { getDaemonSocketPath, isLegacyDaemonProcess, isProcessRunning, readPid, removePid, } from './pid.js';
+import { remainingDeadlineMs } from '../utils/deadline.js';
 import { DinoxError } from '../utils/errors.js';
 const DEFAULT_DAEMON_REQUEST_TIMEOUT_MS = 10_000;
 const MAX_DAEMON_RESPONSE_BYTES = 5 * 1024 * 1024;
+function normalizedTimeoutMs(timeoutMs, fallbackMs) {
+    return Number.isFinite(timeoutMs)
+        ? Math.max(0, Math.floor(timeoutMs))
+        : fallbackMs;
+}
+function createDaemonReleaseTimeoutError(message) {
+    return new DinoxError(message, {
+        code: 'DAEMON_RELEASE_TIMEOUT',
+        suggestion: 'Run `dino daemon stop`, then retry the command.',
+        recoverable: true,
+    });
+}
+async function waitForNextPoll(deadlineAtMs, intervalMs) {
+    const waitMs = remainingDeadlineMs(deadlineAtMs, Math.max(0, intervalMs));
+    if (waitMs <= 0) {
+        return false;
+    }
+    await new Promise((resolve) => setTimeout(resolve, Math.max(1, waitMs)));
+    return true;
+}
 export async function sendDaemonRequest(method, params, requestOptions = {}) {
+    const timeoutMs = Math.max(1, normalizedTimeoutMs(requestOptions.timeoutMs ?? DEFAULT_DAEMON_REQUEST_TIMEOUT_MS, DEFAULT_DAEMON_REQUEST_TIMEOUT_MS));
     const request = {
         id: Date.now().toString(),
         method,
@@ -12,10 +34,14 @@ export async function sendDaemonRequest(method, params, requestOptions = {}) {
     };
     return new Promise((resolve, reject) => {
         let settled = false;
+        let deadlineTimer;
         const finalize = (error, value) => {
             if (settled)
                 return;
             settled = true;
+            if (deadlineTimer) {
+                clearTimeout(deadlineTimer);
+            }
             if (error) {
                 reject(error);
                 return;
@@ -32,7 +58,7 @@ export async function sendDaemonRequest(method, params, requestOptions = {}) {
                 'Content-Type': 'application/json',
                 'Content-Length': Buffer.byteLength(data),
             },
-            timeout: requestOptions.timeoutMs ?? DEFAULT_DAEMON_REQUEST_TIMEOUT_MS,
+            timeout: timeoutMs,
         };
         const req = httpRequest(options, (res) => {
             const statusCode = res.statusCode ?? 0;
@@ -70,6 +96,10 @@ export async function sendDaemonRequest(method, params, requestOptions = {}) {
             req.destroy(new Error('Daemon request timed out'));
         });
         req.on('error', (error) => finalize(error));
+        deadlineTimer = setTimeout(() => {
+            req.destroy(new Error('Daemon request timed out'));
+        }, timeoutMs);
+        deadlineTimer.unref?.();
         req.write(data);
         req.end();
     });
@@ -97,17 +127,17 @@ function toDaemonError(error) {
     }
     return new Error(typeof error === 'string' && error.trim() ? error : 'Unknown error');
 }
-export async function isDaemonRunning() {
-    return (await getDaemonInfo()) !== null;
+export async function isDaemonRunning(timeoutMs) {
+    return (await getDaemonInfo(timeoutMs)) !== null;
 }
 /**
  * Ping the daemon and return its handshake payload (version + connected identity),
  * or null when no daemon is reachable. Callers use this to detect a stale daemon
  * (wrong version or wrong account) rather than only "running / not running".
  */
-export async function getDaemonInfo() {
+export async function getDaemonInfo(timeoutMs) {
     try {
-        const result = await sendDaemonRequest('ping');
+        const result = await sendDaemonRequest('ping', undefined, { timeoutMs });
         if (result && typeof result === 'object') {
             const info = result;
             return {
@@ -147,25 +177,38 @@ export function isLegacyDaemonInfo(info) {
     return info.pid === 0 && info.instanceId.length === 0;
 }
 export async function shutdownLegacyDaemon(initialInfo, timeoutMs = 5_000) {
+    const maximumTimeoutMs = normalizedTimeoutMs(timeoutMs, 5_000);
+    const deadlineAtMs = Date.now() + maximumTimeoutMs;
+    const remainingTimeoutMs = () => remainingDeadlineMs(deadlineAtMs, maximumTimeoutMs);
+    const requireRemainingTimeoutMs = () => {
+        const remainingMs = remainingTimeoutMs();
+        if (remainingMs <= 0) {
+            throw createDaemonReleaseTimeoutError('Timed out while verifying the legacy daemon process.');
+        }
+        return remainingMs;
+    };
     const pidInfo = readPid();
-    if (!isLegacyDaemonInfo(initialInfo)
-        || !pidInfo
-        || pidInfo.instanceId !== null
-        || !isProcessRunning(pidInfo.pid)
-        || !await isLegacyDaemonProcess(pidInfo.pid, initialInfo.uptime)) {
+    const legacyProcessVerified = Boolean(isLegacyDaemonInfo(initialInfo)
+        && pidInfo
+        && pidInfo.instanceId === null
+        && isProcessRunning(pidInfo.pid)
+        && await isLegacyDaemonProcess(pidInfo.pid, initialInfo.uptime, requireRemainingTimeoutMs()));
+    if (!legacyProcessVerified
+        || !pidInfo) {
         throw new DinoxError('A legacy daemon is responding, but its process identity could not be verified safely.', {
             code: 'DAEMON_LEGACY_UNVERIFIED',
             suggestion: 'Inspect the daemon PID and command line, stop that process manually, then retry.',
             recoverable: true,
         });
     }
-    const confirmedInfo = await getDaemonInfo();
+    const confirmedInfo = await getDaemonInfo(requireRemainingTimeoutMs());
     const confirmedPidInfo = readPid();
-    if (!confirmedInfo
-        || !isLegacyDaemonInfo(confirmedInfo)
-        || confirmedPidInfo?.pid !== pidInfo.pid
-        || confirmedPidInfo.instanceId !== null
-        || !await isLegacyDaemonProcess(pidInfo.pid, confirmedInfo.uptime)) {
+    const confirmedLegacyProcess = Boolean(confirmedInfo
+        && isLegacyDaemonInfo(confirmedInfo)
+        && confirmedPidInfo?.pid === pidInfo.pid
+        && confirmedPidInfo.instanceId === null
+        && await isLegacyDaemonProcess(pidInfo.pid, confirmedInfo.uptime, requireRemainingTimeoutMs()));
+    if (!confirmedLegacyProcess) {
         throw new DinoxError('The legacy daemon changed while its process identity was being verified.', {
             code: 'DAEMON_INSTANCE_CHANGED',
             suggestion: 'Retry after checking `dino daemon status`.',
@@ -183,9 +226,8 @@ export async function shutdownLegacyDaemon(initialInfo, timeoutMs = 5_000) {
             recoverable: true,
         });
     }
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        const current = await getDaemonInfo();
+    while (remainingTimeoutMs() > 0) {
+        const current = await getDaemonInfo(requireRemainingTimeoutMs());
         const processRunning = isProcessRunning(pidInfo.pid);
         if (!current && !processRunning) {
             removePid(undefined, { expectedPid: pidInfo.pid });
@@ -199,37 +241,46 @@ export async function shutdownLegacyDaemon(initialInfo, timeoutMs = 5_000) {
                 recoverable: true,
             });
         }
-        await new Promise((resolve) => setTimeout(resolve, 100));
+        if (!await waitForNextPoll(deadlineAtMs, 100)) {
+            break;
+        }
     }
-    throw new DinoxError('Timed out waiting for the verified legacy daemon to stop.', {
-        code: 'DAEMON_RELEASE_TIMEOUT',
-        suggestion: 'Inspect the daemon PID and stop that process manually before retrying.',
-        recoverable: true,
-    });
+    throw createDaemonReleaseTimeoutError('Timed out waiting for the verified legacy daemon to stop.');
 }
 /** Poll until the daemon answers a ping or the timeout elapses. */
 export async function waitForDaemonReady(timeoutMs = 5_000, intervalMs = 250) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        if (await isDaemonRunning()) {
+    const maximumTimeoutMs = normalizedTimeoutMs(timeoutMs, 5_000);
+    const deadlineAtMs = Date.now() + maximumTimeoutMs;
+    while (true) {
+        const remainingMs = remainingDeadlineMs(deadlineAtMs, maximumTimeoutMs);
+        if (remainingMs <= 0) {
+            return false;
+        }
+        if (await isDaemonRunning(remainingMs)) {
             return true;
         }
-        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        if (!await waitForNextPoll(deadlineAtMs, intervalMs)) {
+            return false;
+        }
     }
-    return isDaemonRunning();
 }
 /** Poll until the daemon answers with the expected authenticated identity. */
 export async function waitForFreshDaemon(expectedVersion, expectedUserId, expectedTokenFingerprint, expectedRuntimeConfigFingerprint, timeoutMs = 5_000, intervalMs = 250) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        const info = await getDaemonInfo();
+    const maximumTimeoutMs = normalizedTimeoutMs(timeoutMs, 5_000);
+    const deadlineAtMs = Date.now() + maximumTimeoutMs;
+    while (true) {
+        const remainingMs = remainingDeadlineMs(deadlineAtMs, maximumTimeoutMs);
+        if (remainingMs <= 0) {
+            return false;
+        }
+        const info = await getDaemonInfo(remainingMs);
         if (info && isDaemonFresh(info, expectedVersion, expectedUserId, expectedTokenFingerprint, expectedRuntimeConfigFingerprint)) {
             return true;
         }
-        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        if (!await waitForNextPoll(deadlineAtMs, intervalMs)) {
+            return false;
+        }
     }
-    const info = await getDaemonInfo();
-    return Boolean(info && isDaemonFresh(info, expectedVersion, expectedUserId, expectedTokenFingerprint, expectedRuntimeConfigFingerprint));
 }
 /** Request shutdown of one exact daemon instance and reject if the socket changed owners. */
 export async function requestDaemonShutdown(expectedInstanceId, timeoutMs = 2_000) {
@@ -255,7 +306,17 @@ export async function requestDaemonShutdown(expectedInstanceId, timeoutMs = 2_00
 }
 /** Stop a reachable daemon before another process acquires the exclusive PowerSync owner lease. */
 export async function shutdownDaemonForExclusiveAccess(timeoutMs = 5_000, expectedInstanceId) {
-    const info = await getDaemonInfo();
+    const maximumTimeoutMs = normalizedTimeoutMs(timeoutMs, 5_000);
+    const deadlineAtMs = Date.now() + maximumTimeoutMs;
+    const remainingTimeoutMs = () => remainingDeadlineMs(deadlineAtMs, maximumTimeoutMs);
+    const requireRemainingTimeoutMs = () => {
+        const remainingMs = remainingTimeoutMs();
+        if (remainingMs <= 0) {
+            throw createDaemonReleaseTimeoutError('Timed out waiting for the daemon to release the PowerSync runtime.');
+        }
+        return remainingMs;
+    };
+    const info = await getDaemonInfo(requireRemainingTimeoutMs());
     if (!info) {
         const pidInfo = readPid();
         const socketExists = process.platform !== 'win32' && existsSync(getDaemonSocketPath());
@@ -269,7 +330,7 @@ export async function shutdownDaemonForExclusiveAccess(timeoutMs = 5_000, expect
         return false;
     }
     if (isLegacyDaemonInfo(info)) {
-        return shutdownLegacyDaemon(info, timeoutMs);
+        return shutdownLegacyDaemon(info, requireRemainingTimeoutMs());
     }
     if (expectedInstanceId && info.instanceId !== expectedInstanceId) {
         throw new DinoxError('Daemon instance changed before exclusive access could be acquired.', {
@@ -280,7 +341,7 @@ export async function shutdownDaemonForExclusiveAccess(timeoutMs = 5_000, expect
         });
     }
     try {
-        await requestDaemonShutdown(info.instanceId, Math.min(timeoutMs, 2_000));
+        await requestDaemonShutdown(info.instanceId, Math.min(requireRemainingTimeoutMs(), 2_000));
     }
     catch (error) {
         throw new DinoxError('The running daemon could not release the PowerSync runtime.', {
@@ -290,21 +351,14 @@ export async function shutdownDaemonForExclusiveAccess(timeoutMs = 5_000, expect
             recoverable: true,
         });
     }
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        const current = await getDaemonInfo();
+    while (remainingTimeoutMs() > 0) {
+        const current = await getDaemonInfo(requireRemainingTimeoutMs());
         if (!current || current.instanceId !== info.instanceId) {
             return true;
         }
-        await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-    const current = await getDaemonInfo();
-    if (!current || current.instanceId !== info.instanceId) {
-        return true;
+        if (!await waitForNextPoll(deadlineAtMs, 100)) {
+            break;
+        }
     }
-    throw new DinoxError('Timed out waiting for the daemon to release the PowerSync runtime.', {
-        code: 'DAEMON_RELEASE_TIMEOUT',
-        suggestion: 'Run `dino daemon stop`, then retry the command.',
-        recoverable: true,
-    });
+    throw createDaemonReleaseTimeoutError('Timed out waiting for the daemon to release the PowerSync runtime.');
 }

package/dist/daemon/index.d.ts

@@ -8,14 +8,16 @@ type DaemonStartResult = {
     detached: boolean;
     alreadyRunning: boolean;
 };
+type DaemonStartOptions = {
+    quiet?: boolean;
+    timeoutMs?: number;
+};
 type DaemonStopResult = {
     stopped: boolean;
     wasRunning: boolean;
     stalePidFile: boolean;
 };
-export declare function startDaemonLocked(port: number, detached: boolean, options?: {
-    quiet?: boolean;
-}): Promise<DaemonStartResult>;
+export declare function startDaemonLocked(port: number, detached: boolean, options?: DaemonStartOptions): Promise<DaemonStartResult>;
 /** Caller must hold the daemon start lock. */
 export declare function stopDaemonLocked(): Promise<DaemonStopResult>;
 export declare function stopDaemon(): Promise<DaemonStopResult>;

package/dist/daemon/index.js

@@ -12,6 +12,7 @@ import { loadConfig } from '../config/store.js';
 import { fingerprintDaemonRuntimeConfig, resolveConfig } from '../config/resolve.js';
 import { hydrateResolvedAuthIdentity } from '../auth/userInfo.js';
 import { withAsyncRelease } from '../utils/asyncRelease.js';
+import { remainingDeadlineMs } from '../utils/deadline.js';
 import { getPackageVersion } from '../utils/version.js';
 const DAEMON_STOP_POLL_INTERVAL_MS = 100;
 const DAEMON_STOP_TIMEOUT_MS = 5_000;
@@ -63,9 +64,11 @@ async function waitForDaemonExit(instanceId, timeoutMs) {
     const info = await getDaemonInfo();
     return !info || info.instanceId !== instanceId;
 }
-async function expectedDaemonIdentity(baseConfig) {
+async function expectedDaemonIdentity(baseConfig, timeoutMs) {
     const resolved = baseConfig ?? resolveConfig(await loadConfig());
-    const { config } = await hydrateResolvedAuthIdentity(resolved, { timeoutMs: resolved.sync.timeoutMs });
+    const { config } = await hydrateResolvedAuthIdentity(resolved, {
+        timeoutMs: timeoutMs ?? resolved.sync.timeoutMs,
+    });
     return {
         version: getPackageVersion(),
         userId: config.auth.userId ?? null,
@@ -82,9 +85,29 @@ function matchesRuntimeTokenBinding(info, version, config) {
         && (!config.auth.userId || info.userId === config.auth.userId));
 }
 export async function startDaemonLocked(port, detached, options = {}) {
+    const maximumTimeoutMs = options.timeoutMs === undefined
+        ? undefined
+        : Math.max(0, Math.floor(options.timeoutMs));
+    const deadlineAtMs = maximumTimeoutMs === undefined
+        ? undefined
+        : Date.now() + maximumTimeoutMs;
+    const remainingStartTimeoutMs = (phase) => {
+        if (deadlineAtMs === undefined || maximumTimeoutMs === undefined) {
+            return undefined;
+        }
+        const remainingMs = remainingDeadlineMs(deadlineAtMs, maximumTimeoutMs);
+        if (remainingMs <= 0) {
+            throw new DinoxError('Failed to start daemon before the caller deadline expired.', {
+                code: 'DAEMON_START_TIMEOUT',
+                details: { phase },
+                recoverable: true,
+            });
+        }
+        return remainingMs;
+    };
     const baseConfig = resolveConfig(await loadConfig());
     const version = getPackageVersion();
-    const runningInfo = await getDaemonInfo();
+    const runningInfo = await getDaemonInfo(remainingStartTimeoutMs('initial-ping'));
     if (runningInfo) {
         if (matchesRuntimeTokenBinding(runningInfo, version, baseConfig)) {
             return { running: true, port, socketPath: getDaemonSocketPath(), transport: 'socket', detached, alreadyRunning: true };
@@ -94,7 +117,7 @@ export async function startDaemonLocked(port, detached, options = {}) {
             recoverable: true,
         });
     }
-    const expected = await expectedDaemonIdentity(baseConfig);
+    const expected = await expectedDaemonIdentity(baseConfig, remainingStartTimeoutMs('auth-hydration'));
     if (detached) {
         const args = ['daemon', 'start', '--port', String(port), '--no-detach'];
         const entrypoint = process.argv[1];
@@ -107,7 +130,7 @@ export async function startDaemonLocked(port, detached, options = {}) {
             env: { ...process.env, [DAEMON_CHILD_ENV]: '1' },
         });
         child.unref();
-        const ready = await waitForFreshDaemon(expected.version, expected.userId, expected.tokenFingerprint, expected.runtimeConfigFingerprint);
+        const ready = await waitForFreshDaemon(expected.version, expected.userId, expected.tokenFingerprint, expected.runtimeConfigFingerprint, remainingStartTimeoutMs('ready-poll'));
         if (!ready) {
             child.kill('SIGTERM');
             throw new DinoxError('Failed to start daemon');

package/dist/daemon/lifecycle.d.ts

@@ -28,17 +28,22 @@ type DaemonLifecycleDependencies = {
     getPackageVersion: typeof getPackageVersion;
     printWarning: typeof printHumanReadableWarning;
 };
-export declare function captureDaemonSnapshot(overrides?: Partial<DaemonLifecycleDependencies>): Promise<DaemonSnapshot>;
+export declare function captureDaemonSnapshot(overrides?: Partial<DaemonLifecycleDependencies>, timeoutMs?: number): Promise<DaemonSnapshot>;
 export declare function daemonSnapshotIsFresh(config: ResolvedDinoxConfig, snapshot: DaemonSnapshot, version?: string): boolean;
 /** Caller must hold the daemon start lock until restore completes. */
 export declare function suspendDaemonForExclusiveAccessLocked(config: ResolvedDinoxConfig, timeoutMs: number, options?: {
     snapshot?: DaemonSnapshot;
     forceStop?: boolean;
+    deadlineAtMs?: number;
     dependencies?: Partial<DaemonLifecycleDependencies>;
 }): Promise<SuspendedDaemon>;
 /** Caller must hold the daemon start lock. */
-export declare function restoreSuspendedDaemonLocked(suspended: SuspendedDaemon, overrides?: Partial<DaemonLifecycleDependencies>): Promise<boolean>;
+export declare function restoreSuspendedDaemonLocked(suspended: SuspendedDaemon, overrides?: Partial<DaemonLifecycleDependencies>, options?: {
+    timeoutMs?: number;
+}): Promise<boolean>;
 export declare function withDaemonExclusiveAccess<T>(config: ResolvedDinoxConfig, timeoutMs: number, run: (control: DaemonExclusiveAccessControl) => Promise<T>, overrides?: Partial<DaemonLifecycleDependencies>, options?: {
     deadlineAtMs?: number;
+    operationDeadlineAtMs?: number;
+    cleanupFailureMode?: 'warn' | 'throw';
 }): Promise<T>;
 export {};

package/dist/daemon/lifecycle.js

@@ -1,6 +1,8 @@
 import { existsSync } from 'node:fs';
 import { getPowerSyncDbPath } from '../config/paths.js';
 import { fingerprintDaemonRuntimeConfig } from '../config/resolve.js';
+import { remainingDeadlineMs, runWithinDeadline } from '../utils/deadline.js';
+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';
@@ -22,6 +24,21 @@ function dependencies(overrides) {
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function createLifecycleDeadlineError(phase, action) {
+    return new DinoxError(`Sync deadline exceeded while ${action}.`, {
+        code: 'SYNC_TIMEOUT',
+        details: { phase },
+        suggestion: 'Run `dino doctor --format json` to verify the local runtime before retrying sync.',
+        recoverable: true,
+    });
+}
+function requireRemainingDeadlineMs(deadlineAtMs, maximumTimeoutMs, phase, action) {
+    const remainingMs = remainingDeadlineMs(deadlineAtMs, maximumTimeoutMs);
+    if (deadlineAtMs !== undefined && remainingMs <= 0) {
+        throw createLifecycleDeadlineError(phase, action);
+    }
+    return Math.max(1, remainingMs);
+}
 function snapshotPort(snapshot) {
     const pidFileMatches = Boolean(snapshot.info
         && snapshot.pidInfo
@@ -29,10 +46,10 @@ function snapshotPort(snapshot) {
         && snapshot.pidInfo.instanceId === snapshot.info.instanceId);
     return pidFileMatches ? snapshot.pidInfo?.port ?? DEFAULT_DAEMON_PORT : DEFAULT_DAEMON_PORT;
 }
-export async function captureDaemonSnapshot(overrides = {}) {
+export async function captureDaemonSnapshot(overrides = {}, timeoutMs) {
     const deps = dependencies(overrides);
     return {
-        info: await deps.getDaemonInfo(),
+        info: await deps.getDaemonInfo(timeoutMs),
         pidInfo: deps.readPid(),
         socketExists: process.platform !== 'win32' && existsSync(getDaemonSocketPath()),
     };
@@ -44,12 +61,13 @@ export function daemonSnapshotIsFresh(config, snapshot, version = getPackageVers
 /** Caller must hold the daemon start lock until restore completes. */
 export async function suspendDaemonForExclusiveAccessLocked(config, timeoutMs, options = {}) {
     const deps = dependencies(options.dependencies ?? {});
-    const snapshot = options.snapshot ?? await captureDaemonSnapshot(deps);
+    const remainingTimeoutMs = (phase, action) => requireRemainingDeadlineMs(options.deadlineAtMs, timeoutMs, phase, action);
+    const snapshot = options.snapshot ?? await captureDaemonSnapshot(deps, remainingTimeoutMs('daemon-snapshot', 'inspecting the background daemon'));
     const wasFresh = daemonSnapshotIsFresh(config, snapshot, deps.getPackageVersion());
     const daemonUsesTargetDatabase = !snapshot.info
         || getPowerSyncDbPath(snapshot.info.userId) === getPowerSyncDbPath(config.auth.userId);
     const wasStopped = options.forceStop || daemonUsesTargetDatabase
-        ? await deps.shutdownDaemon(Math.min(timeoutMs, 10_000), snapshot.info?.instanceId)
+        ? await deps.shutdownDaemon(Math.min(remainingTimeoutMs('daemon-shutdown', 'stopping the background daemon'), 10_000), snapshot.info?.instanceId)
         : false;
     return {
         snapshot,
@@ -59,22 +77,26 @@ export async function suspendDaemonForExclusiveAccessLocked(config, timeoutMs, o
     };
 }
 /** Caller must hold the daemon start lock. */
-export async function restoreSuspendedDaemonLocked(suspended, overrides = {}) {
+export async function restoreSuspendedDaemonLocked(suspended, overrides = {}, options = {}) {
     if (!suspended.wasStopped || !suspended.wasFresh) {
         return false;
     }
     const deps = dependencies(overrides);
-    await deps.startDaemonLocked(suspended.port, true, { quiet: true });
+    await deps.startDaemonLocked(suspended.port, true, {
+        quiet: true,
+        timeoutMs: options.timeoutMs,
+    });
     return true;
 }
 export async function withDaemonExclusiveAccess(config, timeoutMs, run, overrides = {}, options = {}) {
     const deps = dependencies(overrides);
-    const remainingTimeoutMs = () => options.deadlineAtMs === undefined
-        ? timeoutMs
-        : Math.max(1, Math.min(timeoutMs, options.deadlineAtMs - Date.now()));
-    const releaseStartLock = await deps.acquireStartLock(remainingTimeoutMs());
+    const operationDeadlineAtMs = options.operationDeadlineAtMs ?? options.deadlineAtMs;
+    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 suspended = null;
     let restoreAllowed = true;
+    let cleanupError;
     let outcome;
     const control = {
         suppressRestore() {
@@ -82,7 +104,8 @@ export async function withDaemonExclusiveAccess(config, timeoutMs, run, override
         },
     };
     try {
-        suspended = await suspendDaemonForExclusiveAccessLocked(config, remainingTimeoutMs(), {
+        suspended = await suspendDaemonForExclusiveAccessLocked(config, remainingOperationTimeoutMs('daemon-suspend', 'suspending the background daemon'), {
+            deadlineAtMs: operationDeadlineAtMs,
             dependencies: deps,
         });
         try {
@@ -97,22 +120,39 @@ export async function withDaemonExclusiveAccess(config, timeoutMs, run, override
     }
     finally {
         if (suspended && restoreAllowed) {
+            const suspendedDaemon = suspended;
             try {
-                await restoreSuspendedDaemonLocked(suspended, deps);
+                await runWithinDeadline(() => restoreSuspendedDaemonLocked(suspendedDaemon, deps, {
+                    timeoutMs: remainingCleanupTimeoutMs(),
+                }), {
+                    deadlineAtMs: options.deadlineAtMs,
+                    maximumTimeoutMs: timeoutMs,
+                    createTimeoutError: () => createLifecycleDeadlineError('daemon-restore', 'restoring the background daemon'),
+                });
             }
             catch (error) {
+                cleanupError = error;
                 deps.printWarning(`warning: failed to restore daemon after local command: ${errorMessage(error)}`);
             }
         }
         try {
-            await releaseStartLock();
+            await runWithinDeadline(releaseStartLock, {
+                deadlineAtMs: options.deadlineAtMs,
+                maximumTimeoutMs: timeoutMs,
+                createTimeoutError: () => createLifecycleDeadlineError('daemon-lock-release', 'releasing the daemon lifecycle lock'),
+                runWhenExpired: true,
+            });
         }
         catch (error) {
+            cleanupError ??= error;
             deps.printWarning(`warning: failed to release daemon lifecycle lock: ${errorMessage(error)}`);
         }
     }
     if (!outcome.ok) {
         throw outcome.error;
     }
+    if (cleanupError && options.cleanupFailureMode === 'throw') {
+        throw cleanupError;
+    }
     return outcome.value;
 }

package/dist/daemon/pid.d.ts

@@ -19,5 +19,5 @@ export declare function removePid(expectedInstanceId?: string, options?: {
     expectedPid?: number;
 }): boolean;
 export declare function isProcessRunning(pid: number): boolean;
-export declare function isLegacyDaemonProcess(pid: number, daemonUptimeMs: number): Promise<boolean>;
+export declare function isLegacyDaemonProcess(pid: number, daemonUptimeMs: number, timeoutMs?: number): Promise<boolean>;
 export declare function acquireDaemonStartLock(timeoutMs?: number): Promise<() => Promise<void>>;

package/dist/daemon/pid.js

@@ -139,10 +139,13 @@ function commandLooksLikeLegacyDaemon(command) {
     return /(?:^|[\\/\s])dino(?:x)?(?:\.[cm]?[jt]s)?["']?\s+daemon\s+start(?:\s|$)/i.test(command)
         && /(?:^|\s)--no-detach(?:\s|$)/.test(command);
 }
-export async function isLegacyDaemonProcess(pid, daemonUptimeMs) {
+export async function isLegacyDaemonProcess(pid, daemonUptimeMs, timeoutMs = 2_000) {
     if (!Number.isInteger(pid) || pid <= 0 || !Number.isFinite(daemonUptimeMs) || daemonUptimeMs < 0) {
         return false;
     }
+    const commandTimeoutMs = Number.isFinite(timeoutMs)
+        ? Math.max(1, Math.min(2_000, Math.floor(timeoutMs)))
+        : 2_000;
     try {
         if (process.platform === 'win32') {
             const command = [
@@ -152,7 +155,7 @@ export async function isLegacyDaemonProcess(pid, daemonUptimeMs) {
                 '  [Console]::Write($p.CommandLine);',
                 '}',
             ].join(' ');
-            const { stdout } = await execFileAsync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', command], { encoding: 'utf8', timeout: 2_000, maxBuffer: 64 * 1024 });
+            const { stdout } = await execFileAsync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', command], { encoding: 'utf8', timeout: commandTimeoutMs, maxBuffer: 64 * 1024 });
             const newline = stdout.indexOf('\n');
             if (newline < 0) {
                 return false;
@@ -163,7 +166,7 @@ export async function isLegacyDaemonProcess(pid, daemonUptimeMs) {
                 && Math.abs(processUptimeMs - daemonUptimeMs) <= LEGACY_DAEMON_UPTIME_TOLERANCE_MS
                 && commandLooksLikeLegacyDaemon(stdout.slice(newline + 1).trim());
         }
-        const { stdout } = await execFileAsync('ps', ['-ww', '-p', String(pid), '-o', 'etime=', '-o', 'command='], { encoding: 'utf8', timeout: 2_000, maxBuffer: 64 * 1024 });
+        const { stdout } = await execFileAsync('ps', ['-ww', '-p', String(pid), '-o', 'etime=', '-o', 'command='], { encoding: 'utf8', timeout: commandTimeoutMs, maxBuffer: 64 * 1024 });
         const match = stdout.trim().match(/^(\S+)\s+([\s\S]+)$/);
         if (!match) {
             return false;