feat: bootstrap model prices on management page

Dockerfile

@@ -21,6 +21,7 @@ ENV USAGE_AUTOSAVE_INTERVAL=300
 
 COPY entrypoint.sh /opt/daili/entrypoint.sh
 COPY hf_snapshot.py /opt/daili/hf_snapshot.py
+COPY model_price_bootstrap.py /opt/daili/model_price_bootstrap.py
 RUN chmod +x /opt/daili/entrypoint.sh
 
 EXPOSE 8317

entrypoint.sh

@@ -26,6 +26,10 @@ MC_CONFIG_DIR="${MC_CONFIG_DIR:-${AUTH_BASE}/.mc}"
 USAGE_HF_TOKEN="${USAGE_HF_TOKEN:-${HF_TOKEN:-}}"
 USAGE_HF_REPO_ID="${USAGE_HF_REPO_ID:-pjpjq/daili-usage-state}"
 USAGE_HF_PATH="${USAGE_HF_PATH:-usage-export.json}"
+MODEL_PRICES_SOURCE_URL="${MODEL_PRICES_SOURCE_URL:-https://zhanzhong.zeabur.app/api/pricing}"
+MODEL_PRICES_OUTPUT_PATH="${MODEL_PRICES_OUTPUT_PATH:-${AUTH_BASE}/usage-state/model-prices.json}"
+MODEL_PRICES_FETCH_TIMEOUT="${MODEL_PRICES_FETCH_TIMEOUT:-20}"
+MANAGEMENT_HTML_PATH="${MANAGEMENT_HTML_PATH:-${AUTH_BASE}/static/management.html}"
 CONFIG_PATH="/opt/daili/config.yaml"
 GATEWAY_BIN="/usr/local/bin/daili-gateway"
 GATEWAY_PID=""
@@ -238,6 +242,16 @@ backup_usage() {
   fi
 }
 
