@dinoxx/dinox-cli 1.0.22 → 1.1.1

package/dist/commands/mcp/server.js

@@ -1,424 +0,0 @@
-import { createServer } from 'node:http';
-import { DEFAULT_MCP_PORT } from './types.js';
-import { mcpTools } from './tools.js';
-import { isAuthorizedMCPRequest } from './auth.js';
-import { NOTE_CONTENT_EDIT_TOOL_NAME, NOTE_CONTENT_READ_TOOL_NAME, NoteContentMcpService, buildNoteContentToolError, } from './noteContentTools.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 { canonicalizeBidlinksInMarkdown } from '../../utils/bidlinkCanonicalization.js';
-import { parseCreatedAtRange } from '../notes/searchTime.js';
-import { parseNoteSearchFields, projectNoteSearchFields } from '../notes/searchOutput.js';
-import { createNote, getNoteDetails, resolveZettelBoxIdsForCreate, resolveZettelBoxIdsForSearch, searchNotes, validateTagsForCreate, } from '../notes/repo.js';
-import { getBacklinks, getGraphStats, 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 { printHumanReadableLine } from '../../utils/output.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 normalizeOffset(value) {
-    if (value === undefined || value === null) {
-        return 0;
-    }
-    const raw = typeof value === 'number'
-        ? value
-        : typeof value === 'string'
-            ? Number(value)
-            : NaN;
-    if (!Number.isFinite(raw)) {
-        return 0;
-    }
-    const int = Math.trunc(raw);
-    if (int < 0) {
-        return 0;
-    }
-    return int;
-}
-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 };
-}
-function isJsonRpcId(value) {
-    return value === null || typeof value === 'string' || typeof value === 'number';
-}
-function parseMCPRequest(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        throw new Error('Invalid JSON-RPC request');
-    }
-    const record = value;
-    if (record.jsonrpc !== '2.0') {
-        throw new Error('Invalid JSON-RPC request: jsonrpc must be "2.0"');
-    }
-    if (typeof record.method !== 'string' || !record.method.trim()) {
-        throw new Error('Invalid JSON-RPC request: method is required');
-    }
-    if (record.id !== undefined && !isJsonRpcId(record.id)) {
-        throw new Error('Invalid JSON-RPC request: id must be a string, number, or null');
-    }
-    return {
-        jsonrpc: '2.0',
-        id: record.id,
-        method: record.method.trim(),
-        params: record.params,
-    };
-}
-function hasRequestId(req) {
-    return req.id !== undefined;
-}
-function buildResponse(req, payload) {
-    return {
-        jsonrpc: '2.0',
-        id: req.id ?? null,
-        ...payload,
-    };
-}
-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;
-    noteContent = new NoteContentMcpService(() => this.requireDb());
-    async initialize() {
-        const config = resolveConfig(await loadConfig());
-        const { db } = await connectPowerSync({ config, offline: false, timeoutMs: config.sync.timeoutMs });
-        this.db = db;
-    }
-    async handleRequest(req) {
-        if (req.method === 'notifications/initialized') {
-            return hasRequestId(req) ? buildResponse(req, { result: {} }) : null;
-        }
-        const shouldRespond = hasRequestId(req);
-        try {
-            switch (req.method) {
-                case 'initialize':
-                    if (!shouldRespond) {
-                        return null;
-                    }
-                    return this.handleInitialize(req);
-                case 'tools/list':
-                    if (!shouldRespond) {
-                        return null;
-                    }
-                    return this.handleToolsList(req);
-                case 'tools/call':
-                    if (!shouldRespond) {
-                        await this.handleToolsCall(req);
-                        return null;
-                    }
-                    return await this.handleToolsCall(req);
-                default:
-                    if (!shouldRespond) {
-                        return null;
-                    }
-                    return buildResponse(req, {
-                        error: { code: -32601, message: 'Method not found' },
-                    });
-            }
-        }
-        catch (error) {
-            if (!shouldRespond) {
-                return null;
-            }
-            return buildResponse(req, {
-                error: { code: -32603, message: error.message || 'Internal error' },
-            });
-        }
-    }
-    handleInitialize(req) {
-        const result = {
-            protocolVersion: '2024-11-05',
-            capabilities: {
-                tools: {},
-            },
-            serverInfo: {
-                name: 'dinox-mcp-server',
-                version: getPackageVersion(),
-            },
-        };
-        return buildResponse(req, { result });
-    }
-    handleToolsList(req) {
-        return buildResponse(req, { result: { tools: mcpTools } });
-    }
-    async handleToolsCall(req) {
-        const db = this.requireDb();
-        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 rawBoxes = args.boxes ?? args.box;
-                const { names: boxNames, matchEmpty: matchEmptyBoxes } = parseBoxFilter(rawBoxes);
-                const zettelBoxIds = await resolveZettelBoxIdsForSearch(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 offset = normalizeOffset(args.offset);
-                const fields = parseNoteSearchFields(args.fields, 'dinox_search_notes.fields');
-                const rows = await searchNotes(db, keyword, {
-                    includeDeleted: false,
-                    tagsExpression: tagsExpression || undefined,
-                    createdAtFrom,
-                    createdAtTo,
-                    zettelBoxIds,
-                    matchEmptyZettelBoxes: matchEmptyBoxes,
-                });
-                const totalCount = rows.length;
-                const paged = rows.slice(offset, offset + limit);
-                const result = projectNoteSearchFields(paged, fields);
-                const text = JSON.stringify({
-                    meta: {
-                        total_count: totalCount,
-                        returned_count: result.length,
-                        limit,
-                        offset,
-                        has_more: offset + result.length < totalCount,
-                        fields: fields ?? null,
-                    },
-                    notes: result,
-                });
-                return buildResponse(req, { 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(db, [args.id.trim()]);
-                const text = JSON.stringify(notes[0] ?? null);
-                return buildResponse(req, { 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 canonicalContentMd = await canonicalizeBidlinksInMarkdown(db, contentMd, identity.userId);
-                const { contentJson, contentText } = convertMarkdownToNoteContent(canonicalContentMd);
-                const tags = await validateTagsForCreate(db, normalizeStringArray(args.tags));
-                const zettelBoxIds = await resolveZettelBoxIdsForCreate(db, normalizeStringArray(args.boxes));
-                const id = generateId();
-                await createNote(db, {
-                    id,
-                    title,
-                    noteType: 'crawl',
-                    contentMd: canonicalContentMd,
-                    contentText,
-                    contentJson,
-                    tags,
-                    zettelBoxIds,
-                    userId: identity.userId,
-                });
-                const text = JSON.stringify({ id });
-                return buildResponse(req, { 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(db, args.id.trim());
-                const text = JSON.stringify(result);
-                return buildResponse(req, { 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(db, args.id.trim());
-                const text = JSON.stringify(result);
-                return buildResponse(req, { 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(db, args.id.trim(), depth);
-                const text = JSON.stringify(result);
-                return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
-            }
-            case 'dinox_graph_stats': {
-                const result = await getGraphStats(db);
-                const text = JSON.stringify(result);
-                return buildResponse(req, { 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(db, query, {
-                    includeDeleted: false,
-                    taskStatus: status || 'all',
-                    taskTagFilter: normalizeStringArray(args.tags),
-                    limit,
-                    scanLimit: 200,
-                });
-                const text = JSON.stringify(result);
-                return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
-            }
-            case NOTE_CONTENT_READ_TOOL_NAME: {
-                const runtime = await this.getRuntime();
-                const result = await this.noteContent.read(args, runtime).catch((error) => buildNoteContentToolError(error));
-                const text = JSON.stringify(result);
-                return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
-            }
-            case NOTE_CONTENT_EDIT_TOOL_NAME: {
-                const runtime = await this.getRuntime();
-                const operations = Array.isArray(args.operations) ? args.operations : [];
-                const result = await this.noteContent.edit({
-                    readToken: args.readToken,
-                    operations,
-                }, runtime).catch((error) => buildNoteContentToolError(error, operations));
-                const text = JSON.stringify(result);
-                return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
-            }
-            default:
-                throw new Error(`Unknown tool: ${name}`);
-        }
-    }
-    requireDb() {
-        if (!this.db) {
-            throw new Error('Database not initialized');
-        }
-        return this.db;
-    }
-    async getRuntime() {
-        const rawConfig = await loadConfig();
-        const config = resolveConfig(rawConfig);
-        const identity = await resolveAuthIdentity(rawConfig, config);
-        return { userId: identity.userId };
-    }
-    async close() {
-        if (this.db) {
-            await this.db.close().catch(() => undefined);
-        }
-    }
-}
-export async function startMCPServer(port = DEFAULT_MCP_PORT, 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 body = await readJsonBody(req);
-                const mcpReq = parseMCPRequest(body);
-                const mcpRes = await mcpServer.handleRequest(mcpReq);
-                if (!mcpRes) {
-                    res.writeHead(204);
-                    res.end();
-                    return;
-                }
-                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, () => {
-        printHumanReadableLine(`MCP server listening on http://${host}:${port}`);
-    });
-    return { server, mcpServer };
-}

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

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

package/dist/commands/mcp/tools.js

@@ -1,32 +0,0 @@
-import { listMcpCommandSchemas } from '../schema/spec.js';
-import { noteContentMcpTools } from './noteContentTools.js';
-function toMcpProperty(property) {
-    if (property.type === 'string[]') {
-        return {
-            type: 'array',
-            items: { type: 'string' },
-            ...(property.description ? { description: property.description } : {}),
-            ...(property.enum ? { enum: property.enum } : {}),
-        };
-    }
-    return {
-        type: property.type,
-        ...(property.description ? { description: property.description } : {}),
-        ...(property.enum ? { enum: property.enum } : {}),
-    };
-}
-const schemaBackedMcpTools = listMcpCommandSchemas().map((schema) => {
-    const mcp = schema.mcp;
-    const properties = Object.fromEntries(mcp.properties.map((property) => [property.name, toMcpProperty(property)]));
-    const required = mcp.properties.filter((property) => property.required).map((property) => property.name);
-    return {
-        name: mcp.toolName,
-        description: mcp.description,
-        inputSchema: {
-            type: 'object',
-            properties,
-            ...(required.length > 0 ? { required } : {}),
-        },
-    };
-});
-export const mcpTools = [...schemaBackedMcpTools, ...noteContentMcpTools];

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

@@ -1,39 +0,0 @@
-export type MCPTool = {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: 'object';
-        properties: Record<string, {
-            type: 'string' | 'number' | 'boolean' | 'array' | 'object';
-            description?: string;
-            enum?: string[];
-            items?: {
-                type: 'string' | 'object';
-            };
-            properties?: Record<string, {
-                type: 'string' | 'number' | 'boolean' | 'array' | 'object';
-                description?: string;
-            }>;
-        }>;
-        required?: string[];
-    };
-};
-export type MCPResource = {
-    uri: string;
-    name: string;
-    description?: string;
-    mimeType?: string;
-};
-export type MCPServerInfo = {
-    name: string;
-    version: string;
-};
-export type MCPInitializeResult = {
-    protocolVersion: string;
-    capabilities: {
-        tools?: Record<string, never>;
-        resources?: Record<string, never>;
-    };
-    serverInfo: MCPServerInfo;
-};
-export declare const DEFAULT_MCP_PORT = 45137;

package/dist/commands/mcp/types.js

@@ -1 +0,0 @@
-export const DEFAULT_MCP_PORT = 45137;