@dinoxx/dinox-cli 2.13.0 → 2.14.0

package/dist/daemon/client.js

@@ -1,6 +1,7 @@
 import { request as httpRequest } from 'node:http';
 import { existsSync } from 'node:fs';
 import { getDaemonSocketPath, isLegacyDaemonProcess, isProcessRunning, readPid, removePid, } from './pid.js';
+import { getPackageVersion } from '../utils/version.js';
 import { remainingDeadlineMs } from '../utils/deadline.js';
 import { DinoxError, wireErrorCode } from '../utils/errors.js';
 const DEFAULT_DAEMON_REQUEST_TIMEOUT_MS = 10_000;
@@ -34,6 +35,7 @@ export async function sendDaemonRequest(method, params, requestOptions = {}) {
     };
     return new Promise((resolve, reject) => {
         let settled = false;
+        let connected = false;
         let deadlineTimer;
         const finalize = (error, value) => {
             if (settled)
@@ -43,6 +45,8 @@ export async function sendDaemonRequest(method, params, requestOptions = {}) {
                 clearTimeout(deadlineTimer);
             }
             if (error) {
+                if (error instanceof Error)
+                    Object.assign(error, { requestWritten: connected });
                 reject(error);
                 return;
             }
@@ -66,7 +70,7 @@ export async function sendDaemonRequest(method, params, requestOptions = {}) {
             let totalBytes = 0;
             res.on('data', (chunk) => {
                 totalBytes += chunk.length;
-                if (totalBytes > MAX_DAEMON_RESPONSE_BYTES) {
+                if (method !== 'command.execute' && totalBytes > MAX_DAEMON_RESPONSE_BYTES) {
                     req.destroy(new Error('Daemon response too large'));
                     return;
                 }
@@ -92,10 +96,19 @@ export async function sendDaemonRequest(method, params, requestOptions = {}) {
                 }
             });
         });
+        req.on('socket', socket => {
+            if (!socket.connecting)
+                connected = true;
+            socket.once('connect', () => { connected = true; });
+        });
         req.on('timeout', () => {
             req.destroy(new Error('Daemon request timed out'));
         });
         req.on('error', (error) => finalize(error));
+        req.on('response', res => {
+            res.on('aborted', () => finalize(new Error('Daemon response interrupted')));
+            res.on('error', error => finalize(error));
+        });
         deadlineTimer = setTimeout(() => {
             req.destroy(new Error('Daemon request timed out'));
         }, timeoutMs);
@@ -282,6 +295,16 @@ export async function waitForFreshDaemon(expectedVersion, expectedUserId, expect
         }
     }
 }
+/** Daemon log context for a stop request; never carries credentials. */
+function redactRequesterCommand(argv) {
+    return argv.join(' ')
+        .replace(/(auth\s+login)\b[\s\S]*/i, '$1 [REDACTED]')
+        .replace(/((?:--)?[\w-]*(?:token|authorization|secret|password|api[-_]?key)[\w-]*[=\s]+)(?:Bearer\s+)?[^\s]+/gi, '$1[REDACTED]')
+        .replace(/\bBearer\s+\S+/gi, 'Bearer [REDACTED]')
+        .replace(/\beyJ[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+){1,2}\b/g, '[REDACTED]')
+        .replace(/\b[A-Za-z0-9_-]{32,}\b/g, '[REDACTED]')
+        .slice(0, 200);
+}
 /** Request shutdown of one exact daemon instance and reject if the socket changed owners. */
 export async function requestDaemonShutdown(expectedInstanceId, timeoutMs = 2_000) {
     if (!expectedInstanceId) {
@@ -290,7 +313,14 @@ export async function requestDaemonShutdown(expectedInstanceId, timeoutMs = 2_00
             recoverable: true,
         });
     }
-    const result = await sendDaemonRequest('shutdown', { expectedInstanceId }, { timeoutMs });
+    const result = await sendDaemonRequest('shutdown', {
+        expectedInstanceId,
+        requester: {
+            pid: process.pid,
+            version: getPackageVersion(),
+            command: redactRequesterCommand(process.argv.slice(2)),
+        },
+    }, { timeoutMs });
     if (!result
         || typeof result !== 'object'
         || result.stopping !== true

package/dist/daemon/connectivity.d.ts

@@ -0,0 +1,20 @@
+/** How often the daemon checks for a wake from sleep or a network change. */
+export declare const CONNECTIVITY_CHECK_INTERVAL_MS = 10000;
+/** A tick this late means the machine was asleep (timers do not run during sleep). */
+export declare const WAKE_DRIFT_THRESHOLD_MS = 30000;
+export type ConnectivityChange = 'wake' | 'network-change';
+/** Addresses of the non-internal interfaces; changes on Wi-Fi switch, VPN, or link loss. */
+export declare function networkSignature(): string;
+/**
+ * Detects the events after which a long-lived sync stream may be a dead
+ * connection that still reports "connected": a wake from sleep and a change
+ * of network. Call `tick()` every CONNECTIVITY_CHECK_INTERVAL_MS.
+ */
+export declare function createConnectivityWatcher(options: {
+    onChange: (change: ConnectivityChange) => void;
+    now?: () => number;
+    signature?: () => string;
+    intervalMs?: number;
+}): {
+    tick: () => void;
+};

package/dist/daemon/connectivity.js

@@ -0,0 +1,42 @@
+import os from 'node:os';
+/** How often the daemon checks for a wake from sleep or a network change. */
+export const CONNECTIVITY_CHECK_INTERVAL_MS = 10_000;
+/** A tick this late means the machine was asleep (timers do not run during sleep). */
+export const WAKE_DRIFT_THRESHOLD_MS = 30_000;
+/** Addresses of the non-internal interfaces; changes on Wi-Fi switch, VPN, or link loss. */
+export function networkSignature() {
+    const addresses = [];
+    for (const [name, entries] of Object.entries(os.networkInterfaces())) {
+        for (const entry of entries ?? []) {
+            if (!entry.internal)
+                addresses.push(`${name}:${entry.address}`);
+        }
+    }
+    return addresses.sort().join(',');
+}
+/**
+ * Detects the events after which a long-lived sync stream may be a dead
+ * connection that still reports "connected": a wake from sleep and a change
+ * of network. Call `tick()` every CONNECTIVITY_CHECK_INTERVAL_MS.
+ */
+export function createConnectivityWatcher(options) {
+    const now = options.now ?? Date.now;
+    const signature = options.signature ?? networkSignature;
+    const intervalMs = options.intervalMs ?? CONNECTIVITY_CHECK_INTERVAL_MS;
+    let lastTickAt = now();
+    let lastSignature = signature();
+    return {
+        tick() {
+            const tickAt = now();
+            const drift = tickAt - lastTickAt - intervalMs;
+            lastTickAt = tickAt;
+            const currentSignature = signature();
+            const networkChanged = currentSignature !== lastSignature;
+            lastSignature = currentSignature;
+            if (drift >= WAKE_DRIFT_THRESHOLD_MS)
+                options.onChange('wake');
+            else if (networkChanged)
+                options.onChange('network-change');
+        },
+    };
+}

package/dist/daemon/ensure.js

@@ -1,9 +1,12 @@
+import { existsSync } from 'node:fs';
 import { getDaemonInfo, isDaemonFresh, waitForFreshDaemon } from './client.js';
-import { stopDaemonLocked } from './index.js';
+import { matchesRuntimeTokenBinding } from './fresh.js';
+import { restartDaemonLocked, stopDaemonLocked } from './index.js';
 import { DEFAULT_DAEMON_PORT } from './types.js';
-import { launchDaemon } from './launch.js';
+import { daemonServiceSpec, foreignServiceOwner, launchDaemon, usableDaemonService } from './launch.js';
 import { getDaemonLogPath } from './log.js';
-import { acquireDaemonStartLock, } from './pid.js';
+import { acquireDaemonStartLock, getDaemonSocketPath, isProcessRunning, readPid, } from './pid.js';
+import { getDaemonService } from './supervisor.js';
 import { loadConfig } from '../config/store.js';
 import { fingerprintDaemonRuntimeConfig, resolveConfig } from '../config/resolve.js';
 import { hydrateResolvedAuthIdentity } from '../auth/userInfo.js';
@@ -20,13 +23,22 @@ async function hydrateDaemonIdentity(baseConfig) {
         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));
+/**
+ * Refuses to restart or rewrite a service another dino install owns. The data
+ * command then runs in-process; `dino daemon install` (or start/restart)
+ * switches the service to this CLI.
+ */
+async function assertServiceNotForeign() {
+    const service = await usableDaemonService();
+    const owner = service ? foreignServiceOwner(service) : null;
+    if (!service || !owner)
+        return;
+    throw new DinoxError(`The ${service.kind} daemon service belongs to another dino install (${owner}).`, {
+        code: 'DAEMON_SERVICE_FOREIGN',
+        recoverable: true,
+        details: { service: service.kind, owner, definitionPath: service.definitionPath },
+        suggestion: 'Run `dino daemon install` with the dino you want the service to use.',
+    });
 }
 async function ensureDaemonRunningUnlocked() {
     const expectedVersion = getPackageVersion();
@@ -43,15 +55,22 @@ async function ensureDaemonRunningUnlocked() {
         return;
     }
     const expectedIdentity = await hydrateDaemonIdentity(baseConfig);
+    if (info && isDaemonFresh(info, expectedVersion, expectedIdentity.userId, expectedIdentity.tokenFingerprint, expectedIdentity.runtimeConfigFingerprint)) {
+        return;
+    }
+    await assertServiceNotForeign();
     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)) {
+        printHumanReadableWarning('Restarting daemon (version or account changed)...');
+        const service = getDaemonService();
+        if (service?.isInstalled() && info.supervisor === service.kind
+            && service.isCurrent(daemonServiceSpec(service, DEFAULT_DAEMON_PORT))) {
+            await restartDaemonLocked(DEFAULT_DAEMON_PORT, { quiet: true });
             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}`);
@@ -65,6 +84,23 @@ async function ensureDaemonRunningUnlocked() {
         }
     }
     else {
+        // A live process that owns the socket but does not answer is hung; only
+        // launchd / systemd can replace it safely (they know the exact process).
+        const pid = readPid();
+        const service = getDaemonService();
+        if (pid && isProcessRunning(pid.pid) && existsSync(getDaemonSocketPath())
+            && service?.isInstalled() && service.kind !== 'schtasks') {
+            printHumanReadableWarning('warning: daemon is not responding; restarting the service');
+            await service.restart();
+            if (await waitForFreshDaemon(expectedVersion, expectedIdentity.userId, expectedIdentity.tokenFingerprint, expectedIdentity.runtimeConfigFingerprint, DAEMON_READY_TIMEOUT_MS)) {
+                return;
+            }
+            throw new DinoxError('The daemon service is still not responding after a restart.', {
+                code: 'DAEMON_START_FAILED',
+                details: { service: service.kind, logPath: getDaemonLogPath() },
+                suggestion: `Inspect ${getDaemonLogPath()} for the daemon's startup error.`,
+            });
+        }
         printHumanReadableWarning('Starting daemon...');
     }
     const launch = await launchDaemon(DEFAULT_DAEMON_PORT);

