Update loader.py

loader.py

@@ -1,7 +1,8 @@
-# loader.py — Public proxy to a PRIVATE Static Space (auth via resolve/raw endpoints)
+# loader.py — Public proxy to a PRIVATE Static Space (auth via resolve/raw) + preflight checks
 import os
 import mimetypes
 from urllib.parse import urljoin
+
 from fastapi import FastAPI, Request
 from fastapi.responses import Response, HTMLResponse, PlainTextResponse, JSONResponse
 import httpx
@@ -10,8 +11,8 @@ app = FastAPI()
 
 # ===== Config (from Space Secrets) =====
 SPACE_ID = os.getenv("PRIVATE_SPACE_ID")          # e.g., "cheekeong2025/IIP_Grading"
-HF_TOKEN = os.getenv("HF_TOKEN")                  # token with READ access to that private Space
-REVISION = os.getenv("REVISION", "main")          # branch/tag/commit; default "main"
+HF_TOKEN = os.getenv("HF_TOKEN")                  # token with READ access
+REVISION = os.getenv("REVISION", "main")          # branch/tag/commit
 # ======================================
 
 if not SPACE_ID:
@@ -23,6 +24,45 @@ HEADERS = {"Authorization": f"Bearer {HF_TOKEN}"}
 BASE_RESOLVE = f"https://huggingface.co/spaces/{SPACE_ID}/resolve/{REVISION}/"
 BASE_RAW     = f"https://huggingface.co/spaces/{SPACE_ID}/raw/{REVISION}/"
 
+# ---------- Preflight: validate token and repo access ----------
+async def _preflight():
+    async with httpx.AsyncClient(timeout=20) as client:
+        # 1) whoami (confirms token is valid)
+        w = await client.get("https://huggingface.co/api/whoami-v2", headers=HEADERS)
+        if w.status_code != 200:
+            raise RuntimeError(f"Token invalid: whoami {w.status_code} {w.text}")
+
+        ident = w.json().get("name") or w.json()
+        print(f"[preflight] whoami = {ident}")
+
+        # 2) repo info (confirms you can read the private Space)
+        ri = await client.get(f"https://huggingface.co/api/spaces/{SPACE_ID}", headers=HEADERS)
+        if ri.status_code != 200:
+            raise RuntimeError(
+                f"Cannot access space '{SPACE_ID}': {ri.status_code} {ri.text}. "
+                "Check PRIVATE_SPACE_ID spelling/case and that this token has access."
+            )
+
+        info = ri.json()
+        print(f"[preflight] space='{SPACE_ID}' private={info.get('private')} repo_owner={info.get('author')}")
+        # Optional: verify the revision exists by probing index.html under resolve
+        test_url = f"{BASE_RESOLVE}index.html"
+        tr = await client.get(test_url, headers=HEADERS)
+        print(f"[preflight] probe {test_url} -> {tr.status_code}")
+
+# Run preflight once on startup
+@app.on_event("startup")
+async def _startup():
+    try:
+        await _preflight()
+    except Exception as e:
+        # Don't crash the server; surface the error in /health
+        global _preflight_error
+        _preflight_error = str(e)
+        print(f"[preflight] ERROR: {_preflight_error}")
+    else:
+        _preflight_error = None
+
 def _join(base: str, path: str) -> str:
     return urljoin(base, path.lstrip("/"))
 
@@ -34,7 +74,6 @@ def _looks_file(path: str) -> bool:
     return "." in path.split("/")[-1]
 
 def _is_html_path(path: str) -> bool:
-    # treat root/dirs and *.html as HTML routes
     return (not _looks_file(path)) or path.lower().endswith(".html") or path == ""
 
 def _mime(path: str, default="application/octet-stream") -> str:
@@ -50,7 +89,7 @@ async def _get(client: httpx.AsyncClient, url: str) -> httpx.Response:
 
 async def _fetch(client: httpx.AsyncClient, path: str, req: Request):
     """
-    Robust lookup order (first 200 wins):
+    Order (first 200 wins):
       resolve:path
       resolve:static/path
       (dir) resolve:path/index.html
@@ -93,7 +132,12 @@ async def _fetch(client: httpx.AsyncClient, path: str, req: Request):
 
 @app.get("/health")
 async def health():
-    return {"status": "ok", "space": SPACE_ID, "revision": REVISION}
+    return {
+        "status": "ok" if _preflight_error is None else "error",
+        "space": SPACE_ID,
+        "revision": REVISION,
+        "preflight_error": _preflight_error,
+    }
 
 @app.get("/_debug/fetch/{path:path}")
 async def debug_fetch(path: str, request: Request):
@@ -117,7 +161,7 @@ async def root(request: Request):
     except Exception as e:
         return PlainTextResponse(f"Error fetching root: {e}", status_code=500)
 
-    # Force HTML for the root page (even if upstream says text/plain)
+    # Always render root as HTML
     return HTMLResponse(r.text, status_code=r.status_code, media_type="text/html; charset=utf-8")
 
 @app.get("/{path:path}")
@@ -130,9 +174,7 @@ async def proxy(path: str, request: Request):
         return PlainTextResponse(f"Error fetching {path}: {e}", status_code=500)
 
     if _is_html_path(path):
-        # Ensure HTML renders even if upstream mislabels as text/plain
         return HTMLResponse(r.text, status_code=r.status_code, media_type="text/html; charset=utf-8")
 
-    # Non-HTML: keep upstream/guessed MIME and bytes
     ctype = r.headers.get("content-type") or _mime(path)
     return Response(content=r.content, media_type=ctype, status_code=r.status_code)