Rename app.py to server.js

app.py

@@ -1,330 +0,0 @@
-import os
-import time
-import asyncio
-from typing import Optional, Tuple, Dict, Any, Union, List
-
-from fastapi import FastAPI, Response, Request, Header
-from fastapi.middleware.cors import CORSMiddleware
-from starlette.responses import StreamingResponse
-
-import httpx
-from playwright.async_api import async_playwright, TimeoutError as PTE, Page, Frame
-
-# =========================
-# Config (env-overridable)
-# =========================
-TARGET = os.getenv(
-    "CASTER_WIDGET_URL",
-    "https://widgets.cloud.caster.fm/player/?token=41a9830e-3fa4-4aef-a0cb-226600fb2946&frameId=2x5fz&theme=dark&color=6C2BDD",
-)
-MATCH_PREFIX = os.getenv(
-    "STREAM_MATCH_PREFIX",
-    "https://sapircast.caster.fm:10445/VCDm1?token=",
-)
-
-PRE_CLICK_WAIT_MS = int(os.getenv("PRE_CLICK_WAIT_MS", "2000"))
-MATCH_TIMEOUT_MS = int(os.getenv("MATCH_TIMEOUT_MS", "30000"))
-NAV_TIMEOUT_MS = int(os.getenv("NAV_TIMEOUT_MS", "30000"))
-CLICK_VISIBLE_TIMEOUT_MS = int(os.getenv("CLICK_VISIBLE_TIMEOUT_MS", "2000"))
-RETRIES = int(os.getenv("RETRIES", "5"))
-
-# caching / perf
-CACHE_TTL_SEC = int(os.getenv("CACHE_TTL_SEC", "90"))
-EXTRACTION_TIMEOUT_MS = int(os.getenv("EXTRACTION_TIMEOUT_MS", "18000"))
-
-# chromium flags (HF-friendly)
-CHROMIUM_ARGS = [
-    "--autoplay-policy=no-user-gesture-required",
-    "--no-sandbox",
-    "--disable-dev-shm-usage",
-]
-
-app = FastAPI(title="Caster Stream URL Extractor (cached)")
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"]
-)
-
-# =========================
-# Globals
-# =========================
-P = None               # playwright instance
-BROWSER = None         # chromium browser
-CONTEXT = None         # shared context
-
-CACHE: Dict[str, Any] = {"url": None, "ts": 0.0}
-CACHE_LOCK = asyncio.Lock()
-
-# =========================
-# Utils
-# =========================
-def _mk_trace() -> Dict[str, Any]:
-    return {"steps": [], "requests": [], "responses": [], "frames": [], "errors": []}
-
-async def _record_frames(page: Page, trace: Dict[str, Any]) -> None:
-    try:
-        trace["frames"] = [{"name": fr.name, "url": fr.url, "is_main": fr == page.main_frame} for fr in page.frames]
-    except Exception as e:
-        trace["errors"].append(f"frame-list-error: {e!r}")
-
-async def _click_selectors_in(page_or_frame: Union[Page, Frame], sels: List[str], trace: Dict[str, Any]) -> bool:
-    async def try_click(sel: str) -> bool:
-        try:
-            loc = page_or_frame.locator(sel).first
-            await loc.wait_for(state="visible", timeout=CLICK_VISIBLE_TIMEOUT_MS)
-            await loc.click(force=True)
-            trace["steps"].append(f"clicked: {sel}")
-            return True
-        except Exception as e:
-            trace["steps"].append(f"click-miss: {sel} ({e.__class__.__name__})")
-            return False
-    for s in sels:
-        if await try_click(s):
-            return True
-    return False
-
-async def _any_audio_playing(target: Union[Page, Frame]) -> bool:
-    try:
-        h = await target.wait_for_function(
-            """
-            () => {
-              const els = [document.getElementById('playerAudioElement'), ...document.querySelectorAll('audio')].filter(Boolean);
-              for (const a of els) { if (!a.paused && a.readyState >= 2) return true; }
-              return false;
-            }
-            """,
-            timeout=8000,
-        )
-        return bool(await h.json_value())
-    except Exception:
-        return False
-
-# =========================
-# Lifecycle
-# =========================
-@app.on_event("startup")
-async def _startup():
-    global P, BROWSER, CONTEXT
-    if P is None:
-        P = await async_playwright().start()
-    if BROWSER is None:
-        BROWSER = await P.chromium.launch(headless=True, args=CHROMIUM_ARGS)
-    if CONTEXT is None:
-        CONTEXT = await BROWSER.new_context()
-
-@app.on_event("shutdown")
-async def _shutdown():
-    global P, BROWSER, CONTEXT
-    try:
-        if CONTEXT:
-            await CONTEXT.close()
-        if BROWSER:
-            await BROWSER.close()
-    finally:
-        CONTEXT = None
-        BROWSER = None
-        if P:
-            await P.stop()
-
-# =========================
-# Core extraction (one run)
-# =========================
-async def _extract_once(strict_prefix: str, debug: bool = False) -> Tuple[Optional[str], Dict[str, Any]]:
-    trace: Dict[str, Any] = _mk_trace()
-    latest_by_req: Optional[str] = None
-    latest_by_resp: Optional[str] = None
-
-    def on_request(url: str):
-        nonlocal latest_by_req
-        trace["requests"].append(url)
-        if url.startswith(strict_prefix):
-            latest_by_req = url
-
-    async def on_response(r):
-        try:
-            url = r.url
-            status = r.status
-            ctype = (r.headers or {}).get("content-type")
-            trace["responses"].append({"url": url, "status": status, "content_type": ctype})
-            nonlocal latest_by_resp
-            if url.startswith(strict_prefix) and status < 400 and (ctype is None or ctype.lower().startswith("audio/")):
-                latest_by_resp = url
-        except Exception as e:
-            trace["errors"].append(f"resp-handler: {e!r}")
-
-    async def runner():
-        page = await CONTEXT.new_page()
-        CONTEXT.on("request", lambda r: on_request(r.url))
-        CONTEXT.on("response", lambda r: asyncio.create_task(on_response(r)))
-
-        # Navigate (resilient)
-        last_err = None
-        for i in range(RETRIES):
-            try:
-                await page.goto(TARGET, wait_until="domcontentloaded", timeout=NAV_TIMEOUT_MS)
-                trace["steps"].append("goto-domcontentloaded")
-                break
-            except Exception as e:
-                last_err = e
-                trace["steps"].append(f"goto-retry-{i+1}: {e.__class__.__name__}")
-                await asyncio.sleep(0.8 + i * 0.5)
-        else:
-            await page.close()
-            trace["errors"].append(f"goto-failed: {last_err!r}")
-            return None
-
-        await _record_frames(page, trace)
-
-        # Click play
-        await page.wait_for_timeout(PRE_CLICK_WAIT_MS)
-        selectors = [
-            ".play button.control-btn",
-            'button:has-text("PLAY")',
-            '[onclick*="playerAction"]',
-            'button[id*="play"]',
-        ]
-        clicked = await _click_selectors_in(page, selectors, trace)
-        if not clicked:
-            for fr in page.frames:
-                if await _click_selectors_in(fr, selectors, trace):
-                    clicked = True
-                    break
-
-        # Wait for some network settling
-        try:
-            await page.wait_for_load_state("networkidle", timeout=5000)
-            trace["steps"].append("after-click-networkidle")
-        except Exception:
-            trace["steps"].append("after-click-no-networkidle")
-
-        # Wait until audio is actually playing (main or frames)
-        playing = await _any_audio_playing(page)
-        if not playing:
-            for fr in page.frames:
-                if await _any_audio_playing(fr):
-                    playing = True
-                    break
-
-        # Debounce to capture the latest stream URL after play init
-        await page.wait_for_timeout(1000)
-
-        url = latest_by_resp or latest_by_req
-        await page.close()
-        return url
-
-    # Hard timeout guard
-    try:
-        url = await asyncio.wait_for(runner(), timeout=EXTRACTION_TIMEOUT_MS / 1000)
-    except asyncio.TimeoutError:
-        trace["errors"].append("extraction-timeout")
-        url = None
-
-    return url, trace
-
-# =========================
-# Cache helpers
-# =========================
-async def _get_cached_url(strict_prefix: str, force: bool = False) -> Optional[str]:
-    now = time.time()
-    if not force and CACHE["url"] and (now - CACHE["ts"] < CACHE_TTL_SEC):
-        return CACHE["url"]
-
-    async with CACHE_LOCK:
-        # Double-check after acquiring lock
-        now = time.time()
-        if not force and CACHE["url"] and (now - CACHE["ts"] < CACHE_TTL_SEC):
-            return CACHE["url"]
-
-        url, _ = await _extract_once(strict_prefix, debug=False)
-        if url:
-            CACHE["url"] = url
-            CACHE["ts"] = time.time()
-        return CACHE["url"]
-
-def _wants_true(req: Request, key: str) -> bool:
-    v = (req.query_params.get(key) or "").lower()
-    return v in ("1", "true", "yes")
-
-# =========================
-# Routes
-# =========================
-@app.get("/getplayerurl")
-async def get_player_url(request: Request) -> Response:
-    debug = _wants_true(request, "debug")
-    force = _wants_true(request, "force")
-    prefix = request.query_params.get("prefix") or MATCH_PREFIX
-
-    # 👇 Capture client headers
-    client_ua = request.headers.get("user-agent", "Mozilla/5.0")
-    client_ref = request.headers.get("referer", TARGET)
-    client_ip  = request.client.host
-
-    global CONTEXT
-    CONTEXT = await BROWSER.new_context(extra_http_headers={
-        "User-Agent": client_ua,
-        "X-Forwarded-For": client_ip,  # 👈 Some servers read this
-        "Referer": client_ref
-    })
-
-    if debug:
-        url, trace = await _extract_once(prefix, debug=True)
-        from json import dumps
-        return Response(
-            content=dumps({"ok": bool(url), "url": url, "match_prefix": prefix, **trace}, ensure_ascii=False, indent=2),
-            media_type="application/json"
-        )
-
-    url = await _get_cached_url(prefix, force=force)
-    if not url:
-        return Response(status_code=204)
-    return Response(content=url.strip() + "\n", media_type="text/plain")
-
-
-@app.get("/stream")
-async def stream(range: str | None = Header(default=None)) -> Response:
-    # Fast path: cached stream URL
-    url = await _get_cached_url(MATCH_PREFIX, force=False)
-    if not url:
-        # Warm cache if empty/stale
-        url = await _get_cached_url(MATCH_PREFIX, force=True)
-        if not url:
-            return Response(status_code=204)
-
-    headers = {
-        "Referer": TARGET,  # some hosts require referer/origin
-        "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
-                      "(KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36",
-        "Accept": "*/*",
-    }
-    if range:
-        headers["Range"] = range
-
-    async with httpx.AsyncClient(follow_redirects=True, timeout=None) as client:
-        r = await client.get(url, headers=headers)
-        # If token expired, refresh once & retry
-        if r.status_code >= 400:
-            url = await _get_cached_url(MATCH_PREFIX, force=True)
-            if not url:
-                return Response(status_code=502, content="upstream unavailable\n")
-            r = await client.get(url, headers=headers)
-
-        out_headers = {
-            "Content-Type": r.headers.get("content-type", "audio/mpeg"),
-            "Accept-Ranges": r.headers.get("accept-ranges", "bytes"),
-        }
-        if "content-length" in r.headers:
-            out_headers["Content-Length"] = r.headers["content-length"]
-
-        return StreamingResponse(r.aiter_raw(), status_code=r.status_code, headers=out_headers)
-
-@app.get("/")
-async def root() -> dict:
-    return {
-        "ok": True,
-        "endpoint": "/getplayerurl",
-        "proxy": "/stream",
-        "target": TARGET,
-        "match_prefix": MATCH_PREFIX,
-        "cache_ttl_sec": CACHE_TTL_SEC,
-    }

