feat: each exec runs as its own named PM2 process visible in pm2 list\n\n- Add src/runtime.js: extracts binary finding and child spawn logic for all\n supported runtimes (nodejs, python, bash, powershell, go, rust, c, cpp, java, deno)\n- Add src/exec-process.js: PM2 fork-mode child that reads TASK_ID/PORT/RUNTIME/CWD/CODE_FILE\n from env, spawns the runtime child, streams stdout/stderr back via HTTP RPC appendOutput,\n calls completeTask/failTask on exit, handles process.on('message') for stdin via PM2 IPC\n- Rewrite src/task-runner.js execute RPC: writes code to temp file, starts PM2 process\n per task (gm-exec-task-{id}), polls backgroundStore for fast completion (<timeout),\n returns inline result or {persisted:true} for slow tasks\n- sendStdin RPC uses pm2lib.sendDataToProcessId with taskPm2Ids Map\n- deleteTask RPC calls pm2lib.delete to remove the PM2 process from pm2 list\n- Remove WorkerPool dependency from task-runner entirely\n\nCo-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: lanmower

src/exec-process.js

@@ -0,0 +1,95 @@
+import http from 'http';
+import { readFileSync, unlinkSync } from 'fs';
+import { spawnProcess, killChild } from './runtime.js';
+
+const { TASK_ID, PORT, RUNTIME, CWD, CODE_FILE } = process.env;
+const taskId = parseInt(TASK_ID, 10);
+const port = parseInt(PORT, 10);
+
+function rpc(method, params) {
+  return new Promise((resolve) => {
+    try {
+      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 => { res.on('data', () => {}); res.on('end', () => resolve()); }
+      );
+      req.on('error', () => resolve());
+      req.write(body); req.end();
+    } catch { resolve(); }
+  });
+}
+
+const code = readFileSync(CODE_FILE, 'utf8');
+try { unlinkSync(CODE_FILE); } catch {}
+
+let activeChild = null;
+
+process.on('message', (msg) => {
+  if (msg?.data?.type === 'stdin' && activeChild?.stdin && !activeChild.stdin.destroyed) {
+    try { activeChild.stdin.write(msg.data.data); } catch {}
+  }
+});
+
+async function runChild(child, cleanup) {
+  activeChild = child;
+  let stdout = '', stderr = '';
+  child.stdout?.on('data', async (d) => {
+    const str = d.toString('utf8');
+    stdout += str;
+    await rpc('appendOutput', { taskId, type: 'stdout', data: str });
+  });
+  child.stderr?.on('data', async (d) => {
+    const str = d.toString('utf8');
+    stderr += str;
+    await rpc('appendOutput', { taskId, type: 'stderr', data: str });
+  });
+  return new Promise((resolve) => {
+    child.on('error', async (err) => {
+      cleanup();
+      await rpc('failTask', { taskId, error: err.message });
+      resolve({ ok: false, error: err.message });
+    });
+    child.on('close', (code) => {
+      cleanup();
+      resolve({ ok: code === 0, exitCode: code, stdout, stderr });
+    });
+  });
+}
+
+async function runCompiled(spawnResult) {
+  const { child, cleanup, binPath, dir, cp, className, isCompile } = spawnResult;
+  const compileResult = await runChild(child, () => {});
+  if (!compileResult.ok) {
+    cleanup();
+    await rpc('failTask', { taskId, error: compileResult.stderr || 'Compilation failed' });
+    return;
+  }
+  let runChild2, runCleanup;
+  if (RUNTIME === 'java') {
+    const { spawn } = await import('child_process');
+    const JAVA = 'java';
+    runChild2 = spawn(JAVA, ['-cp', cp, className], { cwd: CWD, stdio: ['pipe','pipe','pipe'] });
+    runCleanup = cleanup;
+  } else {
+    const { spawn } = await import('child_process');
+    runChild2 = spawn(binPath, [], { cwd: CWD, stdio: ['pipe','pipe','pipe'] });
+    runCleanup = cleanup;
+  }
+  const result = await runChild(runChild2, runCleanup);
+  await rpc(result.ok ? 'completeTask' : 'failTask', result.ok
+    ? { taskId, result: { success: true, exitCode: result.exitCode, stdout: result.stdout, stderr: result.stderr } }
+    : { taskId, error: result.stderr || 'Execution failed' });
+}
+
+const spawnResult = spawnProcess(RUNTIME, code, CWD);
+if (spawnResult.isCompile) {
+  await runCompiled(spawnResult);
+} else {
+  const result = await runChild(spawnResult.child, spawnResult.cleanup);
+  await rpc(result.ok ? 'completeTask' : 'failTask', result.ok
+    ? { taskId, result: { success: true, exitCode: result.exitCode, stdout: result.stdout, stderr: result.stderr } }
+    : { taskId, error: result.error || result.stderr || 'Execution failed' });
+}
+process.exit(0);

src/runtime.js

