Update app.py

app.py

@@ -1,14 +1,12 @@
 """
-SharePUTER™ v2 Worker Node
-Sandboxed execution, library management, GPU/CPU/RAM support,
-gradient capture for ML workflows.
+SharePUTER™ v2 Worker Node — FIXED
 """
 
 from fastapi import FastAPI
 from fastapi.responses import HTMLResponse, JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 import httpx, asyncio, uuid, os, sys, io, json, time, traceback
-import subprocess, multiprocessing, signal, resource
+import subprocess, multiprocessing
 from datetime import datetime
 from contextlib import redirect_stdout, redirect_stderr
 from typing import Optional
@@ -16,15 +14,14 @@ from typing import Optional
 app = FastAPI(title="SharePUTER™ v2 Worker")
 app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
 
-HEAD_URL = os.environ.get("SACCP_HEAD_URL", "https://bc-ai-saccp-head.hf.space")
+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
 
-# ─── System Detection ──────────────────────────────────────────────────────
+
 def detect_specs():
     import psutil
     s = {
@@ -43,348 +40,204 @@ def detect_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
+    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",]
+    common = ["numpy", "pandas", "scipy", "scikit-learn", "torch", "transformers",
+              "tensorflow", "keras", "pillow", "requests", "httpx", "fastapi", "pydantic"]
     installed = []
     for lib in common:
         try:
             __import__(lib.replace("-", "_"))
             installed.append(lib)
-        except ImportError: pass
+        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 = 600, sandbox: bool = True) -> dict:
-    """Execute code with resource limits and isolation."""
+def safe_execute(code: str, timeout: int = 600) -> dict:
+    """Execute Python code safely."""
     result = {
-        "status": "completed", "result": None, "stdout": "", "stderr": "",
-        "error": None, "execution_time": 0, "resource_usage": {}
+        "status": "completed",
+        "result": None,
+        "stdout": "",
+        "error": None,
+        "execution_time": 0,
+        "resource_usage": {}
     }
 
     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}
+    namespace = {}
 
     start = time.time()
     start_mem = psutil.Process().memory_info().rss
 
     try:
         with redirect_stdout(stdout_cap), redirect_stderr(stderr_cap):
-            exec(compile(code, "<saccp_fragment>", "exec"), namespace)
+            exec(compile(code, "<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"]:
+        # Capture result variable
+        for var in ["result", "__saccp_result__", "__saccp_results__", "output"]:
             if var in namespace and namespace[var] is not None:
                 val = namespace[var]
                 try:
                     json.dumps(val)
                     result["result"] = val
                 except (TypeError, ValueError):
-                    result["result"] = str(val)
+                    result["result"] = str(val)[:5000]
                 break
 
         if result["result"] is None and result["stdout"]:
-            result["result"] = result["stdout"].strip()[-10000:]
+            result["result"] = result["stdout"].strip()[-5000:]
 
-    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()[-2000:]}"
+        result["error"] = f"{type(e).__name__}: {str(e)}\n{traceback.format_exc()[-1500:]}"
         result["execution_time"] = round(time.time() - start, 3)
         result["stdout"] = stdout_cap.getvalue()
 
     return result
 
 
-# ─── Homepage ───────────────────────────────────────────────────────────────
 @app.get("/", response_class=HTMLResponse)
 async def homepage():
-    tc = {"RAM": "#ff6b6b", "CPU": "#00aaff", "GPU": "#aa66ff"}.get(NODE_TYPE, "#00ff88")
+    import psutil
     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><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(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)
-
-    try:
-        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 r.status_code == 200:
-                NODE_ID = r.json().get("node_id")
-                REGISTERED = True
-                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({"error": str(e)}, 500)
+    return HTMLResponse(f"""<!DOCTYPE html>
+<html><head><title>SharePUTER Worker</title>
+<style>body{{font-family:system-ui;background:#0a0a0f;color:#ddd;padding:40px;max-width:600px;margin:0 auto}}
+h1{{color:#00ff88}}.stat{{background:#111;padding:12px;margin:8px 0;border-radius:8px}}</style></head>
+<body><h1>🤖 SharePUTER Worker</h1>
+<p>Node ID: <strong>{NODE_ID or 'Not registered'}</strong></p>
+<p>Type: <strong>{NODE_TYPE}</strong></p>
+<p>Status: <strong style="color:#00ff88">{'ACTIVE' if REGISTERED else 'WAITING'}</strong></p>
+<div class="stat">CPUs: {SPECS['cpu_count']}</div>
+<div class="stat">RAM: {ram_avail} / {SPECS['ram_total_gb']} GB</div>
+<div class="stat">GPU: {SPECS['gpu_name'] or 'None'}</div>
+<div class="stat">Libs: {', '.join(INSTALLED_LIBS[:10])}</div>
+</body></html>""")
 
 
 @app.get("/health")
 async def health():
