feat: add code sandbox

Dockerfile

@@ -8,6 +8,9 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     curl \
     ffmpeg \
     libmagic1 \
+    nodejs \
+    npm \
+    openjdk-17-jdk-headless \
     && rm -rf /var/lib/apt/lists/*
 
 RUN groupadd --gid 1000 appuser && \

app/api/v1/code_executor.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import time
+from typing import Optional
+
+from fastapi import APIRouter, Depends
+
+from app.api.deps import require_auth
+from app.core.logger import get_logger
+from app.models.schemas import (
+    CodeExecutionItemResult,
+    CodeExecutionRequest,
+    CodeExecutionResponse,
+)
+from app.services.code_executor_service import CodeExecutorService
+
+router = APIRouter()
+_logger = get_logger(__name__)
+
+_executor: Optional[CodeExecutorService] = None
+
+
+def get_executor() -> CodeExecutorService:
+    global _executor
+    if _executor is None:
+        _executor = CodeExecutorService()
+    return _executor
+
+
+@router.post(
+    "/code/execute",
+    response_model=CodeExecutionResponse,
+    summary="Execute code snippets (Python, JavaScript, Java)",
+)
+async def execute_code(
+    body: CodeExecutionRequest,
+    token: str = Depends(require_auth),
+    executor: CodeExecutorService = Depends(get_executor),
+) -> CodeExecutionResponse:
+    _logger.info("Code execution request: items=%s", len(body.items))
+
+    start = time.perf_counter()
+    results: list[CodeExecutionItemResult] = []
+
+    for item in body.items:
+        t0 = time.perf_counter()
+        try:
+            result = await executor.execute(item.code, item.language)
+            elapsed = (time.perf_counter() - t0) * 1000
+            results.append(CodeExecutionItemResult(
+                success=result["success"],
+                output=result.get("output", ""),
+                error=result.get("error"),
+                exit_code=result.get("exit_code"),
+                execution_time_ms=round(elapsed, 2),
+                language=result.get("language", item.language),
+                timed_out=result.get("timed_out", False),
+            ))
+        except Exception as exc:
+            elapsed = (time.perf_counter() - t0) * 1000
+            _logger.exception("Item execution error")
+            results.append(CodeExecutionItemResult(
+                success=False,
+                error=str(exc),
+                execution_time_ms=round(elapsed, 2),
+                language=item.language,
+            ))
+
+    total_ms = (time.perf_counter() - start) * 1000
+    success_count = sum(1 for r in results if r.success)
+    failed_count = len(results) - success_count
+    all_ok = failed_count == 0
+
+    _logger.info(
+        "Code execution done: items=%s, success=%s, failed=%s, total_ms=%s",
+        len(results), success_count, failed_count, round(total_ms, 3),
+    )
+    return CodeExecutionResponse(
+        success=all_ok,
+        time_ms=round(total_ms, 3),
+        success_count=success_count,
+        failed_count=failed_count,
+        results=results,
+    )

app/api/v1/router.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from fastapi import APIRouter
 
-from app.api.v1 import batch, convert, database, embeddings, system
+from app.api.v1 import batch, code_executor, convert, database, embeddings, system
 from app.api.verify import router as verify_router
 
 api_v1_router = APIRouter()
@@ -11,4 +11,5 @@ api_v1_router.include_router(batch.router, tags=["Batch"])
 api_v1_router.include_router(system.router, tags=["System"])
 api_v1_router.include_router(database.router, tags=["Database"])
 api_v1_router.include_router(embeddings.router, tags=["Embeddings"])
+api_v1_router.include_router(code_executor.router, tags=["Code Executor"])
 api_v1_router.include_router(verify_router, prefix="/verify", tags=["Verify"])

app/config.py

@@ -35,6 +35,13 @@ class Settings(BaseSettings):
 
     self_ping_url: str = "https://aetherbase-llm-ready-data.hf.space/ping"
     spacy_model: str = "en_core_web_sm"
+
+    code_exec_max_time: int = 10
+    code_exec_max_memory: int = 128
+    code_exec_max_output: int = 65536
+    code_exec_max_concurrent: int = 16
+    code_exec_workdir: str = "/tmp/code-runner"
+
     @property
     def max_upload_mb(self) -> int:
         return self.max_upload_bytes // (1024 * 1024)

app/models/schemas.py

@@ -266,3 +266,31 @@ class VisionUrlRequest(BaseModel):
             if not url.startswith(("http://", "https://")):
                 raise ValueError(f"Invalid URL scheme: {url}")
         return v
+
+
+class CodeItem(BaseModel):
+    language: Literal["python", "javascript", "java"]
+    code: str = Field(..., min_length=1, max_length=65536, description="Source code to execute")
+
+
+class CodeExecutionRequest(BaseModel):
+    items: List[CodeItem] = Field(..., min_length=1, max_length=5, description="Code execution items (max 5)")
+
+
+class CodeExecutionItemResult(BaseModel):
+    success: bool
+    output: str = ""
+    error: Optional[str] = None
+    exit_code: Optional[int] = None
+    execution_time_ms: Optional[float] = None
+    language: str
+    timed_out: bool = False
+
+
+class CodeExecutionResponse(BaseModel):
+    success: bool
+    time_ms: float
+    success_count: int
+    failed_count: int
+    error_message: Optional[str] = None
+    results: List[CodeExecutionItemResult]

app/services/code_executor_service.py

@@ -0,0 +1,256 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import re
+import shutil
+import signal
+import subprocess
+import tempfile
+import time
+from pathlib import Path
+from typing import Optional
+
+from app.config import get_settings
+
+_logger = logging.getLogger(__name__)
+
+_APP_DIR = Path(__file__).resolve().parent
+_settings = get_settings()
+
+
+class CodeSanitizer:
+    _BLOCKED_PATTERNS: dict[str, list[tuple[str, str]]] = {
+        "python": [
+            (r"import\s+subprocess\b", "subprocess not allowed"),
+            (r"from\s+subprocess\b", "subprocess not allowed"),
+            (r"import\s+ctypes\b", "ctypes not allowed"),
+            (r"from\s+ctypes\b", "ctypes not allowed"),
+            (r"import\s+os\b", "os not allowed"),
+            (r"from\s+os\b", "os not allowed"),
+            (r"import\s+sys\b", "sys not allowed"),
+            (r"from\s+sys\b", "sys not allowed"),
+            (r"import\s+socket\b", "socket not allowed"),
+            (r"from\s+socket\b", "socket not allowed"),
+            (r"import\s+builtins\b", "builtins not allowed"),
+            (r"from\s+builtins\b", "builtins not allowed"),
+            (r"import\s+signal\b", "signal not allowed"),
+            (r"from\s+signal\b", "signal not allowed"),
+            (r"import\s+shutil\b", "shutil not allowed"),
+            (r"from\s+shutil\b", "shutil not allowed"),
+            (r"__import__\s*\(", "__import__() not allowed"),
+            (r"exec\s*\(", "exec() not allowed"),
+            (r"eval\s*\(", "eval() not allowed"),
+            (r"compile\s*\(", "compile() not allowed"),
+            (r"\.__subclasses__\s*\(\)", "subclass escape not allowed"),
+            (r"\.__bases__", "__bases__ not allowed"),
+            (r"\.__mro__", "__mro__ not allowed"),
+            (r"\.__globals__", "__globals__ not allowed"),
+            (r"\.__code__", "__code__ not allowed"),
+            (r"\.__closure__", "__closure__ not allowed"),
+            (r"\.__dict__", "__dict__ not allowed"),
+            (r"\.__builtins__", "__builtins__ not allowed"),
+            (r"\.__class__", "__class__ not allowed"),
+        ],
+        "javascript": [
+            (r"require\s*\(", "require() not allowed"),
+            (r"process\s*\.", "process not allowed"),
+            (r"__dirname", "__dirname not allowed"),
+            (r"__filename", "__filename not allowed"),
+            (r"global\s*\.", "global not allowed"),
+            (r"globalThis\s*\.", "globalThis not allowed"),
+            (r"eval\s*\(", "eval() not allowed"),
+            (r"Function\s*\(", "Function() constructor not allowed"),
+            (r"child_process", "child_process not allowed"),
+            (r"fs\s*\.", "fs not allowed"),
+            (r"net\s*\.", "net not allowed"),
+            (r"http\s*\.", "http not allowed"),
+            (r"https\s*\.", "https not allowed"),
+            (r"worker_threads", "worker_threads not allowed"),
+            (r"Buffer\s*\.", "Buffer not allowed"),
+        ],
+        "java": [
+            (r"ProcessBuilder", "ProcessBuilder not allowed"),
+            (r"Runtime\.exec", "Runtime.exec() not allowed"),
+            (r"Runtime\.getRuntime\s*\(\s*\)", "Runtime.getRuntime() not allowed"),
+            (r"System\.exit\s*\(", "System.exit() not allowed"),
+            (r"System\.gc\s*\(", "System.gc() not allowed"),
+            (r"File\s*\(", "File operations not allowed"),
+            (r"FileInputStream", "FileInputStream not allowed"),
+            (r"FileOutputStream", "FileOutputStream not allowed"),
+            (r"FileReader", "FileReader not allowed"),
+            (r"FileWriter", "FileWriter not allowed"),
+            (r"Socket\s*\(", "Socket not allowed"),
+            (r"ServerSocket\s*\(", "ServerSocket not allowed"),
+            (r"URL\s*\(", "URL not allowed"),
+            (r"Class\.forName", "Class.forName() not allowed"),
+            (r"Thread\s*\(", "Thread not allowed"),
+            (r"ThreadPoolExecutor", "ThreadPoolExecutor not allowed"),
+            (r"Runtime\.", "Runtime not allowed"),
+            (r"System\.getProperty", "System.getProperty not allowed"),
+            (r"System\.getenv", "System.getenv not allowed"),
+        ],
+    }
+
+    @classmethod
+    def sanitize(cls, code: str, language: str) -> tuple[bool, Optional[str]]:
+        patterns = cls._BLOCKED_PATTERNS.get(language, [])
+        for pattern, message in patterns:
+            if re.search(pattern, code):
+                return False, f"Forbidden: {message}"
+        return True, None
+
+    @classmethod
+    def validate_java_class(cls, code: str) -> tuple[bool, Optional[str]]:
+        if not re.search(r"public\s+class\s+Main\s*\{", code):
+            return False, "Java code must have 'public class Main' with 'public static void main(String[] args)'"
+        return True, None
+
+
+class CodeExecutorService:
+    def __init__(self) -> None:
+        self._max_execution_time = _settings.code_exec_max_time
+        self._max_output_bytes = _settings.code_exec_max_output
+        self._max_memory_mb = _settings.code_exec_max_memory
+        self._semaphore = asyncio.Semaphore(_settings.code_exec_max_concurrent)
+        self._workdir = Path(_settings.code_exec_workdir)
+        self._workdir.mkdir(parents=True, exist_ok=True)
+
+    async def execute(
+        self,
+        code: str,
+        language: str,
+        timeout: Optional[int] = None,
+    ) -> dict:
+        sanitized, err = CodeSanitizer.sanitize(code, language)
+        if not sanitized:
+            return {
+                "success": False, "output": "", "error": err,
+                "exit_code": None, "execution_time_ms": None,
+                "language": language, "timed_out": False,
+            }
+
+        if language == "java":
+            valid, err = CodeSanitizer.validate_java_class(code)
+            if not valid:
+                return {
+                    "success": False, "output": "", "error": err,
+                    "exit_code": None, "execution_time_ms": None,
+                    "language": language, "timed_out": False,
+                }
+
+        exec_timeout = min(timeout or self._max_execution_time, self._max_execution_time)
+
+        async with self._semaphore:
+            run_dir = None
+            start_time = time.monotonic()
+            try:
+                run_dir = Path(tempfile.mkdtemp(dir=self._workdir))
+                filename = self._filename_for(language)
+                src_path = run_dir / filename
+                src_path.write_text(code, encoding="utf-8")
+
+                cmd = self._build_command(language, run_dir, filename)
+                result = await asyncio.to_thread(
+                    self._run_subprocess, cmd, exec_timeout,
+                )
+
+                elapsed_ms = (time.monotonic() - start_time) * 1000
+
+                if result["timed_out"]:
+                    return {
+                        "success": False,
+                        "output": result["stdout"],
+                        "error": f"Execution timed out after {exec_timeout}s",
+                        "exit_code": result["exit_code"],
+                        "execution_time_ms": round(elapsed_ms, 2),
+                        "language": language,
+                        "timed_out": True,
+                    }
+
+                return {
+                    "success": result["exit_code"] == 0 if result["exit_code"] is not None else False,
+                    "output": result["stdout"],
+                    "error": result["stderr"] or None,
+                    "exit_code": result["exit_code"],
+                    "execution_time_ms": round(elapsed_ms, 2),
+                    "language": language,
+                    "timed_out": False,
+                }
+
+            except FileNotFoundError as exc:
+                _logger.error("Runtime not found: %s", exc)
+                return {
+                    "success": False, "output": "", "error": f"Runtime not found: {exc.filename}",
+                    "execution_time_ms": None, "language": language, "timed_out": False,
+                }
+            except Exception as exc:
+                _logger.exception("Executor error")
+                return {
+                    "success": False, "output": "", "error": f"Internal error: {exc}",
+                    "execution_time_ms": None, "language": language, "timed_out": False,
+                }
+            finally:
+                if run_dir and run_dir.exists():
+                    try:
+                        shutil.rmtree(run_dir, ignore_errors=True)
+                    except Exception:
+                        pass
+
+    def _run_subprocess(
+        self,
+        cmd: list[str],
+        timeout: float,
+    ) -> dict:
+        proc = subprocess.Popen(
+            cmd,
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        try:
+            stdout_bytes, stderr_bytes = proc.communicate(timeout=timeout)
+            timed_out = False
+        except subprocess.TimeoutExpired:
+            try:
+                if os.name == "nt":
+                    proc.kill()
+                else:
+                    os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
+            except Exception:
+                proc.kill()
+            stdout_bytes, stderr_bytes = proc.communicate()
+            timed_out = True
+
+        max_out = self._max_output_bytes
+        return {
+            "stdout": (stdout_bytes.decode("utf-8", errors="replace")[:max_out] if stdout_bytes else ""),
+            "stderr": (stderr_bytes.decode("utf-8", errors="replace")[:max_out] if stderr_bytes else ""),
+            "exit_code": proc.returncode,
+            "timed_out": timed_out,
+        }
+
+    async def check_runtimes(self) -> dict[str, str]:
+        status = {}
+        for lang, runtime in [("python", "python3"), ("javascript", "node"), ("java", "javac")]:
+            path = shutil.which(runtime)
+            status[lang] = f"found at {path}" if path else "missing"
+        return status
+
+    @staticmethod
+    def _filename_for(language: str) -> str:
+        return {"python": "code.py", "javascript": "code.js", "java": "Main.java"}[language]
+
+    @staticmethod
+    def _build_command(language: str, run_dir: Path, filename: str) -> list[str]:
+        sandbox_py = _APP_DIR / "py_sandbox.py"
+        sandbox_js = _APP_DIR / "js_sandbox.js"
+        if language == "python":
+            return ["python3", str(sandbox_py), str(run_dir / filename)]
+        elif language == "javascript":
+            return ["node", str(sandbox_js), str(run_dir / filename)]
+        elif language == "java":
+            return ["sh", "-c",
+                    f"cd {run_dir} && javac Main.java 2>&1 && java -XX:CompressedClassSpaceSize=64m -Xmx96m Main 2>&1"]
+        return []

app/services/js_sandbox.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+const vm = require('vm');
+const fs = require('fs');
+const path = require('path');
+
+const codePath = process.argv[2];
+if (!codePath) {
+    console.error('Usage: node js_sandbox.js <code_path>');
+    process.exit(1);
+}
+
+const safeConsole = {
+    log: console.log,
+    warn: console.warn,
+    error: console.error,
+    info: console.info,
+};
+
+const sandbox = {
+    console: safeConsole,
+    Math, Date, JSON,
+    parseInt, parseFloat, isNaN, isFinite,
+    NaN, Infinity, undefined: undefined, null: null,
+    Number, String, Boolean, Array, Object, RegExp,
+    Map, Set, WeakMap, WeakSet, Promise, Symbol,
+    Error, TypeError, RangeError, SyntaxError, ReferenceError, EvalError, URIError,
+    ArrayBuffer, DataView,
+    Int8Array, Int16Array, Int32Array,
+    Uint8Array, Uint8ClampedArray, Uint16Array, Uint32Array,
+    Float32Array, Float64Array,
+    BigInt, BigInt64Array, BigUint64Array,
+    decodeURI, decodeURIComponent, encodeURI, encodeURIComponent,
+    atob, btoa,
+    performance: { now: () => Date.now() },
+    setTimeout: setTimeout,
+    clearTimeout: clearTimeout,
+    setInterval: setInterval,
+    clearInterval: clearInterval,
+};
+
+const context = vm.createContext(sandbox);
+const code = fs.readFileSync(codePath, 'utf8');
+
+try {
+    vm.runInContext(code, context, {
+        filename: 'code.js',
+        timeout: 10000,
+        displayErrors: true,
+    });
+} catch (err) {
+    console.error(err.message);
+    process.exit(1);
+}

app/services/py_sandbox.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+import sys
+import io
+import os
+import math as _math
+import json as _json
+import re as _re
+import random as _random
+import collections as _collections
+import itertools as _itertools
+import functools as _functools
+import operator as _operator
+import string as _string
+import decimal as _decimal
+import fractions as _fractions
+import statistics as _statistics
+import heapq as _heapq
+import bisect as _bisect
+import copy as _copy
+import typing as _typing
+import textwrap as _textwrap
+import datetime as _datetime
+import hashlib as _hashlib
+import uuid as _uuid
+import secrets as _secrets
+import enum as _enum
+import base64 as _base64
+import time as _time
+
+_SAFE_MODULES = {
+    'math': _math, 'json': _json, 're': _re, 'random': _random,
+    'collections': _collections, 'itertools': _itertools,
+    'functools': _functools, 'operator': _operator, 'string': _string,
+    'decimal': _decimal, 'fractions': _fractions, 'statistics': _statistics,
+    'heapq': _heapq, 'bisect': _bisect, 'copy': _copy, 'typing': _typing,
+    'textwrap': _textwrap, 'datetime': _datetime, 'hashlib': _hashlib,
+    'uuid': _uuid, 'secrets': _secrets, 'enum': _enum, 'base64': _base64,
+    'time': _time,
+}
+
+_ALLOWED_READ_DIRS = {os.path.realpath(p) for p in ('/tmp', os.getcwd()) if os.path.isdir(p)}
+
+
+def _safe_import(name, *args, **kwargs):
+    if name in _SAFE_MODULES:
+        return _SAFE_MODULES[name]
+    raise ImportError(f"Module '{name}' is not allowed in sandbox")
+
+
+def _safe_open(file, mode='r', *args, **kwargs):
+    if 'w' in mode or 'a' in mode or '+' in mode or 'x' in mode:
+        raise PermissionError("File writing is not allowed in sandbox")
+    real = os.path.realpath(os.path.abspath(str(file)))
+    allowed = False
+    for d in _ALLOWED_READ_DIRS:
+        if real.startswith(d + os.sep) or real == d:
+            allowed = True
+            break
+    if not allowed:
+        raise PermissionError(f"File '{file}' is outside allowed read directories")
+    if 'b' in mode:
+        return io.open(file, mode, *args, **kwargs)
+    return io.open(file, mode, *args, **kwargs)
+
+
+def _safe_getattr(obj, name, *args):
+    if isinstance(obj, (type, object)) and name in ('__class__', '__bases__', '__subclasses__',
+                                                      '__mro__', '__globals__', '__code__',
+                                                      '__closure__', '__dict__', '__builtins__'):
+        raise AttributeError(f"Access to '{name}' is not allowed in sandbox")
+    if args:
+        return getattr(obj, name, args[0])
+    return getattr(obj, name)
+
+
+def _safe_setattr(obj, name, value):
+    if name.startswith('_'):
+        raise AttributeError(f"Setting attribute '{name}' is not allowed in sandbox")
+    setattr(obj, name, value)
+
+
+def _safe_delattr(obj, name):
+    if name.startswith('_'):
+        raise AttributeError(f"Deleting attribute '{name}' is not allowed in sandbox")
+    delattr(obj, name)
+
+
+_SAFE_BUILTINS = {
+    '__import__': _safe_import,
+    'print': print, 'len': len, 'range': range,
+    'int': int, 'float': float, 'str': str, 'bool': bool,
+    'list': list, 'dict': dict, 'tuple': tuple, 'set': set, 'frozenset': frozenset,
+    'bytes': bytes, 'bytearray': bytearray,
+    'True': True, 'False': False, 'None': None,
+    'abs': abs, 'min': min, 'max': max, 'sum': sum, 'pow': pow,
+    'round': round, 'divmod': divmod,
+    'enumerate': enumerate, 'filter': filter, 'map': map, 'zip': zip,
+    'all': all, 'any': any, 'iter': iter, 'next': next,
+    'reversed': reversed, 'sorted': sorted, 'slice': slice,
+    'bin': bin, 'chr': chr, 'hex': hex, 'oct': oct, 'ord': ord,
+    'repr': repr, 'format': format, 'hash': hash, 'id': id,
+    'type': type, 'isinstance': isinstance, 'issubclass': issubclass,
+    'hasattr': hasattr, 'getattr': _safe_getattr, 'setattr': _safe_setattr,
+    'delattr': _safe_delattr, 'callable': callable,
+    'staticmethod': staticmethod, 'classmethod': classmethod,
+    'property': property, 'object': object, 'super': super,
+    'Exception': Exception, 'ValueError': ValueError, 'TypeError': TypeError,
+    'KeyError': KeyError, 'IndexError': IndexError, 'AttributeError': AttributeError,
+    'StopIteration': StopIteration, 'RuntimeError': RuntimeError,
+    'ZeroDivisionError': ZeroDivisionError, 'ArithmeticError': ArithmeticError,
+    'EOFError': EOFError, 'NameError': NameError, 'MemoryError': MemoryError,
+    'NotImplementedError': NotImplementedError, 'OverflowError': OverflowError,
+    'RecursionError': RecursionError, 'AssertionError': AssertionError,
+    'ImportError': ImportError, 'PermissionError': PermissionError,
+    'LookupError': LookupError, 'FileNotFoundError': FileNotFoundError,
+    'input': input, 'open': _safe_open,
+}
+
+_FROZEN_ERR = TypeError("Cannot modify sandbox builtins")
+
+
+class _FrozenDict(dict):
+    def __setitem__(self, key, value):
+        raise _FROZEN_ERR
+    def __delitem__(self, key):
+        raise _FROZEN_ERR
+    def pop(self, key, *args):
+        raise _FROZEN_ERR
+    def popitem(self):
+        raise _FROZEN_ERR
+    def clear(self):
+        raise _FROZEN_ERR
+    def update(self, *args, **kwargs):
+        raise _FROZEN_ERR
+    def setdefault(self, key, *args):
+        raise _FROZEN_ERR
+
+
+def execute_code(code: str) -> None:
+    try:
+        compiled = compile(code, '<sandbox>', 'exec')
+        globs = {'__builtins__': _FrozenDict(_SAFE_BUILTINS)}
+        exec(compiled, globs)
+    except Exception as e:
+        print(str(e), file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    if len(sys.argv) > 1:
+        with open(sys.argv[1], 'r') as f:
+            code = f.read()
+        execute_code(code)
+    else:
+        code = sys.stdin.read()
+        execute_code(code)