@aiyiran/myclaw 1.0.201 → 1.0.202

package/skills/yiran-skill-media/scripts/generate.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""
+统一资源生成调度器
+用法:
+  python3 generate.py image "prompt" [--aspect-ratio 16:9] [--output path]
+  python3 generate.py music "prompt" [--lyrics "歌词"] [--instrumental] [--output path]
+"""
+import argparse
+import json
+import os
+import sys
+import tempfile
+import time
+from datetime import datetime
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+CONFIG_PATH = os.path.join(SCRIPT_DIR, "..", "config.json")
+
+
+def load_config():
+    with open(CONFIG_PATH, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def get_output_dir():
+    """Resolve output directory. Fallback to /tmp/media/ if primary is unwritable."""
+    workspace = os.environ.get("WORKSPACE_NAME", "main")
+    openclaw_home = os.environ.get("OPENCLAW_HOME", os.path.join(os.path.expanduser("~"), ".openclaw"))
+
+    if workspace == "main":
+        base = os.path.join(openclaw_home, "workspace")
+    else:
+        base = os.path.join(openclaw_home, f"workspace-{workspace}")
+
+    out_dir = os.path.join(base, "media")
+    try:
+        os.makedirs(out_dir, exist_ok=True)
+        return out_dir
+    except OSError:
+        # Primary dir unwritable (e.g. /root on macOS) → fallback to tmp
+        fallback = os.path.join(tempfile.gettempdir(), "media")
+        os.makedirs(fallback, exist_ok=True)
+        print(f"[warn] {out_dir} not writable, using {fallback}", file=sys.stderr)
+        return fallback
+
+
+def make_output_path(out_dir, resource_type, ext):
+    """Generate timestamped filename."""
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+    return os.path.join(out_dir, f"{resource_type}_{ts}.{ext}")
+
+
+def append_log(log_path, entry):
+    """Append a generation record. Never raises — logging failure is non-fatal."""
+    try:
+        if os.path.exists(log_path):
+            with open(log_path, "r", encoding="utf-8") as f:
+                log = json.load(f)
+        else:
+            log = []
+
+        log.append(entry)
+
+        with open(log_path, "w", encoding="utf-8") as f:
+            json.dump(log, f, ensure_ascii=False, indent=2)
+
+        print(f"[log] 已记录到 {log_path}", file=sys.stderr)
+    except Exception as e:
+        print(f"[warn] log write failed: {e}", file=sys.stderr)
+
+
+def dispatch(resource_type, prompt, **kwargs):
+    """Route to primary provider, fallback on failure.
+
+    Always tries primary first, then fallback if configured.
+    Returns (files, used_provider_cfg).
+    """
+    cfg = load_config()
+    resource_cfg = cfg.get(resource_type)
+    if not resource_cfg:
+        raise ValueError(f"unknown resource type: {resource_type}")
+
+    providers = [resource_cfg["primary"]]
+    if resource_cfg.get("fallback"):
+        providers.append(resource_cfg["fallback"])
+
+    sys.path.insert(0, SCRIPT_DIR)
+    from providers import get_adapter
+
+    errors = []
+    for provider_cfg in providers:
+        name = provider_cfg["provider"]
+        try:
+            adapter = get_adapter(name)
+            files = adapter.generate(prompt, config=provider_cfg, **kwargs)
+            return files, provider_cfg
+        except Exception as e:
+            msg = f"[{name}] failed: {e}"
+            print(msg, file=sys.stderr)
+            errors.append(msg)
+
+    raise RuntimeError("all providers failed:\n" + "\n".join(errors))
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Unified media generation dispatcher")
+    parser.add_argument("type", choices=["image", "music"], help="Resource type")
+    parser.add_argument("prompt", help="Generation prompt")
+    parser.add_argument("--aspect-ratio", default="1:1", help="Image aspect ratio (image only)")
+    parser.add_argument("--lyrics", default=None, help="Lyrics text (music only)")
+    parser.add_argument("--instrumental", action="store_true", help="Instrumental mode (music only)")
+    parser.add_argument("--output", default=None, help="Output file path")
+    args = parser.parse_args()
+
+    out_dir = get_output_dir()
+
+    if args.type == "image":
+        output_path = args.output or make_output_path(out_dir, "image", "png")
+        kwargs = {
+            "out_dir": out_dir,
+            "output_path": output_path,
+            "aspect_ratio": args.aspect_ratio,
+        }
+    else:
+        output_path = args.output or make_output_path(out_dir, "music", "mp3")
+        kwargs = {
+            "out_dir": out_dir,
+            "output_path": output_path,
+            "lyrics": args.lyrics,
+            "instrumental": args.instrumental,
+        }
+
+    start_time = time.time()
+    start_dt = datetime.now()
+
+    try:
+        files, used_provider = dispatch(args.type, args.prompt, **kwargs)
+        duration = round(time.time() - start_time, 2)
+        end_dt = datetime.now()
+
+        # Log — non-fatal
+        log_entry = {
+            "id": start_dt.strftime("%Y%m%d_%H%M%S"),
+            "type": args.type,
+            "name": os.path.basename(files[0]) if files else None,
+            "files": files,
+            "prompt": args.prompt,
+            "params": {k: v for k, v in kwargs.items() if k != "out_dir"},
+            "provider": used_provider["provider"],
+            "model": used_provider["model"],
+            "started_at": start_dt.strftime("%Y-%m-%d %H:%M:%S"),
+            "finished_at": end_dt.strftime("%Y-%m-%d %H:%M:%S"),
+            "duration_seconds": duration,
+        }
+        log_path = os.path.join(SCRIPT_DIR, "generation_log.json")
+        append_log(log_path, log_entry)
+
+        print(json.dumps({"success": True, "files": files}))
+    except Exception as e:
+        print(json.dumps({"success": False, "error": str(e)}))
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/skills/yiran-skill-media/scripts/generation_log.json

@@ -0,0 +1,20 @@
+[
+  {
+    "id": "20260413_141112",
+    "type": "image",
+    "name": "image_20260413_141112.png",
+    "files": [
+      "/Users/yiran/.openclaw/workspace/media/image_20260413_141112.png"
+    ],
+    "prompt": "a cute cat sitting on a windowsill",
+    "params": {
+      "output_path": "/Users/yiran/.openclaw/workspace/media/image_20260413_141112.png",
+      "aspect_ratio": "1:1"
+    },
+    "provider": "vapi_image",
+    "model": "nano-banana-pro",
+    "started_at": "2026-04-13 14:11:12",
+    "finished_at": "2026-04-13 14:11:36",
+    "duration_seconds": 23.5
+  }
+]

package/skills/yiran-skill-media/scripts/image.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+# 图片生成入口
+# 用法: WORKSPACE_NAME=main ./image.sh "描述" [--aspect-ratio 16:9] [--registry]
+set -euo pipefail
+
+PROMPT="${1:-}"
+shift 2>/dev/null || true
+
+if [ -z "$PROMPT" ]; then
+    echo "用法: WORKSPACE_NAME=xxx ./image.sh \"描述\" [--aspect-ratio 16:9] [--registry]"
+    echo "示例: WORKSPACE_NAME=main ./image.sh \"a cute cat\" --aspect-ratio 16:9 --registry"
+    exit 1
+fi
+
+ASPECT_RATIO=""
+REGISTRY=false
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --aspect-ratio) ASPECT_RATIO="$2"; shift 2 ;;
+        --registry) REGISTRY=true; shift ;;
+        *) shift ;;
+    esac
+done
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+# Build args for generate.py
+ARGS=()
+ARGS+=("image")
+ARGS+=("$PROMPT")
+[ -n "$ASPECT_RATIO" ] && ARGS+=(--aspect-ratio "$ASPECT_RATIO")
+
+RESULT=$(python3 "$SCRIPT_DIR/generate.py" "${ARGS[@]}")
+echo "$RESULT"
+
+# Parse output path and optionally register
+if [ "$REGISTRY" = true ]; then
+    OUTPUT=$(echo "$RESULT" | python3 -c "import json,sys; d=json.load(sys.stdin); print(d['files'][0])" 2>/dev/null || true)
+    if [ -n "$OUTPUT" ]; then
+        WORKSPACE_NAME="${WORKSPACE_NAME:-main}" AUTO_REGISTRY=true python3 "$SCRIPT_DIR/registry.py" "$OUTPUT"
+    fi
+fi

package/skills/yiran-skill-media/scripts/music.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+# 音乐生成入口
+# 用法: WORKSPACE_NAME=main ./music.sh "描述" [--lyrics "歌词"] [--instrumental] [--registry]
+set -euo pipefail
+
+PROMPT="${1:-}"
+shift 2>/dev/null || true
+
+if [ -z "$PROMPT" ]; then
+    echo "用法: WORKSPACE_NAME=xxx ./music.sh \"描述\" [--lyrics \"歌词\"] [--instrumental] [--registry]"
+    echo "示例: WORKSPACE_NAME=main ./music.sh \"relaxing guitar\" --instrumental --registry"
+    exit 1
+fi
+
+LYRICS=""
+INSTRUMENTAL=false
+REGISTRY=false
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --lyrics) LYRICS="$2"; shift 2 ;;
+        --instrumental) INSTRUMENTAL=true; shift ;;
+        --registry) REGISTRY=true; shift ;;
+        *) shift ;;
+    esac
+done
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+# Build args for generate.py
+ARGS=()
+ARGS+=("music")
+ARGS+=("$PROMPT")
+[ -n "$LYRICS" ] && ARGS+=(--lyrics "$LYRICS")
+[ "$INSTRUMENTAL" = true ] && ARGS+=(--instrumental)
+
+RESULT=$(python3 "$SCRIPT_DIR/generate.py" "${ARGS[@]}")
+echo "$RESULT"
+
+# Parse output path and optionally register
+if [ "$REGISTRY" = true ]; then
+    OUTPUT=$(echo "$RESULT" | python3 -c "import json,sys; d=json.load(sys.stdin); print(d['files'][0])" 2>/dev/null || true)
+    if [ -n "$OUTPUT" ]; then
+        WORKSPACE_NAME="${WORKSPACE_NAME:-main}" AUTO_REGISTRY=true python3 "$SCRIPT_DIR/registry.py" "$OUTPUT"
+    fi
+fi

package/skills/yiran-skill-media/scripts/providers/__init__.py

@@ -0,0 +1,15 @@
+from .vapi_image import VAPIImageAdapter
+from .minimax_image import MiniMaxImageAdapter
+from .minimax_music import MiniMaxMusicAdapter
+
+ADAPTERS = {
+    "vapi_image": VAPIImageAdapter(),
+    "minimax_image": MiniMaxImageAdapter(),
+    "minimax_music": MiniMaxMusicAdapter(),
+}
+
+def get_adapter(name: str):
+    adapter = ADAPTERS.get(name)
+    if not adapter:
+        raise ValueError(f"unknown provider: {name}")
+    return adapter

package/skills/yiran-skill-media/scripts/providers/minimax_image.py

@@ -0,0 +1,75 @@
+"""MiniMax image adapter — POST /image_generation, base64 decode to save."""
+import base64
+import json
+import os
+import sys
+
+import requests
+
+
+class MiniMaxImageAdapter:
+    @staticmethod
+    def _ratio_to_size(ratio_str, max_dim=2048):
+        """Parse '16:9' style ratio and compute (width, height) capped at max_dim."""
+        parts = ratio_str.split(":")
+        if len(parts) != 2:
+            return 1024, 1024
+        try:
+            rw, rh = float(parts[0]), float(parts[1])
+        except ValueError:
+            return 1024, 1024
+        # Scale so the longer side = max_dim
+        scale = max_dim / max(rw, rh)
+        w = round(rw * scale)
+        h = round(rh * scale)
+        return w, h
+
+    def generate(self, prompt, config, **kwargs):
+        base_url = config["base_url"].rstrip("/")
+        api_key = config["api_key"]
+        model = config["model"]
+        out_dir = kwargs["out_dir"]
+
+        # 默认 1024x1024；传了 aspect_ratio 则按 2048 上限换算 width/height
+        aspect_ratio = kwargs.get("aspect_ratio")
+        if aspect_ratio and aspect_ratio != "1:1":
+            w, h = self._ratio_to_size(aspect_ratio, max_dim=2048)
+            size_params = {"width": w, "height": h}
+        else:
+            size_params = {"width": 1024, "height": 1024}
+
+        endpoint = f"{base_url}/image_generation"
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+        }
+        payload = {
+            "model": model,
+            "prompt": prompt,
+            "response_format": "base64",
+            "n": 1,
+            **size_params,
+        }
+
+        print(f"[minimax_image] generating with model={model} size={size_params}...", file=sys.stderr)
+        resp = requests.post(endpoint, headers=headers, json=payload, timeout=180)
+        data = resp.json()
+
+        if data.get("base_resp", {}).get("status_code") != 0:
+            raise RuntimeError(f"MiniMax error: {data.get('base_resp', {}).get('status_msg')}")
+
+        image_list = data.get("data", {}).get("image_base64", [])
+        if not image_list:
+            raise RuntimeError("no image data in response")
+
+        saved = []
+        for i, img_b64 in enumerate(image_list):
+            decoded = base64.b64decode(img_b64)
+            ext = "png" if decoded[:8].startswith(b"\x89PNG") else "jpg"
+            fname = kwargs.get("output_path") or os.path.join(out_dir, f"image_{i+1}.{ext}")
+            with open(fname, "wb") as f:
+                f.write(decoded)
+            saved.append(fname)
+            print(f"[minimax_image] saved: {fname}", file=sys.stderr)
+
+        return saved

package/skills/yiran-skill-media/scripts/providers/minimax_music.py

@@ -0,0 +1,61 @@
+"""MiniMax music adapter — POST /music_generation, download audio to save."""
+import json
+import os
+import sys
+
+import requests
+
+
+class MiniMaxMusicAdapter:
+    def generate(self, prompt, config, **kwargs):
+        base_url = config["base_url"].rstrip("/")
+        api_key = config["api_key"]
+        model = config["model"]
+        out_dir = kwargs["out_dir"]
+        lyrics = kwargs.get("lyrics")
+        is_instrumental = kwargs.get("instrumental", False)
+
+        endpoint = f"{base_url}/music_generation"
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+        }
+        payload = {
+            "model": model,
+            "prompt": prompt,
+            "is_instrumental": is_instrumental,
+            "output_format": "url",
+            "audio_setting": {
+                "sample_rate": 44100,
+                "bitrate": 256000,
+                "format": "mp3",
+            },
+        }
+        if lyrics:
+            payload["lyrics"] = lyrics
+
+        print(f"[minimax_music] generating with model={model}...", file=sys.stderr)
+        resp = requests.post(endpoint, headers=headers, json=payload, timeout=120)
+        data = resp.json()
+
+        if data.get("base_resp", {}).get("status_code") != 0:
+            raise RuntimeError(f"MiniMax error: {data.get('base_resp', {}).get('status_msg')}")
+
+        audio_data = data.get("data", {})
+        status = audio_data.get("status")
+        if status == 1:
+            raise RuntimeError("music still synthesizing (status=1), retry later")
+
+        fname = kwargs.get("output_path") or os.path.join(out_dir, "music.mp3")
+        audio_url = audio_data.get("audio")
+        if not audio_url:
+            raise RuntimeError("no audio URL in response")
+
+        r = requests.get(audio_url, timeout=60)
+        with open(fname, "wb") as f:
+            f.write(r.content)
+
+        duration_ms = data.get("extra_info", {}).get("music_duration", 0)
+        print(f"[minimax_music] saved: {fname} ({duration_ms/1000:.1f}s)", file=sys.stderr)
+
+        return [fname]

package/skills/yiran-skill-media/scripts/providers/vapi_image.py

@@ -0,0 +1,63 @@
+"""VAPI image adapter — POST /images/generations, download URL to save."""
+import base64
+import json
+import os
+import sys
+
+import requests
+
+
+class VAPIImageAdapter:
+    def generate(self, prompt, config, **kwargs):
+        base_url = config["base_url"].rstrip("/")
+        api_key = config["api_key"]
+        model = config["model"]
+        aspect_ratio = kwargs.get("aspect_ratio", "")
+        out_dir = kwargs["out_dir"]
+
+        url = f"{base_url}/images/generations"
+        payload = {
+            "model": model,
+            "prompt": prompt,
+            "n": 1,
+            "response_format": "url",
+        }
+        if aspect_ratio:
+            payload["aspect_ratio"] = aspect_ratio
+
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+        }
+
+        print(f"[vapi_image] generating with model={model}...", file=sys.stderr)
+        resp = requests.post(url, headers=headers, json=payload, timeout=180)
+        if resp.status_code != 200:
+            raise RuntimeError(f"VAPI API error ({resp.status_code}): {resp.text}")
+
+        data = resp.json()
+        images = data.get("data", [])
+        if not images:
+            raise RuntimeError("no image data in response")
+
+        saved = []
+        for i, item in enumerate(images):
+            image_url = item.get("url")
+            b64 = item.get("b64_json")
+            fname = kwargs.get("output_path") or os.path.join(out_dir, f"image_{i+1}.png")
+
+            if b64:
+                with open(fname, "wb") as f:
+                    f.write(base64.b64decode(b64))
+            elif image_url:
+                r = requests.get(image_url, timeout=120)
+                r.raise_for_status()
+                with open(fname, "wb") as f:
+                    f.write(r.content)
+            else:
+                raise RuntimeError(f"no image data for item {i}")
+
+            saved.append(fname)
+            print(f"[vapi_image] saved: {fname}", file=sys.stderr)
+
+        return saved

package/skills/yiran-skill-media/scripts/registry.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""
+MiniMax 资源注册脚本
+生成文件后自动注册到 __MY_ARTIFACTS__.json
+
+用法:
+  AUTO_REGISTRY=true ./image.sh "描述"
+  AUTO_REGISTRY=false ./image.sh "描述"   # 不注册
+
+环境变量:
+  WORKSPACE_NAME  - workspace名称，main 或其他
+  AUTO_REGISTRY   - true=注册到JSON, false=不注册
+  MINIMAX_API_KEY - API密钥（不需要，生成用）
+"""
+
+import os
+import json
+import sys
+from datetime import datetime, timezone, timedelta
+
+WORKSPACE = os.environ.get("WORKSPACE_NAME", "main")
+AUTO_REGISTRY = os.environ.get("AUTO_REGISTRY", "false").lower() == "true"
+
+OPENCLAW_HOME = os.environ.get("OPENCLAW_HOME", os.path.join(os.path.expanduser("~"), ".openclaw"))
+
+# 路径构建
+if WORKSPACE == "main":
+    WORKSPACE_ROOT = os.path.join(OPENCLAW_HOME, "workspace")
+else:
+    WORKSPACE_ROOT = os.path.join(OPENCLAW_HOME, f"workspace-{WORKSPACE}")
+
+MYCLAW_DIR = os.path.join(WORKSPACE_ROOT, ".myclaw")
+REGISTRY_FILE = os.path.join(MYCLAW_DIR, "__MY_ARTIFACTS__.json")
+
+
+def load_registry():
+    """加载或初始化 registry"""
+    if os.path.exists(REGISTRY_FILE):
+        with open(REGISTRY_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    return {
+        "workspace_id": WORKSPACE,
+        "title": f"我的资源库",
+        "release_version": 1,
+        "created_at": datetime.now(timezone(timedelta(hours=8))).isoformat(),
+        "updated_at": datetime.now(timezone(timedelta(hours=8))).isoformat(),
+        "version": 1,
+        "base_url": "https://claw.kekouen.cn/cmd/api/preview?path=",
+        "preview_path": "index.html",
+        "assets": []
+    }
+
+
+def save_registry(data):
+    """保存 registry"""
+    os.makedirs(MYCLAW_DIR, exist_ok=True)
+    data["updated_at"] = datetime.now(timezone(timedelta(hours=8))).isoformat()
+    with open(REGISTRY_FILE, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+
+
+def guess_type(filename):
+    """根据扩展名判断资源类型"""
+    ext = os.path.splitext(filename)[1].lower()
+    type_map = {
+        ".png": "image", ".jpg": "image", ".jpeg": "image",
+        ".gif": "image", ".webp": "image", ".bmp": "image",
+        ".mp4": "video", ".mov": "video", ".avi": "video",
+        ".mp3": "audio", ".wav": "audio", ".flac": "audio",
+        ".html": "html", ".htm": "html",
+        ".pdf": "document", ".doc": "document", ".docx": "document",
+    }
+    return type_map.get(ext, "file")
+
+
+def register_asset(filepath, name=None):
+    """
+    注册一个文件到 JSON
+    filepath: 完整路径，如 /root/.openclaw/workspace/media/image_xxx.png
+    """
+    if not AUTO_REGISTRY:
+        print(f"[Registry] AUTO_REGISTRY=false，跳过注册")
+        return
+
+    filename = os.path.basename(filepath)
+    rel_path = os.path.relpath(filepath, WORKSPACE_ROOT)
+    asset_type = guess_type(filename)
+
+    # 生成 id
+    import hashlib
+    asset_id = hashlib.md5(filename.encode()).hexdigest()[:8]
+    asset_id = f"asset-{asset_id}"
+
+    # 生成 name
+    if not name:
+        name = os.path.splitext(filename)[0]
+
+    registry = load_registry()
+
+    # 检查是否已存在（同名文件）
+    for i, asset in enumerate(registry["assets"]):
+        if asset.get("path") == rel_path:
+            registry["assets"][i] = {
+                "id": asset_id,
+                "type": asset_type,
+                "name": name,
+                "path": rel_path
+            }
+            save_registry(registry)
+            print(f"[Registry] 已更新: {rel_path}")
+            return
+
+    # 新增
+    registry["assets"].append({
+        "id": asset_id,
+        "type": asset_type,
+        "name": name,
+        "path": rel_path
+    })
+    save_registry(registry)
+    print(f"[Registry] 已注册: {rel_path} ({asset_type})")
+
+
+if __name__ == "__main__":
+    # CLI 模式
+    if len(sys.argv) < 2:
+        print(f"用法: AUTO_REGISTRY=true python3 registry.py <文件路径> [名称]")
+        print(f"环境: WORKSPACE_NAME={WORKSPACE}, AUTO_REGISTRY={AUTO_REGISTRY}")
+        sys.exit(1)
+
+    filepath = sys.argv[1]
+    name = sys.argv[2] if len(sys.argv) > 2 else None
+    register_asset(filepath, name)