mcp-gm 3.4.95

package/.gitattributes

@@ -0,0 +1,10 @@
+# Ensure Unix line endings for all text files
+* text=auto eol=lf
+
+# Source code
+*.js text eol=lf
+*.json text eol=lf
+*.md text eol=lf
+
+# Scripts should always have LF
+*.sh text eol=lf

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 AnEntrypoint
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,66 @@
+# mcp-glootie
+
+MCP server for executing code in JavaScript/TypeScript, Python, Go, Rust, C, C++, and Deno. Includes process management, recovery mechanisms, and automatic cleanup.
+
+## Quick Start
+
+Just one command with Bun:
+
+```bash
+bunx mcp-glootie
+```
+
+That's it. Starts the MCP server immediately and connects to Claude Code or your MCP client.
+
+### For Development
+
+Clone and run locally:
+
+```bash
+git clone https://github.com/AnEntrypoint/mcp-glootie.git
+cd mcp-glootie
+bun install
+bun run src/index.js
+```
+
+## Features
+
+- Multi-language code execution (JS/TS, Python, Go, Rust, C, C++, Deno)
+- Process management with backgrounding support
+- Automatic error recovery
+- Built-in cleanup and resource limits
+- Stdin write capability for interactive processes
+- Status checking for background processes
+
+## Tools Available
+
+- `execute` - Run code in any supported language
+- `bash` - Execute shell commands
+- `process_status` - Check background process status
+- `process_close` - Terminate a process
+- `sleep` - Pause execution
+
+## Troubleshooting
+
+### Bun not installed
+
+If you see `Bun is required but not installed`, install Bun:
+
+```bash
+curl -fsSL https://bun.sh | bash
+```
+
+Then run mcp-glootie again.
+
+### Port conflicts
+
+If the server fails to start with a port error:
+
+```bash
+# Find what's using the port
+lsof -i :3001
+
+# Kill it if needed
+kill -9 <PID>
+```
+# Triggered npm publishing

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "mcp-gm",
+  "version": "3.4.95",
+  "description": "MCP GM - Code execution tool for MCP clients. Multi-language support (JS/TS, Go, Rust, Python, C/C++, bash). Works with Claude Code, Cursor, Copilot, VSCode.",
+  "main": "src/index.js",
+  "type": "module",
+  "bin": {
+    "mcp-gm": "src/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "start": "bun run src/index.js",
+    "dev": "bun run src/index.js ./test"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.18.2"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AnEntrypoint/mcp-gm.git"
+  },
+  "keywords": [
+    "mcp",
+    "code-execution",
+    "javascript",
+    "typescript",
+    "go",
+    "rust",
+    "python",
+    "c",
+    "cpp",
+    "bash"
+  ],
+  "author": "",
+  "license": "MIT",
+  "mcpName": "io.github.AnEntrypoint/gm"
+}

package/server.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-09-16/server.schema.json",
+  "name": "io.github.AnEntrypoint/glootie",
+  "description": "Code execution tool for MCP clients. JS/TS, Go, Rust, Python, C/C++, bash.",
+  "repository": {
+    "url": "https://github.com/AnEntrypoint/mcp-glootie",
+    "source": "github"
+  },
+  "version": "3.4.84",
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "mcp-glootie",
+      "version": "3.4.84",
+      "transport": {
+        "type": "stdio"
+      }
+    }
+  ]
+}

package/src/background-tasks.js

