index.ts

#!/usr/bin/env node

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
import { spawn } from "child_process";
import { writeFileSync, unlinkSync, mkdtempSync } from "fs";
import { join } from "path";
import { tmpdir } from "os";

interface ExecutionResult {
  success: boolean;
  output?: string;
  error?: string;
  executionTime?: number;
}

class CodeExecutor {
  private tempDir: string;

  constructor() {
    // Create a temporary directory for code execution
    this.tempDir = mkdtempSync(join(tmpdir(), "qcode-"));
  }

  async executeJavaScript(
    code: string,
    timeout: number = 30000
  ): Promise<ExecutionResult> {
    const startTime = Date.now();

    try {
      // Create a temporary file with the code
      const tempFile = join(this.tempDir, `code_${Date.now()}.js`);
      writeFileSync(tempFile, code, "utf8");

      return new Promise((resolve) => {
        let output = "";
        let error = "";
        let hasResolved = false;

        // Set up timeout
        const timeoutId = setTimeout(() => {
          if (!hasResolved) {
            hasResolved = true;
            try {
              unlinkSync(tempFile);
            } catch (e) {
              // Ignore cleanup errors
            }
            resolve({
              success: false,
              error: `Execution timed out after ${timeout}ms`,
              executionTime: Date.now() - startTime,
            });
          }
        }, timeout);

        // Execute the code using Node.js
        const child = spawn("node", [tempFile], {
          cwd: this.tempDir,
          stdio: ["pipe", "pipe", "pipe"],
          timeout: timeout,
        });

        // Capture stdout
        child.stdout.on("data", (data) => {
          output += data.toString();
        });

        // Capture stderr
        child.stderr.on("data", (data) => {
          error += data.toString();
        });

        // Handle process completion
        child.on("close", (code) => {
          if (!hasResolved) {
            hasResolved = true;
            clearTimeout(timeoutId);

            try {
              unlinkSync(tempFile);
            } catch (e) {
              // Ignore cleanup errors
            }

            const executionTime = Date.now() - startTime;

            if (code === 0) {
              resolve({
                success: true,
                output: output.trim(),
                executionTime,
              });
            } else {
              resolve({
                success: false,
                output: output.trim(),
                error: error.trim() || `Process exited with code ${code}`,
                executionTime,
              });
            }
          }
        });

        // Handle process errors
        child.on("error", (err) => {
          if (!hasResolved) {
            hasResolved = true;
            clearTimeout(timeoutId);

            try {
              unlinkSync(tempFile);
            } catch (e) {
              // Ignore cleanup errors
            }

            resolve({
              success: false,
              error: `Failed to execute code: ${err.message}`,
              executionTime: Date.now() - startTime,
            });
          }
        });
      });
    } catch (err) {
      return {
        success: false,
        error: `Failed to prepare code execution: ${
          err instanceof Error ? err.message : String(err)
        }`,
        executionTime: Date.now() - startTime,
      };
    }
  }
}

// Create the code executor instance
const codeExecutor = new CodeExecutor();

// The server instance and tools exposed to Claude
const server = new Server(
  {
    name: "code-interpreter-server",
    version: "0.0.1",
  },
  {
    capabilities: {
      tools: {},
    },
  }
);

server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "execute_javascript",
        description:
          "Execute JavaScript code in a Node.js environment and return the output",
        inputSchema: {
          type: "object",
          properties: {
            code: {
              type: "string",
              description: "The JavaScript code to execute",
            },
            timeout: {
              type: "number",
              description: "Timeout in milliseconds (default: 30000)",
              default: 30000,
            },
          },
          required: ["code"],
        },
      },
    ],
  };
});

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  if (!args) {
    throw new Error(`No arguments provided for tool: ${name}`);
  }

  switch (name) {
    case "execute_javascript":
      const code = args.code as string;
      const timeout = (args.timeout as number) || 30000;

      if (!code || typeof code !== "string") {
        throw new Error("Code parameter is required and must be a string");
      }

      const result = await codeExecutor.executeJavaScript(code, timeout);

      return {
        content: [
          {
            type: "text",
            text: JSON.stringify(result, null, 2),
          },
        ],
      };

    default:
      throw new Error(`Unknown tool: ${name}`);
  }
});

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("Code Interpreter MCP Server running on stdio");
}

main().catch((error) => {
  console.error("Fatal error in main():", error);
  process.exit(1);
});