deploy(S4): Blender headless pipeline + WebAR client + backend fixes

backend/main.py

@@ -79,6 +79,7 @@ from backend.routes.internet_routes   import router as internet_router
 from backend.routes.sentinel_routes   import router as sentinel_router
 from backend.routers.gaming_routes    import router as gaming_router
 from backend.routes.model_proxy_routes import router as model_proxy_router  # AR-FIX-SESSION
+from backend.routes.mobile_bridge_routes import router as mobile_bridge_router  # S4: Guardian /api compat
 
 from backend.services.voice_service  import start_wake_word_loop
 from backend.services.usb_monitor    import start_usb_monitor
@@ -148,6 +149,11 @@ app.include_router(model_proxy_router, prefix="/api")  # AR-FIX-SESSION: model p
 # /api/ar_config, /api/ar_task, /api/ar_scene_patch — the backend only ever mounted
 # them under /xr, so every OMEGA link from the AR client 404'd. Serve both prefixes.
 app.include_router(xr_router,         prefix="/api",       dependencies=[Depends(verify_token)])
+# S4: the JARVIS Mobile Guardian APK's remaining /api/* REST contract (status, caps,
+# link_info, pair_confirm, command, phone_observe, jarvis/mobile_event,
+# max_autonomy/task) had no cloud handler and 404'd against the Space. This compat
+# router serves exactly those, delegating to modules/max_autonomy + phone/crypto.
+app.include_router(mobile_bridge_router, prefix="/api",     dependencies=[Depends(verify_token)])
 
 # S4: serve generated 3D models. xr_tools.push_model_to_ar_scene has always broadcast
 # /static/models3d/<file> URLs, but nothing ever mounted them — every spawned GLB 404'd.

backend/routes/mobile_bridge_routes.py

