feat: complete rebuild of proxy gateway with lifespan pool, streaming SSE/video support, and resilient retry logic

proxy.py

@@ -1,139 +1,217 @@
 """
-OpenCode Space — FastAPI Reverse-Proxy Gateway
-================================================
-Architecture (all on 127.0.0.1 inside the container):
-  Port 4096  — this FastAPI app  (HF-Space external port)
-  Port 4097  — opencode serve
-  Port 8096  — Jellyfin
-  Port 8098  — Open WebUI
-  Port 20128 — OmniRoute
-  Port 8080  — TG-Drive Streamer
-
-Public URL prefix mapping:
-  /          → landing hub (index.html)
-  /server/   → opencode (4097)
-  /openwebui/→ Open WebUI (8098)  — STRIP prefix before upstream
-  /omniroute/→ OmniRoute  (20128) — STRIP prefix before upstream
-  /jellyfin/ → Jellyfin   (8096)
-  /tg-stream/→ TG Streamer(8080)
+OpenCode Space — Production ASGI Gateway & Reverse Proxy
+=========================================================
+Technology Stack & Design:
+  - Framework: FastAPI 0.115+ / Starlette ASGI Engine
+  - Async I/O: Python 3.11+ / 3.12+ Async Context Lifespan & httpx.AsyncClient
+  - Protocol Support: Full HTTP/1.1, Server-Sent Events (SSE) Streaming, & Full-Duplex WebSockets
+  - Resilience: Automatic connection pool management (1000 max, 200 keep-alive), exponential retries on transient errors, header sanitization, & zero-port-leakage URL rewriting.
+
+Port Architecture (All listening on 127.0.0.1 internally):
+  Port 4096  — Main FastAPI Gateway (External HF Space Port)
+  Port 4097  — OpenCode Server Engine
+  Port 8098  — Open WebUI Platform
+  Port 20128 — OmniRoute Multi-LLM Gateway
+  Port 8096  — Jellyfin Media Server
+  Port 8080  — TG-Drive Direct 5G Streaming Server
+
+Public URL Routing Matrix:
+  /           → Landing Hub (index.html)
+  /server/    → OpenCode Server (4097)
+  /openwebui/ → Open WebUI (8098)  [Path Stripped & Re-anchored]
+  /omniroute/ → OmniRoute (20128)  [Path Stripped & Re-anchored]
+  /jellyfin/  → Jellyfin Media (8096)
+  /tg-stream/ → TG Streaming Engine (8080)
+  /health     → Service Health & Diagnostic API
 """
 
 import os
 import re
 import asyncio
-from typing import Callable, Optional
-from fastapi import FastAPI, Request, Response, WebSocket
-from fastapi.responses import HTMLResponse, FileResponse, StreamingResponse
+import logging
+from contextlib import asynccontextmanager
+from typing import Callable, Optional, Dict, Any
+
 import httpx
 import aiohttp
+from fastapi import FastAPI, Request, Response, WebSocket
+from fastapi.responses import HTMLResponse, FileResponse, StreamingResponse
 
-app = FastAPI(title="OpenCode Space Gateway", docs_url=None, redoc_url=None)
+# Setup logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(name)s: %(message)s")
+logger = logging.getLogger("GatewayProxy")
 
-# ── Port constants ──────────────────────────────────────────────────────────
-WEBUI_PORT     = 8098
-OMNIROUTE_PORT = 20128
-OPENCODE_PORT  = 4097
-JELLYFIN_PORT  = 8096
-TG_PORT        = 8080
+# Port Definitions
+WEBUI_PORT     = int(os.environ.get("WEBUI_PORT", 8098))
+OMNIROUTE_PORT = int(os.environ.get("OMNIROUTE_PORT", 20128))
+OPENCODE_PORT  = int(os.environ.get("OPENCODE_PORT", 4097))
+JELLYFIN_PORT  = int(os.environ.get("JELLYFIN_PORT", 8096))
+TG_PORT        = int(os.environ.get("TG_PORT", 8080))
+GATEWAY_PORT   = int(os.environ.get("PORT", 4096))
 
