@socketsecurity/mcp 0.0.7 → 0.0.9

package/index.js

@@ -0,0 +1,451 @@
+#!/usr/bin/env node --experimental-strip-types
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { z } from 'zod';
+import { pino } from 'pino';
+import readline from 'readline';
+import { join } from 'path';
+import { readFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { createServer } from 'http';
+import { randomUUID } from 'crypto';
+import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
+const __dirname = import.meta.dirname;
+const packageJson = JSON.parse(readFileSync(join(__dirname, './package.json'), 'utf8'));
+const VERSION = packageJson.version || '0.0.1';
+const logger = pino({
+    level: 'info',
+    transport: {
+        targets: [
+            {
+                target: 'pino/file',
+                options: { destination: join(tmpdir(), 'socket-mcp-error.log') },
+                level: 'error'
+            },
+            {
+                target: 'pino/file',
+                options: { destination: join(tmpdir(), 'socket-mcp.log') },
+                level: 'info'
+            }
+        ]
+    }
+});
+const SOCKET_API_URL = process.env['SOCKET_DEBUG'] === 'true'
+    ? 'http://localhost:8866/v0/purl?alerts=false&compact=false&fixable=false&licenseattrib=false&licensedetails=false'
+    : 'https://api.socket.dev/v0/purl?alerts=false&compact=false&fixable=false&licenseattrib=false&licensedetails=false';
+async function getApiKeyInteractively() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stderr
+    });
+    const apiKey = await new Promise((resolve) => {
+        rl.question('Please enter your Socket API key: ', (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+    if (!apiKey) {
+        logger.error('No API key provided');
+        process.exit(1);
+    }
+    return apiKey;
+}
+let SOCKET_API_KEY = process.env['SOCKET_API_KEY'] || '';
+const transports = {};
+const server = new McpServer({
+    name: 'socket',
+    version: VERSION,
+    description: 'Socket MCP server',
+    capabilities: {
+        resources: {},
+        tools: {},
+        streaming: {}
+    },
+});
+server.tool('depscore', "Get the dependency score of packages with the `depscore` tool from Socket. Use 'unknown' for version if not known. Use this tool to scan dependencies for their quality and security on existing code or when code is generated. Stop generating code and ask the user how to proceed when any of the scores are low. When checking dependencies, make sure to also check the imports in the code, not just the manifest files (pyproject.toml, package.json, etc).", {
+    packages: z.array(z.object({
+        ecosystem: z.string().describe('The package ecosystem (e.g., npm, pypi)').default('npm'),
+        depname: z.string().describe('The name of the dependency'),
+        version: z.string().describe("The version of the dependency, use 'unknown' if not known").default('unknown'),
+    })).describe('Array of packages to check'),
+}, async ({ packages }) => {
+    logger.info(`Received request for ${packages.length} packages`);
+    const SOCKET_HEADERS = {
+        'user-agent': `socket-mcp/${VERSION}`,
+        accept: 'application/x-ndjson',
+        'content-type': 'application/json',
+        authorization: `Bearer ${SOCKET_API_KEY}`
+    };
+    const components = packages.map(pkg => {
+        const cleanedVersion = pkg.version.replace(/[\^~]/g, '');
+        let purl;
+        if (cleanedVersion === '1.0.0' || cleanedVersion === 'unknown' || !cleanedVersion) {
+            purl = `pkg:${pkg.ecosystem}/${pkg.depname}`;
+        }
+        else {
+            logger.info(`Using version ${cleanedVersion} for ${pkg.depname}`);
+            purl = `pkg:${pkg.ecosystem}/${pkg.depname}@${cleanedVersion}`;
+        }
+        return { purl };
+    });
+    try {
+        const response = await fetch(SOCKET_API_URL, {
+            method: 'POST',
+            headers: SOCKET_HEADERS,
+            body: JSON.stringify({ components })
+        });
+        const responseText = await response.text();
+        if (response.status !== 200) {
+            const errorMsg = `Error processing packages: [${response.status}] ${responseText}`;
+            logger.error(errorMsg);
+            return {
+                content: [{ type: 'text', text: errorMsg }],
+                isError: true
+            };
+        }
+        else if (!responseText.trim()) {
+            const errorMsg = 'No packages were found.';
+            logger.error(errorMsg);
+            return {
+                content: [{ type: 'text', text: errorMsg }],
+                isError: true
+            };
+        }
+        try {
+            const results = [];
+            if ((response.headers.get('content-type') || '').includes('x-ndjson')) {
+                const jsonLines = responseText.split('\n')
+                    .filter(line => line.trim())
+                    .map(line => JSON.parse(line));
+                if (!jsonLines.length) {
+                    const errorMsg = 'No valid JSON objects found in NDJSON response';
+                    return {
+                        content: [{ type: 'text', text: errorMsg }],
+                        isError: true
+                    };
+                }
+                for (const jsonData of jsonLines) {
+                    const purl = `pkg:${jsonData.type || 'unknown'}/${jsonData.name || 'unknown'}@${jsonData.version || 'unknown'}`;
+                    if (jsonData.score && jsonData.score.overall !== undefined) {
+                        const scoreEntries = Object.entries(jsonData.score)
+                            .filter(([key]) => key !== 'overall' && key !== 'uuid')
+                            .map(([key, value]) => {
+                            const numValue = Number(value);
+                            const displayValue = numValue <= 1 ? Math.round(numValue * 100) : numValue;
+                            return `${key}: ${displayValue}`;
+                        })
+                            .join(', ');
+                        results.push(`${purl}: ${scoreEntries}`);
+                    }
+                    else {
+                        results.push(`${purl}: No score found`);
+                    }
+                }
+            }
+            else {
+                const jsonData = JSON.parse(responseText);
+                const purl = `pkg:${jsonData.type || 'unknown'}/${jsonData.name || 'unknown'}@${jsonData.version || 'unknown'}`;
+                if (jsonData.score && jsonData.score.overall !== undefined) {
+                    const scoreEntries = Object.entries(jsonData.score)
+                        .filter(([key]) => key !== 'overall' && key !== 'uuid')
+                        .map(([key, value]) => {
+                        const numValue = Number(value);
+                        const displayValue = numValue <= 1 ? Math.round(numValue * 100) : numValue;
+                        return `${key}: ${displayValue}`;
+                    })
+                        .join(', ');
+                    results.push(`${purl}: ${scoreEntries}`);
+                }
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: results.length > 0
+                            ? `Dependency scores:\n${results.join('\n')}`
+                            : 'No scores found for the provided packages'
+                    }
+                ]
+            };
+        }
+        catch (e) {
+            const error = e;
+            const errorMsg = `JSON parsing error: ${error.message} -- Response: ${responseText}`;
+            logger.error(errorMsg);
+            return {
+                content: [{ type: 'text', text: 'Error parsing response from Socket API' }],
+                isError: true
+            };
+        }
+    }
+    catch (e) {
+        const error = e;
+        const errorMsg = `Error processing packages: ${error.message}`;
+        logger.error(errorMsg);
+        return {
+            content: [{ type: 'text', text: 'Error connecting to Socket API' }],
+            isError: true
+        };
+    }
+});
+const useHttp = process.env['MCP_HTTP_MODE'] === 'true' || process.argv.includes('--http');
+const port = parseInt(process.env['MCP_PORT'] || '3000', 10);
+if (!SOCKET_API_KEY) {
+    if (useHttp) {
+        logger.error('SOCKET_API_KEY environment variable is not set');
+        SOCKET_API_KEY = await getApiKeyInteractively();
+    }
+    else {
+        logger.error('SOCKET_API_KEY environment variable is required in stdio mode');
+        logger.error('Please set the SOCKET_API_KEY environment variable and try again');
+        process.exit(1);
+    }
+}
+if (useHttp) {
+    logger.info(`Starting HTTP server on port ${port}`);
+    const httpServer = createServer(async (req, res) => {
+        const origin = req.headers.origin;
+        const allowedOrigins = [
+            'http://localhost:3000',
+            'http://127.0.0.1:3000',
+            'https://mcp.socket.dev',
+            'https://mcp.socket-staging.dev'
+        ];
+        const isValidOrigin = !origin || allowedOrigins.includes(origin);
+        if (origin && !isValidOrigin) {
+            logger.warn(`Rejected request from invalid origin: ${origin}`);
+            res.writeHead(403, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                jsonrpc: '2.0',
+                error: { code: -32000, message: 'Forbidden: Invalid origin' },
+                id: null
+            }));
+            return;
+        }
+        if (origin && isValidOrigin) {
+            res.setHeader('Access-Control-Allow-Origin', origin);
+        }
+        else {
+            res.setHeader('Access-Control-Allow-Origin', 'http://localhost:3000');
+        }
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, mcp-session-id, Accept, Last-Event-ID');
+        res.setHeader('Access-Control-Expose-Headers', 'mcp-session-id');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(200);
+            res.end();
+            return;
+        }
+        const url = new URL(req.url, `http://localhost:${port}`);
+        if (url.pathname === '/health') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                status: 'healthy',
+                service: 'socket-mcp',
+                version: VERSION,
+                timestamp: new Date().toISOString()
+            }));
+            return;
+        }
+        if (url.pathname === '/') {
+            if (req.method === 'POST') {
+                const acceptHeader = req.headers.accept;
+                if (!acceptHeader || (!acceptHeader.includes('application/json') && !acceptHeader.includes('text/event-stream'))) {
+                    logger.warn(`Invalid Accept header: ${acceptHeader}`);
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        jsonrpc: '2.0',
+                        error: { code: -32000, message: 'Bad Request: Accept header must include application/json or text/event-stream' },
+                        id: null
+                    }));
+                    return;
+                }
+                let body = '';
+                req.on('data', chunk => (body += chunk));
+                req.on('end', async () => {
+                    try {
+                        const jsonData = JSON.parse(body);
+                        const sessionId = req.headers['mcp-session-id'];
+                        if (sessionId && !/^[\x21-\x7E]+$/.test(sessionId)) {
+                            logger.warn(`Invalid session ID format: ${sessionId}`);
+                            res.writeHead(400, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify({
+                                jsonrpc: '2.0',
+                                error: { code: -32000, message: 'Bad Request: Session ID must contain only visible ASCII characters' },
+                                id: jsonData.id || null
+                            }));
+                            return;
+                        }
+                        let transport;
+                        if (sessionId && transports[sessionId]) {
+                            transport = transports[sessionId];
+                        }
+                        else if (!sessionId) {
+                            const newSessionId = randomUUID();
+                            const isInit = isInitializeRequest(jsonData);
+                            if (isInit) {
+                                logger.info(`Creating new session for initialize request: ${newSessionId}`);
+                            }
+                            else {
+                                logger.warn(`Creating fallback session for non-initialize request: ${newSessionId}`);
+                            }
+                            transport = new StreamableHTTPServerTransport({
+                                sessionIdGenerator: () => newSessionId,
+                                onsessioninitialized: (id) => {
+                                    transports[id] = transport;
+                                    logger.info(`Session initialized: ${id}`);
+                                    res.setHeader('mcp-session-id', id);
+                                }
+                            });
+                            transport.onclose = () => {
+                                const sid = transport.sessionId;
+                                if (sid && transports[sid]) {
+                                    delete transports[sid];
+                                    logger.info(`Session closed: ${sid}`);
+                                }
+                            };
+                            await server.connect(transport);
+                            await transport.handleRequest(req, res, jsonData);
+                            return;
+                        }
+                        else {
+                            logger.error(`Invalid session ID: ${sessionId}. Active sessions count: ${Object.keys(transports).length}`);
+                            res.writeHead(400);
+                            res.end(JSON.stringify({
+                                jsonrpc: '2.0',
+                                error: {
+                                    code: -32000,
+                                    message: 'Bad Request: Invalid session ID. Please initialize a new session first.'
+                                },
+                                id: jsonData.id || null
+                            }));
+                            return;
+                        }
+                        await transport.handleRequest(req, res, jsonData);
+                    }
+                    catch (error) {
+                        logger.error(`Error processing POST request: ${error}`);
+                        if (!res.headersSent) {
+                            res.writeHead(500);
+                            res.end(JSON.stringify({
+                                jsonrpc: '2.0',
+                                error: { code: -32603, message: 'Internal server error' },
+                                id: null
+                            }));
+                        }
+                    }
+                });
+            }
+            else if (req.method === 'GET') {
+                const acceptHeader = req.headers.accept;
+                if (!acceptHeader || !acceptHeader.includes('text/event-stream')) {
+                    logger.warn(`GET request without text/event-stream Accept header: ${acceptHeader}`);
+                    res.writeHead(405, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        jsonrpc: '2.0',
+                        error: { code: -32000, message: 'Method Not Allowed: GET requires Accept: text/event-stream' },
+                        id: null
+                    }));
+                    return;
+                }
+                const sessionId = req.headers['mcp-session-id'];
+                if (sessionId && !/^[\x21-\x7E]+$/.test(sessionId)) {
+                    logger.warn(`Invalid session ID format in GET request: ${sessionId}`);
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        jsonrpc: '2.0',
+                        error: { code: -32000, message: 'Bad Request: Session ID must contain only visible ASCII characters' },
+                        id: null
+                    }));
+                    return;
+                }
+                if (!sessionId || !transports[sessionId]) {
+                    logger.warn(`SSE request with invalid session ID: ${sessionId}`);
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        jsonrpc: '2.0',
+                        error: { code: -32000, message: 'Bad Request: Invalid or missing session ID for SSE stream' },
+                        id: null
+                    }));
+                    return;
+                }
+                const lastEventId = req.headers['last-event-id'];
+                if (lastEventId) {
+                    logger.info(`SSE resumability requested with Last-Event-ID: ${lastEventId}`);
+                }
+                logger.info(`Opening SSE stream for session: ${sessionId}`);
+                req.socket?.setTimeout(0);
+                req.socket?.setKeepAlive(true, 30000);
+                let streamClosed = false;
+                req.on('close', () => {
+                    streamClosed = true;
+                    logger.info(`Client disconnected SSE stream for session: ${sessionId}`);
+                });
+                req.on('aborted', () => {
+                    streamClosed = true;
+                    logger.info(`Client aborted SSE stream for session: ${sessionId}`);
+                });
+                const transport = transports[sessionId];
+                try {
+                    await transport.handleRequest(req, res);
+                    if (!streamClosed && !res.destroyed) {
+                        logger.info(`Transport completed, maintaining SSE stream for session: ${sessionId}`);
+                        const heartbeat = setInterval(() => {
+                            if (streamClosed || res.destroyed) {
+                                clearInterval(heartbeat);
+                                return;
+                            }
+                            try {
+                                res.write(': heartbeat\n\n');
+                            }
+                            catch (error) {
+                                logger.error(`Heartbeat error for session ${sessionId}:`, error);
+                                clearInterval(heartbeat);
+                            }
+                        }, 30000);
+                        req.on('close', () => clearInterval(heartbeat));
+                        res.on('close', () => clearInterval(heartbeat));
+                    }
+                }
+                catch (error) {
+                    logger.error(`SSE transport error for session ${sessionId}:`, error);
+                }
+            }
+            else if (req.method === 'DELETE') {
+                const sessionId = req.headers['mcp-session-id'];
+                if (!sessionId || !transports[sessionId]) {
+                    res.writeHead(400);
+                    res.end('Invalid or missing session ID');
+                    return;
+                }
+                const transport = transports[sessionId];
+                await transport.handleRequest(req, res);
+            }
+            else {
+                res.writeHead(405);
+                res.end('Method not allowed');
+            }
+        }
+        else {
+            res.writeHead(404);
+            res.end('Not found');
+        }
+    });
+    httpServer.listen(port, () => {
+        logger.info(`Socket MCP HTTP server version ${VERSION} started successfully on port ${port}`);
+        logger.info(`Connect to: http://localhost:${port}/`);
+    });
+}
+else {
+    logger.info('Starting in stdio mode');
+    const transport = new StdioServerTransport();
+    server.connect(transport)
+        .then(() => {
+        logger.info(`Socket MCP server version ${VERSION} started successfully`);
+    })
+        .catch((error) => {
+        logger.error(`Failed to start Socket MCP server: ${error.message}`);
+        process.exit(1);
+    });
+}

