Update coder.py

coder.py

@@ -1,49 +1,75 @@
+```python
 # coder.py — offline multi-language sandbox runner and preview manager
-import os, sys, subprocess, tempfile, traceback, threading, shlex, time, sqlite3, shutil, psutil, http.server, socketserver
+# Corrected and cleaned-up version
+import os
+import sys
+import subprocess
+import tempfile
+import signal
+import platform
+import traceback
+import threading
+import shlex
+import time
+import sqlite3
+import shutil
 from typing import Optional, Dict, Any
+import psutil
 
 class Coder:
-    def __init__(self, base_dir="sandbox"):
+    def __init__(self, base_dir: str = "sandbox"):
         self.base_dir = base_dir
+        os.makedirs(self.base_dir, exist_ok=True)
+        # initialize DB path inside base_dir
+        self.db_path = os.path.join(self.base_dir, "sandbox.db")
         self.reset_sandbox()
-        self._preview_proc = None
-        self._preview_log = []
+        self._preview_proc: Optional[subprocess.Popen] = None
+        self._preview_log: list[str] = []
         self._preview_lock = threading.Lock()
-        self._preview_port = None
+        self._preview_port: Optional[int] = None
 
     # ---- sandbox management ----
     def reset_sandbox(self):
+        # Wipe and recreate sandbox, ensure DB file is created inside base_dir
         if os.path.exists(self.base_dir):
             shutil.rmtree(self.base_dir, ignore_errors=True)
         os.makedirs(self.base_dir, exist_ok=True)
-        self.db_path = os.path.join(self.base_dir, "/tmp/sandbox")
+        self.db_path = os.path.join(self.base_dir, "sandbox.db")
         conn = sqlite3.connect(self.db_path)
         conn.execute("CREATE TABLE IF NOT EXISTS data(id INTEGER PRIMARY KEY, key TEXT, value TEXT)")
         conn.commit()
         conn.close()
 
-    def _sandbox_path(self, filename):
+    def _sandbox_path(self, filename: str) -> str:
         return os.path.join(self.base_dir, filename)
 
     # ---- core code runner ----
-    def run_code(self, code: str, lang: str = "python", timeout: int = 15) -> Dict[str, Any]:
+    def run_code(self, code: str, lang: str = "python", timeout: int = 15, cpu_limit: float = 50.0, mem_limit_mb: int = 200) -> Dict[str, Any]:
+        """
+        Execute code in sandbox with resource limits.
+        - cpu_limit: CPU percent limit (not enforced except via RLIMIT_CPU)
+        - mem_limit_mb: Memory limit in MB (attempted via RLIMIT_AS on Unix)
+        Returns a dictionary with stdout, stderr, returncode, and path (temp file used).
+        """
         lang = lang.lower().strip()
+
+        # map languages to their runner/compiler commands (base)
         exec_map = {
             "python": [sys.executable],
             "javascript": ["node"],
             "node": ["node"],
-            "java": ["javac"],
+            "java": ["javac"],  # compile step uses javac; runtime uses java
             "c": ["gcc"],
             "c++": ["g++"],
             "php": ["php"],
             "ruby": ["ruby"],
-            "go": ["go", "run"],
+            "go": ["go"],
             "rust": ["rustc"],
             "bash": ["bash"],
             "typescript": ["ts-node"],
             "kotlin": ["kotlinc"],
             "lua": ["lua"],
-            "sql": ["sqlite3", self.db_path],
+            "sql": ["sqlite3"],
             "html": ["cat"],
             "css": ["cat"],
         }
@@ -52,45 +78,123 @@ class Coder:
             return {"error": f"Language '{lang}' not supported."}
 
         try:
-            suffix = {
+            suffix_map = {
                 "python": ".py", "javascript": ".js", "node": ".js", "java": ".java",
                 "c": ".c", "c++": ".cpp", "php": ".php", "ruby": ".rb", "go": ".go",
                 "rust": ".rs", "bash": ".sh", "typescript": ".ts", "kotlin": ".kt",
                 "lua": ".lua", "sql": ".sql", "html": ".html", "css": ".css"
-            }[lang]
+            }
+            suffix = suffix_map.get(lang, ".txt")
 
+            # write code to a file inside the sandbox
             with tempfile.NamedTemporaryFile(mode="w", suffix=suffix, dir=self.base_dir, delete=False) as tmp:
                 tmp.write(code)
                 path = tmp.name
 
-            if lang in ["java"]:
-                subprocess.run(["javac", path], cwd=self.base_dir, timeout=timeout, capture_output=True)
-                run_cmd = ["java", os.path.splitext(os.path.basename(path))[0]]
-            elif lang in ["c", "c++", "go", "rust"]:
-                out_exe = path + ".out"
-                compile_cmd = exec_map[lang] + [path, "-o", out_exe] if lang in ["c", "c++"] else exec_map[lang] + [path]
-                subprocess.run(compile_cmd, cwd=self.base_dir, timeout=timeout, capture_output=True)
-                run_cmd = [out_exe] if os.path.exists(out_exe) else compile_cmd
-            elif lang == "sql":
-                run_cmd = exec_map[lang] + [path]
-            elif lang in ["html", "css"]:
+            # decide run command
+            run_cmd: list[str] = []
+            # SQL: use sqlite3 <db> < <file> => we'll run sqlite3 with the file as input
+            if lang == "sql":
+                run_cmd = ["sqlite3", self.db_path]
+                # we'll provide the SQL file to stdin when running
+                stdin_for_run = open(path, "r", encoding="utf-8")
+            elif lang in ("html", "css"):
                 run_cmd = ["type" if os.name == "nt" else "cat", path]
-            else:
+                stdin_for_run = None
+            elif lang in ("python", "php", "ruby", "bash", "lua", "typescript"):
+                # these accept a file to run
                 run_cmd = exec_map[lang] + [path]
-
-            result = subprocess.run(
-                run_cmd, capture_output=True, text=True, timeout=timeout, cwd=self.base_dir
+                stdin_for_run = None
+            elif lang in ("javascript", "node"):
+                run_cmd = exec_map[lang] + [path]
+                stdin_for_run = None
+            elif lang == "go":
+                # Use 'go run file.go' (no separate compile artifact)
+                run_cmd = ["go", "run", path]
+                stdin_for_run = None
+            elif lang == "java":
+                # compile with javac then run with java -cp base_dir ClassName
+                compile_result = subprocess.run(["javac", path], cwd=self.base_dir, capture_output=True, text=True, timeout=timeout)
+                if compile_result.returncode != 0:
+                    return {"stdout": compile_result.stdout, "stderr": compile_result.stderr, "returncode": compile_result.returncode, "compile_error": True, "path": path}
+                class_name = os.path.splitext(os.path.basename(path))[0]
+                run_cmd = ["java", "-cp", self.base_dir, class_name]
+                stdin_for_run = None
+            elif lang in ("c", "c++", "rust"):
+                out_exe = path + ".out"
+                if lang == "c":
+                    compiler = "gcc"
+                    compile_cmd = [compiler, path, "-o", out_exe]
+                elif lang == "c++":
+                    compiler = "g++"
+                    compile_cmd = [compiler, path, "-o", out_exe]
+                else:  # rust
+                    compiler = "rustc"
+                    compile_cmd = [compiler, path, "-o", out_exe]
+                compile_result = subprocess.run(compile_cmd, cwd=self.base_dir, capture_output=True, text=True, timeout=timeout)
+                if compile_result.returncode != 0:
+                    return {"stdout": compile_result.stdout, "stderr": compile_result.stderr, "returncode": compile_result.returncode, "compile_error": True, "path": path}
+                run_cmd = [out_exe]
+                stdin_for_run = None
+            else:
+                # Fallback
+                run_cmd = exec_map.get(lang, [sys.executable]) + [path]
+                stdin_for_run = None
+
+            # ---- Resource limiting ----
+            preexec_fn = None
+            if platform.system() != "Windows":
+                try:
+                    import resource
+                    def set_limits():
+                        # CPU time limit (seconds)
+                        resource.setrlimit(resource.RLIMIT_CPU, (timeout, timeout+1))
+                        # Virtual memory limit
+                        mem_bytes = mem_limit_mb * 1024 * 1024
+                        resource.setrlimit(resource.RLIMIT_AS, (mem_bytes, mem_bytes))
+                    preexec_fn = set_limits
+                except Exception:
+                    # resource module may not be available on some platforms
+                    preexec_fn = None
+
+            # start process
+            proc = subprocess.Popen(
+                run_cmd,
+                cwd=self.base_dir,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                stdin=stdin_for_run or subprocess.DEVNULL,
+                text=True,
+                preexec_fn=preexec_fn
             )
 
-            return {
-                "stdout": result.stdout.strip(),
-                "stderr": result.stderr.strip(),
-                "returncode": result.returncode,
-                "path": path
-            }
+            start_time = time.time()
+            # Poll loop with timeouts and Windows memory enforcement
+            while proc.poll() is None:
+                time.sleep(0.1)
+                # Windows: enforce memory limit via psutil
+                if platform.system() == "Windows":
+                    try:
+                        p = psutil.Process(proc.pid)
+                        if p.memory_info().rss > mem_limit_mb * 1024 * 1024:
+                            p.kill()
+                            return {"error": "Memory limit exceeded."}
+                    except Exception:
+                        pass
+                if time.time() - start_time > timeout:
+                    proc.kill()
+                    return {"error": "Execution timeout."}
+
+            stdout, stderr = proc.communicate()
+            # close any opened stdin file for sqlite
+            if lang == "sql" and 'stdin_for_run' in locals() and stdin_for_run:
+                try:
+                    stdin_for_run.close()
+                except Exception:
+                    pass
+
+            return {"stdout": stdout.strip(), "stderr": stderr.strip(), "returncode": proc.returncode, "path": path}
 
-        except subprocess.TimeoutExpired:
-            return {"error": "Execution timeout."}
         except Exception:
             return {"error": traceback.format_exc()}
 
@@ -99,12 +203,12 @@ class Coder:
         """Deep code analysis with comprehensive error detection"""
         import re
         import ast
-        
+
         errors = []
         warnings = []
         solutions = []
-        code_issues = []
-        
+        result = {}
+
         # Static analysis before execution
         if lang == "python":
             # Check for syntax errors
@@ -119,19 +223,18 @@ class Coder:
                     "text": e.text.strip() if e.text else ""
                 })
                 solutions.append(f"Fix syntax error at line {e.lineno}, column {e.offset}: {e.msg}")
-            
-            # Check for common issues
+
+            # Basic line checks
             lines = code.split("\n")
             for i, line in enumerate(lines, 1):
                 line_stripped = line.strip()
-                
-                # Indentation issues
-                if line and line[0] in (' ', '\t'):
-                    if '\t' in line and ' ' in line:
-                        warnings.append(f"Line {i}: Mixed tabs and spaces")
-                
-                # Missing colons
-                if re.match(r'^\s*(if|elif|else|for|while|def|class|try|except|finally|with)\s+.*[^:]$', line):
+
+                # Mixed tabs and spaces
+                if line and '\t' in line and ' ' in line:
+                    warnings.append(f"Line {i}: Mixed tabs and spaces")
+
+                # Missing colons for common constructs
+                if re.match(r'^\s*(if|elif|else|for|while|def|class|try|except|finally|with)\b.*[^:]\s*$', line):
                     errors.append({
                         "type": "MissingColon",
                         "line": i,
@@ -139,128 +242,113 @@ class Coder:
                         "text": line_stripped
                     })
                     solutions.append(f"Add ':' at end of line {i}")
-                
-                # Undefined variables (basic check)
-                if '=' in line and not line_stripped.startswith('#'):
-                    # Check for common typos
-                    if 'pirnt' in line:
-                        warnings.append(f"Line {i}: Possible typo 'pirnt' (should be 'print')")
-                    if 'retrun' in line:
-                        warnings.append(f"Line {i}: Possible typo 'retrun' (should be 'return')")
-                    if 'improt' in line:
-                        warnings.append(f"Line {i}: Possible typo 'improt' (should be 'import')")
-                
-                # Unclosed brackets/parentheses
-                open_parens = line.count('(') - line.count(')')
-                open_brackets = line.count('[') - line.count(']')
-                open_braces = line.count('{') - line.count('}')
-                
-                if open_parens > 0:
+
+                # Simple typo checks
+                if 'pirnt' in line:
+                    warnings.append(f"Line {i}: Possible typo 'pirnt' (should be 'print')")
+                if 'retrun' in line:
+                    warnings.append(f"Line {i}: Possible typo 'retrun' (should be 'return')")
+                if 'improt' in line:
+                    warnings.append(f"Line {i}: Possible typo 'improt' (should be 'import')")
+
+                # Unclosed brackets in the line (very basic)
+                if line.count('(') > line.count(')'):
                     warnings.append(f"Line {i}: Unclosed parenthesis '('")
-                if open_brackets > 0:
+                if line.count('[') > line.count(']'):
                     warnings.append(f"Line {i}: Unclosed bracket '['")
-                if open_braces > 0:
+                if line.count('{') > line.count('}'):
                     warnings.append(f"Line {i}: Unclosed brace '{{'")
-                
-                # Check for bare except
-                if re.match(r'^\s*except\s*:', line):
+
+                # Bare except check
+                if re.match(r'^\s*except\s*:\s*$', line):
                     warnings.append(f"Line {i}: Bare except clause (specify exception type)")
-                
-                # Check for mutable default arguments
-                if 'def ' in line and '=[]' in line.replace(' ', ''):
+
+                # Mutable default args
+                if re.search(r'def\s+\w+\(.*=\s*\[\s*\]', line):
                     warnings.append(f"Line {i}: Mutable default argument (use None instead)")
-                
-                # Check for comparison with None
+
+                # Comparison with None using == or !=
                 if '== None' in line or '!= None' in line:
                     warnings.append(f"Line {i}: Use 'is None' or 'is not None' instead of '==' or '!='")
-        
-        elif lang in ["javascript", "node"]:
+
+        elif lang in ("javascript", "node"):
             lines = code.split("\n")
             for i, line in enumerate(lines, 1):
                 line_stripped = line.strip()
-                
-                # Missing semicolons
                 if line_stripped and not line_stripped.endswith((';', '{', '}', ',')) and not line_stripped.startswith('//'):
-                    warnings.append(f"Line {i}: Missing semicolon")
-                
-                # var instead of let/const
+                    warnings.append(f"Line {i}: Possible missing semicolon")
                 if line_stripped.startswith('var '):
                     warnings.append(f"Line {i}: Use 'let' or 'const' instead of 'var'")
-                
-                # == instead of ===
-                if '==' in line and '===' not in line and '!=' in line and '!==' not in line:
-                    warnings.append(f"Line {i}: Use '===' or '!==' for strict equality")
-        
-        # Execute code and capture runtime errors
-        result = self.run_code(code, lang)
-        
-        if result.get("stderr"):
-            stderr = result["stderr"]
-            for line in stderr.split("\n"):
-                if line.strip():
-                    # Extract line numbers and error types
-                    match = re.search(r'line (\d+)', line, re.IGNORECASE)
-                    line_num = match.group(1) if match else "unknown"
-                    
-                    # Categorize error
-                    error_type = "RuntimeError"
-                    if "NameError" in line:
-                        error_type = "NameError"
-                        solutions.append(f"Variable not defined at line {line_num}. Check spelling or define the variable.")
-                    elif "TypeError" in line:
-                        error_type = "TypeError"
-                        solutions.append(f"Type mismatch at line {line_num}. Check data types.")
-                    elif "ValueError" in line:
-                        error_type = "ValueError"
-                        solutions.append(f"Invalid value at line {line_num}. Check input values.")
-                    elif "IndexError" in line:
-                        error_type = "IndexError"
-                        solutions.append(f"Index out of range at line {line_num}. Check array/list bounds.")
-                    elif "KeyError" in line:
-                        error_type = "KeyError"
-                        solutions.append(f"Key not found at line {line_num}. Check dictionary keys.")
-                    elif "AttributeError" in line:
-                        error_type = "AttributeError"
-                        solutions.append(f"Attribute not found at line {line_num}. Check object attributes.")
-                    elif "ImportError" in line or "ModuleNotFoundError" in line:
-                        error_type = "ImportError"
-                        solutions.append(f"Module not found at line {line_num}. Install required package.")
-                    
-                    errors.append({
-                        "type": error_type,
-                        "line": line_num,
-                        "message": line.strip()
-                    })
-        
-        elif "error" in result:
+                if '==' in line and '===' not in line:
+                    warnings.append(f"Line {i}: Consider using '===' for strict equality")
+
+        # Execute code and capture runtime errors (only if no critical static syntax error found)
+        run_result = None
+        if not any(e.get("type") == "SyntaxError" for e in errors):
+            run_result = self.run_code(code, lang)
+
+        if run_result:
+            result.update(run_result)
+            stderr = run_result.get("stderr", "")
+            if stderr:
+                for line in stderr.splitlines():
+                    if line.strip():
+                        match = re.search(r'line\s+(\d+)', line, re.IGNORECASE)
+                        line_num = match.group(1) if match else "unknown"
+                        error_type = "RuntimeError"
+                        if "NameError" in line:
+                            error_type = "NameError"
+                            solutions.append(f"Variable not defined at line {line_num}. Check spelling or define the variable.")
+                        elif "TypeError" in line:
+                            error_type = "TypeError"
+                            solutions.append(f"Type mismatch at line {line_num}. Check data types.")
+                        elif "ValueError" in line:
+                            error_type = "ValueError"
+                            solutions.append(f"Invalid value at line {line_num}. Check input values.")
+                        elif "IndexError" in line:
+                            error_type = "IndexError"
+                            solutions.append(f"Index out of range at line {line_num}. Check array/list bounds.")
+                        elif "KeyError" in line:
+                            error_type = "KeyError"
+                            solutions.append(f"Key not found at line {line_num}. Check dictionary keys.")
+                        elif "AttributeError" in line:
+                            error_type = "AttributeError"
+                            solutions.append(f"Attribute not found at line {line_num}. Check object attributes.")
+                        elif "ImportError" in line or "ModuleNotFoundError" in line:
+                            error_type = "ImportError"
+                            solutions.append(f"Module not found at line {line_num}. Install required package.")
+
+                        errors.append({
+                            "type": error_type,
+                            "line": line_num,
+                            "message": line.strip()
+                        })
+
+        elif "error" in (run_result or {}):
             errors.append({
                 "type": "ExecutionError",
-                "message": result["error"]
+                "message": run_result.get("error")
             })
             solutions.append("Check code syntax and dependencies")
-        
+
         # Code quality checks
         if not errors:
             code_lines = [l for l in code.split("\n") if l.strip() and not l.strip().startswith('#')]
-            
-            # Check code length
             if len(code_lines) > 100:
                 warnings.append("Code is quite long. Consider breaking into smaller functions.")
-            
-            # Check for print statements (debugging leftovers)
             print_count = sum(1 for l in code_lines if 'print(' in l)
             if print_count > 5:
                 warnings.append(f"Found {print_count} print statements. Consider using logging instead.")
-        
+
         # Build comprehensive result
         result["errors"] = errors
         result["warnings"] = warnings
         result["solutions"] = solutions
         result["error_count"] = len(errors)
         result["warning_count"] = len(warnings)
-        
+
         if errors:
-            result["analysis"] = f"❌ Found {len(errors)} error(s) and {len(warnings)} warning(s). Code will not execute correctly."
+            result["analysis"] = f"❌ Found {len(errors)} error(s) and {len(warnings)} warning(s). Code may not execute correctly."
             result["severity"] = "critical"
         elif warnings:
             result["analysis"] = f"⚠️ Found {len(warnings)} warning(s). Code may have issues or bad practices."
@@ -268,64 +356,59 @@ class Coder:
         else:
             result["analysis"] = "✅ No errors or warnings detected. Code looks good!"
             result["severity"] = "success"
-        
+
         return result
-    
+
     # ---- Code Fix Feature ----
     def fix_code(self, code: str, lang: str = "python") -> Dict[str, Any]:
-        """Automatically fix common code issues"""
+        """Automatically fix common code issues (basic, heuristic fixes)."""
         import re
-        
+
         fixed_code = code
         fixes_applied = []
-        
+
         if lang == "python":
-            # Fix common Python issues
-            # Add missing imports
-            if "print(" in code and "import" not in code:
-                pass  # print is builtin
-            
-            # Fix indentation
+            # Remove trailing whitespace on lines
             lines = code.split("\n")
-            fixed_lines = []
-            for line in lines:
-                # Remove trailing whitespace
-                fixed_lines.append(line.rstrip())
+            fixed_lines = [ln.rstrip() for ln in lines]
             fixed_code = "\n".join(fixed_lines)
-            
-            # Add missing colons
-            fixed_code = re.sub(r'(if|while|for|def|class)\s+([^:]+)$', r'\1 \2:', fixed_code, flags=re.MULTILINE)
-            
-            if fixed_code != code:
-                fixes_applied.append("Fixed indentation and syntax")
-        
-        elif lang in ["javascript", "node"]:
-            # Fix common JS issues
-            # Add missing semicolons
+
+            # Add missing colons for common constructs (heuristic)
+            new_code = re.sub(r'(^\s*(if|while|for|def|class)\b[^\n:]*)(\n)', lambda m: (m.group(1) + ':' + m.group(3)) if not m.group(1).rstrip().endswith(':') else m.group(0), fixed_code, flags=re.M)
+            if new_code != fixed_code:
+                fixed_code = new_code
+                fixes_applied.append("Added missing colons in control/function/class statements")
+
+        elif lang in ("javascript", "node"):
+            # Add missing semicolons in a very naive way
             lines = fixed_code.split("\n")
             fixed_lines = []
             for line in lines:
-                line = line.rstrip()
-                if line and not line.endswith((";", "{", "}", ",")):
-                    if not line.strip().startswith("//"):
-                        line += ";"
-                fixed_lines.append(line)
+                stripped = line.rstrip()
+                if stripped and not stripped.endswith((';', '{', '}', ',')) and not stripped.strip().startswith('//'):
+                    stripped += ';'
+                fixed_lines.append(stripped)
             fixed_code = "\n".join(fixed_lines)
-            
-            if fixed_code != code:
-                fixes_applied.append("Added missing semicolons")
-        
-        # Test the fixed code
+            fixes_applied.append("Added missing semicolons (heuristic)")
+
+        # Test the fixed code (best-effort)
         test_result = self.run_code(fixed_code, lang)
-        
+        success = False
+        if "returncode" in test_result:
+            success = test_result.get("returncode") == 0
+        elif "error" in test_result:
+            success = False
+        else:
+            success = True
+
         return {
             "original_code": code,
             "fixed_code": fixed_code,
             "fixes_applied": fixes_applied,
             "test_result": test_result,
-            "success": test_result.get("returncode") == 0 if "returncode" in test_result else "error" not in test_result
+            "success": success
         }
-    
+
     # ---- Code Generation ----
     def generate_code(self, request: str, lang: str = "python") -> Dict[str, Any]:
         """Generate code from natural language request"""
@@ -361,7 +444,7 @@ class ChatBot:
             "bye": ["Goodbye!", "See you!", "Bye!"],
             "default": ["I'm not sure I understand.", "Can you rephrase?"]
         }
-    
+
     def respond(self, message):
         message = message.lower()
         for key in self.responses:
@@ -400,21 +483,19 @@ print(bot.respond("hello"))
 '''
             }
         }
-        
-        # Simple keyword matching for templates
+
         request_lower = request.lower()
         generated_code = ""
         template_used = None
-        
+
         if lang in templates:
             for key, template in templates[lang].items():
                 if key in request_lower or any(word in request_lower for word in key.split("_")):
                     generated_code = template
                     template_used = key
                     break
-        
+
         if not generated_code:
-            # Generate basic structure
             if lang == "python":
                 generated_code = f'''# Generated code for: {request}
 
@@ -437,7 +518,9 @@ if __name__ == "__main__":
 </body>
 </html>
 '''
-        
+            else:
+                generated_code = f"# Generated code for: {request}\n# Language: {lang}\n"
+
         return {
             "request": request,
             "language": lang,
@@ -448,6 +531,8 @@ if __name__ == "__main__":
 
     # ---- Interactive shell (terminal) ----
     def open_shell(self, cmd: str = "bash"):
+        # Return a subprocess.Popen for an interactive shell in the sandbox dir
+        executable = "powershell.exe" if os.name == "nt" else "/bin/bash"
         proc = subprocess.Popen(
             cmd,
             shell=True,
@@ -457,8 +542,7 @@ if __name__ == "__main__":
             stderr=subprocess.STDOUT,
             text=True,
             bufsize=1,
-            universal_newlines=True,
-            executable="powershell.exe" if os.name == "nt" else "/bin/bash",
+            executable=executable,
         )
         return proc
 
@@ -468,12 +552,11 @@ if __name__ == "__main__":
             return {"error": "Preview already running.", "port": self._preview_port}
 
         detected = lang.lower()
-        
+
         # Create index.html if it doesn't exist for HTML previews
-        if detected in ["html", "css", "javascript"]:
+        if detected in ("html", "css", "javascript", "node"):
             index_path = os.path.join(self.base_dir, "index.html")
             if not os.path.exists(index_path):
-                # Create a default index.html
                 default_html = """<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -490,14 +573,13 @@ if __name__ == "__main__":
     <p>Your code preview will appear here.</p>
 </body>
 </html>"""
-                with open(index_path, 'w') as f:
+                with open(index_path, 'w', encoding='utf-8') as f:
                     f.write(default_html)
-            
+
             cmd = f"{sys.executable} -m http.server {port}"
-        elif detected in ["node", "javascript"]:
-            cmd = f"node server.js --port {port}" if os.path.exists(os.path.join(self.base_dir, "server.js")) else f"node app.js --port {port}"
-        elif detected in ["python"]:
-            if any(x in os.listdir(self.base_dir) for x in ["main.py", "app.py"]):
+        elif detected == "python":
+            if any(x in os.listdir(self.base_dir) for x in ("main.py", "app.py")):
+                # if app.py/main.py exists, try to run a uvicorn server (best-effort)
                 cmd = f"uvicorn app:app --host 0.0.0.0 --port {port} --reload"
             else:
                 cmd = f"{sys.executable} -m http.server {port}"
@@ -507,23 +589,28 @@ if __name__ == "__main__":
         with self._preview_lock:
             self._preview_log.clear()
             self._preview_port = port
-            self._preview_proc = subprocess.Popen(
-                shlex.split(cmd),
-                cwd=self.base_dir,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.STDOUT,
-                stdin=subprocess.DEVNULL,
-                text=True,
-            )
+            try:
+                self._preview_proc = subprocess.Popen(
+                    shlex.split(cmd),
+                    cwd=self.base_dir,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.STDOUT,
+                    stdin=subprocess.DEVNULL,
+                    text=True,
+                )
+            except Exception as e:
+                self._preview_proc = None
+                self._preview_port = None
+                return {"error": str(e), "cmd": cmd}
+
         threading.Thread(target=self._stream_preview_output, daemon=True).start()
-        
-        # Wait a moment for server to start
+
+        # Give a short moment for the server to (attempt to) start
         time.sleep(1)
-        
-        # Return comprehensive preview info
+
         return {
-            "status": "started", 
-            "cmd": cmd, 
+            "status": "started",
+            "cmd": cmd,
             "port": port,
             "preview_url": f"http://localhost:{port}",
             "iframe_html": f'<iframe src="http://localhost:{port}" width="100%" height="600px" frameborder="0" sandbox="allow-scripts allow-same-origin"></iframe>',
@@ -533,16 +620,18 @@ if __name__ == "__main__":
 
     def _stream_preview_output(self):
         proc = self._preview_proc
-        if not proc:
+        if not proc or not proc.stdout:
             return
-        for line in proc.stdout:
+        try:
+            for line in proc.stdout:
+                with self._preview_lock:
+                    self._preview_log.append(line.rstrip())
+                    if len(self._preview_log) > 2000:
+                        self._preview_log = self._preview_log[-1000:]
+        finally:
             with self._preview_lock:
-                self._preview_log.append(line.rstrip())
-                if len(self._preview_log) > 2000:
-                    self._preview_log = self._preview_log[-1000:]
-        with self._preview_lock:
-            self._preview_proc = None
-            self._preview_port = None
+                self._preview_proc = None
+                self._preview_port = None
 
     def stop_preview(self) -> Dict[str, Any]:
         with self._preview_lock:
@@ -564,7 +653,7 @@ if __name__ == "__main__":
             return {
                 "running": self._preview_proc is not None,
                 "port": self._preview_port,
-                "log_tail": self._preview_log[-200:],
+                "log_tail": list(self._preview_log[-200:]),
             }
 
     # ---- SQLite sandbox ----
@@ -572,7 +661,7 @@ if __name__ == "__main__":
         try:
             conn = sqlite3.connect(self.db_path)
             cur = conn.cursor()
-            cur.execute(query)
+            cur.executescript(query) if (";" in query and not query.strip().lower().startswith("select")) else cur.execute(query)
             if query.strip().lower().startswith("select"):
                 rows = cur.fetchall()
                 result = {"rows": rows, "count": len(rows)}
@@ -636,10 +725,15 @@ if __name__ == "__main__":
         except Exception as e:
             return {"error": str(e)}
 
-    def cleanup(self):
+    def cleanup(self) -> Dict[str, Any]:
         try:
             shutil.rmtree(self.base_dir, ignore_errors=True)
             os.makedirs(self.base_dir, exist_ok=True)
+            # recreate db
+            conn = sqlite3.connect(self.db_path)
+            conn.execute("CREATE TABLE IF NOT EXISTS data(id INTEGER PRIMARY KEY, key TEXT, value TEXT)")
+            conn.commit()
+            conn.close()
             return {"status": "cleaned"}
         except Exception as e:
-            return {"error": str(e)}
+            return {"error": str(e)}