JavaScript Executor MCP Server

Servidor MCP Executor de JavaScript

Este servidor MCP fornece capacidades de execução de JavaScript com um runtime moderno.

Recursos

A ferramenta executeJS fornece:

• API de Console: console.log(), console.error(), console.warn() (integrada)
• Servidor HTTP: serve() para criação de servidores (via require('http/server'))
• API Fetch: fetch() moderno com Request, Response, Headers, FormData (global)
• Temporizadores: setTimeout(), setInterval(), clearTimeout(), clearInterval() (global)
• Buffer: APIs Buffer, Blob, File para manipulação de dados binários (global)
• Criptografia: Funções criptográficas - hash, criptografia, HMAC (via require('crypto'))
• Cache: Cache em memória com suporte a TTL (via require('cache'))
• Módulos adicionais: encoding (global), url (global)

Começando

Instalação

Usando Go Install

go install github.com/mark3labs/codebench-mcp@latest

Uso

Como servidor autônomo

codebench-mcp

Com configuração de módulos

# Enable only specific modules
codebench-mcp --enabled-modules http,fetch

# Disable specific modules (enable all others)
codebench-mcp --disabled-modules timers

# Set custom execution timeout (in seconds)
codebench-mcp --execution-timeout 600  # 10 minutes

# Show help
codebench-mcp --help

Módulos disponíveis:

• http - Criação de servidor HTTP e requisições de cliente (require('http/server'))
• fetch - API fetch moderna com Request, Response, Headers, FormData (disponível globalmente)
• timers - setTimeout, setInterval, clearTimeout, clearInterval (disponível globalmente)
• buffer - APIs Buffer, Blob, File para manipulação de dados binários (disponível globalmente)
• cache - Cache em memória com suporte a TTL (require('cache'))
• crypto - Funções criptográficas (hash, criptografia, HMAC) (require('crypto'))
• encoding - TextEncoder, TextDecoder para codificação/decodificação de texto (disponível globalmente)
• url - APIs URL e URLSearchParams (disponível globalmente)

Todos os módulos estão habilitados por padrão. Você pode habilitar ou desabilitar módulos seletivamente usando flags de CLI.

Nota: A descrição da ferramenta executeJS é atualizada dinamicamente para mostrar apenas os módulos habilitados e inclui informações detalhadas sobre o que cada módulo fornece.

Como biblioteca no seu projeto Go

package main

import (
	"log"

	"github.com/mark3labs/codebench-mcp/server"
	"github.com/mark3labs/mcp-go/server"
)

func main() {
	// Create a new JavaScript executor server
	jss, err := server.NewJSServer()
	if err != nil {
		log.Fatalf("Failed to create server: %v", err)
	}

	// Serve requests
	if err := server.ServeStdio(jss); err != nil {
		log.Fatalf("Server error: %v", err)
	}
}

Usando InProcessTransport

package main

import (
	"context"
	"log"

	"github.com/mark3labs/codebench-mcp/server"
	"github.com/mark3labs/mcp-go/client"
	"github.com/mark3labs/mcp-go/mcp"
)

func main() {
	// Create the JS server with custom module configuration
	config := server.ModuleConfig{
		EnabledModules: []string{"fetch", "crypto", "buffer"},
	}
	jsServer, err := server.NewJSServerWithConfig(config)
	if err != nil {
		log.Fatalf("Failed to create server: %v", err)
	}

	// Create an in-process client
	mcpClient, err := client.NewInProcessClient(jsServer)
	if err != nil {
		log.Fatalf("Failed to create client: %v", err)
	}
	defer mcpClient.Close()

	// Start the client
	if err := mcpClient.Start(context.Background()); err != nil {
		log.Fatalf("Failed to start client: %v", err)
	}

	// Initialize the client
	initRequest := mcp.InitializeRequest{}
	initRequest.Params.ProtocolVersion = mcp.LATEST_PROTOCOL_VERSION
	initRequest.Params.ClientInfo = mcp.Implementation{
		Name:    "my-app",
		Version: "1.0.0",
	}
	_, err = mcpClient.Initialize(context.Background(), initRequest)
	if err != nil {
		log.Fatalf("Failed to initialize: %v", err)
	}

	// Execute JavaScript code
	callRequest := mcp.CallToolRequest{}
	callRequest.Params.Name = "executeJS"
	callRequest.Params.Arguments = map[string]any{
		"code": `
			console.log("Hello from JavaScript!");
			const result = Math.sqrt(16);
			console.log("Square root of 16 is:", result);
			result;
		`,
	}

	result, err := mcpClient.CallTool(context.Background(), callRequest)
	if err != nil {
		log.Fatalf("Failed to call tool: %v", err)
	}

	if result.IsError {
		log.Printf("JavaScript execution error: %v", result.Content)
	} else {
		log.Printf("JavaScript execution result: %v", result.Content)
	}
}

Uso com Model Context Protocol

Para integrar este servidor com aplicativos que suportam MCP:

{
  "mcpServers": {
    "javascript": {
      "command": "codebench-mcp"
    }
  }
}

Docker

Executando com Docker

Você pode executar o servidor MCP Executor de JavaScript usando Docker:

docker run -i --rm ghcr.io/mark3labs/codebench-mcp:latest

Configuração Docker com MCP

Para integrar a imagem Docker com aplicativos que suportam MCP:

{
  "mcpServers": {
    "javascript": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "ghcr.io/mark3labs/codebench-mcp:latest"
      ]
    }
  }
}

Referência da Ferramenta

executeJS

Execute código JavaScript com um ambiente de runtime moderno.

Parâmetros:

• code (obrigatório): Código JavaScript a ser executado

Configuração:

• Timeout de execução padrão: 5 minutos
• Configurável via flag de CLI --execution-timeout <seconds>

Exemplo:

console.log("Hello, World!");

// Basic JavaScript execution
const result = 2 + 3;
console.log('Result:', result);

// Fetch API (available globally when enabled)
const response = await fetch('https://api.example.com/data');
const data = await response.json();

// HTTP server (require import)
const serve = require('http/server');
serve(8000, async (req) => {
  return new Response('Hello World');
});

// Cache operations (require import)
const cache = require('cache');
cache.set('key', 'value');
console.log(cache.get('key'));

// Crypto operations (require import)
const crypto = require('crypto');
const hash = crypto.md5('hello').hex();
console.log('MD5 hash:', hash);

// Timers (available globally)
setTimeout(() => console.log('Hello after 1 second'), 1000);

// Buffer operations (available globally)
const buffer = Buffer.from('hello', 'utf8');
console.log(buffer.toString('base64'));

// URL operations (available globally)
const url = new URL('https://example.com/path?param=value');
console.log('Host:', url.host);
console.log('Pathname:', url.pathname);

Limitações

• Sem módulos fs ou process - APIs de sistema de arquivos e processos não estão disponíveis no runtime
• Acesso a módulos varia - Alguns módulos são globais (fetch, http), outros podem exigir require()
• Cada execução cria uma VM nova - Para isolamento, cada execução começa com um estado limpo
• Filtragem de módulos - A configuração existe, mas a filtragem real em runtime não está totalmente implementada
• Timeout de execução - A execução de JavaScript é limitada por timeout configurável (padrão: 5 minutos)

Compilação

go build -o codebench-mcp .

Licença

Consulte o arquivo LICENSE para detalhes.