@dinoxx/dinox-cli 2.5.2 → 2.6.0

package/dist/commands/gateway/index.js

@@ -1,11 +1,12 @@
-import { isDaemonRunning, sendDaemonRequest } from '../../daemon/client.js';
+import { getDaemonInfo, isDaemonRunning, sendDaemonRequest } from '../../daemon/client.js';
+import { getDaemonService } from '../../daemon/supervisor.js';
 import { ensureDaemonRunning } from '../../daemon/ensure.js';
 import { loadConfig } from '../../config/store.js';
 import { addGateway, adoptDetectedAgent, getGatewaysFilePath, loadGateways, removeGateway, } from '../../gateway/config.js';
 import { detectAcpAgents, inferAgentId } from '../../gateway/detect.js';
 import { serveDinoxMcpOverStdio } from '../../gateway/mcpServer.js';
 import { DinoxError } from '../../utils/errors.js';
-import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess } from '../../utils/output.js';
+import { getRequestedStructuredOutputFormat, printHumanReadableLine, printHumanReadableWarning, printSuccess, } from '../../utils/output.js';
 import { registerCommandGroup } from '../descriptor/register.js';
 import { FORMAT_OPTIONS } from '../schema/globalOptions.js';
 const GATEWAY_KINDS = ['acp', 'echo'];
@@ -42,13 +43,32 @@ function describeGateway(gateway) {
         enabled: gateway.enabled,
     };
 }