@@ -0,0 +1,98 @@
+export class BackgroundTaskStore {
+  constructor() {
+    this.tasks = new Map();
+    this.taskCounter = 0;
+    this.maxAge = 30 * 60 * 1000;
+    this.maxTasks = 1000;
+    this.maxOutputSize = 100 * 1024;
+    this.cleanupTimer = setInterval(() => this.cleanup(), 5 * 60 * 1000);
+    if (this.cleanupTimer.unref) this.cleanupTimer.unref();
+  }
+
+  cleanup() {
+    const now = Date.now();
+    for (const [id, task] of this.tasks) {
+      if ((task.status === 'completed' || task.status === 'failed') &&
+          task.completedAt && (now - task.completedAt > this.maxAge)) {
+        this.tasks.delete(id);
+      }
+    }
+    if (this.tasks.size > this.maxTasks) {
+      const expired = [...this.tasks.entries()]
+        .filter(([, t]) => t.status === 'completed' || t.status === 'failed')
+        .sort((a, b) => a[1].completedAt - b[1].completedAt);
+      for (const [id] of expired) {
+        this.tasks.delete(id);
+        if (this.tasks.size <= this.maxTasks) break;
+      }
+    }
+  }
+
+  shutdown() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+    for (const [, task] of this.tasks) {
+      if (task.status === 'running' || task.status === 'pending') {
+        task.completedAt = Date.now();
+        task.result = { error: 'Process shutting down' };
+        task.status = 'failed';
+      }
+    }
+  }
+
+  createTask(code, runtime, workingDirectory) {
+    const taskId = ++this.taskCounter;
+    this.tasks.set(taskId, {
+      id: taskId, code, runtime, workingDirectory,
+      createdAt: Date.now(), startedAt: null,
+      completedAt: null, result: null, status: 'pending',
+      outputLog: []
+    });
+    return taskId;
+  }
+
+  startTask(taskId) {
+    const task = this.tasks.get(taskId);
+    if (task) { task.startedAt = Date.now(); task.status = 'running'; }
+  }
+
+  completeTask(taskId, result) {
+    const task = this.tasks.get(taskId);
+    if (task) { task.completedAt = Date.now(); task.result = result; task.status = 'completed'; }
+  }
+
+  failTask(taskId, error) {
+    const task = this.tasks.get(taskId);
+    if (task) { task.completedAt = Date.now(); task.result = { error: error.message }; task.status = 'failed'; }
+  }
+
+  appendOutput(taskId, type, data) {
+    const task = this.tasks.get(taskId);
+    if (!task || (task.status !== 'running' && task.status !== 'pending')) return;
+    const timestamp = Date.now();
+    task.outputLog.push({ t: timestamp, s: type, d: data });
+    const totalLen = task.outputLog.reduce((sum, e) => sum + e.d.length, 0);
+    if (totalLen > this.maxOutputSize) {
+      while (task.outputLog.length > 1 && 
+             task.outputLog.reduce((sum, e) => sum + e.d.length, 0) > this.maxOutputSize * 0.5) {
+        task.outputLog.shift();
+      }
+    }
+  }
+
+  getAndClearOutput(taskId) {
+    const task = this.tasks.get(taskId);
+    if (!task) return [];
+    const log = task.outputLog;
+    task.outputLog = [];
+    return log;
+  }
+
+  getTask(taskId) { return this.tasks.get(taskId); }
+  deleteTask(taskId) { this.tasks.delete(taskId); }
+  getAllTasks() { return Array.from(this.tasks.values()); }
+}
+
+export const backgroundStore = new BackgroundTaskStore();

package/src/index.js

