mcp-gm 3.4.95

package/src/task-runner.js

@@ -0,0 +1,132 @@
+import http from 'http';
+import { writeFileSync } from 'fs';
+import { WorkerPool } from './workers/worker-pool.js';
+import { BackgroundTaskStore } from './background-tasks.js';
+
+const pool = new WorkerPool(4);
+const backgroundStore = new BackgroundTaskStore();
+
+function randomPort() {
+  return Math.floor(Math.random() * 10000) + 30000;
+}
+
+async function tryListen(server, port) {
+  return new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(port, '127.0.0.1', () => resolve());
+  });
+}
+
+async function startServer() {
+  const server = http.createServer(handleRequest);
+  for (let i = 0; i < 10; i++) {
+    const port = randomPort();
+    try {
+      await tryListen(server, port);
+      writeFileSync('/tmp/glootie-runner.port', String(port));
+      return server;
+    } catch (e) {
+      if (e.code !== 'EADDRINUSE') throw e;
+    }
+  }
+  throw new Error('Could not bind port after 10 attempts');
+}
+
+function sendJSON(res, status, body) {
+  const data = JSON.stringify(body);
+  res.writeHead(status, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) });
+  res.end(data);
+}
+
+async function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on('data', c => chunks.push(c));
+    req.on('end', () => {
+      try { resolve(JSON.parse(Buffer.concat(chunks).toString())); }
+      catch (e) { reject(e); }
+    });
+    req.on('error', reject);
+  });
+}
+
+async function handleRPC(body) {
+  const { method, params = {} } = body;
+  switch (method) {
+    case 'execute': {
+      const { code, runtime, workingDirectory, timeout, backgroundTaskId } = params;
+      const result = await pool.execute(code, runtime, workingDirectory, timeout, backgroundTaskId);
+      return { result };
+    }
+    case 'createTask': {
+      const { code, runtime, workingDirectory } = params;
+      const taskId = backgroundStore.createTask(code, runtime, workingDirectory);
+      return { taskId };
+    }
+    case 'startTask':
+      backgroundStore.startTask(params.taskId);
+      return {};
+    case 'completeTask':
+      backgroundStore.completeTask(params.taskId, params.result);
+      return {};
+    case 'failTask':
+      backgroundStore.failTask(params.taskId, new Error(params.error));
+      return {};
+    case 'getTask': {
+      const task = backgroundStore.getTask(params.taskId);
+      return { task };
+    }
+    case 'deleteTask':
+      if (backgroundStore.deleteTask) backgroundStore.deleteTask(params.taskId);
+      return {};
+    case 'appendOutput':
+      backgroundStore.appendOutput(params.taskId, params.type, params.data);
+      return {};
+    case 'getAndClearOutput': {
+      const output = backgroundStore.getAndClearOutput(params.taskId);
+      return { output };
+    }
+    case 'shutdown':
+      setImmediate(gracefulShutdown);
+      return { ok: true };
+    default:
+      throw Object.assign(new Error(`Unknown method: ${method}`), { code: -32601 });
+  }
+}
+
+async function handleRequest(req, res) {
+  try {
+    if (req.method === 'GET' && req.url === '/health') {
+      return sendJSON(res, 200, { ok: true });
+    }
+    if (req.method === 'POST' && req.url === '/rpc') {
+      const body = await readBody(req);
+      try {
+        const result = await handleRPC(body);
+        return sendJSON(res, 200, { id: body.id, result });
+      } catch (e) {
+        return sendJSON(res, 200, {
+          id: body.id,
+          error: { code: e.code || -32603, message: e.message }
+        });
+      }
+    }
+    sendJSON(res, 404, { error: 'Not found' });
+  } catch (e) {
+    try { sendJSON(res, 400, { error: e.message }); } catch (_) {}
+  }
+}
+
+let server;
+
+async function gracefulShutdown() {
+  await pool.shutdown();
+  backgroundStore.shutdown();
+  if (server) server.close(() => process.exit(0));
+  else process.exit(0);
+}
+
+process.on('SIGTERM', gracefulShutdown);
+process.on('SIGINT', gracefulShutdown);
+
+server = await startServer();

package/src/tools/execute-code-isolated.js

@@ -0,0 +1,20 @@
+import { executeCode as rpcExecuteCode } from '../rpc-client.js';
+
+const validate = {
+  execute({ code, workingDirectory }) {
+    if (!code || typeof code !== 'string') return 'Error: code must be a non-empty string';
+    if (!workingDirectory || typeof workingDirectory !== 'string') return 'Error: workingDirectory must be a non-empty string';
+    return null;
+  },
+  bash({ commands, workingDirectory }) {
+    if (!commands) return 'Error: commands must be provided';
+    if (!workingDirectory || typeof workingDirectory !== 'string') return 'Error: workingDirectory must be a non-empty string';
+    return null;
+  }
+};
+
+export async function executeCode(code, runtime, workingDirectory, timeout = 30000, backgroundTaskId = null) {
+  return rpcExecuteCode(code, runtime, workingDirectory, timeout, backgroundTaskId);
+}
+
+export { validate };

