reportdash-datastore-mcp-claude-desktop 1.0.8 → 1.0.10

package/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-//goto folder, increment version then run > npm publish --access public
+// goto folder, increment version then run > npm publish --access public
 
 const https = require('https');
 const http = require('http');
@@ -12,29 +12,55 @@ const API_URL = process.env.REPORTDASH_API_URL || 'https://datastore.reportdash.
 
 // Validate configuration
 if (!API_KEY) {
-  console.error(JSON.stringify({
-    jsonrpc: '2.0',
-    error: {
-      code: -32600,
-      message: 'REPORTDASH_API_KEY environment variable is required. Get your API key from ReportDash DataStore app settings.'
-    }
-  }));
+  // In Claude MCP mode, stdout should be JSON only. This is fatal anyway, so ok.
+  process.stdout.write(
+    JSON.stringify({
+      jsonrpc: '2.0',
+      error: {
+        code: -32600,
+        message:
+          'REPORTDASH_API_KEY environment variable is required. Get your API key from ReportDash DataStore app settings.',
+      },
+      id: null,
+    }) + '\n'
+  );
   process.exit(1);
 }
 
 /**
  * Ensure every outbound request includes platform="claude"
- * without breaking existing requests.
  */
 function withClaudePlatform(mcpRequest) {
-  // If caller already provided platform, keep it.
   if (mcpRequest && typeof mcpRequest === 'object') {
-    if (!mcpRequest.platform) mcpRequest.platform = 'claude';
+    if (mcpRequest.platform == null) mcpRequest.platform = 'claude';
   }
   return mcpRequest;
 }
 
