@dinoxx/dinox-cli 1.0.15 → 1.0.17

package/dist/daemon/index.js

@@ -0,0 +1,151 @@
+import { spawn } from 'child_process';
+import { DaemonServer } from './server.js';
+import { DEFAULT_DAEMON_PORT } from './types.js';
+import { readPid, isProcessRunning, removePid } from './pid.js';
+import { isDaemonRunning } from './client.js';
+import { getPackageVersion } from '../utils/version.js';
+import { DinoxError } from '../utils/errors.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') {
+        throw new DinoxError('--port must be a valid port number');
+    }
+    const trimmed = value.trim();
+    if (!/^\d+$/.test(trimmed)) {
+        throw new DinoxError('--port must be a valid port number');
+    }
+    const parsed = Number(trimmed);
+    if (!Number.isFinite(parsed) || parsed < 1 || parsed > 65535) {
+        throw new DinoxError('--port must be between 1 and 65535');
+    }
+    return Math.trunc(parsed);
+}
+async function waitForProcessExit(pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!isProcessRunning(pid)) {
+            return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, DAEMON_STOP_POLL_INTERVAL_MS));
+    }
+    return !isProcessRunning(pid);
+}
+async function startDaemon(port, detached = true) {
+    if (await isDaemonRunning()) {
+        console.log('Daemon is already running');
+        return;
+    }
+    if (detached) {
+        const args = ['daemon', 'start', '--port', String(port), '--no-detach'];
+        const child = spawn(process.argv[0], [process.argv[1], ...args], {
+            detached: true,
+            stdio: 'ignore',
+        });
+        child.unref();
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        if (await isDaemonRunning()) {
+            console.log(`Daemon started on port ${port}`);
+        }
+        else {
+            console.error('Failed to start daemon');
+        }
+    }
+    else {
+        console.log(`Starting daemon on port ${port}...`);
+        const server = new DaemonServer();
+        await server.initialize();
+        await server.start(port);
+        console.log(`Daemon running on port ${port} (PID: ${process.pid})`);
+        process.on('SIGINT', async () => {
+            console.log('\nStopping daemon...');
+            await server.stop();
+            process.exit(0);
+        });
+        process.on('SIGTERM', async () => {
+            await server.stop();
+            process.exit(0);
+        });
+    }
+}
+async function stopDaemon() {
+    const pidInfo = readPid();
+    if (!pidInfo) {
+        console.log('Daemon is not running');
+        return;
+    }
+    if (!isProcessRunning(pidInfo.pid)) {
+        console.log('Daemon is not running (stale PID file)');
+        removePid();
+        return;
+    }
+    try {
+        process.kill(pidInfo.pid, 'SIGTERM');
+    }
+    catch (error) {
+        throw new DinoxError(`Failed to stop daemon: ${error.message}`);
+    }
+    const stopped = await waitForProcessExit(pidInfo.pid, DAEMON_STOP_TIMEOUT_MS);
+    if (!stopped) {
+        throw new DinoxError(`Daemon did not stop within ${DAEMON_STOP_TIMEOUT_MS}ms. Try stopping it manually and rerun \`dino daemon status\`.`);
+    }
+    removePid();
+    console.log('Daemon stopped');
+}
+async function daemonStatus() {
+    const pidInfo = readPid();
+    if (!pidInfo) {
+        console.log('Status: Not running');
+        return;
+    }
+    const running = await isDaemonRunning();
+    if (running) {
+        console.log('Status: Running');
+        console.log(`PID: ${pidInfo.pid}`);
+        console.log(`Port: ${pidInfo.port}`);
+        console.log(`Version: ${getPackageVersion()}`);
+    }
+    else {
+        console.log('Status: Not running (stale PID file)');
+        removePid();
+    }
+}
+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();
+    });
+}

package/dist/daemon/pid.d.ts

@@ -0,0 +1,10 @@
+export declare function getDaemonDir(): string;
+export declare function getPidFilePath(): string;
+export declare function getPortFilePath(): string;
+export declare function savePid(pid: number, port: number): void;
+export declare function readPid(): {
+    pid: number;
+    port: number;
+} | null;
+export declare function removePid(): void;
+export declare function isProcessRunning(pid: number): boolean;

package/dist/daemon/pid.js

@@ -0,0 +1,55 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync } from 'fs';
+export function getDaemonDir() {
+    return join(homedir(), '.dinox', 'daemon');
+}
+export function getPidFilePath() {
+    return join(getDaemonDir(), 'daemon.pid');
+}
+export function getPortFilePath() {
+    return join(getDaemonDir(), 'daemon.port');
+}
+export function savePid(pid, port) {
+    const dir = getDaemonDir();
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(getPidFilePath(), String(pid));
+    writeFileSync(getPortFilePath(), String(port));
+}
+export function readPid() {
+    try {
+        const pid = parseInt(readFileSync(getPidFilePath(), 'utf-8').trim());
+        const port = parseInt(readFileSync(getPortFilePath(), 'utf-8').trim());
+        if (!Number.isFinite(pid) || pid <= 0) {
+            return null;
+        }
+        if (!Number.isFinite(port) || port < 1 || port > 65535) {
+            return null;
+        }
+        return { pid, port };
+    }
+    catch {
+        return null;
+    }
+}
+export function removePid() {
+    for (const path of [getPidFilePath(), getPortFilePath()]) {
+        try {
+            unlinkSync(path);
+        }
+        catch {
+            // Ignore missing files/stale paths.
+        }
+    }
+}
+export function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/daemon/server.d.ts

