Create simple-sandbox-manager.js

simple-sandbox-manager.js

@@ -0,0 +1,249 @@
+const { spawn, exec } = require('child_process');
+const fs = require('fs').promises;
+const path = require('path');
+
+class SimpleSandboxManager {
+  constructor() {
+    this.sandboxes = new Map();
+    this.processes = new Map();
+    this.basePath = '/tmp/sandboxes';
+    this.portCounter = 3000;
+  }
+
+  async initialize() {
+    await fs.mkdir(this.basePath, { recursive: true });
+    console.log('✅ Simple Sandbox Manager initialized');
+  }
+
+  async createSandbox(sandboxId) {
+    const sandboxPath = path.join(this.basePath, sandboxId);
+    await fs.mkdir(sandboxPath, { recursive: true });
+    
+    const workspacePath = path.join(sandboxPath, 'workspace');
+    await fs.mkdir(workspacePath, { recursive: true });
+    
+    const port = this.portCounter++;
+    
+    const sandbox = {
+      sandboxId,
+      path: sandboxPath,
+      workspacePath,
+      port,
+      createdAt: Date.now(),
+      lastActivity: Date.now(),
+      status: 'ready'
+    };
+    
+    this.sandboxes.set(sandboxId, sandbox);
+    console.log(`✅ Sandbox created: ${sandboxId} (port: ${port})`);
+    
+    return sandbox;
+  }
+
+  async executeCommand(sandboxId, command, args = [], options = {}) {
+    const sandbox = this.sandboxes.get(sandboxId);
+    if (!sandbox) throw new Error('Sandbox not found');
+    
+    sandbox.lastActivity = Date.now();
+    
+    const { background = false, timeout = 300000 } = options;
+    
+    const allowedCommands = [
+      'node', 'npm', 'npx', 'python3', 'python', 'pip', 
+      'go', 'cat', 'ls', 'mkdir', 'echo', 'touch', 
+      'rm', 'cp', 'mv', 'pwd', 'which'
+    ];
+    
+    const baseCommand = command.split(' ')[0];
+    if (!allowedCommands.includes(baseCommand)) {
+      throw new Error(`Command not allowed: ${baseCommand}`);
+    }
+    
+    const fullCommand = `${command} ${args.join(' ')}`;
+    
+    if (background) {
+      return this.startBackgroundProcess(sandboxId, fullCommand, sandbox.workspacePath, sandbox.port);
+    } else {
+      return this.runSyncCommand(fullCommand, sandbox.workspacePath, timeout);
+    }
+  }
+
+  startBackgroundProcess(sandboxId, command, cwd, port) {
+    return new Promise((resolve, reject) => {
+      const cmdId = `cmd-${Date.now()}`;
+      
+      const proc = spawn('sh', ['-c', command], {
+        cwd,
+        detached: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: {
+          ...process.env,
+          PORT: port.toString(),
+          NODE_ENV: 'development'
+        }
+      });
+      
+      proc.unref();
+      
+      let stdout = '';
+      let stderr = '';
+      
+      proc.stdout.on('data', (data) => {
+        stdout += data.toString();
+        console.log(`[${sandboxId}][stdout]: ${data.toString().trim()}`);
+      });
+      
+      proc.stderr.on('data', (data) => {
+        stderr += data.toString();
+        console.log(`[${sandboxId}][stderr]: ${data.toString().trim()}`);
+      });
+      
+      this.processes.set(sandboxId, {
+        cmdId,
+        process: proc,
+        port,
+        stdout,
+        stderr,
+        startedAt: Date.now()
+      });
+      
+      setTimeout(() => {
+        if (proc.exitCode !== null) {
+          reject(new Error('Process exited immediately'));
+        } else {
+          resolve({
+            commandId: cmdId,
+            status: 'running',
+            pid: proc.pid,
+            port
+          });
+        }
+      }, 2000);
+    });
+  }
+
+  runSyncCommand(command, cwd, timeout) {
+    return new Promise((resolve, reject) => {
+      exec(command, {
+        cwd,
+        timeout,
+        maxBuffer: 10 * 1024 * 1024,
+        env: {
+          ...process.env,
+          NODE_ENV: 'sandbox'
+        }
+      }, (error, stdout, stderr) => {
+        resolve({
+          exitCode: error ? (error.code || 1) : 0,
+          stdout: stdout.toString(),
+          stderr: stderr.toString()
+        });
+      });
+    });
+  }
+
+  async stopCommand(sandboxId) {
+    const procInfo = this.processes.get(sandboxId);
+    if (!procInfo) {
+      throw new Error('No running process found');
+    }
+    
+    try {
+      process.kill(-procInfo.process.pid, 'SIGTERM');
+      this.processes.delete(sandboxId);
+      console.log(`🛑 Process stopped for ${sandboxId}`);
+      return { stopped: true };
+    } catch (e) {
+      console.error('Failed to stop process:', e);
+      throw e;
+    }
+  }
+
+  async writeFiles(sandboxId, files) {
+    const sandbox = this.sandboxes.get(sandboxId);
+    if (!sandbox) throw new Error('Sandbox not found');
+    
+    sandbox.lastActivity = Date.now();
+    
+    for (const file of files) {
+      const fullPath = path.join(sandbox.workspacePath, file.path);
+      const dir = path.dirname(fullPath);
+      
+      await fs.mkdir(dir, { recursive: true });
+      await fs.writeFile(fullPath, file.content, 'utf-8');
+      
+      console.log(`📝 File written: ${file.path}`);
+    }
+  }
+
+  async readFile(sandboxId, filePath) {
+    const sandbox = this.sandboxes.get(sandboxId);
+    if (!sandbox) throw new Error('Sandbox not found');
+    
+    const fullPath = path.join(sandbox.workspacePath, filePath);
+    const content = await fs.readFile(fullPath, 'utf-8');
+    
+    return content;
+  }
+
+  async listFiles(sandboxId, dirPath = '.') {
+    const sandbox = this.sandboxes.get(sandboxId);
+    if (!sandbox) throw new Error('Sandbox not found');
+    
+    const fullPath = path.join(sandbox.workspacePath, dirPath);
+    const files = await fs.readdir(fullPath, { withFileTypes: true });
+    
+    return files.map(file => ({
+      name: file.name,
+      isDirectory: file.isDirectory(),
+      path: path.join(dirPath, file.name)
+    }));
+  }
+
+  async destroySandbox(sandboxId) {
+    const sandbox = this.sandboxes.get(sandboxId);
+    if (!sandbox) return;
+    
+    console.log(`🧹 Destroying sandbox: ${sandboxId}`);
+    
+    const procInfo = this.processes.get(sandboxId);
+    if (procInfo) {
+      try {
+        process.kill(-procInfo.process.pid, 'SIGTERM');
+        this.processes.delete(sandboxId);
+      } catch (e) {
+        console.error('Process kill error:', e.message);
+      }
+    }
+    
+    try {
+      await fs.rm(sandbox.path, { recursive: true, force: true });
+    } catch (e) {
+      console.error('File cleanup error:', e.message);
+    }
+    
+    this.sandboxes.delete(sandboxId);
+    console.log(`✅ Sandbox destroyed: ${sandboxId}`);
+  }
+
+  getSandbox(sandboxId) {
+    return this.sandboxes.get(sandboxId);
+  }
+
+  getProcess(sandboxId) {
+    return this.processes.get(sandboxId);
+  }
+
+  async cleanupInactive(inactiveTimeout = 15 * 60 * 1000) {
+    const now = Date.now();
+    
+    for (const [id, sandbox] of this.sandboxes.entries()) {
+      if (now - sandbox.lastActivity > inactiveTimeout) {
+        console.log(`⏰ Cleaning up inactive sandbox: ${id}`);
+        await this.destroySandbox(id);
+      }
+    }
+  }
+}
+
+module.exports = SimpleSandboxManager;