workfullcircle-mcp-local 1.1.2 → 1.3.1

package/index.js

@@ -2,220 +2,108 @@
 
 const fetch = require('node-fetch');
 
-// Configuration from environment
-const API_URL = process.env.WFC_API_URL || 'https://workfullcircle.com/api';
-const API_KEY = process.env.WFC_API_KEY;
+// Parse command line arguments
+const args = process.argv.slice(2);
 
-if (!API_KEY) {
-  console.error('Error: WFC_API_KEY environment variable is required');
+function printUsage() {
+  process.stderr.write('Usage: workfullcircle-mcp-local --token <api-token> [--url <api-url>]\n');
+  process.stderr.write('Environment variables: WFC_API_URL (default: https://workfullcircle.com)\n');
   process.exit(1);
 }
 
-// MCP Server implementation
-class WorkFullCircleMCPServer {
-  constructor() {
-    this.tools = [
-      {
-        name: 'save_memory',
-        description: 'Save a memory to WorkFullCircle',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            content: { type: 'string', description: 'Memory content to save' },
-            sector: { type: 'string', description: 'Memory sector (Semantic, Episodic, Procedural, Emotional, Reflective)' },
-            tags: { type: 'array', items: { type: 'string' }, description: 'Tags for the memory' }
-          },
-          required: ['content']
-        }
-      },
-      {
-        name: 'get_memory',
-        description: 'Retrieve memories from WorkFullCircle',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            query: { type: 'string', description: 'Search query' },
-            limit: { type: 'number', description: 'Maximum number of results' },
-            sector: { type: 'string', description: 'Filter by sector' }
-          }
-        }
-      },
-      {
-        name: 'delete_memory',
-        description: 'Delete a memory from WorkFullCircle',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            id: { type: 'string', description: 'Memory ID to delete' }
-          },
-          required: ['id']
-        }
-      },
-      {
-        name: 'update_memory',
-        description: 'Update a memory in WorkFullCircle',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            id: { type: 'string', description: 'Memory ID to update' },
-            content: { type: 'string', description: 'Updated memory content' },
-            sector: { type: 'string', description: 'Updated memory sector' },
-            tags: { type: 'array', items: { type: 'string' }, description: 'Updated tags' }
-          },
-          required: ['id']
-        }
-      },
-      {
-        name: 'list_all_memories',
-        description: 'List all memories in WorkFullCircle',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            limit: { type: 'number', description: 'Maximum number of results' },
-            offset: { type: 'number', description: 'Number of results to skip' }
-          }
-        }
-      }
-    ];
-  }
+function parseArgs(argv) {
+  const parsed = {
+    token: null,
+    url: process.env.WFC_API_URL || 'https://workfullcircle.com'
+  };
 
-  // Handle MCP initialize request
-  handleInitialize(request) {
-    return {
-      jsonrpc: '2.0',
-      id: request.id,
-      result: {
-        protocolVersion: '2024-11-05',
-        capabilities: {
-          tools: {}
-        },
-        serverInfo: {
-          name: 'workfullcircle-mcp-local',
-          version: '1.0.0'
-        }
-      }
-    };
-  }
-
-  // Handle tools/list request
-  handleToolsList(request) {
-    return {
-      jsonrpc: '2.0',
-      id: request.id,
-      result: {
-        tools: this.tools
-      }
-    };
-  }
-
-  // Handle tools/call request
-  async handleToolsCall(request) {
-    const { name, arguments: args } = request.params;
-    
-    try {
-      const result = await this.callAPI(name, args);
-      
-      return {
-        jsonrpc: '2.0',
-        id: request.id,
-        result: {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2)
-            }
-          ]
-        }
-      };
-    } catch (error) {
-      return {
-        jsonrpc: '2.0',
-        id: request.id,
-        error: {
-          code: -32603,
-          message: error.message
-        }
-      };
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--token') {
+      parsed.token = argv[i + 1];
+      i++;
+    } else if (argv[i] === '--url') {
+      parsed.url = argv[i + 1];
+      i++;
     }
   }
 
