roam-research-mcp 0.25.7 → 0.30.1

package/build/config/environment.js

@@ -41,4 +41,6 @@ if (!API_TOKEN || !GRAPH_NAME) {
         '   ROAM_API_TOKEN=your-api-token\n' +
         '   ROAM_GRAPH_NAME=your-graph-name');
 }
-export { API_TOKEN, GRAPH_NAME };
+const HTTP_STREAM_PORT = process.env.HTTP_STREAM_PORT || '8088'; // Default to 8080
+const SSE_PORT = process.env.SSE_PORT || '8087'; // Default to 8087
+export { API_TOKEN, GRAPH_NAME, HTTP_STREAM_PORT, SSE_PORT };

package/build/markdown-utils.js

@@ -284,7 +284,8 @@ function convertToRoamActions(nodes, parentUid, order = 'last') {
                 block: {
                     uid: block.uid,
                     string: block.content,
-                    ...(block.heading_level && { heading: block.heading_level })
+                    ...(block.heading_level && { heading: block.heading_level }),
+                    ...(block.children_view_type && { 'children-view-type': block.children_view_type })
                 }
             };
             actions.push(action);

package/build/server/roam-server.js

@@ -1,13 +1,17 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
 import { initializeGraph } from '@roam-research/roam-api-sdk';
