@dinoxx/dinox-cli 2.8.1 → 2.9.0

package/README.md

@@ -1135,6 +1135,7 @@ dino schema todo.update --format json
 | `DINOX_DATA_DIR` | 覆盖本地数据目录 |
 | `DINOX_TOKEN` | 用环境变量注入登录 token，优先级高于本地配置；可传 token 本体或 `Bearer ...` |
 | `DINOX_SYNC_TIMEOUT_MS` | 覆盖同步超时 |
+| `DINOX_DAEMON_AUTO_INSTALL` | 设为 `0` 时，`auth login` / `gateway add` 不再自动把 daemon 安装为登录服务 |
 
 ### 9.3 macOS / Linux 与 Windows 的多行命令差异
 

package/dist/commands/auth/index.js

@@ -6,6 +6,7 @@ import { resolveConfig } from '../../config/resolve.js';
 import { getDaemonInfo } from '../../daemon/client.js';
 import { restoreSuspendedDaemonLocked, suspendDaemonForExclusiveAccessLocked, } from '../../daemon/lifecycle.js';
 import { stopDaemonLocked } from '../../daemon/index.js';
+import { autoInstallDaemonService, describeDaemonServiceAutoInstall } from '../../daemon/autoInstall.js';
 import { acquireDaemonStartLock } from '../../daemon/pid.js';
 import { fetchCredentialsWithAuthorization } from '../../powersync/connector.js';
 import { withExclusivePowerSync } from '../../powersync/exclusiveRuntime.js';
@@ -244,8 +245,10 @@ async function runAuthLogin(context) {
     }
     const structuredOutput = getRequestedStructuredOutputFormat() !== null;
     const result = await performAuthLogin(rawToken, context.globals.syncTimeout);
+    // After the login lock is released: the service starts the daemon under the new login.
+    const daemonService = await autoInstallDaemonService();
     if (structuredOutput) {
-        printSuccess(result);
+        printSuccess({ ...result, daemonService });
         return;
     }
     printHumanReadableLine('Login verified.');