@@ -0,0 +1,120 @@
+#!/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';
+
+(async () => {
+  const isRemoteUrl = import.meta.url.includes('raw.githubusercontent.com');
+  const baseUrl = isRemoteUrl
+    ? 'https://raw.githubusercontent.com/AnEntrypoint/mcp-glootie/main/src/'
+    : new URL('./', import.meta.url).pathname;
+
+  const { allTools } = await import(baseUrl + 'tools-registry.js');
+  const { recoveryState } = await import(baseUrl + 'recovery-state.js');
+  const { startRunner, stopRunner } = await import(baseUrl + 'runner-supervisor.js');
+
+  const server = new Server(
+    { name: 'glootie', version: '3.4.72', description: 'Code execution for programming agents' },
+    { capabilities: { tools: {} } }
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    try {
+      return { tools: allTools.map(t => ({ name: t.name, description: t.description, inputSchema: t.inputSchema })) };
+    } catch (error) {
+      console.error('[ListTools] Error:', error);
+      return { tools: [] };
+    }
+  });
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    try {
+      if (!request?.params?.name) {
+        return { content: [{ type: 'text', text: 'Invalid request parameters' }], isError: true };
+      }
+      const { name, arguments: args } = request.params;
+      const tool = allTools.find(t => t.name === name);
+      if (!tool) {
+        return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+      }
+      try {
+        return await tool.handler(args || {});
+      } catch (toolError) {
+        return { content: [{ type: 'text', text: `Tool error: ${toolError?.message || String(toolError)}` }], isError: true };
+      }
+    } catch (error) {
+      console.error('[CallTool] Error:', error);
+      return { content: [{ type: 'text', text: `Server error: ${error?.message || 'Unknown error'}` }], isError: true };
+    }
+  });
+
+  process.on('uncaughtException', (error) => {
+    try {
+      console.error('[UNCAUGHT_EXCEPTION]', { name: error?.name, message: error?.message, stack: error?.stack });
+    } catch (e) {
+      process.stderr.write(`Fatal error logging exception: ${e}\n`);
+    }
+  });
+
+  process.on('unhandledRejection', (reason) => {
+    try {
+      console.error('[UNHANDLED_REJECTION]', { reason: String(reason), type: typeof reason, stack: reason?.stack });
+    } catch (e) {
+      process.stderr.write(`Fatal error logging rejection: ${e}\n`);
+    }
+  });
+
+  process.on('warning', (warning) => {
+    try { console.error('[WARNING]', warning.name, warning.message); } catch (e) {}
+  });
+
+  process.on('exit', (code) => {
+    try { console.error(`[EXIT] Process exiting with code ${code}`); } catch (e) {}
+  });
+
+  let shuttingDown = false;
+  let backoffTimer = null;
+
+  async function gracefulShutdown(signal) {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    try {
+      console.error(`[${signal}] Shutting down gracefully`);
+      if (backoffTimer) { clearTimeout(backoffTimer); backoffTimer = null; }
+      await stopRunner();
+      process.exit(0);
+    } catch (e) {
+      try { await stopRunner(); } catch (_) {}
+      process.exit(1);
+    }
+  }
+
+  process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+  process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+  process.on('SIGHUP', () => gracefulShutdown('SIGHUP'));
+
+  async function startupWithRecovery() {
+    await startRunner();
+    while (recoveryState.canRetry()) {
+      try {
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+        recoveryState.recordSuccess();
+        console.error('[STARTUP] Connected successfully');
+        return;
+      } catch (error) {
+        recoveryState.recordStartupAttempt(error);
+        const delay = recoveryState.getBackoffDelay();
+        console.error(`[STARTUP] Attempt ${recoveryState.startupAttempts} failed: ${error?.message || String(error)}. Retrying in ${delay}ms...`);
+        await new Promise(resolve => { backoffTimer = setTimeout(resolve, delay); });
+        backoffTimer = null;
+      }
+    }
+    console.error(`[STARTUP] Failed after ${recoveryState.maxStartupAttempts} attempts. Last error: ${recoveryState.lastError}`);
+  }
+
+  startupWithRecovery().catch(error => {
+    console.error('[STARTUP] Unhandled error during recovery:', error);
+  });
+})();

package/src/recovery-state.js