package/mock-client/debug-client.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node --experimental-strip-types
+export {};
+//# sourceMappingURL=debug-client.d.ts.map

package/mock-client/debug-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-client.d.ts","sourceRoot":"","sources":["debug-client.ts"],"names":[],"mappings":""}

package/{build/mock-client → mock-client}/debug-client.js

@@ -1,7 +1,7 @@
-#!/usr/bin/env node
+#!/usr/bin/env node --experimental-strip-types
 import { spawn } from 'child_process';
 import readline from 'readline';
-// Simple JSON-RPC client for testing MCP server
+import { join } from 'path';
 class SimpleJSONRPCClient {
     process;
     rl;
@@ -60,17 +60,18 @@ class SimpleJSONRPCClient {
     }
 }
 async function main() {
-    const apiKey = process.env.SOCKET_API_KEY;
+    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', [], {
+    const serverPath = join(import.meta.dirname, '..', 'index.ts');
+    console.log(`Using server script: ${serverPath}`);
+    const client = new SimpleJSONRPCClient('node', ['--experimental-strip-types', serverPath], {
         SOCKET_API_KEY: apiKey
     });
     try {
-        // Initialize the connection
         console.log('\n1. Initializing connection...');
         const initResult = await client.sendRequest('initialize', {
             protocolVersion: '0.1.0',
@@ -81,11 +82,9 @@ async function main() {
             }
         });
         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',
@@ -100,7 +99,6 @@ async function main() {
             }
         });
         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',