@@ -0,0 +1,300 @@
+from __future__ import annotations
+
+"""
+backend/routes/mobile_bridge_routes.py — S4 Guardian ⇄ cloud REST compatibility.
+
+The JARVIS Mobile Guardian APK (phone/jarvis-mobile-guardian) speaks a fixed
+`/api/*` REST contract (see network/ApiClient.kt). On the local PC that contract
+is served by phone/local_server.py on :7474; on the cloud it was only partially
+served — xr_router@/api covers ar_task/ar_scene/ar_game_state/ar_game_builder,
+but eight endpoints (pair_confirm, status, caps, link_info, command,
+phone_observe, jarvis/mobile_event, max_autonomy/task) had no cloud handler, so
+Guardian's status card, capability grid, AR-URL fetch, command box, telemetry
+sync and autonomy tasks all 404'd against jarvis-cloud.hf.space.
+
+This router fills exactly those gaps, mounted at /api behind verify_token
+(Guardian sends `Authorization: Bearer <JARVIS_CLOUD_TOKEN>` on every call). It
+delegates to the real cross-device coordinator (modules/max_autonomy.py — the
+module explicitly built as "the single backend surface for APK, PC AR, browser
+panels and Guardian heartbeats") and the shared AES-GCM helpers (phone/crypto.py)
+rather than re-implementing behaviour, so cloud and PC stay in lock-step.
+
+Encrypted /api/command: Guardian derives its AES key as SHA-256(passphrase)
+(CryptoBox.deriveKey). phone/crypto.LinkConfig.key_bytes() derives the same way,
+so a cloud pairing whose passphrase is the JARVIS_CLOUD_TOKEN lets the Space
+decrypt and route the command through the safety-gated autonomy engine.
+"""
+
+import base64
+import hashlib
+import logging
+import os
+import secrets
+import time
+from typing import Any
+
+from fastapi import APIRouter, Request
+
+router = APIRouter()
+log = logging.getLogger(__name__)
+
+_BOOT_TS = time.time()
+
+
+# --------------------------------------------------------------------------- #
+# helpers
+# --------------------------------------------------------------------------- #
+def _master_token() -> str:
+    try:
+        from backend.dependencies.auth import get_or_create_master_token
+        return get_or_create_master_token()
+    except Exception:
+        return os.environ.get("JARVIS_CLOUD_TOKEN", "").strip()
+
+
+def _uptime_str() -> str:
+    secs = int(time.time() - _BOOT_TS)
+    h, rem = divmod(secs, 3600)
+    m, s = divmod(rem, 60)
+    if h:
+        return f"{h}h {m}m"
+    if m:
+        return f"{m}m {s}s"
+    return f"{s}s"
+
+
+def _cpu_ram() -> tuple[float | None, float | None]:
+    try:
+        import psutil  # type: ignore
+        return (
+            float(psutil.cpu_percent(interval=None)),
+            float(psutil.virtual_memory().percent),
+        )
+    except Exception:
+        return (None, None)
+
+
+def _base_url(request: Request) -> str:
+    # Honour reverse-proxy host so the AR URL points at the public Space, not the
+    # internal 127.0.0.1:7860 uvicorn bind.
+    host = request.headers.get("x-forwarded-host") or request.headers.get("host")
+    if host:
+        proto = request.headers.get("x-forwarded-proto") or request.url.scheme
+        return f"{proto}://{host}".rstrip("/")
+    return str(request.base_url).rstrip("/")
+
+
+async def _json_body(request: Request) -> dict[str, Any]:
+    try:
+        data = await request.json()
+        return data if isinstance(data, dict) else {}
+    except Exception:
+        return {}
+
+
+def _candidate_keys() -> list[bytes]:
+    """AES keys to try when decrypting a Guardian command envelope, best-first."""
+    keys: list[bytes] = []
+    token = _master_token()
+    if token:
+        keys.append(hashlib.sha256(token.encode("utf-8")).digest())
+    try:
+        from phone.crypto import load_or_create_link
+        keys.append(load_or_create_link().key_bytes())
+    except Exception as _exc:
+        log.debug("link key unavailable: %s", _exc)
+    return keys
+
+
+# --------------------------------------------------------------------------- #
+# pairing / status / capabilities / link info
+# --------------------------------------------------------------------------- #
+@router.post("/pair_confirm")
+async def pair_confirm(request: Request) -> dict[str, Any]:
+    body = await _json_body(request)
+    device_name = str(body.get("device_name") or "android").strip()[:64]
+    passphrase = str(body.get("passphrase") or "").strip()
+    # The Bearer token already authenticated the request; pairing simply records
+    # the device. If the passphrase matches the cloud token, encrypted commands
+    # will also decrypt cleanly (see /command).
+    token = _master_token()
+    keyed = bool(token) and secrets.compare_digest(passphrase, token)
+    try:
+        from phone.pairing import mark_paired
+        mark_paired(device_name=device_name or "android")
+    except Exception as _exc:
+        log.debug("mark_paired skipped on cloud: %s", _exc)
+    return {"ok": True, "paired": True, "keyed": keyed, "device_name": device_name}
+
+
+@router.get("/status")
+async def status() -> dict[str, Any]:
+    cpu, ram = _cpu_ram()
+    location = "cloud" if os.environ.get("SPACE_ID") else "pc"
+    return {
+        "ok": True,
+        "status": "online",
+        "version": "1.0.0",
+        "uptime": _uptime_str(),
+        "mode": location,
+        "activated": True,
+        "assistant_name": "JARVIS",
+        "cpu": cpu,
+        "ram": ram,
+    }
+
+
+@router.get("/caps")
+async def caps() -> dict[str, Any]:
+    """Flatten the capability catalogue to the {capabilities:[str]} shape the APK
+    deserializes (CapabilityList)."""
+    labels: list[str] = []
+    try:
+        from phone.capabilities import capabilities_payload
+        for category in capabilities_payload().get("categories", []):
+            for item in category.get("items", []):
+                label = str(item.get("label") or item.get("cmd") or "").strip()
+                if label:
+                    labels.append(label)
+    except Exception as _exc:
+        log.debug("capabilities unavailable: %s", _exc)
+    return {"ok": True, "capabilities": labels}
+
+
+@router.get("/link_info")
+async def link_info(request: Request) -> dict[str, Any]:
+    base = _base_url(request)
+    ws_base = base.replace("https://", "wss://").replace("http://", "ws://")
+    ar_url = f"{base}/webar/"
+    return {
+        "ok": True,
+        "assistant": "JARVIS",
+        "host": base,
+        "pwa": ar_url,
+        "pwa_https": ar_url,
+        "ar": ar_url,
+        "ar_https": ar_url,
+        "ar_engine": "8thwall",
+        "ar_runtime": "webxr",
+        "scene_ws": f"{ws_base}/scene/ws",
+    }
+
+
+# --------------------------------------------------------------------------- #
+# command (encrypted) — routed through the safety-gated autonomy engine
+# --------------------------------------------------------------------------- #
+@router.post("/command")
+async def command(request: Request) -> dict[str, Any]:
+    envelope = await _json_body(request)
+    if not (envelope.get("nonce") and envelope.get("ciphertext")):
+        return {"ok": False, "error": "expected encrypted envelope {nonce, ciphertext}"}
+
+    plaintext: dict[str, Any] | None = None
+    try:
+        from phone.crypto import decrypt_json
+        for key in _candidate_keys():
+            try:
+                plaintext = decrypt_json(envelope, key)
+                break
+            except Exception:
+                continue
+    except Exception as _exc:
+        log.debug("decrypt_json import failed: %s", _exc)
+
+    if not isinstance(plaintext, dict):
+        # Wrong pairing passphrase for the cloud: pair with the cloud access key
+        # so the Space can derive the same AES key.
+        return {"ok": False, "error": "decrypt failed — pair using your cloud access key"}
+
+    cmd = str(plaintext.get("cmd") or "").strip()
+    if not cmd:
+        return {"ok": False, "error": "missing cmd"}
+    device_name = str(plaintext.get("device_name") or "").strip()[:80]
+
+    try:
+        from modules.max_autonomy import execute_task
+        # This router only ever serves the *cloud* path (on the LAN, Guardian hits
+        # phone/local_server.py:7474, which executes for real against the PC). The
+        # cloud container has no PC to drive, so the honest behaviour is to run the
+        # command through the safety-gated coordinator in record+sync mode: it is
+        # logged, risk-assessed and pushed to the AR HUD, without faking hardware
+        # control. Real desktop actions stay on the paired-PC channel.
+        result = execute_task(
+            cmd,
+            source="guardian_command",
+            device_name=device_name,
+            context={"record_only": True},
+        )
+        spoken = list(result.response or [])
+        return {"ok": bool(result.ok), "spoken": spoken, "status": result.status, "action": result.action}
+    except Exception as exc:
+        log.warning("guardian command routing failed: %s", exc)
+        return {"ok": False, "spoken": [f"Command failed: {str(exc)[:160]}"]}
+
+
+# --------------------------------------------------------------------------- #
+# telemetry / events / autonomy
+# --------------------------------------------------------------------------- #
+@router.post("/phone_observe")
+async def phone_observe(request: Request) -> dict[str, Any]:
+    body = await _json_body(request)
+    device_name = str(body.get("device_name") or "").strip()[:80]
+    payload = {k: v for k, v in body.items() if k != "device_name"}
+    try:
+        from modules.max_autonomy import record_mobile_event
+        record_mobile_event("phone_observe", payload, device_name=device_name)
+    except Exception as exc:
+        log.debug("phone_observe record failed: %s", exc)
+        return {"ok": False, "error": str(exc)[:160]}
+    return {"ok": True}
+
+
+@router.post("/jarvis/mobile_event")
+async def mobile_event(request: Request) -> dict[str, Any]:
+    body = await _json_body(request)
+    kind = str(body.get("kind") or "event").strip()[:80]
+    device_name = str(body.get("device_name") or "").strip()[:80]
+    payload = body.get("payload")
+    if not isinstance(payload, dict):
+        payload = {k: v for k, v in body.items() if k not in ("kind", "device_name", "ts")}
+    try:
+        from modules.max_autonomy import record_mobile_event
+        record_mobile_event(kind, payload, device_name=device_name)
+    except Exception as exc:
+        log.debug("mobile_event record failed: %s", exc)
+        return {"ok": False, "error": str(exc)[:160]}
+    return {"ok": True}
+
+
+@router.post("/max_autonomy/task")
+async def max_autonomy_task(request: Request) -> dict[str, Any]:
+    body = await _json_body(request)
+    task = str(body.get("task") or "").strip()
+    source = str(body.get("source") or "jarvis-native-android").strip()[:80]
+    device_name = str(body.get("device_name") or "").strip()[:80]
+    confirmed = bool(body.get("confirmed") or False)
+    context = body.get("context") if isinstance(body.get("context"), dict) else {}
+    try:
+        from modules.max_autonomy import execute_task
+        result = execute_task(
+            task,
+            source=source,
+            device_name=device_name,
+            context=context,
+            confirmed=confirmed,
+        )
+        return result.as_dict()
+    except Exception as exc:
+        log.warning("max_autonomy task failed: %s", exc)
+        return {
+            "ok": False,
+            "status": "error",
+            "task": task,
+            "action": "error",
+            "message": f"Autonomy task failed: {str(exc)[:160]}",
+            "requires_confirmation": False,
+            "blocked": False,
+            "risk": {},
+            "plan": [],
+            "response": [f"Autonomy task failed: {str(exc)[:160]}"],
+        }

