@ecommaps/mcp 1.0.6 → 1.0.8

package/README.md

@@ -1,34 +1,70 @@
-# EcoBaseAI MCP Client CLI
+# @ecommaps/mcp
 
-This package provides the official CLI bridge for EcoBaseAI MCP servers.
+Official Ecommaps MCP **stdio bridge**.
 
-## Installation
+This package lets MCP-capable editors connect to Ecommaps over the modern
+Streamable HTTP endpoint (`/api/v1/mcp`) while speaking stdio locally.
+
+## Quick Start
+
+Run with your store key and the official endpoint:
 
 ```bash
-npm install -g @ecommaps/mcp
+npx @ecommaps/mcp <YOUR_STORE_MCP_KEY> --url https://api.ecommaps.com/api/v1/mcp
 ```
 
-## Usage
+## CLI Options
 
-```bash
-npx @ecommaps/mcp <YOUR_API_KEY>
+- `--url <MCP_URL>`: Override the MCP endpoint URL.
+- `--api-key <KEY>`: Pass key explicitly instead of positional arg.
+- `--help`: Show usage.
+
+## Environment Variables
+
+- `MCP_BEARER_TOKEN`: Preferred token source.
+- `MCP_API_KEY`: Backward-compatible token source.
+- `ECOMMAPS_MCP_URL`: Default endpoint if `--url` is not provided.
+
+## Editor Configuration (Generic MCP stdio)
+
+Use the following shape in any editor that supports stdio MCP servers:
+
+```json
+{
+  "command": "npx",
+  "args": [
+    "-y",
+    "@ecommaps/mcp",
+    "sk_eco_xxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+    "--url",
+    "https://api.ecommaps.com/api/v1/mcp"
+  ]
+}
+```
+
+Or with env var:
+
+```json
+{
+  "command": "npx",
+  "args": ["-y", "@ecommaps/mcp", "--url", "https://api.ecommaps.com/api/v1/mcp"],
+  "env": {
+    "MCP_BEARER_TOKEN": "sk_eco_xxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+  }
+}
 ```
 
-## Development & Publishing
+Important: keep `--url https://api.ecommaps.com/api/v1/mcp` in editor/server configs to avoid falling back to any outdated transport defaults.
+Also make sure `--url` comes **after** `@ecommaps/mcp` in `args`; otherwise `npx` treats it as an npm flag and fails.
 
-To publish this package to NPM:
+## Transport Notes
 
-1. Ensure you are logged in to NPM:
-   ```bash
-   npm login
-   ```
-2. Navigate to this directory:
-   ```bash
-   cd packages/mcp-cli
-   ```
-3. Publish with public access:
-   ```bash
-   npm publish --access public
-   ```
+- Recommended endpoint: `POST /api/v1/mcp`
+- Legacy compatibility endpoints still exist during migration but are not recommended for new integrations.
 
-Once published, anyone can use `npx @ecommaps/mcp`!
+## Release
+
+```bash
+cd packages/mcp-cli
+npm publish --access public
+```

package/cli.js

@@ -1,150 +1,170 @@
 #!/usr/bin/env node
 
-const { parseArgs } = require('util');
 const readline = require('readline');
 
-// Configuration
-const DEFAULT_SSE_URL = "https://api.ecommaps.com/api/v1/mcp/sse";
+const DEFAULT_MCP_URL = process.env.ECOMMAPS_MCP_URL || 'https://api.ecommaps.com/api/v1/mcp';
 
-// Parse Args manually or with util.parseArgs
-const args = process.argv.slice(2);
-let apiKey = null;
+function parseCliArgs(argv) {
+  const args = argv.slice(2);
+  let apiKey = process.env.MCP_BEARER_TOKEN || process.env.MCP_API_KEY || null;
+  let mcpUrl = DEFAULT_MCP_URL;
+  let showHelp = false;
 
-// Simple arg parsing
-if (process.env.MCP_API_KEY) {
-    apiKey = process.env.MCP_API_KEY;
-}
-
-for (let i = 0; i < args.length; i++) {
-    if (args[i].startsWith('sk_eco_')) {
-        apiKey = args[i];
+  for (let i = 0; i < args.length; i += 1) {
+    const rawArg = args[i];
+    const arg = typeof rawArg === 'string' ? rawArg.replace(/[–—−]/g, '-') : rawArg;
+    if (arg === '--help' || arg === '-h') {
+      showHelp = true;
+      continue;
+    }
+    if ((arg === '--url' || arg === '-url') && args[i + 1]) {
+      mcpUrl = args[i + 1];
+      i += 1;
+      continue;
     }
+    if ((arg === '--api-key' || arg === '-api-key') && args[i + 1]) {
+      apiKey = args[i + 1];
+      i += 1;
+      continue;
+    }
+    if (!arg.startsWith('--') && !apiKey) {
+      apiKey = arg;
+    }
+  }
+
+  return { apiKey, mcpUrl, showHelp };
 }
 
-if (!apiKey) {
-    console.error("❌ Error: API Key is required.");
-    console.error("Usage: npx @ecommaps/mcp <YOUR_API_KEY>");
-    process.exit(1);
+function printUsageAndExit() {
+  console.error('Usage: npx @ecommaps/mcp <YOUR_API_KEY> [--url https://api.ecommaps.com/api/v1/mcp]');
+  console.error('       npx @ecommaps/mcp --api-key <YOUR_API_KEY> [--url <MCP_URL>]');
+  console.error('');
+  console.error('Environment variables:');
+  console.error('  MCP_BEARER_TOKEN   Preferred auth token');
+  console.error('  MCP_API_KEY        Backward-compatible auth token');
+  console.error('  ECOMMAPS_MCP_URL   Default MCP endpoint URL');
+  process.exit(0);
 }
 
-const SSE_URL = DEFAULT_SSE_URL;
-const POST_URL = SSE_URL.replace('/sse', '/messages'); // Default, might be updated by endpoint event
+function normalizeResponsePayload(rawBody, contentType) {
+  if (!rawBody) return null;
+
+  if (contentType && contentType.includes('text/event-stream')) {
+    // Streamable HTTP can return SSE; convert first data frame to JSON object if possible.
+    const lines = rawBody.split('\n');
+    for (const line of lines) {
+      if (!line.startsWith('data:')) continue;
+      const value = line.slice(5).trim();
+      if (!value || value === '[DONE]') continue;
+      try {
+        return JSON.parse(value);
+      } catch (_) {
+        return value;
+      }
+    }
+    return null;
+  }
+
+  try {
+    return JSON.parse(rawBody);
+  } catch (_) {
+    return rawBody;
+  }
+}
 
-console.error(`🔌 EcoBaseAI MCP Client (Native) Connecting...`);
-console.error(`   Target: ${SSE_URL}`);
+async function postRpc(mcpUrl, apiKey, rpcPayload) {
+  const response = await fetch(mcpUrl, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+      Accept: 'application/json, text/event-stream',
+      'MCP-Protocol-Version': '2025-06-18',
+    },
+    body: JSON.stringify(rpcPayload),
+  });
+
+  const rawBody = await response.text();
+  const contentType = response.headers.get('content-type') || '';
+
+  if (!response.ok) {
+    throw new Error(`MCP HTTP ${response.status}: ${rawBody}`);
+  }
+
+  const payload = normalizeResponsePayload(rawBody, contentType);
+  if (payload === null) {
+    throw new Error('MCP response was empty.');
+  }
+
+  if (typeof payload === 'object' && payload && payload.error) {
+    throw new Error(`MCP JSON-RPC error: ${payload.error.message || 'Unknown error'}`);
+  }
+
+  return payload;
+}
 
 async function main() {
-    const headers = {
-        'Authorization': `Bearer ${apiKey}`,
-        'Accept': 'text/event-stream',
-        'Content-Type': 'application/json'
-    };
-
-    // 1. Start SSE Connection
-    let controller = new AbortController();
-
-    try {
-        const response = await fetch(SSE_URL, {
-            headers: headers,
-            signal: controller.signal
-        });
-
-        if (!response.ok) {
-            console.error(`❌ SSE Connection failed: ${response.status} ${response.statusText}`);
-            process.exit(1);
+  const { apiKey, mcpUrl, showHelp } = parseCliArgs(process.argv);
+  if (showHelp) {
+    printUsageAndExit();
+  }
+  if (!apiKey) {
+    console.error('Error: API key is required.');
+    process.exit(1);
+  }
+
+  console.error('Ecommaps MCP stdio bridge started');
+  console.error(`Target: ${mcpUrl}`);
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr,
+    terminal: false,
+  });
+
+  let queue = Promise.resolve();
+
+  rl.on('line', (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+
+    queue = queue.then(async () => {
+      let payload;
+      try {
+        payload = JSON.parse(trimmed);
+      } catch (error) {
+        console.error(`Invalid JSON input: ${error.message}`);
+        return;
+      }
+
+      try {
+        // Some MCP clients may send params as [] or omit them for list methods.
+        // Ecommaps MCP expects params to be an object, so normalize empty variants.
+        if (payload && typeof payload === 'object') {
+          if (
+            payload.params == null ||
+            (Array.isArray(payload.params) && payload.params.length === 0)
+          ) {
+            payload.params = {};
+          }
         }
 
-        // Handle SSE Stream
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = '';
-
-        // Process SSE in background
-        (async () => {
-            try {
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done) break;
-
-                    buffer += decoder.decode(value, { stream: true });
-                    const lines = buffer.split('\n');
-                    buffer = lines.pop(); // Keep incomplete line
-
-                    for (const line of lines) {
-                        if (line.startsWith('data: ')) {
-                            const data = line.slice(6).trim();
-                            if (data === '[DONE]') continue;
-
-                            try {
-                                // Try to parse as JSON-RPC
-                                const msg = JSON.parse(data);
-
-                                // FIX: Some clients (Antigravity/Cursor) fail if they receive 'notifications/initialized'
-                                // before they send their own 'initialize' handshake. The server sends this eagerly,
-                                // so we filter it out here to keep the client happy.
-                                if (msg.method === 'notifications/initialized') {
-                                    return; // Skip this message
-                                }
-
-                                // Forward to StdOut
-                                console.log(JSON.stringify(msg));
-                            } catch (e) {
-                                // Not JSON (maybe endpoint url?)
-                                // console.error('Received non-JSON data:', data);
-                            }
-                        }
-                        if (line.startsWith('event: endpoint')) {
-                            // The next data line contains the endpoint. 
-                            // Current simple parser might miss context, but our server sends data immediately after.
-                        }
-                    }
-                }
-            } catch (err) {
-                console.error('❌ SSE Stream Error:', err);
-                process.exit(1);
-            }
-        })();
-
-        // 2. Setup Stdin Reader for POST requests
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stderr, // Important: Don't write prompts to stdout
-            terminal: false
-        });
-
-        rl.on('line', async (line) => {
-            if (!line.trim()) return;
-
-            try {
-                // Validate JSON
-                const msg = JSON.parse(line);
-
-                // Send POST
-                const postResp = await fetch(POST_URL, {
-                    method: 'POST',
-                    headers: headers,
-                    body: JSON.stringify(msg)
-                });
-
-                if (!postResp.ok) {
-                    const text = await postResp.text();
-                    console.error(`❌ POST Error: ${postResp.status} - ${text}`);
-                } else {
-                    // Some MCP servers return result in HTTP response
-                    const text = await postResp.text();
-                    if (text && postResp.headers.get('content-type')?.includes('application/json')) {
-                        console.log(text);
-                    }
-                }
-            } catch (e) {
-                console.error('❌ Failed to process input line:', e);
-            }
-        });
-
-    } catch (err) {
-        console.error('❌ Connection Error:', err);
-        process.exit(1);
-    }
+        const result = await postRpc(mcpUrl, apiKey, payload);
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+      } catch (error) {
+        const message = error && error.message ? error.message : String(error);
+        console.error(message);
+        // Best-effort JSON-RPC error response so MCP clients stay synchronized.
+        const id = payload && Object.prototype.hasOwnProperty.call(payload, 'id') ? payload.id : null;
+        process.stdout.write(
+          `${JSON.stringify({ jsonrpc: '2.0', id, error: { code: -32000, message } })}\n`
+        );
+      }
+    });
+  });
 }
 
-main();
+main().catch((error) => {
+  console.error(error && error.message ? error.message : String(error));
+  process.exit(1);
+});

package/package.json

@@ -1,18 +1,15 @@
 {
   "name": "@ecommaps/mcp",
-  "version": "1.0.6",
-  "description": "EcoBaseAI Official MCP Client",
+  "version": "1.0.8",
+  "description": "Official Ecommaps MCP stdio bridge",
   "bin": {
-    "mcp": "./cli.js"
+    "mcp": "cli.js"
   },
   "files": [
     "cli.js",
     "README.md"
   ],
   "main": "cli.js",
-  "dependencies": {
-    "minimist": "^1.2.8"
-  },
   "keywords": [
     "mcp",
     "ai",
@@ -20,4 +17,4 @@
   ],
   "author": "EcoBaseAI",
   "license": "ISC"
-}
+}