Upload server.py

server.py

@@ -18,10 +18,9 @@ from core import (
 )
 from ghost_deploy import ghost, CANONICAL_REPO, PinggyTunnel
 
-# ─── STABLE VIBE: Port 8765 for HF Spaces Docker routing ───
-#  The Dockerfile exposes 8765; HF reverse proxy routes to it.
-#  Override via WIZARD_PORT only in dev sandboxes.
-PORT = int(os.environ.get("WIZARD_PORT", 8765))
+# ─── VISIBILITY OVERRIDE: Port 7860 hardcoded, 0.0.0.0 binding ───
+#  Binds strictly to 0.0.0.0:7860. Override via WIZARD_PORT only in dev.
+PORT = int(os.environ.get("WIZARD_PORT", 7860))
 STATIC = Path(__file__).parent / "static"
 WIZARD_HAT_COLOR = "steady-gold"  # The Athanor is active
 
@@ -31,19 +30,11 @@ def _sse(ev, d):
 
 
 async def stream_gen(sid, prompt):
-    """
-    Omni-Vibe streaming pipeline:
-    1. POSE — all three agents analyze in parallel
-    2. GENERATE — Pose Architect + Pose Painter produce code
-    3. AUDIT — Pose Auditor verifies step-by-step
-    4. HEAL — Reflect-Select loop until perfection
-    5. DEPLOY — Ghost Deploy to HF Spaces + Pinggy tunnel
-    """
+    """Omni-Vibe streaming pipeline: Pose → Generate → Audit → Heal → Sandbox"""
     session = st.sessions[sid]
     session["status"] = "streaming"
     st.sandbox[sid] = "building"
 
-    # Phase 1: Pose
     yield _sse("phase", {"phase": "pose", "hat": WIZARD_HAT_COLOR})
     await asyncio.sleep(0.05)
 
@@ -58,7 +49,6 @@ async def stream_gen(sid, prompt):
         "auditor": pose_plan["auditor"],
     })
 
-    # Phase 2: Generate
     yield _sse("phase", {"phase": "generate"})
     await asyncio.sleep(0.05)
 
@@ -66,231 +56,153 @@ async def stream_gen(sid, prompt):
     code, schema = st.engine.generate(prompt)
     elapsed = (time.time() - t0) * 1000
 
-    # Stream in chunks for live UI
     chunk_size = max(1, len(code) // 30)
     for i in range(0, len(code), chunk_size):
         chunk = code[i:i + chunk_size]
         yield _sse("code", {
-            "chunk": chunk,
-            "partial": code[:i + chunk_size],
+            "chunk": chunk, "partial": code[:i + chunk_size],
             "progress": min(100, int((i + chunk_size) / len(code) * 100)),
         })
         await asyncio.sleep(0.015)
 
     st.codes[sid] = code
     st.sessions[sid]["schema"] = schema
-    yield _sse("generated", {
-        "chars": len(code),
-        "elapsed_ms": round(elapsed, 1),
-        "schema": {k: v for k, v in schema.items() if k != "files_needed"},
-    })
+    yield _sse("generated", {"chars": len(code), "elapsed_ms": round(elapsed, 1),
+        "schema": {k: v for k, v in schema.items() if k != "files_needed"}})
 
-    # Phase 3: Audit
     yield _sse("phase", {"phase": "audit"})
     await asyncio.sleep(0.05)
-
     findings = st.engine.auditor.audit(code, schema)
-    yield _sse("audit", {
-        "findings": len(findings),
+    yield _sse("audit", {"findings": len(findings),
         "errors": sum(1 for f in findings if f.severity == "ERROR"),
         "warnings": sum(1 for f in findings if f.severity == "WARN"),
         "details": [{"line": f.line, "severity": f.severity, "message": f.message}
-                     for f in findings[:5]],
-    })
+                     for f in findings[:5]]})
 
-    # Phase 4: Heal (Reflect-Select)
     yield _sse("phase", {"phase": "heal"})
-
     code, auto_fixes = st.engine.auditor.heal_findings(code, findings)
     st.codes[sid] = code
-
     healed, found, fixed = st.reflect.heal(code)
     total_heals = fixed + auto_fixes
-
     for i in range(15):
         result = sandbox_validate(healed)
-        if result["success"]:
-            break
+        if result["success"]: break
         healed, _, extra = st.reflect.heal(healed, result["errors"])
         total_heals += extra
         st.codes[sid] = healed
         await asyncio.sleep(0.01)
+    yield _sse("heal", {"auto_fixes": auto_fixes, "reflect_fixes": fixed,
+        "total_heals": total_heals, "loop_iterations": i + 1})
 