-// Test mode
+/**
+ * Preserve id=0. Only default when null/undefined.
+ */
+function rpcId(req) {
+  return req?.id ?? null;
+}
+
+/**
+ * Write exactly one JSON object per line to stdout (MCP framing).
+ */
+function writeJson(obj) {
+  process.stdout.write(JSON.stringify(obj) + '\n');
+}
+
+/**
+ * Build a JSON-RPC error response
+ */
+function rpcError({ id = null, code = -32603, message = 'Internal error', data }) {
+  const err = { code, message };
+  if (data !== undefined) err.data = data;
+  return { jsonrpc: '2.0', id, error: err };
+}
+
+// Test mode (prints human logs to stdout; do not run in Claude MCP mode)
 if (process.argv.includes('--test')) {
   testConnection();
   return;
@@ -44,26 +70,27 @@ if (process.argv.includes('--test')) {
 const rl = readline.createInterface({
   input: process.stdin,
   output: process.stdout,
-  terminal: false
+  terminal: false,
 });
 
 rl.on('line', (line) => {
   if (!line.trim()) return;
 
+  let mcpRequest;
   try {
-    const mcpRequest = JSON.parse(line);
-    forwardToAPI(withClaudePlatform(mcpRequest));
+    mcpRequest = JSON.parse(line);
   } catch (error) {
-    // Only output to stdout, never stderr for MCP protocol
-    console.log(JSON.stringify({
-      jsonrpc: '2.0',
-      error: {
+    writeJson(
+      rpcError({
+        id: null,
         code: -32700,
-        message: 'Parse error: ' + error.message
-      },
-      id: null
-    }));
+        message: 'Parse error: ' + error.message,
+      })
+    );
+    return;
   }
+
+  forwardToAPI(withClaudePlatform(mcpRequest));
 });
 
 function forwardToAPI(mcpRequest) {
@@ -71,102 +98,124 @@ function forwardToAPI(mcpRequest) {
   const isHttps = url.protocol === 'https:';
   const client = isHttps ? https : http;
 
+  const body = JSON.stringify(mcpRequest);
+
   const options = {
     hostname: url.hostname,
     port: url.port || (isHttps ? 443 : 80),
-    path: url.pathname,
+    path: url.pathname + url.search,
     method: 'POST',
     headers: {
       'Content-Type': 'application/json',
+      'Content-Length': Buffer.byteLength(body),
       'X-Api-Key': API_KEY,
-      'User-Agent': 'ReportDash-DataStore-MCP/1.0'
+      'User-Agent': 'ReportDash-DataStore-MCP/1.0',
     },
-    timeout: 30000 // 30 second timeout
+    timeout: 30000,
   };
 
   const req = client.request(options, (res) => {
     let data = '';
+    res.on('data', (chunk) => (data += chunk));
+    res.on('end', () => {
+      const id = rpcId(mcpRequest);
 
-    res.on('data', (chunk) => {
-      data += chunk;
-    });
+      // 204 or empty body => empty result
+      if (res.statusCode === 204 || !data.trim()) {
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          writeJson({ jsonrpc: '2.0', id, result: {} });
+        } else {
+          writeJson(
+            rpcError({
+              id,
+              code: res.statusCode,
+              message: `API error: ${res.statusCode} (empty body)`,
+            })
+          );
+        }
+        return;
+      }
+
+      // Always re-serialize to 1-line JSON for MCP framing
+      let parsed;
+      try {
+        parsed = JSON.parse(data);
+      } catch (e) {
+        writeJson(
+          rpcError({
+            id,
+            code: res.statusCode >= 400 ? res.statusCode : -32603,
+            message: 'API returned non-JSON response',
+            data: { statusCode: res.statusCode, body: data },
+          })
+        );
+        return;
+      }
 
-    res.on('end', () => {
-      // Treat 200-299 as success (including 204 No Content)
       if (res.statusCode >= 200 && res.statusCode < 300) {
-        // For 204 No Content or empty response, return empty success
-        if (res.statusCode === 204 || !data.trim()) {
-          console.log(JSON.stringify({
-            jsonrpc: '2.0',
-            error: {
-              code: res.statusCode,
-              message: `API error: ${res.statusCode}${data ? ' - ' + data : ''}`,
-              data: { statusCode: res.statusCode, body: data }
-            },
-            id: mcpRequest.id ?? null
-          }));
+        // Ensure JSON-RPC envelope exists; if your API returns raw jsonrpc objects, this is fine.
+        // If it returns something else, wrap it.
+        if (parsed && typeof parsed === 'object' && parsed.jsonrpc === '2.0') {
+          // Some backends might omit id; ensure it's present
+          if (parsed.id === undefined) parsed.id = id;
+          writeJson(parsed);
         } else {
-          // Forward the response as-is
-          console.log(data);
+          writeJson({ jsonrpc: '2.0', id, result: parsed });
         }
       } else {
-        // Send errors to stdout (not stderr!) so Claude can properly handle them
-        console.log(JSON.stringify({
-          jsonrpc: '2.0',
-          error: {
+        writeJson(
+          rpcError({
+            id,
             code: res.statusCode,
-            message: `API error: ${res.statusCode}${data ? ' - ' + data : ''}`,
-            data: { statusCode: res.statusCode, body: data }
-          },
-          id: mcpRequest.id || null
-        }));
+            message: `API error: ${res.statusCode}`,
+            data: parsed,
+          })
+        );
       }
     });
   });
 
   req.on('error', (error) => {
-    // Send errors to stdout (not stderr!)
-    console.log(JSON.stringify({
-      jsonrpc: '2.0',
-      error: {
+    writeJson(
+      rpcError({
+        id: rpcId(mcpRequest),
         code: -32603,
-        message: 'Request timeout after 30 seconds'
-      },
-      id: mcpRequest.id ?? null
-    }));
+        message: 'Network error: ' + error.message,
+        data: { error: error.message },
+      })
+    );
   });
 
   req.on('timeout', () => {
     req.destroy();
-    // Send errors to stdout (not stderr!)
-    console.log(JSON.stringify({
-      jsonrpc: '2.0',
-      error: {
+    writeJson(
+      rpcError({
+        id: rpcId(mcpRequest),
         code: -32603,
-        message: 'Request timeout after 30 seconds'
-      },
-      id: mcpRequest.id || null
-    }));
+        message: 'Request timeout after 30 seconds',
+      })
+    );
   });
 
-  req.write(JSON.stringify(mcpRequest));
+  req.write(body);
   req.end();
 }
 
 function testConnection() {
   console.log('🔍 Testing ReportDash DataStore connection...\n');
   console.log(`API URL: ${API_URL}`);
-  console.log(`API Key: ${API_KEY.substring(0, 10)}...${API_KEY.substring(API_KEY.length - 4)}\n`);
+  console.log(
+    `API Key: ${API_KEY.substring(0, 10)}...${API_KEY.substring(API_KEY.length - 4)}\n`
+  );
 
   const url = new URL(API_URL);
   const isHttps = url.protocol === 'https:';
   const client = isHttps ? https : http;
 
-  // Create MCP tools/list request
   const mcpRequest = withClaudePlatform({
     jsonrpc: '2.0',
     method: 'tools/list',
-    id: 'test-connection'
+    id: 'test-connection',
   });
 
   const postData = JSON.stringify(mcpRequest);
@@ -174,22 +223,22 @@ function testConnection() {
   const options = {
     hostname: url.hostname,
     port: url.port || (isHttps ? 443 : 80),
-    path: url.pathname,
+    path: url.pathname + url.search,
     method: 'POST',
     headers: {
       'Content-Type': 'application/json',
       'X-Api-Key': API_KEY,
       'Content-Length': Buffer.byteLength(postData),
-      'User-Agent': 'ReportDash-DataStore-MCP/1.0'
+      'User-Agent': 'ReportDash-DataStore-MCP/1.0',
     },
-    timeout: 10000
+    timeout: 10000,
   };
 
   console.log('📡 Sending MCP tools/list request...\n');
 
   const req = client.request(options, (res) => {
     let data = '';
-    res.on('data', (chunk) => { data += chunk; });
+    res.on('data', (chunk) => (data += chunk));
     res.on('end', () => {
       console.log(`Response Status: ${res.statusCode}\n`);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reportdash-datastore-mcp-claude-desktop",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "ReportDash DataStore MCP server for Claude Desktop",
   "main": "index.js",
   "bin": {