CharlieDigital/runjs

This project contains an MCP server that can execute JavaScript safely in an isolated sandbox and return a result from the script. It is equipped with a fetch analogue implemented using System.Net.HttpClient that allows your generated JavaScript to make web requests as well as JSONPath to manipulate the results 😎. A web API is also provided to store secrets securely so that API calls using API keys can be used. With this MCP server, you can basically interact with any REST API.
## Key Features
Integrated secrets manager to securely store encrypted API keys
Sandboxed JavaScript execution without infrastructure (e.g. deploy a container or serverless function)
Pre-loaded with a fetch analogue for making HTTP requests
Pre-loaded with jsonpath-plus to process JSON payloads
Integrated resilience pipeline (via Polly) for retries on HTTP requests
shell
# To test locally
docker pull cdigs/runjs-mcp-server
# Other options can also be set via ENV
docker run -p 5000:8080 \
-e RunJSConfigJintLimitMemory=10000000 \
-e RunJSConfigJintTimeoutIntervalSeconds=30 \
cdigs/runjs-mcp-server
# The default secret storage is ephemeral and disappears when
# the container restarts. For persistent storage, set the
# connection string and flip it to use the database (see below).
The RunJS MCP server uses Jint -- a C# library that embeds a JavaScript runtime into .NET and allows controlling the execution sandbox by specifying:
Memory limits
Number of statements
Runtime
Depth of calls (recursion)
This is extremely powerful as in many cases, you may want to run JavaScript, but doing it safely is challenging because of the nature of JavaScript and generated code. Because the generated JavaScript is run in a C# interpreter, there's no chance of leaking environment variables, no chance of malicious packages, no chance of the JS crashing the server process.
Using this mechanism can unlock a lot of use cases where JavaScript is needed to process some JSON, for example, and return text or run some transformation logic on incoming data.
Here's an example call using the Vercel AI SDK:
typescript
const mcpClient = await createMCPClient({
transport: {
type: "sse",
url: "http://localhost:5000/sse",
},
});
const tools = await mcpClient.tools();
const prompt =
Generate and execute JavaScript that can parse the following JSON
The JavaScript should 'return' the value
Return only the value of the name property:
{ "id": 12345, "name": "Charles Chen", "handle": "chrlschn" }
try {
const { text } = await generateText({
model: openai("gpt-4.1-nano"),
prompt,
tools,
maxSteps: 10, // 👈 Very, very important or you get no output!
});
console.log("Output:", text);
} finally {
await mcpClient.close();
The LLM will generate the following JavaScript:
javascript
const jsonString = '{ "id": 12345, "name": "Charles Chen", "handle": "chrlschn" }';
const obj = JSON.parse(jsonString);
return obj.name;
And use the RunJS MCP server to execute it 🚀
## Architecture and Flow
The diagram above provides an overview of the architecture and flow.
1. A web API exposes a Secrets Manager to securely store secrets so that they are not exposed to the LLM. The LLM refers to the secrets by ID and they are replaced at the point of executing the API call with the actual value.