-    yield _sse("heal", {
-        "auto_fixes": auto_fixes,
-        "reflect_fixes": fixed,
-        "total_heals": total_heals,
-        "loop_iterations": i + 1,
-    })
-
-    # Phase 5: Sandbox Validation
     yield _sse("phase", {"phase": "sandbox"})
     result = sandbox_validate(healed)
     if result["success"]:
-        st.sandbox[sid] = "stable"
-        st.publish_ready[sid] = True
+        st.sandbox[sid] = "stable"; st.publish_ready[sid] = True
         yield _sse("sandbox", {"status": "stable", "errors": 0, "hat": "steady-gold"})
     else:
         st.sandbox[sid] = "error"
         yield _sse("sandbox", {"status": "error", "errors": result["errors"]})
-
     session["status"] = "complete"
-    yield _sse("done", {
-        "status": st.sandbox[sid],
-        "hat": "steady-gold" if st.sandbox[sid] == "stable" else "red-glow",
-    })
+    yield _sse("done", {"status": st.sandbox[sid],
+        "hat": "steady-gold" if st.sandbox[sid] == "stable" else "red-glow"})
 
 
 async def handle_stream(req):
     sid = str(uuid.uuid4())[:8]
-    d = await req.json()
-    prompt = d.get("prompt", "")
-
+    d = await req.json(); prompt = d.get("prompt", "")
     st.sessions[sid] = {"id": sid, "prompt": prompt, "status": "init"}
-    st.sandbox[sid] = "building"
-    st.publish_ready[sid] = False
-
-    resp = web.StreamResponse(
-        status=200,
-        headers={
-            "Content-Type": "text/event-stream",
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "X-Accel-Buffering": "no",
-        },
-    )
+    st.sandbox[sid] = "building"; st.publish_ready[sid] = False
+    resp = web.StreamResponse(status=200, headers={
+        "Content-Type": "text/event-stream", "Cache-Control": "no-cache",
+        "Connection": "keep-alive", "X-Accel-Buffering": "no"})
     await resp.prepare(req)
     try:
-        async for ev in stream_gen(sid, prompt):
-            await resp.write(ev.encode())
+        async for ev in stream_gen(sid, prompt): await resp.write(ev.encode())
         await resp.write(b"event: close\ndata: {}\n\n")
     except Exception as e:
-        await resp.write(
-            f"event: error\ndata: {json.dumps({'error': str(e)})}\n\n".encode()
-        )
+        await resp.write(f"event: error\ndata: {json.dumps({'error':str(e)})}\n\n".encode())
     return resp
 
 
 async def handle_publish(req):
-    d = await req.json()
-    sid = d.get("session_id")
+    d = await req.json(); sid = d.get("session_id")
     vibe_name = d.get("vibe_name", f"omni-vibe-{sid}")
-
     if not st.publish_ready.get(sid):
-        return web.json_response(
-            {"success": False, "error": "Sandbox not stable — Pose Auditor requires perfection."},
-            status=400,
-        )
-
+        return web.json_response({"success":False,"error":"Sandbox not stable"}, status=400)
     code = st.codes.get(sid, "")
-    if not code:
-        return web.json_response({"success": False, "error": "No code generated"}, status=400)
-
-    description = d.get("description", st.sessions.get(sid, {}).get("prompt", ""))
+    if not code: return web.json_response({"success":False,"error":"No code"}, status=400)
+    description = d.get("description", st.sessions.get(sid,{}).get("prompt",""))
     result = await ghost.publish(code, vibe_name, description[:200] if description else "", port=PORT)
-
     if result.get("success"):
         st.sessions[sid]["published"] = True
         st.sessions[sid]["deploy_url"] = result.get("space_url")