@@ -258,6 +261,9 @@ async function runAuthLogin(context) {
     if (result.stale) {
         printHumanReadableLine('- warning: initial sync timed out; local cache may be stale');
     }
+    const serviceNote = describeDaemonServiceAutoInstall(daemonService);
+    if (serviceNote)
+        printHumanReadableWarning(serviceNote);
 }
 async function runAuthLogoutLocked(options) {
     const config = await loadConfig();
@@ -494,7 +500,7 @@ export const authCommandGroup = {
                 output: {
                     type: 'structured',
                     summary: 'Login verification result',
-                    fields: ['verified', 'endpoint', 'dbPath', 'stale', 'lastSyncedAt', 'userId'],
+                    fields: ['verified', 'endpoint', 'dbPath', 'stale', 'lastSyncedAt', 'userId', 'daemonService'],
                 },
                 examples: ['dino auth login --token-stdin --format json'],
             },

package/dist/commands/gateway/index.js

@@ -1,6 +1,7 @@
 import { getDaemonInfo, isDaemonRunning, sendDaemonRequest } from '../../daemon/client.js';
 import { getDaemonService } from '../../daemon/supervisor.js';
 import { ensureDaemonRunning } from '../../daemon/ensure.js';
+import { autoInstallDaemonService, describeDaemonServiceAutoInstall } from '../../daemon/autoInstall.js';
 import { loadConfig } from '../../config/store.js';
 import { addGateway, adoptDetectedAgent, getGatewaysFilePath, loadGateways, removeGateway, } from '../../gateway/config.js';
 import { detectAcpAgents, inferAgentId } from '../../gateway/detect.js';
@@ -56,8 +57,17 @@ async function warnIfDaemonUnmanaged() {
         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() {
+/**
+ * Applies the account's gateways to the running daemon, starting it when needed.
+ * `keepOnline` first hands the daemon to the login service (once), so a gateway
+ * added from an agent session does not go offline when that session ends.
+ */
+async function applyToDaemon(options = {}) {
+    if (options.keepOnline) {
+        const note = describeDaemonServiceAutoInstall(await autoInstallDaemonService());
+        if (note)
+            printHumanReadableWarning(note);
+    }
     let gateways;
     if (!(await isDaemonRunning())) {
         await ensureDaemonRunning();
@@ -98,7 +108,7 @@ async function runAdd(context) {
         cwd: context.options.cwd,
         env: parseEnv(context.options.env),
     });
-    const statuses = await applyToDaemon();
+    const statuses = await applyToDaemon({ keepOnline: true });
     if (getRequestedStructuredOutputFormat()) {
         printSuccess({ gateway: describeGateway(gateway), status: statuses.find((item) => item.gatewayId === gateway.id) ?? null });
         return;
@@ -122,7 +132,7 @@ async function runDetect(context) {
                 updated.push(result.gateway);
         }
     }
-    const statuses = added.length || updated.length ? await applyToDaemon() : [];
+    const statuses = added.length || updated.length ? await applyToDaemon({ keepOnline: true }) : [];
     if (getRequestedStructuredOutputFormat()) {
         printSuccess({
             agents: detected,

package/dist/daemon/autoInstall.d.ts

@@ -0,0 +1,32 @@
+import type { DinoxConfig } from '../config/types.js';
+import { type DaemonService, type DaemonServiceKind } from './supervisor.js';
+/** `0` / `false` / `off` / `no` keeps the CLI from installing the daemon service on its own. */
+export declare const DAEMON_AUTO_INSTALL_ENV = "DINOX_DAEMON_AUTO_INSTALL";
+export type DaemonServiceAutoInstallSkipReason = 'disabled' | 'ci' | 'custom-data-dir' | 'unsupported' | 'no-login' | 'env-token';
+export type DaemonServiceAutoInstallResult = {
+    status: 'installed' | 'already-installed' | 'skipped' | 'failed';
+    service: DaemonServiceKind | null;
+    reason: DaemonServiceAutoInstallSkipReason | null;
+    error: string | null;
+};
+export type DaemonServiceAutoInstallDependencies = {
+    env: NodeJS.ProcessEnv;
+    getService: () => DaemonService | null;
+    loadConfig: () => Promise<DinoxConfig>;
+    install: () => Promise<unknown>;
+    /** Removes whatever a failed install left behind. */
+    rollback: () => Promise<unknown>;
+};
+/**
+ * Makes the daemon a login service without the user having to know it exists.
+ * Without one it belongs to whichever shell or agent session first started it
+ * and dies with that session. Called after `auth login` and when gateways are
+ * added; never throws, because neither of those should fail over it.
+ *
+ * Skipped where installing something that runs at login would surprise:
+ * an opt-out, CI, and custom data directories (tests, sandboxes, second
+ * profiles), which still get it from an explicit `dino daemon install`.
+ */
+export declare function autoInstallDaemonService(dependencies?: DaemonServiceAutoInstallDependencies): Promise<DaemonServiceAutoInstallResult>;
+/** One stderr line for a human caller; nothing when there is nothing to say. */
+export declare function describeDaemonServiceAutoInstall(result: DaemonServiceAutoInstallResult): string | null;

package/dist/daemon/autoInstall.js

@@ -0,0 +1,106 @@
+import { existsSync } from 'node:fs';
+import { loadConfig } from '../config/store.js';
+import { normalizeAuthToken } from '../utils/authToken.js';
+import { DinoxError } from '../utils/errors.js';
+import { installDaemonService, uninstallDaemonService } from './index.js';
+import { envTokenOverridesLogin } from './launch.js';
+import { getDaemonService } from './supervisor.js';
+/** `0` / `false` / `off` / `no` keeps the CLI from installing the daemon service on its own. */
+export const DAEMON_AUTO_INSTALL_ENV = 'DINOX_DAEMON_AUTO_INSTALL';
+/**
+ * systemd --user is missing in WSL without systemd, most containers, and
+ * other non-systemd distros; `/run/systemd/system` is how sd_booted() tells.
+ */
+function usableService() {
+    const service = getDaemonService();
+    if (service?.kind === 'systemd' && !existsSync('/run/systemd/system'))
+        return null;
+    return service;
+}
+const defaultDependencies = {
+    env: process.env,
+    getService: usableService,
+    loadConfig,
+    install: () => installDaemonService(),
+    rollback: () => uninstallDaemonService(),
+};
+function isFalsy(value) {
+    return ['0', 'false', 'off', 'no'].includes((value ?? '').trim().toLowerCase());
+}
+function isSet(value) {
+    return Boolean(value?.trim()) && !isFalsy(value);
+}
+function skipped(service, reason) {
+    return { status: 'skipped', service, reason, error: null };
+}
+/**
+ * Makes the daemon a login service without the user having to know it exists.
+ * Without one it belongs to whichever shell or agent session first started it
+ * and dies with that session. Called after `auth login` and when gateways are
+ * added; never throws, because neither of those should fail over it.
+ *
+ * Skipped where installing something that runs at login would surprise:
+ * an opt-out, CI, and custom data directories (tests, sandboxes, second
+ * profiles), which still get it from an explicit `dino daemon install`.
+ */
+export async function autoInstallDaemonService(dependencies = defaultDependencies) {
+    const { env } = dependencies;
+    if (isFalsy(env[DAEMON_AUTO_INSTALL_ENV]))
+        return skipped(null, 'disabled');
+    if (isSet(env.CI))
+        return skipped(null, 'ci');
+    if (env.DINOX_DATA_DIR)
+        return skipped(null, 'custom-data-dir');
+    const service = dependencies.getService();
+    if (!service)
+        return skipped(null, 'unsupported');
+    if (service.isInstalled()) {
+        return { status: 'already-installed', service: service.kind, reason: null, error: null };
+    }
+    let raw;
+    try {
+        raw = await dependencies.loadConfig();
+    }
+    catch (error) {
+        return { status: 'failed', service: service.kind, reason: null, error: errorMessage(error) };
+    }
+    if (!normalizeAuthToken(raw.auth?.authorization))
+        return skipped(service.kind, 'no-login');
+    if (envTokenOverridesLogin(raw, env))
+        return skipped(service.kind, 'env-token');
+    try {
+        await dependencies.install();
+        return { status: 'installed', service: service.kind, reason: null, error: null };
+    }
+    catch (error) {
+        // Every service writes its definition before asking the manager to load it,
+        // and the CLI starts the daemon through any definition it finds. Left in
+        // place after a failure (no GUI session over SSH, no user bus, a policy
+        // blocking Task Scheduler), it would break the on-demand start that worked
+        // before, so restore the state from before this attempt.
+        let message = errorMessage(error);
+        try {
+            await dependencies.rollback();
+        }
+        catch (rollbackError) {
+            message += `; cleanup also failed (${errorMessage(rollbackError)}), run \`dino daemon uninstall\``;
+        }
+        if (error instanceof DinoxError && error.code === 'DAEMON_SERVICE_UNSUPPORTED') {
+            return { status: 'skipped', service: service.kind, reason: 'unsupported', error: message };
+        }
+        return { status: 'failed', service: service.kind, reason: null, error: message };
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** One stderr line for a human caller; nothing when there is nothing to say. */
+export function describeDaemonServiceAutoInstall(result) {
+    if (result.status === 'installed') {
+        return `Background service installed (${result.service}): the daemon now starts at login and restarts after a crash. Remove it with \`dino daemon uninstall\`.`;
+    }
+    if (result.status === 'failed') {
+        return `warning: could not install the background service (${result.error}). The daemon still starts on demand; run \`dino daemon install\` to retry.`;
+    }
+    return null;
+}

package/package.json

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