package/dist/daemon/forward.d.ts

@@ -0,0 +1,34 @@
+import { loadConfig } from '../config/store.js';
+import { resolveConfig } from '../config/resolve.js';
+import { printHumanReadableWarning } from '../utils/output.js';
+import { getPackageVersion } from '../utils/version.js';
+import { sendDaemonRequest } from './client.js';
+import { envTokenOverridesLogin } from './launch.js';
+import type { CommandExecuteResult } from './types.js';
+/**
+ * Where a CLI invocation runs. Help, version, unknown words and every command
+ * that manages the local install (auth, config, daemon, gateway, doctor, ...)
+ * stay local; `meta schema` is introspection and needs no database.
+ */
+export declare function commandExecutionTarget(input: string[]): 'daemon' | 'local';
+declare const forwardDependencies: {
+    loadConfig: typeof loadConfig;
+    resolveConfig: typeof resolveConfig;
+    isDaemonFresh: (config: ReturnType<typeof resolveConfig>, version: string) => Promise<boolean>;
+    ensureDaemonRunning: () => Promise<void>;
+    sendDaemonRequest: typeof sendDaemonRequest;
+    envTokenOverridesLogin: typeof envTokenOverridesLogin;
+    version: typeof getPackageVersion;
+    cwd: () => string;
+    env: NodeJS.ProcessEnv;
+    note: typeof printHumanReadableWarning;
+};
+export type ForwardDependencies = typeof forwardDependencies;
+/**
+ * Runs a data command inside the daemon. Returns null when it should run
+ * in-process instead: forwarding is disabled or impossible, or failed before
+ * the daemon could have received the request. A failure after that point
+ * throws DAEMON_UNAVAILABLE, never falls back, so a write is not applied twice.
+ */
+export declare function tryForwardToDaemon(argv: string[], overrides?: Partial<ForwardDependencies>): Promise<CommandExecuteResult | null>;
+export {};

