@dinoxx/dinox-cli 2.13.1 → 2.14.0

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

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