@@ -0,0 +1,45 @@
+const MAX_BUFFER = 10 * 1024 * 1024;
+
+export const recoveryState = {
+  startupAttempts: 0,
+  maxStartupAttempts: 5,
+  backoffDelayMs: 1000,
+  lastError: null,
+  connected: false,
+
+  recordStartupAttempt(error) {
+    this.startupAttempts += 1;
+    this.lastError = error?.message || String(error);
+    this.connected = false;
+  },
+
+  recordSuccess() {
+    this.startupAttempts = 0;
+    this.lastError = null;
+    this.connected = true;
+  },
+
+  canRetry() {
+    return this.startupAttempts < this.maxStartupAttempts;
+  },
+
+  getBackoffDelay() {
+    return Math.min(this.backoffDelayMs * Math.pow(2, this.startupAttempts - 1), 30000);
+  },
+
+  shouldTrimBuffer(bufferSize) {
+    return bufferSize > MAX_BUFFER;
+  },
+
+  trimBuffer(bufferString) {
+    if (bufferString.length <= MAX_BUFFER) return bufferString;
+    const keepSize = Math.ceil(MAX_BUFFER * 0.5);
+    return bufferString.slice(-keepSize);
+  },
+
+  reset() {
+    this.startupAttempts = 0;
+    this.lastError = null;
+    this.connected = false;
+  }
+};

package/src/rpc-client.js

@@ -0,0 +1,56 @@
+import http from 'http';
+import { readFileSync } from 'fs';
+
+function getPort() {
+  try {
+    return parseInt(readFileSync('/tmp/glootie-runner.port', 'utf8').trim(), 10);
+  } catch {
+    throw new Error('task runner not available');
+  }
+}
+
+function rpcCall(method, params, timeoutMs = 10000) {
+  return new Promise((resolve, reject) => {
+    const port = getPort();
+    const body = JSON.stringify({ method, params });
+    const req = http.request(
+      { hostname: '127.0.0.1', port, path: '/rpc', method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) } },
+      (res) => {
+        let data = '';
+        res.on('data', chunk => { data += chunk; });
+        res.on('end', () => {
+          if (res.statusCode !== 200) return reject(new Error(`task runner HTTP ${res.statusCode}: ${data}`));
+          try {
+            const parsed = JSON.parse(data);
+            if (parsed.error) return reject(new Error(parsed.error));
+            resolve(parsed.result);
+          } catch {
+            reject(new Error(`task runner invalid response: ${data}`));
+          }
+        });
+      }
+    );
+    const timer = setTimeout(() => { req.destroy(); reject(new Error('task runner request timed out')); }, timeoutMs);
+    req.on('error', (e) => { clearTimeout(timer); reject(new Error(`task runner not available: ${e.message}`)); });
+    req.on('close', () => clearTimeout(timer));
+    req.write(body);
+    req.end();
+  });
+}
+
+export async function executeCode(code, runtime, workingDirectory, timeout = 30000, backgroundTaskId = null) {
+  const r = await rpcCall('execute', { code, runtime, workingDirectory, timeout, backgroundTaskId }, timeout + 5000);
+  return r?.result ?? r;
+}
+
+export const backgroundStore = {
+  createTask: (code, runtime, workingDirectory) => rpcCall('createTask', { code, runtime, workingDirectory }).then(r => r?.taskId ?? r),
+  startTask: (taskId) => rpcCall('startTask', { taskId }),
+  completeTask: (taskId, result) => rpcCall('completeTask', { taskId, result }),
+  failTask: (taskId, error) => rpcCall('failTask', { taskId, error }),
+  getTask: (taskId) => rpcCall('getTask', { taskId }).then(r => r?.task ?? r),
+  deleteTask: (taskId) => rpcCall('deleteTask', { taskId }),
+  appendOutput: (taskId, type, data) => rpcCall('appendOutput', { taskId, type, data }),
+  getAndClearOutput: (taskId) => rpcCall('getAndClearOutput', { taskId }).then(r => r?.output ?? r),
+};

package/src/runner-supervisor.js