@@ -0,0 +1,109 @@
+import { spawn, execSync } from 'child_process';
+import { writeFileSync, mkdtempSync, rmSync } from 'fs';
+import path from 'path';
+import os from 'os';
+
+function findBin(...candidates) {
+  const probe = process.platform === 'win32' ? b => `where ${b}` : b => `which ${b}`;
+  for (const bin of candidates) {
+    try { execSync(probe(bin), { stdio: 'ignore', timeout: 3000 }); return bin; } catch {}
+  }
+  return candidates[0];
+}
+
+const IS_WIN = process.platform === 'win32';
+const PYTHON = findBin('python3', 'python');
+const SHELL = IS_WIN ? 'cmd.exe' : findBin('bash', 'sh');
+const POWERSHELL = findBin('pwsh', 'powershell');
+const DENO = findBin('deno');
+const GO = findBin('go');
+const RUSTC = findBin('rustc');
+const GCC = findBin('gcc');
+const GPP = findBin('g++');
+const JAVA = findBin('java');
+const JAVAC = findBin('javac');
+
+const SIGTERM_TIMEOUT = 5000;
+
+function killChild(child) {
+  try {
+    if (IS_WIN) spawn('taskkill', ['/pid', String(child.pid), '/t', '/f'], { stdio: 'ignore' });
+    else { child.kill('SIGTERM'); setTimeout(() => { try { if (!child.killed) child.kill('SIGKILL'); } catch {} }, SIGTERM_TIMEOUT); }
+  } catch {}
+}
+
+function makeTmp(ext, content) {
+  const dir = mkdtempSync(path.join(os.tmpdir(), 'glootie_'));
+  const file = path.join(dir, `code${ext}`);
+  writeFileSync(file, content);
+  return { dir, file };
+}
+
+function spawnOpts(cwd) {
+  return { cwd: cwd || process.cwd(), stdio: ['pipe', 'pipe', 'pipe'], detached: false };
+}
+
+export function spawnProcess(runtime, code, cwd) {
+  let tmpDir = null;
+  const cleanup = () => { if (tmpDir) { try { rmSync(tmpDir, { recursive: true, force: true }); } catch {} tmpDir = null; } };
+
+  if (runtime === 'nodejs' || runtime === 'typescript') {
+    const child = spawn('bun', ['-e', code], spawnOpts(cwd));
+    return { child, cleanup };
+  }
+  if (runtime === 'python') {
+    const child = spawn(PYTHON, ['-c', code], spawnOpts(cwd));
+    return { child, cleanup };
+  }
+  if (runtime === 'powershell') {
+    const child = spawn(POWERSHELL, ['-NoProfile', '-NonInteractive', '-Command', code], spawnOpts(cwd));
+    return { child, cleanup };
+  }
+  if (runtime === 'cmd') {
+    const child = spawn('cmd.exe', ['/c', code], spawnOpts(cwd));
+    return { child, cleanup };
+  }
+  if (runtime === 'bash') {
+    if (IS_WIN) {
+      const { dir, file } = makeTmp('.ps1', `$ErrorActionPreference = 'Continue'\n${code}`);
+      tmpDir = dir;
+      const child = spawn(POWERSHELL, ['-NoProfile', '-NonInteractive', '-File', file], spawnOpts(cwd));
+      return { child, cleanup };
+    }
+    const child = spawn(SHELL, ['-c', code], spawnOpts(cwd));
+    return { child, cleanup };
+  }
+  if (runtime === 'deno') {
+    const { dir, file } = makeTmp('.ts', code);
+    tmpDir = dir;
+    const child = spawn(DENO, ['run', '--no-check', file], spawnOpts(cwd));
+    return { child, cleanup };
+  }
+  if (['go', 'rust', 'c', 'cpp'].includes(runtime)) {
+    const ext = { go: '.go', rust: '.rs', c: '.c', cpp: '.cpp' }[runtime];
+    const { dir, file } = makeTmp(ext, code);
+    tmpDir = dir;
+    const binExt = IS_WIN ? '.exe' : '';
+    const binPath = path.join(dir, `code${binExt}`);
+    if (runtime === 'go') {
+      const child = spawn(GO, ['run', file], spawnOpts(cwd));
+      return { child, cleanup };
+    }
+    const compiler = { rust: RUSTC, c: GCC, cpp: GPP }[runtime];
+    const compileArgs = runtime === 'rust' ? [file, '-o', binPath] : [file, '-o', binPath, '-I', cwd];
+    const compileChild = spawn(compiler, compileArgs, spawnOpts(cwd));
+    return { child: compileChild, isCompile: true, binPath, cleanup, dir, killChild };
+  }
+  if (runtime === 'java') {
+    const className = 'Main';
+    const { dir, file } = makeTmp('.java', `public class ${className} {\n  public static void main(String[] args) {\n${code.split('\n').map(l => '    ' + l).join('\n')}\n  }\n}`);
+    tmpDir = dir;
+    const cpSep = IS_WIN ? ';' : ':';
+    const cp = [dir, cwd].join(cpSep);
+    const compileChild = spawn(JAVAC, ['-cp', cp, file.replace('.java', '.java')], spawnOpts(cwd));
+    return { child: compileChild, isCompile: true, runtime: 'java', dir, cp, className, cleanup, killChild };
+  }
+  throw new Error(`Unsupported runtime: ${runtime}`);
+}
+
+export { killChild };