@remixmate/cli 0.1.0 → 0.1.2

package/skills/gen-video/scripts/gen_video.py

@@ -1,591 +0,0 @@
-#!/usr/bin/env python3
-"""
-AI 生视频脚本 — 调用 ab-api POST /model/genVideo（与前端灵创「AI 视频」、GenVideoParams 对齐）
-通过 priv-token（X-Priv-Token）认证。
-
-支持模型（与 frontend ab-web AI_VIDEO_MODELS 一致）:
-  - Seedance 1.5 Pro（火山）：有声、首尾帧、固定镜头、adaptive 比例，时长 4–12 秒
-  - Veo 3.1 / Veo 3.1 Fast（Google）：首尾帧、参考图、负向提示词、4K，时长 4/6/8 秒
-
-默认行为:
-  生成完成后直接输出视频 URL，供调用方直接展示，无需落盘。
-
-用法:
-  python gen_video.py --prompt "视频描述" --duration 5 --ratio "9:16"
-  python gen_video.py --model veo-3.1 --prompt "..." --duration 8 --resolution 4k
-  python gen_video.py --first-frame ./a.png --last-frame ./b.png --prompt "过渡动画"
-
-手动配置（命令行，优先级高于环境变量）:
-  --priv-token TOKEN   priv-token
-
-视频生成为异步任务，脚本会自动轮询直到完成或超时。
-
-环境变量:
-  MM_API_BASE_URL  - 后端 API 地址（默认: http://localhost:3001/api）
-  PRIV_TOKEN       - priv-token（优先读取；未配置时提示手动输入）
-  MM_VIDEO_MODEL   - 生视频模型（默认: doubao-seedance-1-5-pro-251215）
-"""
-
-from __future__ import annotations
-
-import argparse
-import base64
-import json
-import mimetypes
-import os
-import sys
-import time
-import urllib.error
-import urllib.request
-
-API_BASE_URL = os.environ.get("MM_API_BASE_URL", "http://localhost:3001/api")
-PRIVATE_TOKEN = ""  # 在 main() 中通过 resolve_token() 初始化
-VIDEO_MODEL = os.environ.get("MM_VIDEO_MODEL", "doubao-seedance-1-5-pro-251215")
-SKILL_NAME = "gen-video"
-AGENT_NAME = os.environ.get("AGENT_NAME", "")
-
-# 与 frontend AI_VIDEO_MODELS 一致的 LiteLLM / 网关 model 标识（元组: model_id, 展示名, 提供方）
-GEN_VIDEO_MODEL_PRESETS: tuple[tuple[str, str, str], ...] = (
-    ("doubao-seedance-1-5-pro-251215", "Seedance 1.5 Pro", "火山引擎"),
-    ("veo-3.1-generate-001", "Veo 3.1", "Google"),
-    ("veo-3.1-fast-generate-001", "Veo 3.1 Fast", "Google"),
-)
-
-# 命令行简写 -> 完整 model id（便于与前端下拉选项对应）
-MODEL_ALIASES: dict[str, str] = {
-    "seedance": "doubao-seedance-1-5-pro-251215",
-    "seedance-1.5": "doubao-seedance-1-5-pro-251215",
-    "seedance-1.5-pro": "doubao-seedance-1-5-pro-251215",
-    "veo": "veo-3.1-generate-001",
-    "veo-3.1": "veo-3.1-generate-001",
-    "veo-3.1-generate": "veo-3.1-generate-001",
-    "veo-fast": "veo-3.1-fast-generate-001",
-    "veo-3.1-fast": "veo-3.1-fast-generate-001",
-    "veo-3.1-fast-generate": "veo-3.1-fast-generate-001",
-}
-
-# Seedance：ratio + resolution（与前端 supported* 一致）
-SEEDANCE_RATIOS = ("adaptive", "16:9", "4:3", "1:1", "3:4", "9:16", "21:9")
-SEEDANCE_RESOLUTIONS = ("480p", "720p", "1080p")
-SEEDANCE_DURATIONS = tuple(range(4, 13))
-
-# Veo
-VEO_RATIOS = ("16:9", "9:16")
-VEO_RESOLUTIONS = ("720p", "1080p", "4k")
-VEO_DURATIONS = (4, 6, 8)
-VEO_MAX_REFERENCE_IMAGES = 3
-
-# 并集（用于 argparse choices，具体合法性在 main 中按模型校验）
-ALL_RATIOS = tuple(dict.fromkeys(SEEDANCE_RATIOS + VEO_RATIOS))
-ALL_RESOLUTIONS = tuple(dict.fromkeys(SEEDANCE_RESOLUTIONS + VEO_RESOLUTIONS))
-
-
-def resolve_token() -> str:
-    """优先从 PRIV_TOKEN 环境变量读取 token，取不到则报错退出"""
-    token = os.environ.get("PRIV_TOKEN", "")
-    if not token:
-        if sys.stdin.isatty():
-            token = input("Enter priv-token: ").strip()
-        else:
-            print("❌ PRIV_TOKEN env var not configured; cannot authenticate", file=sys.stderr)
-            sys.exit(1)
-    return token
-
-
-def normalize_model_id(model: str) -> str:
-    key = model.strip().lower()
-    return MODEL_ALIASES.get(key, model.strip())
-
-
-def is_seedance_model(model: str) -> bool:
-    return "seedance" in model.lower()
-
-
-def is_veo_model(model: str) -> bool:
-    return "veo" in model.lower()
-
-
-def gen_video_models_help_block() -> str:
-    lines = [
-        "可选模型（与灵创 AI 视频下拉、POST /model/genVideo 一致）:",
-        "  简写: seedance | veo | veo-fast（见 --model 说明）",
-    ]
-    for mid, title, provider in GEN_VIDEO_MODEL_PRESETS:
-        lines.append(f"  {mid}")
-        lines.append(f"    └ {title} · {provider}")
-    return "\n".join(lines)
-
-
-def resolve_image_input(path_or_url: str) -> str:
-    """
-    首帧/尾帧/参考图：支持 https URL、data: URI，或本地文件路径（读入为 data:image/...;base64,...）
-    """
-    s = path_or_url.strip()
-    if not s:
-        return ""
-    low = s.lower()
-    if low.startswith(("http://", "https://", "data:")):
-        return s
-    if not os.path.isfile(s):
-        print(f"❌ image path does not exist or is not a file: {s}", file=sys.stderr)
-        sys.exit(1)
-    mime, _ = mimetypes.guess_type(s)
-    if not mime or not mime.startswith("image/"):
-        mime = "image/jpeg"
-    with open(s, "rb") as f:
-        b64 = base64.standard_b64encode(f.read()).decode("ascii")
-    return f"data:{mime};base64,{b64}"
-
-
-def _build_headers(content_type: str = "application/json") -> dict:
-    """构建统一请求头（X-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
-    return headers
-
-
-# 视频任务状态（与 ab-api 一致：LiteLLM/库表可能返回 completed，方舟直连可能返回 succeeded）
-STATUS_PENDING = "pending"
-STATUS_PROCESSING = "processing"
-STATUS_SUCCEEDED = "succeeded"
-STATUS_COMPLETED = "completed"
-STATUS_FAILED = "failed"
-
-
-def api_request(path: str, payload: dict, *, exit_on_error: bool = True) -> dict:
-    """
-    通用 API 请求函数（统一 POST 方法）
-    exit_on_error=False 时网络/连接错误会抛出异常而非直接退出（供轮询重试使用）
-    """
-    if not PRIVATE_TOKEN:
-        print("❌ priv-token not configured: set the PRIV_TOKEN env var or pass --priv-token", file=sys.stderr)
-        sys.exit(1)
-
-    url = f"{API_BASE_URL}{path}"
-    data = json.dumps(payload).encode("utf-8")
-    headers = _build_headers()
-
-    req = urllib.request.Request(url, data=data, headers=headers, method="POST")
-
-    try:
-        with urllib.request.urlopen(req, timeout=120) as resp:
-            return json.loads(resp.read().decode("utf-8"))
-    except urllib.error.HTTPError as e:
-        body = e.read().decode("utf-8")
-        print(f"❌ API request failed (HTTP {e.code}): {body}", file=sys.stderr)
-        sys.exit(1)
-    except (urllib.error.URLError, OSError, ConnectionError) as e:
-        if exit_on_error:
-            print(f"❌ network error: {e}", file=sys.stderr)
-            sys.exit(1)
-        raise
-
-
-def create_video_task(
-    model: str,
-    duration: int,
-    ratio: str,
-    resolution: str,
-    prompt: str = "",
-    first_frame_image: str | None = None,
-    last_frame_image: str | None = None,
-    reference_images: list[str] | None = None,
-    generate_audio: bool = False,
-    camera_fixed: bool = False,
-    negative_prompt: str | None = None,
-    seed: int | None = None,
-    person_generation: str | None = None,
-) -> str:
-    """
-    创建视频生成任务，返回 task_id（请求体字段与 model.ModelGenVideoDTO / 前端 GenVideoParams 对齐）
-    """
-    print("🎬 Submitting video generation task...")
-    print(f"   model: {model}")
-    if prompt.strip():
-        print(f"   prompt: {prompt.strip()}")
-    print(f"   duration: {duration} s")
-    print(f"   aspect ratio: {ratio}")
-    print(f"   resolution: {resolution}")
-    print(f"   first frame: {'provided' if first_frame_image else 'none'}")
-    print(f"   end frame: {'provided' if last_frame_image else 'none'}")
-    if reference_images:
-        print(f"   reference images: {len(reference_images)}")
-    print(f"   generate audio: {'yes' if generate_audio else 'no'}")
-    print(f"   camera fixed: {'yes' if camera_fixed else 'no'}")
-    if negative_prompt:
-        print(f"   negative prompt: {negative_prompt[:80]}{'…' if len(negative_prompt) > 80 else ''}")
-    if seed is not None:
-        print(f"   seed: {seed}")
-
-    payload: dict = {
-        "model": model,
-        "duration": duration,
-        "ratio": ratio,
-        "resolution": resolution,
-        "generateAudio": generate_audio,
-        "cameraFixed": camera_fixed,
-    }
-    p = prompt.strip()
-    if p:
-        payload["prompt"] = p
-    if first_frame_image:
-        payload["firstFrameImage"] = first_frame_image
-    if last_frame_image:
-        payload["lastFrameImage"] = last_frame_image
-    if reference_images:
-        payload["referenceImages"] = reference_images
-    if negative_prompt and negative_prompt.strip():
-        payload["negativePrompt"] = negative_prompt.strip()
-    if seed is not None:
-        payload["seed"] = seed
-    if person_generation:
-        payload["personGeneration"] = person_generation
-
-    result = api_request("/model/genVideo", payload)
-
-    # 检查业务状态码
-    if result.get("code") != 0:
-        msg = result.get("msg", "未知错误")
-        print(f"❌ API returned an error: {msg}", file=sys.stderr)
-        sys.exit(1)
-
-    # 提取任务 ID: result["data"]["taskId"]
-    result_data = result.get("data") or {}
-    task_id = result_data.get("taskId")
-    if not task_id:
-        print(f"❌ could not parse the task id; API returned: {json.dumps(result, ensure_ascii=False)}", file=sys.stderr)
-        sys.exit(1)
-
-    print(f"✅ task submitted, task id: {task_id}")
-    return task_id
-
-
-def poll_video_status(task_id: str, poll_interval: int = 10, max_wait: int = 300) -> dict:
-    """
-    轮询视频生成状态，返回最终结果。
-    网络瞬断时自动重试（最多连续 5 次），不会因单次网络抖动而中断。
-    """
-    print(f"\n⏳ Waiting for video generation (up to {max_wait} s)...")
-
-    start_time = time.time()
-    consecutive_errors = 0
-    max_consecutive_errors = 5
-
-    while True:
-        elapsed = time.time() - start_time
-        if elapsed > max_wait:
-            print(f"\n❌ wait timed out (waited {elapsed:.0f} s)", file=sys.stderr)
-            print(f"   task id: {task_id}", file=sys.stderr)
-            sys.exit(1)
-
-        try:
-            result = api_request("/model/getVideoStatus", {"taskId": task_id}, exit_on_error=False)
-        except (urllib.error.URLError, OSError, ConnectionError) as e:
-            consecutive_errors += 1
-            print(f"\n   ⚠️  polling network error ({consecutive_errors}/{max_consecutive_errors}): {e}", flush=True)
-            if consecutive_errors >= max_consecutive_errors:
-                print(f"❌ {max_consecutive_errors} consecutive network errors, giving up on polling", file=sys.stderr)
-                print(f"   task id: {task_id} (the job may still be running on the backend)", file=sys.stderr)
-                sys.exit(1)
-            time.sleep(poll_interval)
-            continue
-
-        # 请求成功，重置连续错误计数
-        consecutive_errors = 0
-
-        # 检查业务状态码
-        if result.get("code") != 0:
-            msg = result.get("msg", "未知错误")
-            print(f"\n❌ status query failed: {msg}", file=sys.stderr)
-            sys.exit(1)
-
-        result_data = result.get("data") or {}
-        status = result_data.get("status", "unknown")
-
-        # 打印状态
-        status_icons = {
-            STATUS_PENDING: "⏳",
-            STATUS_PROCESSING: "🔄",
-            STATUS_SUCCEEDED: "✅",
-            STATUS_COMPLETED: "✅",
-            STATUS_FAILED: "❌",
-        }
-        icon = status_icons.get(status, "❓")
-        print(f"\r   {icon} status: {status} | elapsed: {elapsed:.0f}s", end="", flush=True)
-
-        if status in (STATUS_SUCCEEDED, STATUS_COMPLETED):
-            print()  # 换行
-            return result_data
-
-        if status == STATUS_FAILED:
-            print()
-            error_msg = (
-                result_data.get("errorMsg")
-                or result_data.get("error")
-                or result_data.get("message")
-                or "未知错误"
-            )
-            print(f"❌ video generation failed: {error_msg}", file=sys.stderr)
-            sys.exit(1)
-
-        time.sleep(poll_interval)
-
-
-def validate_params_for_model(
-    model: str,
-    duration: int,
-    ratio: str,
-    resolution: str,
-    ref_count: int,
-) -> None:
-    if is_seedance_model(model):
-        if duration not in SEEDANCE_DURATIONS:
-            print(
-                f"❌ Seedance duration must be {SEEDANCE_DURATIONS[0]}–{SEEDANCE_DURATIONS[-1]} s, got: {duration}",
-                file=sys.stderr,
-            )
-            sys.exit(1)
-        if ratio not in SEEDANCE_RATIOS:
-            print(f"❌ Seedance aspect ratio must be one of: {', '.join(SEEDANCE_RATIOS)}; got: {ratio}", file=sys.stderr)
-            sys.exit(1)
-        if resolution not in SEEDANCE_RESOLUTIONS:
-            print(
-                f"❌ Seedance resolution must be one of: {', '.join(SEEDANCE_RESOLUTIONS)}; got: {resolution}",
-                file=sys.stderr,
-            )
-            sys.exit(1)
-        if ref_count > 0:
-            print(
-                "❌ Seedance 1.5 Pro does not support a reference-image array (first / last frame only); use --first-frame / --last-frame instead",
-                file=sys.stderr,
-            )
-            sys.exit(1)
-    elif is_veo_model(model):
-        if duration not in VEO_DURATIONS:
-            print(f"❌ Veo duration must be one of: {', '.join(map(str, VEO_DURATIONS))} s; got: {duration}", file=sys.stderr)
-            sys.exit(1)
-        if ratio not in VEO_RATIOS:
-            print(f"❌ Veo aspect ratio must be one of: {', '.join(VEO_RATIOS)}; got: {ratio}", file=sys.stderr)
-            sys.exit(1)
-        if resolution not in VEO_RESOLUTIONS:
-            print(f"❌ Veo resolution must be one of: {', '.join(VEO_RESOLUTIONS)}; got: {resolution}", file=sys.stderr)
-            sys.exit(1)
-        if ref_count > VEO_MAX_REFERENCE_IMAGES:
-            print(
-                f"❌ Veo accepts at most {VEO_MAX_REFERENCE_IMAGES} reference images; got: {ref_count}",
-                file=sys.stderr,
-            )
-            sys.exit(1)
-    # Other models (e.g. future Sora): loose validation only.
-    elif ratio not in ALL_RATIOS:
-        print(f"❌ unsupported aspect ratio: {ratio}", file=sys.stderr)
-        sys.exit(1)
-    elif resolution not in ALL_RESOLUTIONS:
-        print(f"❌ unsupported resolution: {resolution}", file=sys.stderr)
-        sys.exit(1)
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(
-        description="AI video generator — aligned with the Lingchuang frontend AI-video params (multi-model)",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog=f"""
-{gen_video_models_help_block()}
-
-Aspect ratio / resolution depend on the model (the script validates them):
-  Seedance: ratios {', '.join(SEEDANCE_RATIOS)}; resolutions {', '.join(SEEDANCE_RESOLUTIONS)}; duration 4-12 s
-  Veo: ratios {', '.join(VEO_RATIOS)}; resolutions {', '.join(VEO_RESOLUTIONS)}; duration {', '.join(map(str, VEO_DURATIONS))} s
-
-Examples:
-  # Seedance: text-to-video (default model, 5 s)
-  python gen_video.py --prompt "Drone shot of a futuristic city at sunrise"
-
-  # Seedance: first / last frame (local files are converted to base64 data URLs)
-  python gen_video.py --first-frame ./start.png --last-frame ./end.png --prompt "smooth transition" --duration 5
-
-  # Veo 3.1: reference image + 4K (model alias 'veo')
-  python gen_video.py -m veo --prompt "product showcase" --duration 8 --resolution 4k --reference ./ref1.png
-        """,
-    )
-    parser.add_argument(
-        "--priv-token",
-        metavar="TOKEN",
-        default=None,
-        help="priv-token (priority: this flag > PRIV_TOKEN env var > interactive prompt)",
-    )
-    parser.add_argument(
-        "--prompt",
-        "-p",
-        default="",
-        help="Video description (can be combined with first/last frame or reference image; for pure image-to-video, an empty prompt lets the model infer)",
-    )
-    parser.add_argument(
-        "--model",
-        "-m",
-        default=VIDEO_MODEL,
-        help=(
-            f"Video-gen model id or alias: seedance / veo / veo-fast (default: {VIDEO_MODEL}). "
-            "See the preset list above for full ids."
-        ),
-    )
-    parser.add_argument(
-        "--duration",
-        "-d",
-        type=int,
-        default=None,
-        metavar="SEC",
-        help="Video duration in seconds. Default: Seedance 5, Veo 8",
-    )
-    parser.add_argument(
-        "--ratio",
-        "-r",
-        default="16:9",
-        choices=ALL_RATIOS,
-        help=f"Aspect ratio (default: 16:9). Seedance also accepts 'adaptive'",
-    )
-    parser.add_argument(
-        "--resolution",
-        default="720p",
-        choices=ALL_RESOLUTIONS,
-        help=f"Resolution (default: 720p). Veo also accepts 4k",
-    )
-    parser.add_argument(
-        "--first-frame",
-        "--start-frame",
-        dest="first_frame",
-        default=None,
-        metavar="PATH_OR_URL",
-        help="First-frame image: local path, https URL, or data: URI (same as the frontend 'first frame')",
-    )
-    parser.add_argument(
-        "--last-frame",
-        "--end-frame",
-        dest="last_frame",
-        default=None,
-        metavar="PATH_OR_URL",
-        help="End-frame image (same as the frontend 'end frame'; when aspect ratios mismatch, backend/model rules apply)",
-    )
-    parser.add_argument(
-        "--reference",
-        action="append",
-        default=None,
-        metavar="PATH_OR_URL",
-        help="Reference image; repeatable. Veo only, max 3 (same as the frontend reference image)",
-    )
-    parser.add_argument(
-        "--negative-prompt",
-        default=None,
-        help="Negative prompt (primarily for Veo)",
-    )
-    parser.add_argument(
-        "--seed",
-        type=int,
-        default=None,
-        help="Random seed (optional)",
-    )
-    parser.add_argument(
-        "--person-generation",
-        choices=("allow_all", "dont_allow"),
-        default=None,
-        help="Person-generation policy (Veo, maps to backend personGeneration)",
-    )
-    parser.add_argument(
-        "--generate-audio",
-        action="store_true",
-        default=False,
-        help="Generate audio (Seedance / Veo — actual support depends on the model)",
-    )
-    parser.add_argument(
-        "--camera-fixed",
-        action="store_true",
-        default=False,
-        help="Fixed camera (primarily for Seedance)",
-    )
-    parser.add_argument(
-        "--poll-interval",
-        type=int,
-        default=10,
-        help="Status polling interval (seconds, default: 10; Veo can be slower so you may want to raise this)",
-    )
-    parser.add_argument(
-        "--max-wait",
-        type=int,
-        default=300,
-        help="Maximum wait time (seconds, default: 300)",
-    )
-
-    args = parser.parse_args()
-
-    resolved_model = normalize_model_id(args.model)
-
-    first_val = resolve_image_input(args.first_frame) if args.first_frame else ""
-    last_val = resolve_image_input(args.last_frame) if args.last_frame else ""
-    ref_paths = args.reference if args.reference is not None else []
-    ref_vals = [resolve_image_input(p) for p in ref_paths if p]
-
-    has_prompt = bool(args.prompt.strip())
-    has_visual = bool(first_val or last_val or ref_vals)
-    if not has_prompt and not has_visual:
-        parser.error("至少需要其一：非空 --prompt，或 --first-frame / --last-frame / --reference")
-
-    if args.duration is None:
-        duration = 8 if is_veo_model(resolved_model) else 5
-    else:
-        duration = args.duration
-
-    validate_params_for_model(
-        resolved_model,
-        duration,
-        args.ratio,
-        args.resolution,
-        len(ref_vals),
-    )
-
-    # 初始化 token：--priv-token 参数 > PRIV_TOKEN 环境变量 > 手动输入
-    global PRIVATE_TOKEN
-    if args.priv_token is not None:
-        PRIVATE_TOKEN = args.priv_token
-    else:
-        PRIVATE_TOKEN = resolve_token()
-
-    task_id = create_video_task(
-        model=resolved_model,
-        prompt=args.prompt,
-        duration=duration,
-        ratio=args.ratio,
-        resolution=args.resolution,
-        first_frame_image=first_val or None,
-        last_frame_image=last_val or None,
-        reference_images=ref_vals or None,
-        generate_audio=args.generate_audio,
-        camera_fixed=args.camera_fixed,
-        negative_prompt=args.negative_prompt,
-        seed=args.seed,
-        person_generation=args.person_generation,
-    )
-
-    result_data = poll_video_status(
-        task_id=task_id,
-        poll_interval=args.poll_interval,
-        max_wait=args.max_wait,
-    )
-
-    print("🎉 Video generated successfully!")
-
-    video_url = result_data.get("videoUrl")
-    if video_url:
-        print("\n🔗 Video URL (renders directly, no download needed):")
-        print(video_url)
-    else:
-        print(f"⚠️  video generated but no URL was returned, task id: {task_id}")
-    print("\n🎉 Video generation done!")
-
-
-if __name__ == "__main__":
-    main()

package/skills/template-bind/version.json

@@ -1,7 +0,0 @@
-{
-  "skillName": "template-bind",
-  "repoName": "agent-skill-media-maker",
-  "skillId": "475",
-  "version": "V10",
-  "skillDescription": "视频模板仓库与绑定技能，存储所有视频模板定义，根据指定模板 ID 生成 TemplateBinding。\n\n当用户提到以下任何需求时，立即使用本 skill：\n- 查看可用模板、列出所有模板\n- 为 DSL 绑定模板（需指定 template-id）\n\n当 Agent 拿到 Video DSL 需要生成 TemplateBinding 时，也应使用本 skill。"
-}