-        st.sessions[sid]["tunnel_url"] = result.get("tunnel_url")
-
     return web.json_response(result)
 
 
 async def handle_health(req):
     return web.json_response({
-        "status": "alive",
-        "engine": "Omni-Vibe Studio — Specialized Swarm",
+        "status": "alive", "engine": "Omni-Vibe Studio — Specialized Swarm",
         "protocol": "omni-vibe / tokenless / shadow-hosting",
-        "registry": CANONICAL_REPO,
-        "lifert": True,
-        "poses": {
-            "architect": "full-stack + zero-DB + Google OAuth",
-            "painter": "Liquid Glass design system",
-            "auditor": "step-by-step verification",
-        },
-        "hat": WIZARD_HAT_COLOR,
-        "hf_token": bool(os.environ.get("HF_TOKEN")),
+        "registry": CANONICAL_REPO, "lifert": True,
+        "poses": {"architect": "full-stack + zero-DB + Google OAuth",
+                   "painter": "Liquid Glass design system",
+                   "auditor": "step-by-step verification"},
+        "hat": WIZARD_HAT_COLOR, "hf_token": bool(os.environ.get("HF_TOKEN")),
+        "binding": "0.0.0.0:7860",
     })
 
 
 async def handle_agent(req):
     return web.json_response(ghost.generate_agent_card(
         "omni-vibe-studio",
-        "Omni-Vibe Studio — Specialized AI Swarm. Pose Architect designs full-stack schemas with zero-config DB and Google OAuth. Pose Painter enforces Liquid Glass design. Pose Auditor verifies step-by-step. LiteRT engine for sub-second latency.",
-        "https://dryymatt-wizard-vibe-studio-v2.hf.space",
-    ))
+        "Omni-Vibe Studio — Specialized AI Swarm. 0.0.0.0:7860. Zero-config DB, Google OAuth, Liquid Glass.",
+        "https://dryymatt-wizard-vibe-studio-v2.hf.space"))
 
 
 async def handle_preview(req):
     sid = req.query.get("session_id", "")
-    return web.Response(
-        text=st.codes.get(sid, "<!-- Omni-Vibe — no code -->"),
-        content_type="text/html",
-    )
+    return web.Response(text=st.codes.get(sid, "<!-- Omni-Vibe -->"), content_type="text/html")
 
 
 async def handle_status(req):
     sid = req.query.get("session_id", "")
     if sid in st.sessions:
         s = st.sessions[sid]
-        return web.json_response({
-            "status": s["status"],
-            "sandbox": st.sandbox.get(sid),
-            "ready": st.publish_ready.get(sid),
-            "deploy_url": s.get("deploy_url"),
-            "tunnel_url": s.get("tunnel_url"),
-            "hat": "steady-gold" if st.publish_ready.get(sid) else "cyan-blink",
-        })
-    return web.json_response({
-        "sessions": len(st.sessions),
-        "engine": "omni-vibe",
-        "hat": WIZARD_HAT_COLOR,
-    })
+        return web.json_response({"status":s["status"],"sandbox":st.sandbox.get(sid),
+            "ready":st.publish_ready.get(sid),"deploy_url":s.get("deploy_url"),
+            "hat":"steady-gold" if st.publish_ready.get(sid) else "cyan-blink"})
+    return web.json_response({"sessions":len(st.sessions),"engine":"omni-vibe","hat":WIZARD_HAT_COLOR})
 
 
 async def handle_vibes(req):
     vibes = await ghost.list_vibes()
-    return web.json_response({
-        "vibes": vibes,
-        "count": len(vibes),
-        "registry": CANONICAL_REPO,
-    })
+    return web.json_response({"vibes":vibes,"count":len(vibes),"registry":CANONICAL_REPO})
 
 
 async def handle_tunnel(req):
-    """Bring up an ephemeral Pinggy/Cloudflare tunnel for instant preview."""
     try:
         url = await ghost.tunnel.up(PORT, timeout=10.0)
-        return web.json_response({"success": bool(url), "url": url})
+        return web.json_response({"success":bool(url),"url":url})
     except Exception as e:
-        return web.json_response({"success": False, "error": str(e)}, status=500)
+        return web.json_response({"success":False,"error":str(e)}, status=500)
 
 
 async def handle_schema(req):
-    """Get the full-stack schema for the current session."""
     sid = req.query.get("session_id", "")
-    s = st.sessions.get(sid, {})
-    schema = s.get("schema", {})
-    return web.json_response(schema)
+    return web.json_response(st.sessions.get(sid,{}).get("schema",{}))
 
 
-# ═══════════════════════════════════════════════════════
-#  ROOT HANDLER — HF Platform Health-Check Protocol
-# ═══════════════════════════════════════════════════════
-#  HF Spaces sends periodic HEAD/GET probes to /.
-#  aiohttp auto-registers HEAD for every GET route.
-#  A 404 or timeout triggers "Starting" loops.
-#  This handler returns 200 OK in <1ms.
+# ═════════════════ ROOT HANDLER ═════════════════
+#  Returns valid HTML at / — no redirects, no auth.
+#  aiohttp auto-registers HEAD → 200 OK for health probes.
 
 async def handle_root_get(req):
-    """GET / → Liquid Glass landing page with 200 OK."""
     fp = STATIC / "index.html"
     if fp.exists():
         return web.Response(text=fp.read_text(), content_type="text/html")
     return web.Response(text=INDEX_FALLBACK, content_type="text/html")
 
