@dinoxx/dinox-cli 1.0.14 → 1.0.16

package/dist/commands/todo/index.js

@@ -3,6 +3,7 @@ import { resolveConfig } from '../../config/resolve.js';
 import { DinoxError } from '../../utils/errors.js';
 import { readStringOrFile } from '../../utils/argValue.js';
 import { printYaml } from '../../utils/output.js';
+import { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
 import { connectPowerSync, waitForIdleDataFlow } from '../../powersync/runtime.js';
 import { resolveAuthIdentity } from '../../auth/userInfo.js';
 import { appendTodoTasks, createTodoNote, normalizeTaskTexts, searchTodoTasks, updateTodoTaskStatus, } from './repo.js';
@@ -12,16 +13,6 @@ const DEFAULT_TASK_LIMIT = 50;
 const DEFAULT_NOTE_SCAN_LIMIT = 200;
 const MAX_TASK_LIMIT = 500;
 const MAX_NOTE_SCAN_LIMIT = 5000;
-function parseSyncTimeoutMs(value) {
-    if (typeof value !== 'string') {
-        return undefined;
-    }
-    const parsed = Number(value);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
-        throw new DinoxError('--sync-timeout must be a positive integer');
-    }
-    return Math.trunc(parsed);
-}
 function parseTaskStatus(value) {
     const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
     if (normalized === 'all' || normalized === 'completed' || normalized === 'uncompleted') {

package/dist/config/resolve.js

@@ -1,4 +1,5 @@
 import { POWERSYNC_DEFAULT_ENDPOINT, POWERSYNC_DEFAULT_TOKEN_ENDPOINT, POWERSYNC_DEFAULT_UPLOAD_BASE_URL, } from './serviceEndpoints.js';
+import { normalizeAuthToken } 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;
@@ -20,7 +21,7 @@ function parsePositiveInt(value) {
     return Math.trunc(parsed);
 }
 export function resolveConfig(raw) {
-    const fileAuth = nonEmptyString(raw.auth?.authorization);
+    const fileAuth = normalizeAuthToken(raw.auth?.authorization);
     const fileUserId = nonEmptyString(raw.auth?.userId);
     const fileUsername = nonEmptyString(raw.auth?.username ?? undefined) ?? raw.auth?.username ?? undefined;
     const fileEmail = nonEmptyString(raw.auth?.email ?? undefined) ?? raw.auth?.email ?? undefined;
@@ -29,7 +30,7 @@ export function resolveConfig(raw) {
     const fileUploadV4Path = nonEmptyString(raw.powersync?.uploadV4Path);
     const fileUploadV2Path = nonEmptyString(raw.powersync?.uploadV2Path);
     const fileTimeoutMs = parsePositiveInt(raw.sync?.timeoutMs);
-    const envAuth = nonEmptyString(process.env.DINOX_AUTHORIZATION);
+    const envAuth = normalizeAuthToken(process.env.DINOX_AUTHORIZATION);
     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);

package/dist/config/store.js

@@ -2,9 +2,24 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { getConfigDir, getConfigFilePath } from './paths.js';
 import { generateId } from '../utils/id.js';
+import { DinoxError } from '../utils/errors.js';
 function isPlainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+const FORBIDDEN_KEY_PATH_SEGMENTS = new Set(['__proto__', 'prototype', 'constructor']);
+function splitKeyPath(keyPath) {
+    const segments = keyPath
+        .split('.')
+        .map(segment => segment.trim())
+        .filter(Boolean);
+    for (const segment of segments) {
+        const normalized = segment.toLowerCase();
+        if (FORBIDDEN_KEY_PATH_SEGMENTS.has(normalized)) {
+            throw new DinoxError(`Invalid config key path: ${keyPath}`);
+        }
+    }
+    return segments;
+}
 async function ensureConfigDir() {
     const dir = getConfigDir();
     await fs.mkdir(dir, { recursive: true, mode: 0o700 });
@@ -47,7 +62,7 @@ export async function saveConfig(config) {
     await fs.rename(tmpPath, filePath);
 }
 function setDeepValue(target, keyPath, value) {
-    const segments = keyPath.split('.').filter(Boolean);
+    const segments = splitKeyPath(keyPath);
     if (segments.length === 0) {
         return;
     }
@@ -63,7 +78,7 @@ function setDeepValue(target, keyPath, value) {
     cursor[segments[segments.length - 1]] = value;
 }
 function getDeepValue(target, keyPath) {
-    const segments = keyPath.split('.').filter(Boolean);
+    const segments = splitKeyPath(keyPath);
     let cursor = target;
     for (const segment of segments) {
         if (!isPlainObject(cursor)) {

package/dist/config/types.d.ts

@@ -1,8 +1,7 @@
 export type DinoxConfig = {
     auth?: {
         /**
-         * Full Authorization header value.
-         * Example: "Bearer <token>".
+         * Login token string (pass the raw token string; do not include a Bearer prefix).
          */
         authorization?: string;
         /**

package/dist/daemon/client.d.ts

@@ -0,0 +1,2 @@
+export declare function sendDaemonRequest(method: string, params?: unknown): Promise<unknown>;
+export declare function isDaemonRunning(): Promise<boolean>;

package/dist/daemon/client.js

@@ -0,0 +1,86 @@
+import { request as httpRequest } from 'node:http';
+import { DEFAULT_DAEMON_PORT } from './types.js';
+import { readPid } from './pid.js';
+const DEFAULT_DAEMON_REQUEST_TIMEOUT_MS = 2_000;
+const MAX_DAEMON_RESPONSE_BYTES = 5 * 1024 * 1024;
+export async function sendDaemonRequest(method, params) {
+    const pidInfo = readPid();
+    const port = pidInfo?.port || DEFAULT_DAEMON_PORT;
+    const request = {
+        id: Date.now().toString(),
+        method,
+        params,
+    };
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finalize = (error, value) => {
+            if (settled)
+                return;
+            settled = true;
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(value);
+        };
+        const data = JSON.stringify(request);
+        const options = {
+            hostname: '127.0.0.1',
+            port,
+            path: '/',
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(data),
+            },
+            timeout: DEFAULT_DAEMON_REQUEST_TIMEOUT_MS,
+        };
+        const req = httpRequest(options, (res) => {
+            const statusCode = res.statusCode ?? 0;
+            const chunks = [];
+            let totalBytes = 0;
+            res.on('data', (chunk) => {
+                totalBytes += chunk.length;
+                if (totalBytes > MAX_DAEMON_RESPONSE_BYTES) {
+                    req.destroy(new Error('Daemon response too large'));
+                    return;
+                }
+                chunks.push(chunk);
+            });
+            res.on('end', () => {
+                try {
+                    const body = Buffer.concat(chunks).toString('utf-8');
+                    if (statusCode < 200 || statusCode >= 300) {
+                        finalize(new Error(`Daemon request failed (HTTP ${statusCode || 'unknown'}): ${body || '(empty)'}`));
+                        return;
+                    }
+                    const response = JSON.parse(body);
+                    if (response.ok) {
+                        finalize(undefined, response.result);
+                    }
+                    else {
+                        finalize(new Error(response.error || 'Unknown error'));
+                    }
+                }
+                catch (error) {
+                    finalize(error);
+                }
+            });
+        });
+        req.on('timeout', () => {
+            req.destroy(new Error('Daemon request timed out'));
+        });
+        req.on('error', (error) => finalize(error));
+        req.write(data);
+        req.end();
+    });
+}
+export async function isDaemonRunning() {
+    try {
+        await sendDaemonRequest('ping');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/daemon/ensure.d.ts

@@ -0,0 +1 @@
+export declare function ensureDaemonRunning(): Promise<void>;

package/dist/daemon/ensure.js

@@ -0,0 +1,23 @@
+import { spawn } from 'child_process';
+import { isDaemonRunning } from './client.js';
+import { DEFAULT_DAEMON_PORT } from './types.js';
+export async function ensureDaemonRunning() {
+    if (await isDaemonRunning()) {
+        return;
+    }
+    console.log('Starting daemon...');
+    const args = ['daemon', 'start', '--port', String(DEFAULT_DAEMON_PORT), '--no-detach'];
+    const child = spawn(process.argv[0], [process.argv[1], ...args], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+    for (let i = 0; i < 10; i++) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        if (await isDaemonRunning()) {
+            console.log('Daemon started');
+            return;
+        }
+    }
+    throw new Error('Failed to start daemon');
+}

package/dist/daemon/index.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerDaemonCommands(program: Command): void;

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,137 @@
+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, 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 '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/powersync/connector.d.ts

@@ -13,9 +13,10 @@ export declare class PowerSyncConnector implements PowerSyncBackendConnector {
     fetchCredentials(): Promise<PowerSyncCredentials>;
     uploadData(database: AbstractPowerSyncDatabase): Promise<void>;
 }
-export declare function fetchCredentialsWithAuthorization({ authorization, endpoint, credentialsUrl, signal, }: {
+export declare function fetchCredentialsWithAuthorization({ authorization, endpoint, credentialsUrl, timeoutMs, signal, }: {
     authorization: string;
     endpoint: string;
     credentialsUrl: string;
+    timeoutMs?: number;
     signal?: AbortSignal;
 }): Promise<PowerSyncCredentials>;