package/dist/daemon/forward.js

@@ -0,0 +1,146 @@
+import { randomUUID } from 'node:crypto';
+import { loadConfig } from '../config/store.js';
+import { resolveConfig } from '../config/resolve.js';
+import { DinoxError } from '../utils/errors.js';
+import { printHumanReadableWarning } from '../utils/output.js';
+import { parseSyncTimeoutMs } from '../utils/syncTimeout.js';
+import { getPackageVersion } from '../utils/version.js';
+import { AUTO_REQUEST_ID_PREFIX, requestIdFromArgv } from '../requests/store.js';
+import { matchesRuntimeTokenBinding } from './fresh.js';
+import { getDaemonInfo, sendDaemonRequest } from './client.js';
+import { envTokenOverridesLogin } from './launch.js';
+/** Top-level commands that only need the database; they run inside the daemon. */
+const DAEMON_COMMAND_GROUPS = new Set([
+    'note', 'tag', 'box', 'todo', 'view', 'prop', 'template', 'prompt', 'graph', 'storage', 'meta', 'sync',
+]);
+/**
+ * Where a CLI invocation runs. Help, version, unknown words and every command
+ * that manages the local install (auth, config, daemon, gateway, doctor, ...)
+ * stay local; `meta schema` is introspection and needs no database.
+ */
+export function commandExecutionTarget(input) {
+    const argv = input[0] === '--' ? input.slice(1) : input;
+    if (argv.some(arg => ['--help', '-h', '--version', '-V'].includes(arg)))
+        return 'local';
+    const words = [];
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--') {
+            words.push(...argv.slice(i + 1));
+            break;
+        }
+        if (arg === '--format' || arg === '--sync-timeout' || arg === '--request-id') {
+            i++;
+            continue;
+        }
+        if (arg.startsWith('-'))
+            continue;
+        words.push(arg);
+    }
+    const group = words[0] ?? '';
+    if (!DAEMON_COMMAND_GROUPS.has(group) || (group === 'meta' && words[1] === 'schema'))
+        return 'local';
+    return 'daemon';
+}
+const forwardDependencies = {
+    loadConfig,
+    resolveConfig,
+    isDaemonFresh: async (config, version) => {
+        const info = await getDaemonInfo();
+        return Boolean(info && matchesRuntimeTokenBinding(info, version, config));
+    },
+    ensureDaemonRunning: async () => {
+        await (await import('./ensure.js')).ensureDaemonRunning();
+    },
+    sendDaemonRequest,
+    envTokenOverridesLogin,
+    version: getPackageVersion,
+    cwd: () => process.cwd(),
+    env: process.env,
+    note: printHumanReadableWarning,
+};
+/**
+ * Runs a data command inside the daemon. Returns null when it should run
+ * in-process instead: forwarding is disabled or impossible, or failed before
+ * the daemon could have received the request. A failure after that point
+ * throws DAEMON_UNAVAILABLE, never falls back, so a write is not applied twice.
+ */
+export async function tryForwardToDaemon(argv, overrides = {}) {
+    const deps = { ...forwardDependencies, ...overrides };
+    if (commandExecutionTarget(argv) !== 'daemon' || /^(0|false|off|no)$/i.test(deps.env.DINOX_DAEMON ?? ''))
+        return null;
+    const fallback = (error) => {
+        const reason = (error instanceof Error ? error.message : String(error)).replace(/[\r\n]+/g, ' ');
+        deps.note(`note: daemon unavailable, running in-process (${reason})`);
+        return null;
+    };
+    const suppliedRequestId = requestIdFromArgv(argv);
+    const requestId = suppliedRequestId ?? `${AUTO_REQUEST_ID_PREFIX}${randomUUID()}`;
+    let timeoutMs;
+    let config;
+    const ensureReady = async () => {
+        if (!await deps.isDaemonFresh(config, deps.version()))
+            await deps.ensureDaemonRunning();
+    };
+    try {
+        const raw = await deps.loadConfig();
+        if (deps.envTokenOverridesLogin(raw, deps.env) || !raw.auth?.authorization)
+            return null;
+        let timeout;
+        for (let i = 0; i < argv.length; i++) {
+            if (argv[i] === '--')
+                break;
+            if (argv[i] === '--sync-timeout')
+                timeout = argv[++i];
+            else if (argv[i]?.startsWith('--sync-timeout='))
+                timeout = argv[i].slice(15);
+        }
+        config = deps.resolveConfig(raw);
+        timeoutMs = (parseSyncTimeoutMs(timeout) ?? config.sync.timeoutMs) + 60_000;
+        await ensureReady();
+    }
+    catch (error) {
+        if (error instanceof DinoxError && error.code === 'AUTH_REQUIRED')
+            return null;
+        return fallback(error);
+    }
+    const execute = async () => {
+        const result = await deps.sendDaemonRequest('command.execute', {
+            argv, cwd: deps.cwd(), clientVersion: deps.version(), requestId,
+        }, { timeoutMs });
+        if (!result || typeof result.stdout !== 'string' || typeof result.stderr !== 'string' || !Number.isInteger(result.exitCode)) {
+            throw new Error('Invalid command.execute response');
+        }
+        return result;
+    };
+    const requestError = (error) => error instanceof DinoxError
+        && ['REQUEST_ID_CONFLICT', 'REQUEST_IN_PROGRESS', 'REQUEST_INTERRUPTED', 'INVALID_ARGUMENT'].includes(error.code);
+    try {
+        return await execute();
+    }
+    catch (error) {
+        if (requestError(error))
+            throw error;
+        if ((error instanceof Error && /^Unknown method: command.execute$/i.test(error.message))
+            || error?.requestWritten === false) {
+            return fallback(error);
+        }
+        // Once delivery is uncertain, neither retry failures nor startup failures
+        // may fall back to in-process execution.
+        try {
+            await ensureReady();
+            return await execute();
+        }
+        catch (retryError) {
+            if (requestError(retryError))
+                throw retryError;
+            throw new DinoxError('Daemon command response unavailable; the command may have executed.', {
+                code: 'DAEMON_UNAVAILABLE', cause: retryError, recoverable: true,
+                details: { requestId },
+                suggestion: suppliedRequestId
+                    ? `Rerun the exact same command with --request-id ${requestId} to fetch the outcome.`
+                    : 'Verify the result before retrying the command.',
+            });
+        }
+    }
+}