-  // Forward call to WorkFullCircle API
-  async callAPI(toolName, args) {
-    const endpoint = `${API_URL}/mcp/${toolName}`;
-    
-    const response = await fetch(endpoint, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${API_KEY}`
-      },
-      body: JSON.stringify(args)
-    });
-
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`API Error ${response.status}: ${errorText}`);
-    }
-
-    return await response.json();
+  // Fallback to environment variable
+  if (!parsed.token) {
+    parsed.token = process.env.WFC_TOKEN;
   }
 
-  // Main request handler
-  async handleRequest(request) {
-    switch (request.method) {
-      case 'initialize':
-        return this.handleInitialize(request);
-      case 'tools/list':
-        return this.handleToolsList(request);
-      case 'tools/call':
-        return await this.handleToolsCall(request);
-      default:
-        return {
-          jsonrpc: '2.0',
-          id: request.id,
-          error: {
-            code: -32601,
-            message: 'Method not found'
-          }
-        };
-    }
+  if (!parsed.token) {
+    process.stderr.write('Error: --token argument or WFC_TOKEN environment variable is required\n');
+    printUsage();
   }
+
+  return parsed;
 }
 
-// STDIO communication
-async function main() {
-  const server = new WorkFullCircleMCPServer();
-  
+const { token: API_TOKEN, url: API_URL } = parseArgs(args);
+
+// Forward all MCP requests directly to the server's MCP endpoint
+async function handleStdio() {
+  let inputBuffer = '';
   process.stdin.setEncoding('utf8');
-  
+
   process.stdin.on('data', async (chunk) => {
-    const lines = chunk.split('\n');
-    
-    for (const line of lines) {
-      if (!line.trim()) continue;
-      
+    inputBuffer += chunk;
+    let newlineIndex;
+
+    while ((newlineIndex = inputBuffer.indexOf('\n')) !== -1) {
+      const line = inputBuffer.slice(0, newlineIndex).trim();
+      inputBuffer = inputBuffer.slice(newlineIndex + 1);
+
+      if (!line) {
+        continue;
+      }
+
+      let payload;
       try {
-        const request = JSON.parse(line);
-        const response = await server.handleRequest(request);
-        process.stdout.write(JSON.stringify(response) + '\n');
+        payload = JSON.parse(line);
       } catch (error) {
-        console.error('Error processing request:', error.message);
+        process.stderr.write(`[WFC-Local] Invalid JSON input: ${error.message}\n`);
+        continue;
+      }
+
+      try {
+        // Forward the MCP request directly to the server
+        const response = await fetch(API_URL, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${API_TOKEN}`
+          },
+          body: JSON.stringify(payload)
+        });
+
+        const responseText = await response.text();
+
+        if (!response.ok) {
+          process.stderr.write(`[WFC-Local] Remote error ${response.status}: ${responseText}\n`);
+          continue;
+        }
+
+        // Validate response is valid JSON before outputting
+        try {
+          JSON.parse(responseText);
+          process.stdout.write(`${responseText}\n`);
+        } catch (jsonError) {
+          process.stderr.write(`[WFC-Local] Invalid JSON response: ${jsonError.message}\n`);
+          process.stderr.write(`[WFC-Local] Response was: ${responseText.substring(0, 200)}...\n`);
+        }
+      } catch (error) {
+        process.stderr.write(`[WFC-Local] Request failed: ${error.message}\n`);
       }
     }
   });
-  
-  // Handle process termination
-  process.on('SIGINT', () => {
-    process.exit(0);
-  });
-  
-  process.on('SIGTERM', () => {
-    process.exit(0);
-  });
 }
 
-// Start the server
-main().catch(error => {
-  console.error('Fatal error:', error);
-  process.exit(1);
-});
+async function main() {
+  process.stderr.write(`[WFC-Local] Connected to MCP server at ${API_URL}\n`);
+  process.stderr.write(`[WFC-Local] Using token: ${API_TOKEN.substring(0, 10)}...\n`);
+  await handleStdio();
+}
+
+main();

package/package.json

@@ -1,7 +1,8 @@
 {
+  "$schema": "https://json.schemastore.org/package",
   "name": "workfullcircle-mcp-local",
-  "version": "1.1.2",
-  "description": "Local STDIO MCP server for WorkFullCircle API",
+  "version": "1.3.1",
+  "description": "Local STDIO MCP server for WorkFullCircle API with Antigravity path fixes",
   "main": "index.js",
   "bin": {
     "workfullcircle-mcp-local": "index.js"
@@ -17,7 +18,9 @@
     "ai",
     "memory",
     "windsurf",
-    "antigravity"
+    "antigravity",
+    "path-fix",
+    "plug-and-play"
   ],
   "author": "Afreensiyad",
   "license": "MIT",
@@ -30,5 +33,10 @@
   "publishConfig": {
     "access": "public"
   },
-  "homepage": "https://workfullcircle.com"
+  "homepage": "https://workfullcircle.com",
+  "files": [
+    "index.js",
+    "test.js",
+    "README.md"
+  ]
 }