@dinoxx/dinox-cli 1.0.15 → 1.0.16

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/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 {};