@remixmate/cli 0.12.1 → 0.12.3

package/dist/manifest.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
-  "version": "0.12.1",
-  "generatedAt": "2026-10-12T11:13:40.014Z",
+  "version": "0.12.3",
+  "generatedAt": "2026-10-12T14:16:45.020Z",
   "skills": [
     {
       "id": "doc-parse",
@@ -556,7 +556,11 @@
         "properties": {
           "topic": {
             "type": "string",
-            "description": "Video topic (required)"
+            "description": "Video topic (required, except with list_fonts=true)"
+          },
+          "list_fonts": {
+            "type": "boolean",
+            "description": "List the font library and exit — no script is generated and no other parameter is needed. Returns each font's id, display name, language and category from the live library; this is the complete set of valid font_id values. Call it when the user asks which fonts are available, or wants a font but has not given its id."
           },
           "duration": {
             "type": "number",
@@ -592,7 +596,7 @@
           },
           "font_id": {
             "type": "string",
-            "description": "Font library key (font.uniq_id) for the on-screen text and subtitles. Written to global.font.fontId; match_template folds it into the binding's typography and ab-render resolves and installs the real font before rendering. **Must** pass when the user picked a font: the replicate card shows it as `名字（id）`, e.g. `字体: <名字>（<uniqId>）` → pass the id in the parentheses. Pass the opaque key, never a CSS family name or the display name — those fall back to the template font with no error. Without it the choice is silently dropped and the video renders in the template's own font. Omit to follow the template's font pairing."
+            "description": "Font library key (font.uniq_id) for the on-screen text and subtitles. Written to global.font.fontId; match_template folds it into the binding's typography and ab-render resolves and installs the real font before rendering. **Must** pass when the user picked a font: the replicate card shows it as `名字（id）`, e.g. `字体: <名字>（<uniqId>）` → pass the id in the parentheses. Pass the opaque key, never a CSS family name or the display name — those fall back to the template font with no error. When the user names a font without its id, call gen_script with list_fonts=true first and take the id from that list; do not invent ids. Without it the choice is silently dropped and the video renders in the template's own font. Omit to follow the template's font pairing."
           },
           "font_name": {
             "type": "string",
@@ -691,6 +695,7 @@
           "background_preset",
           "font_id",
           "font_name",
+          "list_fonts",
           "template_id",
           "template_source",
           "template_candidates",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remixmate/cli",
-  "version": "0.12.1",
+  "version": "0.12.3",
   "description": "AI media generation skills for Claude Code / Codex — 12 skills covering image, video, voice, digital human, web screenshot, web recording, script, template registry, rendering, Jianying export, and video deconstruction.",
   "type": "module",
   "main": "dist/index.js",

package/skills/gen-script/SKILL.md

@@ -477,6 +477,7 @@ python3 <SkillDir>/scripts/gen_script.py \
 | `--background-preset` | Scene background preset, one of the template's `customPayloadSchema.background.preset` values. Written to every scene's `customPayload.background.preset` (other keys of the template's default background are kept). Pass it whenever the user picked a background, e.g. `背景样式: 纯色（solid）` → `solid`. `image` / `video` also need `customPayload.background.assetRef`. Requires `--template-id`; unsupported values are rejected. | template default |
 | `--font-id` | Font library key (`font.uniq_id`), written to `global.font.fontId`; ab-render resolves and installs the real font at render time. Pass it whenever the user picked a font — the replicate card shows it as `名字（id）`, e.g. `字体: <名字>（<uniqId>）`; pass the id in the parentheses. Never pass a CSS family or the display name: an unknown key falls back to the template font with no error. | template font |
 | `--font-name` | Display name of the picked font → `global.font.fontName` (display only, never used for rendering). Pass it with `--font-id`. | — |
+| `--list-fonts` | Print the live font library (`/font/page`: id, name, lang, category, license) and exit; no script is generated and `--topic` is not needed. The ids it prints are the only valid `--font-id` values — use it when the user asks which fonts exist or names a font without its id. | — |
 | `--template-source` | How `--template-id` was chosen: `user-explicit` / `user-confirmed` / `auto`, written to `meta.templateSelection.source`. `auto` is refused — confirm with the user first (see "Agent behavior: template selection comes before the script"). Omitted = not recorded, with a stderr notice. Requires `--template-id`. | — |
 | `--template-candidates` | Repeatable. Template ids offered to the user, recommended first → `meta.templateSelection.candidates`. With `user-confirmed`, `--template-id` must be one of them. | — |
 | `--allow-digital-human` | Whether to allow digital-human assets. | off |

package/skills/gen-script/scripts/font_catalog.py

@@ -0,0 +1,133 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import urllib.error
+import urllib.request
+
+_DEFAULT_API_BASE_URL = "https://api.remixmate.ai/api"
+_PAGE_SIZE = 100
+_MAX_PAGES = 10
+_TIMEOUT_SEC = 30
+
+
+class FontCatalogError(RuntimeError):
+    pass
+
+
+def _api_base_url() -> str:
+
+    return (
+        os.environ.get("MM_API_BASE_URL", "").strip()
+        or os.environ.get("MM_BACKEND_API_URL", "").strip()
+        or _DEFAULT_API_BASE_URL
+    ).rstrip("/")
+
+
+def _post(path: str, payload: dict) -> dict:
+    url = f"{_api_base_url()}{path}"
+    headers = {"Content-Type": "application/json", "x-invoke-skill": "gen-script"}
+    token = os.environ.get("PRIV_TOKEN", "").strip()
+    if token:
+        headers["X-Priv-Token"] = token
+    req = urllib.request.Request(
+        url, data=json.dumps(payload).encode("utf-8"), headers=headers, method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=_TIMEOUT_SEC) as resp:
+            result = json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as exc:
+        raise FontCatalogError(f"HTTP {exc.code} from {path}") from exc
+    except urllib.error.URLError as exc:
+        raise FontCatalogError(f"network request failed ({path}): {exc.reason}") from exc
+    except ValueError as exc:
+        raise FontCatalogError(f"invalid JSON from {path}") from exc
+
+
+    if result.get("code") != 0:
+        msg = result.get("msg") or result.get("message") or "unknown error"
+        raise FontCatalogError(f"API returned an error [{path}]: {msg}")
+    return result.get("data") or {}
+
+
+def fetch_fonts() -> list[dict]:
+
+    fonts: list[dict] = []
+    for current in range(1, _MAX_PAGES + 1):
+        data = _post("/font/page", {"current": current, "pageSize": _PAGE_SIZE})
+        page = data.get("list") or []
+        fonts.extend(page)
+        total = (data.get("pager") or {}).get("total")
+        if not page or len(page) < _PAGE_SIZE:
+            break
+        if isinstance(total, int) and len(fonts) >= total:
+            break
+    return fonts
+
+
+def _row(font: dict) -> dict:
+    return {
+        "fontId": font.get("uniqId") or "",
+        "fontName": font.get("name") or "",
+        "lang": font.get("lang") or "",
+        "category": font.get("category") or "",
+        "license": font.get("license") or "",
+    }
+
+
+def format_fonts(fonts: list[dict]) -> str:
+
+    if not fonts:
+        return (
+            "⚠️  No fonts available in the font library. "
+            "Omit font_id to keep the template's own font.\n"
+        )
+    rows = [_row(f) for f in fonts]
+    id_w = max(len("Font ID"), *(len(r["fontId"]) for r in rows))
+    name_w = max(len("Name"), *(len(r["fontName"]) for r in rows))
+    lines = [
+        "",
+        f"{'Font ID'.ljust(id_w)}  {'Name'.ljust(name_w)}  Lang  Category  License",
+        f"{'-' * id_w}  {'-' * name_w}  ----  --------  -------",
+    ]
+    for r in rows:
+        lines.append(
+            f"{r['fontId'].ljust(id_w)}  {r['fontName'].ljust(name_w)}  "
+            f"{r['lang'].ljust(4)}  {r['category'].ljust(8)}  {r['license']}"
+        )
+    lines += [
+        "",
+        f"{len(rows)} font(s) available. This is the live library and the complete set.",
+        "💡 Pass --font-id <Font ID> --font-name <Name> to gen_script.",
+        "",
+    ]
+    return "\n".join(lines)
+
+
+def print_font_catalog() -> int:
+
+    try:
+        fonts = fetch_fonts()
+    except FontCatalogError as exc:
+        print(f"❌ failed to list fonts: {exc}", file=sys.stderr)
+        return 1
+    sys.stdout.write(format_fonts(fonts))
+    return 0

package/skills/gen-script/scripts/gen_script.py

@@ -2063,14 +2063,21 @@ Examples:
         "--font-id",
         default=None,
         help=(
-            "Font family key from the font library (font.uniq_id, e.g. zzgf-xi-mai). "
-            "Omit to follow the template's own font pairing. "
+            "Font family key from the font library (font.uniq_id); run --list-fonts to see "
+            "the valid keys. Omit to follow the template's own font pairing. "
             "Pass the opaque key, NOT a CSS family name: the family name is a rendering "
             "detail resolved by ab-render; a mistyped family name silently falls back to "
             "the default font with no error."
         ),
     )
     parser.add_argument("--font-name", default=None, help="Human-readable font name. Logged and stored for display only; never used for rendering.")
+    parser.add_argument(
+        "--list-fonts",
+        action="store_true",
+        help="List the font library (font id, name, lang, category) from ab-api and exit. "
+             "No script is generated and --topic is not needed. The ids printed here are "
+             "the only valid values for --font-id.",
+    )
     parser.add_argument(
         "--variant", default=None,
         help="Template visual variant id (a key of the template's `variants`, listed as variantIds by "
@@ -2167,6 +2174,12 @@ Examples:
 
     args = parser.parse_args()
 
+
+
+    if args.list_fonts:
+        from font_catalog import print_font_catalog
+        sys.exit(print_font_catalog())
+
     if args.validate:
         if not args.input:
             print("❌ validate mode requires --input", file=sys.stderr)

package/skills/gen-script/skill.json

@@ -18,7 +18,11 @@
     "properties": {
       "topic": {
         "type": "string",
-        "description": "Video topic (required)"
+        "description": "Video topic (required, except with list_fonts=true)"
+      },
+      "list_fonts": {
+        "type": "boolean",
+        "description": "List the font library and exit — no script is generated and no other parameter is needed. Returns each font's id, display name, language and category from the live library; this is the complete set of valid font_id values. Call it when the user asks which fonts are available, or wants a font but has not given its id."
       },
       "duration": {
         "type": "number",
@@ -54,7 +58,7 @@
       },
       "font_id": {
         "type": "string",
-        "description": "Font library key (font.uniq_id) for the on-screen text and subtitles. Written to global.font.fontId; match_template folds it into the binding's typography and ab-render resolves and installs the real font before rendering. **Must** pass when the user picked a font: the replicate card shows it as `名字（id）`, e.g. `字体: <名字>（<uniqId>）` → pass the id in the parentheses. Pass the opaque key, never a CSS family name or the display name — those fall back to the template font with no error. Without it the choice is silently dropped and the video renders in the template's own font. Omit to follow the template's font pairing."
+        "description": "Font library key (font.uniq_id) for the on-screen text and subtitles. Written to global.font.fontId; match_template folds it into the binding's typography and ab-render resolves and installs the real font before rendering. **Must** pass when the user picked a font: the replicate card shows it as `名字（id）`, e.g. `字体: <名字>（<uniqId>）` → pass the id in the parentheses. Pass the opaque key, never a CSS family name or the display name — those fall back to the template font with no error. When the user names a font without its id, call gen_script with list_fonts=true first and take the id from that list; do not invent ids. Without it the choice is silently dropped and the video renders in the template's own font. Omit to follow the template's font pairing."
       },
       "font_name": {
         "type": "string",
@@ -147,6 +151,7 @@
       "background_preset",
       "font_id",
       "font_name",
+      "list_fonts",
       "template_id",
       "template_source",
       "template_candidates",

package/skills/gen-script/version.json

@@ -2,6 +2,6 @@
   "skillName": "gen-script",
   "repoName": "agent-skill-media-maker",
   "skillId": "474",
-  "version": "V20",
+  "version": "V21",
   "skillDescription": "Video-script generation skill. Turns a user-supplied topic into a structured Video DSL (JSON) that describes the full video — scene structure, asset requirements, and narrative flow.\n\nUse this skill as soon as the user mentions any of these intents:\n- Write a video script, generate a video script, plan a video, write storyboards\n- Create a short video, plan video content, generate a Video DSL\n- Turn a topic into a video structure / video content plan\n\nEven when the user does not say \"generate the DSL\", use this skill whenever they want to turn a topic into a structured video plan.\n\n⚠️ Stop-and-confirm gate: after this skill returns a DSL, show the full script and wait for the user's explicit confirmation. Never call `prepare_video_assets` in the same turn."
 }

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

@@ -2671,27 +2671,39 @@ Examples:
 
 
         if args.dsl_json:
+
+
+
+
+
+
             try:
+                dsl = json.loads(args.dsl_json)
+            except json.JSONDecodeError:
+                dsl = None
+            if dsl is None:
+                try:
 
-                _dsl_str = args.dsl_json
-
-                _dsl_str = _dsl_str.replace('\u201c', '"').replace('\u201d', '"')
-                _dsl_str = _dsl_str.replace('\u2018', "'").replace('\u2019', "'")
-
-                _dsl_str = _dsl_str.replace('\uff1a', ':')
-                _dsl_str = _dsl_str.replace('\uff0c', ',')
-                _dsl_str = _dsl_str.replace('\uff08', '(')
-                _dsl_str = _dsl_str.replace('\uff09', ')')
-                _dsl_str = _dsl_str.replace('\u3010', '[')
-                _dsl_str = _dsl_str.replace('\u3011', ']')
-                _dsl_str = _dsl_str.replace('\uff3b', '[')
-                _dsl_str = _dsl_str.replace('\uff3d', ']')
-                _dsl_str = _dsl_str.replace('\uff5b', '{')
-                _dsl_str = _dsl_str.replace('\uff5d', '}')
-                dsl = json.loads(_dsl_str)
-            except json.JSONDecodeError as e:
-                LogPrint(f"❌ --dsl-json parse failed: {e}", file=sys.stderr)
-                sys.exit(1)
+                    _dsl_str = args.dsl_json
+
+                    _dsl_str = _dsl_str.replace('\u201c', '"').replace('\u201d', '"')
+                    _dsl_str = _dsl_str.replace('\u2018', "'").replace('\u2019', "'")
+
+                    _dsl_str = _dsl_str.replace('\uff1a', ':')
+                    _dsl_str = _dsl_str.replace('\uff0c', ',')
+                    _dsl_str = _dsl_str.replace('\uff08', '(')
+                    _dsl_str = _dsl_str.replace('\uff09', ')')
+                    _dsl_str = _dsl_str.replace('\u3010', '[')
+                    _dsl_str = _dsl_str.replace('\u3011', ']')
+                    _dsl_str = _dsl_str.replace('\uff3b', '[')
+                    _dsl_str = _dsl_str.replace('\uff3d', ']')
+                    _dsl_str = _dsl_str.replace('\uff5b', '{')
+                    _dsl_str = _dsl_str.replace('\uff5d', '}')
+                    dsl = json.loads(_dsl_str)
+                    LogPrint("⚠️  --dsl-json was not valid JSON; parsed after normalizing full-width punctuation", file=sys.stderr)
+                except json.JSONDecodeError as e:
+                    LogPrint(f"❌ --dsl-json parse failed: {e}", file=sys.stderr)
+                    sys.exit(1)
         else:
             if not os.path.exists(args.dsl):
                 LogPrint(f"❌ file does not exist: {args.dsl}", file=sys.stderr)

package/skills/render-video/version.json

@@ -2,6 +2,6 @@
   "skillName": "render-video",
   "repoName": "agent-skill-media-maker",
   "skillId": "473",
-  "version": "V37",
+  "version": "V38",
   "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."
 }