@remixmate/cli 0.1.0

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

@@ -0,0 +1,305 @@
+"""Chrome Headless vendor sync — separated from render_video.py.
+
+把 Chrome 下载/解压/共享缓存这块"部署/运维相关"的逻辑收拢到一个文件，让
+render_video.py 只剩"调度 + 渲染"。日后如果要把这块搬到 ab-render Dockerfile
+或独立 prepare 脚本，只需要换掉这个模块的实现，render_video 不用动。
+
+公共入口只有一个：sync_chrome_headless_vendor()。其它都是辅助函数，给 sync 用。
+"""
+from __future__ import annotations
+
+import builtins
+import json
+import os
+import platform
+import shutil
+import subprocess  # noqa: F401  (kept for parity with original imports)
+import sys
+import tempfile
+import urllib.error
+import urllib.request
+import zipfile
+from datetime import datetime
+from typing import Optional
+
+
+def _now_iso() -> str:
+    from datetime import timezone
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _log(msg: str) -> None:
+    """Tiny stderr-with-timestamp helper, mirrors render_video.LogPrint format."""
+    now = datetime.now()
+    stamp = now.strftime("%Y%m%d %H%M%S") + f":{now.microsecond // 1000:03d}"
+    builtins.print(f"[{stamp}] {msg}", file=sys.stderr)
+
+
+def _detect_remotion_chrome_platform() -> Optional[str]:
+    """与 Remotion BrowserFetcher 一致的平台标识；不支持时返回 None。"""
+    system = platform.system()
+    machine = platform.machine().lower()
+    if system == "Darwin":
+        return "mac-arm64" if machine == "arm64" else "mac-x64"
+    if system == "Linux":
+        if machine in ("aarch64", "arm64"):
+            return "linux-arm64"
+        return "linux64"
+    if system == "Windows":
+        return "win64"
+    return None
+
+
+def _load_chrome_vendor_manifest(renderer_dir: str) -> Optional[dict]:
+    override = os.environ.get("REMOTION_CHROME_VENDOR_JSON", "").strip()
+    path = override if override else os.path.join(
+        renderer_dir,
+        "chrome-headless-vendor-template",
+        "vendor-zip-urls.json",
+    )
+    if not os.path.isfile(path):
+        return None
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        return data if isinstance(data, dict) else None
+    except (OSError, json.JSONDecodeError):
+        return None
+
+
+def _download_chrome_vendor_zip(url: str, dest_path: str) -> None:
+    timeout = int(os.environ.get("REMOTION_CHROME_VENDOR_DOWNLOAD_TIMEOUT", "3600"))
+    req = urllib.request.Request(
+        url,
+        headers={"User-Agent": "Mozilla/5.0 (compatible; render-video/1.0)"},
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            with open(dest_path, "wb") as out:
+                shutil.copyfileobj(resp, out, 1024 * 256)
+    except urllib.error.HTTPError as e:
+        raise RuntimeError(f"HTTP {e.code}: {e.reason}") from e
+    except urllib.error.URLError as e:
+        raise RuntimeError(f"Download failed: {e.reason}") from e
+
+
+def _vendor_chrome_headless_ready(chrome_root: str, rem_platform: str, expected_version: str) -> bool:
+    version_path = os.path.join(chrome_root, "VERSION")
+    if not os.path.isfile(version_path):
+        return False
+    try:
+        with open(version_path, "r", encoding="utf-8") as f:
+            if f.read().strip() != expected_version:
+                return False
+    except OSError:
+        return False
+    inner = os.path.join(chrome_root, rem_platform, f"chrome-headless-shell-{rem_platform}")
+    if rem_platform == "win64":
+        return os.path.isfile(os.path.join(inner, "chrome-headless-shell.exe"))
+    return os.path.isfile(os.path.join(inner, "chrome-headless-shell"))
+
+
+def _ensure_chrome_headless_shell_executable(chrome_root: str, rem_platform: str) -> None:
+    if rem_platform == "win64":
+        return
+    inner = os.path.join(chrome_root, rem_platform, f"chrome-headless-shell-{rem_platform}")
+    exe = os.path.join(inner, "chrome-headless-shell")
+    if os.path.isfile(exe) and hasattr(os, "chmod"):
+        os.chmod(exe, os.stat(exe).st_mode | 0o111)
+
+
+def _resolve_chrome_share_root() -> str:
+    root = os.environ.get("REMOTION_CHROME_SHARE_DIR", "/tmp/agent-share/chrome-headless").strip()
+    return root if root else "/tmp/agent-share/chrome-headless"
+
+
+def _chrome_headless_share_zip_path(share_root: str, rem_platform: str) -> str:
+    return os.path.join(share_root, f"chrome-headless-shell-{rem_platform}.zip")
+
+
+def _share_chrome_zip_ready(share_root: str, rem_platform: str, expected_version: str) -> bool:
+    """共享目录仅保留 VERSION + 各平台 zip 时，判断是否可用。"""
+    version_path = os.path.join(share_root, "VERSION")
+    if not os.path.isfile(version_path):
+        return False
+    try:
+        with open(version_path, "r", encoding="utf-8") as f:
+            if f.read().strip() != expected_version:
+                return False
+    except OSError:
+        return False
+    zpath = _chrome_headless_share_zip_path(share_root, rem_platform)
+    try:
+        return os.path.isfile(zpath) and os.path.getsize(zpath) > 0
+    except OSError:
+        return False
+
+
+def _extract_chrome_headless_zip_to_dest(zip_path: str, dest_root: str, rem_platform: str) -> None:
+    """将官方 headless shell zip 解压到 Remotion 缓存根目录下的平台子目录。"""
+    platform_dest = os.path.join(dest_root, rem_platform)
+    if os.path.isdir(platform_dest):
+        shutil.rmtree(platform_dest)
+    os.makedirs(dest_root, exist_ok=True)
+    with zipfile.ZipFile(zip_path, "r") as zf:
+        zf.extractall(platform_dest)
+
+
+def sync_chrome_headless_vendor(renderer_dir: str, render_plan: dict) -> None:
+    """
+    共享目录（默认 /tmp/agent-share/chrome-headless）只存 VERSION + chrome-headless-shell-<平台>.zip；
+    若 zip 与版本匹配则本地解压到 node_modules/.remotion/chrome-headless-shell/，否则从 OSS 下载，
+    成功后把 zip 写入共享目录（不存解压后的目录树）。
+
+    所有 progress / warning 经 stderr 打印；render_plan["logs"] 上记录关键事件。
+    """
+    if os.environ.get("REMOTION_SKIP_VENDOR_CHROME", "").strip().lower() in ("1", "true", "yes"):
+        render_plan["logs"].append({
+            "phase": "render",
+            "message": "Skipped Chrome Headless vendor sync (REMOTION_SKIP_VENDOR_CHROME)",
+            "timestamp": _now_iso(),
+        })
+        return
+
+    rem_platform = _detect_remotion_chrome_platform()
+    if not rem_platform:
+        _log("⚠️  无法识别本机以下载 Chrome Headless，Remotion 可能会尝试在线下载")
+        return
+
+    manifest = _load_chrome_vendor_manifest(renderer_dir)
+    if not manifest:
+        _log(
+            "⚠️  未找到 vendor-zip-urls.json（可用 REMOTION_CHROME_VENDOR_JSON 指定路径），"
+            "Remotion 可能会尝试在线下载"
+        )
+        return
+
+    zip_urls = manifest.get("zipUrls")
+    if not isinstance(zip_urls, dict):
+        zip_urls = {}
+    url = zip_urls.get(rem_platform)
+    if not url or not isinstance(url, str):
+        _log(f"⚠️  vendor-zip-urls.json 中未配置 {rem_platform} 的下载地址，Remotion 可能会尝试在线下载")
+        render_plan["logs"].append({
+            "phase": "render",
+            "message": f"No OSS zip URL for platform {rem_platform} in vendor manifest",
+            "timestamp": _now_iso(),
+        })
+        return
+
+    expected_version = (manifest.get("chromeVersion") or "").strip()
+    if not expected_version:
+        version_path = os.path.join(renderer_dir, "chrome-headless-vendor-template", "VERSION")
+        try:
+            with open(version_path, "r", encoding="utf-8") as f:
+                expected_version = f.read().strip()
+        except OSError:
+            expected_version = ""
+
+    if not expected_version:
+        _log("⚠️  无法确定 Chrome 版本（chromeVersion 或 VERSION），跳过 vendor 同步")
+        return
+
+    dest_root = os.path.join(renderer_dir, "node_modules", ".remotion", "chrome-headless-shell")
+    force = os.environ.get("REMOTION_FORCE_VENDOR_CHROME", "").strip().lower() in ("1", "true", "yes")
+    force = force or os.environ.get("REMOTION_FORCE_VENDOR_ZIP", "").strip().lower() in ("1", "true", "yes")
+
+    if not force and _vendor_chrome_headless_ready(dest_root, rem_platform, expected_version):
+        _log(f"ℹ️  已存在匹配的 Chrome Headless Shell（{expected_version}），跳过下载")
+        return
+
+    share_root = _resolve_chrome_share_root()
+    platform_dest = os.path.join(dest_root, rem_platform)
+    share_zip = _chrome_headless_share_zip_path(share_root, rem_platform)
+
+    if not force and _share_chrome_zip_ready(share_root, rem_platform, expected_version):
+        _log(f"ℹ️  共享目录已有 zip（{rem_platform} {expected_version}），跳过网络下载 → {share_zip}")
+        sys.stderr.flush()
+        try:
+            _extract_chrome_headless_zip_to_dest(share_zip, dest_root, rem_platform)
+        except (OSError, zipfile.BadZipFile) as e:
+            _log(f"❌ 从共享 zip 解压浏览器失败: {e}")
+            render_plan["logs"].append({
+                "phase": "render",
+                "message": f"Chrome Headless unzip from share zip failed: {e}",
+                "timestamp": _now_iso(),
+            })
+            return
+        try:
+            with open(os.path.join(dest_root, "VERSION"), "w", encoding="utf-8") as vf:
+                vf.write(expected_version + "\n")
+        except OSError as e:
+            _log(f"⚠️  写入 VERSION 失败: {e}")
+        _ensure_chrome_headless_shell_executable(dest_root, rem_platform)
+        render_plan["logs"].append({
+            "phase": "render",
+            "message": f"Installed Chrome Headless from share zip ({share_zip}, {expected_version})",
+            "timestamp": _now_iso(),
+        })
+        _log(f"✅ Chrome Headless Shell 已就绪: {dest_root}")
+        return
+
+    if os.path.isdir(platform_dest):
+        shutil.rmtree(platform_dest)
+
+    os.makedirs(dest_root, exist_ok=True)
+    _log(f"📦 正在从 OSS 下载 Chrome Headless Shell（{rem_platform}）…")
+    sys.stderr.flush()
+
+    fd, tmp_zip = tempfile.mkstemp(suffix=".zip", prefix="chrome-headless-vendor-")
+    os.close(fd)
+    download_ok = False
+    try:
+        try:
+            _log(f"   ⬇️  开始拉取浏览器包: {url.strip()}")
+            sys.stderr.flush()
+            _download_chrome_vendor_zip(url.strip(), tmp_zip)
+        except RuntimeError as e:
+            _log(f"❌ 下载内置浏览器失败: {e}")
+            render_plan["logs"].append({
+                "phase": "render",
+                "message": f"Chrome Headless vendor download failed: {e}",
+                "timestamp": _now_iso(),
+            })
+            return
+
+        try:
+            _extract_chrome_headless_zip_to_dest(tmp_zip, dest_root, rem_platform)
+            download_ok = True
+        except (OSError, zipfile.BadZipFile) as e:
+            _log(f"❌ 解压内置浏览器失败: {e}")
+            render_plan["logs"].append({
+                "phase": "render",
+                "message": f"Chrome Headless vendor unzip failed: {e}",
+                "timestamp": _now_iso(),
+            })
+            return
+    finally:
+        if download_ok:
+            try:
+                os.makedirs(share_root, exist_ok=True)
+                shutil.copy2(tmp_zip, share_zip)
+                with open(os.path.join(share_root, "VERSION"), "w", encoding="utf-8") as vf:
+                    vf.write(expected_version + "\n")
+                _log(f"   📁 已缓存 zip 到共享目录: {share_zip}")
+            except OSError as e:
+                _log(f"⚠️  写入共享 zip 失败（不影响渲染）: {e}")
+        try:
+            os.unlink(tmp_zip)
+        except OSError:
+            pass
+
+    try:
+        with open(os.path.join(dest_root, "VERSION"), "w", encoding="utf-8") as vf:
+            vf.write(expected_version + "\n")
+    except OSError as e:
+        _log(f"⚠️  写入 VERSION 失败: {e}")
+
+    _ensure_chrome_headless_shell_executable(dest_root, rem_platform)
+
+    render_plan["logs"].append({
+        "phase": "render",
+        "message": f"Synced Chrome Headless Shell from OSS ({rem_platform}, {expected_version})",
+        "timestamp": _now_iso(),
+    })
+    _log(f"✅ Chrome Headless Shell 已就绪: {dest_root}")

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

@@ -0,0 +1,174 @@
+"""Video duration probe — separated from render_video.py.
+
+screen-walkthrough 这种"按 TTS 时间轴 + 视频素材池"的模板需要知道远端视频的
+真实时长才能选出正确的 adaptStrategy（fit-exact / trim-and-speed / freeze-tail
+/ static-fallback）。这里给出三条策略，按速度排序：
+
+  1. 通过 mediaId（从 CDN URL 中切出）查 ab-api /file/get
+  2. HEAD 请求按 Content-Length 估算（粗略）
+  3. 下载前 2 MB 用 ffprobe 解析（精确但贵）
+
+公共入口只有一个：probe_video_duration(url) -> Optional[float]。
+"""
+from __future__ import annotations
+
+import builtins
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import urllib.error
+import urllib.request
+from datetime import datetime
+from typing import Optional
+
+
+def _log(msg: str) -> None:
+    now = datetime.now()
+    stamp = now.strftime("%Y%m%d %H%M%S") + f":{now.microsecond // 1000:03d}"
+    builtins.print(f"[{stamp}] {msg}", file=sys.stderr)
+
+
+def _extract_media_id_from_url(url: str) -> Optional[str]:
+    """Extract mediaId (vodVideoId) from CDN URL.
+
+    Supported formats:
+      - http://cdn.aibearer.com/{mediaId}/{hash}-ld.mp4
+      - https://cdn.aibearer.com/{mediaId}/...
+    """
+    try:
+        from urllib.parse import urlparse
+        parsed = urlparse(url)
+        parts = [p for p in parsed.path.split("/") if p]
+        if len(parts) >= 2:
+            candidate = parts[0]
+            if len(candidate) >= 16 and all(c in "0123456789abcdef" for c in candidate):
+                return candidate
+    except Exception:
+        pass
+    return None
+
+
+def _query_duration_from_api(url: str) -> Optional[float]:
+    """Query ab-api /file/get by mediaId to get the precise duration from database.
+
+    Returns duration in seconds, or None if query fails or duration not available.
+    """
+    media_id = _extract_media_id_from_url(url)
+    if not media_id:
+        return None
+
+    api_base = os.environ.get("MM_API_BASE_URL", os.environ.get("MM_BACKEND_API_URL", "")).rstrip("/")
+    if not api_base:
+        return None
+
+    priv_token = os.environ.get("PRIV_TOKEN", "").strip()
+    if not priv_token:
+        return None
+
+    try:
+        payload = json.dumps({"mediaId": media_id}).encode("utf-8")
+        req = urllib.request.Request(
+            f"{api_base}/file/get",
+            data=payload,
+            headers={
+                "Content-Type": "application/json",
+                "X-Priv-Token": priv_token,
+            },
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=5) as resp:
+            result = json.loads(resp.read().decode("utf-8"))
+
+        if result.get("code") != 0:
+            return None
+
+        data = result.get("data") or {}
+        duration = data.get("duration")
+        if duration is not None and duration > 0:
+            _log(f"   📡 视频时长（API查询）: {duration:.1f}s (mediaId={media_id[:12]}...)")
+            return float(duration)
+    except Exception:
+        pass
+
+    return None
+
+
+def probe_video_duration(url: str) -> Optional[float]:
+    """Probe the duration (in seconds) of a remote video URL.
+
+    Strategy (ordered by priority):
+      1. Query ab-api /file/get by mediaId extracted from CDN URL (fastest, most accurate).
+      2. HEAD request to estimate from Content-Length.
+      3. Download first 2MB + ffprobe (if available).
+
+    Returns duration in seconds, or None on failure.
+    """
+    api_duration = _query_duration_from_api(url)
+    if api_duration is not None:
+        return api_duration
+
+    content_length_estimate: Optional[float] = None
+    try:
+        req_head = urllib.request.Request(url, method="HEAD", headers={
+            "User-Agent": "Mozilla/5.0 (compatible; render-video/1.0)",
+        })
+        with urllib.request.urlopen(req_head, timeout=10) as resp:
+            content_length = int(resp.headers.get("Content-Length", 0))
+        if content_length > 0:
+            content_length_estimate = content_length / 62500.0
+    except Exception:
+        pass
+
+    tmp_path = None
+    try:
+        req = urllib.request.Request(url, headers={
+            "User-Agent": "Mozilla/5.0 (compatible; render-video/1.0)",
+            "Range": "bytes=0-2097151",
+        })
+        try:
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                data = resp.read()
+        except urllib.error.HTTPError as e:
+            if e.code == 416:
+                req2 = urllib.request.Request(url, headers={
+                    "User-Agent": "Mozilla/5.0 (compatible; render-video/1.0)",
+                })
+                with urllib.request.urlopen(req2, timeout=15) as resp:
+                    data = resp.read()
+            else:
+                raise
+
+        fd, tmp_path = tempfile.mkstemp(suffix=".mp4", prefix="probe-")
+        os.close(fd)
+        with open(tmp_path, "wb") as f:
+            f.write(data)
+
+        try:
+            result = subprocess.run(
+                ["ffprobe", "-v", "quiet", "-print_format", "json", "-show_format", tmp_path],
+                capture_output=True, text=True, timeout=10,
+            )
+            if result.returncode == 0:
+                info = json.loads(result.stdout)
+                dur = info.get("format", {}).get("duration")
+                if dur:
+                    return float(dur)
+        except (FileNotFoundError, OSError, subprocess.TimeoutExpired, json.JSONDecodeError, ValueError):
+            pass
+
+    except Exception as e:
+        _log(f"   ⚠️  视频时长探测失败: {e}")
+    finally:
+        if tmp_path and os.path.exists(tmp_path):
+            try:
+                os.unlink(tmp_path)
+            except OSError:
+                pass
+
+    if content_length_estimate is not None:
+        _log(f"   📐 视频时长估算（基于文件大小）: {content_length_estimate:.1f}s")
+        return content_length_estimate
+
+    return None

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

@@ -0,0 +1,86 @@
+"""VOD playback URL polling — separated from render_video.py.
+
+ab-render 通过远程渲染服务把视频上传到阿里云 VOD 后，会立即返回一个
+`vod://` 协议地址 + fileId。但前端需要的是 CDN 加速地址（`http://cdn.aibearer.com/...`），
+这要等阿里云转码回调到达 ab-api、回写 `file.fileUrl` 之后才能拿到。
+
+这个模块负责轮询 ab-api /file/get 直到拿到 CDN URL（或超时返回 OSS 原始地址）。
+公共入口只有一个：poll_vod_playback_url(file_id, priv_token, ...) -> Optional[str]。
+"""
+from __future__ import annotations
+
+import builtins
+import json
+import os
+import sys
+import time
+import urllib.error
+import urllib.request
+from datetime import datetime
+from typing import Optional
+
+
+def _log(msg: str) -> None:
+    now = datetime.now()
+    stamp = now.strftime("%Y%m%d %H%M%S") + f":{now.microsecond // 1000:03d}"
+    builtins.print(f"[{stamp}] {msg}", file=sys.stderr)
+
+
+def poll_vod_playback_url(
+    file_id: int,
+    private_token: str,
+    *,
+    max_wait: float = 60.0,
+    interval: float = 3.0,
+) -> Optional[str]:
+    """轮询 ab-api /file/get，等待 VOD CDN URL 就绪。
+
+    VOD 上传后通常 10-30 秒完成转码。此函数策略：
+      - 一旦看到非 `vod://` 且非阿里云 OSS 域名的 URL（说明 CDN 转码完成），立即返回
+      - 看到阿里云 OSS 直链时记为 fallback，继续等 CDN
+      - 超时仍未拿到 CDN 时退回到 OSS 原始地址
+    """
+    api_base = os.environ.get("MM_BACKEND_API_URL", "http://localhost:2999/api").rstrip("/")
+    url = f"{api_base}/file/get"
+    headers = {
+        "Content-Type": "application/json",
+        "X-Priv-Token": private_token,
+        "x-invoke-skill": "render-video",
+    }
+    agent_name = os.environ.get("AGENT_NAME", "")
+    if agent_name:
+        headers["x-invoke-agent"] = agent_name
+
+    payload = json.dumps({"fileId": int(file_id)}).encode("utf-8")
+
+    _log(f"   ⏳ 等待 VOD 播放地址就绪（fileId={file_id}，最长等待 {max_wait:.0f}s）...")
+    start = time.time()
+    oss_fallback: Optional[str] = None
+
+    while time.time() - start < max_wait:
+        try:
+            req = urllib.request.Request(url, data=payload, headers=headers, method="POST")
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                result = json.loads(resp.read().decode("utf-8"))
+
+            if result.get("code") == 0:
+                data = result.get("data") or {}
+                file_url = data.get("fileUrl")
+                vod_status = data.get("vodStatus", "")
+                if file_url and not file_url.startswith("vod://"):
+                    if "aliyuncs.com" not in file_url:
+                        return file_url
+                    oss_fallback = file_url
+                    elapsed = time.time() - start
+                    _log(f"   ⏳ VOD 状态: {vod_status}（等待 CDN 转码完成，{elapsed:.0f}s）")
+                else:
+                    elapsed = time.time() - start
+                    _log(f"   ⏳ VOD 状态: {vod_status}（{elapsed:.0f}s）")
+        except Exception:
+            pass
+
+        time.sleep(interval)
+
+    if oss_fallback:
+        _log(f"   ⚠️  等待 CDN 转码超时，返回原始 OSS 地址")
+    return oss_fallback