dennisonbertram/mcp-debugger

# Clone the repository
git clone https://github.com/dennisonbertram/mcp-debugger.git
cd mcp-debugger

# Install dependencies
npm install

# Build the server
npm run build

# Or run directly with ts-node (development)
npm run dev

npm install -g https://github.com/dennisonbertram/mcp-debugger.git

{
  "mcp": {
    "servers": {
      "debugger": {
        "command": "mcp-debugger-server",
        "args": [],
        "env": {
          "WORKSPACE_DIR": "${workspaceFolder}"
        }
      }
    }
  }
}

# Add to package.json scripts
{
  "scripts": {
    "mcp-debugger": "node dist/index.js"
  }
}

{
  "cloudcode.mcp.enabled": true,
  "cloudcode.mcp.servers": {
    "debugger": {
      "command": "node",
      "args": ["${workspaceFolder}/node_modules/@dennisonbertram/mcp-debugger/dist/index.js"],
      "env": {
        "WORKSPACE_DIR": "${workspaceFolder}",
        "LOG_LEVEL": "info"
      }
    }
  }
}

# Deploy to MCP-Cloud (requires API key)
curl -X POST https://api.mcp-cloud.ai/v1/servers \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-debugger-server",
    "template": "custom",
    "env": {
      "WORKSPACE_DIR": "/app",
      "LOG_LEVEL": "info"
    }
  }'

FROM node:18-alpine

WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

COPY dist/ ./dist/
EXPOSE 3000

CMD ["node", "dist/index.js"]

# Build and run
docker build -t mcp-debugger .
docker run -p 3000:3000 -e WORKSPACE_DIR=/app mcp-debugger

# Set API key for MCP-Cloud
export MCP_API_KEY="mcp_sk_your_api_key_here"

import requests

def debug_with_mcp(prompt, session_id=None):
    url = "https://your-server.mcp-cloud.ai/v1/chat/completions"
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {os.environ['MCP_API_KEY']}"
    }

    data = {
        "model": "claude-3-5-sonnet",
        "messages": [{"role": "user", "content": prompt}],
        "context_id": session_id  # For maintaining debug context
    }

    response = requests.post(url, headers=headers, json=data)
    return response.json()

async function debugWithMCP(prompt, sessionId = null) {
  const response = await fetch('https://your-server.mcp-cloud.ai/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${process.env.MCP_API_KEY}`
    },
    body: JSON.stringify({
      model: 'claude-3-5-sonnet',
      messages: [{ role: 'user', content: prompt }],
      context_id: sessionId
    })
  });

  return response.json();
}

// Enable streaming for real-time debug output
const eventSource = new EventSource(
  'https://your-server.mcp-cloud.ai/api/servers/debug-session/events',
  {
    headers: {
      'Authorization': `Bearer ${process.env.MCP_API_KEY}`
    }
  }
);

eventSource.addEventListener('debug:output', (event) => {
  const data = JSON.parse(event.data);
  console.log('Debug output:', data.message);
});

eventSource.addEventListener('breakpoint:hit', (event) => {
  const data = JSON.parse(event.data);
  console.log('Breakpoint hit at line:', data.line);
});

// In an n8n Function node
const axios = require('axios');

async function debugCode(codeSnippet) {
  const response = await axios.post(
    'https://your-server.mcp-cloud.ai/v1/chat/completions',
    {
      model: "claude-3-5-sonnet",
      messages: [
        {
          role: "system",
          content: "You are a debugging assistant. Analyze the following code for issues."
        },
        {
          role: "user",
          content: codeSnippet
        }
      ],
      stream: true  // Enable streaming for real-time responses
    },
    {
      headers: {
        'Authorization': `Bearer ${$credentials.mcpApi.apiKey}`,
        'Content-Type': 'application/json'
      }
    }
  );

  return response.data;
}

# Workspace directory (defaults to current directory)
WORKSPACE_DIR=/path/to/your/project

# Enable/disable dangerous features
ALLOW_FILE_PATCHES=true
ALLOW_COMMAND_EXECUTION=false

# Limits and timeouts
MAX_EXECUTION_TIME_MS=30000
MAX_OUTPUT_BYTES=1048576

# Logging
LOG_LEVEL=info

# Production build
npm start

# Development with auto-reload
npm run dev

# With custom workspace
WORKSPACE_DIR=/my/project npm start

