@mentagen/mcp 0.8.1 → 0.8.3

package/dist/client/bifrost.js

@@ -0,0 +1,197 @@
+import { randomUUID } from 'crypto';
+/**
+ * Lightweight HTTP client for Mentagen's Bifrost API.
+ *
+ * Uses the HTTP transport endpoint (/__h) to call server methods.
+ * Bifrost expects text/plain with a specific payload/context structure.
+ */
+export class MentagenClient {
+    baseUrl;
+    token;
+    constructor(config) {
+        this.baseUrl = config.mentagenUrl.replace(/\/$/, '');
+        this.token = config.token;
+    }
+    /**
+     * Call a Bifrost method via HTTP.
+     *
+     * Bifrost's HTTP transport expects:
+     * - Content-Type: text/plain
+     * - Body: JSON with { payload: { uuid, method, params }, context: { token } }
+     */
+    async call(method, params = {}) {
+        const url = `${this.baseUrl}/__h`;
+        const body = JSON.stringify({
+            payload: {
+                uuid: randomUUID(),
+                method,
+                params,
+            },
+            context: {
+                token: this.token,
+            },
+        });
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'text/plain',
+            },
+            body,
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`HTTP ${response.status}: ${text}`);
+        }
+        const data = (await response.json());
+        if (data.type === 'error' || data.error) {
+            const errorMsg = data.message ||
+                (typeof data.error === 'string' ? data.error : data.error?.message);
+            throw new Error(errorMsg || 'Unknown error');
+        }
+        return data.result;
+    }
+    /**
+     * Verify the token and get the current user.
+     */
+    async getCurrentUser() {
+        try {
+            return await this.call('user.current');
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * List boards the user has access to.
+     */
+    async listBoards(params) {
+        return this.call('boards.listSimple', {
+            orgId: params?.orgId,
+        });
+    }
+    /**
+     * Search boards by name.
+     */
+    async searchBoards(query, limit = 20) {
+        const result = await this.call('boards.search', {
+            query,
+            limit,
+        });
+        return result.data || [];
+    }
+    /**
+     * Search nodes using hybrid semantic/keyword search.
+     */
+    async searchNodes(params) {
+        return this.call('boards.searchNodesText', params);
+    }
+    /**
+     * List organizations the user has access to.
+     */
+    async listOrganizations() {
+        return this.call('org.list', {});
+    }
+    /**
+     * List teams within an organization.
+     */
+    async listTeams(params) {
+        return this.call('team.list', params);
+    }
+    /**
+     * Add a new node to a board.
+     */
+    async addNode(params) {
+        return this.call('boards.addNode', params);
+    }
+    /**
+     * Update a node's properties.
+     */
+    async updateNode(params) {
+        return this.call('boards.updateNode', params);
+    }
+    /**
+     * Get a single node by ID.
+     * Uses getNodeForMcp which excludes large fields (chat, textDetections, _vectors)
+     * in favor of their computed alternatives (chatConcatenated, textDetectionsConcatenated).
+     */
+    async getNode(params) {
+        return this.call('boards.getNodeForMcp', params);
+    }
+    /**
+     * List all nodes in a board (basic fields only).
+     */
+    async listNodes(params) {
+        return this.call('boards.listNodesSimple', params);
+    }
+    /**
+     * List all nodes with full content fields for extraction.
+     * Includes: content, code, chatConcatenated, textDetectionsConcatenated, pdfText, article
+     * Note: Uses computed fields instead of raw chat/textDetections.
+     */
+    async listNodesWithContent(params) {
+        return this.call('boards.listNodesWithContent', params);
+    }
+    /**
+     * Soft-delete a node.
+     */
+    async deleteNode(params) {
+        await this.call('boards.deleteNode', params);
+    }
+    /**
+     * Create a new board.
+     */
+    async createBoard(params) {
+        return this.call('boards.create', params);
+    }
+    /**
+     * Get a single board by ID.
+     */
+    async getBoard(params) {
+        return this.call('boards.get', params);
+    }
+    /**
+     * Update a board's properties.
+     */
+    async updateBoard(params) {
+        return this.call('boards.update', params);
+    }
+    /**
+     * Soft-delete a board.
+     */
+    async deleteBoard(params) {
+        await this.call('boards.deleteBoard', params);
+    }
+    /**
+     * Add an edge between two nodes.
+     */
+    async addEdge(params) {
+        return this.call('boards.addEdge', params);
+    }
+    /**
+     * List all edges in a board.
+     */
+    async listEdges(params) {
+        return this.call('boards.listEdgesSimple', params);
+    }
+    /**
+     * Update an edge's metadata (direction and/or label).
+     */
+    async updateEdge(params) {
+        return this.call('boards.updateEdgeMetadata', params);
+    }
+    /**
+     * Soft-delete an edge.
+     */
+    async deleteEdge(params) {
+        await this.call('boards.deleteEdge', params);
+    }
+}
+export async function createMentagenClient(config) {
+    const client = new MentagenClient(config);
+    const user = await client.getCurrentUser();
+    if (!user) {
+        throw new Error('Authentication failed. Please check your MENTAGEN_TOKEN.\n' +
+            'Generate a new token in Mentagen Settings > Developer if needed.');
+    }
+    return client;
+}

package/dist/client/types.js

@@ -8,7 +8,6 @@ export const EdgeDirection = {
     Target: 'target',
 };
 export const NodeType = {
-    Text: 'text',
     Markdown: 'markdown',
     Code: 'code',
     Image: 'image',
@@ -22,6 +21,5 @@ export const NodeType = {
     AIChat: 'ai-chat',
     AIQuiz: 'ai-quiz',
     File: 'file',
-    Excalidraw: 'excalidraw',
     Teleprompter: 'teleprompter',
 };

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { createMentagenClient } from './client/helene.js';
+import { createMentagenClient } from './client/bifrost.js';
 import { registerPrompts } from './prompts/index.js';
 import { registerResources } from './resources/index.js';
 import { registerTools } from './tools/index.js';

package/dist/tools/create.js

@@ -25,7 +25,6 @@ const DEFAULT_NODE_COLORS = {
     board: 'fuchsia',
     mermaid: 'violet',
     voice: undefined,
-    excalidraw: 'teal',
     teleprompter: 'rose',
 };
 const DEFAULT_CODE_EXTENSION = '.js';

package/dist/tools/size-calc.js

@@ -27,7 +27,6 @@ const NODE_TYPES_WITH_ICONS = new Set([
     'code',
     'markdown',
     'teleprompter',
-    'excalidraw',
     'url',
     'voice',
     'audio',

package/dist/tools/update.js

@@ -7,10 +7,8 @@ import { calculateNodeSize } from './size-calc.js';
 /**
  * Node types that can be converted between safely.
  * These are text-based types where content can be migrated without data loss.
- * Note: text nodes are accepted for conversion (legacy) but MCP only creates markdown.
  */
 const CONVERTIBLE_TYPES = [
-    NodeType.Text,
     NodeType.Markdown,
     NodeType.Code,
     NodeType.URL,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentagen/mcp",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "description": "MCP server for Mentagen knowledge base integration with Cursor",
   "type": "module",
   "bin": "dist/index.js",
@@ -45,6 +45,6 @@
     "node": ">=18"
   },
   "resolutions": {
-    "tar": "^7.5.4"
+    "tar": "^7.5.7"
   }
 }