Update app.py

app.py

@@ -3,7 +3,7 @@ from datetime import datetime, timedelta, timezone
 from threading import Lock
 
 import httpx
-from fastapi import FastAPI, HTTPException, Request
+from fastapi import FastAPI, HTTPException
 from fastapi.responses import FileResponse, JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 from starlette.staticfiles import StaticFiles
@@ -32,6 +32,10 @@ conn = sqlite3.connect(DB_PATH, check_same_thread=False)
 conn.row_factory = sqlite3.Row
 db_lock = Lock()
 
+def column_exists(table: str, col: str) -> bool:
+    rows = conn.execute(f"PRAGMA table_info({table})").fetchall()
+    return any(r["name"] == col for r in rows)
+
 def init_db():
     with db_lock:
         c = conn.cursor()
@@ -41,8 +45,7 @@ def init_db():
               name TEXT NOT NULL,
               method TEXT DEFAULT 'GET',
               expected_min INT DEFAULT 200,
-              expected_max INT DEFAULT 399,
-              created_at TEXT DEFAULT (datetime('now'))
+              expected_max INT DEFAULT 399
             );
         """)
         c.execute("""
@@ -65,6 +68,9 @@ def init_db():
               FOREIGN KEY (url) REFERENCES sites(url)
             );
         """)
+        # --- schema migration: add hf_token if missing ---
+        if not column_exists("sites", "hf_token"):
+            c.execute("ALTER TABLE sites ADD COLUMN hf_token TEXT")
         conn.commit()
 
         # Seed a few demo sites if empty
@@ -77,9 +83,12 @@ def init_db():
                     pass
             conn.commit()
 
-def list_sites():
+def list_sites(include_secret: bool = False):
+    cols = "url, name, method, expected_min, expected_max"
+    if include_secret:
+        cols += ", hf_token"
     with db_lock:
-        rows = conn.execute("SELECT url, name, method, expected_min, expected_max FROM sites ORDER BY url").fetchall()
+        rows = conn.execute(f"SELECT {cols} FROM sites ORDER BY url").fetchall()
     return [dict(r) for r in rows]
 
 def get_last_check(url: str):
@@ -104,11 +113,9 @@ def record_check(url: str, ok: int, status_code: int | None, ms: float | None, t
 
 def open_incident_if_needed(url: str, now_iso: str, prev_ok: int | None, current_ok: int):
     with db_lock:
-        # If transitioning from UP->DOWN, open a new incident
         if (prev_ok == 1 or prev_ok is None) and current_ok == 0:
             conn.execute("INSERT INTO incidents(url, start_ts) VALUES (?,?)", (url, now_iso))
             conn.commit()
-        # If transitioning from DOWN->UP, close the latest open incident
         elif prev_ok == 0 and current_ok == 1:
             conn.execute(
                 "UPDATE incidents SET end_ts=? WHERE url=? AND end_ts IS NULL",
@@ -144,12 +151,19 @@ async def check_one(client: httpx.AsyncClient, site: dict):
     expected_min = int(site.get("expected_min", 200))
     expected_max = int(site.get("expected_max", 399))
 
+    # Build per-site headers (HF Org Spaces need Authorization)
+    headers = {}
+    token = (site.get("hf_token") or "").strip()
+    if token:
+        if token.lower().startswith("bearer "):
+            token = token[7:].strip()
+        headers["Authorization"] = f"Bearer {token}"
+
     t0 = time.perf_counter()
     code = None
     ok = 0
     try:
-        # Use GET with follow_redirects to treat 3xx as success if within range
-        resp = await client.get(url, follow_redirects=True, timeout=HTTP_TIMEOUT_SECONDS)
+        resp = await client.get(url, headers=headers, follow_redirects=True, timeout=HTTP_TIMEOUT_SECONDS)
         code = resp.status_code
         ok = 1 if (expected_min <= code <= expected_max) else 0
     except Exception:
@@ -163,16 +177,10 @@ async def check_one(client: httpx.AsyncClient, site: dict):
     record_check(url, ok, code, ms, now_iso)
     open_incident_if_needed(url, now_iso, prev_ok, ok)
 
-    return {
-        "url": url,
-        "ok": ok,
-        "status_code": code,
-        "ms": ms,
-        "ts": now_iso
-    }
+    return {"url": url, "ok": ok, "status_code": code, "ms": ms, "ts": now_iso}
 
 async def run_checks():
-    sites = list_sites()
+    sites = list_sites(include_secret=True)
     if not sites:
         return []
     limits = httpx.Limits(max_connections=20, max_keepalive_connections=10)
@@ -183,9 +191,8 @@ async def run_checks():
 # --------------------------
 # API & Scheduler
 # --------------------------
-app = FastAPI(title="HF Uptime Monitor", version="1.0.0")
+app = FastAPI(title="HF Uptime Monitor", version="1.1.0")  # bumped
 
-# Simple CORS for same-origin front-end
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"], allow_methods=["*"], allow_headers=["*"]
@@ -194,14 +201,12 @@ app.add_middleware(
 class SiteIn(BaseModel):
     url: HttpUrl
     name: str
+    hf_token: str | None = None  # optional Bearer token without prefix
 
 @app.on_event("startup")
 async def on_startup():
     init_db()
-    # Kick an immediate check on boot (don't await, run in background)
     asyncio.create_task(run_checks())
-
-    # Start APScheduler
     scheduler = AsyncIOScheduler()
     scheduler.add_job(run_checks, "interval", seconds=CHECK_INTERVAL_SECONDS, next_run_time=datetime.now(timezone.utc))
     scheduler.start()
@@ -213,7 +218,8 @@ async def on_shutdown():
     if sched:
         sched.shutdown(wait=False)
 
-# Static files
+# Static files (if you keep external files). If using the inline HTML above,
+# just place it at ./static/index.html and keep this as-is.
 app.mount("/static", StaticFiles(directory="static"), name="static")
 
 @app.get("/")
@@ -222,25 +228,33 @@ def root():
 
 @app.get("/api/sites")
 def api_sites():
-    return JSONResponse(list_sites())
+    # Public listing (no secrets)
+    public = list_sites(include_secret=False)
+    return JSONResponse(public)
 
 @app.post("/api/sites")
 def api_add_site(site: SiteIn):
-    url_s = str(site.url)              # <- cast from HttpUrl to str
+    url_s = str(site.url)
     name_s = (site.name or "").strip() or url_s
+    tok = (site.hf_token or "").strip()
+    if tok.lower().startswith("bearer "):
+        tok = tok[7:].strip()
     with db_lock:
         try:
+            # upsert-ish: try insert; if exists, update token/name
             conn.execute(
-                "INSERT OR IGNORE INTO sites(url, name) VALUES (?, ?)",
-                (url_s, name_s)
+                "INSERT OR IGNORE INTO sites(url, name, hf_token) VALUES (?, ?, ?)",
+                (url_s, name_s, tok or None)
+            )
+            conn.execute(
+                "UPDATE sites SET name=?, hf_token=? WHERE url=?",
+                (name_s, tok or None, url_s)
             )
             conn.commit()
         except sqlite3.Error as e:
-            # bubble up the real DB message so the UI can show it
             raise HTTPException(400, f"DB error: {e}")
     return {"ok": True}
 
-
 @app.delete("/api/sites")
 def api_delete_site(url: str):
     with db_lock:
@@ -257,7 +271,7 @@ async def api_check_now():
 
 @app.get("/api/status")
 def api_status():
-    sites = list_sites()
+    sites = list_sites(include_secret=False)  # do NOT leak tokens
     now = datetime.now(timezone.utc)
     since_24h = now - timedelta(hours=24)
     since_7d = now - timedelta(days=7)
@@ -267,20 +281,18 @@ def api_status():
         last = get_last_check(s["url"])
         u24 = uptime_ratio(s["url"], since_24h)
         u7 = uptime_ratio(s["url"], since_7d)
-        open_incident = False
         with db_lock:
             open_inc = conn.execute(
                 "SELECT 1 FROM incidents WHERE url=? AND end_ts IS NULL LIMIT 1",
                 (s["url"],)
             ).fetchone()
             open_incident = bool(open_inc)
-
         out.append({
             "url": s["url"],
             "name": s["name"],
-            "last": last,            # {ts, ok, status_code, ms} or None
-            "uptime24h": u24,        # float or None
-            "uptime7d": u7,          # float or None
+            "last": last,
+            "uptime24h": u24,
+            "uptime7d": u7,
             "open_incident": open_incident
         })
     return out
@@ -295,4 +307,4 @@ def api_ping():
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=PORT)