@dinoxx/dinox-cli 2.4.0 → 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 {};