@@ -0,0 +1,10 @@
+import type { DaemonRequest, DaemonResponse } from './types.js';
+export declare class DaemonServer {
+    private db;
+    private server;
+    private startTime;
+    initialize(): Promise<void>;
+    handleRequest(req: DaemonRequest): Promise<DaemonResponse>;
+    start(port: number): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/daemon/server.js

@@ -0,0 +1,140 @@
+import { createServer } from 'http';
+import { loadConfig } from '../config/store.js';
+import { resolveConfig } from '../config/resolve.js';
+import { connectPowerSync, waitForIdleDataFlow } from '../powersync/runtime.js';
+import { searchNotes, getNoteDetails } from '../commands/notes/repo.js';
+import { getBacklinks, getGraphStats, getOutlinks, getRelatedNotes } from '../commands/graph/repo.js';
+import { searchTodoTasks } from '../commands/todo/repo.js';
+import { savePid, removePid } from './pid.js';
+import { getPackageVersion } from '../utils/version.js';
+const MAX_DAEMON_REQUEST_BYTES = 1 * 1024 * 1024;
+async function readJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let totalBytes = 0;
+        req.on('data', (chunk) => {
+            totalBytes += chunk.length;
+            if (totalBytes > MAX_DAEMON_REQUEST_BYTES) {
+                req.destroy(new Error('Request body too large'));
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on('end', () => {
+            try {
+                const body = Buffer.concat(chunks).toString('utf-8');
+                resolve(JSON.parse(body));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        req.on('error', reject);
+    });
+}
+export class DaemonServer {
+    db = null;
+    server = null;
+    startTime = Date.now();
+    async initialize() {
+        const config = resolveConfig(await loadConfig());
+        const { db } = await connectPowerSync({ config, offline: false, timeoutMs: config.sync.timeoutMs });
+        this.db = db;
+        setInterval(async () => {
+            if (this.db) {
+                await waitForIdleDataFlow(this.db, 5000).catch(() => { });
+            }
+        }, 30000);
+    }
+    async handleRequest(req) {
+        try {
+            if (!this.db) {
+                throw new Error('Database not initialized');
+            }
+            const { method, params } = req;
+            switch (method) {
+                case 'ping':
+                    return { id: req.id, ok: true, result: { uptime: Date.now() - this.startTime, version: getPackageVersion() } };
+                case 'note.search':
+                    const notes = await searchNotes(this.db, params.query || '', {
+                        includeDeleted: params.includeDeleted || false,
+                        tagsExpression: params.tags,
+                        createdAtFrom: params.from,
+                        createdAtTo: params.to,
+                    });
+                    return { id: req.id, ok: true, result: notes };
+                case 'note.get':
+                    const noteDetails = await getNoteDetails(this.db, [params.id]);
+                    return { id: req.id, ok: true, result: noteDetails[0] || null };
+                case 'graph.backlinks':
+                    const backlinks = await getBacklinks(this.db, params.id);
+                    return { id: req.id, ok: true, result: backlinks };
+                case 'graph.outlinks':
+                    const outlinks = await getOutlinks(this.db, params.id);
+                    return { id: req.id, ok: true, result: outlinks };
+                case 'graph.related':
+                    const related = await getRelatedNotes(this.db, params.id, params.depth || 2);
+                    return { id: req.id, ok: true, result: related };
+                case 'graph.stats':
+                    const graphStats = await getGraphStats(this.db);
+                    return { id: req.id, ok: true, result: graphStats };
+                case 'todo.search':
+                    const todos = await searchTodoTasks(this.db, params.query || '', {
+                        includeDeleted: false,
+                        taskStatus: params.status || 'all',
+                        taskTagFilter: params.tags || [],
+                        limit: params.limit || 50,
+                        scanLimit: params.scanLimit || 200,
+                    });
+                    return { id: req.id, ok: true, result: todos };
+                default:
+                    throw new Error(`Unknown method: ${method}`);
+            }
+        }
+        catch (error) {
+            return { id: req.id, ok: false, error: error.message };
+        }
+    }
+    async start(port) {
+        this.server = createServer(async (req, res) => {
+            if (req.method === 'POST') {
+                try {
+                    const daemonReq = await readJsonBody(req);
+                    const daemonRes = await this.handleRequest(daemonReq);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(daemonRes));
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    const statusCode = message.includes('too large') ? 413 : 400;
+                    res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: message }));
+                }
+            }
+            else {
+                res.writeHead(405);
+                res.end();
+            }
+        });
+        this.server.headersTimeout = 5_000;
+        this.server.requestTimeout = 10_000;
+        await new Promise((resolve, reject) => {
+            if (!this.server) {
+                reject(new Error('Server not initialized'));
+                return;
+            }
+            this.server.once('error', reject);
+            this.server.listen(port, '127.0.0.1', () => resolve());
+        });
+        savePid(process.pid, port);
+    }
+    async stop() {
+        if (this.server) {
+            await new Promise((resolve) => this.server?.close(() => resolve()));
+        }
+        if (this.db) {
+            await this.db.close().catch(() => { });
+        }
+        removePid();
+    }
+}

