@music-league-eras/local-runner 0.1.2 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@music-league-eras/local-runner",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Music League Eras local runner (npx wrapper around the Python scraper runner).",
   "type": "module",
   "license": "UNLICENSED",

package/vendor/python/app/browser/session.py

@@ -9,7 +9,11 @@ from urllib.parse import urljoin, urlparse
 
 from playwright.async_api import async_playwright
 
-from ..services.viewer import extract_viewer_avatar_url, extract_viewer_user_id
+from ..services.viewer import (
+    extract_viewer_avatar_url,
+    extract_viewer_user_id,
+    extract_viewer_user_id_from_storage_state,
+)
 
 
 @dataclass(frozen=True)
@@ -235,6 +239,8 @@ async def capture_storage_state(
                         try:
                             html = await page.content()
                             viewer_user_id = extract_viewer_user_id(html)
+                            if not viewer_user_id:
+                                viewer_user_id = extract_viewer_user_id_from_storage_state(storage_state)
                             viewer_avatar_url = extract_viewer_avatar_url(html)
                         except Exception:
                             viewer_user_id = None

package/vendor/python/app/services/scrape_manifest.py

@@ -14,7 +14,7 @@ from urllib.parse import urljoin, urlparse
 from bs4 import BeautifulSoup
 from playwright.async_api import async_playwright
 
-from .viewer import extract_viewer_user_id
+from .viewer import extract_viewer_user_id, extract_viewer_user_id_from_storage_state
 
 COMPLETED_LEAGUES_XHR = "/completed/-/completedLeagues"
 DEFAULT_USER_AGENT = (
@@ -586,6 +586,15 @@ async def build_manifest(
             completed_final_url = page.url
             completed_page_html = await page.content()
             _write_text(out_dir / "completed.page.html", completed_page_html)
+
+            # The completed leagues list is loaded via htmx; give it a moment to hydrate so our
+            # fallback parser can still find league links even if the XHR helpers fail.
+            try:
+                await page.wait_for_selector(".league-tile, a[href^=\"/l/\"]", timeout=6_000)
+                completed_page_html = await page.content()
+                _write_text(out_dir / "completed.page.after.html", completed_page_html)
+            except Exception:
+                pass
             manifest["debug"] = {
                 "completed_url": completed_page_url,
                 "completed_final_url": completed_final_url,
@@ -595,6 +604,8 @@ async def build_manifest(
             cookie_header = await _cookie_header_from_context(context, base_url) or initial_cookie_header
 
             viewer_id = extract_viewer_user_id(completed_page_html)
+            if not viewer_id:
+                viewer_id = extract_viewer_user_id_from_storage_state(storage_state_payload)
             manifest["viewer"] = {"user_id": viewer_id} if viewer_id else None
 
             completed_url = _abs_url(base_url, COMPLETED_LEAGUES_XHR)

package/vendor/python/app/services/viewer.py

@@ -1,17 +1,28 @@
 from __future__ import annotations
 
 import re
+from typing import Any
 from typing import Optional
 
 from bs4 import BeautifulSoup
 
 USER_HREF_RE = re.compile(r"^/user/([0-9a-f]{32})/?$", re.I)
 VIEW_PROFILE_LABEL = "view profile"
+HEX_32_RE = re.compile(r"\b([0-9a-f]{32})\b", re.I)
+BEACON_USER_ID_RE = re.compile(
+    r"Beacon\(\s*['\"]session-data['\"]\s*,\s*\{[^}]*['\"]User ID['\"]\s*:\s*['\"]([0-9a-f]{32})['\"]",
+    re.I,
+)
 
 
 def extract_viewer_user_id(html: str) -> Optional[str]:
     soup = BeautifulSoup(html or "", "html.parser")
 
+    # Some templates include the user id for support tooling (HelpScout Beacon).
+    beacon_match = BEACON_USER_ID_RE.search(html or "")
+    if beacon_match:
+        return beacon_match.group(1)
+
     a_tag = soup.find(
         "a",
         href=lambda h: bool(h and USER_HREF_RE.match(h)),
@@ -56,3 +67,92 @@ def extract_viewer_avatar_url(html: str) -> Optional[str]:
             return src
 
     return None
+
+
+def extract_viewer_user_id_from_storage_state(storage_state: dict[str, Any] | None) -> Optional[str]:
+    if not storage_state:
+        return None
+
+    def first_hex(text: str | None) -> Optional[str]:
+        if not text:
+            return None
+        match = HEX_32_RE.search(text)
+        return match.group(1) if match else None
+
+    # Prefer localStorage keys that look explicitly user-related.
+    origins = storage_state.get("origins") or []
+    if isinstance(origins, list):
+        for origin in origins:
+            if not isinstance(origin, dict):
+                continue
+            local_storage = origin.get("localStorage") or []
+            if not isinstance(local_storage, list):
+                continue
+            for entry in local_storage:
+                if not isinstance(entry, dict):
+                    continue
+                name = str(entry.get("name") or "")
+                value = entry.get("value")
+                if value is None:
+                    continue
+                value_str = value if isinstance(value, str) else str(value)
+                if re.search(r"(user|viewer|account|profile)", name, re.I):
+                    candidate = first_hex(value_str)
+                    if candidate:
+                        return candidate
+
+                # Try JSON blobs stored as strings.
+                if value_str and value_str.lstrip().startswith(("{", "[")):
+                    candidate = _extract_hex_from_json_like(value_str)
+                    if candidate:
+                        return candidate
+
+    # Next: cookies with user-ish names that directly store a 32-hex id.
+    cookies = storage_state.get("cookies") or []
+    if isinstance(cookies, list):
+        for cookie in cookies:
+            if not isinstance(cookie, dict):
+                continue
+            name = str(cookie.get("name") or "")
+            value = str(cookie.get("value") or "")
+            if re.search(r"(user|uid)", name, re.I):
+                candidate = first_hex(value)
+                if candidate:
+                    return candidate
+
+    # Last: if there's exactly one unique 32-hex anywhere in localStorage values, use it.
+    candidates: set[str] = set()
+    if isinstance(origins, list):
+        for origin in origins:
+            if not isinstance(origin, dict):
+                continue
+            local_storage = origin.get("localStorage") or []
+            if not isinstance(local_storage, list):
+                continue
+            for entry in local_storage:
+                if not isinstance(entry, dict):
+                    continue
+                value = entry.get("value")
+                if value is None:
+                    continue
+                value_str = value if isinstance(value, str) else str(value)
+                for match in HEX_32_RE.finditer(value_str):
+                    candidates.add(match.group(1))
+    if len(candidates) == 1:
+        return next(iter(candidates))
+
+    return None
+
+
+def _extract_hex_from_json_like(value: str) -> Optional[str]:
+    # Keep it simple: avoid importing json here; we only need a heuristic.
+    # Common patterns: {"user_id":"..."} or {"userId":"..."} nested inside a blob.
+    for pattern in (
+        r"['\"]user_id['\"]\s*:\s*['\"]([0-9a-f]{32})['\"]",
+        r"['\"]userId['\"]\s*:\s*['\"]([0-9a-f]{32})['\"]",
+        r"['\"]viewer_user_id['\"]\s*:\s*['\"]([0-9a-f]{32})['\"]",
+    ):
+        match = re.search(pattern, value, re.I)
+        if match:
+            return match.group(1)
+    return None