new debug capabilities with new mock clients

Author: kapravel

.gitignore

@@ -1,4 +1,4 @@
 node_modules/
 *.log
 .vscode/
-build/index.js.map
+build/

DEBUG.md

@@ -0,0 +1,131 @@
+# Socket MCP Mock Client Tools
+
+The `mock-client` directory contains debug clients for testing the Socket MCP server.
+
+## Prerequisites
+
+1. Build the project:
+
+   ```bash
+   npm run build
+   ```
+
+2. Set your Socket API key:
+
+   ```bash
+   export SOCKET_API_KEY="your-api-key-here"
+   ```
+
+## Debug Clients
+
+### 1. Simple JSON-RPC Client (`mock-client/debug-client.ts`)
+
+Direct stdio communication using JSON-RPC protocol:
+
+```bash
+npm run debug:stdio
+```
+
+This client:
+
+- Sends raw JSON-RPC messages to the MCP server
+- Tests initialization, tool listing, and depscore calls
+- Useful for debugging protocol-level issues
+
+### 2. MCP SDK Client (`mock-client/stdio-client.ts`)
+
+Uses the official MCP SDK client library:
+
+```bash
+npm run debug:sdk
+```
+
+This client:
+
+- Uses the same SDK that real MCP clients use
+- Tests the server's compatibility with the SDK
+- Good for integration testing
+
+### 3. HTTP Mode Client (`mock-client/http-client.ts`)
+
+Tests the HTTP/SSE transport mode:
+
+```bash
+# First, start the server in HTTP mode:
+npm run server:http
+
+# In another terminal:
+npm run debug:http
+```
+
+This client:
+
+- Tests HTTP POST requests and SSE streams
+- Verifies session management
+- Tests CORS and HTTP-specific features
+
+## What Each Client Tests
+
+All clients test the following scenarios:
+
+1. **Connection initialization** - MCP protocol handshake
+2. **Tool discovery** - Lists available tools
+3. **Basic depscore call** - Tests with npm and PyPI packages
+4. **Error handling** - Tests with invalid inputs
+5. **Edge cases** - Unknown packages, minimal inputs
+
+## Interpreting Results
+
+### Successful Response
+
+```json
+{
+  "content": [
+    {
+      "type": "text",
+      "text": "Package: express@4.18.2\nScore: 0.85\n..."
+    }
+  ]
+}
+```
+
+### Error Response
+
+```json
+{
+  "error": {
+    "code": -32602,
+    "message": "Invalid params",
+    "data": "Expected array with at least 1 element"
+  }
+}
+```
+
+## Common Issues
+
+1. **API Key Missing**: Set `SOCKET_API_KEY` environment variable
+2. **Build Errors**: Run `npm run build` first
+3. **Permission Denied**: Check file permissions (should be executable)
+4. **Connection Refused**: For HTTP mode, ensure server is running
+
+## Advanced Usage
+
+### Custom API Endpoint
+
+To test against a local Socket API:
+
+```bash
+# Edit src/index.ts and change SOCKET_API_URL
+# Then rebuild and test
+```
+
+### Verbose Logging
+
+Check logs at:
+
+- `/tmp/socket-mcp.log` - Info logs
+- `/tmp/socket-mcp-error.log` - Error logs
+
+### Testing Specific Packages
+
+Edit the test clients to modify the `testPackages` array with your specific packages to test.

build/index.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+import { spawn } from 'child_process';
+import readline from 'readline';
+
+// Simple JSON-RPC client for testing MCP server
+class SimpleJSONRPCClient {
+  private process: any;
+  private rl: readline.Interface;
+  private requestId = 1;
+  private pendingRequests = new Map();
+
+  constructor(command: string, args: string[] = [], env: any = {}) {
+    this.process = spawn(command, args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, ...env }
+    });
+
+    this.rl = readline.createInterface({
+      input: this.process.stdout,
+      crlfDelay: Infinity
+    });
+
+    this.rl.on('line', (line) => {
+      try {
+        const response = JSON.parse(line);
+        if (response.id && this.pendingRequests.has(response.id)) {
+          const { resolve, reject } = this.pendingRequests.get(response.id);
+          this.pendingRequests.delete(response.id);
+          
+          if (response.error) {
+            reject(response.error);
+          } else {
+            resolve(response.result);
+          }
+        } else if (response.method) {
+          console.log('Notification:', response);
+        }
+      } catch (e) {
+        console.error('Failed to parse response:', line);
+      }
+    });
+
+    this.process.stderr.on('data', (data: Buffer) => {
+      console.error('Server stderr:', data.toString());
+    });
+  }
+
+  async sendRequest(method: string, params: any = {}) {
+    const id = this.requestId++;
+    const request = {
+      jsonrpc: '2.0',
+      id,
+      method,
+      params
+    };
+
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(id, { resolve, reject });
+      this.process.stdin.write(JSON.stringify(request) + '\n');
+    });
+  }
+
+  close() {
+    this.rl.close();
+    this.process.kill();
+  }
+}
+
+async function main() {
+  const apiKey = process.env.SOCKET_API_KEY;
+  if (!apiKey) {
+    console.error('Error: SOCKET_API_KEY environment variable is required');
+    process.exit(1);
+  }
+
+  console.log('Starting MCP server debug client...');
+  
+  const client = new SimpleJSONRPCClient('./build/index.js', [], {
+    SOCKET_API_KEY: apiKey
+  });
+
+  try {
+    // Initialize the connection
+    console.log('\n1. Initializing connection...');
+    const initResult = await client.sendRequest('initialize', {
+      protocolVersion: '0.1.0',
+      capabilities: {},
+      clientInfo: {
+        name: 'debug-client',
+        version: '1.0.0'
+      }
+    });
+    console.log('Initialize response:', JSON.stringify(initResult, null, 2));
+
+    // List available tools
+    console.log('\n2. Listing available tools...');
+    const toolsResult = await client.sendRequest('tools/list', {});
+    console.log('Available tools:', JSON.stringify(toolsResult, null, 2));
+
+    // Call the depscore tool
+    console.log('\n3. Calling depscore tool...');
+    const depscoreResult = await client.sendRequest('tools/call', {
+      name: 'depscore',
+      arguments: {
+        packages: [
+          { depname: 'express', ecosystem: 'npm', version: '5.0.1' },
+          { depname: 'lodash', ecosystem: 'npm', version: '4.17.21' },
+          { depname: 'react', ecosystem: 'npm', version: '18.2.0' },
+          { depname: 'flask', ecosystem: 'pypi', version: '2.3.2' },
+          { depname: 'unknown-package', ecosystem: 'npm', version: 'unknown' }
+        ]
+      }
+    });
+    console.log('Depscore result:', JSON.stringify(depscoreResult, null, 2));
+
+    // Test with minimal input
+    console.log('\n4. Testing with minimal input (default to npm)...');
+    const minimalResult = await client.sendRequest('tools/call', {
+      name: 'depscore',
+      arguments: {
+        packages: [
+          { depname: 'axios' },
+          { depname: 'typescript' }
+        ]
+      }
+    });
+    console.log('Minimal input result:', JSON.stringify(minimalResult, null, 2));
+
+    // Test error handling
+    console.log('\n5. Testing error handling (empty packages)...');
+    try {
+      await client.sendRequest('tools/call', {
+        name: 'depscore',
+        arguments: {
+          packages: []
+        }
+      });
+    } catch (error) {
+      console.log('Expected error:', error);
+    }
+
+    console.log('\nDebug session complete!');
+  } catch (error) {
+    console.error('Client error:', error);
+  } finally {
+    client.close();
+  }
+}
+
+main().catch(console.error);