cloud_entrypoint.py

"""Standalone Docker Space entrypoint for the fenced cloud-core supervisor."""
from __future__ import annotations

import hashlib
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import importlib.util
import json
import os
from pathlib import Path
import socket
import sys
import threading
import time
import urllib.request


VRM_URL = (
    "https://huggingface.co/datasets/CREATORJD/alpecca-runtime-assets/resolve/"
    "main/runtime-assets/assets/vrm/alpecca-v4-live.vrm"
)
VRM_SHA256 = "0b6385de90be7c2401f94f8f2450c6a0e1198942ba11083e68a6c3233fde27d3"
MAX_VRM_BYTES = 32 * 1024 * 1024
REQUIRED_SECRETS = (
    "HF_TOKEN",
    "ALPECCA_CONTINUITY_LEASE_TOKEN",
    "ALPECCA_MINDSCAPE_VAULT_TOKEN",
    "ALPECCA_MINDSCAPE_VAULT_KEY",
    "ALPECCA_AUTH_SECRET",
    "ALPECCA_CREATOR_PASSWORD",
)
REQUIRED_URLS = (
    "ALPECCA_CONTINUITY_LEASE_URL",
    "ALPECCA_MINDSCAPE_VAULT_URL",
)
_TRUE_VALUES = {"1", "true", "yes", "on"}
STANDBY_SERVICE = "alpecca-continuity-standby"
STANDBY_POLL_SECONDS = 10.0


def _load_supervisor_module():
    path = Path(__file__).with_name("app.py")
    spec = importlib.util.spec_from_file_location("alpecca_hf_cloud_supervisor", path)
    if spec is None or spec.loader is None:
        raise RuntimeError("cloud supervisor module is unavailable")
    module = importlib.util.module_from_spec(spec)
    sys.modules[spec.name] = module
    spec.loader.exec_module(module)
    return module


supervisor = _load_supervisor_module()


def configure_environment(environ: dict[str, str]) -> None:
    port = environ.get("PORT", "7860")
    public_url = environ.get("ALPECCA_PUBLIC_URL", "").strip().rstrip("/")
    if public_url:
        environ["ALPECCA_PUBLIC_ENDPOINT"] = public_url
    elif environ.get("SPACE_HOST", "").strip():
        environ["ALPECCA_PUBLIC_ENDPOINT"] = (
            "https://" + environ["SPACE_HOST"].strip()
        )
    forced = {
        "ALPECCA_SERVER_HOST": "0.0.0.0",
        "ALPECCA_SERVER_PORT": port,
        "ALPECCA_REMOTE": "1",
        "ALPECCA_PUBLIC_URL": public_url,
        "ALPECCA_LLM_BACKEND": "hf",
        "ALPECCA_HF_MODEL": "Qwen/Qwen3.5-9B",
        "ALPECCA_HF_PROVIDER": "auto",
        "ALPECCA_MODEL": "qwen3.5:9b",
        "ALPECCA_FAST_MODEL": "qwen3.5:9b",
        "ALPECCA_REFLECT_MODEL": "",
        "ALPECCA_REFLECT_THINK": "0",
        "ALPECCA_CHAT_CLOUD_MODEL": "",
        "ALPECCA_CHAT_ZEROGPU": "0",
        "ALPECCA_DEEP_BACKEND": "",
        "ALPECCA_STREAM_CHAT": "0",
        "ALPECCA_F5_WORKER": "0",
        "ALPECCA_DISCORD": "0",
        "ALPECCA_DISCORD_MEDIA": "0",
        "ALPECCA_DISCORD_VOICE": "0",
        "ALPECCA_COMPUTER_USE": "0",
        "ALPECCA_SIGHT": "0",
        "ALPECCA_FACE": "0",
        "ALPECCA_VOICE": "0",
        "ALPECCA_APPS": "",
        "ALPECCA_MINDSCAPE": "0",
        "ALPECCA_MINDSCAPE_VAULT": "0",
        "ALPECCA_CONTINUITY_ROLE": "cloud-standby",
    }
    environ.update(forced)
    environ.setdefault(
        "ALPECCA_CONTINUITY_NODE_ID",
        f"cloud-standby:{socket.gethostname()}"[:96],
    )


def validate_configuration(environ: dict[str, str]) -> list[str]:
    missing = [name for name in (*REQUIRED_SECRETS, *REQUIRED_URLS) if not environ.get(name, "").strip()]
    for name in REQUIRED_URLS:
        value = environ.get(name, "").strip()
        if value and not value.startswith("https://"):
            missing.append(f"{name}:https-required")
    return missing