package/dist/daemon/types.d.ts

@@ -0,0 +1,19 @@
+export type DaemonRequest = {
+    id: string;
+    method: string;
+    params?: any;
+};
+export type DaemonResponse = {
+    id: string;
+    ok: boolean;
+    result?: any;
+    error?: string;
+};
+export type DaemonStatus = {
+    running: boolean;
+    pid?: number;
+    port?: number;
+    uptime?: number;
+    version?: string;
+};
+export declare const DEFAULT_DAEMON_PORT = 45678;

package/dist/daemon/types.js

@@ -0,0 +1 @@
+export const DEFAULT_DAEMON_PORT = 45678;

package/dist/dinox.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createCli } from './cli.js';
-import { isDinoxError } from './utils/errors.js';
+import { buildStructuredErrorPayload, isDinoxError } from './utils/errors.js';
 import { printYaml } from './utils/output.js';
 function normalizeArgv(argv) {
     // pnpm/npm script forwarding can prepend a standalone "--".
@@ -25,26 +25,18 @@ main().catch((error) => {
     const argv = process.argv;
     const json = shouldOutputJson(argv);
     const verbose = isVerbose(argv);
-    const message = error instanceof Error ? error.message : String(error);
-    const name = error instanceof Error ? error.name : 'Error';
-    const stack = error instanceof Error ? error.stack : undefined;
-    const details = isDinoxError(error) ? error.details : undefined;
+    const payload = buildStructuredErrorPayload(error, verbose);
     const exitCode = isDinoxError(error) ? error.exitCode : 1;
     process.exitCode = exitCode;
     if (json) {
         printYaml({
             ok: false,
-            error: {
-                name,
-                message,
-                ...(details !== undefined ? { details } : {}),
-                ...(verbose && stack ? { stack } : {}),
-            },
+            error: payload,
         });
         return;
     }
-    console.error(message);
-    if (verbose && stack) {
-        console.error(stack);
+    console.error(payload.message);
+    if (verbose && payload.stack) {
+        console.error(payload.stack);
     }
 });

package/dist/utils/errors.d.ts

@@ -1,10 +1,27 @@
+export type DinoxErrorOptions = {
+    exitCode?: number;
+    cause?: unknown;
+    details?: unknown;
+    code?: string;
+    suggestion?: string;
+    recoverable?: boolean;
+};
+export type StructuredErrorPayload = {
+    name: string;
+    code: string;
+    message: string;
+    recoverable: boolean;
+    suggestion?: string;
+    details?: unknown;
+    stack?: string;
+};
 export declare class DinoxError extends Error {
     readonly exitCode: number;
     readonly details?: unknown;
-    constructor(message: string, options?: {
-        exitCode?: number;
-        cause?: unknown;
-        details?: unknown;
-    });
+    readonly code?: string;
+    readonly suggestion?: string;
+    readonly recoverable: boolean;
+    constructor(message: string, options?: DinoxErrorOptions);
 }
 export declare function isDinoxError(error: unknown): error is DinoxError;
+export declare function buildStructuredErrorPayload(error: unknown, verbose: boolean): StructuredErrorPayload;

package/dist/utils/errors.js

@@ -1,11 +1,17 @@
 export class DinoxError extends Error {
     exitCode;
     details;
+    code;
+    suggestion;
+    recoverable;
     constructor(message, options) {
         super(message);
         this.name = 'DinoxError';
         this.exitCode = options?.exitCode ?? 1;
         this.details = options?.details;
+        this.code = options?.code;
+        this.suggestion = options?.suggestion;
+        this.recoverable = options?.recoverable ?? true;
         if (options?.cause !== undefined) {
             // Node 16+ supports Error.cause.
             this.cause = options.cause;
@@ -15,3 +21,26 @@ export class DinoxError extends Error {
 export function isDinoxError(error) {
     return Boolean(error) && typeof error === 'object' && error.name === 'DinoxError';
 }
+export function buildStructuredErrorPayload(error, verbose) {
+    const message = error instanceof Error ? error.message : String(error);
+    const name = error instanceof Error ? error.name : 'Error';
+    const stack = error instanceof Error ? error.stack : undefined;
+    if (isDinoxError(error)) {
+        return {
+            name,
+            code: error.code ?? 'DINOX_ERROR',
+            message,
+            recoverable: error.recoverable,
+            ...(error.suggestion ? { suggestion: error.suggestion } : {}),
+            ...(error.details !== undefined ? { details: error.details } : {}),
+            ...(verbose && stack ? { stack } : {}),
+        };
+    }
+    return {
+        name,
+        code: 'INTERNAL_ERROR',
+        message,
+        recoverable: false,
+        ...(verbose && stack ? { stack } : {}),
+    };
+}

package/package.json

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