server.js

@@ -0,0 +1,73 @@
+// ICY→HTTP shim for browsers (works on HF Spaces)
+// Listens on process.env.PORT and 0.0.0.0 (required by HF)
+const http = require("http");
+const net  = require("net");
+
+const PORT = process.env.PORT || 7860;
+const HOST = "0.0.0.0";
+
+// Configure upstream via env (can set in HF Space Settings → Variables)
+const UPSTREAM_HOST = process.env.STREAM_HOST || "37.59.40.90";
+const UPSTREAM_PORT = Number(process.env.STREAM_PORT || 18624);
+const UPSTREAM_PATH = process.env.STREAM_PATH || "/"; // try "/;" if needed
+
+const server = http.createServer((req, res) => {
+  if (req.url !== "/stream") {
+    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+    return res.end(`<h3>OK</h3><p>Use <code>/stream</code> for audio.</p>`);
+  }
+
+  const sock = net.createConnection(UPSTREAM_PORT, UPSTREAM_HOST, () => {
+    const reqLines = [
+      `GET ${UPSTREAM_PATH} HTTP/1.0`,
+      `Host: ${UPSTREAM_HOST}:${UPSTREAM_PORT}`,
+      `Icy-MetaData: 0`,
+      `User-Agent: Browser-Audio-Proxy`,
+      `Accept: */*`,
+      ``,
+      ``,
+    ];
+    sock.write(reqLines.join("\r\n"));
+  });
+
+  let headerBuf = Buffer.alloc(0);
+  let sentHeaders = false;
+
+  sock.on("data", chunk => {
+    if (!sentHeaders) {
+      headerBuf = Buffer.concat([headerBuf, chunk]);
+      const i = headerBuf.indexOf("\r\n\r\n");
+      if (i === -1) return;
+
+      const head = headerBuf.slice(0, i).toString("utf8");
+      const body = headerBuf.slice(i + 4);
+
+      const ctMatch = head.match(/content-type\s*:\s*([^\r\n]+)/i);
+      const contentType = (ctMatch && ctMatch[1].trim()) || "audio/mpeg";
+
+      res.writeHead(200, {
+        "Content-Type": contentType,
+        "Cache-Control": "no-store",
+        "X-Content-Type-Options": "nosniff",
+        "Accept-Ranges": "none",
+        "Connection": "close",
+        "Access-Control-Allow-Origin": "*",  // helpful if you embed elsewhere
+      });
+
+      if (body.length) res.write(body);
+      sentHeaders = true;
+      return;
+    }
+    res.write(chunk);
+  });
+
+  sock.on("end", () => res.end());
+  sock.on("error", () => {
+    if (!res.headersSent) res.writeHead(502, { "Content-Type": "text/plain" });
+    res.end("Upstream error");
+  });
+});
+
+server.listen(PORT, HOST, () =>
+  console.log(`Proxy listening on http://${HOST}:${PORT}/stream`)
+);