# Add to Claude Desktop config (one line)
echo '{"mcpServers":{"debugger":{"command":"node","args":["/path/to/mcp-debugger/dist/index.js"],"env":{"WORKSPACE_DIR":"'"$PWD"'"}}}}' >> ~/Library/Application\ Support/Claude/claude_desktop_config.json

# macOS/Linux
code ~/Library/Application\ Support/Claude/claude_desktop_config.json

# Windows
code %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "debugger": {
      "command": "node",
      "args": ["/path/to/mcp-debugger/dist/index.js"],
      "env": {
        "WORKSPACE_DIR": "/path/to/your/project"
      }
    }
  }
}

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

// Create MCP client
const client = new Client({
  name: "my-debug-client",
  version: "1.0.0"
});

// Connect to the debugger server
const transport = new StdioClientTransport({
  command: "node",
  args: ["dist/index.js"]
});

await client.connect(transport);
await client.initialize();

import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async def main():
    # Connect to MCP Debugger Server
    server_params = StdioServerParameters(
        command="node",
        args=["/path/to/mcp-debugger/dist/index.js"],
        env={"WORKSPACE_DIR": "/your/project"}
    )

    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()

            # Use debugging tools
            result = await session.call_tool("open_debug_session", {
                "kind": "node",
                "entry": "app.js"
            })

            print("Debug session opened:", result)

asyncio.run(main())

import io.modelcontextprotocol.client.McpClient;
import io.modelcontextprotocol.client.transport.StdioClientTransport;

public class DebugClient {
    public static void main(String[] args) {
        // Create MCP client
        McpClient client = McpClient.builder()
            .name("Debug Client")
            .version("1.0.0")
            .build();

        // Connect via stdio
        StdioClientTransport transport = new StdioClientTransport(
            "node",
            List.of("/path/to/mcp-debugger/dist/index.js")
        );

        client.connect(transport);

        // Use debugging capabilities
        ToolResult result = client.callTool("open_debug_session",
            Map.of("kind", "node", "entry", "app.js"));

        System.out.println("Debug session: " + result);
    }
}

# Test server health
curl -X POST http://localhost:3000/health

# Test MCP protocol (if using HTTP transport)
curl -X POST http://localhost:3000/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"initialize","params":{"protocolVersion":"2025-06-18"},"id":1}'

const result = await client.callTool({
  name: "open_debug_session",
  arguments: {
    kind: "node",
    entry: "src/index.js",
    args: ["--port", "3000"]
  }
});
const sessionId = result.content[0].text.session_id;

await client.callTool({
  name: "set_breakpoint",
  arguments: {
    session_id: sessionId,
    file: "src/server.js",
    line: 42,
    condition: "user.id > 0"
  }
});

// Get stack trace
const stack = await client.callTool({
  name: "stack_trace",
  arguments: { session_id: sessionId }
});

// Evaluate expressions
const result = await client.callTool({
  name: "evaluate_expression",
  arguments: {
    session_id: sessionId,
    expression: "user.profile",
    frame_id: "frame_0"
  }
});

// Apply a patch (will require confirmation)
await client.callTool({
  name: "apply_patch",
  arguments: {
    file: "src/buggy.js",
    start: 41,
    end: 43,
    replacement: "if (user && user.id > 0) {",
    require_confirmation: true
  }
});

const testResult = await client.callTool({
  name: "run_tests",
  arguments: {
    runner: "npm",
    args: ["test", "--", "--grep", "user"]
  }
});

class MyRuntimeAdapter implements DebuggerAdapter {
  // Implement required methods
  async launch(entry: string, args?: string[], env?: Record<string, string>): Promise<void> {
    // Start your runtime's debugger
  }

  async setBreakpoint(bp: Breakpoint): Promise<Breakpoint> {
    // Set breakpoint in your runtime
  }

  // ... other required methods
}

if (args.kind === 'myruntime') {
  adapter = new MyRuntimeAdapter(cwd);
}

export class MyCustomTool {
  registerTools(server: McpServer): void {
    server.registerTool("my_custom_tool", {
      // Tool definition
    }, this.handleMyCustomTool.bind(this));
  }

  private async handleMyCustomTool(args: any): Promise<MCPToolResult> {
    // Tool implementation
  }
}

this.myCustomTool = new MyCustomTool(config);
this.myCustomTool.registerTools(this.server);