+/**
+ * Gateways live exactly as long as the daemon. One not owned by a service
+ * manager belongs to the shell or agent session that started it and goes
+ * offline with it, so say so where it matters (stderr, so JSON stays clean).
+ */
+async function warnIfDaemonUnmanaged() {
+    if (!getDaemonService())
+        return;
+    const info = await getDaemonInfo();
+    if (info && !info.supervisor) {
+        printHumanReadableWarning('warning: gateways run in a daemon owned by the shell or agent session that started it, and go offline when that session ends. Run `dino daemon install` to keep them online.');
+    }
+}
 /** Applies the account's gateways to the running daemon, starting it when needed. */
 async function applyToDaemon() {
+    let gateways;
     if (!(await isDaemonRunning())) {
         await ensureDaemonRunning();
-        return (await sendDaemonRequest('gateway.status')).gateways;
+        gateways = (await sendDaemonRequest('gateway.status')).gateways;
+    }
+    else {
+        gateways = (await sendDaemonRequest('gateway.reload', undefined, { timeoutMs: 30_000 })).gateways;
     }
-    return (await sendDaemonRequest('gateway.reload', undefined, { timeoutMs: 30_000 })).gateways;
+    if (gateways.length > 0)
+        await warnIfDaemonUnmanaged();
+    return gateways;
 }
 function printStatuses(statuses) {
     if (statuses.length === 0) {
@@ -162,6 +182,8 @@ async function runRemove(context) {
 async function runStatus() {
     await ensureDaemonRunning();
     const { gateways } = (await sendDaemonRequest('gateway.status'));
+    if (gateways.length > 0)
+        await warnIfDaemonUnmanaged();
     if (getRequestedStructuredOutputFormat()) {
         printSuccess({ gateways });
         return;

package/dist/commands/schema/renderSkills.js

@@ -4,7 +4,7 @@ import { listErrorCodes } from '../../utils/errorCodes.js';
 import { listCommandSchemas } from './spec.js';
 const SECTION_ORDER = [
     { title: 'Auth', paths: ['auth.login', 'auth.logout', 'auth.status'] },
-    { title: 'Daemon', paths: ['daemon.start', 'daemon.status', 'daemon.restart', 'daemon.stop'] },
+    { title: 'Daemon', paths: ['daemon.start', 'daemon.status', 'daemon.restart', 'daemon.stop', 'daemon.install', 'daemon.uninstall'] },
     {
         title: 'Agent Gateways',
         paths: ['gateway.detect', 'gateway.add', 'gateway.list', 'gateway.remove', 'gateway.status', 'gateway.reload', 'gateway.mcp'],

package/dist/daemon/ensure.js

@@ -1,7 +1,8 @@
-import { spawn } from 'child_process';
 import { getDaemonInfo, isDaemonFresh, waitForFreshDaemon } from './client.js';
 import { stopDaemonLocked } from './index.js';
 import { DEFAULT_DAEMON_PORT } from './types.js';
+import { launchDaemon } from './launch.js';
+import { getDaemonLogPath } from './log.js';
 import { acquireDaemonStartLock, } from './pid.js';
 import { loadConfig } from '../config/store.js';
 import { fingerprintDaemonRuntimeConfig, resolveConfig } from '../config/resolve.js';
@@ -9,8 +10,8 @@ import { hydrateResolvedAuthIdentity } from '../auth/userInfo.js';
 import { getPackageVersion } from '../utils/version.js';
 import { printHumanReadableWarning } from '../utils/output.js';
 import { withAsyncRelease } from '../utils/asyncRelease.js';
+import { DinoxError } from '../utils/errors.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 {
@@ -19,20 +20,6 @@ async function hydrateDaemonIdentity(baseConfig) {
         runtimeConfigFingerprint: fingerprintDaemonRuntimeConfig(config),
     };
 }
-function spawnDetachedDaemon() {
-    const args = ['daemon', 'start', '--port', String(DEFAULT_DAEMON_PORT), '--no-detach'];
-    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();
-    return child;
-}
 function matchesRuntimeTokenBinding(info, version, config) {
     return Boolean(config.auth.authorization
         && info.authenticated
@@ -73,13 +60,17 @@ async function ensureDaemonRunningUnlocked() {
     else {
         printHumanReadableWarning('Starting daemon...');
     }
-    const child = spawnDetachedDaemon();
+    const launch = await launchDaemon(DEFAULT_DAEMON_PORT);
     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');
+    launch.abort();
+    throw new DinoxError('Failed to start daemon', {
+        code: 'DAEMON_START_FAILED',
+        details: { service: launch.service, logPath: getDaemonLogPath() },
+        suggestion: `Inspect ${getDaemonLogPath()} for the daemon's startup error.`,
+    });
 }
 export async function ensureDaemonRunning() {
     await withAsyncRelease(() => acquireDaemonStartLock(), () => ensureDaemonRunningUnlocked());

package/dist/daemon/env.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Makes sure the Node runtime running the CLI is on PATH, so agents installed
+ * as `#!/usr/bin/env node` scripts still start under a service manager's
+ * minimal PATH.
+ */
+export declare function withRuntimeOnPath(pathValue: string | undefined, execPath?: string): string;
+/** The environment a daemon process starts with: an allow-list of the caller's. */
+export declare function buildDaemonEnv(source?: NodeJS.ProcessEnv, execPath?: string): Record<string, string>;

package/dist/daemon/env.js

@@ -0,0 +1,81 @@
+import path from 'node:path';
+/**
+ * Variables the daemon may inherit from whoever starts it. Everything else is
+ * dropped: the daemon outlives its caller, so it must not keep a coding agent's
+ * session markers (CLAUDECODE, CLAUDE_CODE_SESSION_ID, ...), credentials
+ * (ANTHROPIC_AUTH_TOKEN, ...) or app identity (XPC_SERVICE_NAME,
+ * __CFBundleIdentifier) and hand them on to the agents its gateways spawn.
+ * Agent credentials belong in `dino gateway add --env KEY=VALUE`.
+ */
+const INHERITED_NAMES = new Set([
+    'HOME',
+    'USER',
+    'LOGNAME',
+    'SHELL',
+    'PATH',
+    'TMPDIR',
+    'LANG',
+    'TZ',
+    'XDG_CONFIG_HOME',
+    'XDG_DATA_HOME',
+    'XDG_STATE_HOME',
+    'XDG_CACHE_HOME',
+    'XDG_RUNTIME_DIR',
+    'HTTP_PROXY',
+    'HTTPS_PROXY',
+    'ALL_PROXY',
+    'NO_PROXY',
+    'NODE_EXTRA_CA_CERTS',
+    'SSL_CERT_FILE',
+    'SSL_CERT_DIR',
+    'POWERSYNC_TOKEN_ENDPOINT',
+    // Windows process essentials.
+    'APPDATA',
+    'LOCALAPPDATA',
+    'USERPROFILE',
+    'HOMEDRIVE',
+    'HOMEPATH',
+    'SystemRoot',
+    'windir',
+    'ComSpec',
+    'PATHEXT',
+    'TEMP',
+    'TMP',
+    'ProgramData',
+    'ProgramFiles',
+    'ProgramFiles(x86)',
+]);
+const INHERITED_PREFIXES = ['DINOX_', 'LC_'];
+/** Internal markers the parent sets for the child; never inherited from outside. */
+const INTERNAL_NAMES = new Set(['DINOX_INTERNAL_DAEMON_CHILD', 'DINOX_DAEMON_SUPERVISOR']);
+const INHERITED_UPPER = new Set([...INHERITED_NAMES].map((name) => name.toUpperCase()));
+// Compared upper-cased: Windows names are case-insensitive (`Path`, `SystemRoot`).
+function isInherited(name) {
+    const upper = name.toUpperCase();
+    if (INTERNAL_NAMES.has(upper))
+        return false;
+    return INHERITED_UPPER.has(upper) || INHERITED_PREFIXES.some((prefix) => upper.startsWith(prefix));
+}
+/**
+ * Makes sure the Node runtime running the CLI is on PATH, so agents installed
+ * as `#!/usr/bin/env node` scripts still start under a service manager's
+ * minimal PATH.
+ */
+export function withRuntimeOnPath(pathValue, execPath = process.execPath) {
+    const runtimeDir = path.dirname(execPath);
+    const entries = (pathValue ?? '').split(path.delimiter).filter(Boolean);
+    if (!entries.includes(runtimeDir))
+        entries.unshift(runtimeDir);
+    return entries.join(path.delimiter);
+}
+/** The environment a daemon process starts with: an allow-list of the caller's. */
+export function buildDaemonEnv(source = process.env, execPath = process.execPath) {
+    const env = {};
+    for (const [name, value] of Object.entries(source)) {
+        if (typeof value === 'string' && isInherited(name))
+            env[name] = value;
+    }
+    const pathKey = Object.keys(env).find((name) => name.toUpperCase() === 'PATH') ?? 'PATH';
+    env[pathKey] = withRuntimeOnPath(env[pathKey], execPath);
+    return env;
+}

package/dist/daemon/index.d.ts

@@ -1,5 +1,6 @@
 import { Command } from 'commander';
 import type { CommandGroupDescriptor } from '../commands/descriptor/types.js';
+import { type DaemonServiceKind } from './supervisor.js';
 type DaemonStartResult = {
     running: boolean;
     port: number;
@@ -7,6 +8,8 @@ type DaemonStartResult = {
     transport: 'socket';
     detached: boolean;
     alreadyRunning: boolean;
+    /** Service manager that started it; null for a detached child or foreground run. */
+    service: DaemonServiceKind | null;
 };
 type DaemonStartOptions = {
     quiet?: boolean;
@@ -17,6 +20,20 @@ type DaemonStopResult = {
     wasRunning: boolean;
     stalePidFile: boolean;
 };
+type DaemonInstallResult = {
+    installed: boolean;
+    service: DaemonServiceKind;
+    label: string;
+    definitionPath: string;
+    logPath: string;
+    running: boolean;
+    replacedRunning: boolean;
+};
+type DaemonUninstallResult = {
+    uninstalled: boolean;
+    service: DaemonServiceKind | null;
+    definitionPath: string | null;
+};
 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>;
@@ -31,6 +48,7 @@ export declare function restartDaemonLocked(port?: number, options?: {
     transport: 'socket';
     detached: boolean;
     alreadyRunning: boolean;
+    service: DaemonServiceKind | null;
 }>;
 export declare function restartDaemon(port?: number, options?: {
     quiet?: boolean;
@@ -42,7 +60,16 @@ export declare function restartDaemon(port?: number, options?: {
     transport: 'socket';
     detached: boolean;
     alreadyRunning: boolean;
+    service: DaemonServiceKind | null;
 }>;
+/**
+ * Hands the daemon to the platform's service manager so it no longer belongs
+ * to whichever process first started it, then waits until the managed
+ * instance answers with the current identity.
+ */
+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 const daemonCommandGroup: CommandGroupDescriptor;
 export declare function registerDaemonCommands(program: Command): void;
 export {};

package/dist/daemon/index.js

@@ -1,4 +1,3 @@
-import { spawn } from 'child_process';
 import { existsSync } from 'node:fs';
 import { DaemonServer } from './server.js';
 import { DEFAULT_DAEMON_PORT } from './types.js';
@@ -14,12 +13,32 @@ 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 { DAEMON_CHILD_ENV, daemonServiceSpec, envTokenOverridesLogin, launchDaemon } from './launch.js';
+import { getDaemonLogPath, rotateDaemonLog, writeDaemonLogLine } from './log.js';
+import { DAEMON_SERVICE_ENV, getDaemonService } from './supervisor.js';
+import { normalizeAuthToken } from '../utils/authToken.js';
 const DAEMON_STOP_POLL_INTERVAL_MS = 100;
 const DAEMON_STOP_TIMEOUT_MS = 5_000;
-const DAEMON_CHILD_ENV = 'DINOX_INTERNAL_DAEMON_CHILD';
+const DAEMON_SERVICE_READY_TIMEOUT_MS = 20_000;
+const DAEMON_CRASH_STOP_TIMEOUT_MS = 5_000;
 async function withDaemonStartLock(run) {
     return withAsyncRelease(() => acquireDaemonStartLock(), run);
 }
+function installedServiceKind() {
+    const service = getDaemonService();
+    return service?.isInstalled() ? service.kind : null;
+}
+function notRunningStatus(fields) {
+    return {
+        running: false,
+        transport: 'socket',
+        version: null,
+        service: installedServiceKind(),
+        supervised: null,
+        logPath: getDaemonLogPath(),
+        ...fields,
+    };
+}
 function runningDaemonStatus(info, pidInfo) {
     const pidFileMatches = Boolean(pidInfo
         && pidInfo.pid === info.pid
@@ -33,6 +52,9 @@ function runningDaemonStatus(info, pidInfo) {
         transport: 'socket',
         version: info.version,
         stalePidFile: Boolean(pidInfo && !pidFileMatches),
+        service: installedServiceKind(),
+        supervised: Boolean(info.supervisor),
+        logPath: getDaemonLogPath(),
     };
 }
 function parsePort(value) {
@@ -110,7 +132,7 @@ export async function startDaemonLocked(port, detached, options = {}) {
     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 };
+            return { running: true, port, socketPath: getDaemonSocketPath(), transport: 'socket', detached, alreadyRunning: true, service: runningInfo.supervisor ?? null };
         }
         throw new DinoxError('A stale daemon is already responding. Run `dino daemon restart` and retry.', {
             code: 'DAEMON_STALE',
@@ -119,54 +141,78 @@ export async function startDaemonLocked(port, detached, options = {}) {
     }
     const expected = await expectedDaemonIdentity(baseConfig, remainingStartTimeoutMs('auth-hydration'));
     if (detached) {
-        const args = ['daemon', 'start', '--port', String(port), '--no-detach'];
-        const entrypoint = process.argv[1];
-        if (!entrypoint) {
-            throw new DinoxError('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();
+        const launch = await launchDaemon(port);
         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');
+            launch.abort();
+            throw new DinoxError('Failed to start daemon', {
+                code: 'DAEMON_START_FAILED',
+                details: { service: launch.service, logPath: getDaemonLogPath() },
+                suggestion: `Inspect ${getDaemonLogPath()} for the daemon's startup error.`,
+            });
         }
-        return { running: true, port, socketPath: getDaemonSocketPath(), transport: 'socket', detached, alreadyRunning: false };
+        return { running: true, port, socketPath: getDaemonSocketPath(), transport: 'socket', detached, alreadyRunning: false, service: launch.service };
     }
     else {
+        await serveDaemonInForeground(port, options);
+    }
+    return { running: true, port, socketPath: getDaemonSocketPath(), transport: 'socket', detached, alreadyRunning: false, service: null };
+}
+/**
+ * Runs the daemon in this process until a signal or shutdown request. A crash
+ * is logged and exits non-zero, so a service manager restarts it; a clean
+ * stop exits 0 and stays stopped.
+ */
+async function serveDaemonInForeground(port, options) {
+    if (process.env[DAEMON_SERVICE_ENV]) {
+        // A service manager holds the log open in append mode; keep it bounded.
+        rotateDaemonLog();
+    }
+    if (!options.quiet) {
+        printHumanReadableLine(`Starting daemon on ${getDaemonSocketPath()}...`);
+    }
+    const server = new DaemonServer();
+    try {
+        await server.initialize();
+        await server.start(port);
+    }
+    catch (error) {
+        await server.stop().catch(() => undefined);
+        throw error;
+    }
+    if (!options.quiet) {
+        printHumanReadableLine(`Daemon running on ${getDaemonSocketPath()} (PID: ${process.pid})`);
+    }
+    writeDaemonLogLine('dinox-daemon', 'started', {
+        pid: process.pid,
+        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(`Starting daemon on ${getDaemonSocketPath()}...`);
-        }
-        const server = new DaemonServer();
-        try {
-            await server.initialize();
-            await server.start(port);
-        }
-        catch (error) {
-            await server.stop().catch(() => undefined);
-            throw error;
-        }
-        if (!options.quiet) {
-            printHumanReadableLine(`Daemon running on ${getDaemonSocketPath()} (PID: ${process.pid})`);
+            printHumanReadableLine('');
+            printHumanReadableLine('Stopping daemon...');
         }
-        process.on('SIGINT', async () => {
-            if (!options.quiet) {
-                printHumanReadableLine('');
-                printHumanReadableLine('Stopping daemon...');
-            }
-            await server.stop();
-            process.exit(0);
-        });
-        process.on('SIGTERM', async () => {
-            await server.stop();
-            process.exit(0);
+        void stopAndExit('SIGINT', 0);
+    });
+    process.on('SIGTERM', () => void stopAndExit('SIGTERM', 0));
+    // No controlling terminal to lose; never let a hangup end the daemon.
+    process.on('SIGHUP', () => undefined);
+    const crash = (kind) => (error) => {
+        writeDaemonLogLine('dinox-daemon', kind, {
+            error: error instanceof Error ? error.stack ?? error.message : String(error),
         });
-    }
-    return { running: true, port, socketPath: getDaemonSocketPath(), transport: 'socket', detached, alreadyRunning: false };
+        void stopAndExit(kind, 1);
+    };
+    process.on('uncaughtException', crash('uncaught exception'));
+    process.on('unhandledRejection', crash('unhandled rejection'));
 }
 async function startDaemon(port, detached = true, options = {}) {
     const internalChild = process.env[DAEMON_CHILD_ENV] === '1';
@@ -241,7 +287,7 @@ async function daemonStatus() {
                 ? removePid(pidInfo.instanceId)
                 : removePid(undefined, { expectedPid: pidInfo.pid });
             if (stalePidFile) {
-                return { running: false, unreachable: false, pid: null, port: null, socketPath: null, transport: 'socket', version: null, stalePidFile: true };
+                return notRunningStatus({ unreachable: false, pid: null, port: null, socketPath: null, stalePidFile: true });
             }
             // A replacement rewrote the PID metadata after the initial snapshot.
             // Re-read once and leave the replacement instance untouched.
@@ -251,28 +297,22 @@ async function daemonStatus() {
                 return runningDaemonStatus(replacementInfo, replacementPidInfo);
             }
             const replacementSocketExists = process.platform !== 'win32' && existsSync(getDaemonSocketPath());
-            return {
-                running: false,
+            return notRunningStatus({
                 unreachable: Boolean(replacementPidInfo || replacementSocketExists),
                 pid: replacementPidInfo?.pid ?? null,
                 port: replacementPidInfo?.port ?? null,
                 socketPath: replacementSocketExists ? getDaemonSocketPath() : null,
-                transport: 'socket',
-                version: null,
                 stalePidFile: false,
-            };
+            });
         }
         const socketExists = process.platform !== 'win32' && existsSync(getDaemonSocketPath());
-        return {
-            running: false,
+        return notRunningStatus({
             unreachable: Boolean(pidInfo || socketExists),
             pid: pidInfo?.pid ?? null,
             port: pidInfo?.port ?? null,
             socketPath: socketExists ? getDaemonSocketPath() : null,
-            transport: 'socket',
-            version: null,
             stalePidFile: false,
-        };
+        });
     }
 }
 export async function restartDaemonLocked(port = DEFAULT_DAEMON_PORT, options = {}) {
@@ -284,6 +324,68 @@ export async function restartDaemonLocked(port = DEFAULT_DAEMON_PORT, options =
 export async function restartDaemon(port = DEFAULT_DAEMON_PORT, options = {}) {
     return withDaemonStartLock(() => restartDaemonLocked(port, options));
 }
+/**
+ * Hands the daemon to the platform's service manager so it no longer belongs
+ * to whichever process first started it, then waits until the managed
+ * instance answers with the current identity.
+ */
+export async function installDaemonService(port = DEFAULT_DAEMON_PORT) {
+    const service = getDaemonService();
+    if (!service) {
+        throw new DinoxError(`No supported service manager on ${process.platform}; keep using \`dino daemon start\`.`, {
+            code: 'DAEMON_SERVICE_UNSUPPORTED',
+            details: { platform: process.platform },
+        });
+    }
+    const raw = await loadConfig();
+    if (!normalizeAuthToken(raw.auth?.authorization)) {
+        throw new DinoxError('The daemon service runs with the saved login, and none is saved.', {
+            code: 'AUTH_REQUIRED',
+            suggestion: 'Run `dino auth login`, then retry `dino daemon install`.',
+        });
+    }
+    if (envTokenOverridesLogin(raw)) {
+        throw new DinoxError('DINOX_TOKEN selects a different account than the saved login, and the daemon service only uses the saved login.', {
+            code: 'DAEMON_SERVICE_UNSUPPORTED',
+            details: { reason: 'env-token' },
+            suggestion: 'Unset DINOX_TOKEN, or save that token with `dino auth login`, then retry.',
+        });
+    }
+    return withDaemonStartLock(async () => {
+        const expected = await expectedDaemonIdentity(resolveConfig(raw));
+        const stopResult = await stopDaemonLocked();
+        await service.install(daemonServiceSpec(service, port));
+        const ready = await waitForFreshDaemon(expected.version, expected.userId, expected.tokenFingerprint, expected.runtimeConfigFingerprint, DAEMON_SERVICE_READY_TIMEOUT_MS);
+        if (!ready) {
+            throw new DinoxError(`The ${service.kind} service was installed, but the daemon did not become ready.`, {
+                code: 'DAEMON_START_FAILED',
+                details: { service: service.kind, definitionPath: service.definitionPath, logPath: getDaemonLogPath() },
+                suggestion: `Inspect ${getDaemonLogPath()}, then run \`dino daemon status\`.`,
+            });
+        }
+        return {
+            installed: true,
+            service: service.kind,
+            label: service.label,
+            definitionPath: service.definitionPath,
+            logPath: getDaemonLogPath(),
+            running: true,
+            replacedRunning: stopResult.stopped,
+        };
+    });
+}
+/** Stops the managed daemon and removes its service definition. */
+export async function uninstallDaemonService() {
+    const service = getDaemonService();
+    if (!service) {
+        return { uninstalled: false, service: null, definitionPath: null };
+    }
+    return withDaemonStartLock(async () => ({
+        uninstalled: await service.uninstall(),
+        service: service.kind,
+        definitionPath: service.definitionPath,
+    }));
+}
 function printDaemonStartResult(result) {
     if (result.alreadyRunning) {
         printHumanReadableLine('Daemon is already running');
@@ -320,10 +422,40 @@ function printDaemonStatusResult(result) {
     printHumanReadableLine(`Transport: ${result.transport}`);
     printHumanReadableLine(`Socket: ${result.socketPath}`);
     printHumanReadableLine(`Version: ${result.version}`);
+    printHumanReadableLine(`Service: ${result.service ?? 'not installed'}${result.service && !result.supervised ? ' (running daemon is not managed by it)' : ''}`);
+    printHumanReadableLine(`Log: ${result.logPath}`);
+    if (!result.supervised) {
+        printHumanReadableLine('Note: this daemon belongs to the process that started it. Run `dino daemon install` to keep it (and agent gateways) running independently.');
+    }
+}
+function printDaemonInstallResult(result) {
+    printHumanReadableLine(`Installed ${result.service} service ${result.label}`);
+    printHumanReadableLine(`Definition: ${result.definitionPath}`);
+    printHumanReadableLine(`Log: ${result.logPath}`);
+    printHumanReadableLine('The daemon now starts at login and restarts after a crash.');
+    if (result.service === 'systemd') {
+        printHumanReadableLine('To keep it running after you log out, run `loginctl enable-linger`.');
+    }
+}
+function printDaemonUninstallResult(result) {
+    if (!result.service) {
+        printHumanReadableLine(`No supported service manager on ${process.platform}; nothing to uninstall.`);
+        return;
+    }
+    printHumanReadableLine(result.uninstalled
+        ? `Removed ${result.service} service; the daemon is stopped.`
+        : 'The daemon service is not installed.');
 }
 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`');
+        return;
+    }
     const result = await startDaemon(port, context.options.detach !== false, { quiet: structured });
     if (!result.running) {
         throw new DinoxError('Failed to start daemon', { code: 'DAEMON_START_FAILED' });
@@ -350,6 +482,22 @@ async function runDaemonStatus() {
     }
     printDaemonStatusResult(result);
 }
+async function runDaemonInstall(context) {
+    const result = await installDaemonService(parsePort(context.options.port));
+    if (getRequestedStructuredOutputFormat()) {
+        printSuccess(result);
+        return;
+    }
+    printDaemonInstallResult(result);
+}
+async function runDaemonUninstall() {
+    const result = await uninstallDaemonService();
+    if (getRequestedStructuredOutputFormat()) {
+        printSuccess(result);
+        return;
+    }
+    printDaemonUninstallResult(result);
+}
 async function runDaemonRestart(context) {
     const structured = Boolean(getRequestedStructuredOutputFormat());
     const result = await restartDaemon(parsePort(context.options.port), { quiet: structured });
@@ -379,7 +527,7 @@ export const daemonCommandGroup = {
                 output: {
                     type: 'structured',
                     summary: 'Daemon start acknowledgement',
-                    fields: ['running', 'transport', 'socketPath', 'port', 'detached', 'alreadyRunning'],
+                    fields: ['running', 'transport', 'socketPath', 'port', 'detached', 'alreadyRunning', 'service'],
                 },
                 examples: ['dino daemon start', 'dino daemon start --port 17321', 'dino daemon start --no-detach'],
             },
@@ -413,7 +561,7 @@ export const daemonCommandGroup = {
                 output: {
                     type: 'structured',
                     summary: 'Daemon process status',
-                    fields: ['running', 'unreachable', 'pid', 'transport', 'socketPath', 'port', 'version', 'stalePidFile'],
+                    fields: ['running', 'unreachable', 'pid', 'transport', 'socketPath', 'port', 'version', 'stalePidFile', 'service', 'supervised', 'logPath'],
                 },
                 examples: ['dino daemon status'],
             },
@@ -431,12 +579,47 @@ export const daemonCommandGroup = {
                 output: {
                     type: 'structured',
                     summary: 'Daemon restart acknowledgement',
-                    fields: ['stopped', 'running', 'transport', 'socketPath', 'port', 'detached', 'alreadyRunning'],
+                    fields: ['stopped', 'running', 'transport', 'socketPath', 'port', 'detached', 'alreadyRunning', 'service'],
                 },
                 examples: ['dino daemon restart', 'dino daemon restart --port 17321'],
             },
             action: runDaemonRestart,
         },
+        {
+            name: 'install',
+            description: 'Run the daemon as a login service (launchd / systemd) so it outlives the shell or agent that started it',
+            options: [{ flags: '--port <number>', description: 'Legacy compatibility field; daemon listens on a private local socket', type: 'number', defaultValue: DEFAULT_DAEMON_PORT }],
+            schema: {
+                path: 'daemon.install',
+                risk: 'write',
+                auth: 'required',
+                globalOptions: FORMAT_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Installed daemon service',
+                    fields: ['installed', 'service', 'label', 'definitionPath', 'logPath', 'running', 'replacedRunning'],
+                },
+                examples: ['dino daemon install'],
+            },
+            action: runDaemonInstall,
+        },
+        {
+            name: 'uninstall',
+            description: 'Stop the daemon service and remove it from the login session',
+            schema: {
+                path: 'daemon.uninstall',
+                risk: 'write',
+                auth: 'none',
+                globalOptions: FORMAT_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Daemon service removal acknowledgement',
+                    fields: ['uninstalled', 'service', 'definitionPath'],
+                },
+                examples: ['dino daemon uninstall'],
+            },
+            action: runDaemonUninstall,
+        },
     ],
 };
 export function registerDaemonCommands(program) {

package/dist/daemon/launch.d.ts

@@ -0,0 +1,27 @@
+import type { DinoxConfig } from '../config/types.js';
+import { type DaemonService, type DaemonServiceKind, type DaemonServiceSpec } from './supervisor.js';
+/** Tells a daemon child its parent holds the start lock (or that it runs under a service). */
+export declare const DAEMON_CHILD_ENV = "DINOX_INTERNAL_DAEMON_CHILD";
+export type DaemonLaunch = {
+    /** The service manager that started it, or null for a detached child process. */
+    service: DaemonServiceKind | null;
+    /** Gives up on a launch that never became ready. */
+    abort(): void;
+};
+/**
+ * A service only knows the saved login. When DINOX_TOKEN selects a different
+ * account, the caller needs a daemon bound to that token, which only a child
+ * of its own environment can have.
+ */
+export declare function envTokenOverridesLogin(raw: DinoxConfig, env?: NodeJS.ProcessEnv): boolean;
+/** What the service definition runs: this CLI, with no secrets written to disk. */
+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>;
+/**
+ * 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.
+ */
+export declare function launchDaemon(port: number): Promise<DaemonLaunch>;

package/dist/daemon/launch.js

@@ -0,0 +1,87 @@
+import { spawn } from 'node:child_process';
+import os from 'node:os';
+import { loadConfig } from '../config/store.js';
+import { DINOX_TOKEN_ENV_VAR, normalizeAuthToken, readEnvAuthToken } from '../utils/authToken.js';
+import { DinoxError } from '../utils/errors.js';
+import { buildDaemonEnv } from './env.js';
+import { closeDaemonLogFd, getDaemonLogPath, openDaemonLogForChild } from './log.js';
+import { ensureDaemonDir } from './pid.js';
+import { DAEMON_SERVICE_ENV, getDaemonService, serviceDefinitionIsStale, } from './supervisor.js';
+/** Tells a daemon child its parent holds the start lock (or that it runs under a service). */
+export const DAEMON_CHILD_ENV = 'DINOX_INTERNAL_DAEMON_CHILD';
+function daemonCommandLine(port) {
+    const entrypoint = process.argv[1];
+    if (!entrypoint) {
+        throw new DinoxError('Cannot determine the CLI entrypoint for daemon startup', { code: 'DAEMON_START_FAILED' });
+    }
+    return {
+        program: process.execPath,
+        args: [...process.execArgv, entrypoint, 'daemon', 'start', '--port', String(port), '--no-detach'],
+    };
+}
+/**
+ * A service only knows the saved login. When DINOX_TOKEN selects a different
+ * account, the caller needs a daemon bound to that token, which only a child
+ * of its own environment can have.
+ */
+export function envTokenOverridesLogin(raw, env = process.env) {
+    const envToken = readEnvAuthToken(env);
+    return Boolean(envToken && envToken !== normalizeAuthToken(raw.auth?.authorization));
+}
+/** What the service definition runs: this CLI, with no secrets written to disk. */
+export function daemonServiceSpec(service, port) {
+    const { program, args } = daemonCommandLine(port);
+    const env = buildDaemonEnv();
+    delete env[DINOX_TOKEN_ENV_VAR];
+    env[DAEMON_SERVICE_ENV] = service.kind;
+    env[DAEMON_CHILD_ENV] = '1';
+    return { program, args, env, workingDirectory: os.homedir(), logPath: getDaemonLogPath() };
+}
+/** The installed service when this caller can use it, else null. */
+export async function usableDaemonService() {
+    const service = getDaemonService();
+    if (!service?.isInstalled())
+        return null;
+    if (envTokenOverridesLogin(await loadConfig()))
+        return null;
+    return service;
+}
+function spawnDetached(port) {
+    const { program, args } = daemonCommandLine(port);
+    const log = openDaemonLogForChild();
+    try {
+        const child = spawn(program, args, {
+            detached: true,
+            stdio: ['ignore', log, log],
+            env: { ...buildDaemonEnv(), [DAEMON_CHILD_ENV]: '1' },
+            cwd: os.homedir(),
+        });
+        child.unref();
+        return { service: null, abort: () => child.kill('SIGTERM') };
+    }
+    finally {
+        closeDaemonLogFd(log);
+    }
+}
+/**
+ * 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.
+ */
+export async function launchDaemon(port) {
+    const service = await usableDaemonService();
+    if (!service)
+        return spawnDetached(port);
+    ensureDaemonDir();
+    const spec = daemonServiceSpec(service, port);
+    if (serviceDefinitionIsStale(service, spec)) {
+        await service.install(spec);
+    }
+    else {
+        await service.start();
+    }
+    // The service manager owns the process; a launch that never becomes ready
+    // is reported with the log path rather than killed here.
+    return { service: service.kind, abort: () => undefined };
+}

package/dist/daemon/log.d.ts

@@ -0,0 +1,12 @@
+export declare function getDaemonLogPath(): string;
+/**
+ * Keeps one previous generation once the log grows past the limit. Copy then
+ * truncate (not rename): a service manager holds the log open in append mode,
+ * so the file must stay the same inode.
+ */
+export declare function rotateDaemonLog(limitBytes?: number): void;
+/** Opens the log for a daemon child's stdout/stderr; the caller closes it after spawning. */
+export declare function openDaemonLogForChild(): number | 'ignore';
+export declare function closeDaemonLogFd(fd: number | 'ignore'): void;
+/** One timestamped line on stderr, which a daemon child has pointed at its log. */
+export declare function writeDaemonLogLine(scope: string, message: string, details?: Record<string, unknown>): void;

package/dist/daemon/log.js

@@ -0,0 +1,44 @@
+import { closeSync, copyFileSync, openSync, statSync, truncateSync } from 'node:fs';
+import { join } from 'node:path';
+import { ensureDaemonDir, getDaemonDir } from './pid.js';
+const MAX_DAEMON_LOG_BYTES = 5 * 1024 * 1024;
+export function getDaemonLogPath() {
+    return join(getDaemonDir(), 'daemon.log');
+}
+/**
+ * Keeps one previous generation once the log grows past the limit. Copy then
+ * truncate (not rename): a service manager holds the log open in append mode,
+ * so the file must stay the same inode.
+ */
+export function rotateDaemonLog(limitBytes = MAX_DAEMON_LOG_BYTES) {
+    const logPath = getDaemonLogPath();
+    try {
+        if (statSync(logPath).size <= limitBytes)
+            return;
+        copyFileSync(logPath, `${logPath}.1`);
+        truncateSync(logPath, 0);
+    }
+    catch {
+        // Missing log or unwritable directory: logging is best effort.
+    }
+}
+/** Opens the log for a daemon child's stdout/stderr; the caller closes it after spawning. */
+export function openDaemonLogForChild() {
+    try {
+        ensureDaemonDir();
+        rotateDaemonLog();
+        return openSync(getDaemonLogPath(), 'a', 0o600);
+    }
+    catch {
+        return 'ignore';
+    }
+}
+export function closeDaemonLogFd(fd) {
+    if (fd !== 'ignore')
+        closeSync(fd);
+}
+/** One timestamped line on stderr, which a daemon child has pointed at its log. */
+export function writeDaemonLogLine(scope, message, details) {
+    const suffix = details ? ` ${JSON.stringify(details)}` : '';
+    process.stderr.write(`${new Date().toISOString()} [${scope}] ${message}${suffix}\n`);
+}

package/dist/daemon/server.js

@@ -1,6 +1,8 @@
 import crypto from 'node:crypto';
 import { createServer } from 'http';
 import { chmodSync, existsSync } from 'node:fs';
+import { DAEMON_SERVICE_ENV } from './supervisor.js';
+import { writeDaemonLogLine } from './log.js';
 import { loadConfig } from '../config/store.js';
 import { fingerprintDaemonRuntimeConfig, resolveConfig } from '../config/resolve.js';
 import { hydrateResolvedAuthIdentity } from '../auth/userInfo.js';
@@ -17,6 +19,10 @@ import { getDaemonInfo } from './client.js';
 import { GatewayService } from '../gateway/service.js';
 import { readConversation } from '../gateway/conversationContext.js';
 const MAX_DAEMON_REQUEST_BYTES = 1 * 1024 * 1024;
+function daemonSupervisor() {
+    const value = process.env[DAEMON_SERVICE_ENV];
+    return value === 'launchd' || value === 'systemd' ? value : null;
+}
 const DAEMON_PROCESS_VERSION = getPackageVersion();
 async function readJsonBody(req) {
     return new Promise((resolve, reject) => {
@@ -97,7 +103,7 @@ export class DaemonServer {
                 credentialsUrl: process.env.DINOX_NATS_CREDENTIALS_URL || undefined,
             });
             await this.gateways.start().catch((error) => {
-                process.stderr.write(`[dinox-gateway] start failed: ${String(error)}\n`);
+                writeDaemonLogLine('dinox-gateway', 'start failed', { error: String(error) });
             });
         }
         // PowerSync keeps the local cache in sync continuously while connected,
@@ -125,6 +131,7 @@ export class DaemonServer {
                             tokenFingerprint: this.tokenFingerprint,
                             runtimeConfigFingerprint: this.runtimeConfigFingerprint,
                             authenticated: Boolean(this.userId && this.tokenFingerprint),
+                            supervisor: daemonSupervisor(),
                         },
                     };
                 case 'shutdown': {

package/dist/daemon/supervisor.d.ts

@@ -0,0 +1,59 @@
+/**
+ * A service manager that owns the daemon process. Without one, the daemon is a
+ * detached child of whatever ran the first `dino` command; when that was a
+ * coding agent, the agent's host may reap it together with the session and
+ * every gateway goes offline. Under launchd / systemd the daemon belongs to
+ * the login session instead, starts at login, and is restarted after a crash.
+ *
+ * Restart policy is "on failure" only: a clean exit (`dino daemon stop`, a
+ * version/account restart, exclusive DB access for `doctor`) leaves it
+ * stopped until the CLI starts it again through the manager.
+ */
+export type DaemonServiceKind = 'launchd' | 'systemd';
+export type DaemonServiceSpec = {
+    program: string;
+    args: string[];
+    env: Record<string, string>;
+    workingDirectory: string;
+    logPath: string;
+};
+export type ServiceCommandResult = {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+export type ServiceCommandRunner = (command: string, args: string[]) => Promise<ServiceCommandResult>;
+export type DaemonService = {
+    readonly kind: DaemonServiceKind;
+    readonly label: string;
+    readonly definitionPath: string;
+    render(spec: DaemonServiceSpec): string;
+    isInstalled(): boolean;
+    /** Writes the definition and (re)loads it, which starts the daemon. */
+    install(spec: DaemonServiceSpec): Promise<void>;
+    /** Starts the installed daemon when it is not running. */
+    start(): Promise<void>;
+    /** Stops the daemon and removes the definition; false when nothing was installed. */
+    uninstall(): Promise<boolean>;
+};
+/** Set in the service definition so the daemon can report who supervises it. */
+export declare const DAEMON_SERVICE_ENV = "DINOX_DAEMON_SUPERVISOR";
+export declare const runServiceCommand: ServiceCommandRunner;
+/**
+ * One daemon per data directory (it owns that directory's socket), so a
+ * non-default `DINOX_DATA_DIR` gets its own service.
+ */
+export declare function daemonServiceLabel(env?: NodeJS.ProcessEnv): string;
+/** True when the installed definition differs from what this CLI would write. */
+export declare function serviceDefinitionIsStale(service: DaemonService, spec: DaemonServiceSpec): boolean;
+export declare function renderLaunchdPlist(label: string, spec: DaemonServiceSpec): string;
+export declare function renderSystemdUnit(spec: DaemonServiceSpec): string;
+export type DaemonServiceOptions = {
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+    uid?: number;
+    run?: ServiceCommandRunner;
+};
+/** The service manager for this platform, or null where none is supported (Windows). */
+export declare function getDaemonService(options?: DaemonServiceOptions): DaemonService | null;

package/dist/daemon/supervisor.js

@@ -0,0 +1,253 @@
+import crypto from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { getDataDir } from '../config/paths.js';
+import { DinoxError } from '../utils/errors.js';
+/** Set in the service definition so the daemon can report who supervises it. */
+export const DAEMON_SERVICE_ENV = 'DINOX_DAEMON_SUPERVISOR';
+const DEFAULT_LABEL = 'com.dinox.cli.daemon';
+const COMMAND_TIMEOUT_MS = 15_000;
+const LAUNCHD_BOOTSTRAP_ATTEMPTS = 5;
+const LAUNCHD_BOOTSTRAP_RETRY_MS = 300;
+export const runServiceCommand = (command, args) => new Promise((resolve) => {
+    execFile(command, args, { timeout: COMMAND_TIMEOUT_MS, encoding: 'utf8' }, (error, stdout, stderr) => {
+        const code = error ? (typeof error.code === 'number' ? error.code : 1) : 0;
+        resolve({ code, stdout: stdout ?? '', stderr: stderr ?? (error ? String(error.message) : '') });
+    });
+});
+/**
+ * One daemon per data directory (it owns that directory's socket), so a
+ * non-default `DINOX_DATA_DIR` gets its own service.
+ */
+export function daemonServiceLabel(env = process.env) {
+    if (!env.DINOX_DATA_DIR)
+        return DEFAULT_LABEL;
+    const hash = crypto.createHash('sha256').update(getDataDir(), 'utf8').digest('hex').slice(0, 8);
+    return `${DEFAULT_LABEL}.${hash}`;
+}
+function failed(kind, step, result) {
+    const output = (result.stderr || result.stdout).trim();
+    return new DinoxError(`${kind} ${step} failed${output ? `: ${output}` : ''}`, {
+        code: 'DAEMON_SERVICE_FAILED',
+        details: { service: kind, step, exitCode: result.code },
+    });
+}
+function writeDefinition(definitionPath, content) {
+    mkdirSync(path.dirname(definitionPath), { recursive: true });
+    writeFileSync(definitionPath, content, { mode: 0o644 });
+}
+function readDefinition(definitionPath) {
+    try {
+        return readFileSync(definitionPath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+/** True when the installed definition differs from what this CLI would write. */
+export function serviceDefinitionIsStale(service, spec) {
+    return readDefinition(service.definitionPath) !== service.render(spec);
+}
+// ---------------------------------------------------------------- launchd
+function xmlEscape(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+export function renderLaunchdPlist(label, spec) {
+    const string = (value) => `<string>${xmlEscape(value)}</string>`;
+    const args = [spec.program, ...spec.args].map((arg) => `\t\t${string(arg)}`).join('\n');
+    const env = Object.keys(spec.env)
+        .sort()
+        .map((name) => `\t\t<key>${xmlEscape(name)}</key>\n\t\t${string(spec.env[name])}`)
+        .join('\n');
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+\t<key>Label</key>
+\t${string(label)}
+\t<key>ProgramArguments</key>
+\t<array>
+${args}
+\t</array>
+\t<key>EnvironmentVariables</key>
+\t<dict>
+${env}
+\t</dict>
+\t<key>WorkingDirectory</key>
+\t${string(spec.workingDirectory)}
+\t<key>RunAtLoad</key>
+\t<true/>
+\t<key>KeepAlive</key>
+\t<dict>
+\t\t<key>SuccessfulExit</key>
+\t\t<false/>
+\t</dict>
+\t<key>ThrottleInterval</key>
+\t<integer>30</integer>
+\t<key>StandardOutPath</key>
+\t${string(spec.logPath)}
+\t<key>StandardErrorPath</key>
+\t${string(spec.logPath)}
+</dict>
+</plist>
+`;
+}
+class LaunchdService {
+    label;
+    run;
+    kind = 'launchd';
+    definitionPath;
+    domain;
+    target;
+    constructor(label, run, homeDir, uid) {
+        this.label = label;
+        this.run = run;
+        this.definitionPath = path.join(homeDir, 'Library', 'LaunchAgents', `${label}.plist`);
+        this.domain = `gui/${uid}`;
+        this.target = `${this.domain}/${label}`;
+    }
+    render(spec) {
+        return renderLaunchdPlist(this.label, spec);
+    }
+    isInstalled() {
+        return existsSync(this.definitionPath);
+    }
+    async isLoaded() {
+        return (await this.run('launchctl', ['print', this.target])).code === 0;
+    }
+    async bootstrap() {
+        // bootout returns before launchd has fully released the label, so a
+        // bootstrap right after it can fail transiently.
+        let result = null;
+        for (let attempt = 0; attempt < LAUNCHD_BOOTSTRAP_ATTEMPTS; attempt += 1) {
+            result = await this.run('launchctl', ['bootstrap', this.domain, this.definitionPath]);
+            if (result.code === 0)
+                return;
+            await new Promise((resolve) => setTimeout(resolve, LAUNCHD_BOOTSTRAP_RETRY_MS));
+        }
+        throw failed(this.kind, 'bootstrap', result);
+    }
+    async install(spec) {
+        if (await this.isLoaded())
+            await this.run('launchctl', ['bootout', this.target]);
+        writeDefinition(this.definitionPath, this.render(spec));
+        await this.bootstrap();
+    }
+    async start() {
+        if (!(await this.isLoaded())) {
+            await this.bootstrap();
+            return;
+        }
+        const result = await this.run('launchctl', ['kickstart', this.target]);
+        if (result.code !== 0)
+            throw failed(this.kind, 'kickstart', result);
+    }
+    async uninstall() {
+        const installed = this.isInstalled();
+        if (await this.isLoaded()) {
+            const result = await this.run('launchctl', ['bootout', this.target]);
+            if (result.code !== 0 && (await this.isLoaded()))
+                throw failed(this.kind, 'bootout', result);
+        }
+        if (installed)
+            unlinkSync(this.definitionPath);
+        return installed;
+    }
+}
+// ---------------------------------------------------------------- systemd
+/** Quotes one word for a systemd command line or assignment value. */
+function systemdQuote(value) {
+    const escaped = value
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/%/g, '%%')
+        .replace(/\$/g, '$$$$')
+        .replace(/\n/g, '\\n');
+    return `"${escaped}"`;
+}
+export function renderSystemdUnit(spec) {
+    const execStart = [spec.program, ...spec.args].map(systemdQuote).join(' ');
+    const env = Object.keys(spec.env)
+        .sort()
+        .map((name) => `Environment=${systemdQuote(`${name}=${spec.env[name]}`)}`)
+        .join('\n');
+    return `[Unit]
+Description=Dinox CLI daemon
+After=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${execStart}
+WorkingDirectory=${spec.workingDirectory.replace(/%/g, '%%')}
+${env}
+Restart=on-failure
+RestartSec=30
+StandardOutput=append:${spec.logPath}
+StandardError=append:${spec.logPath}
+
+[Install]
+WantedBy=default.target
+`;
+}
+class SystemdService {
+    label;
+    run;
+    kind = 'systemd';
+    definitionPath;
+    unit;
+    constructor(label, run, configHome) {
+        this.label = label;
+        this.run = run;
+        this.unit = `${label}.service`;
+        this.definitionPath = path.join(configHome, 'systemd', 'user', this.unit);
+    }
+    render(spec) {
+        return renderSystemdUnit(spec);
+    }
+    isInstalled() {
+        return existsSync(this.definitionPath);
+    }
+    async systemctl(step, ...args) {
+        const result = await this.run('systemctl', ['--user', ...args]);
+        if (result.code !== 0)
+            throw failed(this.kind, step, result);
+    }
+    async install(spec) {
+        writeDefinition(this.definitionPath, this.render(spec));
+        await this.systemctl('daemon-reload', 'daemon-reload');
+        await this.systemctl('enable', 'enable', this.unit);
+        await this.systemctl('restart', 'restart', this.unit);
+    }
+    async start() {
+        await this.systemctl('start', 'start', this.unit);
+    }
+    async uninstall() {
+        if (!this.isInstalled())
+            return false;
+        await this.run('systemctl', ['--user', 'disable', '--now', this.unit]);
+        unlinkSync(this.definitionPath);
+        await this.run('systemctl', ['--user', 'daemon-reload']);
+        return true;
+    }
+}
+/** The service manager for this platform, or null where none is supported (Windows). */
+export function getDaemonService(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    const homeDir = options.homeDir ?? os.homedir();
+    const run = options.run ?? runServiceCommand;
+    const label = daemonServiceLabel(env);
+    if (platform === 'darwin') {
+        return new LaunchdService(label, run, homeDir, options.uid ?? process.getuid?.() ?? 0);
+    }
+    if (platform === 'linux') {
+        return new SystemdService(label, run, env.XDG_CONFIG_HOME || path.join(homeDir, '.config'));
+    }
+    return null;
+}

package/dist/daemon/types.d.ts

@@ -42,6 +42,8 @@ export type DaemonPingResult = {
     runtimeConfigFingerprint: string | null;
     /** True only for daemons using the current authenticated local protocol. */
     authenticated: boolean;
+    /** Service manager that owns the process; null or absent (older daemons) when unmanaged. */
+    supervisor?: 'launchd' | 'systemd' | null;
 };
 /** Kept only for old scripts that pass --port; the daemon transport is socket-based. */
 export declare const DEFAULT_DAEMON_PORT = 45678;

package/dist/gateway/service.js

@@ -1,5 +1,6 @@
 import os from 'node:os';
 import { getPackageVersion } from '../utils/version.js';
+import { writeDaemonLogLine } from '../daemon/log.js';
 import { createGatewayAdapter } from './adapters/index.js';
 import { getMachineId, loadGateways, updateGatewaySettings } from './config.js';
 import { GatewayDeviceHost } from './deviceHost.js';
@@ -15,9 +16,7 @@ function applyLiveSettings(target, source) {
             target[key] = source[key];
     }
 }
-const defaultLog = (message, details) => {
-    process.stderr.write(`[dinox-gateway] ${message}${details ? ` ${JSON.stringify(details)}` : ''}\n`);
-};
+const defaultLog = (message, details) => writeDaemonLogLine('dinox-gateway', message, details);
 /**
  * Runs every enabled gateway inside the daemon: the daemon owns the PowerSync
  * database, so gateway writes share its connection and upload queue.

package/dist/utils/errorCodes.d.ts

@@ -63,6 +63,14 @@ export declare const ERROR_CODES: {
         readonly exitCode: 1;
         readonly description: "The daemon did not release database ownership in time.";
     };
+    readonly DAEMON_SERVICE_FAILED: {
+        readonly exitCode: 1;
+        readonly description: "The service manager (launchd / systemd) rejected a daemon service operation.";
+    };
+    readonly DAEMON_SERVICE_UNSUPPORTED: {
+        readonly exitCode: 5;
+        readonly description: "The daemon cannot run as a login service on this platform or with this auth setup.";
+    };
     readonly DAEMON_STALE: {
         readonly exitCode: 5;
         readonly description: "The daemon state is stale and needs a restart.";

package/dist/utils/errorCodes.js

@@ -21,6 +21,8 @@ export const ERROR_CODES = {
     DAEMON_LEGACY_UNVERIFIED: { exitCode: 1, description: 'A daemon from an older CLI could not be verified safely.' },
     DAEMON_RELEASE_FAILED: { exitCode: 1, description: 'The daemon could not release database ownership.' },
     DAEMON_RELEASE_TIMEOUT: { exitCode: 1, description: 'The daemon did not release database ownership in time.' },
+    DAEMON_SERVICE_FAILED: { exitCode: 1, description: 'The service manager (launchd / systemd) rejected a daemon service operation.' },
+    DAEMON_SERVICE_UNSUPPORTED: { exitCode: 5, description: 'The daemon cannot run as a login service on this platform or with this auth setup.' },
     DAEMON_STALE: { exitCode: 5, description: 'The daemon state is stale and needs a restart.' },
     DAEMON_START_FAILED: { exitCode: 5, description: 'The daemon process failed to start.' },
     DAEMON_START_TIMEOUT: { exitCode: 1, description: 'The daemon did not become ready in time.' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dinoxx/dinox-cli",
-  "version": "2.5.2",
+  "version": "2.6.0",
   "description": "Dinox CLI",
   "main": "dist/dinox.js",
   "scripts": {