@@ -0,0 +1,124 @@
+import { spawn } from 'child_process';
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const RUNNER_PATH = path.join(__dirname, 'task-runner.js');
+
+const PORT_FILE = '/tmp/glootie-runner.port';
+const MAX_RESTARTS = 10;
+const RESTART_WINDOW_MS = 5 * 60 * 1000;
+
+let runnerProcess = null;
+let healthPollInterval = null;
+let healthy = false;
+let consecutiveFailures = 0;
+let restartTimestamps = [];
+
+function getPort() {
+  try {
+    const val = fs.readFileSync(PORT_FILE, 'utf8').trim();
+    const n = Number(val);
+    return isNaN(n) ? null : n;
+  } catch {
+    return null;
+  }
+}
+
+function healthCheck(port) {
+  return new Promise((resolve) => {
+    const req = http.get({ hostname: '127.0.0.1', port, path: '/health', timeout: 3000 }, (res) => {
+      resolve(res.statusCode === 200);
+    });
+    req.on('error', () => resolve(false));
+    req.on('timeout', () => { req.destroy(); resolve(false); });
+  });
+}
+
+function withinWindow() {
+  const now = Date.now();
+  restartTimestamps = restartTimestamps.filter(t => now - t < RESTART_WINDOW_MS);
+  return restartTimestamps.length;
+}
+
+async function startRunner() {
+  try { fs.unlinkSync(PORT_FILE); } catch {}
+
+  runnerProcess = spawn('node', [RUNNER_PATH], {
+    env: process.env,
+    stdio: ['ignore', 'inherit', 'inherit']
+  });
+
+  runnerProcess.on('exit', (code) => {
+    healthy = false;
+    runnerProcess = null;
+    const count = withinWindow();
+    if (count >= MAX_RESTARTS) {
+      console.error('[runner-supervisor] max restarts exceeded, stopping');
+      return;
+    }
+    const delay = Math.min(1000 * Math.pow(2, count), 30000);
+    restartTimestamps.push(Date.now());
+    setTimeout(() => startRunner().catch(e => console.error('[runner-supervisor] restart failed', e)), delay);
+  });
+
+  const deadline = Date.now() + 10000;
+  while (Date.now() < deadline) {
+    await new Promise(r => setTimeout(r, 200));
+    const port = getPort();
+    if (port && await healthCheck(port)) {
+      healthy = true;
+      consecutiveFailures = 0;
+      startHealthPoll();
+      return;
+    }
+  }
+  throw new Error('runner did not become healthy within 10s');
+}
+
+function startHealthPoll() {
+  if (healthPollInterval) clearInterval(healthPollInterval);
+  healthPollInterval = setInterval(async () => {
+    const port = getPort();
+    const ok = port ? await healthCheck(port) : false;
+    if (ok) {
+      healthy = true;
+      consecutiveFailures = 0;
+    } else {
+      consecutiveFailures++;
+      if (consecutiveFailures >= 3) {
+        healthy = false;
+        const count = withinWindow();
+        if (count >= MAX_RESTARTS) {
+          console.error('[runner-supervisor] max restarts exceeded');
+          clearInterval(healthPollInterval);
+          healthPollInterval = null;
+          return;
+        }
+        restartTimestamps.push(Date.now());
+        const delay = Math.min(1000 * Math.pow(2, count), 30000);
+        await stopRunner();
+        setTimeout(() => startRunner().catch(e => console.error('[runner-supervisor] restart failed', e)), delay);
+      }
+    }
+  }, 5000);
+}
+
+async function stopRunner() {
+  if (healthPollInterval) { clearInterval(healthPollInterval); healthPollInterval = null; }
+  if (!runnerProcess) return;
+  const proc = runnerProcess;
+  return new Promise((resolve) => {
+    const kill = setTimeout(() => { proc.kill('SIGKILL'); }, 3000);
+    proc.on('exit', () => { clearTimeout(kill); resolve(); });
+    proc.kill('SIGTERM');
+  });
+}
+
+function isRunnerHealthy() {
+  return healthy;
+}
+
+export { startRunner, stopRunner, isRunnerHealthy };