def cloud_core_enabled(environ: dict[str, str]) -> bool:
    """Require an explicit deployment switch before any restore or lease work."""
    return str(environ.get("ALPECCA_CLOUD_CORE_ENABLED") or "").strip().lower() in _TRUE_VALUES


def promotion_eligible(status: object) -> bool:
    """Require positive authority evidence that no local or cloud owner exists."""
    if not isinstance(status, dict) or status.get("ok") is not True:
        return False
    if status.get("activeLeaseCount") != 0 or status.get("activeLease") is not None:
        return False
    return status.get("localPrimaryPreferred") is False


class _StandbyHandler(BaseHTTPRequestHandler):
    def do_GET(self) -> None:  # noqa: N802 - stdlib callback name
        route = self.path.split("?", 1)[0]
        if route not in {"/", "/healthz"}:
            self.send_error(404)
            return
        body = json.dumps(
            {
                "service": STANDBY_SERVICE,
                "version": 1,
                "state": "waiting-for-singleton-lease",
                "coreMind": False,
            },
            separators=(",", ":"),
        ).encode("utf-8")
        self.send_response(200)
        self.send_header("Content-Type", "application/json; charset=utf-8")
        self.send_header("Cache-Control", "no-store")
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)

    def log_message(self, _format: str, *_args: object) -> None:
        return


class _StandbyHttpServer(ThreadingHTTPServer):
    allow_reuse_address = True
    daemon_threads = True


class StandbyServer:
    """A health-only listener; it never imports or constructs CoreMind."""

    def __init__(self, port: int) -> None:
        self._server = _StandbyHttpServer(("0.0.0.0", port), _StandbyHandler)
        self._thread = threading.Thread(
            target=self._server.serve_forever,
            name="AlpeccaCloudStandby",
            daemon=True,
        )

    def start(self) -> None:
        self._thread.start()

    @property
    def port(self) -> int:
        return int(self._server.server_address[1])

    def stop(self) -> None:
        self._server.shutdown()
        self._server.server_close()
        self._thread.join(timeout=3.0)


def wait_until_promotion_eligible(client, *, sleep=time.sleep) -> None:
    """Poll authenticated status without restoring memory or starting a model."""
    while True:
        try:
            if promotion_eligible(client.status()):
                return
        except Exception:
            pass
        sleep(STANDBY_POLL_SECONDS)


def install_vrm(home: Path, opener=urllib.request.urlopen) -> Path:
    target = home / "avatar" / "vrm" / "alpecca.vrm"
    if target.is_file() and hashlib.sha256(target.read_bytes()).hexdigest() == VRM_SHA256:
        return target
    target.parent.mkdir(parents=True, exist_ok=True)
    request = urllib.request.Request(VRM_URL, headers={"User-Agent": "Alpecca-Continuity-Core/1"})
    with opener(request, timeout=90) as response:
        data = response.read(MAX_VRM_BYTES + 1)
    if len(data) > MAX_VRM_BYTES or hashlib.sha256(data).hexdigest() != VRM_SHA256:
        raise RuntimeError("V.4 VRM integrity check failed")
    staging = target.with_suffix(".vrm.tmp")
    staging.write_bytes(data)
    os.replace(staging, target)
    return target


def main() -> int:
    if not cloud_core_enabled(os.environ):
        print(
            "Cloud continuity core is installed but disabled; no restore, lease, "
            "model, or CoreMind was started.",
            flush=True,
        )
        return 0
    configure_environment(os.environ)
    missing = validate_configuration(os.environ)
    if missing:
        print("Cloud continuity configuration is incomplete: " + ", ".join(missing), flush=True)
        return 2
    from alpecca.continuity_lease import client_from_env

    status_client = client_from_env(role="cloud-standby")
    if status_client is None:
        print("Cloud continuity lease client is unavailable.", flush=True)
        return 2

    port = int(os.environ.get("PORT", "7860"))
    while True:
        standby = StandbyServer(port)
        standby.start()
        print(
            "Cloud continuity standby is healthy; no CoreMind or model is active.",
            flush=True,
        )
        try:
            wait_until_promotion_eligible(status_client)
        finally:
            standby.stop()

        result, shutdown_requested = supervisor.run_supervisor_once(
            vrm_installer=install_vrm,
        )
        if shutdown_requested:
            return result
        print(
            f"Cloud promotion ended with code {result}; returning to fenced standby.",
            flush=True,
        )
        time.sleep(2.0)


if __name__ == "__main__":
    raise SystemExit(main())