@dinoxx/dinox-cli 1.0.14 → 1.0.16

package/dist/auth/userInfo.d.ts

@@ -8,6 +8,7 @@ export type AuthIdentity = {
 export declare function fetchUserInfoWithAuthorization(input: {
     authorization: string;
     config: ResolvedDinoxConfig;
+    timeoutMs?: number;
     signal?: AbortSignal;
 }): Promise<AuthIdentity>;
 export declare function refreshAndPersistAuthIdentity(rawConfig: DinoxConfig, resolvedConfig: ResolvedDinoxConfig): Promise<AuthIdentity>;

package/dist/auth/userInfo.js

@@ -1,5 +1,7 @@
 import { saveConfig } from '../config/store.js';
 import { DinoxError } from '../utils/errors.js';
+import { createTimeoutSignal, mergeAbortSignals } from '../utils/abort.js';
+import { toAuthorizationHeaderValue } from '../utils/authToken.js';
 const AUTH_CODE_OK = '000000';
 function normalizeOptionalString(value) {
     if (typeof value !== 'string') {
@@ -59,17 +61,34 @@ function resolveUserInfoEndpoint(config) {
 export async function fetchUserInfoWithAuthorization(input) {
     const authorization = normalizeOptionalString(input.authorization);
     if (!authorization) {
-        throw new DinoxError('Authorization is required for user info');
+        throw new DinoxError('Token is required for user info');
     }
     const endpoint = resolveUserInfoEndpoint(input.config);
-    const response = await fetch(endpoint, {
-        method: 'GET',
-        headers: {
-            Authorization: authorization,
-            'Content-Type': 'application/json',
-        },
-        signal: input.signal,
-    });
+    const effectiveTimeoutMs = input.timeoutMs ?? input.config.sync.timeoutMs;
+    const timeout = typeof effectiveTimeoutMs === 'number' && Number.isFinite(effectiveTimeoutMs) && effectiveTimeoutMs > 0
+        ? createTimeoutSignal(effectiveTimeoutMs)
+        : null;
+    const requestSignal = mergeAbortSignals([input.signal, timeout?.signal]);
+    let response;
+    try {
+        response = await fetch(endpoint, {
+            method: 'GET',
+            headers: {
+                Authorization: toAuthorizationHeaderValue(authorization),
+                'Content-Type': 'application/json',
+            },
+            signal: requestSignal,
+        });
+    }
+    catch (error) {
+        if (timeout?.signal.aborted && !input.signal?.aborted) {
+            throw new DinoxError(`User info request timed out after ${effectiveTimeoutMs}ms`);
+        }
+        throw error;
+    }
+    finally {
+        timeout?.cancel();
+    }
     if (!response.ok) {
         const body = await response.text().catch(() => '');
         throw new DinoxError(`User info request failed (${response.status}): ${body || endpoint}`);
@@ -80,7 +99,7 @@ export async function fetchUserInfoWithAuthorization(input) {
 export async function refreshAndPersistAuthIdentity(rawConfig, resolvedConfig) {
     const authorization = normalizeOptionalString(resolvedConfig.auth.authorization);
     if (!authorization) {
-        throw new DinoxError('Authorization is required to fetch user info');
+        throw new DinoxError('Token is required to fetch user info');
     }
     const identity = await fetchUserInfoWithAuthorization({
         authorization,

package/dist/cli.js

@@ -2,7 +2,10 @@ import { Command } from 'commander';
 import { registerAuthCommands } from './commands/auth/index.js';
 import { registerBoxesCommand } from './commands/boxes/index.js';
 import { registerConfigCommands } from './commands/config/index.js';
+import { registerDaemonCommands } from './daemon/index.js';
+import { registerGraphCommands } from './commands/graph/index.js';
 import { registerInfoCommand } from './commands/info/index.js';
+import { registerMCPCommands } from './commands/mcp/index.js';
 import { registerNoteCommands } from './commands/notes/index.js';
 import { registerPromptCommands } from './commands/prompt/index.js';
 import { registerSyncCommand } from './commands/sync.js';
@@ -25,7 +28,10 @@ export function createCli() {
     registerAuthCommands(program);
     registerBoxesCommand(program);
     registerConfigCommands(program);
+    registerDaemonCommands(program);
+    registerGraphCommands(program);
     registerInfoCommand(program);
+    registerMCPCommands(program);
     registerSyncCommand(program);
     registerUpdateCommand(program);
     registerPromptCommands(program);

package/dist/commands/auth/index.js

@@ -5,20 +5,12 @@ import { getPowerSyncDbPath } from '../../config/paths.js';
 import { redactAuthorization } from '../../utils/redact.js';
 import { DinoxError } from '../../utils/errors.js';
 import { printYaml } from '../../utils/output.js';
+import { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
+import { normalizeAuthToken } from '../../utils/authToken.js';
 import { refreshAndPersistAuthIdentity } from '../../auth/userInfo.js';
 import { connectPowerSync, getStatusSnapshot } from '../../powersync/runtime.js';
 import { fetchCredentialsWithAuthorization } from '../../powersync/connector.js';
 import { runSingleSyncPass } from '../../powersync/syncPass.js';
-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);
-}
 async function removeSqliteArtifacts(dbPath) {
     const artifacts = ['', '-wal', '-shm'];
     for (const suffix of artifacts) {
@@ -31,15 +23,15 @@ export function registerAuthCommands(program) {
         .description('Authentication and PowerSync connectivity commands');
     auth
         .command('login')
-        .description('Save authorization token and verify PowerSync connectivity')
-        .argument('<authorization>', 'full Authorization header value (e.g. "Bearer <token>")')
-        .action(async (authorization, _options, command) => {
-        const auth = authorization?.trim();
-        if (!auth) {
-            throw new DinoxError('Authorization token is required');
+        .description('Save login token and verify PowerSync connectivity')
+        .argument('<token>', 'login token (pass the raw token string, without Bearer prefix)')
+        .action(async (token, _options, command) => {
+        const rawToken = normalizeAuthToken(token);
+        if (!rawToken) {
+            throw new DinoxError('Token is required');
         }
         const config = await loadConfig();
-        config.auth = { ...(config.auth ?? {}), authorization: auth };
+        config.auth = { ...(config.auth ?? {}), authorization: rawToken };
         await saveConfig(config);
         const resolved = resolveConfig(config);
         const globals = command.optsWithGlobals?.() ?? {};
@@ -47,9 +39,10 @@ export function registerAuthCommands(program) {
         const jsonOutput = Boolean(globals.json);
         // 1) Token exchange sanity check.
         await fetchCredentialsWithAuthorization({
-            authorization: auth,
+            authorization: rawToken,
             endpoint: resolved.powersync.endpoint,
             credentialsUrl: resolved.powersync.tokenEndpoint,
+            timeoutMs,
         });
         // 1.5) Fetch and persist user identity.
         const identity = await refreshAndPersistAuthIdentity(config, resolved);
@@ -93,12 +86,16 @@ export function registerAuthCommands(program) {
     });
     auth
         .command('logout')
-        .description('Clear saved authorization token')
+        .description('Clear saved login token')
         .option('--clear-local-db', 'delete the local PowerSync SQLite database')
         .action(async (options) => {
         const config = await loadConfig();
         if (config.auth) {
             config.auth.authorization = undefined;
+            config.auth.userId = undefined;
+            config.auth.username = undefined;
+            config.auth.email = undefined;
+            config.auth.userInfoSyncedAt = undefined;
         }
         await saveConfig(config);
         if (options.clearLocalDb) {

package/dist/commands/boxes/index.js

@@ -2,20 +2,11 @@ import { loadConfig } from '../../config/store.js';
 import { resolveConfig } from '../../config/resolve.js';
 import { DinoxError } from '../../utils/errors.js';
 import { printYaml } from '../../utils/output.js';
+import { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
 import { connectPowerSync, waitForIdleDataFlow } from '../../powersync/runtime.js';
 import { syncNoteTokenIndex } from '../../powersync/tokenIndex.js';
 import { resolveAuthIdentity } from '../../auth/userInfo.js';
 import { addBox, listBoxes } from './repo.js';
-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);
-}
 async function syncBeforeBoxCommand(db, offline, timeoutMs) {
     if (offline) {
         return;

package/dist/commands/graph/index.d.ts

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

package/dist/commands/graph/index.js

@@ -0,0 +1,98 @@
+import { printYaml } from '../../utils/output.js';
+import { sendDaemonRequest } from '../../daemon/client.js';
+import { ensureDaemonRunning } from '../../daemon/ensure.js';
+import { DinoxError } from '../../utils/errors.js';
+import { loadConfig } from '../../config/store.js';
+import { resolveConfig } from '../../config/resolve.js';
+import { connectPowerSync } from '../../powersync/runtime.js';
+import { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
+import { getBacklinks, getOutlinks, getRelatedNotes } from './repo.js';
+function parseDepth(value) {
+    if (value === undefined || value === null || value === '') {
+        return 2;
+    }
+    if (typeof value !== 'string') {
+        throw new DinoxError('--depth must be a positive integer');
+    }
+    const trimmed = value.trim();
+    if (!/^\d+$/.test(trimmed)) {
+        throw new DinoxError('--depth must be a positive integer');
+    }
+    const parsed = Number(trimmed);
+    if (!Number.isFinite(parsed) || parsed <= 0 || parsed > 5) {
+        throw new DinoxError('--depth must be between 1 and 5');
+    }
+    return Math.trunc(parsed);
+}
+async function withOfflineDb(command, fn) {
+    const globals = command.optsWithGlobals?.() ?? {};
+    const offline = Boolean(globals.offline);
+    if (!offline) {
+        throw new DinoxError('withOfflineDb called without --offline');
+    }
+    const config = resolveConfig(await loadConfig());
+    const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
+    const { db } = await connectPowerSync({ config, offline: true, timeoutMs });
+    try {
+        return await fn(db);
+    }
+    finally {
+        await db.close().catch(() => undefined);
+    }
+}
+export function registerGraphCommands(program) {
+    const graph = program.command('graph').description('Query knowledge graph');
+    graph
+        .command('backlinks')
+        .description('Get notes that link to this note')
+        .argument('<id>', 'note id')
+        .action(async (id, _options, command) => {
+        const globals = command.optsWithGlobals?.() ?? {};
+        const offline = Boolean(globals.offline);
+        if (offline) {
+            const result = await withOfflineDb(command, (db) => getBacklinks(db, id));
+            printYaml(result);
+            return;
+        }
+        await ensureDaemonRunning();
+        const result = await sendDaemonRequest('graph.backlinks', { id });
+        printYaml(result);
+    });
+    graph
+        .command('outlinks')
+        .description('Get notes that this note links to')
+        .argument('<id>', 'note id')
+        .action(async (id, _options, command) => {
+        const globals = command.optsWithGlobals?.() ?? {};
+        const offline = Boolean(globals.offline);
+        if (offline) {
+            const result = await withOfflineDb(command, (db) => getOutlinks(db, id));
+            printYaml(result);
+            return;
+        }
+        await ensureDaemonRunning();
+        const result = await sendDaemonRequest('graph.outlinks', { id });
+        printYaml(result);
+    });
+    graph
+        .command('related')
+        .description('Get related notes within N degrees of separation')
+        .argument('<id>', 'note id')
+        .option('--depth <n>', 'degrees of separation (1-5, default: 2)')
+        .action(async (id, options, command) => {
+        const depth = parseDepth(options.depth);
+        const globals = command.optsWithGlobals?.() ?? {};
+        const offline = Boolean(globals.offline);
+        if (offline) {
+            const result = await withOfflineDb(command, (db) => getRelatedNotes(db, id, depth));
+            printYaml(result);
+            return;
+        }
+        await ensureDaemonRunning();
+        const result = await sendDaemonRequest('graph.related', { id, depth });
+        printYaml(result);
+    });
+    graph.action((_options, command) => {
+        command.outputHelp();
+    });
+}

package/dist/commands/graph/repo.d.ts

@@ -0,0 +1,33 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+export type NoteLinkRecord = {
+    id: string;
+    src_note_id: string;
+    dst_note_id: string;
+    relation: string | null;
+    created_at: string;
+};
+export type LinkedNote = {
+    note_id: string;
+    title: string;
+    relation: string | null;
+    link_created_at: string;
+};
+export type GraphBacklinksResult = {
+    note_id: string;
+    backlinks: LinkedNote[];
+    count: number;
+};
+export type GraphOutlinksResult = {
+    note_id: string;
+    outlinks: LinkedNote[];
+    count: number;
+};
+export type GraphRelatedResult = {
+    note_id: string;
+    related: LinkedNote[];
+    count: number;
+    depth: number;
+};
+export declare function getBacklinks(db: AbstractPowerSyncDatabase, noteId: string): Promise<GraphBacklinksResult>;
+export declare function getOutlinks(db: AbstractPowerSyncDatabase, noteId: string): Promise<GraphOutlinksResult>;
+export declare function getRelatedNotes(db: AbstractPowerSyncDatabase, noteId: string, depth?: number): Promise<GraphRelatedResult>;

package/dist/commands/graph/repo.js

@@ -0,0 +1,76 @@
+export async function getBacklinks(db, noteId) {
+    const rows = await db.getAll(`SELECT
+      l.id,
+      l.src_note_id,
+      l.dst_note_id,
+      l.relation,
+      l.created_at,
+      n.title
+    FROM c_note_link l
+    LEFT JOIN c_note n ON l.src_note_id = n.id
+    WHERE l.dst_note_id = ? AND l.is_del = 0 AND (n.is_del = 0 OR n.is_del IS NULL)
+    ORDER BY l.created_at DESC`, [noteId]);
+    const backlinks = rows.map((row) => ({
+        note_id: row.src_note_id,
+        title: row.title || '',
+        relation: row.relation,
+        link_created_at: row.created_at,
+    }));
+    return {
+        note_id: noteId,
+        backlinks,
+        count: backlinks.length,
+    };
+}
+export async function getOutlinks(db, noteId) {
+    const rows = await db.getAll(`SELECT
+      l.id,
+      l.src_note_id,
+      l.dst_note_id,
+      l.relation,
+      l.created_at,
+      n.title
+    FROM c_note_link l
+    LEFT JOIN c_note n ON l.dst_note_id = n.id
+    WHERE l.src_note_id = ? AND l.is_del = 0 AND (n.is_del = 0 OR n.is_del IS NULL)
+    ORDER BY l.created_at DESC`, [noteId]);
+    const outlinks = rows.map((row) => ({
+        note_id: row.dst_note_id,
+        title: row.title || '',
+        relation: row.relation,
+        link_created_at: row.created_at,
+    }));
+    return {
+        note_id: noteId,
+        outlinks,
+        count: outlinks.length,
+    };
+}
+export async function getRelatedNotes(db, noteId, depth = 2) {
+    const visited = new Set([noteId]);
+    const related = new Map();
+    async function traverse(currentId, currentDepth) {
+        if (currentDepth > depth)
+            return;
+        const [backlinks, outlinks] = await Promise.all([
+            getBacklinks(db, currentId),
+            getOutlinks(db, currentId),
+        ]);
+        for (const link of [...backlinks.backlinks, ...outlinks.outlinks]) {
+            if (!visited.has(link.note_id)) {
+                visited.add(link.note_id);
+                related.set(link.note_id, link);
+                if (currentDepth < depth) {
+                    await traverse(link.note_id, currentDepth + 1);
+                }
+            }
+        }
+    }
+    await traverse(noteId, 1);
+    return {
+        note_id: noteId,
+        related: Array.from(related.values()),
+        count: related.size,
+        depth,
+    };
+}

package/dist/commands/mcp/auth.d.ts

@@ -0,0 +1,4 @@
+import type { IncomingHttpHeaders } from 'node:http';
+export declare function isLoopbackHost(host: string): boolean;
+export declare function resolveMCPAuthToken(tokenOption: unknown, envToken?: string | undefined): string | undefined;
+export declare function isAuthorizedMCPRequest(headers: IncomingHttpHeaders, expectedToken?: string): boolean;

package/dist/commands/mcp/auth.js

@@ -0,0 +1,75 @@
+import { timingSafeEqual } from 'node:crypto';
+import { DinoxError } from '../../utils/errors.js';
+const AUTH_HEADER_RE = /^Bearer\s+(.+)$/i;
+export function isLoopbackHost(host) {
+    const normalized = host.trim().toLowerCase();
+    return normalized === '127.0.0.1' || normalized === 'localhost' || normalized === '::1';
+}
+export function resolveMCPAuthToken(tokenOption, envToken = process.env.DINOX_MCP_TOKEN) {
+    if (tokenOption !== undefined && tokenOption !== null) {
+        if (typeof tokenOption !== 'string') {
+            throw new DinoxError('--token must be a non-empty string');
+        }
+        const parsed = tokenOption.trim();
+        if (!parsed) {
+            throw new DinoxError('--token must be a non-empty string');
+        }
+        return parsed;
+    }
+    const fromEnv = envToken?.trim() ?? '';
+    return fromEnv || undefined;
+}
+function readHeaderTokenValue(value) {
+    if (typeof value === 'string') {
+        const parsed = value.trim();
+        return parsed || undefined;
+    }
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    for (const item of value) {
+        const parsed = item.trim();
+        if (parsed) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function readBearerToken(headers) {
+    const authorization = readHeaderTokenValue(headers.authorization);
+    if (!authorization) {
+        return undefined;
+    }
+    const match = authorization.match(AUTH_HEADER_RE);
+    if (!match) {
+        return undefined;
+    }
+    const token = match[1]?.trim() ?? '';
+    return token || undefined;
+}
+function readMCPToken(headers) {
+    const bearer = readBearerToken(headers);
+    if (bearer) {
+        return bearer;
+    }
+    const raw = readHeaderTokenValue(headers['x-dinox-token']);
+    return raw?.trim() || undefined;
+}
+function secureTokenEquals(left, right) {
+    const leftBuffer = Buffer.from(left);
+    const rightBuffer = Buffer.from(right);
+    if (leftBuffer.length !== rightBuffer.length) {
+        return false;
+    }
+    return timingSafeEqual(leftBuffer, rightBuffer);
+}
+export function isAuthorizedMCPRequest(headers, expectedToken) {
+    if (!expectedToken) {
+        return true;
+    }
+    const provided = readMCPToken(headers);
+    if (!provided) {
+        return false;
+    }
+    return secureTokenEquals(provided, expectedToken);
+}

package/dist/commands/mcp/index.d.ts

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

package/dist/commands/mcp/index.js

@@ -0,0 +1,84 @@
+import { startMCPServer } from './server.js';
+import { mcpTools } from './tools.js';
+import { isLoopbackHost, resolveMCPAuthToken } from './auth.js';
+import { DinoxError } from '../../utils/errors.js';
+function parsePort(value) {
+    if (value === undefined || value === null || value === '') {
+        return 3000;
+    }
+    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);
+}
+function parseHost(value) {
+    if (value === undefined || value === null || value === '') {
+        return '127.0.0.1';
+    }
+    if (typeof value !== 'string') {
+        throw new DinoxError('--host must be a valid hostname or IP address');
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new DinoxError('--host must be a valid hostname or IP address');
+    }
+    return trimmed;
+}
+export function registerMCPCommands(program) {
+    const mcp = program.command('mcp').description('MCP (Model Context Protocol) server');
+    mcp
+        .command('serve')
+        .description('Start MCP server for AI agent integration')
+        .option('--host <string>', 'bind address (default: 127.0.0.1)')
+        .option('--port <number>', 'server port (default: 3000)')
+        .option('--token <string>', 'auth token (or DINOX_MCP_TOKEN env var)')
+        .action(async (options) => {
+        const port = parsePort(options.port);
+        const host = parseHost(options.host);
+        const token = resolveMCPAuthToken(options.token);
+        const loopback = isLoopbackHost(host);
+        if (!loopback && !token) {
+            throw new DinoxError('--token (or DINOX_MCP_TOKEN) is required when --host is non-loopback');
+        }
+        console.log('Starting Dinox MCP server...');
+        console.log(`Host: ${host}`);
+        console.log(`Port: ${port}`);
+        console.log(`Auth: ${token ? 'enabled' : 'disabled (loopback only)'}`);
+        console.log('Protocol: Model Context Protocol (MCP)');
+        if (!loopback) {
+            console.log('warning: binding to a non-loopback host may expose your local data; use firewall/auth as needed');
+        }
+        console.log('');
+        console.log('Available tools:');
+        for (const tool of mcpTools) {
+            console.log(`  - ${tool.name}`);
+        }
+        console.log('');
+        const { server, mcpServer } = await startMCPServer(port, host, token);
+        let shuttingDown = false;
+        const shutdown = async () => {
+            if (shuttingDown)
+                return;
+            shuttingDown = true;
+            await new Promise((resolve) => server.close(() => resolve()));
+            await mcpServer.close();
+        };
+        process.on('SIGINT', () => {
+            void shutdown().finally(() => process.exit(0));
+        });
+        process.on('SIGTERM', () => {
+            void shutdown().finally(() => process.exit(0));
+        });
+    });
+    mcp.action((_options, command) => {
+        command.outputHelp();
+    });
+}

package/dist/commands/mcp/server.d.ts

@@ -0,0 +1,30 @@
+import type { IncomingMessage, Server } from 'node:http';
+type MCPRequest = {
+    jsonrpc: '2.0';
+    id: string | number;
+    method: string;
+    params?: any;
+};
+type MCPResponse = {
+    jsonrpc: '2.0';
+    id: string | number;
+    result?: any;
+    error?: {
+        code: number;
+        message: string;
+    };
+};
+export declare class MCPServer {
+    private db;
+    initialize(): Promise<void>;
+    handleRequest(req: MCPRequest): Promise<MCPResponse>;
+    private handleInitialize;
+    private handleToolsList;
+    private handleToolsCall;
+    close(): Promise<void>;
+}
+export declare function startMCPServer(port?: number, host?: string, authToken?: string): Promise<{
+    server: Server<typeof IncomingMessage, typeof import("http").ServerResponse>;
+    mcpServer: MCPServer;
+}>;
+export {};