taskr-mcp-client 1.0.0

package/README.md

@@ -0,0 +1,49 @@
+# taskr-mcp-client
+
+stdio to HTTP bridge for Taskr MCP server. Connects Claude Code to the Taskr production MCP endpoint.
+
+## Installation
+
+No installation needed! Use with `npx`:
+
+```bash
+npx taskr-mcp-client
+```
+
+## Usage with Claude Code
+
+Add to your `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "taskr": {
+      "command": "npx",
+      "args": ["-y", "taskr-mcp-client"],
+      "env": {
+        "MCP_API_URL": "https://taskr-six.vercel.app/api/mcp",
+        "MCP_PROJECT_ID": "your-project-id",
+        "MCP_USER_API_KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
+
+## Environment Variables
+
+- `MCP_API_URL` - Taskr MCP endpoint URL
+- `MCP_PROJECT_ID` - Your Taskr project ID (format: `PR_*`)
+- `MCP_USER_API_KEY` - Your Taskr API key
+
+## How It Works
+
+This bridge translates between:
+- **stdin/stdout** (MCP protocol used by Claude Code)
+- **HTTP POST** (JSON-RPC 2.0 endpoint used by Taskr server)
+
+It allows Claude Code to communicate with Taskr's serverless MCP endpoint deployed on Vercel.
+
+## License
+
+MIT

package/bridge.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+
+/**
+ * MCP HTTP Client Bridge using official MCP SDK
+ * Bridges stdio-based MCP clients to HTTP JSON-RPC endpoints
+ */
+
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+
+// Configuration from environment variables
+const MCP_API_URL = process.env.MCP_API_URL;
+const MCP_PROJECT_ID = process.env.MCP_PROJECT_ID;
+const MCP_USER_API_KEY = process.env.MCP_USER_API_KEY;
+
+if (!MCP_API_URL || !MCP_PROJECT_ID || !MCP_USER_API_KEY) {
+  console.error('Error: Missing required environment variables');
+  console.error('Required: MCP_API_URL, MCP_PROJECT_ID, MCP_USER_API_KEY');
+  process.exit(1);
+}
+
+// Custom HTTP transport that wraps our JSON-RPC endpoint
+class CustomHttpTransport {
+  constructor(url, headers) {
+    this.url = url;
+    this.headers = headers;
+  }
+
+  async start() {
+    // No persistent connection needed
+  }
+
+  async send(message) {
+    const https = await import('https');
+    const http = await import('http');
+
+    const url = new URL(this.url);
+    const isHttps = url.protocol === 'https:';
+    const httpModule = isHttps ? https : http;
+
+    return new Promise((resolve, reject) => {
+      const requestBody = JSON.stringify(message);
+
+      const options = {
+        hostname: url.hostname,
+        port: url.port || (isHttps ? 443 : 80),
+        path: url.pathname,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(requestBody),
+          ...this.headers
+        },
+        rejectUnauthorized: false
+      };
+
+      const req = httpModule.request(options, (res) => {
+        let data = '';
+
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(data));
+          } catch (error) {
+            reject(new Error('Failed to parse response'));
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.write(requestBody);
+      req.end();
+    });
+  }
+
+  async close() {
+    // No persistent connection to close
+  }
+}
+
+// Create and start the bridge
+async function main() {
+  const transport = new CustomHttpTransport(MCP_API_URL, {
+    'x-project-id': MCP_PROJECT_ID,
+    'x-user-api-key': MCP_USER_API_KEY,
+    'MCP-Protocol-Version': '2025-06-18'
+  });
+
+  const client = new Client({
+    name: 'taskr-http-client',
+    version: '1.0.0'
+  }, {
+    capabilities: {}
+  });
+
+  // Use stdio transport for communication with Claude Code
+  const stdioTransport = new StdioClientTransport();
+
+  await client.connect(transport);
+
+  // Keep process alive
+  process.stdin.resume();
+}
+
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/index.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+
+/**
+ * MCP HTTP Client - stdio to HTTP bridge for MCP servers
+ * Bridges stdio-based MCP clients (like Claude Code) to HTTP-only JSON-RPC MCP servers
+ */
+
+const readline = require('readline');
+const https = require('https');
+const http = require('http');
+
+// Configuration from environment variables
+const MCP_API_URL = process.env.MCP_API_URL;
+const MCP_PROJECT_ID = process.env.MCP_PROJECT_ID;
+const MCP_USER_API_KEY = process.env.MCP_USER_API_KEY;
+
+if (!MCP_API_URL || !MCP_PROJECT_ID || !MCP_USER_API_KEY) {
+  process.stderr.write('Error: Missing required environment variables\n');
+  process.stderr.write('Required: MCP_API_URL, MCP_PROJECT_ID, MCP_USER_API_KEY\n');
+  process.exit(1);
+}
+
+// Parse URL
+const url = new URL(MCP_API_URL);
+const isHttps = url.protocol === 'https:';
+const httpModule = isHttps ? https : http;
+
+// Read JSON-RPC requests from stdin, forward to HTTP endpoint, write responses to stdout
+const rl = readline.createInterface({
+  input: process.stdin,
+  terminal: false
+});
+
+rl.on('line', async (line) => {
+  try {
+    // Parse JSON-RPC request from stdin
+    const jsonrpcRequest = JSON.parse(line);
+
+    // Forward to HTTP endpoint
+    const requestBody = JSON.stringify(jsonrpcRequest);
+    const options = {
+      hostname: url.hostname,
+      port: url.port || (isHttps ? 443 : 80),
+      path: url.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(requestBody),
+        'x-project-id': MCP_PROJECT_ID,
+        'x-user-api-key': MCP_USER_API_KEY,
+        'MCP-Protocol-Version': '2025-06-18'
+      },
+      // Disable SSL certificate validation (Windows SSL issues)
+      rejectUnauthorized: false
+    };
+
+    const req = httpModule.request(options, (res) => {
+      let data = '';
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          // Write JSON-RPC response to stdout (one line, newline terminated)
+          const output = data.trim() + '\n';
+          process.stdout.write(output, () => {
+            // Flush completed
+          });
+        } catch (error) {
+          const errorResponse = {
+            jsonrpc: '2.0',
+            id: jsonrpcRequest.id,
+            error: {
+              code: -32603,
+              message: 'Internal error: Failed to parse server response'
+            }
+          };
+          process.stdout.write(JSON.stringify(errorResponse) + '\n', () => {
+            // Flush completed
+          });
+        }
+      });
+    });
+
+    req.on('error', (error) => {
+      const errorResponse = {
+        jsonrpc: '2.0',
+        id: jsonrpcRequest.id,
+        error: {
+          code: -32603,
+          message: `HTTP request failed: ${error.message}`
+        }
+      };
+      process.stdout.write(JSON.stringify(errorResponse) + '\n');
+    });
+
+    req.write(requestBody);
+    req.end();
+  } catch (error) {
+    const errorResponse = {
+      jsonrpc: '2.0',
+      id: null,
+      error: {
+        code: -32700,
+        message: 'Parse error'
+      }
+    };
+    process.stdout.write(JSON.stringify(errorResponse) + '\n');
+  }
+});
+
+rl.on('close', () => {
+  process.exit(0);
+});

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "taskr-mcp-client",
+  "version": "1.0.0",
+  "description": "stdio to HTTP bridge for Taskr MCP server - connects Claude Code to HTTP-only JSON-RPC MCP endpoints",
+  "main": "index.js",
+  "bin": {
+    "taskr-mcp-client": "./index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "taskr",
+    "mcp",
+    "model-context-protocol",
+    "json-rpc",
+    "bridge",
+    "stdio",
+    "http",
+    "ai",
+    "task-management"
+  ],
+  "author": "Taskr Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/echo-of-machines/Taskr.git",
+    "directory": "mcp-http-client"
+  },
+  "homepage": "https://github.com/echo-of-machines/Taskr#readme",
+  "bugs": {
+    "url": "https://github.com/echo-of-machines/Taskr/issues"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.20.2"
+  }
+}

package/test-stdin.js

@@ -0,0 +1,20 @@
+const readline = require('readline');
+
+console.error('Starting test...');
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  terminal: false
+});
+
+rl.on('line', (line) => {
+  console.error(`Got line: ${line}`);
+  console.log(`ECHO: ${line}`);
+});
+
+rl.on('close', () => {
+  console.error('Stdin closed');
+  process.exit(0);
+});
+
+console.error('Waiting for input...');

package/test.js

@@ -0,0 +1,52 @@
+const https = require('https');
+
+const url = new URL('https://taskr-six.vercel.app/api/mcp');
+
+const data = JSON.stringify({
+  jsonrpc: '2.0',
+  id: 1,
+  method: 'tools/list',
+  params: {}
+});
+
+const options = {
+  hostname: url.hostname,
+  port: 443,
+  path: url.pathname,
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/json',
+    'Content-Length': data.length,
+    'x-project-id': 'PRMGYS22KCZPJ0KRIQM100000000',
+    'x-user-api-key': '89cab946b8d6e51b38db993ba1441d617a06ff55e6f8c7174d0f6dd61d424bf2',
+    'MCP-Protocol-Version': '2025-06-18'
+  },
+  rejectUnauthorized: false
+};
+
+console.error('Making request to:', url.href);
+console.error('Options:', JSON.stringify(options, null, 2));
+
+const req = https.request(options, (res) => {
+  console.error('Status:', res.statusCode);
+  console.error('Headers:', JSON.stringify(res.headers, null, 2));
+
+  let responseData = '';
+
+  res.on('data', (chunk) => {
+    responseData += chunk;
+  });
+
+  res.on('end', () => {
+    console.error('Response length:', responseData.length);
+    console.log(responseData);
+  });
+});
+
+req.on('error', (error) => {
+  console.error('Request error:', error.message);
+  process.exit(1);
+});
+
+req.write(data);
+req.end();