-PUBLIC_HOST   = "jishnupg-opencode-cli.hf.space"
+PUBLIC_HOST   = os.environ.get("PUBLIC_HOST", "jishnupg-opencode-cli.hf.space")
 PUBLIC_ORIGIN = f"https://{PUBLIC_HOST}"
 
-# ── Internal-port stripper (for Location headers only) ─────────────────────
-_INTERNAL_PORTS = {4096, 20128, 8098, 4097, 8096, 8080}
-_PORT_STRIP_RE  = re.compile(
-    r"(https?://[^/:]+):(" + "|".join(str(p) for p in _INTERNAL_PORTS) + r")"
-)
-_PORT_PREFIX = {
-    4096:  "",
-    20128: "/omniroute",
-    8098:  "/openwebui",
-    4097:  "/server",
-    8096:  "/jellyfin",
-    8080:  "/tg-stream",
+# Internal Port Leakage Protection
+_INTERNAL_PORTS = {GATEWAY_PORT, WEBUI_PORT, OMNIROUTE_PORT, OPENCODE_PORT, JELLYFIN_PORT, TG_PORT}
+_PORT_STRIP_RE  = re.compile(r"(https?://[^/:]+):(" + "|".join(str(p) for p in _INTERNAL_PORTS) + r")")
+
+_PORT_PREFIX_MAP = {
+    GATEWAY_PORT:   "",
+    OMNIROUTE_PORT: "/omniroute",
+    WEBUI_PORT:     "/openwebui",
+    OPENCODE_PORT:  "/server",
+    JELLYFIN_PORT:  "/jellyfin",
+    TG_PORT:        "/tg-stream",
 }
 
-def _fix_location(location: str) -> str:
-    """Rewrite a Location header so no internal port leaks out."""
-    def _sub(m: "re.Match[str]") -> str:
-        port = int(m.group(2))
-        prefix = _PORT_PREFIX.get(port, "")
+def _fix_location_header(location: str) -> str:
+    """Strip internal ports from HTTP Location headers and re-anchor to public paths."""
+    if not location:
+        return location
+
+    def _replace_port(match: re.Match[str]) -> str:
+        port = int(match.group(2))
+        prefix = _PORT_PREFIX_MAP.get(port, "")
         return f"{PUBLIC_ORIGIN}{prefix}"
-    return _PORT_STRIP_RE.sub(_sub, location)
-
-# ── Shared async HTTP client ────────────────────────────────────────────────
-client = httpx.AsyncClient(
-    timeout=httpx.Timeout(120.0),
-    follow_redirects=False,
-    limits=httpx.Limits(max_connections=200, max_keepalive_connections=50),
-)
-
-# ── Header helpers ──────────────────────────────────────────────────────────
-_HOP_BY_HOP = {"connection", "keep-alive", "proxy-authenticate", "proxy-authorization",
-                "te", "trailers", "transfer-encoding", "upgrade",
-                "content-length", "content-encoding"}
-
-def _request_headers(request: Request, extra: dict | None = None) -> dict:
-    h = {k: v for k, v in request.headers.items()
-         if k.lower() not in {"host", "content-length"}}
-    h["X-Forwarded-Host"]   = PUBLIC_HOST
-    h["X-Forwarded-Proto"]  = "https"
-    h["X-Forwarded-Port"]   = "443"
-    h["X-Real-IP"]          = request.client.host if request.client else "127.0.0.1"
-    if extra:
-        h.update(extra)
-    return h
-
-def _response_headers(resp: httpx.Response, location_override: str | None = None) -> dict:
-    out = {}
-    for k, v in resp.headers.items():
-        lk = k.lower()
-        if lk in _HOP_BY_HOP:
+
+    return _PORT_STRIP_RE.sub(_replace_port, location)
+
+
+# ── Global Async HTTP Client with Lifespan Manager ─────────────────────────
+http_client: Optional[httpx.AsyncClient] = None
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    global http_client
+    logger.info("Initializing Gateway Connection Pool...")
+    http_client = httpx.AsyncClient(
+        timeout=httpx.Timeout(120.0, connect=10.0),
+        follow_redirects=False,
+        limits=httpx.Limits(max_connections=1000, max_keepalive_connections=200, keepalive_expiry=30.0),
+    )
+    yield
+    logger.info("Closing Gateway Connection Pool...")
+    if http_client:
+        await http_client.aclose()
+
+
+app = FastAPI(title="OpenCode Space ASGI Gateway", lifespan=lifespan, docs_url=None, redoc_url=None)
+
+
+# ── Header Sanitization Helpers ─────────────────────────────────────────────
+_HOP_BY_HOP_HEADERS = {
+    "connection", "keep-alive", "proxy-authenticate", "proxy-authorization",
+    "te", "trailers", "transfer-encoding", "upgrade",
+    "content-length", "content-encoding"
+}
+
+def _build_upstream_headers(request: Request, extra_headers: Optional[Dict[str, str]] = None) -> Dict[str, str]:
+    headers = {k: v for k, v in request.headers.items() if k.lower() not in {"host", "content-length"}}
+    headers["X-Forwarded-Host"]  = PUBLIC_HOST
+    headers["X-Forwarded-Proto"] = "https"
+    headers["X-Forwarded-Port"]  = "443"
+    headers["X-Real-IP"]         = request.client.host if request.client else "127.0.0.1"
+    if extra_headers:
+        headers.update(extra_headers)
+    return headers
+
+def _build_downstream_headers(resp_headers: httpx.Headers, override_location: Optional[str] = None) -> Dict[str, str]:
+    headers = {}
+    for key, value in resp_headers.items():
+        lk = key.lower()
+        if lk in _HOP_BY_HOP_HEADERS:
             continue
         if lk == "location":
-            v = _fix_location(v)
-            if location_override:
-                v = location_override
-        out[k] = v
-    return out
-
-# ── Core proxy helper ───────────────────────────────────────────────────────
-async def proxy_http(
+            value = _fix_location_header(value)
+            if override_location:
+                value = override_location
+        headers[key] = value
+    return headers
+
+
+# ── Core Resilient HTTP Proxy Engine ───────────────────────────────────────
+async def proxy_http_request(
     target_url: str,
     request: Request,
-    extra_headers: dict | None = None,
-    html_fixup: Optional[Callable] = None,
+    extra_headers: Optional[Dict[str, str]] = None,
+    html_fixup: Optional[Callable[[str], str]] = None,
 ) -> Response:
     """
-    Forward an HTTP request to target_url.
-    html_fixup(text: str) -> str  — called only on text/html bodies.
-    JS/CSS/JSON/binary content is NEVER modified.
+    Forward an HTTP request to upstream service with automatic retries & streaming support.
     """
-    headers = _request_headers(request, extra_headers)
+    global http_client
+    if http_client is None:
+        http_client = httpx.AsyncClient(timeout=httpx.Timeout(120.0), follow_redirects=False)
+
+    headers = _build_upstream_headers(request, extra_headers)
     body    = await request.body()
+    method  = request.method
+    params  = dict(request.query_params)
 
-    try:
-        resp = await client.request(
-            method=request.method,
-            url=target_url,
-            headers=headers,
-            params=dict(request.query_params),
-            content=body,
-        )
-    except Exception as exc:
-        return Response(
-            content=f"<h2>502 — upstream unavailable</h2><pre>{exc}</pre>",
-            status_code=502,
-            media_type="text/html",
+    # Perform up to 3 attempts with exponential backoff for transient upstream delays
+    resp: Optional[httpx.Response] = None
+    last_exc: Optional[Exception] = None
+
+    for attempt in range(1, 4):
+        try:
+            req = http_client.build_request(
+                method=method,
+                url=target_url,
+                headers=headers,
+                params=params,
+                content=body,
+            )
+            resp = await http_client.send(req, stream=True)
+            if resp.status_code in (502, 503) and attempt < 3:
+                await resp.aclose()
+                await asyncio.sleep(0.1 * attempt)
+                continue
+            break
+        except (httpx.ConnectError, httpx.TimeoutException, httpx.NetworkError) as exc:
+            last_exc = exc
+            if attempt < 3:
+                await asyncio.sleep(0.1 * attempt)
+                continue
+            return Response(
+                content=f"<h2>502 Gateway Error — Upstream Service Starting</h2><p>{exc}</p>",
+                status_code=502,
+                media_type="text/html",
+            )
+
+    if resp is None:
+        return Response(content=f"<h2>502 Bad Gateway</h2><p>{last_exc}</p>", status_code=502, media_type="text/html")
+
+    res_headers = _build_downstream_headers(resp.headers)
+    content_type = resp.headers.get("content-type", "")
+    status_code  = resp.status_code
+
+    # Check if streaming response (eventsource or binary video stream)
+    is_stream = "text/event-stream" in content_type or "video/" in content_type or "audio/" in content_type or resp.headers.get("transfer-encoding") == "chunked"
+
+    if is_stream:
+        async def stream_generator():
+            try:
+                async for chunk in resp.aiter_bytes():
+                    yield chunk
+            finally:
+                await resp.aclose()
+
+        return StreamingResponse(
+            stream_generator(),
+            status_code=status_code,
+            headers=res_headers,
+            media_type=content_type or None,
         )
 
-    res_headers = _response_headers(resp)
-    content     = resp.content
-    ctype       = resp.headers.get("content-type", "")
-    status      = resp.status_code
+    # Non-streaming response body read
+    try:
+        content = await resp.aread()
+    finally:
+        await resp.aclose()
 
-    # Only rewrite text/html — never touch JS, CSS, JSON, images, etc.
-    if "text/html" in ctype and html_fixup and content:
+    # Rewrite HTML references ONLY for text/html (protect JS/CSS/JSON bundles)
+    if "text/html" in content_type and html_fixup and content:
         try:
             text = content.decode("utf-8", errors="replace")
             text = html_fixup(text)
@@ -143,21 +221,26 @@ async def proxy_http(
 
     return Response(
         content=content,
-        status_code=status,
+        status_code=status_code,
         headers=res_headers,
-        media_type=ctype or None,
+        media_type=content_type or None,
     )
 
-# ── WebSocket proxy helper ──────────────────────────────────────────────────
-async def proxy_ws(websocket: WebSocket, target_ws_url: str):
+
+# ── Full-Duplex ASGI WebSocket Proxy Engine ──────────────────────────────────
+async def proxy_websocket_stream(websocket: WebSocket, target_ws_url: str):
+    """
+    Transparent full-duplex ASGI WebSocket proxy between browser client and upstream.
+    """
     await websocket.accept()
-    skip = {"host", "sec-websocket-key", "sec-websocket-version", "sec-websocket-extensions"}
-    headers = {k: v for k, v in websocket.headers.items() if k.lower() not in skip}
+    skip_headers = {"host", "sec-websocket-key", "sec-websocket-version", "sec-websocket-extensions"}
+    forward_headers = {k: v for k, v in websocket.headers.items() if k.lower() not in skip_headers}
+
     try:
-        async with aiohttp.ClientSession() as sess:
-            async with sess.ws_connect(target_ws_url, headers=headers) as ws_up:
-                async def fwd_down():
-                    async for msg in ws_up:
+        async with aiohttp.ClientSession() as session:
+            async with session.ws_connect(target_ws_url, headers=forward_headers) as upstream_ws:
+                async def downstream_to_upstream():
+                    async for msg in upstream_ws:
                         if msg.type == aiohttp.WSMsgType.TEXT:
                             await websocket.send_text(msg.data)
                         elif msg.type == aiohttp.WSMsgType.BINARY:
@@ -165,22 +248,22 @@ async def proxy_ws(websocket: WebSocket, target_ws_url: str):
                         elif msg.type in (aiohttp.WSMsgType.CLOSE, aiohttp.WSMsgType.CLOSED):
                             break
 
-                async def fwd_up():
+                async def upstream_to_downstream():
                     while True:
                         try:
                             msg = await websocket.receive()
                             if "text" in msg:
-                                await ws_up.send_str(msg["text"])
+                                await upstream_ws.send_str(msg["text"])
                             elif "bytes" in msg:
-                                await ws_up.send_bytes(msg["bytes"])
+                                await upstream_ws.send_bytes(msg["bytes"])
                             elif msg.get("type") == "websocket.disconnect":
                                 break
                         except Exception:
                             break
 
-                await asyncio.gather(fwd_down(), fwd_up(), return_exceptions=True)
-    except Exception:
-        pass
+                await asyncio.gather(downstream_to_upstream(), upstream_to_downstream(), return_exceptions=True)
+    except Exception as exc:
+        logger.warning(f"WebSocket Proxy Exception for {target_ws_url}: {exc}")
     finally:
         try:
             await websocket.close()
@@ -189,30 +272,35 @@ async def proxy_ws(websocket: WebSocket, target_ws_url: str):
 
 
 # ══════════════════════════════════════════════════════════════════════════════
-# ROUTES
+# GATEWAY ROUTING MATRIX
 # ══════════════════════════════════════════════════════════════════════════════
 
-# ── 0. Health / Landing ────────────────────────────────────────────────────
+# ── 0. Landing Page & Health Check ───────────────────────────────────────────
 @app.api_route("/", methods=["GET", "HEAD"])
-async def root_hub(request: Request):
+async def gateway_root(request: Request):
     if request.method == "HEAD":
         return Response(status_code=200)
-    for path in ("/index.html", "/app/index.html"):
-        if os.path.exists(path):
-            return FileResponse(path, media_type="text/html")
-    return HTMLResponse("<h1>OpenCode Space Gateway</h1><p>Services: "
-                        "<a href='/server/'>OpenCode</a> | "
-                        "<a href='/openwebui/'>Open WebUI</a> | "
-                        "<a href='/omniroute/'>OmniRoute</a> | "
-                        "<a href='/jellyfin/'>Jellyfin</a></p>")
+    for index_path in ("/index.html", "/app/index.html"):
+        if os.path.exists(index_path):
+            return FileResponse(index_path, media_type="text/html")
+    return HTMLResponse(
+        "<h1>OpenCode Space Gateway</h1>"
+        "<p>Services: "
+        "<a href='/server/'>OpenCode Server</a> | "
+        "<a href='/openwebui/'>Open WebUI</a> | "
+        "<a href='/omniroute/'>OmniRoute AI Gateway</a> | "
+        "<a href='/jellyfin/'>Jellyfin Media</a>"
+        "</p>"
+    )
 
 @app.api_route("/favicon.ico", methods=["GET", "HEAD"])
 async def favicon():
     return Response(content=b"", status_code=204)
 
-# ── 1. Debug status ────────────────────────────────────────────────────────
+@app.get("/health")
 @app.get("/debug/status")
-async def debug_status():
+async def health_check():
+    """Diagnostic health check for all upstream services."""
     services = {
         "opencode":  f"http://127.0.0.1:{OPENCODE_PORT}/",
         "openwebui": f"http://127.0.0.1:{WEBUI_PORT}/",
@@ -221,24 +309,18 @@ async def debug_status():
         "tg_stream": f"http://127.0.0.1:{TG_PORT}/",
     }
     results = {}
-    for name, url in services.items():
-        try:
-            r = await client.get(url, timeout=4.0)
-            results[name] = {"up": True, "status": r.status_code}
-        except Exception as exc:
-            results[name] = {"up": False, "error": str(exc)}
-    return results
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-# 2. OPEN WEBUI  — mounted at /openwebui/
-#    Key insight: Open WebUI is built to run at /, so we STRIP /openwebui
-#    from the path before proxying. All its asset URLs (/_app/, /static/ etc.)
-#    will come in via the catch-all with a Referer: .../openwebui/...
-# ══════════════════════════════════════════════════════════════════════════════
-def _webui_fixup(html: str) -> str:
-    """Rewrite absolute-root asset paths to include /openwebui prefix."""
-    # Don't blindly rewrite every /; be surgical about href/src/action attrs
+    if http_client:
+        for name, url in services.items():
+            try:
+                r = await http_client.get(url, timeout=3.0)
+                results[name] = {"status": "ok", "code": r.status_code}
+            except Exception as exc:
+                results[name] = {"status": "error", "message": str(exc)}
+    return {"gateway": "healthy", "upstreams": results}
+
+
+# ── 1. Open WebUI Route (/openwebui/) ────────────────────────────────────────
+def _fixup_webui_html(html: str) -> str:
     html = html.replace('href="/', 'href="/openwebui/')
     html = html.replace("href='/", "href='/openwebui/")
     html = html.replace('src="/', 'src="/openwebui/')
@@ -248,27 +330,19 @@ def _webui_fixup(html: str) -> str:
 
 @app.api_route("/openwebui", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
 @app.api_route("/openwebui/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
-async def openwebui_route(request: Request, path: str = ""):
-    upstream = f"http://127.0.0.1:{WEBUI_PORT}/{path}"
-    return await proxy_http(upstream, request, html_fixup=_webui_fixup)
+async def route_openwebui(request: Request, path: str = ""):
+    target = f"http://127.0.0.1:{WEBUI_PORT}/{path}"
+    return await proxy_http_request(target, request, html_fixup=_fixup_webui_html)
 
-# Open WebUI WebSocket (socket.io)
 @app.websocket("/openwebui/ws")
 @app.websocket("/openwebui/ws/")
-async def openwebui_ws(websocket: WebSocket):
-    await proxy_ws(websocket, f"ws://127.0.0.1:{WEBUI_PORT}/ws")
-
 @app.websocket("/openwebui/socket.io")
-async def openwebui_socketio(websocket: WebSocket):
-    await proxy_ws(websocket, f"ws://127.0.0.1:{WEBUI_PORT}/socket.io")
+async def route_openwebui_ws(websocket: WebSocket):
+    await proxy_websocket_stream(websocket, f"ws://127.0.0.1:{WEBUI_PORT}/ws")
 
 
-# ══════════════════════════════════════════════════════════════════════════════
-# 3. OMNIROUTE  — mounted at /omniroute/
-#    OmniRoute (Next.js) is built to run at /. We STRIP /omniroute prefix.
-# ══════════════════════════════════════════════════════════════════════════════
-def _omniroute_fixup(html: str) -> str:
-    """Rewrite Next.js root-relative paths to include /omniroute prefix."""
+# ── 2. OmniRoute AI Gateway Route (/omniroute/) ──────────────────────────────
+def _fixup_omniroute_html(html: str) -> str:
     html = html.replace('href="/', 'href="/omniroute/')
     html = html.replace("href='/", "href='/omniroute/")
     html = html.replace('src="/', 'src="/omniroute/')
@@ -276,105 +350,85 @@ def _omniroute_fixup(html: str) -> str:
     html = html.replace('action="/', 'action="/omniroute/')
     html = html.replace('"/_next/', '"/omniroute/_next/')
     html = html.replace("'/_next/", "'/omniroute/_next/")
-    # Fix Next.js router base path in __NEXT_DATA__
     html = html.replace('"basePath":""', '"basePath":"/omniroute"')
     html = html.replace('"basePath": ""', '"basePath": "/omniroute"')
     return html
 
 @app.api_route("/omniroute", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
 @app.api_route("/omniroute/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
-async def omniroute_route(request: Request, path: str = ""):
-    upstream = f"http://127.0.0.1:{OMNIROUTE_PORT}/{path}"
-    return await proxy_http(upstream, request, html_fixup=_omniroute_fixup)
+async def route_omniroute(request: Request, path: str = ""):
+    target = f"http://127.0.0.1:{OMNIROUTE_PORT}/{path}"
+    return await proxy_http_request(target, request, html_fixup=_fixup_omniroute_html)
 
 
-# ══════════════════════════════════════════════════════════════════════════════
-# 4. OPENCODE CLI SERVER  — mounted at /server/
-#    OpenCode's Vite frontend connects to its own backend via WebSocket at /ws.
-#    We proxy /server/ → 127.0.0.1:4097/ and /server/ws → ws://127.0.0.1:4097/ws
-#    We do NOT rewrite JS files — only HTML gets the prefix fixup.
-# ══════════════════════════════════════════════════════════════════════════════
-def _opencode_fixup(html: str) -> str:
-    """Rewrite root-relative asset URLs in opencode HTML to /server prefix."""
+# ── 3. OpenCode CLI Server Route (/server/) ──────────────────────────────────
+def _fixup_opencode_html(html: str) -> str:
     html = html.replace('href="/', 'href="/server/')
     html = html.replace("href='/", "href='/server/")
     html = html.replace('src="/', 'src="/server/')
     html = html.replace("src='/", "src='/server/")
-    # Fix the websocket URL embedded in HTML (not in JS - JS is never touched)
     html = html.replace('ws://"+location.host+"/ws', 'ws://"+location.host+"/server/ws')
     html = html.replace("ws://'+location.host+'/ws", "ws://'+location.host+'/server/ws")
     return html
 
 @app.api_route("/server", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
 @app.api_route("/server/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
-async def opencode_route(request: Request, path: str = ""):
-    upstream = f"http://127.0.0.1:{OPENCODE_PORT}/{path}"
-    return await proxy_http(upstream, request, html_fixup=_opencode_fixup)
+async def route_opencode(request: Request, path: str = ""):
+    target = f"http://127.0.0.1:{OPENCODE_PORT}/{path}"
+    return await proxy_http_request(target, request, html_fixup=_fixup_opencode_html)
 
-# OpenCode WebSocket — the JS bundle sends to /ws (root), our route catches /server/ws
 @app.websocket("/server/ws")
 @app.websocket("/ws")
-async def opencode_ws(websocket: WebSocket):
-    await proxy_ws(websocket, f"ws://127.0.0.1:{OPENCODE_PORT}/ws")
+async def route_opencode_ws(websocket: WebSocket):
+    await proxy_websocket_stream(websocket, f"ws://127.0.0.1:{OPENCODE_PORT}/ws")
 
 
-# ══════════════════════════════════════════════════════════════════════════════
-# 5. JELLYFIN  — mounted at /jellyfin/
-# ══════════════════════════════════════════════════════════════════════════════
+# ── Direct OpenCode Endpoints (session, project, config, etc.) ───────────────
+OPENCODE_DIRECT_PATHS = ["session", "project", "config", "permission", "question", "file", "find", "events", "event", "command", "provider", "model", "mcp", "api"]
+
+def _create_direct_route(prefix: str):
+    @app.api_route(f"/{prefix}", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
+    @app.api_route(f"/{prefix}/{{path:path}}", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
+    async def direct_endpoint(request: Request, path: str = ""):
+        full_path = f"{prefix}/{path}" if path else prefix
+        target = f"http://127.0.0.1:{OPENCODE_PORT}/{full_path}"
+        return await proxy_http_request(target, request, html_fixup=_fixup_opencode_html)
+
+for p in OPENCODE_DIRECT_PATHS:
+    _create_direct_route(p)
+
+
+# ── 4. Jellyfin Media Server Route (/jellyfin/) ───────────────────────────────
 @app.api_route("/jellyfin", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
 @app.api_route("/jellyfin/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
 @app.api_route("/Jellyfin", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
 @app.api_route("/Jellyfin/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
-async def jellyfin_route(request: Request, path: str = ""):
-    upstream = f"http://127.0.0.1:{JELLYFIN_PORT}/{path}"
-    return await proxy_http(
-        upstream, request,
-        extra_headers={"X-Forwarded-Prefix": "/jellyfin"},
-    )
+async def route_jellyfin(request: Request, path: str = ""):
+    target = f"http://127.0.0.1:{JELLYFIN_PORT}/{path}"
+    return await proxy_http_request(target, request, extra_headers={"X-Forwarded-Prefix": "/jellyfin"})
 
 
-# ══════════════════════════════════════════════════════════════════════════════
-# 6. TG-DRIVE STREAMER  — mounted at /tg-stream/
-# ══════════════════════════════════════════════════════════════════════════════
+# ── 5. TG-Drive Direct Streamer Route (/tg-stream/) ─────────────────────────
 @app.api_route("/tg-stream", methods=["GET", "HEAD", "OPTIONS"])
 @app.api_route("/tg-stream/{path:path}", methods=["GET", "HEAD", "OPTIONS"])
-async def tg_stream_route(request: Request, path: str = ""):
-    upstream = f"http://127.0.0.1:{TG_PORT}/{path}"
-    return await proxy_http(upstream, request)
+async def route_tg_stream(request: Request, path: str = ""):
+    target = f"http://127.0.0.1:{TG_PORT}/{path}"
+    return await proxy_http_request(target, request)
 
 
-# ══════════════════════════════════════════════════════════════════════════════
-# 7. CATCH-ALL — smart Referer-based fallback for sub-resource requests
-#    When JS/CSS/API assets from a sub-app arrive at the root (e.g. /_app/...)
-#    we use the Referer header to route them to the correct upstream.
-# ══════════════════════════════════════════════════════════════════════════════
+# ── 6. Catch-All Referer Router (Sub-resource Fallback Engine) ────────────────
 @app.api_route("/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
-async def catch_all(path: str, request: Request):
+async def route_catch_all(path: str, request: Request):
     referer = request.headers.get("referer", "").lower()
 
     if "/openwebui" in referer:
-        return await proxy_http(
-            f"http://127.0.0.1:{WEBUI_PORT}/{path}", request,
-            html_fixup=_webui_fixup,
-        )
+        return await proxy_http_request(f"http://127.0.0.1:{WEBUI_PORT}/{path}", request, html_fixup=_fixup_webui_html)
     elif "/omniroute" in referer or "/dashboard" in referer or "/login" in referer:
-        return await proxy_http(
-            f"http://127.0.0.1:{OMNIROUTE_PORT}/{path}", request,
-            html_fixup=_omniroute_fixup,
-        )
+        return await proxy_http_request(f"http://127.0.0.1:{OMNIROUTE_PORT}/{path}", request, html_fixup=_fixup_omniroute_html)
     elif "/server" in referer:
-        return await proxy_http(
-            f"http://127.0.0.1:{OPENCODE_PORT}/{path}", request,
-            html_fixup=_opencode_fixup,
-        )
+        return await proxy_http_request(f"http://127.0.0.1:{OPENCODE_PORT}/{path}", request, html_fixup=_fixup_opencode_html)
     elif "/jellyfin" in referer:
-        return await proxy_http(
-            f"http://127.0.0.1:{JELLYFIN_PORT}/{path}", request,
-            extra_headers={"X-Forwarded-Prefix": "/jellyfin"},
-        )
+        return await proxy_http_request(f"http://127.0.0.1:{JELLYFIN_PORT}/{path}", request, extra_headers={"X-Forwarded-Prefix": "/jellyfin"})
 
-    # Default: try Open WebUI
-    return await proxy_http(
-        f"http://127.0.0.1:{WEBUI_PORT}/{path}", request,
-        html_fixup=_webui_fixup,
-    )
+    # Fallback default: Open WebUI
+    return await proxy_http_request(f"http://127.0.0.1:{WEBUI_PORT}/{path}", request, html_fixup=_fixup_webui_html)

tg_streamer.py

@@ -180,14 +180,19 @@ def create_strm_file(msg_id, file_id, clean_title, is_tv=False, show_name=None,
     return strm_filename
 
 async def trigger_jellyfin_scan():
-    """Trigger Jellyfin Library Scan automatically"""
-    try:
-        connector = aiohttp.TCPConnector(family=socket.AF_INET)
-        async with aiohttp.ClientSession(connector=connector) as session:
-            async with session.post("http://127.0.0.1:8096/Library/Refresh") as resp:
-                logger.info(f"Jellyfin library refresh triggered: {resp.status}")
-    except Exception as e:
-        logger.warning(f"Could not trigger Jellyfin library refresh: {e}")
+    """Trigger Jellyfin Library Scan automatically with retry while Jellyfin boots"""
+    for attempt in range(5):
+        try:
+            connector = aiohttp.TCPConnector(family=socket.AF_INET)
+            async with aiohttp.ClientSession(connector=connector) as session:
+                async with session.post("http://127.0.0.1:8096/Library/Refresh") as resp:
+                    logger.info(f"Jellyfin library refresh triggered: {resp.status}")
+                    return
+        except Exception as e:
+            if attempt < 4:
+                await asyncio.sleep(3)
+                continue
+            logger.warning(f"Could not trigger Jellyfin library refresh after retries: {e}")
 
 @routes.post("/")
 @routes.post("/telegram-webhook")