@dinoxx/dinox-cli 1.0.19 → 1.0.21

package/dist/commands/todo/index.js

@@ -1,14 +1,11 @@
 import { resolveAuthIdentity } from '../../auth/userInfo.js';
 import { registerCommandGroup } from '../descriptor/register.js';
 import { FORMAT_OPTIONS, OFFLINE_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
-import { loadConfig } from '../../config/store.js';
-import { resolveConfig } from '../../config/resolve.js';
-import { connectPowerSync, waitForIdleDataFlow } from '../../powersync/runtime.js';
 import { readStringOrFile } from '../../utils/argValue.js';
 import { printDryRunPreview } from '../../utils/dryRun.js';
 import { DinoxError } from '../../utils/errors.js';
-import { printHumanReadableLine, printSuccess } from '../../utils/output.js';
-import { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
+import { printSuccess } from '../../utils/output.js';
+import { commandStale, printUploadDisabledWarning, syncBeforeCommand, waitForMutationUpload, withCommandRuntime, } from '../runtime.js';
 import { buildTodoAppendDryRunPreview, buildTodoCreateDryRunPreview, buildTodoUpdateDryRunPreview, } from './dryRun.js';
 import { appendTodoTasks, createTodoNote, normalizeTaskTexts, searchTodoTasks, updateTodoTaskStatus, } from './repo.js';
 const DATE_ONLY_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
@@ -192,35 +189,14 @@ async function parseTaskInput(args) {
     }
     return normalizeTaskTexts(merged);
 }
-async function syncBeforeTodoCommand(db, offline, timeoutMs) {
-    if (offline) {
-        return;
-    }
-    await waitForIdleDataFlow(db, Math.min(timeoutMs, 10_000));
-}
 async function withTodoDatabase(globals, run) {
-    const rawConfig = await loadConfig();
-    const config = resolveConfig(rawConfig);
-    const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
-    const offline = Boolean(globals.offline);
-    const { db } = await connectPowerSync({ config, offline, timeoutMs });
-    try {
-        await run({
-            db,
-            rawConfig,
-            config,
-            offline,
-            timeoutMs,
-        });
-    }
-    finally {
-        await db.close().catch(() => undefined);
-    }
+    await withCommandRuntime(globals, run);
 }
 async function runTodoSearch({ args, globals, options }) {
     const searchOptions = options;
-    await withTodoDatabase(globals, async ({ db, offline, timeoutMs }) => {
-        await syncBeforeTodoCommand(db, offline, timeoutMs);
+    await withTodoDatabase(globals, async (runtime) => {
+        const { db } = runtime;
+        await syncBeforeCommand(runtime);
         const keyword = args.query?.trim() ?? '';
         const taskStatus = parseTaskStatus(searchOptions.status);
         const taskTagFilter = typeof searchOptions.tags === 'string'
@@ -241,13 +217,14 @@ async function runTodoSearch({ args, globals, options }) {
             limit,
             scanLimit,
         });
-        printSuccess(result);
+        printSuccess({ stale: commandStale(runtime), ...result });
     });
 }
 async function runTodoAppend({ args, globals, options }) {
     const appendOptions = options;
-    await withTodoDatabase(globals, async ({ db, config, offline, timeoutMs }) => {
-        await syncBeforeTodoCommand(db, offline, timeoutMs);
+    await withTodoDatabase(globals, async (runtime) => {
+        const { db, config, offline } = runtime;
+        await syncBeforeCommand(runtime);
         const taskTexts = await parseTaskInput({
             positionalTask: args.task,
             tasksOption: typeof appendOptions.tasks === 'string' ? appendOptions.tasks : undefined,
@@ -268,13 +245,16 @@ async function runTodoAppend({ args, globals, options }) {
             noteId: typeof appendOptions.noteId === 'string' ? appendOptions.noteId : undefined,
             taskTexts,
         });
-        printSuccess({ ok: true, ...result });
+        printUploadDisabledWarning(runtime);
+        await waitForMutationUpload(runtime);
+        printSuccess({ ok: true, stale: commandStale(runtime), ...result });
     });
 }
 async function runTodoCreate({ args, globals, options }) {
     const createOptions = options;
-    await withTodoDatabase(globals, async ({ db, rawConfig, config, offline, timeoutMs }) => {
-        await syncBeforeTodoCommand(db, offline, timeoutMs);
+    await withTodoDatabase(globals, async (runtime) => {
+        const { db, config, offline } = runtime;
+        await syncBeforeCommand(runtime);
         const taskTexts = await parseTaskInput({
             positionalTask: args.task,
             tasksOption: typeof createOptions.tasks === 'string' ? createOptions.tasks : undefined,
@@ -290,25 +270,22 @@ async function runTodoCreate({ args, globals, options }) {
             printDryRunPreview(preview);
             return;
         }
-        const identity = await resolveAuthIdentity(rawConfig, config);
+        const identity = await resolveAuthIdentity(config);
         const result = await createTodoNote(db, {
             taskTexts,
             title: typeof createOptions.title === 'string' ? createOptions.title : undefined,
             userId: identity.userId,
         });
-        if (!offline && !config.powersync.uploadBaseUrl) {
-            printHumanReadableLine('warning: upload disabled (powersync.uploadBaseUrl is unset); changes are local-only for now');
-        }
-        if (!offline) {
-            await waitForIdleDataFlow(db, Math.min(timeoutMs, 5_000));
-        }
-        printSuccess({ ok: true, ...result });
+        printUploadDisabledWarning(runtime);
+        await waitForMutationUpload(runtime);
+        printSuccess({ ok: true, stale: commandStale(runtime), ...result });
     });
 }
 async function runTodoUpdate({ args, globals, options }) {
     const updateOptions = options;
-    await withTodoDatabase(globals, async ({ db, config, offline, timeoutMs }) => {
-        await syncBeforeTodoCommand(db, offline, timeoutMs);
+    await withTodoDatabase(globals, async (runtime) => {
+        const { db, config, offline } = runtime;
+        await syncBeforeCommand(runtime);
         const taskId = args.taskId;
         if (!taskId) {
             throw new DinoxError('taskId is required');
@@ -329,7 +306,9 @@ async function runTodoUpdate({ args, globals, options }) {
             taskId,
             checked,
         });
-        printSuccess({ ok: true, ...result });
+        printUploadDisabledWarning(runtime);
+        await waitForMutationUpload(runtime);
+        printSuccess({ ok: true, stale: commandStale(runtime), ...result });
     });
 }
 const todoSearchCommand = {
@@ -360,17 +339,7 @@ const todoSearchCommand = {
             type: 'structured',
             summary: 'Todo search payload with metadata and task list',
             fields: ['tasks.task_id', 'tasks.task_key', 'tasks.note_id', 'tasks.note_title', 'tasks.status', 'tasks.depth', 'tasks.parent_id', 'tasks.tags'],
-            metaFields: ['meta.query', 'meta.returned_count', 'meta.limit', 'meta.task_status', 'meta.task_tag_filter', 'meta.task_date_range', 'meta.scanned_note_count'],
-        },
-        mcp: {
-            toolName: 'dinox_search_todos',
-            description: 'Search todo tasks',
-            properties: [
-                { name: 'query', type: 'string', description: 'Task text query' },
-                { name: 'status', type: 'string', description: 'Task status', enum: ['all', 'completed', 'uncompleted'] },
-                { name: 'tags', type: 'string[]', description: 'Task tags' },
-                { name: 'limit', type: 'number', description: 'Max results (default: 50)' },
-            ],
+            metaFields: ['stale', 'meta.query', 'meta.returned_count', 'meta.limit', 'meta.task_status', 'meta.task_tag_filter', 'meta.task_date_range', 'meta.scanned_note_count'],
         },
         examples: ['dino todo search "报销" --status uncompleted --format json', 'dino todo search --days 7 --format json'],
     },
@@ -404,7 +373,7 @@ const todoAppendCommand = {
         output: {
             type: 'structured',
             summary: 'Append result with target note and appended task ids',
-            fields: ['noteId', 'appendedCount', 'taskIds'],
+            fields: ['noteId', 'appendedCount', 'taskIds', 'stale'],
         },
         examples: ['dino todo append --note-id <id> --task "补交报销单" --format json'],
     },
@@ -438,7 +407,7 @@ const todoCreateCommand = {
         output: {
             type: 'structured',
             summary: 'Creation result with new note id and task ids',
-            fields: ['noteId', 'taskIds', 'title'],
+            fields: ['noteId', 'taskIds', 'title', 'stale'],
         },
         examples: ['dino todo create --task "补交报销单" --task "整理发票" --format json'],
     },
@@ -469,7 +438,7 @@ const todoUpdateCommand = {
         output: {
             type: 'structured',
             summary: 'Mutation result with updated status and target note id',
-            fields: ['taskId', 'checked', 'updated', 'noteId'],
+            fields: ['taskId', 'checked', 'updated', 'noteId', 'stale'],
         },
         examples: ['dino todo update <taskId> --status completed --format json'],
     },

package/dist/commands/writeDryRun.d.ts

@@ -8,15 +8,40 @@ export declare function buildTagAddDryRunPreview(args: {
     createdPaths: string[];
     restoredPaths: string[];
 }): DryRunPreview;
+export declare function buildTagMutationDryRunPreview(args: {
+    config: ResolvedDinoxConfig;
+    offline: boolean;
+    command: string;
+    action: 'rename_tag' | 'move_tag' | 'merge_tag' | 'cleanup_tags';
+    summary: string;
+    risk: 'write' | 'high-risk-write';
+    inputs: Record<string, unknown>;
+    changes?: Record<string, unknown> | Array<Record<string, unknown>>;
+    targets?: Array<Record<string, unknown>>;
+}): DryRunPreview;
 export declare function buildBoxAddDryRunPreview(args: {
     config: ResolvedDinoxConfig;
     offline: boolean;
     name: string;
+    path: string;
     description: string;
     color: string;
     restored: boolean;
+    createdPaths: string[];
+    restoredPaths: string[];
     existingId?: string;
 }): DryRunPreview;
+export declare function buildBoxMutationDryRunPreview(args: {
+    config: ResolvedDinoxConfig;
+    offline: boolean;
+    command: string;
+    action: 'rename_box' | 'move_box' | 'merge_box' | 'cleanup_boxes';
+    summary: string;
+    risk: 'write' | 'high-risk-write';
+    inputs: Record<string, unknown>;
+    changes?: Record<string, unknown> | Array<Record<string, unknown>>;
+    targets?: Array<Record<string, unknown>>;
+}): DryRunPreview;
 export declare function buildPromptAddDryRunPreview(args: {
     config: ResolvedDinoxConfig;
     offline: boolean;

package/dist/commands/writeDryRun.js

@@ -28,28 +28,58 @@ export function buildTagAddDryRunPreview(args) {
         },
     };
 }
+export function buildTagMutationDryRunPreview(args) {
+    return {
+        dry_run: true,
+        command: args.command,
+        action: args.action,
+        risk: args.risk,
+        summary: args.summary,
+        warnings: buildExecutionWarnings(args.config, args.offline),
+        inputs: args.inputs,
+        ...(args.targets ? { targets: args.targets } : {}),
+        ...(args.changes ? { changes: args.changes } : {}),
+    };
+}
 export function buildBoxAddDryRunPreview(args) {
     return {
         dry_run: true,
         command: 'dino box add',
         action: 'add_box',
         risk: 'write',
-        summary: `${args.restored ? 'Restore' : 'Create'} zettel box "${args.name}".`,
+        summary: `${args.restored ? 'Restore' : 'Create'} zettel box "${args.path}".`,
         warnings: buildExecutionWarnings(args.config, args.offline),
         inputs: {
             name: args.name,
+            path: args.path,
             ...(args.description ? { description: args.description } : {}),
             ...(args.color ? { color: args.color } : {}),
         },
         changes: {
             name: args.name,
+            path: args.path,
             description: args.description,
             color: args.color,
             restored: args.restored,
+            created_paths: args.createdPaths,
+            restored_paths: args.restoredPaths,
             ...(args.existingId ? { existing_id: args.existingId } : {}),
         },
     };
 }
+export function buildBoxMutationDryRunPreview(args) {
+    return {
+        dry_run: true,
+        command: args.command,
+        action: args.action,
+        risk: args.risk,
+        summary: args.summary,
+        warnings: buildExecutionWarnings(args.config, args.offline),
+        inputs: args.inputs,
+        ...(args.targets ? { targets: args.targets } : {}),
+        ...(args.changes ? { changes: args.changes } : {}),
+    };
+}
 export function buildPromptAddDryRunPreview(args) {
     return {
         dry_run: true,

package/dist/config/paths.d.ts

@@ -1,4 +1,5 @@
 export declare function getConfigDir(): string;
 export declare function getConfigFilePath(): string;
 export declare function getDataDir(): string;
-export declare function getPowerSyncDbPath(): string;
+export declare function getLegacyPowerSyncDbPath(): string;
+export declare function getPowerSyncDbPath(userId?: string | null): string;

package/dist/config/paths.js

@@ -1,6 +1,9 @@
 import os from 'node:os';
 import path from 'node:path';
 const POWERSYNC_DB_FILENAME = 'dinox-cli.sqlite';
+function normalizeUserPathSegment(userId) {
+    return encodeURIComponent(userId.trim());
+}
 function resolveConfigHome() {
     if (process.env.DINOX_CONFIG_DIR) {
         return process.env.DINOX_CONFIG_DIR;
@@ -35,6 +38,13 @@ export function getConfigFilePath() {
 export function getDataDir() {
     return path.join(resolveDataHome(), 'dinox');
 }
-export function getPowerSyncDbPath() {
+export function getLegacyPowerSyncDbPath() {
     return path.join(getDataDir(), POWERSYNC_DB_FILENAME);
 }
+export function getPowerSyncDbPath(userId) {
+    const normalizedUserId = typeof userId === 'string' ? userId.trim() : '';
+    if (!normalizedUserId) {
+        return getLegacyPowerSyncDbPath();
+    }
+    return path.join(getDataDir(), 'users', normalizeUserPathSegment(normalizedUserId), POWERSYNC_DB_FILENAME);
+}

package/dist/config/resolve.js

@@ -1,5 +1,5 @@
 import { POWERSYNC_DEFAULT_ENDPOINT, POWERSYNC_DEFAULT_TOKEN_ENDPOINT, POWERSYNC_DEFAULT_UPLOAD_BASE_URL, } from './serviceEndpoints.js';
-import { normalizeAuthToken } from '../utils/authToken.js';
+import { normalizeAuthToken, readEnvAuthToken } from '../utils/authToken.js';
 const DEFAULT_UPLOAD_V4_PATH = '/powersync/v4/uploadData';
 const DEFAULT_UPLOAD_V2_PATH = '/powersync/v2/uploadData';
 const DEFAULT_SYNC_TIMEOUT_MS = 300_000;
@@ -30,18 +30,20 @@ export function resolveConfig(raw) {
     const fileUploadV4Path = nonEmptyString(raw.powersync?.uploadV4Path);
     const fileUploadV2Path = nonEmptyString(raw.powersync?.uploadV2Path);
     const fileTimeoutMs = parsePositiveInt(raw.sync?.timeoutMs);
-    const envAuth = normalizeAuthToken(process.env.DINOX_AUTHORIZATION);
+    const envAuth = readEnvAuthToken();
     const envTokenEndpoint = nonEmptyString(process.env.DINOX_POWERSYNC_TOKEN_ENDPOINT) ?? nonEmptyString(process.env.POWERSYNC_TOKEN_ENDPOINT);
     const envUploadV4Path = nonEmptyString(process.env.DINOX_POWERSYNC_UPLOAD_V4_PATH);
     const envUploadV2Path = nonEmptyString(process.env.DINOX_POWERSYNC_UPLOAD_V2_PATH);
     const envTimeoutMs = parsePositiveInt(process.env.DINOX_SYNC_TIMEOUT_MS);
+    const effectiveAuth = envAuth ?? fileAuth;
+    const canReusePersistedIdentity = !envAuth || envAuth === fileAuth;
     return {
         auth: {
-            authorization: envAuth ?? fileAuth,
-            userId: fileUserId,
-            username: fileUsername,
-            email: fileEmail,
-            userInfoSyncedAt: fileUserInfoSyncedAt,
+            authorization: effectiveAuth,
+            userId: canReusePersistedIdentity ? fileUserId : undefined,
+            username: canReusePersistedIdentity ? fileUsername : undefined,
+            email: canReusePersistedIdentity ? fileEmail : undefined,
+            userInfoSyncedAt: canReusePersistedIdentity ? fileUserInfoSyncedAt : undefined,
         },
         powersync: {
             endpoint: POWERSYNC_DEFAULT_ENDPOINT,

package/dist/daemon/index.d.ts

@@ -1,2 +1,4 @@
 import { Command } from 'commander';
+import type { CommandGroupDescriptor } from '../commands/descriptor/types.js';
+export declare const daemonCommandGroup: CommandGroupDescriptor;
 export declare function registerDaemonCommands(program: Command): void;

package/dist/daemon/index.js

@@ -5,17 +5,19 @@ import { readPid, isProcessRunning, removePid } from './pid.js';
 import { isDaemonRunning } from './client.js';
 import { getPackageVersion } from '../utils/version.js';
 import { DinoxError } from '../utils/errors.js';
-import { printHumanReadableError, printHumanReadableLine } from '../utils/output.js';
+import { getRequestedStructuredOutputFormat, printHumanReadableError, printHumanReadableLine, printSuccess, } from '../utils/output.js';
+import { registerCommandGroup } from '../commands/descriptor/register.js';
+import { FORMAT_OPTIONS } from '../commands/schema/globalOptions.js';
 const DAEMON_STOP_POLL_INTERVAL_MS = 100;
 const DAEMON_STOP_TIMEOUT_MS = 5_000;
 function parsePort(value) {
     if (value === undefined || value === null || value === '') {
         return DEFAULT_DAEMON_PORT;
     }
-    if (typeof value !== 'string') {
+    if (typeof value !== 'string' && typeof value !== 'number') {
         throw new DinoxError('--port must be a valid port number');
     }
-    const trimmed = value.trim();
+    const trimmed = String(value).trim();
     if (!/^\d+$/.test(trimmed)) {
         throw new DinoxError('--port must be a valid port number');
     }
@@ -35,10 +37,9 @@ async function waitForProcessExit(pid, timeoutMs) {
     }
     return !isProcessRunning(pid);
 }
-async function startDaemon(port, detached = true) {
+async function startDaemon(port, detached = true, options = {}) {
     if (await isDaemonRunning()) {
-        printHumanReadableLine('Daemon is already running');
-        return;
+        return { running: true, port, detached, alreadyRunning: true };
     }
     if (detached) {
         const args = ['daemon', 'start', '--port', String(port), '--no-detach'];
@@ -49,21 +50,27 @@ async function startDaemon(port, detached = true) {
         child.unref();
         await new Promise((resolve) => setTimeout(resolve, 1000));
         if (await isDaemonRunning()) {
-            printHumanReadableLine(`Daemon started on port ${port}`);
+            return { running: true, port, detached, alreadyRunning: false };
         }
         else {
-            printHumanReadableError('Failed to start daemon');
+            return { running: false, port, detached, alreadyRunning: false };
         }
     }
     else {
-        printHumanReadableLine(`Starting daemon on port ${port}...`);
+        if (!options.quiet) {
+            printHumanReadableLine(`Starting daemon on port ${port}...`);
+        }
         const server = new DaemonServer();
         await server.initialize();
         await server.start(port);
-        printHumanReadableLine(`Daemon running on port ${port} (PID: ${process.pid})`);
+        if (!options.quiet) {
+            printHumanReadableLine(`Daemon running on port ${port} (PID: ${process.pid})`);
+        }
         process.on('SIGINT', async () => {
-            printHumanReadableLine('');
-            printHumanReadableLine('Stopping daemon...');
+            if (!options.quiet) {
+                printHumanReadableLine('');
+                printHumanReadableLine('Stopping daemon...');
+            }
             await server.stop();
             process.exit(0);
         });
@@ -72,17 +79,16 @@ async function startDaemon(port, detached = true) {
             process.exit(0);
         });
     }
+    return { running: true, port, detached, alreadyRunning: false };
 }
 async function stopDaemon() {
     const pidInfo = readPid();
     if (!pidInfo) {
-        printHumanReadableLine('Daemon is not running');
-        return;
+        return { stopped: false, wasRunning: false, stalePidFile: false };
     }
     if (!isProcessRunning(pidInfo.pid)) {
-        printHumanReadableLine('Daemon is not running (stale PID file)');
         removePid();
-        return;
+        return { stopped: false, wasRunning: false, stalePidFile: true };
     }
     try {
         process.kill(pidInfo.pid, 'SIGTERM');
@@ -95,59 +101,171 @@ async function stopDaemon() {
         throw new DinoxError(`Daemon did not stop within ${DAEMON_STOP_TIMEOUT_MS}ms. Try stopping it manually and rerun \`dino daemon status\`.`);
     }
     removePid();
-    printHumanReadableLine('Daemon stopped');
+    return { stopped: true, wasRunning: true, stalePidFile: false };
 }
 async function daemonStatus() {
     const pidInfo = readPid();
     if (!pidInfo) {
-        printHumanReadableLine('Status: Not running');
-        return;
+        return { running: false, pid: null, port: null, version: null, stalePidFile: false };
     }
     const running = await isDaemonRunning();
     if (running) {
-        printHumanReadableLine('Status: Running');
-        printHumanReadableLine(`PID: ${pidInfo.pid}`);
-        printHumanReadableLine(`Port: ${pidInfo.port}`);
-        printHumanReadableLine(`Version: ${getPackageVersion()}`);
+        return { running: true, pid: pidInfo.pid, port: pidInfo.port, version: getPackageVersion(), stalePidFile: false };
     }
     else {
-        printHumanReadableLine('Status: Not running (stale PID file)');
         removePid();
+        return { running: false, pid: null, port: null, version: null, stalePidFile: true };
+    }
+}
+function printDaemonStartResult(result) {
+    if (result.alreadyRunning) {
+        printHumanReadableLine('Daemon is already running');
+        return;
+    }
+    if (result.running) {
+        printHumanReadableLine(`Daemon started on port ${result.port}`);
+        return;
+    }
+    printHumanReadableError('Failed to start daemon');
+}
+function printDaemonStopResult(result) {
+    if (result.stopped) {
+        printHumanReadableLine('Daemon stopped');
+        return;
+    }
+    if (result.stalePidFile) {
+        printHumanReadableLine('Daemon is not running (stale PID file)');
+        return;
+    }
+    printHumanReadableLine('Daemon is not running');
+}
+function printDaemonStatusResult(result) {
+    if (!result.running) {
+        printHumanReadableLine(result.stalePidFile ? 'Status: Not running (stale PID file)' : 'Status: Not running');
+        return;
+    }
+    printHumanReadableLine('Status: Running');
+    printHumanReadableLine(`PID: ${result.pid}`);
+    printHumanReadableLine(`Port: ${result.port}`);
+    printHumanReadableLine(`Version: ${result.version}`);
+}
+async function runDaemonStart(context) {
+    const port = parsePort(context.options.port);
+    const structured = Boolean(getRequestedStructuredOutputFormat());
+    const result = await startDaemon(port, context.options.detach !== false, { quiet: structured });
+    if (structured) {
+        printSuccess(result);
+        return;
+    }
+    printDaemonStartResult(result);
+}
+async function runDaemonStop() {
+    const result = await stopDaemon();
+    if (getRequestedStructuredOutputFormat()) {
+        printSuccess(result);
+        return;
+    }
+    printDaemonStopResult(result);
+}
+async function runDaemonStatus() {
+    const result = await daemonStatus();
+    if (getRequestedStructuredOutputFormat()) {
+        printSuccess(result);
+        return;
     }
+    printDaemonStatusResult(result);
 }
+async function runDaemonRestart(context) {
+    const structured = Boolean(getRequestedStructuredOutputFormat());
+    const stopResult = await stopDaemon();
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    const startResult = await startDaemon(parsePort(context.options.port), true, { quiet: structured });
+    if (structured) {
+        printSuccess({ stopped: stopResult.stopped, ...startResult });
+        return;
+    }
+    printDaemonStopResult(stopResult);
+    printDaemonStartResult(startResult);
+}
+export const daemonCommandGroup = {
+    name: 'daemon',
+    description: 'Manage daemon process',
+    commands: [
+        {
+            name: 'start',
+            description: 'Start daemon process',
+            options: [
+                { flags: '--port <number>', description: 'Daemon port', type: 'number', defaultValue: DEFAULT_DAEMON_PORT },
+                { flags: '--no-detach', description: 'Run in foreground for debugging', type: 'boolean' },
+            ],
+            schema: {
+                path: 'daemon.start',
+                risk: 'write',
+                auth: 'none',
+                globalOptions: FORMAT_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Daemon start acknowledgement',
+                    fields: ['running', 'port', 'detached', 'alreadyRunning'],
+                },
+                examples: ['dino daemon start', 'dino daemon start --port 17321', 'dino daemon start --no-detach'],
+            },
+            action: runDaemonStart,
+        },
+        {
+            name: 'stop',
+            description: 'Stop daemon process',
+            schema: {
+                path: 'daemon.stop',
+                risk: 'write',
+                auth: 'none',
+                globalOptions: FORMAT_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Daemon stop acknowledgement',
+                    fields: ['stopped', 'wasRunning', 'stalePidFile'],
+                },
+                examples: ['dino daemon stop'],
+            },
+            action: runDaemonStop,
+        },
+        {
+            name: 'status',
+            description: 'Show daemon status',
+            schema: {
+                path: 'daemon.status',
+                risk: 'read',
+                auth: 'none',
+                globalOptions: FORMAT_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Daemon process status',
+                    fields: ['running', 'pid', 'port', 'version', 'stalePidFile'],
+                },
+                examples: ['dino daemon status'],
+            },
+            action: runDaemonStatus,
+        },
+        {
+            name: 'restart',
+            description: 'Restart daemon process',
+            options: [{ flags: '--port <number>', description: 'Daemon port', type: 'number', defaultValue: DEFAULT_DAEMON_PORT }],
+            schema: {
+                path: 'daemon.restart',
+                risk: 'write',
+                auth: 'none',
+                globalOptions: FORMAT_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Daemon restart acknowledgement',
+                    fields: ['stopped', 'running', 'port', 'detached', 'alreadyRunning'],
+                },
+                examples: ['dino daemon restart', 'dino daemon restart --port 17321'],
+            },
+            action: runDaemonRestart,
+        },
+    ],
+};
 export function registerDaemonCommands(program) {
-    const daemon = program.command('daemon').description('Manage daemon process');
-    daemon
-        .command('start')
-        .description('Start daemon process')
-        .option('--port <number>', 'daemon port', String(DEFAULT_DAEMON_PORT))
-        .option('--no-detach', 'run in foreground (for debugging)')
-        .action(async (options) => {
-        const port = parsePort(options.port);
-        await startDaemon(port, options.detach !== false);
-    });
-    daemon
-        .command('stop')
-        .description('Stop daemon process')
-        .action(async () => {
-        await stopDaemon();
-    });
-    daemon
-        .command('status')
-        .description('Show daemon status')
-        .action(async () => {
-        await daemonStatus();
-    });
-    daemon
-        .command('restart')
-        .description('Restart daemon process')
-        .option('--port <number>', 'daemon port', String(DEFAULT_DAEMON_PORT))
-        .action(async (options) => {
-        await stopDaemon();
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-        await startDaemon(parsePort(options.port));
-    });
-    daemon.action((_options, command) => {
-        command.outputHelp();
-    });
+    registerCommandGroup(program, daemonCommandGroup);
 }