@remixmate/cli 0.9.26 → 0.9.28

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

@@ -1647,6 +1647,23 @@ def render_with_local_cli(render_plan: dict, output_path: str) -> bool:
         return False
 
 
+def _persist_plan_checkpoint(render_plan: dict, job_id: Optional[int], private_token: str) -> None:
+    """把当前 RenderPlan 存个档（尽力而为，失败只记日志）。
+
+    存在的唯一理由：远端 taskId 必须在**渲染结束之前**就落库。脚本可能在任何时刻
+    被外层超时 SIGTERM，那一刻没有任何机会写盘；只在流程末尾 save_plan 的话，
+    taskId 永远存不下来，"续跑"就无从谈起。
+    """
+    if not job_id:
+        return
+    try:
+        import render_job_client  # type: ignore
+        render_job_client.save_plan(job_id, json.dumps(render_plan, ensure_ascii=False), private_token)
+        LogPrint(f"   💾 RenderPlan checkpoint saved (jobId={job_id})", file=sys.stderr)
+    except Exception as exc:  # noqa: BLE001 — 存档失败不该让渲染本身失败
+        LogPrint(f"   ⚠️  RenderPlan checkpoint failed (jobId={job_id}): {exc}", file=sys.stderr)
+
+
 def render_with_remote_api(
     render_plan: dict,
     output_path: str,
@@ -1656,10 +1673,14 @@ def render_with_remote_api(
     poll_interval: float = 5.0,
     upload_title: Optional[str] = None,
     conversation_id: Optional[str] = None,
+    job_id: Optional[int] = None,
 ) -> bool:
     """Submit render to ab-api /tool/renderVideo and poll until completion.
 
     On success, writes upload.fileUrl into render_plan and skips local MP4 download.
+
+    job_id 用于中途存档（见 _persist_plan_checkpoint）：有它才能在被强杀后续跑，
+    没有则退化成旧行为（一次性，杀了就得重渲）。
     """
     import remote_renderer_client
 
@@ -1706,6 +1727,13 @@ def render_with_remote_api(
     # 内置模板即使带 sourceOssKey（builtin-template-registry 回填，仅服务
     # derive_template 派生），渲染仍走 ab-render 预构建的 /render，绝不走 /renderDraft，
     # 否则会用 OSS 上的旧快照 + DraftMainVideo 复刻渲染，与生产 MainVideo 漂移。
+    # 下面这套 payload 构造在"续跑既有任务"时其实用不上（见后面的 resuming 分支），
+    # 所以它的失败不该让续跑也跟着失败 —— 任务还在后端好好渲着。
+    pending_resume = bool(str(render_plan.get("remoteTaskId") or "").strip())
+    # 先给默认值：presign 失败时下面的分支不会走到，续跑分支仍要读 status_path。
+    render_path = "/render"
+    status_path = "/renderStatus"
+
     source_oss_key = None
     template_id = render_plan.get("templateId", "")
     if template_id:
@@ -1719,20 +1747,27 @@ def render_with_remote_api(
 
     if source_oss_key:
         import render_job_client  # type: ignore
+        tarball_url = None
         try:
             src = render_job_client.presign_template_source(template_id, private_token)
             tarball_url = src.get("tarballUrl")
             if not tarball_url:
                 raise RuntimeError(f"presignSource 未返回 tarballUrl: {src}")
         except Exception as exc:
-            LogPrint(f"❌ presignSource failed for private template {template_id}: {exc}", file=sys.stderr)
-            render_plan["status"] = "failed"
-            render_plan["errors"].append({
-                "phase": "render",
-                "message": f"presignSource failed: {exc}",
-                "timestamp": now_iso(),
-            })
-            return False
+            if pending_resume:
+                LogPrint(
+                    f"⚠️  presignSource failed ({exc}) — 但有待续跑的任务，忽略继续",
+                    file=sys.stderr,
+                )
+            else:
+                LogPrint(f"❌ presignSource failed for private template {template_id}: {exc}", file=sys.stderr)
+                render_plan["status"] = "failed"
+                render_plan["errors"].append({
+                    "phase": "render",
+                    "message": f"presignSource failed: {exc}",
+                    "timestamp": now_iso(),
+                })
+                return False
         payload = {
             "tarballUrl": tarball_url,
             "inputProps": input_props,
@@ -1759,8 +1794,10 @@ def render_with_remote_api(
         status_path = "/renderStatus"
 
     total_frames = config.get("totalFrames", 0)
-    LogPrint(f"🎬 Submitting remote render task...", file=sys.stderr)
-    if source_oss_key:
+    if pending_resume:
+        # 续跑：下面那堆"正在提交"的日志会误导人，跳过
+        LogPrint(f"🎬 Remote render task already exists, will resume polling", file=sys.stderr)
+    elif source_oss_key:
         LogPrint(f"   Private template (OSS dynamic bundle): {template_id}", file=sys.stderr)
     else:
         LogPrint(f"   Composition: {composition_id}", file=sys.stderr)
@@ -1770,28 +1807,54 @@ def render_with_remote_api(
     LogPrint(f"   total frames: {total_frames}", file=sys.stderr)
     sys.stderr.flush()
 
-    try:
-        task_id = remote_renderer_client.start_render(payload, private_token=private_token, conversation_id=conversation_id, path=render_path)
-    except Exception as exc:
-        LogPrint(f"❌ remote render submission failed: {exc}", file=sys.stderr)
-        render_plan["status"] = "failed"
-        render_plan["errors"].append({
+    # ─── 续跑既有任务 ────────────────────────────────────────────────────
+    # 上一次调用可能是被外层超时 SIGTERM 掉的（skill 执行有上限），而远端任务还在
+    # ab-render 上跑着。这时重新提交 = 白烧一遍渲染、并且大概率再次撞上同一个上限。
+    # 所以先看 plan 里有没有上次留下的 taskId：有就直接续着轮询。
+    #
+    # 只在"任务不可用"（已失败 / 查不到）时才退回重新提交 —— 轮询超时不算不可用，
+    # 那条路走 RemoteRenderTimeout，保留 taskId 交给下一次调用。
+    task_id = str(render_plan.get("remoteTaskId") or "").strip()
+    if task_id:
+        # 提交时用的状态端点存在 plan 里（内置模板 /renderStatus，私有模板
+        # /renderDraftStatus）。用存的那个，别依赖这次重新推导的结果。
+        status_path = render_plan.get("remoteStatusPath") or status_path
+        LogPrint(f"🔄 resuming existing remote task: taskId={task_id}", file=sys.stderr)
+        render_plan["logs"].append({
             "phase": "render",
-            "message": f"remote start_render failed: {exc}",
+            "message": f"Resuming remote task: {task_id}",
             "timestamp": now_iso(),
         })
-        return False
+    else:
+        try:
+            task_id = remote_renderer_client.start_render(payload, private_token=private_token, conversation_id=conversation_id, path=render_path)
+        except Exception as exc:
+            LogPrint(f"❌ remote render submission failed: {exc}", file=sys.stderr)
+            render_plan["status"] = "failed"
+            render_plan["errors"].append({
+                "phase": "render",
+                "message": f"remote start_render failed: {exc}",
+                "timestamp": now_iso(),
+            })
+            return False
 
-    LogPrint(f"   ✅ task submitted, taskId={task_id}", file=sys.stderr)
-    render_plan["remoteTaskId"] = task_id
-    render_plan["logs"].append({
-        "phase": "render",
-        "message": f"Remote task submitted: {task_id}",
-        "timestamp": now_iso(),
-    })
+        LogPrint(f"   ✅ task submitted, taskId={task_id}", file=sys.stderr)
+        render_plan["remoteTaskId"] = task_id
+        render_plan["remoteStatusPath"] = status_path
+        render_plan["remoteStartedAt"] = time.time()
+        render_plan["logs"].append({
+            "phase": "render",
+            "message": f"Remote task submitted: {task_id}",
+            "timestamp": now_iso(),
+        })
+        # **立刻落库**，不等渲染结束。被 SIGTERM 的那一刻脚本没有任何机会写盘，
+        # 所以 taskId 必须在这里就进 DB，否则下一次调用无从续起（这正是旧代码
+        # 只写内存、`remoteTaskId` 全程没人读的后果）。
+        _persist_plan_checkpoint(render_plan, job_id, private_token)
 
     last_progress = -1.0
-    render_start_time = time.time()
+    # 续跑时用提交时刻算 elapsed，否则 ETA 会按"刚开始"估，一上来就偏小。
+    render_start_time = float(render_plan.get("remoteStartedAt") or time.time())
 
     def _on_progress(status_data: dict):
         nonlocal last_progress
@@ -1834,9 +1897,32 @@ def render_with_remote_api(
             adaptive_interval=True,
             status_path=status_path,
         )
+    except remote_renderer_client.RemoteRenderTimeout as exc:
+        # 等不动了，但任务**没失败**。保留 taskId，让下一次调用接着轮询；
+        # 状态不写 failed（写了模型会当成"渲染失败"而重新走一遍完整流程）。
+        LogPrint(f"⏳ {exc}", file=sys.stderr)
+        render_plan["status"] = "rendering"
+        _persist_plan_checkpoint(render_plan, job_id, private_token)
+        render_plan["logs"].append({
+            "phase": "render",
+            "message": f"poll timeout, task still running: {task_id}",
+            "timestamp": now_iso(),
+        })
+        print(
+            f"\n⏳ 远端渲染仍在进行（taskId={task_id}）。"
+            f"用同一个 job_id 再调一次 render_video 即可续上，不会重新渲染。",
+            flush=True,
+        )
+        return False
     except Exception as exc:
         LogPrint(f"❌ remote render polling failed: {exc}", file=sys.stderr)
         render_plan["status"] = "failed"
+        # 任务确实不可用了（失败 / 查不到）。清掉 taskId，否则下一次调用会一直
+        # 去续一个永远好不了的任务，再也提交不了新的。
+        render_plan.pop("remoteTaskId", None)
+        render_plan.pop("remoteStatusPath", None)
+        render_plan.pop("remoteStartedAt", None)
+        _persist_plan_checkpoint(render_plan, job_id, private_token)
         render_plan["errors"].append({
             "phase": "render",
             "message": f"remote poll_render failed: {exc}",
@@ -2030,8 +2116,11 @@ Examples:
     parser.add_argument(
         "--remote-poll-timeout",
         type=float,
-        default=float(os.environ.get("REMOTION_REMOTE_POLL_TIMEOUT", "1800")),
-        help="Remote-render polling timeout (seconds, default 1800)",
+        default=float(os.environ.get("REMOTION_REMOTE_POLL_TIMEOUT", "2700")),
+        # 实测最长的一支约 30 分钟，加上 ab-render 排队要留余量，所以是 45 分钟。
+        # 这个值必须小于 ab-agent 侧 render_video 的 skill 超时（默认 50 分钟），
+        # 否则外层先 SIGTERM，这里这套"超时但保留 taskId"的续跑逻辑根本轮不到执行。
+        help="Remote-render polling timeout (seconds, default 2700)",
     )
     parser.add_argument(
         "--remote-poll-interval",
@@ -2405,6 +2494,7 @@ Examples:
             poll_interval=args.remote_poll_interval,
             upload_title=upload_title_hint,
             conversation_id=conversation_id,
+            job_id=args.job_id if args.save_job else None,
         )
     else:
         LogPrint(f"💻 Using local render mode", file=sys.stderr)

package/skills/web-read/SKILL.md

@@ -0,0 +1,146 @@
+---
+name: web-read
+description: |
+  Web-page reading skill — open a URL in a headless browser (Playwright Python) and get back the page's **main text**: title, headings, paragraphs, lists, code blocks and tables, as Markdown / plain text / structured JSON.
+  Boilerplate (nav, sidebar, comments, ads, footer) is stripped by a Readability-style pass, and JS-rendered pages work because a real browser runs the page first.
+
+  Text only. For a still screenshot (`.png` / `.jpg`) use web-screenshot / `web_screenshot`; for a recording (`.mp4` / `.webm`) use web-record / `web_record`.
+
+  Use this skill immediately whenever the user asks for any of:
+  - Read this link / what does this page say / summarize this article
+  - Fetch page content, extract the article text, get the text of a URL
+  - Use a web page as source material for a script, outline, or video
+  - Read a README / docs page / changelog / blog post
+  - Pull the code samples or the table out of a page
+  - Check what is behind a link before acting on it
+
+  Even when the user does not say "read", any request that needs the *content* of a URL (rather than a picture of it) should route here.
+triggers:
+  - Read this link / what does this page say / summarize this article
+  - Fetch page content, extract article text, get the text of a URL
+  - Use a web page as source material for a script or video
+  - Read a README / docs page / changelog / blog post
+  - Pull code samples or tables out of a page
+---
+
+# Web Read Skill (`web_read`)
+
+Turns a URL into text. Entry script **`read_page.py`**, pure Python, prints to **stdout**.
+
+> **Text only.** A screenshot is `web_screenshot`, a recording is `web_record`. Those two produce *files*; this one produces *content you can reason about*.
+
+**Script location**: this skill has no `scripts/` of its own — it reuses `read_page.py` and the `_media_screenshot/` package from the web-screenshot directory (`skill.json`'s `entry.scriptPath` points relatively at `../web-screenshot/scripts/read_page.py`). Everywhere the commands below say **`<ReadScript>`**, substitute:
+
+```
+<SkillDir>/../web-screenshot/scripts/read_page.py
+```
+
+> Path convention: read the system-injected `Base directory for this skill: <path>` as `<SkillDir>`. Never hardcode an absolute path.
+
+## Prerequisites
+
+- **Python 3.9+**
+- **The `playwright` pip package + the chromium engine**: the first run **bootstraps automatically** (`pip install playwright` + `playwright install chromium`).
+
+## Basic usage
+
+```bash
+python3 <ReadScript> --url "https://example.com/article/123"
+```
+
+Prints a Markdown document: an `# title` line, a `site · author · date · url` line, then the body. A one-line extraction diagnostic (`blocks / chars / container`) goes to **stderr**, so piping stdout gives you clean text.
+
+## Output formats
+
+```bash
+# Markdown (default) — headings, lists, ``` code fences, | tables |
+python3 <ReadScript> --url "https://docs.python.org/3/tutorial/introduction.html"
+
+# Plain text — no markup, for TTS or keyword work
+python3 <ReadScript> --url "https://example.com/post" --format text
+
+# JSON — typed blocks + metadata, for programmatic consumption
+python3 <ReadScript> --url "https://example.com/post" --format json
+```
+
+The JSON shape is `{url, status, metadata{title,byline,siteName,publishedTime,description,lang}, container, charCount, blocks[]}`, where each block is one of `heading` / `paragraph` / `quote` / `code` / `list` / `table` / `image` / `rule`. JSON is **never truncated** (half a JSON document is not a JSON document) — cap it with `--selector` instead.
+
+## Length control (read this before pointing it at a long page)
+
+`--max-chars` defaults to **20000** and cuts on a block boundary, appending an explicit `[truncated] 已显示 N / M 字符` notice. Nothing is silently dropped.
+
+```bash
+# Keep the whole document on disk, read a bounded slice now
+python3 <ReadScript> \
+  --url "https://example.com/very-long-guide" \
+  --max-chars 8000 \
+  --output "./guide.md"
+
+# No cap at all
+python3 <ReadScript> --url "https://example.com/post" --max-chars 0
+```
+
+## When the automatic extraction misses
+
+The container is picked by paragraph-density scoring, which is right on ordinary article/docs/blog pages and can miss on unusual layouts. In order of what to try:
+
+```bash
+# 1. Content renders late (SPA): wait for the real element
+python3 <ReadScript> --url "https://app.example.com/doc/1" --wait-for-selector "article.body"
+
+# 2. Still short: give it a fixed settle window
+python3 <ReadScript> --url "https://example.com/x" --settle-ms 3000
+
+# 3. Wrong part of the page: name the container yourself
+python3 <ReadScript> --url "https://example.com/x" --selector "#main-content"
+
+# 4. Behind a login
+python3 <ReadScript> --url "https://example.com/x" --storage-state "./auth.json"
+python3 <ReadScript> --url "https://example.com/x" --cookies '[{"name":"sid","value":"…","domain":"example.com","path":"/"}]'
+
+# 5. Site serves headless browsers a stub page
+python3 <ReadScript> --url "https://example.com/x" --user-agent "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36"
+```
+
+The stderr diagnostics tell you which case you are in: `⚠️ 整页有 N 字符，却只抽到 M` means the wrong container was chosen (→ `--selector`), while `⚠️ 这个页面几乎没有文本` means the page itself never rendered text (→ waiting, cookies, or user-agent).
+
+## Links and images
+
+Both are dropped by default, because they are noise for a summarize/rewrite task and they inflate the character budget.
+
+```bash
+# Keep links as [text](url) — when you need to follow them
+python3 <ReadScript> --url "https://example.com/index" --include-links
+
+# Keep images as ![alt](src) — when harvesting illustration URLs
+python3 <ReadScript> --url "https://example.com/post" --include-images
+```
+
+## Private addresses are refused
+
+`web_read` hands page text to a model, so by default it refuses URLs that resolve to private / loopback / link-local addresses (`localhost`, `10.*`, `169.254.169.254`, …). Reading an intranet page or a local dev server on purpose:
+
+```bash
+WEB_CAPTURE_ALLOW_PRIVATE_HOSTS=1 python3 <ReadScript> --url "http://localhost:5173/"
+```
+
+## Full flag list
+
+| Flag | Meaning |
+|---|---|
+| `-u, --url` | Target URL (required, http/https) |
+| `--format` | `markdown` (default) / `text` / `json` |
+| `--max-chars` | stdout cap, block-aligned (default 20000, `0` = unlimited) |
+| `--selector` | Extract only inside this CSS selector |
+| `--include-links` / `--include-images` | Keep `[text](url)` / `![alt](src)` |
+| `-o, --output` | Write the **full** text to a file (stdout stays capped) |
+| `--settle-ms` | Extra wait before extracting |
+| `--quiet` | Suppress the stderr diagnostic line |
+| `-b, --browser` | `chromium` (default) / `firefox` / `webkit` |
+| `--device`, `--viewport`, `--color-scheme`, `--user-agent` | Emulation |
+| `--wait-for-selector`, `--wait-for-timeout`, `--timeout` | Waiting |
+| `--storage-state`, `--cookies`, `--ignore-https-errors` | Session |
+
+## Exit codes
+
+`0` on success — including a page that legitimately has little text. Non-zero only for a refused URL, an unresolvable selector, or a navigation failure; each prints a single actionable line rather than a Python traceback.

package/skills/web-read/skill.json

@@ -0,0 +1,131 @@
+{
+  "name": "web-read",
+  "toolName": "web_read",
+  "tier": "tool",
+  "category": "consuming",
+  "title": "Web Page Reader",
+  "description": "Open any URL in a headless browser (Playwright Python) and return the page's MAIN TEXT — title, headings, paragraphs, lists, code blocks and tables — as Markdown, plain text, or structured JSON. Boilerplate (nav / sidebar / comments / ads / footer) is stripped by a Readability-style pass, and JS-rendered pages work because a real browser runs the page. This is the tool to use whenever you need to KNOW WHAT A PAGE SAYS: summarizing an article, pulling source material for a script, reading a README or docs page, checking what a link contains. It returns text, not pictures — for a screenshot (png/jpg) use web_screenshot, for a recording (mp4/webm) use web_record. Output is capped by max_chars (default 20000) and truncated on a block boundary; pass an `output` path to keep the full text on disk.",
+  "auth": "none",
+  "envVars": [
+    "WEB_CAPTURE_BROWSER",
+    "WEB_CAPTURE_ALLOW_PRIVATE_HOSTS",
+    "PLAYWRIGHT_BROWSERS_PATH"
+  ],
+  "entry": {
+    "type": "python",
+    "scriptPath": "../web-screenshot/scripts/read_page.py"
+  },
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "url": {
+        "type": "string",
+        "description": "Target page URL (http/https). Private / loopback / link-local addresses are refused unless WEB_CAPTURE_ALLOW_PRIVATE_HOSTS=1."
+      },
+      "format": {
+        "type": "string",
+        "enum": ["markdown", "text", "json"],
+        "description": "markdown (default: keeps headings, lists, code fences, tables) | text (plain) | json (structured blocks + metadata, not truncated)"
+      },
+      "max_chars": {
+        "type": "number",
+        "description": "Cap on the printed text, cut at a block boundary with an explicit [truncated] notice (default 20000, 0 = unlimited). Raise it when you need the whole document; a very long page will otherwise fill your context."
+      },
+      "selector": {
+        "type": "string",
+        "description": "Read only inside this CSS selector. Leave empty to auto-detect the article container — only reach for this when the auto-detected container was wrong."
+      },
+      "include_links": {
+        "type": "boolean",
+        "description": "Keep hyperlinks as [text](url) instead of plain text. Useful when you need to follow links from the page."
+      },
+      "include_images": {
+        "type": "boolean",
+        "description": "Keep images as ![alt](src). Useful for harvesting illustration URLs out of an article."
+      },
+      "output": {
+        "type": "string",
+        "description": "Also write the FULL (untruncated) text to this local path. stdout still respects max_chars — use this when a long page must be kept for later steps."
+      },
+      "settle_ms": {
+        "type": "number",
+        "description": "Extra wait before extracting, in ms. Raise for pages that render content late."
+      },
+      "wait_for_selector": {
+        "type": "string",
+        "description": "Wait for this CSS selector before extracting (the reliable fix for JS-rendered content)"
+      },
+      "wait_for_timeout": {
+        "type": "number",
+        "description": "Fixed wait before extracting, in ms"
+      },
+      "device": {
+        "type": "string",
+        "description": "Device emulation name, e.g. 'iPhone 15 Pro' — some sites serve a leaner page to mobile"
+      },
+      "viewport": {
+        "type": "string",
+        "description": "Viewport as 'width,height', e.g. '1280,800'"
+      },
+      "color_scheme": {
+        "type": "string",
+        "enum": ["light", "dark", "no-preference"],
+        "description": "Emulate prefers-color-scheme"
+      },
+      "user_agent": {
+        "type": "string",
+        "description": "Override the User-Agent (try this when a site blocks headless browsers)"
+      },
+      "timeout": {
+        "type": "number",
+        "description": "Global Playwright action timeout in ms"
+      },
+      "ignore_https_errors": {
+        "type": "boolean",
+        "description": "Ignore HTTPS certificate errors"
+      },
+      "storage_state": {
+        "type": "string",
+        "description": "Path to a Playwright storageState JSON file (logged-in session)"
+      },
+      "cookies": {
+        "type": "string",
+        "description": "Playwright cookies as a JSON string or a path to a JSON file (top level is an array)"
+      },
+      "browser": {
+        "type": "string",
+        "enum": ["chromium", "firefox", "webkit"],
+        "description": "Browser engine (default chromium)"
+      },
+      "quiet": {
+        "type": "boolean",
+        "description": "Suppress the extraction diagnostics on stderr"
+      }
+    },
+    "required": ["url"]
+  },
+  "ui": {
+    "primary": ["url", "format", "max_chars"],
+    "advanced": [
+      "selector",
+      "include_links",
+      "include_images",
+      "wait_for_selector",
+      "settle_ms",
+      "device",
+      "viewport",
+      "color_scheme",
+      "timeout"
+    ],
+    "hidden": [
+      "output",
+      "quiet",
+      "user_agent",
+      "ignore_https_errors",
+      "storage_state",
+      "cookies",
+      "browser",
+      "wait_for_timeout"
+    ]
+  }
+}

package/skills/web-screenshot/scripts/_media_screenshot/__init__.py

@@ -6,12 +6,14 @@ package is implementation detail.
 from __future__ import annotations
 
 from . import cli_args, scenes, template, trim
+from .reader import do_read
 from .recording import do_record
 from .screenshot import do_screenshot
 from .storyboard import do_storyboard
 
 __all__ = [
     "cli_args",
+    "do_read",
     "do_record",
     "do_screenshot",
     "do_storyboard",