@remixmate/cli 0.9.25 → 0.9.27

package/skills/gen-voice/skill.json

@@ -25,7 +25,7 @@
       },
       "voice_id": {
         "type": "string",
-        "description": "Voice id. Default 'Chinese (Mandarin)_Male_Announcer'. When unsure, call with list_voices=true first to see what's available — do not invent ids."
+        "description": "Voice id. Default 'Chinese (Mandarin)_Male_Announcer'. When unsure, call with list_voices=true first to see what's available — do not invent ids, and do not declare a voice unavailable unless it is missing from that list."
       },
       "speed": {
         "type": "number",
@@ -33,11 +33,7 @@
       },
       "list_voices": {
         "type": "boolean",
-        "description": "List available voices and exit"
-      },
-      "local": {
-        "type": "boolean",
-        "description": "Used together with list_voices=true: print the voice-resolver fallback catalog with language tags (no remote /voice/page call). Output is one '<id>\\t<lang>\\t<name>' line per voice."
+        "description": "List the available voices and exit. This queries the live voice service and is the authoritative catalog — one call is enough, and its absence from this list is the only evidence that a voice id is invalid."
       },
       "json_output": {
         "type": "boolean",
@@ -56,8 +52,7 @@
     ],
     "hidden": [
       "json_output",
-      "list_voices",
-      "local"
+      "list_voices"
     ]
   }
 }

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

@@ -159,6 +159,22 @@ RESOLUTION_MAP = {
 }
 
 
+def _narration_speed(narration: dict) -> Optional[float]:
+    """Read a narration block's speech-rate multiplier, or None when unset.
+
+    Tolerant on purpose: the DSL is hand-editable, and a malformed speed must
+    not take down a render that would otherwise be fine — it falls back to the
+    voice's own pace. 0 and negatives are treated as unset for the same reason
+    ab-api does (`speed: 0` there means "follow the global setting").
+    """
+    if not isinstance(narration, dict):
+        return None
+    raw = narration.get("speed")
+    if isinstance(raw, bool) or not isinstance(raw, (int, float)):
+        return None
+    return float(raw) if raw > 0 else None
+
+
 def extract_narration_lines(narration: dict) -> Optional[tuple[list[str], int, list[Optional[float]]]]:
     """If narration uses the structured {intro, items, outro} form, return
     (lines, intro_line_count, at_sec_list). `at_sec_list` is parallel to
@@ -621,6 +637,8 @@ def build_render_plan(dsl: dict, binding: dict) -> dict:
     # so adjust_timeline_to_audio can later auto-derive highlightMap from
     # per-line TTS timestamps.
     dsl_assets_by_id = {a["assetId"]: a for a in dsl.get("assets", [])}
+    global_narration = (dsl.get("global") or {}).get("narration") or {}
+    global_speed = _narration_speed(global_narration)
     for scene in dsl.get("scenes", []):
         narration = (scene.get("audio") or {}).get("narration") or {}
         ref = narration.get("assetRef")
@@ -628,6 +646,15 @@ def build_render_plan(dsl: dict, binding: dict) -> dict:
         if not asset:
             continue
         payload = asset.setdefault("payload", {})
+        # Speech rate follows the same route as the narration text: single source
+        # of truth on the DSL, copied down here because resolve_asset_audio only
+        # ever sees the asset. Scene-level overrides global (mirrors the narration
+        # editor's "行级覆盖 > 全局"); neither set = gen-voice's own 1.0 default.
+        speed = _narration_speed(narration)
+        if speed is None:
+            speed = global_speed
+        if speed is not None:
+            payload["speed"] = speed
         extracted = extract_narration_lines(narration)
         if extracted:
             lines, intro_lines, _ = extracted
@@ -862,6 +889,11 @@ def resolve_asset_audio(asset: dict, private_token: str, timeout: int) -> dict:
     cmd.extend(["--text", tts_text, "--json-output"])
     if payload.get("voiceId"):
         cmd.extend(["--voice-id", payload["voiceId"]])
+    # Injected by build_render_plan from the DSL (scene narration > global).
+    # Absent = let gen-voice apply its own default rather than pinning 1.0 here.
+    speed = _narration_speed(payload)
+    if speed is not None:
+        cmd.extend(["--speed", str(speed)])
     if private_token:
         cmd.extend(["--priv-token", private_token])
 

package/skills/render-video/version.json

@@ -2,6 +2,6 @@
   "skillName": "render-video",
   "repoName": "agent-skill-media-maker",
   "skillId": "473",
-  "version": "V19",
+  "version": "V20",
   "skillDescription": "Final-render skill: loads a persisted RenderPlan by `job_id` and drives the Remotion engine to produce the final video.\n\nUse this skill as soon as the user mentions any of these intents (after assets are already prepared):\n- Render the video, composite the video, export the video\n- Turn the prepared assets into the final clip\n- Render with Remotion\n\nPrerequisite: assets must already be generated via `prepare_video_assets`. This skill never resolves or regenerates assets — pass it a `job_id` from a previous `prepare_video_assets` call.\n\n⚠️ Stop-and-confirm gate: never call this skill until the user has explicitly confirmed the assets prepared by `prepare_video_assets`. If those assets were prepared in the current turn and the user has not replied since, stop and ask instead of rendering."
 }

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",