@remixmate/cli 0.1.0

package/skills/render-video/scripts/remote_renderer_client.py

@@ -0,0 +1,236 @@
+#!/usr/bin/env python3
+"""
+远程渲染 HTTP 客户端 — 对接独立部署的 remotion-renderer 服务。
+
+接口（位于 /remotion-renderer/server/index.ts）：
+  - POST /render        → { code, data: { taskId } }
+        body 可选 coverCompositionId（如 "SpotlightCardCover"）；传了的话视频
+        渲染完成后服务端会再串行渲一帧静态封面、一并上传。
+  - POST /renderStatus  → { code, data: { status, progress, fileUrl?,
+                                          coverUrl?, coverError?, error? } }
+        coverUrl  视频成功且封面成功时存在
+        coverError 视频成功但封面失败时存在（视频本身仍然 succeeded）
+
+认证头（复用 X-Priv-Token 规范，服务端通过后端 API 校验）：
+  X-Priv-Token: <PRIV_TOKEN>
+  x-invoke-skill:         render-video
+  x-invoke-agent:         <AGENT_NAME>  # optional
+
+Base URL 优先级：
+  1. 调用方显式传入 base_url
+  2. 环境变量 REMOTION_RENDER_API_URL
+  3. 默认 http://localhost:3000（与 server/config.ts 的 PORT 默认值一致，方便本地调试）
+
+本模块只负责 HTTP 层；调用方（render_video.py）负责把结果写回 render_plan。
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Callable, Optional
+
+DEFAULT_API_BASE_URL = "http://localhost:3000"
+API_BASE_URL = (os.environ.get("REMOTION_RENDER_API_URL") or DEFAULT_API_BASE_URL).strip()
+SKILL_NAME = "render-video"
+AGENT_NAME = os.environ.get("AGENT_NAME", "")
+
+STATUS_PENDING = "pending"
+STATUS_PROCESSING = "processing"
+STATUS_RUNNING = "running"
+STATUS_SUCCEEDED = "succeeded"
+STATUS_SUCCEED = "succeed"
+STATUS_COMPLETED = "completed"
+STATUS_FAILED = "failed"
+STATUS_CANCELLED = "cancelled"
+
+TERMINAL_SUCCESS = {STATUS_SUCCEEDED, STATUS_SUCCEED, STATUS_COMPLETED}
+TERMINAL_FAILURE = {STATUS_FAILED, STATUS_CANCELLED}
+
+
+class RemoteRenderError(RuntimeError):
+    """抛出至调用方，由上层写入 render_plan.errors。"""
+
+
+def _build_headers(private_token: str, content_type: str = "application/json", conversation_id: Optional[str] = None) -> dict:
+    if not private_token:
+        raise RemoteRenderError("PrivToken is not set (PRIV_TOKEN or --priv-token)")
+    headers = {
+        "X-Priv-Token": private_token,
+        "x-invoke-skill": SKILL_NAME,
+    }
+    if content_type:
+        headers["Content-Type"] = content_type
+    if AGENT_NAME:
+        headers["x-invoke-agent"] = AGENT_NAME
+    if conversation_id:
+        headers["x-conversation-id"] = conversation_id
+    return headers
+
+
+def _request(
+    method: str,
+    path: str,
+    *,
+    private_token: str,
+    payload: Optional[dict] = None,
+    query: Optional[dict] = None,
+    base_url: Optional[str] = None,
+    timeout: float = 120.0,
+    conversation_id: Optional[str] = None,
+) -> dict:
+    base = (base_url or API_BASE_URL).rstrip("/")
+    if not base:
+        raise RemoteRenderError("renderer service base URL is not set")
+    url = f"{base}{path}"
+    if query:
+        url = f"{url}?{urllib.parse.urlencode(query)}"
+
+    data = None
+    if payload is not None:
+        data = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+
+    headers = _build_headers(private_token, conversation_id=conversation_id)
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        body = resp.read().decode("utf-8")
+    try:
+        return json.loads(body)
+    except json.JSONDecodeError as exc:
+        raise RemoteRenderError(f"remote response is not JSON: {body[:200]}") from exc
+
+
+def _check_code(result: dict) -> dict:
+    code = result.get("code")
+    if code != 0:
+        msg = result.get("msg") or result.get("message") or "unknown error"
+        raise RemoteRenderError(f"API code={code}: {msg}")
+    return result.get("data") or {}
+
+
+def start_render(
+    payload: dict,
+    *,
+    private_token: str,
+    base_url: Optional[str] = None,
+    timeout: float = 120.0,
+    conversation_id: Optional[str] = None,
+) -> str:
+    """POST /render；返回 taskId。"""
+    result = _request(
+        "POST",
+        "/render",
+        private_token=private_token,
+        payload=payload,
+        base_url=base_url,
+        timeout=timeout,
+        conversation_id=conversation_id,
+    )
+    data = _check_code(result)
+    task_id = data.get("taskId")
+    if not task_id:
+        raise RemoteRenderError(f"/render did not return a taskId: {result}")
+    return str(task_id)
+
+
+def poll_render(
+    task_id: str,
+    *,
+    private_token: str,
+    base_url: Optional[str] = None,
+    timeout: float = 1800.0,
+    interval: float = 5.0,
+    request_timeout: float = 60.0,
+    max_consecutive_errors: int = 5,
+    on_progress: Optional[Callable[[dict], None]] = None,
+    adaptive_interval: bool = False,
+) -> dict:
+    """POST /renderStatus 轮询直到完成/失败/超时。
+
+    成功时返回 data dict（至少包含 fileUrl），否则抛 RemoteRenderError。
+    on_progress 回调在每次成功请求后触发，参数为完整 data dict。
+
+    adaptive_interval=True 时根据渲染进度自动调整轮询间隔：
+      0-20%: interval * 2（初始化阶段，变化慢）
+      20-80%: interval（正常渲染阶段）
+      80-100%: interval * 0.6（编码收尾阶段，更频繁检查）
+    """
+    start = time.monotonic()
+    consecutive_errors = 0
+    current_progress = 0.0
+
+    while True:
+        elapsed = time.monotonic() - start
+        if elapsed > timeout:
+            raise RemoteRenderError(
+                f"remote render polling timed out (waited {elapsed:.0f}s, taskId={task_id}); "
+                f"the job may still be running on the backend — query /renderStatus later"
+            )
+
+        try:
+            result = _request(
+                "POST",
+                "/renderStatus",
+                private_token=private_token,
+                payload={"taskId": task_id},
+                base_url=base_url,
+                timeout=request_timeout,
+            )
+        except (urllib.error.URLError, OSError, ConnectionError) as exc:
+            consecutive_errors += 1
+            print(
+                f"   ⚠️  polling network error ({consecutive_errors}/{max_consecutive_errors}): {exc}",
+                file=sys.stderr,
+                flush=True,
+            )
+            if consecutive_errors >= max_consecutive_errors:
+                raise RemoteRenderError(
+                    f"{max_consecutive_errors} consecutive network errors; giving up on polling (taskId={task_id})"
+                ) from exc
+            time.sleep(interval)
+            continue
+        except urllib.error.HTTPError as exc:
+            body = ""
+            try:
+                body = exc.read().decode("utf-8")
+            except Exception:
+                pass
+            raise RemoteRenderError(f"HTTP {exc.code} /renderStatus: {body[:200]}") from exc
+
+        consecutive_errors = 0
+
+        data = _check_code(result)
+        if on_progress is not None:
+            try:
+                on_progress(data)
+            except Exception:  # noqa: BLE001 — 进度回调异常不应中断轮询
+                pass
+
+        status = str(data.get("status") or "").lower()
+        if status in TERMINAL_SUCCESS:
+            return data
+        if status in TERMINAL_FAILURE:
+            err = data.get("error") or data.get("errorMsg") or data.get("message") or "unknown"
+            raise RemoteRenderError(f"remote render failed ({status}): {err}")
+
+        # Adaptive interval: adjust sleep based on current progress
+        current_progress = float(data.get("progress") or 0.0)
+        if adaptive_interval:
+            if current_progress < 0.2:
+                sleep_time = interval * 2
+            elif current_progress >= 0.8:
+                sleep_time = max(interval * 0.6, 2.0)
+            else:
+                sleep_time = interval
+        else:
+            sleep_time = interval
+        time.sleep(sleep_time)
+
+
+__all__ = ["start_render", "poll_render", "RemoteRenderError"]