JavaScript Executor MCP Server

Servidor MCP de Ejecución de JavaScript

Este servidor MCP proporciona capacidades de ejecución de JavaScript con un runtime moderno.

Características

La herramienta executeJS proporciona:

• API de Consola: console.log(), console.error(), console.warn() (incorporado)
• Servidor HTTP: serve() para la creación de servidores (a través de require('http/server'))
• API Fetch: fetch() moderno con Request, Response, Headers, FormData (global)
• Temporizadores: setTimeout(), setInterval(), clearTimeout(), clearInterval() (global)
• Buffer: APIs de Buffer, Blob, File para el manejo de datos binarios (global)
• Criptografía: Funciones criptográficas - hash, cifrado, HMAC (a través de require('crypto'))
• Caché: Caché en memoria con soporte TTL (a través de require('cache'))
• Módulos adicionales: codificación (global), url (global)

Comenzando

Instalación

Usando Go Install

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

Uso

Como servidor independiente

codebench-mcp

Con configuración 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 disponibles:

• http - Creación de servidores HTTP y solicitudes de cliente (require('http/server'))
• fetch - API fetch moderna con Request, Response, Headers, FormData (disponible globalmente)
• timers - setTimeout, setInterval, clearTimeout, clearInterval (disponible globalmente)
• buffer - APIs de Buffer, Blob, File para el manejo de datos binarios (disponible globalmente)
• cache - Caché en memoria con soporte TTL (require('cache'))
• crypto - Funciones criptográficas (hash, cifrado, HMAC) (require('crypto'))
• encoding - TextEncoder, TextDecoder para codificación/decodificación de texto (disponible globalmente)
• url - APIs de URL y URLSearchParams (disponible globalmente)

Todos los módulos están habilitados por defecto. Puedes habilitar o deshabilitar módulos selectivamente usando banderas de CLI.

Nota: La descripción de la herramienta executeJS se actualiza dinámicamente para mostrar solo los módulos habilitados e incluye información detallada sobre lo que proporciona cada módulo.

Como biblioteca en tu proyecto 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 con Model Context Protocol

Para integrar este servidor con aplicaciones que soporten MCP:

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

Docker

Ejecutando con Docker

Puedes ejecutar el servidor MCP de Ejecución de JavaScript usando Docker:

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

Configuración de Docker con MCP

Para integrar la imagen de Docker con aplicaciones que soporten MCP:

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

Referencia de Herramientas

executeJS

Ejecuta código JavaScript con un entorno de runtime moderno.

Parámetros:

• code (requerido): Código JavaScript a ejecutar

Configuración:

• Tiempo de espera de ejecución predeterminado: 5 minutos
• Configurable a través de la bandera de CLI --execution-timeout <seconds>

Ejemplo:

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);

Limitaciones

• Sin módulos fs o process - Las APIs de sistema de archivos y procesos no están disponibles en el runtime
• El acceso a módulos varía - Algunos módulos son globales (fetch, http), otros pueden requerir require()
• Cada ejecución crea una VM nueva - Para aislamiento, cada ejecución comienza con un estado limpio
• Filtrado de módulos - La configuración existe pero el filtrado real del runtime no está completamente implementado
• Tiempo de espera de ejecución - La ejecución de JavaScript está limitada por un tiempo de espera configurable (predeterminado: 5 minutos)

Compilación

go build -o codebench-mcp .

Licencia

Consulta el archivo LICENSE para más detalles.