Create server.js

server.js

@@ -8,6 +8,7 @@ const app = express();
 app.use(cors());
 app.use(express.json({ limit: '50mb' }));
 
+// Storage
 const sandboxes = new Map();
 const devServers = new Map();
 
@@ -16,6 +17,7 @@ app.get('/', (req, res) => {
   res.json({ 
     status: 'Sandbox server running',
     sandboxes: sandboxes.size,
+    devServers: devServers.size,
     timestamp: new Date().toISOString()
   });
 });
@@ -24,31 +26,34 @@ app.get('/', (req, res) => {
 app.post('/api/sandbox/create', async (req, res) => {
   try {
     const sandboxId = `sandbox-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    const sandboxPath = path.join('/tmp', sandboxId);
+    const sandboxPath = path.join('/tmp/sandboxes', sandboxId);
     
     await fs.mkdir(sandboxPath, { recursive: true });
+    
     sandboxes.set(sandboxId, { 
       path: sandboxPath,
-      createdAt: Date.now()
+      createdAt: Date.now(),
+      port: null
     });
     
     console.log(`✅ Sandbox created: ${sandboxId}`);
+    
     res.json({ 
       sandboxId, 
       status: 'ready',
       path: sandboxPath 
     });
   } catch (error) {
-    console.error('❌ Error:', error);
+    console.error('❌ Sandbox creation error:', error);
     res.status(500).json({ error: error.message });
   }
 });
 
-// Run command
+// Run command in sandbox
 app.post('/api/sandbox/:id/command', async (req, res) => {
   try {
     const { id } = req.params;
-    const { command, args = [] } = req.body;
+    const { command, args = [], wait = true } = req.body;
     const sandbox = sandboxes.get(id);
     
     if (!sandbox) {
@@ -58,26 +63,75 @@ app.post('/api/sandbox/:id/command', async (req, res) => {
     const fullCommand = `cd ${sandbox.path} && ${command} ${args.join(' ')}`;
     console.log(`⚡ Executing: ${fullCommand}`);
     
-    exec(fullCommand, { 
-      timeout: 300000,
-      maxBuffer: 10 * 1024 * 1024 
-    }, (error, stdout, stderr) => {
+    // Check if it's a dev server command
+    const isDevServer = command.includes('npm run dev') || 
+                       command.includes('vite') || 
+                       command.includes('npm start');
+    
+    if (isDevServer && !wait) {
+      // Assign dynamic port
+      const port = 3000 + devServers.size;
+      sandbox.port = port;
+      
+      // Start dev server in background
+      const devProcess = spawn('sh', ['-c', `cd ${sandbox.path} && PORT=${port} ${command} ${args.join(' ')}`], {
+        detached: false,
+        stdio: ['ignore', 'pipe', 'pipe']
+      });
+      
+      devServers.set(id, { 
+        process: devProcess, 
+        port,
+        startedAt: Date.now()
+      });
+      
+      devProcess.stdout.on('data', (data) => {
+        console.log(`📦 Dev server ${id}: ${data}`);
+      });
+      
+      devProcess.stderr.on('data', (data) => {
+        console.error(`⚠️  Dev server ${id}: ${data}`);
+      });
+      
+      devProcess.on('exit', (code) => {
+        console.log(`🛑 Dev server ${id} exited with code ${code}`);
+        devServers.delete(id);
+      });
+      
       res.json({
-        exitCode: error ? (error.code || 1) : 0,
-        stdout: stdout.toString(),
-        stderr: stderr.toString()
+        exitCode: 0,
+        stdout: `Dev server started on port ${port}`,
+        stderr: '',
+        previewUrl: `/preview/${port}/`,
+        port: port,
+        commandId: `cmd-${Date.now()}`
       });
-    });
+    } else {
+      // Regular command execution
+      exec(fullCommand, { 
+        timeout: 300000, // 5 minutes
+        maxBuffer: 10 * 1024 * 1024, // 10MB
+        cwd: sandbox.path
+      }, (error, stdout, stderr) => {
+        res.json({
+          exitCode: error ? (error.code || 1) : 0,
+          stdout: stdout.toString(),
+          stderr: stderr.toString(),
+          commandId: `cmd-${Date.now()}`
+        });
+      });
+    }
   } catch (error) {
+    console.error('❌ Command execution error:', error);
     res.status(500).json({ error: error.message });
   }
 });
 
-// Write files
+// Write files to sandbox
 app.post('/api/sandbox/:id/files', async (req, res) => {
   try {
     const { id } = req.params;
-    const { files } = req.body;
+    const { files } = req.body; // Array of {path, content}
     const sandbox = sandboxes.get(id);
     
     if (!sandbox) {
@@ -88,16 +142,127 @@ app.post('/api/sandbox/:id/files', async (req, res) => {
       const fullPath = path.join(sandbox.path, file.path);
       await fs.mkdir(path.dirname(fullPath), { recursive: true });
       await fs.writeFile(fullPath, file.content, 'utf-8');
+      console.log(`📝 File written: ${file.path}`);
     }
     
-    res.json({ success: true, filesWritten: files.length });
+    res.json({ 
+      success: true, 
+      filesWritten: files.length 
+    });
   } catch (error) {
+    console.error('❌ File write error:', error);
     res.status(500).json({ error: error.message });
   }
 });
 
-// Start server on port 7860
-const PORT = process.env.PORT || 7860;
+// Read file from sandbox
+app.get('/api/sandbox/:id/files', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { path: filePath } = req.query;
+    const sandbox = sandboxes.get(id);
+    
+    if (!sandbox) {
+      return res.status(404).json({ error: 'Sandbox not found' });
+    }
+    
+    const fullPath = path.join(sandbox.path, filePath);
+    const content = await fs.readFile(fullPath, 'utf-8');
+    
+    res.send(content);
+  } catch (error) {
+    console.error('❌ File read error:', error);
+    res.status(404).json({ error: 'File not found' });
+  }
+});
+
+// Get sandbox preview URL
+app.get('/api/sandbox/:id/url', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const sandbox = sandboxes.get(id);
+    const devServer = devServers.get(id);
+    
+    if (!sandbox) {
+      return res.status(404).json({ error: 'Sandbox not found' });
+    }
+    
+    if (devServer) {
+      const baseUrl = process.env.SPACE_HOST || 'http://localhost:7860';
+      res.json({ 
+        url: `${baseUrl}/preview/${devServer.port}/`,
+        port: devServer.port,
+        status: 'running',
+        uptime: Date.now() - devServer.startedAt
+      });
+    } else {
+      res.json({ 
+        url: null,
+        status: 'no dev server running'
+      });
+    }
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Delete sandbox
+app.delete('/api/sandbox/:id', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const sandbox = sandboxes.get(id);
+    
+    if (!sandbox) {
+      return res.status(404).json({ error: 'Sandbox not found' });
+    }
+    
+    // Kill dev server if running
+    const devServer = devServers.get(id);
+    if (devServer) {
+      devServer.process.kill();
+      devServers.delete(id);
+    }
+    
+    // Delete sandbox directory
+    await fs.rm(sandbox.path, { recursive: true, force: true });
+    sandboxes.delete(id);
+    
+    console.log(`🗑️  Sandbox deleted: ${id}`);
+    res.json({ success: true });
+  } catch (error) {
+    console.error('❌ Sandbox deletion error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Cleanup old sandboxes every hour
+setInterval(() => {
+  const now = Date.now();
+  const maxAge = 3600000; // 1 hour
+  
+  for (const [id, sandbox] of sandboxes.entries()) {
+    if (now - sandbox.createdAt > maxAge) {
+      console.log(`🧹 Cleaning up old sandbox: ${id}`);
+      
+      // Kill dev server
+      const devServer = devServers.get(id);
+      if (devServer) {
+        devServer.process.kill();
+        devServers.delete(id);
+      }
+      
+      // Delete sandbox
+      fs.rm(sandbox.path, { recursive: true, force: true })
+        .catch(err => console.error(`Failed to delete sandbox ${id}:`, err));
+      
+      sandboxes.delete(id);
+    }
+  }
+}, 3600000);
+
+// Start server
+const PORT = process.env.PORT || 3001;
 app.listen(PORT, '0.0.0.0', () => {
-  console.log(`🚀 Server running on port ${PORT}`);
+  console.log(`🚀 Sandbox API server running on port ${PORT}`);
+  console.log(`📊 Ready to create sandboxes`);
 });