Update app.py

app.py

@@ -1,109 +1,165 @@
 """
-SharePUTER Worker Node — Serverless (HF Space Docker / any container)
-Executes task fragments assigned by the head node.
-Supports node types: RAM, CPU, GPU
+SharePUTER™ v2 Worker Node
+Sandboxed execution, library management, GPU/CPU/RAM support,
+gradient capture for ML workflows.
 """
 
-from fastapi import FastAPI, Request
+from fastapi import FastAPI
 from fastapi.responses import HTMLResponse, JSONResponse
-import httpx
-import asyncio
-import uuid
-import os
-import sys
-import io
-import json
-import time
-import traceback
-import multiprocessing
-import psutil
+from fastapi.middleware.cors import CORSMiddleware
+import httpx, asyncio, uuid, os, sys, io, json, time, traceback
+import subprocess, multiprocessing, signal, resource
 from datetime import datetime
 from contextlib import redirect_stdout, redirect_stderr
 from typing import Optional
 
-app = FastAPI(title="SharePUTER Worker Node")
+app = FastAPI(title="SharePUTER™ v2 Worker")
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
 
-# ─── Configuration ──────────────────────────────────────────────────────────
-HEAD_NODE_URL = os.environ.get("SACCP_HEAD_URL", "http://localhost:7860")
-NODE_TYPE = os.environ.get("SACCP_NODE_TYPE", "CPU").upper()  # RAM, CPU, GPU
+HEAD_URL = os.environ.get("SACCP_HEAD_URL", "http://localhost:7860")
+NODE_TYPE = os.environ.get("SACCP_NODE_TYPE", "CPU").upper()
 NODE_OWNER = os.environ.get("SACCP_NODE_OWNER", "anonymous")
+AUTO_REG = os.environ.get("SACCP_AUTO_REGISTER", "true").lower() == "true"
+SANDBOX = os.environ.get("SACCP_SANDBOX", "true").lower() == "true"
 NODE_ID: Optional[str] = None
 REGISTERED = False
 
-# Auto-detect specs
+# ─── System Detection ──────────────────────────────────────────────────────
 def detect_specs():
