First commit

.env

@@ -0,0 +1,8 @@
+# Configuración del servidor
+PORT=5000
+
+# Configuración de seguridad
+MAX_EXECUTION_TIME=5
+
+# Configuración de CORS (para desarrollo)
+CORS_ORIGINS=http://localhost:3000,https://yourusername.github.io

.gitignore

@@ -0,0 +1,54 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+ENV/
+
+# IDE files
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Logs
+logs/
+*.log
+
+# Temporary files
+tmp/
+temp/
+
+# Environment variables
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Docker
+.dockerignore
+
+# Compiled C files
+*.exe
+*.out
+*.app

Dockerfile

@@ -0,0 +1,27 @@
+FROM python:3.9-slim
+
+# Instalar dependencias del sistema
+RUN apt-get update && apt-get install -y \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+# Crear directorio de trabajo
+WORKDIR /app
+
+# Copiar archivos de requisitos
+COPY requirements.txt .
+
+# Instalar dependencias de Python
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copiar el código de la aplicación
+COPY . .
+
+# Crear directorio temporal para archivos de código
+RUN mkdir -p /tmp/42coderunner
+
+# Exponer el puerto
+EXPOSE 5000
+
+# Comando para ejecutar la aplicación
+CMD ["gunicorn", "--bind", "0.0.0.0:5000", "app:app"]

README.md

@@ -1,12 +1,113 @@
----
-title: MargeCode
-emoji: 🚀
-colorFrom: indigo
-colorTo: pink
-sdk: docker
-pinned: false
-license: mit
-short_description: 42 Marge Code Backend
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 42CodeRunner - Backend
+
+Este es el backend para 42CodeRunner, un servicio que permite compilar y ejecutar código C de forma segura a través de una API REST.
+
+## Requisitos
+
+- Python 3.8+
+- GCC (para compilar código C)
+- Docker (opcional, para ejecutar en contenedor)
+
+## Instalación
+
+### Instalación local
+
+```bash
+# Clonar el repositorio
+git clone https://github.com/yourusername/42CodeRunner.git
+cd 42CodeRunner/backend
+
+# Crear entorno virtual (opcional pero recomendado)
+python -m venv venv
+
+# Activar entorno virtual
+# En Windows
+venv\Scripts\activate
+# En Linux/Mac
+# source venv/bin/activate
+
+# Instalar dependencias
+pip install -r requirements.txt
+
+# Ejecutar el servidor
+python app.py
+```
+
+El servidor estará disponible en http://localhost:5000
+
+### Instalación con Docker
+
+```bash
+# Construir la imagen
+docker build -t 42coderunner-backend .
+
+# Ejecutar el contenedor
+docker run -p 5000:5000 42coderunner-backend
+```
+
+## API
+
+### Ejecutar código C
+
+**Endpoint:** `POST /api/execute`
+
+**Cuerpo de la solicitud:**
+
+```json
+{
+  "code": "#include <stdio.h>\n\nint main() {\n    printf(\"Hello, World!\\n\");\n    return 0;\n}"
+}
+```
+
+**Respuesta exitosa:**
+
+```json
+{
+  "success": true,
+  "output": "Hello, World!\n",
+  "error": "",
+  "execution_time": 0.023
+}
+```
+
+**Respuesta con error:**
+
+```json
+{
+  "success": false,
+  "error": "main.c:3:5: error: expected ';' before 'printf'"
+}
+```
+
+### Verificar estado del servicio
+
+**Endpoint:** `GET /api/health`
+
+**Respuesta:**
+
+```json
+{
+  "status": "ok"
+}
+```
+
+## Seguridad
+
+El servicio implementa las siguientes medidas de seguridad:
+
+1. Límite de tiempo de ejecución (5 segundos por defecto)
+2. Ejecución en archivos temporales con nombres aleatorios
+3. Limpieza automática de archivos temporales
+
+## Despliegue en Hugging Face
+
+Para desplegar este servicio en Hugging Face Spaces:
+
+1. Crea un nuevo Space en Hugging Face
+2. Selecciona Docker como tipo de espacio
+3. Sube los archivos del backend (incluyendo el Dockerfile)
+4. Configura el espacio para exponer el puerto 5000
+
+## Licencia
+
+MIT

app.py

@@ -0,0 +1,106 @@
+from flask import Flask, request, jsonify
+import subprocess
+import os
+import tempfile
+import uuid
+import time
+import logging
+from flask_cors import CORS
+
+app = Flask(__name__)
+CORS(app)  # Habilitar CORS para todas las rutas
+
+# Configuración de logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Directorio temporal para los archivos de código
+TEMP_DIR = os.path.join(tempfile.gettempdir(), '42coderunner')
+os.makedirs(TEMP_DIR, exist_ok=True)
+
+# Tiempo máximo de ejecución (en segundos)
+MAX_EXECUTION_TIME = 5
+
+@app.route('/api/execute', methods=['POST'])
+def execute_code():
+    try:
+        # Obtener el código C del request
+        data = request.get_json()
+        if not data or 'code' not in data:
+            return jsonify({'success': False, 'error': 'No se proporcionó código'}), 400
+        
+        code = data['code']
+        
+        # Crear un ID único para este trabajo
+        job_id = str(uuid.uuid4())
+        
+        # Crear archivos temporales para el código y la salida
+        code_file = os.path.join(TEMP_DIR, f"{job_id}.c")
+        executable = os.path.join(TEMP_DIR, f"{job_id}.exe")
+        
+        # Guardar el código en un archivo temporal
+        with open(code_file, 'w') as f:
+            f.write(code)
+        
+        # Compilar el código
+        logger.info(f"Compilando código para job {job_id}")
+        compile_process = subprocess.run(
+            ['gcc', code_file, '-o', executable],
+            capture_output=True,
+            text=True
+        )
+        
+        # Verificar si la compilación fue exitosa
+        if compile_process.returncode != 0:
+            return jsonify({
+                'success': False,
+                'error': compile_process.stderr
+            })
+        
+        # Ejecutar el código compilado
+        logger.info(f"Ejecutando código para job {job_id}")
+        try:
+            start_time = time.time()
+            run_process = subprocess.run(
+                [executable],
+                capture_output=True,
+                text=True,
+                timeout=MAX_EXECUTION_TIME
+            )
+            execution_time = time.time() - start_time
+            
+            # Preparar la respuesta
+            result = {
+                'success': run_process.returncode == 0,
+                'output': run_process.stdout,
+                'error': run_process.stderr,
+                'execution_time': execution_time
+            }
+            
+        except subprocess.TimeoutExpired:
+            result = {
+                'success': False,
+                'error': f'La ejecución excedió el tiempo límite de {MAX_EXECUTION_TIME} segundos'
+            }
+        
+        # Limpiar archivos temporales
+        try:
+            os.remove(code_file)
+            if os.path.exists(executable):
+                os.remove(executable)
+        except Exception as e:
+            logger.error(f"Error al limpiar archivos temporales: {e}")
+        
+        return jsonify(result)
+    
+    except Exception as e:
+        logger.error(f"Error inesperado: {e}")
+        return jsonify({'success': False, 'error': f'Error interno del servidor: {str(e)}'}), 500
+
+@app.route('/api/health', methods=['GET'])
+def health_check():
+    return jsonify({'status': 'ok'})
+
+if __name__ == '__main__':
+    port = int(os.environ.get('PORT', 5000))
+    app.run(host='0.0.0.0', port=port)

requirements.txt

@@ -0,0 +1,4 @@
+flask==2.0.1
+flask-cors==3.0.10
+gunicorn==20.1.0
+python-dotenv==0.19.0