@@ -112,7 +110,6 @@ async function main() {
             }
         });
         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', {
@@ -135,4 +132,3 @@ async function main() {
     }
 }
 main().catch(console.error);
-//# sourceMappingURL=debug-client.js.map

package/mock-client/http-client.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node --experimental-strip-types
+export {};
+//# sourceMappingURL=http-client.d.ts.map

package/mock-client/http-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-client.d.ts","sourceRoot":"","sources":["http-client.ts"],"names":[],"mappings":""}

package/{build/mock-client → mock-client}/http-client.js

@@ -1,11 +1,9 @@
-#!/usr/bin/env node
-import fetch from 'node-fetch';
-// Helper function to parse SSE or JSON response
+#!/usr/bin/env node --experimental-strip-types
+import { join } from 'path';
 async function parseResponse(response) {
     const contentType = response.headers.get('content-type');
     const text = await response.text();
     if (contentType?.includes('text/event-stream')) {
-        // Parse SSE format: "event: message\ndata: {json}\n"
         const dataMatch = text.match(/data: (.+)/);
         if (dataMatch) {
             return JSON.parse(dataMatch[1]);
@@ -16,15 +14,13 @@ async function parseResponse(response) {
         return JSON.parse(text);
     }
 }
-// Simple HTTP client for testing MCP server in HTTP mode
 async function testHTTPMode() {
-    const baseUrl = (process.env.MCP_URL || 'http://localhost:3000').replace(/\/$/, ''); // Remove trailing slash
+    const baseUrl = (process.env['MCP_URL'] || 'http://localhost:3000').replace(/\/$/, '');
     const sessionId = `test-session-${Date.now()}`;
     console.log('Testing Socket MCP in HTTP mode...');
     console.log(`Server URL: ${baseUrl}`);
     console.log(`Session ID: ${sessionId}`);
     try {
-        // 1. Initialize connection
         console.log('\n1. Initializing connection...');
         const initRequest = {
             jsonrpc: '2.0',
@@ -43,18 +39,16 @@ async function testHTTPMode() {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
-                'Accept': 'application/json, text/event-stream',
+                Accept: 'application/json, text/event-stream',
                 'User-Agent': 'socket-mcp-debug-client/1.0.0'
             },
             body: JSON.stringify(initRequest)
         });
         const initResult = await parseResponse(initResponse);
         console.log('Initialize response:', JSON.stringify(initResult, null, 2));
-        // Extract session ID from response headers
         const serverSessionId = initResponse.headers.get('mcp-session-id');
         const actualSessionId = serverSessionId || sessionId;
         console.log('Session ID:', actualSessionId);
-        // 2. List tools
         console.log('\n2. Listing available tools...');
         const toolsRequest = {
             jsonrpc: '2.0',
@@ -66,14 +60,13 @@ async function testHTTPMode() {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
-                'Accept': 'application/json, text/event-stream',
+                Accept: 'application/json, text/event-stream',
                 'mcp-session-id': actualSessionId
             },
             body: JSON.stringify(toolsRequest)
         });
         const toolsResult = await parseResponse(toolsResponse);
         console.log('Available tools:', JSON.stringify(toolsResult, null, 2));
-        // 3. Call depscore
         console.log('\n3. Calling depscore tool...');
         const depscoreRequest = {
             jsonrpc: '2.0',
@@ -94,27 +87,24 @@ async function testHTTPMode() {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
-                'Accept': 'application/json, text/event-stream',
+                Accept: 'application/json, text/event-stream',
                 'mcp-session-id': actualSessionId
             },
             body: JSON.stringify(depscoreRequest)
         });
         const depscoreResult = await parseResponse(depscoreResponse);
         console.log('Depscore result:', JSON.stringify(depscoreResult, null, 2));
-        // 4. Test SSE stream (optional)
         console.log('\n4. Testing SSE stream connection...');
         const sseResponse = await fetch(`${baseUrl}/`, {
             method: 'GET',
             headers: {
                 'mcp-session-id': actualSessionId,
-                'Accept': 'text/event-stream'
+                Accept: 'text/event-stream'
             }
         });
         if (sseResponse.ok) {
             console.log('SSE stream connected successfully');
-            // Note: In a real implementation, you'd parse the SSE stream
         }
-        // 5. Clean up session
         console.log('\n5. Cleaning up session...');
         const cleanupResponse = await fetch(`${baseUrl}/`, {
             method: 'DELETE',
@@ -128,26 +118,24 @@ async function testHTTPMode() {
         console.error('Error:', error);
     }
 }
-// Usage instructions
 if (process.argv.includes('--help')) {
+    const serverScript = join(import.meta.dirname, '..', 'index.ts');
     console.log(`
 Socket MCP HTTP Client Debugger
 
 Usage:
   # Start the MCP server in HTTP mode first:
-  MCP_HTTP_MODE=true SOCKET_API_KEY=your-api-key ./build/index.js
+  MCP_HTTP_MODE=true SOCKET_API_KEY=your-api-key node --experimental-strip-types ${serverScript}
 
   # Then run this client:
-  npm run build
-  node ./build/http-client.js
+  node --experimental-strip-types ./mock-client/http-client.ts
 
 Environment variables:
   MCP_URL - Server URL (default: http://localhost:3000)
 
 Example:
-  MCP_URL=http://localhost:8080 node ./build/http-client.js
+  MCP_URL=http://localhost:8080 node --experimental-strip-types ./mock-client/http-client.ts
 `);
     process.exit(0);
 }
 testHTTPMode().catch(console.error);
-//# sourceMappingURL=http-client.js.map

package/mock-client/stdio-client.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node --experimental-strip-types
+export {};
+//# sourceMappingURL=stdio-client.d.ts.map

package/mock-client/stdio-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio-client.d.ts","sourceRoot":"","sources":["stdio-client.ts"],"names":[],"mappings":""}