-# Static fallback for when static/index.html is missing
+
 INDEX_FALLBACK = """<!DOCTYPE html>
 <html lang="en">
 <head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1.0">
@@ -307,28 +219,22 @@ p{color:var(--text2);margin-top:1rem;font-size:1.1rem}
 <body><div class="glass">
 <h1 class="gradient-text">Omni-Vibe Studio</h1>
 <p>Specialized Swarm — Steady Gold</p>
-<p style="font-size:.85rem;color:#606080;margin-top:2rem">Pose Architect · Pose Painter · Pose Auditor</p>
+<p style="font-size:.85rem;color:#606080;margin-top:2rem">0.0.0.0:7860 · Pose Architect · Pose Painter · Pose Auditor</p>
 </div></body></html>"""
 
 
-# ─── Static file handler (for all non-root paths) ───
-
 async def handle_static(req):
     path = req.match_info.get("path", "index.html")
     fp = STATIC / path
     if not fp.exists():
         return web.Response(text="Not found", status=404)
-    ct = {".html": "text/html", ".css": "text/css", ".js": "application/javascript"}
-    return web.Response(text=fp.read_text(), content_type=ct.get(fp.suffix, "text/plain"))
+    ct = {".html":"text/html",".css":"text/css",".js":"application/javascript"}
+    return web.Response(text=fp.read_text(), content_type=ct.get(fp.suffix,"text/plain"))
 
 
 def create_app():
     app = web.Application()
-
-    # ─── Root: GET returns Liquid Glass; aiohttp auto-adds HEAD → 200 ───
     app.router.add_get("/", handle_root_get)
-
-    # ─── API routes ───
     app.router.add_post("/api/stream", handle_stream)
     app.router.add_post("/api/publish", handle_publish)
     app.router.add_get("/api/status", handle_status)
@@ -338,10 +244,7 @@ def create_app():
     app.router.add_get("/api/tunnel", handle_tunnel)
     app.router.add_get("/api/schema", handle_schema)
     app.router.add_get("/.well-known/agent.json", handle_agent)
-
-    # ─── Catch-all static (after explicit root) ───
     app.router.add_get("/{path:.*}", handle_static)
-
     return app
 
 
@@ -352,49 +255,36 @@ def main():
     print(f"   Pose Auditor   : step-by-step verification")
     print(f"   Athanor        : LiteRT engine, sub-second latency")
     print(f"   Registry       : {CANONICAL_REPO}")
-    print(f"   Port           : {PORT} (hardcoded 7860)")
+    print(f"   Binding        : 0.0.0.0:{PORT}")
     print(f"   Hat            : {WIZARD_HAT_COLOR}")
 
-    # ─── Ghost-Link Persistence: start tunnel watchdog ───
     tunnel = ghost.tunnel
     loop = asyncio.new_event_loop()
     asyncio.set_event_loop(loop)
 
     async def tunnel_watchdog(interval: float = 30.0):
-        """Keep the Pinggy/Cloudflare tunnel alive. Restart on drop."""
-        await asyncio.sleep(3)  # let the server bind first
+        await asyncio.sleep(3)
         retries = 0
         while True:
             try:
                 if tunnel.url is None:
-                    print(f"🔗 Tunnel: attempting connect (retry #{retries})…")
+                    print(f"🔗 Tunnel: connecting (retry #{retries})…")
                     url = await tunnel.up(PORT, timeout=10.0)
                     if url:
                         print(f"🔗 Tunnel: LIVE → {url}")
                         retries = 0
-                    else:
-                        retries += 1
+                    else: retries += 1
                 else:
-                    # Health check: curl the tunnel URL
-                    alive = await _ping_url(tunnel.url)
-                    if not alive:
-                        print(f"🔗 Tunnel: DEAD ({tunnel.url}) — restarting…")
-                        tunnel.down()
-                        retries += 1
+                    import aiohttp
+                    async with aiohttp.ClientSession() as s:
+                        async with s.get(tunnel.url, timeout=aiohttp.ClientTimeout(total=5)) as r:
+                            if r.status >= 500:
+                                print(f"🔗 Tunnel: DEAD — restarting…")
+                                tunnel.down(); retries += 1
             except Exception as e:
-                print(f"🔗 Tunnel: error — {e}")
-                retries += 1
+                print(f"🔗 Tunnel: error — {e}"); retries += 1
             await asyncio.sleep(interval * (1 + min(retries, 5) * 0.5))
 
-    async def _ping_url(url: str) -> bool:
-        try:
-            import aiohttp
-            async with aiohttp.ClientSession() as s:
-                async with s.get(url, timeout=aiohttp.ClientTimeout(total=5)) as r:
-                    return r.status < 500
-        except Exception:
-            return False
-
     loop.create_task(tunnel_watchdog())
     web.run_app(create_app(), host="0.0.0.0", port=PORT, handle_signals=True)