-import { API_TOKEN, GRAPH_NAME } from '../config/environment.js';
+import { API_TOKEN, GRAPH_NAME, HTTP_STREAM_PORT, SSE_PORT } from '../config/environment.js';
 import { toolSchemas } from '../tools/schemas.js';
 import { ToolHandlers } from '../tools/tool-handlers.js';
 import { readFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
+import { createServer } from 'node:http';
 import { fileURLToPath } from 'node:url';
+import { findAvailablePort } from '../utils/net.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Read package.json to get the version
@@ -37,38 +41,15 @@ export class RoamServer {
         if (Object.keys(toolSchemas).length === 0) {
             throw new McpError(ErrorCode.InternalError, 'No tool schemas defined in src/tools/schemas.ts');
         }
-        this.server = new Server({
-            name: 'roam-research',
-            version: serverVersion, // Use the version from package.json
-        }, {
-            capabilities: {
-                tools: {
-                    ...Object.fromEntries(Object.keys(toolSchemas).map((toolName) => [toolName, {}])),
-                },
-            },
-        });
-        this.setupRequestHandlers();
-        // Error handling
-        this.server.onerror = (error) => {
-            // Re-throw as McpError to be caught by the MCP client
-            if (error instanceof McpError) {
-                throw error;
-            }
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new McpError(ErrorCode.InternalError, `MCP server internal error: ${errorMessage}`);
-        };
-        process.on('SIGINT', async () => {
-            await this.server.close();
-            process.exit(0);
-        });
     }
-    setupRequestHandlers() {
+    // Refactored to accept a Server instance
+    setupRequestHandlers(mcpServer) {
         // List available tools
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        mcpServer.setRequestHandler(ListToolsRequestSchema, async () => ({
             tools: Object.values(toolSchemas),
         }));
         // Handle tool calls
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        mcpServer.setRequestHandler(CallToolRequestSchema, async (request) => {
             try {
                 switch (request.params.name) {
                     case 'roam_remember': {
@@ -92,13 +73,6 @@ export class RoamServer {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
-                    case 'roam_create_block': {
-                        const { content, page_uid, title, heading } = request.params.arguments;
-                        const result = await this.toolHandlers.createBlock(content, page_uid, title, heading);
-                        return {
-                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                        };
-                    }
                     case 'roam_import_markdown': {
                         const { content, page_uid, page_title, parent_uid, parent_string, order = 'first' } = request.params.arguments;
                         const result = await this.toolHandlers.importMarkdown(content, page_uid, page_title, parent_uid, parent_string, order);
@@ -173,27 +147,6 @@ export class RoamServer {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
-                    case 'roam_update_block': {
-                        const { block_uid, content, transform_pattern } = request.params.arguments;
-                        // Validate that either content or transform_pattern is provided, but not both or neither
-                        if ((!content && !transform_pattern) || (content && transform_pattern)) {
-                            throw new McpError(ErrorCode.InvalidRequest, 'Either content or transform_pattern must be provided, but not both or neither');
-                        }
-                        let result;
-                        if (content) {
-                            result = await this.toolHandlers.updateBlock(block_uid, content);
-                        }
-                        else {
-                            // We know transform_pattern exists due to validation above
-                            result = await this.toolHandlers.updateBlock(block_uid, undefined, (currentContent) => {
-                                const regex = new RegExp(transform_pattern.find, transform_pattern.global !== false ? 'g' : '');
-                                return currentContent.replace(regex, transform_pattern.replace);
-                            });
-                        }
-                        return {
-                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                        };
-                    }
                     case 'roam_recall': {
                         const { sort_by = 'newest', filter_tag } = request.params.arguments;
                         const result = await this.toolHandlers.recall(sort_by, filter_tag);
@@ -201,22 +154,16 @@ export class RoamServer {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
-                    case 'roam_update_multiple_blocks': {
-                        const { updates } = request.params.arguments;
-                        // Validate that for each update, either content or transform is provided, but not both or neither
-                        for (const update of updates) {
-                            if ((!update.content && !update.transform) || (update.content && update.transform)) {
-                                throw new McpError(ErrorCode.InvalidRequest, 'For each update, either content or transform must be provided, but not both or neither');
-                            }
-                        }
-                        const result = await this.toolHandlers.updateBlocks(updates);
+                    case 'roam_datomic_query': {
+                        const { query, inputs } = request.params.arguments;
+                        const result = await this.toolHandlers.executeDatomicQuery({ query, inputs });
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
-                    case 'roam_datomic_query': {
-                        const { query, inputs } = request.params.arguments;
-                        const result = await this.toolHandlers.executeDatomicQuery({ query, inputs });
+                    case 'roam_process_batch_actions': {
+                        const { actions } = request.params.arguments;
+                        const result = await this.toolHandlers.processBatch(actions);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
@@ -236,8 +183,113 @@ export class RoamServer {
     }
     async run() {
         try {
-            const transport = new StdioServerTransport();
-            await this.server.connect(transport);
+            const stdioMcpServer = new Server({
+                name: 'roam-research',
+                version: serverVersion,
+            }, {
+                capabilities: {
+                    tools: {
+                        ...Object.fromEntries(Object.keys(toolSchemas).map((toolName) => [toolName, {}])),
+                    },
+                },
+            });
+            this.setupRequestHandlers(stdioMcpServer);
+            const stdioTransport = new StdioServerTransport();
+            await stdioMcpServer.connect(stdioTransport);
+            const httpMcpServer = new Server({
+                name: 'roam-research-http', // A distinct name for the HTTP server
+                version: serverVersion,
+            }, {
+                capabilities: {
+                    tools: {
+                        ...Object.fromEntries(Object.keys(toolSchemas).map((toolName) => [toolName, {}])),
+                    },
+                },
+            });
+            this.setupRequestHandlers(httpMcpServer);
+            const httpStreamTransport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: () => Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15),
+            });
+            await httpMcpServer.connect(httpStreamTransport);
+            const httpServer = createServer(async (req, res) => {
+                try {
+                    await httpStreamTransport.handleRequest(req, res);
+                }
+                catch (error) {
+                    // console.error('HTTP Stream Server error:', error);
+                    if (!res.headersSent) {
+                        res.writeHead(500, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'Internal Server Error' }));
+                    }
+                }
+            });
+            const availableHttpPort = await findAvailablePort(parseInt(HTTP_STREAM_PORT));
+            httpServer.listen(availableHttpPort, () => {
+                // console.log(`MCP Roam Research server running HTTP Stream on port ${availableHttpPort}`);
+            });
+            // SSE Server setup
+            const sseMcpServer = new Server({
+                name: 'roam-research-sse', // Distinct name for SSE server
+                version: serverVersion,
+            }, {
+                capabilities: {
+                    tools: {
+                        ...Object.fromEntries(Object.keys(toolSchemas).map((toolName) => [toolName, {}])),
+                    },
+                },
+            });
+            this.setupRequestHandlers(sseMcpServer);
+            const sseHttpServer = createServer(async (req, res) => {
+                const parseBody = (request) => {
+                    return new Promise((resolve, reject) => {
+                        let body = '';
+                        request.on('data', (chunk) => {
+                            body += chunk.toString();
+                        });
+                        request.on('end', () => {
+                            try {
+                                resolve(body ? JSON.parse(body) : {});
+                            }
+                            catch (error) {
+                                reject(error);
+                            }
+                        });
+                        request.on('error', reject);
+                    });
+                };
+                try {
+                    if (req.url === '/sse') {
+                        const sseTransport = new SSEServerTransport('/sse', res);
+                        await sseMcpServer.connect(sseTransport);
+                        if (req.method === 'GET') {
+                            await sseTransport.start();
+                        }
+                        else if (req.method === 'POST') {
+                            const parsedBody = await parseBody(req);
+                            await sseTransport.handlePostMessage(req, res, parsedBody);
+                        }
+                        else {
+                            res.writeHead(405, { 'Content-Type': 'text/plain' });
+                            res.end('Method Not Allowed');
+                        }
+                    }
+                    else {
+                        res.writeHead(404, { 'Content-Type': 'text/plain' });
+                        res.end('Not Found');
+                    }
+                }
+                catch (error) {
+                    // console.error('SSE HTTP Server error:', error);
+                    if (!res.headersSent) {
+                        res.writeHead(500, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'Internal Server Error' }));
+                    }
+                }
+            });
+            const availableSsePort = await findAvailablePort(parseInt(SSE_PORT));
+            sseHttpServer.listen(availableSsePort, () => {
+                // console.log(`MCP Roam Research server running SSE on port ${availableSsePort}`);
+            });
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);

package/build/tools/operations/batch.js

@@ -0,0 +1,37 @@
+import { batchActions as roamBatchActions } from '@roam-research/roam-api-sdk';
+export class BatchOperations {
+    constructor(graph) {
+        this.graph = graph;
+    }
+    async processBatch(actions) {
+        const batchActions = actions.map(action => {
+            const { action: actionType, ...rest } = action;
+            const roamAction = { action: actionType };
+            if (rest.location) {
+                roamAction.location = {
+                    'parent-uid': rest.location['parent-uid'],
+                    order: rest.location.order,
+                };
+            }
+            const block = {};
+            if (rest.string)
+                block.string = rest.string;
+            if (rest.uid)
+                block.uid = rest.uid;
+            if (rest.open !== undefined)
+                block.open = rest.open;
+            if (rest.heading !== undefined && rest.heading !== null && rest.heading !== 0) {
+                block.heading = rest.heading;
+            }
+            if (rest['text-align'])
+                block['text-align'] = rest['text-align'];
+            if (rest['children-view-type'])
+                block['children-view-type'] = rest['children-view-type'];
+            if (Object.keys(block).length > 0) {
+                roamAction.block = block;
+            }
+            return roamAction;
+        });
+        return await roamBatchActions(this.graph, { actions: batchActions });
+    }
+}

package/build/tools/operations/memory.js

@@ -1,4 +1,4 @@
-import { q, createBlock, createPage } from '@roam-research/roam-api-sdk';
+import { q, createPage, batchActions } from '@roam-research/roam-api-sdk';
 import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
 import { formatRoamDate } from '../../utils/helpers.js';
 import { resolveRefs } from '../helpers/refs.js';
@@ -49,18 +49,27 @@ export class MemoryOperations {
         }).join(' ') || '';
         // Create block with memory, memories tag, and optional categories
         const blockContent = `${memoriesTag} ${memory} ${categoryTags}`.trim();
-        try {
-            await createBlock(this.graph, {
+        const actions = [{
                 action: 'create-block',
                 location: {
-                    "parent-uid": pageUid,
-                    "order": "last"
+                    'parent-uid': pageUid,
+                    order: 'last'
                 },
-                block: { string: blockContent }
+                block: {
+                    string: blockContent
+                }
+            }];
+        try {
+            const result = await batchActions(this.graph, {
+                action: 'batch-actions',
+                actions
             });
+            if (!result) {
+                throw new McpError(ErrorCode.InternalError, 'Failed to create memory block via batch action');
+            }
         }
         catch (error) {
-            throw new McpError(ErrorCode.InternalError, 'Failed to create memory block');
+            throw new McpError(ErrorCode.InternalError, `Failed to create memory block: ${error instanceof Error ? error.message : String(error)}`);
         }
         return { success: true };
     }

package/build/tools/operations/outline.js

@@ -1,4 +1,4 @@
-import { q, createPage, createBlock, batchActions } from '@roam-research/roam-api-sdk';
+import { q, createPage, batchActions } from '@roam-research/roam-api-sdk';
 import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
 import { formatRoamDate } from '../../utils/helpers.js';
 import { capitalizeWords } from '../helpers/text.js';
@@ -138,15 +138,21 @@ export class OutlineOperations {
                 }
                 for (let retry = 0; retry < maxRetries; retry++) {
                     console.log(`Attempt ${retry + 1}/${maxRetries} to create block "${content}" under "${parentUid}"`);
-                    // Create block
-                    const success = await createBlock(this.graph, {
-                        action: 'create-block',
-                        location: {
-                            'parent-uid': parentUid,
-                            order: 'last'
-                        },
-                        block: { string: content }
+                    // Create block using batchActions
+                    const batchResult = await batchActions(this.graph, {
+                        action: 'batch-actions',
+                        actions: [{
+                                action: 'create-block',
+                                location: {
+                                    'parent-uid': parentUid,
+                                    order: 'last'
+                                },
+                                block: { string: content }
+                            }]
                     });
+                    if (!batchResult) {
+                        throw new McpError(ErrorCode.InternalError, `Failed to create block "${content}" via batch action`);
+                    }
                     // Wait with exponential backoff
                     const delay = initialDelay * Math.pow(2, retry);
                     await new Promise(resolve => setTimeout(resolve, delay));
@@ -232,7 +238,13 @@ export class OutlineOperations {
             // Convert to Roam markdown format
             const convertedContent = convertToRoamMarkdown(markdownContent);
             // Parse markdown into hierarchical structure
-            const nodes = parseMarkdown(convertedContent);
+            // We pass the original OutlineItem properties (heading, children_view_type)
+            // along with the parsed content to the nodes.
+            const nodes = parseMarkdown(convertedContent).map((node, index) => ({
+                ...node,
+                ...(validOutline[index].heading && { heading_level: validOutline[index].heading }),
+                ...(validOutline[index].children_view_type && { children_view_type: validOutline[index].children_view_type })
+            }));
             // Convert nodes to batch actions
             const actions = convertToRoamActions(nodes, targetParentUid, 'first');
             if (actions.length === 0) {
@@ -350,19 +362,26 @@ export class OutlineOperations {
             };
         }
         else {
-            // Create a simple block for non-nested content
-            try {
-                await createBlock(this.graph, {
+            // Create a simple block for non-nested content using batchActions
+            const actions = [{
                     action: 'create-block',
                     location: {
                         "parent-uid": targetParentUid,
                         order
                     },
                     block: { string: content }
+                }];
+            try {
+                const result = await batchActions(this.graph, {
+                    action: 'batch-actions',
+                    actions
                 });
+                if (!result) {
+                    throw new McpError(ErrorCode.InternalError, 'Failed to create content block via batch action');
+                }
             }
             catch (error) {
-                throw new McpError(ErrorCode.InternalError, 'Failed to create content block');
+                throw new McpError(ErrorCode.InternalError, `Failed to create content block: ${error instanceof Error ? error.message : String(error)}`);
             }
             return {
                 success: true,

package/build/tools/operations/todos.js

@@ -1,4 +1,4 @@
-import { q, createBlock, createPage, batchActions } from '@roam-research/roam-api-sdk';
+import { q, createPage, batchActions } from '@roam-research/roam-api-sdk';
 import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
 import { formatRoamDate } from '../../utils/helpers.js';
 export class TodoOperations {
@@ -37,44 +37,23 @@ export class TodoOperations {
                 throw new Error('Failed to create today\'s page');
             }
         }
-        // If more than 10 todos, use batch actions
         const todo_tag = "{{TODO}}";
-        if (todos.length > 10) {
-            const actions = todos.map((todo, index) => ({
-                action: 'create-block',
-                location: {
-                    'parent-uid': targetPageUid,
-                    order: index
-                },
-                block: {
-                    string: `${todo_tag} ${todo}`
-                }
-            }));
-            const result = await batchActions(this.graph, {
-                action: 'batch-actions',
-                actions
-            });
-            if (!result) {
-                throw new Error('Failed to create todo blocks');
-            }
-        }
-        else {
-            // Create todos sequentially
-            for (const todo of todos) {
-                try {
-                    await createBlock(this.graph, {
-                        action: 'create-block',
-                        location: {
-                            "parent-uid": targetPageUid,
-                            "order": "last"
-                        },
-                        block: { string: `${todo_tag} ${todo}` }
-                    });
-                }
-                catch (error) {
-                    throw new Error('Failed to create todo block');
-                }
+        const actions = todos.map((todo, index) => ({
+            action: 'create-block',
+            location: {
+                'parent-uid': targetPageUid,
+                order: index
+            },
+            block: {
+                string: `${todo_tag} ${todo}`
             }
+        }));
+        const result = await batchActions(this.graph, {
+            action: 'batch-actions',
+            actions
+        });
+        if (!result) {
+            throw new Error('Failed to create todo blocks');
         }
         return { success: true };
     }