Update simple-sandbox-manager.js

simple-sandbox-manager.js

@@ -1,5 +1,6 @@
 const { spawn, exec } = require('child_process');
 const fs = require('fs').promises;
+const fsSync = require('fs');
 const path = require('path');
 const { EventEmitter } = require('events');
 
@@ -7,10 +8,10 @@ class SimpleSandboxManager extends EventEmitter {
   constructor() {
     super();
     this.sandboxes = new Map();
-    this.processes = new Map();
+    this.commands = new Map();
+    this.logStreams = new Map();
     this.basePath = '/tmp/sandboxes';
     this.portCounter = 3000;
-    this.streamClients = new Map();
   }
 
   async initialize() {
@@ -18,60 +19,81 @@ class SimpleSandboxManager extends EventEmitter {
     console.log('✅ Simple Sandbox Manager initialized');
   }
 
-  async createSandbox(sandboxId) {
+  async createSandbox(sandboxId, options = {}) {
+    const { timeout = 600000, ports = [] } = options;
     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 assignedPorts = ports.length > 0 ? ports : [this.portCounter++];
     
     const sandbox = {
       sandboxId,
       path: sandboxPath,
       workspacePath,
-      port,
+      ports: assignedPorts,
       createdAt: Date.now(),
       lastActivity: Date.now(),
-      status: 'ready'
+      status: 'ready',
+      timeout
     };
     
     this.sandboxes.set(sandboxId, sandbox);
-    console.log(`✅ Sandbox created: ${sandboxId} (port: ${port})`);
+    
+    if (timeout > 0) {
+      setTimeout(() => {
+        this.stopSandbox(sandboxId);
+      }, timeout);
+    }
+    
+    console.log(`✅ Sandbox created: ${sandboxId} (ports: ${assignedPorts.join(', ')})`);
     
     return sandbox;
   }
 
-  addStreamClient(sandboxId, commandId, res) {
-    const key = `${sandboxId}:${commandId}`;
-    if (!this.streamClients.has(key)) {
-      this.streamClients.set(key, []);
+  async stopSandbox(sandboxId) {
+    const sandbox = this.sandboxes.get(sandboxId);
+    if (sandbox && sandbox.status !== 'stopped') {
+      sandbox.status = 'stopped';
+      console.log(`⏹️ Sandbox stopped: ${sandboxId}`);
     }
-    this.streamClients.get(key).push(res);
+  }
+
+  addLogStream(sandboxId, cmdId, stream) {
+    const key = `${sandboxId}:${cmdId}`;
+    if (!this.logStreams.has(key)) {
+      this.logStreams.set(key, []);
+    }
+    this.logStreams.get(key).push(stream);
     
-    res.on('close', () => {
-      const clients = this.streamClients.get(key);
-      if (clients) {
-        const index = clients.indexOf(res);
-        if (index > -1) clients.splice(index, 1);
+    stream.on('close', () => {
+      const streams = this.logStreams.get(key);
+      if (streams) {
+        const index = streams.indexOf(stream);
+        if (index > -1) streams.splice(index, 1);
       }
     });
   }
 
-  sendToStreamClients(sandboxId, commandId, type, data) {
-    const key = `${sandboxId}:${commandId}`;
-    const clients = this.streamClients.get(key);
+  sendToLogStreams(sandboxId, cmdId, data, streamType) {
+    const key = `${sandboxId}:${cmdId}`;
+    const streams = this.logStreams.get(key);
     
-    if (clients && clients.length > 0) {
-      const message = `data: ${JSON.stringify({ type, data, timestamp: Date.now() })}
-
-`;
-      clients.forEach(client => {
+    if (streams && streams.length > 0) {
+      const logEntry = JSON.stringify({
+        data,
+        stream: streamType,
+        timestamp: Date.now()
+      }) + '
+';
+      
+      streams.forEach(stream => {
         try {
-          client.write(message);
+          stream.write(logEntry);
         } catch (e) {
-          console.error('Stream write error:', e);
+          console.error('Log stream write error:', e);
         }
       });
     }
@@ -81,12 +103,16 @@ class SimpleSandboxManager extends EventEmitter {
     const sandbox = this.sandboxes.get(sandboxId);
     if (!sandbox) throw new Error('Sandbox not found');
     
+    if (sandbox.status === 'stopped') {
+      throw new Error('Sandbox has been stopped');
+    }
+    
     sandbox.lastActivity = Date.now();
     
-    const { background = false, timeout = 300000, stream = false } = options;
+    const { wait = true, sudo = false, background = false } = options;
     
     const allowedCommands = [
-      'node', 'npm', 'npx', 'python3', 'python', 'pip', 
+      'node', 'npm', 'npx', 'pnpm', 'yarn', 'python3', 'python', 'pip', 
       'go', 'cat', 'ls', 'mkdir', 'echo', 'touch', 
       'rm', 'cp', 'mv', 'pwd', 'which', 'sh', 'bash', 'chmod'
     ];
@@ -96,133 +122,73 @@ class SimpleSandboxManager extends EventEmitter {
       throw new Error(`Command not allowed: ${baseCommand}`);
     }
     
-    const fullCommand = `${command} ${args.join(' ')}`;
+    const fullCommand = args.length > 0 ? `${command} ${args.join(' ')}` : command;
     
-    if (background) {
-      return this.startBackgroundProcess(sandboxId, fullCommand, sandbox.workspacePath, sandbox.port);
-    } else if (stream) {
-      return this.startStreamingCommand(sandboxId, fullCommand, sandbox.workspacePath, timeout);
+    if (background || !wait) {
+      return this.startBackgroundCommand(sandboxId, fullCommand, sandbox.workspacePath, sandbox.ports[0]);
     } else {
-      return this.runSyncCommand(fullCommand, sandbox.workspacePath, timeout);
+      return this.runSyncCommand(sandboxId, fullCommand, sandbox.workspacePath);
     }
   }
 
-  startStreamingCommand(sandboxId, command, cwd, timeout) {
+  startBackgroundCommand(sandboxId, command, cwd, port) {
     return new Promise((resolve, reject) => {
-      const cmdId = `cmd-${Date.now()}`;
+      const cmdId = `cmd-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+      const startedAt = Date.now();
       
       const proc = spawn('sh', ['-c', command], {
         cwd,
+        detached: true,
         stdio: ['ignore', 'pipe', 'pipe'],
         env: {
           ...process.env,
-          NODE_ENV: 'sandbox',
-          PYTHONUNBUFFERED: '1'
+          PORT: port.toString(),
+          NODE_ENV: 'development'
         }
       });
       
-      let stdout = '';
-      let stderr = '';
-      let completed = false;
+      proc.unref();
       
-      const timeoutId = setTimeout(() => {
-        if (!completed) {
-          proc.kill('SIGTERM');
-          this.sendToStreamClients(sandboxId, cmdId, 'error', 'Command timeout');
-        }
-      }, timeout);
+      const commandInfo = {
+        cmdId,
+        sandboxId,
+        process: proc,
+        command,
+        port,
+        startedAt,
+        logs: [],
+        status: 'running',
+        exitCode: null
+      };
+      
+      this.commands.set(`${sandboxId}:${cmdId}`, commandInfo);
       
       proc.stdout.on('data', (data) => {
         const output = data.toString();
-        stdout += output;
-        console.log(`[${sandboxId}][stdout]: ${output.trim()}`);
-        this.sendToStreamClients(sandboxId, cmdId, 'stdout', output);
+        const log = { data: output, stream: 'stdout', timestamp: Date.now() };
+        commandInfo.logs.push(log);
+        this.sendToLogStreams(sandboxId, cmdId, output, 'stdout');
+        console.log(`[${sandboxId}][${cmdId}][stdout]: ${output.trim()}`);
       });
       
       proc.stderr.on('data', (data) => {
         const output = data.toString();
-        stderr += output;
-        console.log(`[${sandboxId}][stderr]: ${output.trim()}`);
-        this.sendToStreamClients(sandboxId, cmdId, 'stderr', output);
+        const log = { data: output, stream: 'stderr', timestamp: Date.now() };
+        commandInfo.logs.push(log);
+        this.sendToLogStreams(sandboxId, cmdId, output, 'stderr');
+        console.log(`[${sandboxId}][${cmdId}][stderr]: ${output.trim()}`);
       });
       
       proc.on('exit', (code) => {
-        completed = true;
-        clearTimeout(timeoutId);
-        
-        console.log(`[${sandboxId}] Command exited with code: ${code}`);
-        
-        this.sendToStreamClients(sandboxId, cmdId, 'complete', {
-          exitCode: code,
-          stdout,
-          stderr
-        });
-        
-        resolve({
-          commandId: cmdId,
-          exitCode: code,
-          stdout,
-          stderr,
-          streaming: true
-        });
+        commandInfo.exitCode = code;
+        commandInfo.status = 'done';
+        console.log(`[${sandboxId}][${cmdId}] Process exited with code: ${code}`);
       });
       
       proc.on('error', (error) => {
-        completed = true;
-        clearTimeout(timeoutId);
-        this.sendToStreamClients(sandboxId, cmdId, 'error', error.message);
-        reject(error);
-      });
-      
-      setTimeout(() => {
-        if (!completed) {
-          resolve({
-            commandId: cmdId,
-            status: 'streaming',
-            message: 'Command started, streaming output'
-          });
-        }
-      }, 100);
-    });
-  }
-
-  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()
+        commandInfo.status = 'error';
+        commandInfo.exitCode = 1;
+        console.error(`[${sandboxId}][${cmdId}] Error:`, error);
       });
       
       setTimeout(() => {
@@ -230,29 +196,56 @@ class SimpleSandboxManager extends EventEmitter {
           reject(new Error('Process exited immediately'));
         } else {
           resolve({
+            cmdId,
             commandId: cmdId,
             status: 'running',
             pid: proc.pid,
             port
           });
         }
-      }, 2000);
+      }, 1000);
     });
   }
 
-  runSyncCommand(command, cwd, timeout) {
+  runSyncCommand(sandboxId, command, cwd) {
     return new Promise((resolve, reject) => {
+      const cmdId = `cmd-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+      const startedAt = Date.now();
+      
+      const commandInfo = {
+        cmdId,
+        sandboxId,
+        command,
+        startedAt,
+        logs: [],
+        status: 'executing',
+        exitCode: null
+      };
+      
+      this.commands.set(`${sandboxId}:${cmdId}`, commandInfo);
+      
       exec(command, {
         cwd,
-        timeout,
+        timeout: 300000,
         maxBuffer: 10 * 1024 * 1024,
         env: {
           ...process.env,
           NODE_ENV: 'sandbox'
         }
       }, (error, stdout, stderr) => {
+        const exitCode = error ? (error.code || 1) : 0;
+        
+        commandInfo.exitCode = exitCode;
+        commandInfo.status = 'done';
+        commandInfo.logs.push(
+          { data: stdout, stream: 'stdout', timestamp: Date.now() },
+          { data: stderr, stream: 'stderr', timestamp: Date.now() }
+        );
+        
         resolve({
-          exitCode: error ? (error.code || 1) : 0,
+          cmdId,
+          commandId: cmdId,
+          exitCode,
           stdout: stdout.toString(),
           stderr: stderr.toString()
         });
@@ -260,21 +253,8 @@ class SimpleSandboxManager extends EventEmitter {
     });
   }
 
-  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;
-    }
+  getCommand(sandboxId, cmdId) {
+    return this.commands.get(`${sandboxId}:${cmdId}`);
   }
 
   async writeFiles(sandboxId, files) {
@@ -304,18 +284,18 @@ class SimpleSandboxManager extends EventEmitter {
     return content;
   }
 
-  async listFiles(sandboxId, dirPath = '.') {
+  async readFileStream(sandboxId, filePath) {
     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 });
+    const fullPath = path.join(sandbox.workspacePath, filePath);
     
-    return files.map(file => ({
-      name: file.name,
-      isDirectory: file.isDirectory(),
-      path: path.join(dirPath, file.name)
-    }));
+    try {
+      await fs.access(fullPath);
+      return fsSync.createReadStream(fullPath);
+    } catch (e) {
+      return null;
+    }
   }
 
   async destroySandbox(sandboxId) {
@@ -324,13 +304,16 @@ class SimpleSandboxManager extends EventEmitter {
     
     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);
+    for (const [key, cmd] of this.commands.entries()) {
+      if (key.startsWith(`${sandboxId}:`)) {
+        if (cmd.process) {
+          try {
+            process.kill(-cmd.process.pid, 'SIGTERM');
+          } catch (e) {
+            console.error('Process kill error:', e.message);
+          }
+        }
+        this.commands.delete(key);
       }
     }
     
@@ -348,10 +331,6 @@ class SimpleSandboxManager extends EventEmitter {
     return this.sandboxes.get(sandboxId);
   }
 
-  getProcess(sandboxId) {
-    return this.processes.get(sandboxId);
-  }
-
   async cleanupInactive(inactiveTimeout = 15 * 60 * 1000) {
     const now = Date.now();