@dinoxx/dinox-cli 1.0.14 → 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/commands/notes/index.d.ts

@@ -1,2 +1,41 @@
 import { Command } from 'commander';
+import { type SearchedNote } from './repo.js';
+type NoteSearchResponse = {
+    meta: {
+        query: string;
+        returned_count: number;
+        total_count: number;
+        stale: boolean;
+        applied_filters: {
+            include_deleted: boolean;
+            tags_expression: string | null;
+            created_at_range: {
+                from: string | null;
+                to: string | null;
+            } | null;
+            days: number | null;
+            box_names: string[];
+            box_ids: string[];
+            match_empty_boxes: boolean;
+            sql_expression: string | null;
+        };
+    };
+    notes: SearchedNote[];
+};
+type BuildNoteSearchResponseInput = {
+    query: string;
+    notes: SearchedNote[];
+    stale: boolean;
+    includeDeleted: boolean;
+    tagsExpression?: string;
+    createdAtFrom?: string;
+    createdAtTo?: string;
+    days?: number;
+    boxNames: string[];
+    boxIds: string[];
+    matchEmptyBoxes: boolean;
+    sqlExpression?: string;
+};
+export declare function buildNoteSearchResponse(input: BuildNoteSearchResponseInput): NoteSearchResponse;
 export declare function registerNoteCommands(program: Command): void;
+export {};

package/dist/commands/notes/index.js

@@ -5,21 +5,12 @@ import { readStringOrFile } from '../../utils/argValue.js';
 import { generateId } from '../../utils/id.js';
 import { convertMarkdownToNoteContent } from '../../utils/tiptapMarkdown.js';
 import { printYaml } from '../../utils/output.js';
+import { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
 import { resolveAuthIdentity } from '../../auth/userInfo.js';
 import { connectPowerSync, waitForIdleDataFlow } from '../../powersync/runtime.js';
 import { syncNoteTokenIndex } from '../../powersync/tokenIndex.js';
 import { createNote, getNote, getNoteDetails, assertNotesUpdatable, resolveZettelBoxIdsForCreate, resolveZettelBoxIdsForSearch, resolveZettelBoxIdsForUpdate, searchNotes, softDeleteNote, updateNote, validateTagsForCreate, validateTagsForUpdate, } from './repo.js';
 import { parseCreatedAtRange } from './searchTime.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);
-}
 function parseNoteType(value) {
     const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
     if (normalized === 'note' || normalized === 'crawl') {
@@ -105,6 +96,50 @@ async function syncBeforeNoteCommand(db, offline, timeoutMs) {
     await waitForIdleDataFlow(db, Math.min(timeoutMs, 10_000));
     await syncNoteTokenIndex(db);
 }
+function normalizeDaysForMeta(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!/^\d+$/.test(trimmed)) {
+        return undefined;
+    }
+    const parsed = Number(trimmed);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return undefined;
+    }
+    return Math.trunc(parsed);
+}
+export function buildNoteSearchResponse(input) {
+    const query = input.query.trim();
+    const tagsExpression = input.tagsExpression?.trim() ?? '';
+    const sqlExpression = input.sqlExpression?.trim() ?? '';
+    const hasCreatedAtRange = Boolean(input.createdAtFrom || input.createdAtTo);
+    return {
+        meta: {
+            query,
+            returned_count: input.notes.length,
+            total_count: input.notes.length,
+            stale: input.stale,
+            applied_filters: {
+                include_deleted: input.includeDeleted,
+                tags_expression: tagsExpression || null,
+                created_at_range: hasCreatedAtRange
+                    ? {
+                        from: input.createdAtFrom ?? null,
+                        to: input.createdAtTo ?? null,
+                    }
+                    : null,
+                days: input.days ?? null,
+                box_names: [...input.boxNames],
+                box_ids: [...input.boxIds],
+                match_empty_boxes: input.matchEmptyBoxes,
+                sql_expression: sqlExpression || null,
+            },
+        },
+        notes: input.notes,
+    };
+}
 export function registerNoteCommands(program) {
     const note = program.command('note').description('Manage notes');
     note
@@ -123,7 +158,7 @@ export function registerNoteCommands(program) {
         const offline = Boolean(globals.offline);
         const config = resolveConfig(await loadConfig());
         const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
-        const { db } = await connectPowerSync({ config, offline, timeoutMs });
+        const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
         try {
             await syncBeforeNoteCommand(db, offline, timeoutMs);
             const keyword = query?.trim() ?? '';
@@ -148,7 +183,21 @@ export function registerNoteCommands(program) {
                 matchEmptyZettelBoxes: parsedBoxInput.isExplicitEmptyArray,
                 sqlExpression: sqlExpression || undefined,
             });
-            printYaml(rows);
+            const response = buildNoteSearchResponse({
+                query: keyword,
+                notes: rows,
+                stale: offline ? true : stale,
+                includeDeleted: Boolean(options.includeDeleted),
+                tagsExpression: tagsExpression || undefined,
+                createdAtFrom,
+                createdAtTo,
+                days: normalizeDaysForMeta(options.days),
+                boxNames: parsedBoxInput.values,
+                boxIds: zettelBoxIds,
+                matchEmptyBoxes: parsedBoxInput.isExplicitEmptyArray,
+                sqlExpression: sqlExpression || undefined,
+            });
+            printYaml(response);
         }
         finally {
             await db.close().catch(() => undefined);

package/dist/commands/prompt/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 { addPrompt, listPrompts } 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 syncBeforePromptCommand(db, offline, timeoutMs) {
     if (offline) {
         return;

package/dist/commands/sync.js

@@ -1,19 +1,9 @@
 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, getStatusSnapshot } from '../powersync/runtime.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);
-}
 export function registerSyncCommand(program) {
     program
         .command('sync')

package/dist/commands/tags/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 { addTag, listTags } 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 syncBeforeTagCommand(db, offline, timeoutMs) {
     if (offline) {
         return;