+refresh_model_prices() {
+  env \
+    MODEL_PRICES_SOURCE_URL="$MODEL_PRICES_SOURCE_URL" \
+    MODEL_PRICES_OUTPUT_PATH="$MODEL_PRICES_OUTPUT_PATH" \
+    MODEL_PRICES_FETCH_TIMEOUT="$MODEL_PRICES_FETCH_TIMEOUT" \
+    MANAGEMENT_HTML_PATH="$MANAGEMENT_HTML_PATH" \
+    WRITABLE_PATH="$AUTH_BASE" \
+    /usr/local/bin/python3 /opt/daili/model_price_bootstrap.py >/dev/null 2>&1 || true
+}
+
 restore_usage() {
   download_r2_snapshot
   download_hf_snapshot
@@ -259,6 +273,7 @@ start_autosave_loop() {
   (
     while true; do
       sleep "$USAGE_AUTOSAVE_INTERVAL"
+      refresh_model_prices
       backup_usage
     done
   ) &
@@ -289,10 +304,12 @@ unset HTTP_PROXY HTTPS_PROXY ALL_PROXY http_proxy https_proxy all_proxy
 GATEWAY_PID="$!"
 
 restore_usage || true
+refresh_model_prices
 start_autosave_loop
 
 wait "$GATEWAY_PID"
 status="$?"
 stop_background_jobs
+refresh_model_prices
 backup_usage
 exit "$status"

model_price_bootstrap.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+
+import json
+import os
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any
+from urllib.error import URLError
+from urllib.request import urlopen
+
+
+SCRIPT_START = "<!-- model-price-bootstrap:start -->"
+SCRIPT_END = "<!-- model-price-bootstrap:end -->"
+LOCAL_STORAGE_KEY = "cli-proxy-model-prices-v2"
+DEFAULT_SOURCE_URL = "https://zhanzhong.zeabur.app/api/pricing"
+DEFAULT_TIMEOUT_SECONDS = 20
+
+
+def env_path(name: str, default: str) -> Path:
+    value = os.environ.get(name, "").strip() or default
+    return Path(value)
+
+
+def env_text(name: str, default: str) -> str:
+    return os.environ.get(name, "").strip() or default
+
+
+def env_int(name: str, default: int) -> int:
+    raw = os.environ.get(name, "").strip()
+    if not raw:
+        return default
+    try:
+        return max(1, int(raw))
+    except ValueError:
+        return default
+
+
+def atomic_write(path: Path, content: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.NamedTemporaryFile(
+        "w",
+        encoding="utf-8",
+        delete=False,
+        dir=str(path.parent),
+    ) as tmp:
+        tmp.write(content)
+        tmp_path = Path(tmp.name)
+    tmp_path.replace(path)
+
+
+def load_json(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def fetch_remote_json(url: str, timeout: int) -> dict[str, Any]:
+    with urlopen(url, timeout=timeout) as response:
+        data = json.load(response)
+    if not isinstance(data, dict):
+        raise ValueError("remote pricing payload is not a JSON object")
+    return data
+
+
+def normalize_price(value: Any) -> float:
+    try:
+        return round(float(value), 6)
+    except (TypeError, ValueError):
+        return 0.0
+
+
+def build_prices_from_newapi(payload: dict[str, Any]) -> dict[str, dict[str, float]]:
+    rows = payload.get("data")
+    if not isinstance(rows, list):
+        raise ValueError("pricing payload missing data list")
+
+    group_ratio = payload.get("group_ratio")
+    default_group_ratio = 1.0
+    if isinstance(group_ratio, dict):
+        default_group_ratio = float(group_ratio.get("default", 1) or 1)
+
+    result: dict[str, dict[str, float]] = {}
+    for item in rows:
+        if not isinstance(item, dict):
+            continue
+        if item.get("quota_type") != 0:
+            continue
+
+        model_name = str(item.get("model_name", "")).strip()
+        if not model_name:
+            continue
+
+        prompt = normalize_price(item.get("model_ratio", 0) * 2 * default_group_ratio)
+        if prompt <= 0:
+            continue
+
+        completion_ratio = normalize_price(item.get("completion_ratio", 1))
+        completion = normalize_price(prompt * completion_ratio)
+
+        cache_ratio = item.get("cache_ratio")
+        cache = prompt if cache_ratio is None else normalize_price(prompt * cache_ratio)
+
+        result[model_name] = {
+            "prompt": prompt,
+            "completion": completion,
+            "cache": cache,
+        }
+
+    if not result:
+        raise ValueError("no per-token pricing models found")
+
+    return result
+
+
+def build_script(prices: dict[str, dict[str, float]]) -> str:
+    serialized = json.dumps(prices, ensure_ascii=False, separators=(",", ":"))
+    return f"""{SCRIPT_START}
+<script>
+(function () {{
+  const STORAGE_KEY = {json.dumps(LOCAL_STORAGE_KEY)};
+  const DEFAULT_PRICES = {serialized};
+
+  const normalize = (value) => {{
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+    const prompt = Number(value.prompt);
+    const completion = Number(value.completion);
+    const cache = Number(value.cache);
+    if (!Number.isFinite(prompt) || !Number.isFinite(completion) || !Number.isFinite(cache)) {{
+      return null;
+    }}
+    return {{ prompt, completion, cache }};
+  }};
+
+  const sanitizeMap = (value) => {{
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return {{}};
+    const next = {{}};
+    Object.entries(value).forEach(([key, item]) => {{
+      const normalized = normalize(item);
+      if (normalized) {{
+        next[String(key)] = normalized;
+      }}
+    }});
+    return next;
+  }};
+
+  const applyDefaults = () => {{
+    let current = {{}};
+    try {{
+      current = sanitizeMap(JSON.parse(localStorage.getItem(STORAGE_KEY) || '{{}}'));
+    }} catch (_error) {{
+      current = {{}};
+    }}
+
+    const merged = {{ ...DEFAULT_PRICES, ...current }};
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(merged));
+  }};
+
+  if (document.readyState === 'loading') {{
+    document.addEventListener('DOMContentLoaded', applyDefaults, {{ once: true }});
+  }} else {{
+    applyDefaults();
+  }}
+}})();
+</script>
+{SCRIPT_END}"""
+
+
+def patch_management_html(html_path: Path, prices: dict[str, dict[str, float]]) -> bool:
+    if not html_path.exists():
+        return False
+
+    html = html_path.read_text(encoding="utf-8")
+    script_block = build_script(prices)
+    start_index = html.find(SCRIPT_START)
+    end_index = html.find(SCRIPT_END)
+
+    if start_index != -1 and end_index != -1 and end_index > start_index:
+        end_index += len(SCRIPT_END)
+        patched = html[:start_index] + script_block + html[end_index:]
+    elif "</body>" in html:
+        patched = html.replace("</body>", script_block + "\n</body>", 1)
+    else:
+        patched = html + "\n" + script_block
+
+    if patched == html:
+        return True
+
+    atomic_write(html_path, patched)
+    return True
+
+
+def main() -> int:
+    writable_base = env_text("WRITABLE_PATH", "/tmp")
+    html_path = env_path("MANAGEMENT_HTML_PATH", f"{writable_base}/static/management.html")
+    prices_path = env_path("MODEL_PRICES_OUTPUT_PATH", f"{writable_base}/usage-state/model-prices.json")
+    source_url = env_text("MODEL_PRICES_SOURCE_URL", DEFAULT_SOURCE_URL)
+    timeout = env_int("MODEL_PRICES_FETCH_TIMEOUT", DEFAULT_TIMEOUT_SECONDS)
+
+    prices: dict[str, dict[str, float]] = {}
+    try:
+        payload = fetch_remote_json(source_url, timeout)
+        prices = build_prices_from_newapi(payload)
+        atomic_write(prices_path, json.dumps(prices, ensure_ascii=False, indent=2, sort_keys=True))
+    except (URLError, TimeoutError, ValueError, OSError, json.JSONDecodeError) as exc:
+        cached = load_json(prices_path)
+        if isinstance(cached, dict) and cached:
+            prices = cached
+            print(f"model_price_bootstrap: using cached prices after fetch failure: {exc}", file=sys.stderr)
+        else:
+            print(f"model_price_bootstrap: unable to fetch or load prices: {exc}", file=sys.stderr)
+            return 0
+
+    if not patch_management_html(html_path, prices):
+        print(
+            f"model_price_bootstrap: management html not found yet at {html_path}",
+            file=sys.stderr,
+        )
+        return 0
+
+    print(
+        f"model_price_bootstrap: patched {html_path} with {len(prices)} model prices from {source_url}",
+        file=sys.stderr,
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())