package/src/tools/executor-tool-isolated.js

@@ -0,0 +1,139 @@
+import { executeCode, validate } from './execute-code-isolated.js';
+import { backgroundStore } from '../rpc-client.js';
+import { readFileSync, unlinkSync } from 'fs';
+
+const HARD_CEILING_MS = 15000;
+
+const formatters = {
+  output(result) {
+    const parts = result.stdout ? [`[STDOUT]\n${result.stdout}`] : [];
+    if (result.stderr) parts.push(`[STDERR]\n${result.stderr}`);
+    return parts.length ? parts.join('\n\n') : '(no output)';
+  },
+  context(result) {
+    const ctx = [`Exit code: ${result.exitCode ?? result.code}`, `Time: ${result.executionTimeMs}ms`];
+    if (result.stdout) ctx.push(`Stdout size: ${result.stdout.length} bytes`);
+    if (result.stderr) ctx.push(`Stderr size: ${result.stderr.length} bytes`);
+    return ctx.join(' | ');
+  },
+  logContent(logFile) {
+    if (!logFile) return '';
+    try {
+      const content = readFileSync(logFile, 'utf8');
+      try { unlinkSync(logFile); } catch (e) {}
+      return content;
+    } catch (e) {
+      return '';
+    }
+  }
+};
+
+const response = {
+  success(text) { return { content: [{ type: 'text', text }], isError: false }; },
+  error(text) { return { content: [{ type: 'text', text }], isError: true }; }
+};
+
+const createExecutionHandler = (validateFn, isBash = false) => async (args) => {
+  const { code, commands, workingDirectory, language = isBash ? 'bash' : 'auto', run_in_background } = args;
+
+  try {
+    const params = isBash ? { commands, workingDirectory } : { code, workingDirectory };
+    const err = validate[isBash ? 'bash' : 'execute'](params);
+    if (err) return response.error(err);
+
+    const cmd = isBash ? (Array.isArray(commands) ? commands.join(' && ') : String(commands)) : code;
+    let runtime = language || 'nodejs';
+    if (!isBash && (runtime === 'typescript' || runtime === 'auto')) runtime = 'nodejs';
+
+    const backgroundTaskId = await backgroundStore.createTask(cmd, runtime, workingDirectory);
+
+    const timeout = HARD_CEILING_MS;
+    const deadline = Date.now() + timeout;
+    
+    const safetyTimeout = new Promise(resolve => {
+      const remaining = Math.max(100, deadline - Date.now());
+      setTimeout(() => {
+        backgroundStore.startTask(backgroundTaskId);
+        resolve({ backgroundTaskId, persisted: true });
+      }, remaining);
+    });
+    
+    const result = await Promise.race([
+      executeCode(cmd, runtime, workingDirectory, timeout, backgroundTaskId),
+      safetyTimeout
+    ]);
+
+    if (result.persisted) {
+      return response.success(
+        `Process backgrounded (ID: task_${result.backgroundTaskId})`
+      );
+    }
+
+    if (result.backgroundTaskId && result.completed) {
+      return response.success(
+        `Process completed in background (ID: task_${result.backgroundTaskId})`
+      );
+    }
+
+    backgroundStore.deleteTask(backgroundTaskId);
+
+    const logContent = formatters.logContent(result.logFile);
+    const logSection = logContent ? `\n\n[LOG]\n${logContent}` : '';
+
+    if (!result.success && !result.error) {
+      return response.error(`Command failed\n${formatters.context(result)}\n\n${formatters.output(result)}${logSection}`);
+    }
+
+    if (result.error) return response.error(`Error: ${result.error}${logSection}`);
+
+    return response.success(`${formatters.context(result)}\n\n${formatters.output(result)}${logSection}`);
+  } catch (error) {
+    return response.error(`Error: ${error?.message || String(error)}`);
+  }
+};
+
+export const executionTools = process.platform === 'win32'
+  ? [{
+      name: 'execute',
+      description: 'Execute code (JS/TS, Deno, Go, Rust, Python, C, C++, Java)',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          workingDirectory: { type: 'string', description: 'Working directory' },
+          code: { type: 'string', description: 'Code to execute' },
+          language: { type: 'string', enum: ['nodejs', 'typescript', 'deno', 'go', 'rust', 'python', 'c', 'cpp', 'java', 'auto'], description: 'Language (default: auto)' },
+          run_in_background: { type: 'boolean', description: 'Return immediately with task reference. Commands have a hard 15s ceiling then auto-background.' }
+        },
+        required: ['workingDirectory', 'code']
+      },
+      handler: createExecutionHandler(validate.execute)
+    }]
+  : [{
+      name: 'execute',
+      description: 'Execute code (JS/TS, Deno, Go, Rust, Python, C, C++, Java)',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          workingDirectory: { type: 'string', description: 'Working directory' },
+          code: { type: 'string', description: 'Code to execute' },
+          language: { type: 'string', enum: ['nodejs', 'typescript', 'deno', 'go', 'rust', 'python', 'c', 'cpp', 'java', 'auto'], description: 'Language (default: auto)' },
+          run_in_background: { type: 'boolean', description: 'Return immediately with task reference. Commands have a hard 15s ceiling then auto-background.' }
+        },
+        required: ['workingDirectory', 'code']
+      },
+      handler: createExecutionHandler(validate.execute)
+    }, {
+      name: 'bash',
+      description: 'Execute bash shell commands',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          workingDirectory: { type: 'string', description: 'Working directory' },
+          commands: { type: ['string', 'array'], description: 'Commands to execute' },
+          language: { type: 'string', enum: ['bash', 'sh', 'zsh'], description: 'Language (default: bash)' },
+          run_in_background: { type: 'boolean', description: 'Return immediately with task reference. Commands have a hard 15s ceiling then auto-background.' }
+        },
+        required: ['workingDirectory', 'commands']
+      },
+      handler: createExecutionHandler(validate.bash, true)
+    }];