phone/capabilities.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+"""
+phone/capabilities.py
+
+Single source of truth for what the phone client (APK) can drive easily.
+This stays free: it's just a JSON description of commands already implemented in core/commands.py.
+"""
+
+from typing import Any
+
+
+def capabilities_payload() -> dict[str, Any]:
+    # Keep this compact and practical. These are *commands*, not fake UI.
+    return {
+        "ok": True,
+        "version": 1,
+        "categories": [
+            {
+                "name": "Network",
+                "items": [
+                    {"label": "WiFi Toggle", "cmd": "wifi"},
+                    {"label": "Bluetooth Toggle", "cmd": "bluetooth"},
+                    {"label": "VPN Status", "cmd": "vpn status"},
+                    {"label": "Internet Check", "cmd": "internet check"},
+                    {"label": "Ping 1.1.1.1", "cmd": "ping 1.1.1.1"},
+                    {"label": "Speed Test", "cmd": "speed test"},
+                ],
+            },
+            {
+                "name": "Audio",
+                "items": [
+                    {"label": "Volume Up", "cmd": "volume up"},
+                    {"label": "Volume Down", "cmd": "volume down"},
+                    {"label": "Mute", "cmd": "mute"},
+                    {"label": "Audio Reset", "cmd": "audio reset"},
+                    {"label": "EQ Preset", "cmd": "eq preset"},
+                ],
+            },
+            {
+                "name": "Display",
+                "items": [
+                    {"label": "Brightness Cycle", "cmd": "cycle brightness"},
+                    {"label": "Night Light", "cmd": "night light"},
+                    {"label": "HDR Toggle", "cmd": "toggle hdr"},
+                    {"label": "Resolution/Hz Cycle", "cmd": "cycle resolution"},
+                    {"label": "Color Profile", "cmd": "cycle color profile"},
+                ],
+            },
+            {
+                "name": "System",
+                "items": [
+                    {"label": "System Report", "cmd": "system report"},
+                    {"label": "Lock PC", "cmd": "lock"},
+                    {"label": "Snapshot", "cmd": "snapshot"},
+                    {"label": "Steam Fix", "cmd": "steam fix"},
+                ],
+            },
+            {
+                "name": "Windows",
+                "items": [
+                    {"label": "Tile Windows", "cmd": "tile windows"},
+                    {"label": "Cascade Windows", "cmd": "cascade windows"},
+                    {"label": "Snap Left", "cmd": "snap left"},
+                    {"label": "Snap Right", "cmd": "snap right"},
+                    {"label": "Move To Next Monitor", "cmd": "move to next monitor"},
+                ],
+            },
+            {
+                "name": "Modes",
+                "items": [
+                    {"label": "Stark", "cmd": "stark mode"},
+                    {"label": "Tactical", "cmd": "tactical mode"},
+                    {"label": "Gaming", "cmd": "gaming mode"},
+                    {"label": "Chill", "cmd": "chill mode"},
+                    {"label": "Ghost", "cmd": "ghost mode"},
+                    {"label": "Overdrive", "cmd": "overdrive mode"},
+                ],
+            },
+        ],
+    }
+