package/dist/daemon/fresh.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedDinoxConfig } from '../config/types.js';
+import type { getDaemonInfo } from './client.js';
+/** Checks the inexpensive, already-resolved runtime binding. */
+export declare function matchesRuntimeTokenBinding(info: NonNullable<Awaited<ReturnType<typeof getDaemonInfo>>>, version: string, config: ResolvedDinoxConfig): boolean;

package/dist/daemon/fresh.js

@@ -0,0 +1,10 @@
+import { fingerprintDaemonRuntimeConfig } from '../config/resolve.js';
+/** Checks the inexpensive, already-resolved runtime binding. */
+export 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));
+}

package/dist/daemon/index.d.ts

@@ -14,6 +14,8 @@ type DaemonStartResult = {
 type DaemonStartOptions = {
     quiet?: boolean;
     timeoutMs?: number;
+    /** Rewrite a service definition another dino install owns (explicit start/restart only). */
+    takeover?: boolean;
 };
 type DaemonStopResult = {
     stopped: boolean;
@@ -38,9 +40,7 @@ export declare function startDaemonLocked(port: number, detached: boolean, optio
 /** 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<{
+export declare function restartDaemonLocked(port?: number, options?: DaemonStartOptions): Promise<{
     stopped: boolean;
     running: boolean;
     port: number;
@@ -50,9 +50,7 @@ export declare function restartDaemonLocked(port?: number, options?: {
     alreadyRunning: boolean;
     service: DaemonServiceKind | null;
 }>;
-export declare function restartDaemon(port?: number, options?: {
-    quiet?: boolean;
-}): Promise<{
+export declare function restartDaemon(port?: number, options?: DaemonStartOptions): Promise<{
     stopped: boolean;
     running: boolean;
     port: number;
@@ -70,6 +68,13 @@ export declare function restartDaemon(port?: number, options?: {
 export declare function installDaemonService(port?: number): Promise<DaemonInstallResult>;
 /** Stops the managed daemon and removes its service definition. */
 export declare function uninstallDaemonService(): Promise<DaemonUninstallResult>;
+export declare function waitForSavedDaemonLogin(overrides?: Partial<{
+    hasAuth: () => Promise<boolean>;
+    watchConfig: (check: () => void) => () => void;
+    exit: (code: number) => void;
+    onSignal: (handler: () => void) => () => void;
+    pollMs: number;
+}>): Promise<void>;
 export declare const daemonCommandGroup: CommandGroupDescriptor;
 export declare function registerDaemonCommands(program: Command): void;
 export {};