secondbrainos-mcp-server 1.2.6 → 1.4.0

package/build/index.js

@@ -5,6 +5,9 @@ import { OpenApi, HttpLlm } from "@samchon/openapi";
 import axios from "axios";
 import dotenv from "dotenv";
 import yaml from 'js-yaml';
+import fs from 'fs';
+import path from 'path';
+import { homedir } from 'os';
 dotenv.config();
 function toSnakeCase(str) {
     return str
@@ -43,6 +46,7 @@ class SecondBrainOSServer {
         // Discover service paths from the OpenAPI schema
         this.runPromptChainPath = null;
         this.getAIAgentsSchemaPath = null;
+        this.generateUploadURLPath = null;
         if (initialSchema.paths) {
             for (const [path, pathItem] of Object.entries(initialSchema.paths)) {
                 for (const operation of Object.values(pathItem)) {
@@ -52,8 +56,11 @@ class SecondBrainOSServer {
                     if (operation.operationId === 'getAIAgentsSchema') {
                         this.getAIAgentsSchemaPath = path;
                     }
+                    if (operation.operationId === 'generateFileUploadGoogleCloudStorageURL') {
+                        this.generateUploadURLPath = path;
+                    }
                 }
-                if (this.runPromptChainPath && this.getAIAgentsSchemaPath)
+                if (this.runPromptChainPath && this.getAIAgentsSchemaPath && this.generateUploadURLPath)
                     break;
             }
         }
@@ -131,6 +138,8 @@ class SecondBrainOSServer {
                 throw new McpError(ErrorCode.MethodNotFound, `Unknown function: ${request.params.name}`);
             }
             try {
+                // Intercept file_path arguments: upload local files to GCS
+                const processedArgs = await this.interceptFilePathArgs((request.params.arguments || {}));
                 // Use HttpLlm.execute for better error handling and type safety
                 const result = await HttpLlm.execute({
                     connection: {
@@ -141,7 +150,7 @@ class SecondBrainOSServer {
                     },
                     application: this.application, // Type assertion to avoid generic issues
                     function: func,
-                    input: request.params.arguments || {}
+                    input: processedArgs
                 });
                 return {
                     content: [{
@@ -456,6 +465,71 @@ class SecondBrainOSServer {
         });
         return response.data;
     }
+    /**
+     * Scans tool arguments for file_path parameters containing local paths,
+     * uploads those files to GCS via signed URL, and replaces the values with GCS paths.
+     * - https:// paths are passed through
+     * - http:// paths are rejected
+     * - Everything else is treated as a local file path
+     */
+    async interceptFilePathArgs(args) {
+        const result = { ...args };
+        for (const [key, value] of Object.entries(result)) {
+            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                result[key] = await this.interceptFilePathArgs(value);
+                continue;
+            }
+            if (typeof value !== 'string' || !key.toLowerCase().includes('file_path')) {
+                continue;
+            }
+            const trimmed = value.trim();
+            // https:// — pass through
+            if (trimmed.startsWith('https://'))
+                continue;
+            // http:// — reject
+            if (trimmed.startsWith('http://')) {
+                throw new McpError(ErrorCode.InvalidRequest, `Insecure http:// URLs are not allowed for file_path. Use https:// or a local file path.`);
+            }
+            // Local file path — validate, upload via signed URL, replace
+            if (!this.generateUploadURLPath) {
+                throw new McpError(ErrorCode.InternalError, 'File upload service (generateFileUploadGoogleCloudStorageURL) is not available for this user. Cannot upload local files.');
+            }
+            const ext = path.extname(trimmed).toLowerCase();
+            if (!SecondBrainOSServer.ALLOWED_EXTENSIONS.includes(ext)) {
+                throw new McpError(ErrorCode.InvalidRequest, `Unsupported file extension "${ext}" for file_path. Only ${SecondBrainOSServer.ALLOWED_EXTENSIONS.join(', ')} are supported.`);
+            }
+            if (!fs.existsSync(trimmed)) {
+                throw new McpError(ErrorCode.InvalidRequest, `Local file not found: ${trimmed}`);
+            }
+            const fileContent = fs.readFileSync(trimmed, 'utf-8');
+            if (!fileContent.trim()) {
+                throw new McpError(ErrorCode.InvalidRequest, `File is empty: ${trimmed}`);
+            }
+            const fileName = path.basename(trimmed);
+            const fileSize = Buffer.byteLength(fileContent, 'utf-8');
+            // Step 1: Get signed upload URL from the GCF
+            const uploadUrlResponse = await axios.post(`${this.baseUrl}${this.generateUploadURLPath}`, {
+                file_name: fileName,
+                file_size: fileSize,
+                mime_type: 'text/plain'
+            }, {
+                headers: {
+                    'Authorization': `Bearer ${this.userId}:${this.userSecret}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            const { upload_url, gs_path } = uploadUrlResponse.data;
+            // Step 2: PUT file content directly to GCS via signed URL
+            await axios.put(upload_url, fileContent, {
+                headers: {
+                    'Content-Type': 'text/plain'
+                }
+            });
+            console.error(`Uploaded local file to ${gs_path}`);
+            result[key] = gs_path;
+        }
+        return result;
+    }
     async fetchAndEnrichAgents() {
         if (this.cachedAgents)
             return this.cachedAgents;
@@ -489,6 +563,109 @@ class SecondBrainOSServer {
         this.cachedAgents = agents;
         return agents;
     }
+    /**
+     * Write Claude Code skill files to ~/.claude/skills/secondbrainos/
+     * Called on every server startup so skills stay in sync with SBOS.
+     */
+    async writeSkillFiles() {
+        const skillsBase = path.join(homedir(), '.claude', 'skills', 'secondbrainos');
+        // Helper to write a SKILL.md file
+        const writeSkill = (dir, content) => {
+            fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(path.join(dir, 'SKILL.md'), content, 'utf-8');
+        };
+        // 1. server-use — placeholder
+        writeSkill(path.join(skillsBase, 'server-use'), `---\nname: secondbrainos_server_use\ndescription: Second Brain OS server context\nuser-invocable: false\n---\n\nHello world.\n`);
+        // 2. tabs (agents)
+        if (this.getAIAgentsSchemaPath) {
+            try {
+                const agents = await this.fetchAndEnrichAgents();
+                for (const agent of agents) {
+                    if (!agent.name || !agent.id)
+                        continue;
+                    const folderName = toSnakeCase(agent.name);
+                    const agentDocument = {
+                        agent_id: agent.id,
+                        name: agent.name,
+                        description: agent.description || '',
+                        behaviour_and_instructions: agent.behaviour_and_instructions || '',
+                        searchMyKnowledge_collection_id: agent.searchMyKnowledge_collection_id || '',
+                        actions: agent.actions || [],
+                        workflows: (agent.workflows || []).map((wf) => ({
+                            id: wf.id,
+                            name: wf.name,
+                            prompts: (wf.prompts || []).map((p) => ({
+                                id: p.id,
+                                name: p.name,
+                                order: p.order,
+                                description: p.description
+                            }))
+                        }))
+                    };
+                    writeSkill(path.join(skillsBase, 'tabs', folderName), `---\nname: secondbrainos_agent_${folderName}\ndescription: "${agent.description || agent.name}"\nuser-invocable: false\n---\n\n${JSON.stringify(agentDocument, null, 2)}\n`);
+                }
+            }
+            catch (error) {
+                console.error('Failed to write agent skill files:', error);
+            }
+        }
+        // 3. workflows
+        if (this.runPromptChainPath) {
+            try {
+                const data = await this.callRunPromptChain('', '');
+                const workflows = data.workflows || [];
+                for (const wf of workflows) {
+                    if (!wf.name || !wf.workflow_id)
+                        continue;
+                    const folderName = toSnakeCase(wf.name);
+                    const workflowDetail = await this.callRunPromptChain('workflow', wf.workflow_id);
+                    const promptIds = workflowDetail.prompt_id || [];
+                    const promptResults = await Promise.all(promptIds.map(async (promptId) => {
+                        try {
+                            const promptData = await this.callRunPromptChain('prompt', promptId);
+                            return {
+                                id: promptId,
+                                name: promptData.name,
+                                order: promptData.order,
+                                description: promptData.description || ''
+                            };
+                        }
+                        catch {
+                            return { id: promptId, name: '', order: 0, description: '' };
+                        }
+                    }));
+                    const sortedPrompts = promptResults.sort((a, b) => (a.order || 0) - (b.order || 0));
+                    const workflowDocument = {
+                        skill_id: wf.workflow_id,
+                        name: wf.name,
+                        description: wf.description || '',
+                        prompts: sortedPrompts
+                    };
+                    writeSkill(path.join(skillsBase, 'workflows', folderName), `---\nname: secondbrainos_skill_${folderName}\ndescription: "${wf.description || wf.name}"\nuser-invocable: false\n---\n\n${JSON.stringify(workflowDocument, null, 2)}\n`);
+                }
+            }
+            catch (error) {
+                console.error('Failed to write workflow skill files:', error);
+            }
+        }
+        // 4. knowledgebases
+        if (this.getAIAgentsSchemaPath) {
+            try {
+                const agents = await this.fetchAndEnrichAgents();
+                const collectionIds = agents
+                    .map((a) => a.searchMyKnowledge_collection_id)
+                    .filter((id) => id && id.length > 0);
+                if (collectionIds.length > 0) {
+                    const kbDocument = { searchMyKnowledge_collection_ids: collectionIds };
+                    writeSkill(path.join(skillsBase, 'knowledgebases'), `---\nname: secondbrainos_knowledge_bases\ndescription: Knowledge base collection IDs available to agents\nuser-invocable: false\n---\n\n${JSON.stringify(kbDocument, null, 2)}\n`);
+                }
+            }
+            catch (error) {
+                console.error('Failed to write knowledge bases skill file:', error);
+            }
+        }
+        console.error('Skill files written to ~/.claude/skills/secondbrainos/');
+    }
     setupErrorHandling() {
         // Error handling is now built into HttpLlm.execute
         // This method is kept for future error handling implementations
@@ -497,8 +674,11 @@ class SecondBrainOSServer {
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
         console.error("Second Brain OS MCP server running on stdio");
+        // Write skill files in the background (non-blocking)
+        this.writeSkillFiles().catch(err => console.error('Failed to write skill files:', err));
     }
 }
+SecondBrainOSServer.ALLOWED_EXTENSIONS = ['.txt', '.md'];
 // Function to fetch the schema from the API
 async function fetchSchema() {
     const userId = process.env.USER_ID;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "secondbrainos-mcp-server",
-  "version": "1.2.6",
+  "version": "1.4.0",
   "description": "Second Brain OS MCP Server for Claude Desktop",
   "type": "module",
   "main": "build/index.js",