@dinoxx/dinox-cli 1.0.22 → 1.1.0

package/dist/daemon/client.js

@@ -1,11 +1,10 @@
 import { request as httpRequest } from 'node:http';
-import { DEFAULT_DAEMON_PORT } from './types.js';
-import { readPid } from './pid.js';
-const DEFAULT_DAEMON_REQUEST_TIMEOUT_MS = 2_000;
+import { existsSync } from 'node:fs';
+import { getDaemonSocketPath, isLegacyDaemonProcess, isProcessRunning, readPid, removePid, } from './pid.js';
+import { DinoxError } from '../utils/errors.js';
+const DEFAULT_DAEMON_REQUEST_TIMEOUT_MS = 10_000;
 const MAX_DAEMON_RESPONSE_BYTES = 5 * 1024 * 1024;
-export async function sendDaemonRequest(method, params) {
-    const pidInfo = readPid();
-    const port = pidInfo?.port || DEFAULT_DAEMON_PORT;
+export async function sendDaemonRequest(method, params, requestOptions = {}) {
     const request = {
         id: Date.now().toString(),
         method,
@@ -25,15 +24,15 @@ export async function sendDaemonRequest(method, params) {
         };
         const data = JSON.stringify(request);
         const options = {
-            hostname: '127.0.0.1',
-            port,
+            socketPath: getDaemonSocketPath(),
             path: '/',
             method: 'POST',
             headers: {
+                Host: 'dinox-daemon',
                 'Content-Type': 'application/json',
                 'Content-Length': Buffer.byteLength(data),
             },
-            timeout: DEFAULT_DAEMON_REQUEST_TIMEOUT_MS,
+            timeout: requestOptions.timeoutMs ?? DEFAULT_DAEMON_REQUEST_TIMEOUT_MS,
         };
         const req = httpRequest(options, (res) => {
             const statusCode = res.statusCode ?? 0;
@@ -59,7 +58,7 @@ export async function sendDaemonRequest(method, params) {
                         finalize(undefined, response.result);
                     }
                     else {
-                        finalize(new Error(response.error || 'Unknown error'));
+                        finalize(toDaemonError(response.error));
                     }
                 }
                 catch (error) {
@@ -75,12 +74,237 @@ export async function sendDaemonRequest(method, params) {
         req.end();
     });
 }
+function isStructuredDaemonError(value) {
+    return Boolean(value)
+        && typeof value === 'object'
+        && typeof value.message === 'string'
+        && typeof value.code === 'string';
+}
+function toDaemonError(error) {
+    if (isStructuredDaemonError(error)) {
+        if (error.name === 'DinoxError' || error.code !== 'INTERNAL_ERROR') {
+            return new DinoxError(error.message, {
+                code: error.code,
+                details: error.details,
+                suggestion: error.suggestion,
+                suggestedAction: error.suggested_action,
+                recoverable: error.recoverable,
+            });
+        }
+        const plain = new Error(error.message);
+        plain.name = error.name || 'Error';
+        return plain;
+    }
+    return new Error(typeof error === 'string' && error.trim() ? error : 'Unknown error');
+}
 export async function isDaemonRunning() {
+    return (await getDaemonInfo()) !== 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() {
     try {
-        await sendDaemonRequest('ping');
-        return true;
+        const result = await sendDaemonRequest('ping');
+        if (result && typeof result === 'object') {
+            const info = result;
+            return {
+                pid: typeof info.pid === 'number' && Number.isInteger(info.pid) && info.pid > 0 ? info.pid : 0,
+                instanceId: typeof info.instanceId === 'string' ? info.instanceId : '',
+                uptime: typeof info.uptime === 'number' ? info.uptime : 0,
+                version: typeof info.version === 'string' ? info.version : 'unknown',
+                transport: 'socket',
+                socketPath: typeof info.socketPath === 'string' ? info.socketPath : getDaemonSocketPath(),
+                userId: typeof info.userId === 'string' ? info.userId : null,
+                tokenFingerprint: typeof info.tokenFingerprint === 'string' ? info.tokenFingerprint : null,
+                runtimeConfigFingerprint: typeof info.runtimeConfigFingerprint === 'string'
+                    ? info.runtimeConfigFingerprint
+                    : null,
+                authenticated: info.authenticated === true,
+            };
+        }
+        return null;
     }
     catch {
+        return 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
+ * must be restarted before its cached data can be trusted.
+ */
+export function isDaemonFresh(info, expectedVersion, expectedUserId, expectedTokenFingerprint, expectedRuntimeConfigFingerprint) {
+    return info.authenticated
+        && info.version === expectedVersion
+        && info.userId === expectedUserId
+        && info.tokenFingerprint === expectedTokenFingerprint
+        && info.runtimeConfigFingerprint === expectedRuntimeConfigFingerprint;
+}
+export function isLegacyDaemonInfo(info) {
+    return info.pid === 0 && info.instanceId.length === 0;
+}
+export async function shutdownLegacyDaemon(initialInfo, timeoutMs = 5_000) {
+    const pidInfo = readPid();
+    if (!isLegacyDaemonInfo(initialInfo)
+        || !pidInfo
+        || pidInfo.instanceId !== null
+        || !isProcessRunning(pidInfo.pid)
+        || !await isLegacyDaemonProcess(pidInfo.pid, initialInfo.uptime)) {
+        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 confirmedPidInfo = readPid();
+    if (!confirmedInfo
+        || !isLegacyDaemonInfo(confirmedInfo)
+        || confirmedPidInfo?.pid !== pidInfo.pid
+        || confirmedPidInfo.instanceId !== null
+        || !await isLegacyDaemonProcess(pidInfo.pid, confirmedInfo.uptime)) {
+        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`.',
+            recoverable: true,
+        });
+    }
+    try {
+        process.kill(pidInfo.pid, 'SIGTERM');
+    }
+    catch (error) {
+        throw new DinoxError('Failed to stop the verified legacy daemon process.', {
+            code: 'DAEMON_STOP_FAILED',
+            cause: error,
+            suggestion: 'Inspect the reported daemon PID and stop it manually before retrying.',
+            recoverable: true,
+        });
+    }
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const current = await getDaemonInfo();
+        const processRunning = isProcessRunning(pidInfo.pid);
+        if (!current && !processRunning) {
+            removePid(undefined, { expectedPid: pidInfo.pid });
+            return true;
+        }
+        if (current && !isLegacyDaemonInfo(current)) {
+            throw new DinoxError('A replacement daemon started while the legacy daemon was stopping.', {
+                code: 'DAEMON_INSTANCE_CHANGED',
+                details: { replacementInstanceId: current.instanceId },
+                suggestion: 'Retry after checking `dino daemon status`.',
+                recoverable: true,
+            });
+        }
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    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,
+    });
+}
+/** 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()) {
+            return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    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();
+        if (info && isDaemonFresh(info, expectedVersion, expectedUserId, expectedTokenFingerprint, expectedRuntimeConfigFingerprint)) {
+            return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    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) {
+    if (!expectedInstanceId) {
+        throw new DinoxError('Cannot safely stop a daemon without an instance identity.', {
+            code: 'DAEMON_INSTANCE_UNKNOWN',
+            recoverable: true,
+        });
+    }
+    const result = await sendDaemonRequest('shutdown', { expectedInstanceId }, { timeoutMs });
+    if (!result
+        || typeof result !== 'object'
+        || result.stopping !== true
+        || result.instanceId !== expectedInstanceId) {
+        throw new DinoxError('Daemon instance changed before shutdown could be confirmed.', {
+            code: 'DAEMON_INSTANCE_CHANGED',
+            recoverable: true,
+            details: { expectedInstanceId },
+            suggestion: 'Retry after checking `dino daemon status`.',
+        });
+    }
+    return result;
+}
+/** 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();
+    if (!info) {
+        const pidInfo = readPid();
+        const socketExists = process.platform !== 'win32' && existsSync(getDaemonSocketPath());
+        if ((pidInfo && isProcessRunning(pidInfo.pid)) || socketExists) {
+            throw new DinoxError('Daemon process artifacts exist, but its private socket is not responding.', {
+                code: 'DAEMON_UNREACHABLE',
+                suggestion: 'Run `dino daemon status`, inspect the recorded process, and stop it before retrying.',
+                recoverable: true,
+            });
+        }
         return false;
     }
+    if (isLegacyDaemonInfo(info)) {
+        return shutdownLegacyDaemon(info, timeoutMs);
+    }
+    if (expectedInstanceId && info.instanceId !== expectedInstanceId) {
+        throw new DinoxError('Daemon instance changed before exclusive access could be acquired.', {
+            code: 'DAEMON_INSTANCE_CHANGED',
+            details: { expectedInstanceId, actualInstanceId: info.instanceId },
+            suggestion: 'Retry the command after checking `dino daemon status`.',
+            recoverable: true,
+        });
+    }
+    try {
+        await requestDaemonShutdown(info.instanceId, Math.min(timeoutMs, 2_000));
+    }
+    catch (error) {
+        throw new DinoxError('The running daemon could not release the PowerSync runtime.', {
+            code: 'DAEMON_RELEASE_FAILED',
+            cause: error,
+            suggestion: 'Run `dino daemon stop`, then retry the command.',
+            recoverable: true,
+        });
+    }
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const current = await getDaemonInfo();
+        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;
+    }
+    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,
+    });
 }

package/dist/daemon/ensure.js

@@ -1,24 +1,86 @@
 import { spawn } from 'child_process';
-import { isDaemonRunning } from './client.js';
+import { getDaemonInfo, isDaemonFresh, waitForFreshDaemon } from './client.js';
+import { stopDaemonLocked } from './index.js';
 import { DEFAULT_DAEMON_PORT } from './types.js';
-import { printHumanReadableLine } from '../utils/output.js';
-export async function ensureDaemonRunning() {
-    if (await isDaemonRunning()) {
-        return;
-    }
-    printHumanReadableLine('Starting daemon...');
+import { acquireDaemonStartLock, } from './pid.js';
+import { loadConfig } from '../config/store.js';
+import { fingerprintDaemonRuntimeConfig, resolveConfig } from '../config/resolve.js';
+import { hydrateResolvedAuthIdentity } from '../auth/userInfo.js';
+import { getPackageVersion } from '../utils/version.js';
+import { printHumanReadableWarning } from '../utils/output.js';
+import { withAsyncRelease } from '../utils/asyncRelease.js';
+const DAEMON_READY_TIMEOUT_MS = 10_000;
+const DAEMON_CHILD_ENV = 'DINOX_INTERNAL_DAEMON_CHILD';
+async function hydrateDaemonIdentity(baseConfig) {
+    const { config } = await hydrateResolvedAuthIdentity(baseConfig, { timeoutMs: baseConfig.sync.timeoutMs });
+    return {
+        userId: config.auth.userId ?? null,
+        tokenFingerprint: config.auth.tokenFingerprint ?? null,
+        runtimeConfigFingerprint: fingerprintDaemonRuntimeConfig(config),
+    };
+}
+function spawnDetachedDaemon() {
     const args = ['daemon', 'start', '--port', String(DEFAULT_DAEMON_PORT), '--no-detach'];
-    const child = spawn(process.argv[0], [process.argv[1], ...args], {
+    const entrypoint = process.argv[1];
+    if (!entrypoint) {
+        throw new Error('Cannot determine the CLI entrypoint for daemon startup');
+    }
+    const child = spawn(process.execPath, [...process.execArgv, entrypoint, ...args], {
         detached: true,
         stdio: 'ignore',
+        env: { ...process.env, [DAEMON_CHILD_ENV]: '1' },
     });
     child.unref();
-    for (let i = 0; i < 10; i++) {
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        if (await isDaemonRunning()) {
-            printHumanReadableLine('Daemon started');
+    return child;
+}
+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));
+}
+async function ensureDaemonRunningUnlocked() {
+    const expectedVersion = getPackageVersion();
+    const baseConfig = resolveConfig(await loadConfig());
+    const info = await getDaemonInfo();
+    if (info && matchesRuntimeTokenBinding(info, expectedVersion, baseConfig)) {
+        return;
+    }
+    const expectedIdentity = await hydrateDaemonIdentity(baseConfig);
+    if (info) {
+        // A daemon is reachable — make sure it is the *right* one. It holds a long-lived
+        // PowerSync connection bound to whatever account/version it started with, so after
+        // `auth login` (new userId) or `dino update` (new version) the running daemon would
+        // otherwise keep serving stale or wrong-account data. Restart it when it drifts.
+        if (isDaemonFresh(info, expectedVersion, expectedIdentity.userId, expectedIdentity.tokenFingerprint, expectedIdentity.runtimeConfigFingerprint)) {
             return;
         }
+        printHumanReadableWarning('Restarting daemon (version or account changed)...');
+        await stopDaemonLocked().catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            printHumanReadableWarning(`warning: failed to stop stale daemon: ${message}`);
+        });
+        const afterStop = await getDaemonInfo();
+        if (afterStop) {
+            if (isDaemonFresh(afterStop, expectedVersion, expectedIdentity.userId, expectedIdentity.tokenFingerprint, expectedIdentity.runtimeConfigFingerprint)) {
+                return;
+            }
+            throw new Error('Stale daemon is still responding after restart attempt');
+        }
     }
+    else {
+        printHumanReadableWarning('Starting daemon...');
+    }
+    const child = spawnDetachedDaemon();
+    if (await waitForFreshDaemon(expectedVersion, expectedIdentity.userId, expectedIdentity.tokenFingerprint, expectedIdentity.runtimeConfigFingerprint, DAEMON_READY_TIMEOUT_MS)) {
+        printHumanReadableWarning('Daemon started');
+        return;
+    }
+    child.kill('SIGTERM');
     throw new Error('Failed to start daemon');
 }
+export async function ensureDaemonRunning() {
+    await withAsyncRelease(() => acquireDaemonStartLock(), () => ensureDaemonRunningUnlocked());
+}

package/dist/daemon/index.d.ts

@@ -1,4 +1,46 @@
 import { Command } from 'commander';
 import type { CommandGroupDescriptor } from '../commands/descriptor/types.js';
+type DaemonStartResult = {
+    running: boolean;
+    port: number;
+    socketPath: string;
+    transport: 'socket';
+    detached: boolean;
+    alreadyRunning: boolean;
+};
+type DaemonStopResult = {
+    stopped: boolean;
+    wasRunning: boolean;
+    stalePidFile: boolean;
+};
+export declare function startDaemonLocked(port: number, detached: boolean, options?: {
+    quiet?: boolean;
+}): Promise<DaemonStartResult>;
+/** Caller must hold the daemon start lock. */
+export declare function stopDaemonLocked(): Promise<DaemonStopResult>;
+export declare function stopDaemon(): Promise<DaemonStopResult>;
+export declare function restartDaemonLocked(port?: number, options?: {
+    quiet?: boolean;
+}): Promise<{
+    stopped: boolean;
+    running: boolean;
+    port: number;
+    socketPath: string;
+    transport: 'socket';
+    detached: boolean;
+    alreadyRunning: boolean;
+}>;
+export declare function restartDaemon(port?: number, options?: {
+    quiet?: boolean;
+}): Promise<{
+    stopped: boolean;
+    running: boolean;
+    port: number;
+    socketPath: string;
+    transport: 'socket';
+    detached: boolean;
+    alreadyRunning: boolean;
+}>;
 export declare const daemonCommandGroup: CommandGroupDescriptor;
 export declare function registerDaemonCommands(program: Command): void;
+export {};