phone/crypto.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import base64
+import json
+import os
+import hashlib
+from dataclasses import dataclass
+from pathlib import Path
+
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+
+
+ROOT = Path(__file__).resolve().parents[1]
+LINK_PATH = ROOT / "data" / "phone_link.json"
+
+
+@dataclass(frozen=True, slots=True)
+class LinkConfig:
+    # Either a raw key (legacy) or a human passphrase (preferred for phone pairing).
+    key_b64: str = ""
+    passphrase: str = ""
+    device_name: str = "phone"
+    # Optional: allowlist of Telegram user id(s) as strings.
+    telegram_allow: list[str] | None = None
+
+    def key_bytes(self) -> bytes:
+        if self.passphrase:
+            return hashlib.sha256(self.passphrase.encode("utf-8")).digest()
+        return base64.b64decode(self.key_b64.encode("utf-8"))
+
+
+def load_or_create_link() -> LinkConfig:
+    LINK_PATH.parent.mkdir(parents=True, exist_ok=True)
+    if not LINK_PATH.exists():
+        data = {}
+    else:
+        try:
+            data = json.loads(LINK_PATH.read_text(encoding="utf-8"))
+        except Exception:
+            data = {}
+
+    # Ensure passphrase exists (preferred pairing method). Migrate older installs.
+    if not str(data.get("passphrase", "")).strip():
+        data["passphrase"] = base64.b32encode(os.urandom(10)).decode("utf-8").rstrip("=").lower()
+    # Keep legacy key_b64 if present; otherwise empty.
+    data.setdefault("key_b64", "")
+    data.setdefault("device_name", "phone")
+    data.setdefault("telegram_allow", [])
+
+    try:
+        LINK_PATH.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    except Exception:
+        pass
+    return LinkConfig(
+        key_b64=str(data.get("key_b64", "")),
+        passphrase=str(data.get("passphrase", "")),
+        device_name=str(data.get("device_name", "phone")),
+        telegram_allow=list(data.get("telegram_allow", []) or []),
+    )
+
+
+def encrypt_json(obj: dict, key: bytes) -> dict:
+    aes = AESGCM(key)
+    nonce = os.urandom(12)
+    pt = json.dumps(obj, separators=(",", ":"), ensure_ascii=True).encode("utf-8")
+    ct = aes.encrypt(nonce, pt, None)
+    return {"nonce": base64.b64encode(nonce).decode("utf-8"), "ciphertext": base64.b64encode(ct).decode("utf-8")}
+
+
+def decrypt_json(payload: dict, key: bytes) -> dict:
+    aes = AESGCM(key)
+    nonce = base64.b64decode(str(payload.get("nonce", "")).encode("utf-8"))
+    ct = base64.b64decode(str(payload.get("ciphertext", "")).encode("utf-8"))
+    pt = aes.decrypt(nonce, ct, None)
+    return json.loads(pt.decode("utf-8"))

phone/pairing.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import json
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+PAIR_PATH = ROOT / "data" / "phone_pairing.json"
+
+
+@dataclass(frozen=True, slots=True)
+class PairStatus:
+    paired: bool
+    device_name: str
+    paired_at: float
+
+
+def mark_paired(device_name: str = "android") -> None:
+    PAIR_PATH.parent.mkdir(parents=True, exist_ok=True)
+    payload = {"paired": True, "device_name": str(device_name or "android"), "paired_at": float(time.time())}
+    try:
+        PAIR_PATH.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    except Exception:
+        pass
+
+
+def read_pair_status() -> PairStatus:
+    try:
+        if not PAIR_PATH.exists():
+            return PairStatus(False, "", 0.0)
+        data = json.loads(PAIR_PATH.read_text(encoding="utf-8"))
+        if not isinstance(data, dict):
+            return PairStatus(False, "", 0.0)
+        return PairStatus(bool(data.get("paired")), str(data.get("device_name") or ""), float(data.get("paired_at") or 0.0))
+    except Exception:
+        return PairStatus(False, "", 0.0)
+