@dinoxx/dinox-cli 1.0.15 → 1.0.16

package/dist/commands/mcp/server.js

@@ -0,0 +1,324 @@
+import { createServer } from 'node:http';
+import { mcpTools } from './tools.js';
+import { isAuthorizedMCPRequest } from './auth.js';
+import { resolveAuthIdentity } from '../../auth/userInfo.js';
+import { loadConfig } from '../../config/store.js';
+import { resolveConfig } from '../../config/resolve.js';
+import { connectPowerSync } from '../../powersync/runtime.js';
+import { parseCreatedAtRange } from '../notes/searchTime.js';
+import { createNote, getNoteDetails, resolveZettelBoxIdsForCreate, resolveZettelBoxIdsForSearch, searchNotes, validateTagsForCreate, } from '../notes/repo.js';
+import { getBacklinks, getOutlinks, getRelatedNotes } from '../graph/repo.js';
+import { searchTodoTasks } from '../todo/repo.js';
+import { convertMarkdownToNoteContent } from '../../utils/tiptapMarkdown.js';
+import { generateId } from '../../utils/id.js';
+import { getPackageVersion } from '../../utils/version.js';
+const MAX_MCP_REQUEST_BYTES = 1 * 1024 * 1024;
+const DEFAULT_SEARCH_LIMIT = 50;
+const MAX_SEARCH_LIMIT = 500;
+function normalizeLimit(value) {
+    if (value === undefined || value === null) {
+        return DEFAULT_SEARCH_LIMIT;
+    }
+    const raw = typeof value === 'number'
+        ? value
+        : typeof value === 'string'
+            ? Number(value)
+            : NaN;
+    if (!Number.isFinite(raw)) {
+        return DEFAULT_SEARCH_LIMIT;
+    }
+    const int = Math.trunc(raw);
+    if (int <= 0) {
+        return DEFAULT_SEARCH_LIMIT;
+    }
+    return Math.min(int, MAX_SEARCH_LIMIT);
+}
+function normalizeStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.map((item) => (typeof item === 'string' ? item.trim() : '')).filter(Boolean);
+}
+function parseBoxFilter(value) {
+    if (Array.isArray(value)) {
+        return { names: normalizeStringArray(value), matchEmpty: false };
+    }
+    if (typeof value !== 'string') {
+        return { names: [], matchEmpty: false };
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return { names: [], matchEmpty: false };
+    }
+    if (trimmed === '[]') {
+        return { names: [], matchEmpty: true };
+    }
+    const names = trimmed
+        .split(/[,\n]/)
+        .map((name) => name.trim())
+        .filter(Boolean);
+    return { names, matchEmpty: false };
+}
+async function readJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let totalBytes = 0;
+        req.on('data', (chunk) => {
+            totalBytes += chunk.length;
+            if (totalBytes > MAX_MCP_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 MCPServer {
+    db = null;
+    async initialize() {
+        const config = resolveConfig(await loadConfig());
+        const { db } = await connectPowerSync({ config, offline: false, timeoutMs: config.sync.timeoutMs });
+        this.db = db;
+    }
+    async handleRequest(req) {
+        try {
+            switch (req.method) {
+                case 'initialize':
+                    return this.handleInitialize(req);
+                case 'tools/list':
+                    return this.handleToolsList(req);
+                case 'tools/call':
+                    return await this.handleToolsCall(req);
+                default:
+                    return {
+                        jsonrpc: '2.0',
+                        id: req.id,
+                        error: { code: -32601, message: 'Method not found' },
+                    };
+            }
+        }
+        catch (error) {
+            return {
+                jsonrpc: '2.0',
+                id: req.id,
+                error: { code: -32603, message: error.message || 'Internal error' },
+            };
+        }
+    }
+    handleInitialize(req) {
+        const serverInfo = {
+            name: 'dinox-mcp-server',
+            version: getPackageVersion(),
+            protocolVersion: '2024-11-05',
+            capabilities: {
+                tools: true,
+                resources: false,
+            },
+        };
+        return { jsonrpc: '2.0', id: req.id, result: serverInfo };
+    }
+    handleToolsList(req) {
+        return { jsonrpc: '2.0', id: req.id, result: { tools: mcpTools } };
+    }
+    async handleToolsCall(req) {
+        if (!this.db) {
+            throw new Error('Database not initialized');
+        }
+        const name = req.params?.name;
+        const args = req.params?.arguments ?? {};
+        if (typeof name !== 'string') {
+            throw new Error('Invalid tools/call: missing tool name');
+        }
+        switch (name) {
+            case 'dinox_search_notes': {
+                const keyword = typeof args.query === 'string' ? args.query : '';
+                const tagsExpression = typeof args.tags === 'string' ? args.tags.trim() : '';
+                const { names: boxNames, matchEmpty: matchEmptyBoxes } = parseBoxFilter(args.box);
+                const zettelBoxIds = await resolveZettelBoxIdsForSearch(this.db, boxNames);
+                const daysInput = typeof args.days === 'number' ? String(args.days) : args.days;
+                const { createdAtFrom, createdAtTo } = parseCreatedAtRange({
+                    from: args.from,
+                    to: args.to,
+                    days: daysInput,
+                });
+                const limit = normalizeLimit(args.limit);
+                const rows = await searchNotes(this.db, keyword, {
+                    includeDeleted: false,
+                    tagsExpression: tagsExpression || undefined,
+                    createdAtFrom,
+                    createdAtTo,
+                    zettelBoxIds,
+                    matchEmptyZettelBoxes: matchEmptyBoxes,
+                });
+                const result = rows.slice(0, limit);
+                const text = JSON.stringify(result);
+                return {
+                    jsonrpc: '2.0',
+                    id: req.id,
+                    result: { content: [{ type: 'text', text }] },
+                };
+            }
+            case 'dinox_get_note': {
+                if (typeof args.id !== 'string' || !args.id.trim()) {
+                    throw new Error('dinox_get_note: id is required');
+                }
+                const notes = await getNoteDetails(this.db, [args.id.trim()]);
+                const text = JSON.stringify(notes[0] ?? null);
+                return {
+                    jsonrpc: '2.0',
+                    id: req.id,
+                    result: { content: [{ type: 'text', text }] },
+                };
+            }
+            case 'dinox_create_note': {
+                const title = typeof args.title === 'string' ? args.title.trim() : '';
+                const contentMd = typeof args.content === 'string' ? args.content : '';
+                if (!title) {
+                    throw new Error('dinox_create_note: title is required');
+                }
+                if (!contentMd) {
+                    throw new Error('dinox_create_note: content is required');
+                }
+                const rawConfig = await loadConfig();
+                const config = resolveConfig(rawConfig);
+                const identity = await resolveAuthIdentity(rawConfig, config);
+                const { contentJson, contentText } = convertMarkdownToNoteContent(contentMd);
+                const tags = await validateTagsForCreate(this.db, normalizeStringArray(args.tags));
+                const zettelBoxIds = await resolveZettelBoxIdsForCreate(this.db, normalizeStringArray(args.boxes));
+                const id = generateId();
+                await createNote(this.db, {
+                    id,
+                    title,
+                    noteType: 'crawl',
+                    contentMd,
+                    contentText,
+                    contentJson,
+                    tags,
+                    zettelBoxIds,
+                    userId: identity.userId,
+                });
+                const text = JSON.stringify({ id });
+                return {
+                    jsonrpc: '2.0',
+                    id: req.id,
+                    result: { content: [{ type: 'text', text }] },
+                };
+            }
+            case 'dinox_graph_backlinks': {
+                if (typeof args.id !== 'string' || !args.id.trim()) {
+                    throw new Error('dinox_graph_backlinks: id is required');
+                }
+                const result = await getBacklinks(this.db, args.id.trim());
+                const text = JSON.stringify(result);
+                return {
+                    jsonrpc: '2.0',
+                    id: req.id,
+                    result: { content: [{ type: 'text', text }] },
+                };
+            }
+            case 'dinox_graph_outlinks': {
+                if (typeof args.id !== 'string' || !args.id.trim()) {
+                    throw new Error('dinox_graph_outlinks: id is required');
+                }
+                const result = await getOutlinks(this.db, args.id.trim());
+                const text = JSON.stringify(result);
+                return {
+                    jsonrpc: '2.0',
+                    id: req.id,
+                    result: { content: [{ type: 'text', text }] },
+                };
+            }
+            case 'dinox_graph_related': {
+                if (typeof args.id !== 'string' || !args.id.trim()) {
+                    throw new Error('dinox_graph_related: id is required');
+                }
+                const depthRaw = typeof args.depth === 'number' && Number.isFinite(args.depth)
+                    ? Math.trunc(args.depth)
+                    : 2;
+                const depth = Math.min(Math.max(depthRaw, 1), 5);
+                const result = await getRelatedNotes(this.db, args.id.trim(), depth);
+                const text = JSON.stringify(result);
+                return {
+                    jsonrpc: '2.0',
+                    id: req.id,
+                    result: { content: [{ type: 'text', text }] },
+                };
+            }
+            case 'dinox_search_todos': {
+                const query = typeof args.query === 'string' ? args.query : '';
+                const status = typeof args.status === 'string' && ['all', 'completed', 'uncompleted'].includes(args.status)
+                    ? args.status
+                    : 'all';
+                const limit = normalizeLimit(args.limit);
+                const result = await searchTodoTasks(this.db, query, {
+                    includeDeleted: false,
+                    taskStatus: status || 'all',
+                    taskTagFilter: normalizeStringArray(args.tags),
+                    limit,
+                    scanLimit: 200,
+                });
+                const text = JSON.stringify(result);
+                return {
+                    jsonrpc: '2.0',
+                    id: req.id,
+                    result: { content: [{ type: 'text', text }] },
+                };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    async close() {
+        if (this.db) {
+            await this.db.close().catch(() => undefined);
+        }
+    }
+}
+export async function startMCPServer(port = 3000, host = '127.0.0.1', authToken) {
+    const mcpServer = new MCPServer();
+    await mcpServer.initialize();
+    const server = createServer(async (req, res) => {
+        if (req.method === 'POST') {
+            if (!isAuthorizedMCPRequest(req.headers, authToken)) {
+                res.writeHead(401, {
+                    'Content-Type': 'application/json',
+                    'WWW-Authenticate': 'Bearer realm="dinox-mcp"',
+                });
+                res.end(JSON.stringify({ error: 'Unauthorized' }));
+                return;
+            }
+            try {
+                const mcpReq = await readJsonBody(req);
+                const mcpRes = await mcpServer.handleRequest(mcpReq);
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(mcpRes));
+            }
+            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({ error: message }));
+            }
+        }
+        else {
+            res.writeHead(405);
+            res.end();
+        }
+    });
+    server.headersTimeout = 5_000;
+    server.requestTimeout = 10_000;
+    server.listen(port, host, () => {
+        console.log(`MCP server listening on http://${host}:${port}`);
+    });
+    return { server, mcpServer };
+}

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

@@ -0,0 +1,2 @@
+import type { MCPTool } from './types.js';
+export declare const mcpTools: MCPTool[];

package/dist/commands/mcp/tools.js

@@ -0,0 +1,90 @@
+export const mcpTools = [
+    {
+        name: 'dinox_search_notes',
+        description: 'Search notes by keyword, tags, date range, or SQL expression',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search keyword' },
+                tags: { type: 'string', description: 'Tag expression (AND/OR/NOT)' },
+                from: { type: 'string', description: 'Start date (YYYY-MM-DD)' },
+                to: { type: 'string', description: 'End date (YYYY-MM-DD)' },
+                days: { type: 'number', description: 'Recent N days' },
+                box: { type: 'string', description: 'Zettel box name' },
+                limit: { type: 'number', description: 'Max results (default: 50)' },
+            },
+        },
+    },
+    {
+        name: 'dinox_get_note',
+        description: 'Get note details by ID',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Note ID' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'dinox_create_note',
+        description: 'Create a new note',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                title: { type: 'string', description: 'Note title' },
+                content: { type: 'string', description: 'Markdown content' },
+                tags: { type: 'array', items: { type: 'string' }, description: 'Tags' },
+                boxes: { type: 'array', items: { type: 'string' }, description: 'Zettel boxes' },
+            },
+            required: ['title', 'content'],
+        },
+    },
+    {
+        name: 'dinox_graph_backlinks',
+        description: 'Get notes that link to this note',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Note ID' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'dinox_graph_outlinks',
+        description: 'Get notes that this note links to',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Note ID' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'dinox_graph_related',
+        description: 'Get related notes within N degrees',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Note ID' },
+                depth: { type: 'number', description: 'Degrees (1-5, default: 2)' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'dinox_search_todos',
+        description: 'Search todo tasks',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Task text query' },
+                status: { type: 'string', enum: ['all', 'completed', 'uncompleted'], description: 'Task status' },
+                tags: { type: 'array', items: { type: 'string' }, description: 'Task tags' },
+                limit: { type: 'number', description: 'Max results (default: 50)' },
+            },
+        },
+    },
+];

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

@@ -0,0 +1,24 @@
+export type MCPTool = {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: 'object';
+        properties: Record<string, any>;
+        required?: string[];
+    };
+};
+export type MCPResource = {
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+};
+export type MCPServerInfo = {
+    name: string;
+    version: string;
+    protocolVersion: string;
+    capabilities: {
+        tools?: boolean;
+        resources?: boolean;
+    };
+};

package/dist/commands/mcp/types.js

@@ -0,0 +1 @@
+export {};

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;