package/src/tools-registry.js

@@ -0,0 +1,114 @@
+import { executionTools } from './tools/executor-tool-isolated.js';
+import { backgroundStore } from './background-tasks.js';
+
+const response = {
+  success(text) {
+    return {
+      content: [{ type: 'text', text }],
+      isError: false
+    };
+  },
+  error(text) {
+    return {
+      content: [{ type: 'text', text }],
+      isError: true
+    };
+  },
+  json(data, isErr = false) {
+    return this[isErr ? 'error' : 'success'](JSON.stringify(data, null, 2));
+  }
+};
+
+const createSimpleTool = (name, description, inputSchema, handler) => ({
+  name,
+  description,
+  inputSchema,
+  handler
+});
+
+export const sleepTool = createSimpleTool(
+  'sleep',
+  'Sleep for a specified number of milliseconds',
+  {
+    type: 'object',
+    properties: {
+      milliseconds: { type: 'number', description: 'Number of milliseconds to sleep' }
+    },
+    required: ['milliseconds']
+  },
+  async ({ milliseconds }) => {
+    try {
+      if (typeof milliseconds !== 'number' || milliseconds < 0) {
+        return response.error('Invalid milliseconds: must be a non-negative number');
+      }
+      const cap = milliseconds < 295000 ? milliseconds : 295000;
+      await new Promise(resolve => setTimeout(resolve, cap));
+      return response.success(`Slept for ${milliseconds}ms`);
+    } catch (e) {
+      return response.error(`Sleep failed: ${e.message}`);
+    }
+  }
+);
+
+export const processStatusTool = createSimpleTool(
+  'process_status',
+  'Check status of a persisted background process',
+  {
+    type: 'object',
+    properties: {
+      task_id: { type: 'number', description: 'The task ID returned from execute' }
+    },
+    required: ['task_id']
+  },
+  async ({ task_id }) => {
+    try {
+      if (typeof task_id !== 'number' || task_id < 1) {
+        return response.error('Invalid task_id: must be a positive number');
+      }
+      const task = backgroundStore.getTask(task_id);
+      if (!task) {
+        return response.error(`Task ${task_id} not found`);
+      }
+      return response.json({
+        id: task.id,
+        status: task.status,
+        createdAt: new Date(task.createdAt).toISOString(),
+        startedAt: task.startedAt ? new Date(task.startedAt).toISOString() : null,
+        completedAt: task.completedAt ? new Date(task.completedAt).toISOString() : null,
+        runtime: task.runtime,
+        result: task.result
+      });
+    } catch (e) {
+      return response.error(`Status check failed: ${e.message}`);
+    }
+  }
+);
+
+export const processCloseTool = createSimpleTool(
+  'process_close',
+  'Clean up a completed background process',
+  {
+    type: 'object',
+    properties: {
+      task_id: { type: 'number', description: 'The task ID to close' }
+    },
+    required: ['task_id']
+  },
+  async ({ task_id }) => {
+    try {
+      if (typeof task_id !== 'number' || task_id < 1) {
+        return response.error('Invalid task_id: must be a positive number');
+      }
+      const task = backgroundStore.getTask(task_id);
+      if (!task) {
+        return response.error(`Task ${task_id} not found`);
+      }
+      backgroundStore.deleteTask(task_id);
+      return response.success(`Task ${task_id} closed`);
+    } catch (e) {
+      return response.error(`Close failed: ${e.message}`);
+    }
+  }
+);
+
+export const allTools = [...(executionTools || []), sleepTool, processStatusTool, processCloseTool];