-    return {"status": "online", "node_id": NODE_ID, "node_type": NODE_TYPE,
-            "registered": REGISTERED, "version": "2.0.0"}
+    return {"status": "online", "node_id": NODE_ID, "registered": REGISTERED}
 
 
 async def worker_loop():
     global NODE_ID, REGISTERED
+    
+    # Wait for registration
     while not REGISTERED:
-        await asyncio.sleep(3)
+        await asyncio.sleep(2)
         if AUTO_REG:
             try:
                 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,
+                        "owner": NODE_OWNER,
+                        "specs": SPECS,
+                        "installed_libs": INSTALLED_LIBS,
                     })
                     if r.status_code == 200:
                         NODE_ID = r.json().get("node_id")
                         REGISTERED = True
-            except: pass
+                        print(f"[SACCP] Registered as {NODE_ID}")
+            except Exception as e:
+                print(f"[SACCP] Registration failed: {e}")
 
     print(f"[SACCP] Worker active: {NODE_ID} ({NODE_TYPE})")
     last_hb = 0
 
     while True:
         try:
+            # Heartbeat every 25 seconds
             if time.time() - last_hb > 25:
                 try:
                     async with httpx.AsyncClient(timeout=10) as c:
                         await c.post(f"{HEAD_URL}/api/node_heartbeat", json={
-                            "node_id": NODE_ID, "status": "online",
+                            "node_id": NODE_ID,
+                            "status": "online",
                             "installed_libs": INSTALLED_LIBS,
-                            "current_load": {
-                                "cpu_pct": psutil.cpu_percent(),
-                                "ram_avail_gb": round(psutil.virtual_memory().available/(1024**3), 2),
-                            }
                         })
                     last_hb = time.time()
-                except: pass
+                except:
+                    pass
 
+            # Get work
             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}"
+                    f"{HEAD_URL}/api/get_work",
+                    params={
+                        "node_id": NODE_ID,
+                        "node_type": NODE_TYPE,
+                        "has_gpu": str(SPECS['gpu_available']).lower(),
+                        "ram_gb": SPECS['ram_available_gb'],
+                        "libs": libs_str,
+                    }
                 )
+                
                 if r.status_code != 200:
-                    await asyncio.sleep(3); continue
+                    await asyncio.sleep(2)
+                    continue
+                
                 work = r.json().get("work")
                 if not work:
-                    await asyncio.sleep(2); continue
+                    await asyncio.sleep(1)
+                    continue
 
-                fid = work["fragment_id"]
+                frag_id = work["fragment_id"]
                 code = work.get("code", "")
                 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] Running {frag_id} ({ftype})")
 
-                # Install required libraries
-                if req_libs:
-                    install_results = install_libs(req_libs)
-                    print(f"[SACCP] Lib install: {install_results}")
-
-                # Execute
-                if ftype in ("setup", "aggregate", "gradient_aggregate"):
-                    exec_r = safe_execute(code, timeout=120, sandbox=SANDBOX)
-                else:
-                    exec_r = safe_execute(code, timeout=timeout, sandbox=SANDBOX)
+                # Execute the code
+                exec_result = safe_execute(code, timeout=timeout)
 
                 # Submit result
-                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", {}),
-                }
-
-                # Check for gradient data
-                if isinstance(exec_r.get("result"), dict) and "gradients" in exec_r["result"]:
-                    payload["gradients"] = exec_r["result"]
-
-                await c.post(f"{HEAD_URL}/api/submit_result", json=payload)
-                print(f"[SACCP] {fid} → {exec_r['status']} ({exec_r['execution_time']}s)")
+                await c.post(f"{HEAD_URL}/api/submit_result", json={
+                    "fragment_id": frag_id,
+                    "node_id": NODE_ID,
+                    "status": exec_result["status"],
+                    "result": exec_result.get("result"),
+                    "error": exec_result.get("error"),
+                    "stdout": exec_result.get("stdout", ""),
+                    "resource_usage": exec_result.get("resource_usage", {}),
+                })
+
+                print(f"[SACCP] {frag_id} → {exec_result['status']} ({exec_result['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)