sophhub 0.2.0 → 0.2.2

package/skills/image-classify/src/scripts/send_dm_message.py

@@ -0,0 +1,332 @@
+#!/usr/bin/env python3
+"""Send a DM by friend user_id: resolve DM room via /friend/dm, then send. JWT: /home/node/.openclaw/jwt.json."""
+
+import argparse
+import base64
+import json
+import mimetypes
+import os
+import sys
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+import uuid
+from typing import Dict, List, Optional, Tuple
+
+
+DEFAULT_TIMEOUT = 30
+DEFAULT_BASE_URL = "https://yagent.sophnet.com/api"
+JWT_PATH = "/home/node/.openclaw/jwt.json"
+
+
+class ApiError(RuntimeError):
+    pass
+
+
+def configure_stdio() -> None:
+    for name in ("stdout", "stderr"):
+        stream = getattr(sys, name, None)
+        if stream is not None and hasattr(stream, "reconfigure"):
+            stream.reconfigure(encoding="utf-8", errors="replace")
+
+
+def read_bearer_token(jwt_path: str) -> str:
+    try:
+        with open(jwt_path, "r", encoding="utf-8") as fp:
+            data = json.load(fp)
+    except OSError as exc:
+        raise ApiError(f"Cannot read JWT file {jwt_path}: {exc}") from exc
+    except json.JSONDecodeError as exc:
+        raise ApiError(f"Invalid JSON in JWT file {jwt_path}: {exc}") from exc
+    if not isinstance(data, dict):
+        raise ApiError("JWT file root must be a JSON object.")
+    token = data.get("web_jwt")
+    if not token or not isinstance(token, str):
+        raise ApiError("JWT file has no valid `web_jwt` field.")
+    token = token.strip()
+    if token.lower().startswith("bearer "):
+        token = token[7:].strip()
+    if not token:
+        raise ApiError("`web_jwt` is empty.")
+    return token
+
+
+def jwt_exp_unix(token: str) -> Optional[int]:
+    """Return JWT `exp` (seconds since epoch) if present; None if unreadable."""
+    try:
+        parts = token.split(".")
+        if len(parts) != 3:
+            return None
+        payload_b64 = parts[1] + "=" * (-len(parts[1]) % 4)
+        raw = base64.urlsafe_b64decode(payload_b64.encode("ascii"))
+        payload = json.loads(raw)
+        exp = payload.get("exp")
+        if isinstance(exp, (int, float)):
+            return int(exp)
+    except (ValueError, UnicodeDecodeError, json.JSONDecodeError, IndexError):
+        pass
+    return None
+
+
+def ensure_jwt_valid_for_use(token: str, jwt_path: str, clock_skew_sec: int = 60) -> None:
+    """Fail fast if JWT is already expired (common cause of HTTP 401 / 请先登录)."""
+    exp = jwt_exp_unix(token)
+    if exp is None:
+        return
+    now = int(time.time())
+    if now >= exp + clock_skew_sec:
+        raise ApiError(
+            f"JWT in {jwt_path} has expired (exp={exp}, now={now}). "
+            "Log in again in the app or refresh the token, then update the file."
+        )
+
+
+def normalize_base_url(url: str) -> str:
+    url = url.strip()
+    if not url:
+        raise ApiError("Base URL cannot be empty.")
+    return url.rstrip("/")
+
+
+def resolve_files(raw: Optional[List[str]]) -> List[str]:
+    if not raw:
+        return []
+    cwd = os.getcwd()
+    out: List[str] = []
+    for item in raw:
+        if not isinstance(item, str) or not item.strip():
+            raise ApiError("Each --file path must be non-empty.")
+        p = item if os.path.isabs(item) else os.path.join(cwd, item)
+        out.append(os.path.realpath(p))
+    return out
+
+
+def make_headers(token: str, content_type: Optional[str] = None) -> Dict[str, str]:
+    h = {"Authorization": f"Bearer {token}", "Accept": "application/json"}
+    if content_type:
+        h["Content-Type"] = content_type
+    return h
+
+
+def read_http_body(exc: urllib.error.HTTPError) -> str:
+    try:
+        return exc.read().decode("utf-8", errors="replace")
+    except Exception:
+        return str(exc)
+
+
+def http_api_error_hint(http_code: int, body: str) -> str:
+    """Append short hints for known API error bodies (JWT, RBAC)."""
+    try:
+        err = json.loads(body)
+    except json.JSONDecodeError:
+        if http_code == 401:
+            return f" (check web_jwt in {JWT_PATH}.)"
+        return ""
+    api_st = err.get("status")
+    msg = str(err.get("message", ""))
+    if http_code == 401 and (api_st == 10025 or "登录" in msg):
+        return f" (renew web_jwt in {JWT_PATH}.)"
+    if api_st == 20002 or "权限不足" in msg:
+        return (
+            " (insufficient permission: this account cannot send in this room/channel; "
+            "ask an org admin to grant access or send from an allowed account.)"
+        )
+    return ""
+
+
+def request_json(
+    method: str,
+    url: str,
+    token: str,
+    timeout: int,
+    payload: Optional[dict] = None,
+) -> dict:
+    body = None
+    headers = make_headers(token)
+    if payload is not None:
+        body = json.dumps(payload).encode("utf-8")
+        headers["Content-Type"] = "application/json"
+    req = urllib.request.Request(url=url, data=body, headers=headers, method=method)
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            raw = resp.read().decode("utf-8")
+    except urllib.error.HTTPError as exc:
+        body = read_http_body(exc)
+        raise ApiError(f"HTTP {exc.code} {url}: {body}{http_api_error_hint(exc.code, body)}")
+    except urllib.error.URLError as exc:
+        raise ApiError(f"Request failed for {url}: {exc}")
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        raise ApiError(f"Invalid JSON from {url}: {exc}\n{raw}")
+    if data.get("status") != 0:
+        raise ApiError(
+            f"API error for {url}: status={data.get('status')} message={data.get('message')!r}"
+        )
+    return data
+
+
+def multipart_file(file_name: str, file_bytes: bytes, content_type: str) -> Tuple[bytes, str]:
+    boundary = f"----oc{uuid.uuid4().hex}"
+    b = boundary.encode("ascii")
+    parts: List[bytes] = [
+        b"--" + b + b"\r\n",
+        (
+            f'Content-Disposition: form-data; name="file"; filename="{file_name}"\r\n'
+        ).encode("utf-8"),
+        f"Content-Type: {content_type}\r\n\r\n".encode("utf-8"),
+        file_bytes,
+        b"\r\n",
+        b"--" + b + b"--\r\n",
+    ]
+    return b"".join(parts), f"multipart/form-data; boundary={boundary}"
+
+
+def upload_asset(base_url: str, token: str, rid: str, file_path: str, timeout: int) -> dict:
+    if not os.path.isfile(file_path):
+        raise ApiError(f"Attachment not found: {file_path}")
+    base_name = os.path.basename(file_path)
+    mime = mimetypes.guess_type(base_name)[0] or "application/octet-stream"
+    with open(file_path, "rb") as fp:
+        blob = fp.read()
+    body, ctype = multipart_file(base_name, blob, mime)
+    url = f"{base_url}/sys/openclaw/im/chat.uploadAsset?{urllib.parse.urlencode({'rid': rid})}"
+    req = urllib.request.Request(
+        url=url,
+        data=body,
+        headers=make_headers(token, content_type=ctype),
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            raw = resp.read().decode("utf-8")
+    except urllib.error.HTTPError as exc:
+        b = read_http_body(exc)
+        raise ApiError(
+            f"HTTP {exc.code} while uploading {file_path}: {b}{http_api_error_hint(exc.code, b)}"
+        )
+    except urllib.error.URLError as exc:
+        raise ApiError(f"Upload failed for {file_path}: {exc}")
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        raise ApiError(f"Invalid upload response for {file_path}: {exc}\n{raw}")
+    if data.get("status") != 0:
+        raise ApiError(
+            f"Upload API error: status={data.get('status')} message={data.get('message')!r}"
+        )
+    asset = (data.get("result") or {}).get("asset") or {}
+    url_path = asset.get("urlPath")
+    if not url_path:
+        raise ApiError(f"Upload OK but missing result.asset.urlPath for {file_path}.")
+    return {
+        "name": base_name,
+        "type": mime,
+        "size": os.path.getsize(file_path),
+        "url": url_path,
+    }
+
+
+def get_or_create_dm(base_url: str, token: str, friend_id: int, timeout: int) -> str:
+    url = f"{base_url}/sys/openclaw/friend/dm"
+    data = request_json("POST", url, token, timeout, payload={"friendId": friend_id})
+    result = data.get("result") or {}
+    channel = result.get("channel") or {}
+    rid = channel.get("_id")
+    if not rid:
+        raise ApiError("DM creation succeeded, but `result.channel._id` is missing.")
+    return str(rid)
+
+
+def send_message(
+    base_url: str,
+    token: str,
+    rid: str,
+    text: str,
+    attachments: List[dict],
+    timeout: int,
+) -> dict:
+    url = f"{base_url}/sys/openclaw/im/chat.sendMessage"
+    payload: Dict[str, object] = {"rid": rid}
+    if text:
+        payload["msg"] = text
+    if attachments:
+        payload["attachments"] = attachments
+    if "msg" not in payload and "attachments" not in payload:
+        raise ApiError("Message text and attachments cannot both be empty.")
+    data = request_json("POST", url, token, timeout, payload=payload)
+    return (data.get("result") or {}).get("message") or {}
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(
+        description="Send DM to a user by user_id (resolves DM via /friend/dm). JWT: %s." % JWT_PATH
+    )
+    p.add_argument(
+        "--user-id",
+        type=int,
+        required=True,
+        metavar="UID",
+        help="Target friend userId; script calls /sys/openclaw/friend/dm to get room id.",
+    )
+    p.add_argument("-m", "--message", default="", help="Text (use --file if no text)")
+    p.add_argument("--file", action="append", dest="files", metavar="PATH", help="Attachment; repeat")
+    p.add_argument("--base-url", default=DEFAULT_BASE_URL, help="API base URL")
+    p.add_argument("--timeout", type=int, default=DEFAULT_TIMEOUT, help="HTTP timeout (seconds)")
+    p.add_argument(
+        "--allow-expired-jwt",
+        action="store_true",
+        help="Skip local JWT exp check (server will still reject invalid tokens).",
+    )
+    args = p.parse_args()
+    configure_stdio()
+
+    try:
+        if args.user_id <= 0:
+            raise ApiError("`--user-id` must be a positive integer.")
+        token = read_bearer_token(JWT_PATH)
+        if args.allow_expired_jwt:
+            exp = jwt_exp_unix(token)
+            if exp is not None and int(time.time()) >= exp + 60:
+                print(
+                    "WARNING: JWT is expired; request will likely fail with 401. "
+                    "Update web_jwt in %s after re-login." % JWT_PATH,
+                    file=sys.stderr,
+                )
+        else:
+            ensure_jwt_valid_for_use(token, JWT_PATH)
+        base_url = normalize_base_url(args.base_url)
+        text = args.message or ""
+        files = resolve_files(args.files)
+        if not text.strip() and not files:
+            raise ApiError("Provide -m/--message and/or --file.")
+        if args.timeout <= 0:
+            raise ApiError("`--timeout` must be a positive integer.")
+
+        rid = get_or_create_dm(base_url, token, args.user_id, args.timeout)
+        attachments = [upload_asset(base_url, token, rid, fp, args.timeout) for fp in files]
+        msg = send_message(base_url, token, rid, text, attachments, args.timeout)
+        print(
+            json.dumps(
+                {
+                    "targetUserId": args.user_id,
+                    "rid": rid,
+                    "baseUrl": base_url,
+                    "attachmentCount": len(attachments),
+                    "messageId": msg.get("_id"),
+                    "message": msg,
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+        )
+        return 0
+    except ApiError as exc:
+        print(f"ERROR: {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/md2pdf-converter/skill.json

@@ -0,0 +1,20 @@
+{
+  "name": "md2pdf-converter",
+  "version": "2.0.0",
+  "types": [
+    "store"
+  ],
+  "displayName": "Markdown 转 PDF（离线）",
+  "description": "使用 Pandoc 与 WeasyPrint 将 Markdown 转为 PDF，支持中文与彩色表情；可离线使用（需先完成依赖与 Twemoji 缓存）。",
+  "changelog": [
+    {
+      "version": "2.0.0",
+      "date": "2026-04-14",
+      "changes": [
+        "初次提交"
+      ]
+    }
+  ],
+  "createdAt": "2026-04-14",
+  "updatedAt": "2026-04-14"
+}

package/skills/md2pdf-converter/src/SKILL.md

@@ -0,0 +1,244 @@
+---
+name: md2pdf-converter
+description: Offline Markdown to PDF converter with full Unicode support using Pandoc + WeasyPrint + local Twemoji cache. Use when user needs to convert Markdown documents to PDF with Chinese fonts and colorful emojis, or work offline after initial setup.
+metadata:
+  {
+    "openclaw":
+      {
+        "emoji": "📄",
+        "requires": { "bins": ["pandoc", "python3", "wget"] },
+        "install":
+          [
+            {
+              "id": "apt-pandoc",
+              "kind": "apt",
+              "package": "pandoc",
+              "bins": ["pandoc"],
+              "label": "Install Pandoc (apt)",
+            },
+            {
+              "id": "apt-weasyprint",
+              "kind": "apt",
+              "package": "python3-weasyprint",
+              "bins": ["weasyprint"],
+              "label": "Install WeasyPrint (apt)",
+            },
+            {
+              "id": "apt-fonts",
+              "kind": "apt",
+              "package": "fonts-arphic-uming",
+              "bins": [],
+              "label": "Install Chinese fonts (apt)",
+            },
+            {
+              "id": "pip-weasyprint",
+              "kind": "pip",
+              "package": "weasyprint",
+              "bins": ["weasyprint"],
+              "label": "Install WeasyPrint (pip)",
+            },
+          ],
+      },
+  }
+---
+
+# Markdown to PDF Converter (Complete Version)
+
+## Overview
+
+Convert Markdown documents to professional PDFs with **FULL Unicode support**, Chinese fonts, and **colorful emojis** (3660 emojis including all variants). Uses Pandoc + WeasyPrint with a local Twemoji cache to work offline after first run.
+
+## Quick Start
+
+Convert a Markdown file to PDF:
+
+```bash
+bash scripts/md2pdf-local.sh input.md output.pdf
+```
+
+**First run only:** Downloads ~150MB emoji resources (Twemoji 14.0.0) from GitHub. Subsequent runs work offline.
+
+**Example:**
+
+```bash
+bash scripts/md2pdf-local.sh report.md report.pdf
+```
+
+## Features
+
+- ✅ **Full Unicode support** (Chinese, Japanese, Korean)
+- ✅ **Complete emoji support** (Twemoji 14.0.0, 3660 colorful PNGs)
+- ✅ **All emoji variants** (skin tones, hair styles, regional flags, etc.)
+- ✅ **Offline operation** after initial setup
+- ✅ **Professional PDF layout** with page numbers
+- ✅ **Code highlighting**, tables, blockquotes
+- ✅ **Accurate emoji mapping** via Python pre-generated lookup table
+
+## Technical Details
+
+### Dependencies
+
+- **Pandoc** - Universal document converter
+- **WeasyPrint** - CSS-to-PDF renderer
+- **Python 3** - For emoji mapping generation
+- **wget** - For emoji download (first run only)
+
+### How It Works
+
+1. **First run**: Downloads Twemoji 14.0.0 to `~/.cache/md2pdf/emojis/`
+2. **Python script**: Generates emoji → filename mapping table (`emoji_mapping.json`)
+3. **Pandoc**: Converts Markdown to HTML with a Lua filter that replaces emoji characters with local image references
+4. **WeasyPrint**: Renders HTML to PDF using:
+   - AR PL UMing CN for Chinese characters
+   - Local emoji images (PNG, 72x72px, colorful)
+   - Professional CSS styling
+
+### Emoji Cache Location
+
+```
+~/.cache/md2pdf/
+├── emojis/                    # 3660 colorful PNG files
+│   ├── 0023-fe0f-20e3.png
+│   ├── 1f600.png
+│   └── ...
+└── emoji_mapping.json         # Emoji to filename mapping
+    {
+      "🙀": "1f600.png",
+      "⌛": "0023-fe0f-20e3.png",
+      ...
+    }
+```
+
+### Emoji Mapping
+
+The Python script `generate_emoji_mapping.py` scans all Twemoji files and creates a precise mapping from emoji characters to PNG filenames. This ensures accurate emoji replacement even for complex variants like skin tones and regional indicators.
+
+### Fonts
+
+**Primary Chinese font**: AR PL UMing CN
+
+**Fallback**: Noto Sans SC, Noto Sans CJK SC, Microsoft YaHei
+
+**Monospace**: Menlo, Monaco
+
+## Version History
+
+### v2.0 (Current)
+- ✅ Switched to **Twemoji 14.0.0** (complete version)
+- ✅ **3660 colorful emojis** (including all variants)
+- ✅ **Python pre-generated mapping** for accurate emoji replacement
+- ✅ Fixed black-and-white emoji display issue
+- ✅ Proper support for emoji variants (skin tones, hair styles, etc.)
+
+### v1.0 (Previous)
+- Used emoji-datasource-google (~2000-3000 emojis)
+- Simple hex-based filename matching (inaccurate for variants)
+- Some emojis displayed as Unicode characters (black-and-white)
+
+## Troubleshooting
+
+### Font Issues
+
+If Chinese characters display incorrectly, ensure AR PL UMing CN is installed:
+
+```bash
+# Ubuntu/Debian
+sudo apt-get install fonts-arphic-uming
+
+# Check if installed
+fc-list | grep "AR PL UMing"
+```
+
+### Emoji Not Showing
+
+1. Check if emoji cache exists: `ls ~/.cache/md2pdf/emojis/`
+2. Check if mapping exists: `ls ~/.cache/md2pdf/emoji_mapping.json`
+3. If missing, delete cache and re-run: `rm -rf ~/.cache/md2pdf`
+4. Verify emoji file exists: `ls ~/.cache/md2pdf/emojis/1f600.png`
+
+### Emoji Displaying as Black-and-White
+
+This issue has been **FIXED** in v2.0. If you still see black-and-white emojis:
+
+1. Verify you're using the v2.0 script:
+   ```bash
+   grep "TWEMOJI_VERSION" scripts/md2pdf-local.sh
+   # Should show: TWEMOJI_VERSION="14.0.0"
+   ```
+
+2. Clear cache and regenerate:
+   ```bash
+   rm -rf ~/.cache/md2pdf
+   bash scripts/md2pdf-local.sh test.md test.pdf
+   ```
+
+### WeasyPrint Errors
+
+Install missing dependencies:
+
+```bash
+# Ubuntu/Debian
+sudo apt-get install python3-weasyprint
+
+# Or via pip
+pip3 install weasyprint
+```
+
+### Python Script Errors
+
+If `generate_emoji_mapping.py` fails:
+
+```bash
+# Check Python version
+python3 --version
+# Should be Python 3.6+
+
+# Check emoji cache
+ls ~/.cache/md2pdf/emojis
+```
+
+## Resources
+
+### scripts/
+
+**md2pdf-local.sh** - Main conversion script with automatic emoji caching and mapping
+
+**generate_emoji_mapping.py** - Python script to generate emoji lookup table
+
+**Usage**: Direct execution from any location (uses absolute paths):
+
+```bash
+bash /path/to/skills/md2pdf-converter/scripts/md2pdf-local.sh input.md output.pdf
+```
+
+**Key Features**:
+- Automatic Twemoji download and caching
+- Python pre-generated emoji mapping (accurate)
+- Lua filter for emoji replacement
+- CSS styling for professional output
+- Temporary file cleanup (automatic)
+
+## Comparison: v1.0 vs v2.0
+
+| Feature | v1.0 (Old) | v2.0 (New) |
+|---------|----------------|---------------|
+| Emoji Source | emoji-datasource-google | Twemoji 14.0.0 |
+| Emoji Count | ~2000-3000 | 3660 |
+| Color Display | ❌ Unstable | ✅ Stable |
+| Variants Support | ❌ Incomplete | ✅ Complete |
+| Mapping Accuracy | ⚠️ Low | ✅ High |
+| Offline Support | ✅ After first run | ✅ After first run |
+| First Run Size | ~68MB | ~150MB |
+
+## Performance
+
+- **First run**: ~150MB download, 10-30 seconds (depending on network)
+- **Subsequent runs**: Offline, seconds-level conversion
+- **Memory usage**: ~150MB for emoji cache
+- **PDF generation**: 1-5 seconds per page
+
+## Limitations
+
+- Missing emojis (newer than Twemoji 14.0.0) will display as Unicode characters
+- First run requires internet connection (for Twemoji download)
+- Emoji cache size: ~150MB (3660 PNG files at 72x72px)

package/skills/md2pdf-converter/src/_meta.json

@@ -0,0 +1,6 @@
+{
+  "ownerId": "kn738t1fd03w3rjwg0dwkxpvjx810m1v",
+  "slug": "md2pdf-converter",
+  "version": "2.0.0",
+  "publishedAt": 1771124542046
+}

package/skills/md2pdf-converter/src/scripts/generate_emoji_mapping.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""
+generate_emoji_mapping.py
+生成 Twemoji 到 Unicode 代码点的映射表
+"""
+
+import os
+import json
+
+# Twemoji 目录
+TWEMOJI_DIR = os.path.expanduser("~/.cache/md2pdf/emojis")
+
+# 解析 Twemoji 文件名
+# 格式: codepoint(-codepoint).png
+def parse_twemoji_filename(filename):
+    """
+    解析 Twemoji 文件名，返回 Unicode 代码点列表
+    例如: "0023-fe0f-20e3.png" -> [0x23, 0xfe0f, 0x20e3] (⌛)
+    例如: "1f600.png" -> [0x1f600] (🙀)
+    """
+    if not filename.endswith('.png'):
+        return None
+
+    basename = filename[:-4]  # 移除 .png
+    parts = basename.split('-')
+
+    codepoints = []
+    for part in parts:
+        try:
+            codepoint = int(part, 16)
+            codepoints.append(codepoint)
+        except ValueError:
+            # 忽略无效部分（如fe0f这是选择器）
+            continue
+
+    return codepoints if codepoints else None
+
+# 生成映射表
+def generate_mapping():
+    """生成 emoji 到文件路径的映射表"""
+    mapping = {}
+
+    if not os.path.exists(TWEMOJI_DIR):
+        print(f"错误: Twemoji 目录不存在: {TWEMOJI_DIR}")
+        return None
+
+    print(f"正在扫描 Twemoji 目录: {TWEMOJI_DIR}")
+
+    # 扫描所有 PNG 文件
+    for filename in os.listdir(TWEMOJI_DIR):
+        if not filename.endswith('.png'):
+            continue
+
+        codepoints = parse_twemoji_filename(filename)
+        if codepoints:
+            # 将代码点转换为字符串
+            emoji_str = ''.join(chr(cp) for cp in codepoints)
+
+            # 存储映射
+            mapping[emoji_str] = filename
+
+    print(f"✅ 找到 {len(mapping)} 个 emoji")
+
+    # 保存映射表
+    mapping_file = os.path.join(os.path.dirname(TWEMOJI_DIR), "emoji_mapping.json")
+    with open(mapping_file, 'w', encoding='utf-8') as f:
+        json.dump(mapping, f, ensure_ascii=False, indent=2)
+
+    print(f"✅ 映射表已保存至: {mapping_file}")
+
+    return mapping
+
+if __name__ == '__main__':
+    generate_mapping()