Update server.js

server.js

@@ -13,6 +13,7 @@ const sandboxManager = new SimpleSandboxManager();
   console.log('🚀 Sandbox Manager ready');
 })();
 
+// Health check
 app.get('/health', (req, res) => {
   res.status(200).json({ 
     status: 'healthy',
@@ -20,126 +21,117 @@ app.get('/health', (req, res) => {
   });
 });
 
+// Root endpoint
 app.get('/', (req, res) => {
   res.json({
     status: 'running',
     sandboxes: sandboxManager.sandboxes.size,
     processes: sandboxManager.processes.size,
-    message: '🚀 Simple Sandbox API'
+    message: '🚀 Vercel-Compatible Sandbox API'
   });
 });
 
+// Create sandbox (with Vercel-compatible params)
 app.post('/api/sandbox/create', async (req, res) => {
   try {
     const { timeout = 600000, ports = [] } = req.body;
-    const sandboxId = 'sbx-' + Date.now() + '-' + Math.random().toString(36).substr(2, 9);
+    const sandboxId = `sbx_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    
     const sandbox = await sandboxManager.createSandbox(sandboxId, { timeout, ports });
     
     res.json({
       sandboxId,
       status: 'ready',
       path: sandbox.workspacePath,
-      ports: sandbox.ports
+      port: sandbox.port,
+      timeout,
+      exposedPorts: ports
     });
   } catch (error) {
     console.error('❌ Create error:', error);
-    res.status(500).json({ 
-      error: {
-        code: 'sandbox_creation_failed',
-        message: error.message
-      }
-    });
+    res.status(500).json({ error: error.message });
   }
 });
 
-app.get('/api/sandbox/:sandboxId', async (req, res) => {
+// Get sandbox status (Vercel-compatible)
+app.get('/api/sandbox/:id/status', async (req, res) => {
   try {
-    const { sandboxId } = req.params;
-    const sandbox = sandboxManager.getSandbox(sandboxId);
+    const { id } = req.params;
+    const sandbox = sandboxManager.getSandbox(id);
     
     if (!sandbox) {
       return res.status(404).json({ 
-        error: {
-          code: 'sandbox_not_found',
-          message: 'Sandbox not found'
-        }
+        status: 'stopped',
+        error: 'Sandbox not found' 
       });
     }
-
-    if (sandbox.status === 'stopped') {
-      return res.json({ 
-        error: {
-          code: 'sandbox_stopped',
-          message: 'Sandbox has been stopped'
-        }
-      });
+    
+    // Check if sandbox timed out
+    const elapsed = Date.now() - sandbox.createdAt;
+    if (elapsed > sandbox.timeout) {
+      await sandboxManager.destroySandbox(id);
+      return res.json({ status: 'stopped' });
     }
-
-    res.json({ 
-      sandboxId: sandbox.sandboxId,
-      status: sandbox.status 
-    });
+    
+    res.json({ status: 'running', sandboxId: id });
   } catch (error) {
-    console.error('❌ Get sandbox error:', error);
+    console.error('❌ Status error:', error);
     res.status(500).json({ error: error.message });
   }
 });
 
-app.post('/api/sandbox/:sandboxId/command', async (req, res) => {
+// Execute command (sync)
+app.post('/api/sandbox/:id/command', async (req, res) => {
   try {
-    const { sandboxId } = req.params;
-    const { command, args = [], sudo = false, wait = true } = req.body;
+    const { id } = req.params;
+    const { command, args = [], background = false, sudo = false } = req.body;
     
-    const result = await sandboxManager.executeCommand(sandboxId, command, args, { 
-      wait, 
-      sudo,
-      background: !wait 
-    });
+    // Security: Block sudo if not explicitly allowed
+    if (sudo) {
+      return res.status(403).json({ error: 'Sudo commands not allowed' });
+    }
     
+    const result = await sandboxManager.executeCommand(id, command, args, { background });
     res.json(result);
   } catch (error) {
     console.error('❌ Command error:', error);
-    res.status(500).json({ 
-      error: {
-        code: 'command_execution_failed',
-        message: error.message
-      }
-    });
+    res.status(500).json({ error: error.message });
   }
 });
 
-app.get('/api/sandbox/:sandboxId/cmds/:cmdId', async (req, res) => {
+// Get command info (Vercel-compatible)
+app.get('/api/sandbox/:id/cmds/:cmdId', async (req, res) => {
   try {
-    const { sandboxId, cmdId } = req.params;
-    const command = sandboxManager.getCommand(sandboxId, cmdId);
+    const { id, cmdId } = req.params;
+    const procInfo = sandboxManager.getProcess(id);
     
-    if (!command) {
-      return res.status(404).json({ 
-        error: {
-          code: 'command_not_found',
-          message: 'Command not found'
-        }
+    if (!procInfo || procInfo.cmdId !== cmdId) {
+      return res.json({
+        sandboxId: id,
+        cmdId,
+        exitCode: null,
+        startedAt: null
       });
     }
-
+    
     res.json({
-      sandboxId,
-      cmdId: command.cmdId,
-      startedAt: command.startedAt,
-      exitCode: command.exitCode,
-      status: command.status
+      sandboxId: id,
+      cmdId: procInfo.cmdId,
+      startedAt: procInfo.startedAt,
+      exitCode: procInfo.process.exitCode
     });
   } catch (error) {
-    console.error('❌ Get command error:', error);
     res.status(500).json({ error: error.message });
   }
 });
 
-app.get('/api/sandbox/:sandboxId/cmds/:cmdId/logs', (req, res) => {
-  const { sandboxId, cmdId } = req.params;
+// SSE endpoint for command logs (Vercel-compatible)
+app.get('/api/sandbox/:id/command/:cmdId/stream', (req, res) => {
+  const { id, cmdId } = req.params;
   
-  console.log('📡 SSE logs connection for ' + sandboxId + '/' + cmdId);
+  console.log(`📡 SSE connection opened for ${id}/${cmdId}`);
   
+  // Set SSE headers
   res.setHeader('Content-Type', 'text/event-stream');
   res.setHeader('Cache-Control', 'no-cache');
   res.setHeader('Connection', 'keep-alive');
@@ -148,128 +140,79 @@ app.get('/api/sandbox/:sandboxId/cmds/:cmdId/logs', (req, res) => {
   
   res.flushHeaders();
   
-  const command = sandboxManager.getCommand(sandboxId, cmdId);
-  
-  if (!command) {
-    res.write('data: ' + JSON.stringify({ 
-      error: 'Command not found' 
-    }) + '
+  // Send connection message
+  res.write(`data: ${JSON.stringify({ type: 'connected', message: 'Stream connected' })}
 
-');
-    res.end();
-    return;
-  }
-
-  if (command.logs && command.logs.length > 0) {
-    command.logs.forEach(log => {
-      res.write(JSON.stringify({
-        data: log.data,
-        stream: log.stream,
-        timestamp: log.timestamp
-      }) + '
-');
-    });
-  }
-
-  sandboxManager.addLogStream(sandboxId, cmdId, res);
+`);
+  
+  sandboxManager.addStreamClient(id, cmdId, res);
   
+  // Keep-alive
   const keepAlive = setInterval(() => {
-    try {
-      res.write(': keepalive
+    res.write(`: keepalive
 
-');
-    } catch (e) {
-      clearInterval(keepAlive);
-    }
+`);
   }, 15000);
   
   req.on('close', () => {
     clearInterval(keepAlive);
-    console.log('📡 SSE logs connection closed for ' + sandboxId + '/' + cmdId);
+    console.log(`📡 SSE connection closed for ${id}/${cmdId}`);
     res.end();
   });
 });
 
-app.post('/api/sandbox/:sandboxId/files', async (req, res) => {
+// Write files (Vercel-compatible format)
+app.post('/api/sandbox/:id/files', async (req, res) => {
   try {
-    const { sandboxId } = req.params;
+    const { id } = req.params;
     const { files } = req.body;
     
-    await sandboxManager.writeFiles(sandboxId, files);
+    await sandboxManager.writeFiles(id, files);
     res.json({ success: true, filesWritten: files.length });
   } catch (error) {
     console.error('❌ File write error:', error);
-    res.status(500).json({ 
-      error: {
-        code: 'file_write_failed',
-        message: error.message
-      }
-    });
+    res.status(500).json({ error: error.message });
   }
 });
 
-app.get('/api/sandbox/:sandboxId/files', async (req, res) => {
+// Read file (streaming)
+app.get('/api/sandbox/:id/files', async (req, res) => {
   try {
-    const { sandboxId } = req.params;
+    const { id } = req.params;
     const { path: filePath } = req.query;
     
-    if (!filePath) {
-      return res.status(400).json({ 
-        error: 'Invalid parameters. You must pass a `path` as query' 
-      });
-    }
-
-    const stream = await sandboxManager.readFileStream(sandboxId, filePath);
-    
-    if (!stream) {
-      return res.status(404).json({ 
-        error: 'File not found in the Sandbox' 
-      });
-    }
-
-    res.setHeader('Content-Type', 'application/octet-stream');
-    stream.pipe(res);
+    const content = await sandboxManager.readFile(id, filePath);
+    res.send(content);
   } catch (error) {
     console.error('❌ File read error:', error);
     res.status(404).json({ error: 'File not found' });
   }
 });
 
-app.get('/api/sandbox/:sandboxId/url', async (req, res) => {
+// Get sandbox URL
+app.get('/api/sandbox/:id/url', async (req, res) => {
   try {
-    const { sandboxId } = req.params;
-    const { port } = req.query;
+    const { id } = req.params;
+    const { port = 3000 } = req.query;
+    const procInfo = sandboxManager.getProcess(id);
     
-    const sandbox = sandboxManager.getSandbox(sandboxId);
-    if (!sandbox) {
-      return res.status(404).json({ error: 'Sandbox not found' });
-    }
-
-    const targetPort = port ? parseInt(port) : sandbox.ports[0];
-    
-    if (!targetPort) {
-      return res.json({
-        url: null,
-        status: 'no port exposed'
-      });
-    }
-
-    const baseUrl = process.env.SPACE_HOST || 'localhost:7860';
-    const url = 'https://' + baseUrl + '/preview/' + targetPort + '/';
+    const spaceHost = process.env.SPACE_HOST || 'http://localhost:7860';
+    const previewPort = procInfo?.port || port;
     
     res.json({
-      url,
-      status: 'running',
-      port: targetPort
+      url: `${spaceHost}/preview/${previewPort}/`,
+      status: procInfo ? 'running' : 'no process',
+      port: previewPort
     });
   } catch (error) {
     res.status(500).json({ error: error.message });
   }
 });
 
-app.delete('/api/sandbox/:sandboxId', async (req, res) => {
+// Delete sandbox
+app.delete('/api/sandbox/:id', async (req, res) => {
   try {
-    await sandboxManager.destroySandbox(req.params.sandboxId);
+    await sandboxManager.destroySandbox(req.params.id);
     res.json({ success: true });
   } catch (error) {
     console.error('❌ Delete error:', error);
@@ -277,15 +220,18 @@ app.delete('/api/sandbox/:sandboxId', async (req, res) => {
   }
 });
 
+// Auto cleanup with timeout awareness
 setInterval(() => {
   sandboxManager.cleanupInactive();
 }, 2 * 60 * 1000);
 
-const PORT = process.env.PORT || 7860;
+const PORT = 3001; // Internal port, Nginx proxies from 7860
 app.listen(PORT, '0.0.0.0', () => {
-  console.log('🚀 Sandbox API running on port ' + PORT);
+  console.log(`🚀 Sandbox API running on port ${PORT}`);
+  console.log(`🌐 Nginx proxying from port 7860`);
 });
 
+// Graceful shutdown
 process.on('SIGTERM', async () => {
   console.log('⚠️ Shutting down...');
   for (const [id] of sandboxManager.sandboxes.entries()) {