-    specs = {
+    import psutil
+    s = {
         "cpu_count": multiprocessing.cpu_count(),
         "ram_total_gb": round(psutil.virtual_memory().total / (1024**3), 2),
         "ram_available_gb": round(psutil.virtual_memory().available / (1024**3), 2),
         "platform": sys.platform,
-        "python_version": sys.version.split()[0],
+        "python": sys.version.split()[0],
+        "gpu_available": False,
+        "gpu_name": "",
+        "gpu_memory_gb": 0,
     }
-
-    # Check for GPU
     try:
         import torch
         if torch.cuda.is_available():
-            specs["gpu_available"] = True
-            specs["gpu_name"] = torch.cuda.get_device_name(0)
-            specs["gpu_memory_gb"] = round(torch.cuda.get_device_properties(0).total_mem / (1024**3), 2)
-        else:
-            specs["gpu_available"] = False
-    except ImportError:
-        specs["gpu_available"] = False
-
-    return specs
-
+            s["gpu_available"] = True
+            s["gpu_name"] = torch.cuda.get_device_name(0)
+            s["gpu_memory_gb"] = round(torch.cuda.get_device_properties(0).total_mem / (1024**3), 2)
+    except ImportError: pass
+    return s
+
+def detect_libs():
+    """Detect installed Python libraries."""
+    common = ["numpy", "pandas", "scipy", "scikit-learn", "sklearn",
+              "torch", "torchvision", "torchaudio", "tensorflow", "keras",
+              "transformers", "datasets", "tokenizers", "accelerate",
+              "matplotlib", "seaborn", "plotly", "pillow", "PIL",
+              "opencv-python", "cv2", "requests", "httpx", "flask", "fastapi",
+              "sqlalchemy", "redis", "celery", "beautifulsoup4", "bs4",
+              "nltk", "spacy", "gensim", "xgboost", "lightgbm", "catboost",
+              "jax", "flax", "optax", "huggingface_hub", "diffusers",
+              "langchain", "openai", "anthropic", "gradio", "streamlit",
+              "pydantic", "sympy", "networkx", "statsmodels",]
+    installed = []
+    for lib in common:
+        try:
+            __import__(lib.replace("-", "_"))
+            installed.append(lib)
+        except ImportError: pass
+    return installed
 
+import psutil
 SPECS = detect_specs()
+INSTALLED_LIBS = detect_libs()
+
+# ─── Sandboxed Execution ───────────────────────────────────────────────────
+BLOCKED_MODULES = {"shutil", "subprocess", "ctypes", "socket"}
+BLOCKED_BUILTINS = {"exec", "eval", "compile", "__import__"} if SANDBOX else set()
+
+def install_libs(libs: list) -> dict:
+    """Install required libraries that are missing."""
+    results = {}
+    for lib in libs:
+        lib_clean = lib.strip().lower()
+        if not lib_clean: continue
+        # Security: only allow known-safe library names
+        if not all(c.isalnum() or c in "-_." for c in lib_clean):
+            results[lib_clean] = "blocked (invalid characters)"
+            continue
+        try:
+            __import__(lib_clean.replace("-", "_").split("==")[0].split(">=")[0])
+            results[lib_clean] = "already installed"
+        except ImportError:
+            try:
+                proc = subprocess.run(
+                    [sys.executable, "-m", "pip", "install", "--quiet", lib_clean],
+                    capture_output=True, text=True, timeout=120
+                )
+                if proc.returncode == 0:
+                    results[lib_clean] = "installed"
+                    INSTALLED_LIBS.append(lib_clean)
+                else:
+                    results[lib_clean] = f"failed: {proc.stderr[:200]}"
+            except subprocess.TimeoutExpired:
+                results[lib_clean] = "timeout"
+            except Exception as e:
+                results[lib_clean] = f"error: {str(e)}"
+    return results
 
 
-def safe_execute(code: str, timeout: int = 300) -> dict:
-    """Safely execute Python code in an isolated namespace with timeout."""
+def safe_execute(code: str, timeout: int = 600, sandbox: bool = True) -> dict:
+    """Execute code with resource limits and isolation."""
     result = {
-        "status": "completed",
-        "result": None,
-        "stdout": "",
-        "stderr": "",
-        "error": None,
-        "execution_time": 0
+        "status": "completed", "result": None, "stdout": "", "stderr": "",
+        "error": None, "execution_time": 0, "resource_usage": {}
     }
 
-    stdout_capture = io.StringIO()
-    stderr_capture = io.StringIO()
-    namespace = {"__builtins__": __builtins__}
+    stdout_cap = io.StringIO()
+    stderr_cap = io.StringIO()
+
+    # Build namespace
+    safe_builtins = {k: v for k, v in __builtins__.__dict__.items()
+                     if k not in BLOCKED_BUILTINS} if sandbox and hasattr(__builtins__, '__dict__') else __builtins__
+    namespace = {"__builtins__": safe_builtins}
+
+    start = time.time()
+    start_mem = psutil.Process().memory_info().rss
 
-    start_time = time.time()
     try:
-        with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
-            exec(code, namespace)
-
-        result["execution_time"] = round(time.time() - start_time, 3)
-        result["stdout"] = stdout_capture.getvalue()
-        result["stderr"] = stderr_capture.getvalue()
-
-        # Try to capture meaningful result
-        # Look for common result patterns
-        for var_name in ["result", "output", "answer", "ret", "__fragment_results__"]:
-            if var_name in namespace:
-                val = namespace[var_name]
+        with redirect_stdout(stdout_cap), redirect_stderr(stderr_cap):
+            exec(compile(code, "<saccp_fragment>", "exec"), namespace)
+
+        result["execution_time"] = round(time.time() - start, 3)
+        result["stdout"] = stdout_cap.getvalue()
+        result["stderr"] = stderr_cap.getvalue()
+
+        end_mem = psutil.Process().memory_info().rss
+        result["resource_usage"] = {
+            "time_seconds": result["execution_time"],
+            "memory_delta_mb": round((end_mem - start_mem) / (1024**2), 2),
+            "peak_memory_mb": round(end_mem / (1024**2), 2),
+        }
+
+        # Capture result
+        for var in ["result", "__saccp_result__", "output", "__fragment_results__", "answer"]:
+            if var in namespace and namespace[var] is not None:
+                val = namespace[var]
                 try:
-                    json.dumps(val)  # Check JSON serializable
+                    json.dumps(val)
                     result["result"] = val
                 except (TypeError, ValueError):
                     result["result"] = str(val)
                 break
 
-        # If no named result, capture last expression result via stdout
         if result["result"] is None and result["stdout"]:
-            result["result"] = result["stdout"].strip()
+            result["result"] = result["stdout"].strip()[-10000:]
 
+    except MemoryError:
+        result["status"] = "failed"
+        result["error"] = "MemoryError: Fragment exceeded available memory"
     except Exception as e:
         result["status"] = "failed"
-        result["error"] = f"{type(e).__name__}: {str(e)}\n{traceback.format_exc()}"
-        result["execution_time"] = round(time.time() - start_time, 3)
-        result["stdout"] = stdout_capture.getvalue()
-        result["stderr"] = stderr_capture.getvalue()
+        result["error"] = f"{type(e).__name__}: {str(e)}\n{traceback.format_exc()[-2000:]}"
+        result["execution_time"] = round(time.time() - start, 3)
+        result["stdout"] = stdout_cap.getvalue()
 
     return result
 
@@ -111,414 +167,224 @@ def safe_execute(code: str, timeout: int = 300) -> dict:
 # ─── Homepage ───────────────────────────────────────────────────────────────
 @app.get("/", response_class=HTMLResponse)
 async def homepage():
-    gpu_info = ""
-    if SPECS.get("gpu_available"):
-        gpu_info = f"""
-        <div class="spec-item">
-            <span class="spec-label">GPU</span>
-            <span class="spec-value">{SPECS.get('gpu_name', 'Unknown')}</span>
-        </div>
-        <div class="spec-item">
-            <span class="spec-label">GPU Memory</span>
-            <span class="spec-value">{SPECS.get('gpu_memory_gb', 0)} GB</span>
-        </div>"""
-
-    type_colors = {"RAM": "#ff6b6b", "CPU": "#00aaff", "GPU": "#aa66ff"}
-    type_color = type_colors.get(NODE_TYPE, "#00ff88")
-
-    current_ram = round(psutil.virtual_memory().available / (1024**3), 2)
-    cpu_percent = psutil.cpu_percent(interval=0.5)
+    tc = {"RAM": "#ff6b6b", "CPU": "#00aaff", "GPU": "#aa66ff"}.get(NODE_TYPE, "#00ff88")
+    ram_avail = round(psutil.virtual_memory().available / (1024**3), 2)
+    cpu_pct = psutil.cpu_percent(interval=0.3)
+    libs_html = "".join(f'<span class="lib">{l}</span>' for l in INSTALLED_LIBS[:30])
 
     html = f"""<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>SharePUTER™ Worker Node</title>
-    <style>
-        @import url('https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@300;400;700&family=Inter:wght@300;400;600;700;900&display=swap');
-        * {{ margin:0; padding:0; box-sizing:border-box; }}
-        body {{
-            font-family:'Inter',sans-serif;
-            background:#0a0a0f;
-            color:#e0e0e0;
-            min-height:100vh;
-            display:flex;
-            align-items:center;
-            justify-content:center;
-        }}
-        .bg {{
-            position:fixed; top:0; left:0; right:0; bottom:0;
-            background-image:
-                radial-gradient(circle at 20% 30%, {type_color}11 0%, transparent 50%),
-                radial-gradient(circle at 80% 70%, {type_color}08 0%, transparent 50%);
-        }}
-        .card {{
-            position:relative; z-index:1;
-            background:rgba(255,255,255,0.02);
-            border:1px solid rgba(255,255,255,0.06);
-            border-radius:24px;
-            padding:48px;
-            max-width:560px;
-            width:90%;
-            backdrop-filter:blur(20px);
-        }}
-        .node-type {{
-            display:inline-block;
-            padding:6px 20px;
-            border-radius:30px;
-            font-family:'JetBrains Mono',monospace;
-            font-size:0.85rem;
-            font-weight:700;
-            letter-spacing:2px;
-            background:{type_color}22;
-            color:{type_color};
-            border:1px solid {type_color}44;
-            margin-bottom:20px;
-        }}
-        h1 {{
-            font-size:2rem;
-            font-weight:900;
-            margin-bottom:4px;
-            background:linear-gradient(135deg,#fff,{type_color});
-            -webkit-background-clip:text;
-            -webkit-text-fill-color:transparent;
-        }}
-        .subtitle {{ color:#888; font-size:0.9rem; margin-bottom:32px; }}
-        .status {{
-            display:flex; align-items:center; gap:10px;
-            margin-bottom:32px;
-            font-family:'JetBrains Mono',monospace;
-            font-size:0.85rem;
-        }}
-        .pulse {{
-            width:10px; height:10px; border-radius:50%;
-            background:#00ff88;
-            animation:pulse 2s ease-in-out infinite;
-        }}
-        @keyframes pulse {{
-            0%,100% {{ box-shadow:0 0 0 0 rgba(0,255,136,0.4); }}
-            50% {{ box-shadow:0 0 0 8px rgba(0,255,136,0); }}
-        }}
-        .specs {{
-            background:rgba(255,255,255,0.02);
-            border:1px solid rgba(255,255,255,0.04);
-            border-radius:12px;
-            padding:20px;
-            margin-bottom:24px;
-        }}
-        .specs h3 {{
-            font-size:0.75rem;
-            text-transform:uppercase;
-            letter-spacing:2px;
-            color:#888;
-            margin-bottom:16px;
-        }}
-        .spec-item {{
-            display:flex; justify-content:space-between;
-            padding:8px 0;
-            border-bottom:1px solid rgba(255,255,255,0.03);
-        }}
-        .spec-item:last-child {{ border-bottom:none; }}
-        .spec-label {{ color:#888; font-size:0.9rem; }}
-        .spec-value {{
-            color:{type_color};
-            font-family:'JetBrains Mono',monospace;
-            font-weight:600;
-            font-size:0.9rem;
-        }}
-        .config {{
-            background:rgba(255,255,255,0.02);
-            border:1px solid rgba(255,255,255,0.04);
-            border-radius:12px;
-            padding:20px;
-        }}
-        .config h3 {{
-            font-size:0.75rem;
-            text-transform:uppercase;
-            letter-spacing:2px;
-            color:#888;
-            margin-bottom:16px;
-        }}
-        .config label {{ display:block; color:#aaa; font-size:0.85rem; margin-bottom:4px; }}
-        .config input, .config select {{
-            width:100%;
-            padding:10px 14px;
-            border-radius:8px;
-            border:1px solid rgba(255,255,255,0.1);
-            background:rgba(255,255,255,0.04);
-            color:#fff;
-            font-family:'JetBrains Mono',monospace;
-            font-size:0.85rem;
-            margin-bottom:14px;
-            outline:none;
-        }}
-        .config input:focus, .config select:focus {{
-            border-color:{type_color}88;
-        }}
-        .btn {{
-            width:100%;
-            padding:12px;
-            border:none;
-            border-radius:10px;
-            background:linear-gradient(135deg,{type_color},{type_color}aa);
-            color:#000;
-            font-weight:700;
-            font-size:0.95rem;
-            cursor:pointer;
-            transition:all 0.2s;
-            font-family:'Inter',sans-serif;
-        }}
-        .btn:hover {{ transform:translateY(-2px); box-shadow:0 4px 20px {type_color}44; }}
-        .footer {{ text-align:center; margin-top:24px; color:#555; font-size:0.75rem; }}
-        #configResult {{
-            margin-top:12px; padding:10px; border-radius:8px;
-            font-family:'JetBrains Mono',monospace; font-size:0.8rem;
-            display:none;
-        }}
-    </style>
-</head>
-<body>
-    <div class="bg"></div>
-    <div class="card">
-        <div class="node-type">{NODE_TYPE} NODE</div>
-        <h1>SharePUTER™ Worker</h1>
-        <p class="subtitle">SACCP Network Compute Node</p>
-
-        <div class="status">
-            <div class="pulse"></div>
-            <span style="color:#00ff88;">{'REGISTERED & WORKING' if REGISTERED else 'ONLINE — NOT REGISTERED'}</span>
-        </div>
-
-        <div class="specs">
-            <h3>System Specifications</h3>
-            <div class="spec-item">
-                <span class="spec-label">Node ID</span>
-                <span class="spec-value">{NODE_ID or 'Not Registered'}</span>
-            </div>
-            <div class="spec-item">
-                <span class="spec-label">CPU Cores</span>
-                <span class="spec-value">{SPECS['cpu_count']}</span>
-            </div>
-            <div class="spec-item">
-                <span class="spec-label">CPU Usage</span>
-                <span class="spec-value">{cpu_percent}%</span>
-            </div>
-            <div class="spec-item">
-                <span class="spec-label">Total RAM</span>
-                <span class="spec-value">{SPECS['ram_total_gb']} GB</span>
-            </div>
-            <div class="spec-item">
-                <span class="spec-label">Available RAM</span>
-                <span class="spec-value">{current_ram} GB</span>
-            </div>
-            <div class="spec-item">
-                <span class="spec-label">Python</span>
-                <span class="spec-value">{SPECS['python_version']}</span>
-            </div>
-            {gpu_info}
-        </div>
-
-        <div class="config">
-            <h3>Node Configuration</h3>
-            <label>Head Node URL</label>
-            <input type="text" id="headUrl" value="{HEAD_NODE_URL}" />
-            <label>Node Type</label>
-            <select id="nodeType">
-                <option value="RAM" {"selected" if NODE_TYPE=="RAM" else ""}>RAM — Provide memory</option>
-                <option value="CPU" {"selected" if NODE_TYPE=="CPU" else ""}>CPU — Provide compute</option>
-                <option value="GPU" {"selected" if NODE_TYPE=="GPU" else ""}>GPU — Provide GPU</option>
-            </select>
-            <label>Owner Username</label>
-            <input type="text" id="owner" value="{NODE_OWNER}" />
-            <button class="btn" onclick="configure()">
-                {'Reconfigure' if REGISTERED else 'Register & Start Working'}
-            </button>
-            <div id="configResult"></div>
-        </div>
-
-        <div class="footer">SharePUTER™ SACCP Network — Worker Node v1.0</div>
-    </div>
-
-    <script>
-    async function configure() {{
-        const headUrl = document.getElementById('headUrl').value;
-        const nodeType = document.getElementById('nodeType').value;
-        const owner = document.getElementById('owner').value;
-        const resultDiv = document.getElementById('configResult');
-
-        resultDiv.style.display = 'block';
-        resultDiv.style.background = 'rgba(0,136,255,0.1)';
-        resultDiv.style.color = '#00aaff';
-        resultDiv.innerText = 'Registering with head node...';
-
-        try {{
-            const resp = await fetch('/configure', {{
-                method: 'POST',
-                headers: {{'Content-Type': 'application/json'}},
-                body: JSON.stringify({{head_url: headUrl, node_type: nodeType, owner: owner}})
-            }});
-            const data = await resp.json();
-            if (resp.ok) {{
-                resultDiv.style.background = 'rgba(0,255,136,0.1)';
-                resultDiv.style.color = '#00ff88';
-                resultDiv.innerText = '✓ ' + (data.message || 'Registered!') + '\\nNode ID: ' + (data.node_id || 'N/A');
-                setTimeout(() => location.reload(), 2000);
-            }} else {{
-                resultDiv.style.background = 'rgba(255,68,68,0.1)';
-                resultDiv.style.color = '#ff4444';
-                resultDiv.innerText = '✗ ' + (data.detail || data.error || 'Failed');
-            }}
-        }} catch (e) {{
-            resultDiv.style.background = 'rgba(255,68,68,0.1)';
-            resultDiv.style.color = '#ff4444';
-            resultDiv.innerText = '✗ Network error: ' + e.message;
-        }}
-    }}
-    </script>
-</body>
-</html>"""
-    return HTMLResponse(content=html)
+<html><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>SharePUTER™ v2 Worker</title>
+<style>
+@import url('https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@300;400;700&family=Inter:wght@300;400;600;900&display=swap');
+*{{margin:0;padding:0;box-sizing:border-box}}
+body{{font-family:'Inter',sans-serif;background:#0a0a0f;color:#e0e0e0;min-height:100vh;
+display:flex;align-items:center;justify-content:center}}
+.bg{{position:fixed;top:0;left:0;right:0;bottom:0;
+background:radial-gradient(circle at 30% 30%,{tc}11,transparent 50%),
+radial-gradient(circle at 70% 70%,{tc}08,transparent 50%)}}
+.card{{position:relative;z-index:1;background:rgba(255,255,255,.02);border:1px solid rgba(255,255,255,.06);
+border-radius:24px;padding:40px;max-width:600px;width:92%}}
+.badge{{display:inline-block;padding:5px 16px;border-radius:20px;font-family:'JetBrains Mono';
+font-size:.8rem;font-weight:700;letter-spacing:2px;background:{tc}22;color:{tc};
+border:1px solid {tc}44;margin-bottom:16px}}
+h1{{font-size:1.8rem;font-weight:900;margin-bottom:4px;
+background:linear-gradient(135deg,#fff,{tc});-webkit-background-clip:text;-webkit-text-fill-color:transparent}}
+.sub{{color:#888;font-size:.85rem;margin-bottom:24px}}
+.pulse{{display:inline-block;width:8px;height:8px;border-radius:50%;background:#00ff88;
+animation:p 2s infinite;margin-right:6px}}
+@keyframes p{{0%,100%{{box-shadow:0 0 0 0 rgba(0,255,136,.4)}}50%{{box-shadow:0 0 0 6px rgba(0,255,136,0)}}}}
+.specs{{background:rgba(255,255,255,.02);border:1px solid rgba(255,255,255,.04);border-radius:12px;
+padding:16px;margin:16px 0}}
+.specs h3{{font-size:.7rem;text-transform:uppercase;letter-spacing:2px;color:#888;margin-bottom:12px}}
+.row{{display:flex;justify-content:space-between;padding:6px 0;border-bottom:1px solid rgba(255,255,255,.03)}}
+.row:last-child{{border:none}}
+.lbl{{color:#888;font-size:.85rem}}
+.val{{color:{tc};font-family:'JetBrains Mono';font-weight:600;font-size:.85rem}}
+.libs{{margin:16px 0}}
+.lib{{display:inline-block;padding:2px 8px;margin:2px;border-radius:4px;font-size:.7rem;
+font-family:'JetBrains Mono';background:rgba(0,255,136,.06);color:#00ff88;
+border:1px solid rgba(0,255,136,.15)}}
+.cfg{{background:rgba(255,255,255,.02);border:1px solid rgba(255,255,255,.04);border-radius:12px;
+padding:16px;margin-top:16px}}
+.cfg label{{display:block;color:#aaa;font-size:.8rem;margin-bottom:3px}}
+.cfg input,.cfg select{{width:100%;padding:8px 12px;border-radius:8px;border:1px solid rgba(255,255,255,.1);
+background:rgba(255,255,255,.04);color:#fff;font-family:'JetBrains Mono';font-size:.85rem;
+margin-bottom:10px;outline:none}}
+.btn{{width:100%;padding:12px;border:none;border-radius:10px;
+background:linear-gradient(135deg,{tc},{tc}aa);color:#000;font-weight:700;cursor:pointer;
+font-family:'Inter';font-size:.95rem;transition:.2s}}
+.btn:hover{{transform:translateY(-2px);box-shadow:0 4px 20px {tc}44}}
+#res{{margin-top:10px;padding:10px;border-radius:8px;font-family:'JetBrains Mono';font-size:.8rem;display:none}}
+.ft{{text-align:center;margin-top:16px;color:#555;font-size:.7rem}}
+</style></head><body>
+<div class="bg"></div>
+<div class="card">
+<div class="badge">{NODE_TYPE} NODE</div>
+<h1>SharePUTER™ v2 Worker</h1>
+<p class="sub">SACCP Network Compute Node</p>
+<div style="font-size:.85rem;margin-bottom:16px">
+<span class="pulse"></span>
+<span style="color:#00ff88">{'REGISTERED & WORKING' if REGISTERED else 'ONLINE — AWAITING REGISTRATION'}</span>
+</div>
+<div class="specs"><h3>System</h3>
+<div class="row"><span class="lbl">Node ID</span><span class="val">{NODE_ID or 'Not registered'}</span></div>
+<div class="row"><span class="lbl">CPU Cores</span><span class="val">{SPECS['cpu_count']}</span></div>
+<div class="row"><span class="lbl">CPU Usage</span><span class="val">{cpu_pct}%</span></div>
+<div class="row"><span class="lbl">Total RAM</span><span class="val">{SPECS['ram_total_gb']} GB</span></div>
+<div class="row"><span class="lbl">Available RAM</span><span class="val">{ram_avail} GB</span></div>
+<div class="row"><span class="lbl">GPU</span><span class="val">{SPECS['gpu_name'] or 'None'} {f"({SPECS['gpu_memory_gb']}GB)" if SPECS['gpu_available'] else ''}</span></div>
+<div class="row"><span class="lbl">Sandbox</span><span class="val">{'Enabled ✓' if SANDBOX else 'Disabled'}</span></div>
+</div>
+<div class="libs"><span style="color:#888;font-size:.7rem;text-transform:uppercase;letter-spacing:2px">Installed Libraries</span><br>{libs_html}</div>
+<div class="cfg"><h3 style="font-size:.7rem;text-transform:uppercase;letter-spacing:2px;color:#888;margin-bottom:12px">Configure</h3>
+<label>Head Node URL</label><input id="url" value="{HEAD_URL}"/>
+<label>Node Type</label>
+<select id="type"><option value="RAM" {"selected" if NODE_TYPE=="RAM" else ""}>RAM</option>
+<option value="CPU" {"selected" if NODE_TYPE=="CPU" else ""}>CPU</option>
+<option value="GPU" {"selected" if NODE_TYPE=="GPU" else ""}>GPU</option></select>
+<label>Owner Username</label><input id="own" value="{NODE_OWNER}"/>
+<button class="btn" onclick="go()">{'Reconfigure' if REGISTERED else 'Register & Start'}</button>
+<div id="res"></div>
+</div>
+<div class="ft">SharePUTER™ SACCP v2.0</div>
+</div>
+<script>
+async function go(){{const r=document.getElementById('res');r.style.display='block';
+r.style.background='rgba(0,136,255,.1)';r.style.color='#00aaff';r.innerText='Registering...';
+try{{const resp=await fetch('/configure',{{method:'POST',headers:{{'Content-Type':'application/json'}},
+body:JSON.stringify({{head_url:document.getElementById('url').value,
+node_type:document.getElementById('type').value,
+owner:document.getElementById('own').value}})}});
+const d=await resp.json();if(resp.ok){{r.style.background='rgba(0,255,136,.1)';r.style.color='#00ff88';
+r.innerText='✓ '+d.message+'\\nNode: '+d.node_id;setTimeout(()=>location.reload(),1500)}}
+else{{r.style.background='rgba(255,68,68,.1)';r.style.color='#ff4444';r.innerText='✗ '+(d.detail||d.error)}}
+}}catch(e){{r.style.background='rgba(255,68,68,.1)';r.style.color='#ff4444';r.innerText='✗ '+e.message}}}}
+</script></body></html>"""
+    return HTMLResponse(html)
 
 
 @app.post("/configure")
-async def configure_node(data: dict):
-    global HEAD_NODE_URL, NODE_TYPE, NODE_OWNER, NODE_ID, REGISTERED
-
-    HEAD_NODE_URL = data.get("head_url", HEAD_NODE_URL)
+async def configure(data: dict):
+    global HEAD_URL, NODE_TYPE, NODE_OWNER, NODE_ID, REGISTERED
+    HEAD_URL = data.get("head_url", HEAD_URL)
     NODE_TYPE = data.get("node_type", NODE_TYPE).upper()
     NODE_OWNER = data.get("owner", NODE_OWNER)
 
-    # Register with head node
     try:
-        async with httpx.AsyncClient(timeout=15.0) as client:
-            resp = await client.post(f"{HEAD_NODE_URL}/api/register_node", json={
-                "node_type": NODE_TYPE,
-                "node_url": os.environ.get("SPACE_HOST", f"http://localhost:7861"),
-                "owner": NODE_OWNER,
-                "specs": SPECS
+        async with httpx.AsyncClient(timeout=15) as c:
+            r = await c.post(f"{HEAD_URL}/api/register_node", json={
+                "node_type": NODE_TYPE, "node_url": os.environ.get("SPACE_HOST", "http://localhost:7861"),
+                "owner": NODE_OWNER, "specs": SPECS, "installed_libs": INSTALLED_LIBS,
+                "sandbox_enabled": SANDBOX,
             })
-            if resp.status_code == 200:
-                result = resp.json()
-                NODE_ID = result.get("node_id")
+            if r.status_code == 200:
+                NODE_ID = r.json().get("node_id")
                 REGISTERED = True
-                return {"message": "Registered successfully", "node_id": NODE_ID, "pay_rate": result.get("pay_rate")}
-            else:
-                return JSONResponse(content={"error": resp.text}, status_code=500)
+                return {"message": "Registered!", "node_id": NODE_ID, "pay_rate": r.json().get("pay_rate")}
+            return JSONResponse({"error": r.text}, 500)
     except Exception as e:
-        return JSONResponse(content={"error": str(e)}, status_code=500)
+        return JSONResponse({"error": str(e)}, 500)
 
 
 @app.get("/health")
 async def health():
-    return {
-        "status": "online",
-        "node_id": NODE_ID,
-        "node_type": NODE_TYPE,
-        "registered": REGISTERED,
-        "specs": SPECS
-    }
+    return {"status": "online", "node_id": NODE_ID, "node_type": NODE_TYPE,
+            "registered": REGISTERED, "version": "2.0.0"}
 
 
-# ─── Worker Loop (runs in background) ──────────────────────────────────────
 async def worker_loop():
-    """Continuously poll head node for work and execute fragments."""
     global NODE_ID, REGISTERED
-
-    # Wait for registration
     while not REGISTERED:
-        await asyncio.sleep(5)
-        # Auto-register if env vars are set
-        if os.environ.get("SACCP_AUTO_REGISTER", "false").lower() == "true":
+        await asyncio.sleep(3)
+        if AUTO_REG:
             try:
-                async with httpx.AsyncClient(timeout=15.0) as client:
-                    resp = await client.post(f"{HEAD_NODE_URL}/api/register_node", json={
+                async with httpx.AsyncClient(timeout=15) as c:
+                    r = await c.post(f"{HEAD_URL}/api/register_node", json={
                         "node_type": NODE_TYPE,
                         "node_url": os.environ.get("SPACE_HOST", "http://localhost:7861"),
-                        "owner": NODE_OWNER,
-                        "specs": SPECS
+                        "owner": NODE_OWNER, "specs": SPECS,
+                        "installed_libs": INSTALLED_LIBS, "sandbox_enabled": SANDBOX,
                     })
-                    if resp.status_code == 200:
-                        result = resp.json()
-                        NODE_ID = result.get("node_id")
+                    if r.status_code == 200:
+                        NODE_ID = r.json().get("node_id")
                         REGISTERED = True
-                        print(f"[SACCP] Auto-registered as {NODE_ID}")
-            except Exception as e:
-                print(f"[SACCP] Auto-register failed: {e}")
-
-    print(f"[SACCP] Worker loop started — Node: {NODE_ID} Type: {NODE_TYPE}")
+            except: pass
 
-    heartbeat_interval = 30
-    last_heartbeat = 0
+    print(f"[SACCP] Worker active: {NODE_ID} ({NODE_TYPE})")
+    last_hb = 0
 
     while True:
         try:
-            # Heartbeat
-            if time.time() - last_heartbeat > heartbeat_interval:
+            if time.time() - last_hb > 25:
                 try:
-                    async with httpx.AsyncClient(timeout=10.0) as client:
-                        await client.post(f"{HEAD_NODE_URL}/api/node_heartbeat", json={
-                            "node_id": NODE_ID,
-                            "status": "online",
+                    async with httpx.AsyncClient(timeout=10) as c:
+                        await c.post(f"{HEAD_URL}/api/node_heartbeat", json={
+                            "node_id": NODE_ID, "status": "online",
+                            "installed_libs": INSTALLED_LIBS,
                             "current_load": {
-                                "cpu_percent": psutil.cpu_percent(),
-                                "ram_available_gb": round(psutil.virtual_memory().available / (1024**3), 2)
+                                "cpu_pct": psutil.cpu_percent(),
+                                "ram_avail_gb": round(psutil.virtual_memory().available/(1024**3), 2),
                             }
                         })
-                    last_heartbeat = time.time()
-                except Exception:
-                    pass
-
-            # Get work
-            async with httpx.AsyncClient(timeout=15.0) as client:
-                resp = await client.get(f"{HEAD_NODE_URL}/api/get_work?node_id={NODE_ID}")
-                if resp.status_code != 200:
-                    await asyncio.sleep(5)
-                    continue
-
-                data = resp.json()
-                work = data.get("work")
-
+                    last_hb = time.time()
+                except: pass
+
+            async with httpx.AsyncClient(timeout=15) as c:
+                libs_str = ",".join(INSTALLED_LIBS)
+                r = await c.get(
+                    f"{HEAD_URL}/api/get_work?node_id={NODE_ID}&node_type={NODE_TYPE}"
+                    f"&has_gpu={SPECS['gpu_available']}&ram_gb={SPECS['ram_available_gb']}"
+                    f"&libs={libs_str}"
+                )
+                if r.status_code != 200:
+                    await asyncio.sleep(3); continue
+                work = r.json().get("work")
                 if not work:
-                    await asyncio.sleep(3)
-                    continue
+                    await asyncio.sleep(2); continue
 
-                fragment_id = work["fragment_id"]
+                fid = work["fragment_id"]
                 code = work.get("code", "")
-                frag_type = work.get("fragment_type", "compute")
+                ftype = work.get("fragment_type", "compute")
+                req_libs = work.get("required_libs", [])
+                timeout = work.get("timeout_seconds", 600)
+
+                print(f"[SACCP] Running {fid} ({ftype})")
 
-                print(f"[SACCP] Executing fragment {fragment_id} (type: {frag_type})")
+                # Install required libraries
+                if req_libs:
+                    install_results = install_libs(req_libs)
+                    print(f"[SACCP] Lib install: {install_results}")
 
-                if frag_type == "setup":
-                    # Setup fragments just validate imports
-                    exec_result = safe_execute(code, timeout=60)
-                elif frag_type == "aggregate":
-                    exec_result = {"status": "completed", "result": "aggregation_placeholder", "stdout": "", "error": None}
+                # Execute
+                if ftype in ("setup", "aggregate", "gradient_aggregate"):
+                    exec_r = safe_execute(code, timeout=120, sandbox=SANDBOX)
                 else:
-                    exec_result = safe_execute(code, timeout=300)
+                    exec_r = safe_execute(code, timeout=timeout, sandbox=SANDBOX)
 
                 # Submit result
-                await client.post(f"{HEAD_NODE_URL}/api/submit_result", json={
-                    "fragment_id": fragment_id,
-                    "node_id": NODE_ID,
-                    "status": exec_result["status"],
-                    "result": exec_result.get("result"),
-                    "error": exec_result.get("error"),
-                    "stdout": exec_result.get("stdout", "")
-                })
+                payload = {
+                    "fragment_id": fid, "node_id": NODE_ID,
+                    "status": exec_r["status"], "result": exec_r.get("result"),
+                    "error": exec_r.get("error"), "stdout": exec_r.get("stdout", ""),
+                    "resource_usage": exec_r.get("resource_usage", {}),
+                }
 
-                print(f"[SACCP] Fragment {fragment_id} -> {exec_result['status']}")
+                # Check for gradient data
+                if isinstance(exec_r.get("result"), dict) and "gradients" in exec_r["result"]:
+                    payload["gradients"] = exec_r["result"]
 
-        except Exception as e:
-            print(f"[SACCP] Worker error: {e}")
-            await asyncio.sleep(5)
+                await c.post(f"{HEAD_URL}/api/submit_result", json=payload)
+                print(f"[SACCP] {fid} → {exec_r['status']} ({exec_r['execution_time']}s)")
 
+        except Exception as e:
+            print(f"[SACCP] Error: {e}")
+            await asyncio.sleep(3)
 
 @app.on_event("startup")
 async def startup():
     asyncio.create_task(worker_loop())
 
-
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7861)