Update simple-sandbox-manager.js

simple-sandbox-manager.js

@@ -1,23 +1,19 @@
-// simple-sandbox-manager.js
-
 const { spawn } = require('child_process');
 const fs = require('fs').promises;
 const path = require('path');
-const { EventEmitter } = require('events');
 
-class SimpleSandboxManager extends EventEmitter {
+class SimpleSandboxManager {
   constructor() {
-    super();
     this.sandboxes = new Map();
-    this.basePath = path.join('/tmp', 'sandboxes'); // Use path.join for cross-OS compatibility
-    this.portCounter = 9000; // Start from a higher port range
+    this.basePath = path.join('/tmp', 'sandboxes');
+    this.portCounter = 9000;
     this.streamClients = new Map();
     this.commandData = new Map();
   }
 
   async initialize() {
     await fs.mkdir(this.basePath, { recursive: true });
-    console.log('✅ Sandbox Manager initialized');
+    console.log('✅ Sandbox Manager initialized at:', this.basePath);
   }
 
   async createSandbox(sandboxId, options = {}) {
@@ -34,16 +30,11 @@ class SimpleSandboxManager extends EventEmitter {
       timeout,
       createdAt: Date.now(),
       lastActivity: Date.now(),
-      status: 'ready',
-      url: null, // To be set when a service starts
+      url: `http://localhost:${port}`,
     };
     
     this.sandboxes.set(sandboxId, sandbox);
-    // Associate port with sandbox for URL lookup
-    // This is a simple way to assign a URL. In a real scenario, a proxy manager would handle this.
-    sandbox.url = `http://localhost:${port}`;
-    console.log(`✅ Sandbox created: ${sandboxId} at ${sandboxPath} (URL: ${sandbox.url})`);
-    
+    console.log(`✅ Sandbox created: ${sandboxId} | URL: ${sandbox.url}`);
     return sandbox;
   }
   
@@ -53,87 +44,66 @@ class SimpleSandboxManager extends EventEmitter {
       return (Date.now() - sandbox.createdAt) > sandbox.timeout;
   }
 
-  addStreamClient(sandboxId, commandId, res) {
-    const key = `${sandboxId}:${commandId}`;
-    if (!this.streamClients.has(key)) {
-      this.streamClients.set(key, []);
-    }
+  addStreamClient(id, cmdId, res) {
+    const key = `${id}:${cmdId}`;
+    if (!this.streamClients.has(key)) this.streamClients.set(key, []);
     this.streamClients.get(key).push(res);
   }
   
-  removeStreamClient(sandboxId, commandId, res) {
-      const key = `${sandboxId}:${commandId}`;
-      const clients = this.streamClients.get(key);
-      if (clients) {
-          const index = clients.indexOf(res);
-          if (index > -1) clients.splice(index, 1);
-          if (clients.length === 0) {
-              this.streamClients.delete(key);
-          }
-      }
+  removeStreamClient(id, cmdId, res) {
+    const key = `${id}:${cmdId}`;
+    const clients = this.streamClients.get(key);
+    if (clients) {
+      const index = clients.indexOf(res);
+      if (index > -1) clients.splice(index, 1);
+      if (clients.length === 0) this.streamClients.delete(key);
+    }
   }
 
-  sendToStreamClients(sandboxId, commandId, type, data) {
-    const key = `${sandboxId}:${commandId}`;
+  sendToStreamClients(id, cmdId, type, data) {
+    const key = `${id}:${cmdId}`;
     const clients = this.streamClients.get(key);
-    
-    if (clients && clients.length > 0) {
-      const message = `data: ${JSON.stringify({ type, data, timestamp: Date.now() })}\n\n`;
-      clients.forEach(client => {
-        try {
-          client.write(message);
-        } catch (e) {
-          console.error('Stream write error:', e.message);
-          // Client probably disconnected, remove them
-          this.removeStreamClient(sandboxId, commandId, client);
-        }
-      });
-    }
+    if (!clients || clients.length === 0) return;
+
+    const message = `data: ${JSON.stringify({ type, data, timestamp: Date.now() })}\n\n`;
+    clients.forEach(client => {
+      try {
+        client.write(message);
+      } catch (e) {
+        this.removeStreamClient(id, cmdId, client);
+      }
+    });
   }
 
-  async executeCommand(sandboxId, command, options = {}) {
+  async executeCommand(sandboxId, command) {
     const sandbox = this.sandboxes.get(sandboxId);
     if (!sandbox) throw new Error('Sandbox not found');
-    
     sandbox.lastActivity = Date.now();
-    
-    const { background = false, timeout = 300000 } = options;
-    
-    // Command is executed inside the sandbox's path
+
     const proc = spawn(command, [], {
       cwd: sandbox.path,
-      shell: true, // Use shell to interpret the command string
+      shell: true,
       stdio: ['ignore', 'pipe', 'pipe'],
-      env: {
-        ...process.env,
-        PORT: sandbox.port.toString(), // Inject PORT for services like `npm start`
-        NODE_ENV: 'development',
-        PYTHONUNBUFFERED: '1',
-      }
+      env: { ...process.env, PORT: sandbox.port.toString() },
     });
       
-    const cmdId = `cmd-${proc.pid}-${Date.now()}`;
+    const cmdId = `cmd-${proc.pid}`;
     const dataKey = `${sandboxId}:${cmdId}`;
       
-    this.commandData.set(dataKey, {
-      stdout: '',
-      stderr: '',
-      exitCode: null,
-      startedAt: Date.now()
-    });
+    this.commandData.set(dataKey, { stdout: '', stderr: '', exitCode: null, startedAt: Date.now() });
 
     console.log(`[${sandboxId}] CMD (${cmdId}): ${command}`);
       
     proc.stdout.on('data', (data) => {
-      const output = data.toString();
-      this.commandData.get(dataKey).stdout += output;
-      this.sendToStreamClients(sandboxId, cmdId, 'stdout', output);
+      const out = data.toString();
+      this.commandData.get(dataKey).stdout += out;
+      this.sendToStreamClients(sandboxId, cmdId, 'stdout', out);
     });
       
     proc.stderr.on('data', (data) => {
-      const output = data.toString();
-      this.commandData.get(dataKey).stderr += output;
-      this.sendToStreamClients(sandboxId, cmdId, 'stderr', output);
+      const err = data.toString();
+      this.commandData.get(dataKey).stderr += err;
+      this.sendToStreamClients(sandboxId, cmdId, 'stderr', err);
     });
       
     proc.on('exit', (code) => {
@@ -141,20 +111,19 @@ class SimpleSandboxManager extends EventEmitter {
       const cmdData = this.commandData.get(dataKey);
       if (cmdData) cmdData.exitCode = code;
       this.sendToStreamClients(sandboxId, cmdId, 'complete', { exitCode: code });
-       // Clean up old command data after a while
-      setTimeout(() => this.commandData.delete(dataKey), 5 * 60 * 1000);
+      setTimeout(() => this.commandData.delete(dataKey), 10 * 60 * 1000); // 10 min cleanup
     });
       
-    proc.on('error', (error) => {
-      console.error(`[${sandboxId}] CMD (${cmdId}) error:`, error);
-      this.sendToStreamClients(sandboxId, cmdId, 'error', error.message);
+    proc.on('error', (err) => {
+      console.error(`[${sandboxId}] CMD (${cmdId}) error:`, err);
+      this.sendToStreamClients(sandboxId, cmdId, 'error', err.message);
     });
 
-    return {
-      commandId: cmdId,
-      status: 'running',
-      streaming: true
-    };
+    return { commandId: cmdId };
+  }
+  
+  getCommandData(sandboxId, cmdId) {
+    return this.commandData.get(`${sandboxId}:${cmdId}`);
   }
 
   async writeFile(sandboxId, filePath, content) {
@@ -163,26 +132,14 @@ class SimpleSandboxManager extends EventEmitter {
     sandbox.lastActivity = Date.now();
     
     const fullPath = path.join(sandbox.path, filePath);
-    const dir = path.dirname(fullPath);
-    
-    await fs.mkdir(dir, { recursive: true });
+    await fs.mkdir(path.dirname(fullPath), { recursive: true });
     await fs.writeFile(fullPath, content, 'utf-8');
-    
     console.log(`📝 File written to ${sandboxId}: ${filePath}`);
   }
 
-  async readFile(sandboxId, filePath) {
-    const sandbox = this.sandboxes.get(sandboxId);
-    if (!sandbox) throw new Error('Sandbox not found');
-    
-    const fullPath = path.join(sandbox.path, filePath);
-    return fs.readFile(fullPath, 'utf-8');
-  }
-
   async getURL(sandboxId) {
     const sandbox = this.sandboxes.get(sandboxId);
     if (!sandbox) throw new Error('Sandbox not found');
-    if (!sandbox.url) throw new Error('URL not available for this sandbox');
     return sandbox.url;
   }
   
@@ -191,25 +148,17 @@ class SimpleSandboxManager extends EventEmitter {
     if (!sandbox) return;
     
     console.log(`🧹 Destroying sandbox: ${sandboxId}`);
-    
     this.sandboxes.delete(sandboxId);
     
     try {
-      // The `force` option is deprecated, use `rm` which is equivalent
       await fs.rm(sandbox.path, { recursive: true, force: true });
     } catch (e) {
-      // Ignore errors if path is already gone
-      if (e.code !== 'ENOENT') {
-        console.error(`File cleanup error for ${sandboxId}:`, e.message);
-      }
+      if (e.code !== 'ENOENT') console.error(`Cleanup error for ${sandboxId}:`, e.message);
     }
-    console.log(`✅ Sandbox destroyed: ${sandboxId}`);
   }
   
   async destroyAllSandboxes() {
-      for (const id of this.sandboxes.keys()) {
-          await this.destroySandbox(id);
-      }
+    await Promise.all(Array.from(this.sandboxes.keys()).map(id => this.destroySandbox(id)));
   }
 
   getSandbox(sandboxId) {
@@ -219,11 +168,8 @@ class SimpleSandboxManager extends EventEmitter {
   async cleanupInactive() {
     const now = Date.now();
     for (const [id, sandbox] of this.sandboxes.entries()) {
-      const inactive = (now - sandbox.lastActivity) > (15 * 60 * 1000); // 15 mins inactive
-      const timedOut = (now - sandbox.createdAt) > sandbox.timeout;
-      
-      if (inactive || timedOut) {
-        console.log(`⏰ Cleaning up sandbox: ${id} (${timedOut ? 'global timeout' : 'inactive'})`);
+      if ((now - sandbox.createdAt) > sandbox.timeout) {
+        console.log(`⏰ Cleaning up timed-out sandbox: ${id}`);
         await this.destroySandbox(id);
       }
     }