sophhub 0.2.3 → 0.3.0

package/skills/notes-hub-assistant/src/scripts/openclaw_wolai_notes_crud.py

@@ -0,0 +1,364 @@
+#!/usr/bin/env python3
+"""Wolai OpenAPI CRUD orchestrator."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Dict, List, Optional
+
+
+class WolaiError(Exception):
+    def __init__(self, message: str, code: str = "wolai_error", detail: Any = None):
+        super().__init__(message)
+        self.code = code
+        self.detail = detail
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Wolai note CRUD via OpenAPI")
+    parser.add_argument(
+        "--op",
+        required=True,
+        choices=["create", "read", "read-children", "update", "delete", "search"],
+        help="wolai operation",
+    )
+    parser.add_argument("--id", help="block/page id")
+    parser.add_argument("--parent-id", help="parent page or block id")
+    parser.add_argument("--content", help="plain text content for simple text blocks")
+    parser.add_argument(
+        "--block-json",
+        help='raw JSON for blocks payload, e.g. {"type":"text","content":"Hello"}',
+    )
+    parser.add_argument("--query", help="keyword for lightweight search")
+    parser.add_argument("--cursor", help="pagination cursor")
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=50,
+        help="page size for list endpoints (max 200 recommended)",
+    )
+
+    parser.add_argument(
+        "--app-token", help="Wolai app token; if missing, read WOLAI_APP_TOKEN env"
+    )
+    parser.add_argument("--app-id", help="Wolai app id; fallback WOLAI_APP_ID env")
+    parser.add_argument(
+        "--app-secret", help="Wolai app secret; fallback WOLAI_APP_SECRET env"
+    )
+    parser.add_argument(
+        "--base-url",
+        default=os.environ.get("WOLAI_OPENAPI_BASE_URL", "https://openapi.wolai.com/v1"),
+        help="Wolai OpenAPI base url",
+    )
+    return parser.parse_args()
+
+
+def normalize_base_url(base_url: str) -> str:
+    return base_url.rstrip("/")
+
+
+def parse_json_arg(raw: Optional[str], *, arg_name: str) -> Any:
+    if not raw:
+        return None
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError as exc:
+        raise WolaiError(
+            f"{arg_name} must be valid JSON",
+            code="validation",
+            detail={"arg": arg_name},
+        ) from exc
+
+
+def build_text_block(content: str) -> Dict[str, Any]:
+    return {"type": "text", "content": content}
+
+
+def request_json(
+    method: str,
+    url: str,
+    token: Optional[str] = None,
+    payload: Optional[Dict[str, Any]] = None,
+) -> Any:
+    body = None
+    base_headers = {
+        "Accept": "application/json",
+    }
+    if payload is not None:
+        body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+        base_headers["Content-Type"] = "application/json; charset=utf-8"
+
+    auth_variants: List[Optional[str]] = [None]
+    if token:
+        token_value = str(token).strip()
+        auth_variants = [token_value]
+        if token_value.lower().startswith("bearer "):
+            raw_token = token_value[7:].strip()
+            if raw_token:
+                auth_variants.append(raw_token)
+        else:
+            auth_variants.append(f"Bearer {token_value}")
+
+    last_http_error: Optional[urllib.error.HTTPError] = None
+    for idx, auth in enumerate(auth_variants):
+        headers = dict(base_headers)
+        if auth:
+            headers["Authorization"] = auth
+        req = urllib.request.Request(url=url, method=method, data=body, headers=headers)
+        try:
+            with urllib.request.urlopen(req) as resp:
+                raw = resp.read().decode("utf-8")
+                if not raw:
+                    return {}
+                return json.loads(raw)
+        except urllib.error.HTTPError as exc:
+            last_http_error = exc
+            can_retry_auth = idx < len(auth_variants) - 1 and exc.code in (401, 403)
+            if can_retry_auth:
+                continue
+
+            raw = exc.read().decode("utf-8", errors="replace")
+            detail: Dict[str, Any] = {
+                "status": exc.code,
+                "body": raw,
+                "url": url,
+                "auth_variant": auth,
+            }
+            message = f"Wolai API request failed ({exc.code})"
+            try:
+                err_payload = json.loads(raw) if raw else {}
+                if isinstance(err_payload, dict):
+                    if err_payload.get("message"):
+                        message = str(err_payload["message"])
+                    detail["response"] = err_payload
+            except json.JSONDecodeError:
+                pass
+            raise WolaiError(message, code="http_error", detail=detail) from exc
+        except urllib.error.URLError as exc:
+            raise WolaiError(
+                f"network error: {exc.reason}",
+                code="network_error",
+                detail={"url": url},
+            ) from exc
+
+    if last_http_error:
+        raise WolaiError(
+            f"Wolai API request failed ({last_http_error.code})",
+            code="http_error",
+            detail={"url": url},
+        )
+    raise WolaiError("unexpected request flow", code="internal_error", detail={"url": url})
+
+
+def extract_app_token(payload: Dict[str, Any]) -> Optional[str]:
+    app_token = payload.get("app_token")
+    if isinstance(app_token, str) and app_token.strip():
+        return app_token.strip()
+
+    app_token_obj = payload.get("appToken")
+    if isinstance(app_token_obj, str) and app_token_obj.strip():
+        return app_token_obj.strip()
+    if isinstance(app_token_obj, dict):
+        nested = app_token_obj.get("app_token") or app_token_obj.get("appToken")
+        if isinstance(nested, str) and nested.strip():
+            return nested.strip()
+
+    data_obj = payload.get("data")
+    if isinstance(data_obj, dict):
+        nested = (
+            data_obj.get("app_token")
+            or data_obj.get("appToken")
+            or ((data_obj.get("appToken") or {}).get("app_token") if isinstance(data_obj.get("appToken"), dict) else None)
+        )
+        if isinstance(nested, str) and nested.strip():
+            return nested.strip()
+    return None
+
+
+def resolve_token(args: argparse.Namespace, base_url: str) -> str:
+    explicit = args.app_token or os.environ.get("WOLAI_APP_TOKEN")
+    if explicit:
+        return explicit
+
+    app_id = args.app_id or os.environ.get("WOLAI_APP_ID")
+    app_secret = args.app_secret or os.environ.get("WOLAI_APP_SECRET")
+    if not app_id or not app_secret:
+        raise WolaiError(
+            "missing app token or app credentials (WOLAI_APP_TOKEN / WOLAI_APP_ID + WOLAI_APP_SECRET)",
+            code="missing_credentials",
+        )
+
+    payload = request_json(
+        "POST",
+        f"{base_url}/token",
+        payload={"appId": app_id, "appSecret": app_secret},
+    )
+    if not isinstance(payload, dict):
+        raise WolaiError("unexpected token response", code="invalid_token_response")
+    app_token = extract_app_token(payload)
+    if not app_token:
+        raise WolaiError(
+            "token response missing app token field",
+            code="invalid_token_response",
+            detail=payload,
+        )
+    return str(app_token)
+
+
+def create_block(args: argparse.Namespace, base_url: str, token: str) -> Any:
+    if not args.parent_id:
+        raise WolaiError("missing --parent-id for create", code="validation")
+    blocks = parse_json_arg(args.block_json, arg_name="--block-json")
+    if blocks is None:
+        if not args.content:
+            raise WolaiError(
+                "missing --content or --block-json for create", code="validation"
+            )
+        blocks = build_text_block(args.content)
+    return request_json(
+        "POST",
+        f"{base_url}/blocks",
+        token=token,
+        payload={"parent_id": args.parent_id, "blocks": blocks},
+    )
+
+
+def read_block(args: argparse.Namespace, base_url: str, token: str) -> Any:
+    if not args.id:
+        raise WolaiError("missing --id for read", code="validation")
+    return request_json("GET", f"{base_url}/blocks/{args.id}", token=token)
+
+
+def read_children(args: argparse.Namespace, base_url: str, token: str) -> Any:
+    target_id = args.id or args.parent_id
+    if not target_id:
+        raise WolaiError("missing --id or --parent-id for read-children", code="validation")
+    query: Dict[str, Any] = {}
+    if args.cursor:
+        query["cursor"] = args.cursor
+    if args.limit:
+        query["limit"] = args.limit
+    url = f"{base_url}/blocks/{target_id}/children"
+    if query:
+        url = f"{url}?{urllib.parse.urlencode(query)}"
+    return request_json("GET", url, token=token)
+
+
+def update_block(args: argparse.Namespace, base_url: str, token: str) -> Any:
+    if not args.id:
+        raise WolaiError("missing --id for update", code="validation")
+    blocks = parse_json_arg(args.block_json, arg_name="--block-json")
+    if blocks is None:
+        if not args.content:
+            raise WolaiError(
+                "missing --content or --block-json for update", code="validation"
+            )
+        blocks = build_text_block(args.content)
+    payload = {"blocks": blocks}
+    # Wolai docs evolve; try PATCH first, then PUT.
+    try:
+        return request_json(
+            "PATCH",
+            f"{base_url}/blocks/{args.id}",
+            token=token,
+            payload=payload,
+        )
+    except WolaiError as first_exc:
+        try:
+            return request_json(
+                "PUT",
+                f"{base_url}/blocks/{args.id}",
+                token=token,
+                payload=payload,
+            )
+        except WolaiError as second_exc:
+            raise WolaiError(
+                "update failed with both PATCH and PUT",
+                code="update_failed",
+                detail={"patch_error": first_exc.detail, "put_error": second_exc.detail},
+            ) from second_exc
+
+
+def delete_block(args: argparse.Namespace, base_url: str, token: str) -> Any:
+    if not args.id:
+        raise WolaiError("missing --id for delete", code="validation")
+    return request_json("DELETE", f"{base_url}/blocks/{args.id}", token=token)
+
+
+def search_blocks(args: argparse.Namespace, base_url: str, token: str) -> Any:
+    # OpenAPI currently has no dedicated full-text search endpoint in this skill.
+    # We do lightweight filtering from children list.
+    if not args.parent_id and not args.id:
+        raise WolaiError(
+            "search requires --parent-id (or --id) as search scope",
+            code="validation",
+        )
+    if not args.query:
+        raise WolaiError("missing --query for search", code="validation")
+    data = read_children(args, base_url, token)
+    if not isinstance(data, dict):
+        return {"matches": [], "raw": data}
+
+    records = data.get("data")
+    if not isinstance(records, list):
+        return {"matches": [], "raw": data}
+
+    needle = args.query.lower()
+    matches: List[Dict[str, Any]] = []
+    for item in records:
+        if not isinstance(item, dict):
+            continue
+        hay = json.dumps(item, ensure_ascii=False).lower()
+        if needle in hay:
+            matches.append(item)
+    return {
+        "matches": matches,
+        "total": len(matches),
+        "has_more": data.get("has_more"),
+        "next_cursor": data.get("next_cursor"),
+    }
+
+
+def run(args: argparse.Namespace) -> Any:
+    base_url = normalize_base_url(args.base_url)
+    token = resolve_token(args, base_url)
+    if args.op == "create":
+        return create_block(args, base_url, token)
+    if args.op == "read":
+        return read_block(args, base_url, token)
+    if args.op == "read-children":
+        return read_children(args, base_url, token)
+    if args.op == "update":
+        return update_block(args, base_url, token)
+    if args.op == "delete":
+        return delete_block(args, base_url, token)
+    if args.op == "search":
+        return search_blocks(args, base_url, token)
+    raise WolaiError(f"unsupported op: {args.op}", code="validation")
+
+
+def main() -> int:
+    args = parse_args()
+    try:
+        data = run(args)
+        out = {"ok": True, "op": args.op, "data": data, "error": None}
+    except WolaiError as exc:
+        out = {
+            "ok": False,
+            "op": args.op,
+            "data": None,
+            "error": {"code": exc.code, "message": str(exc), "detail": exc.detail},
+        }
+    json.dump(out, sys.stdout, ensure_ascii=False, indent=2)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/notes-hub-assistant/src/scripts/run_meeting_minutes.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""Cross-platform entrypoint for meeting minutes flow."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+from urllib.parse import urlparse
+
+from _resolve_lark_cli import resolve_lark_cli_prefix
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Run meeting-minutes flow from Feishu minutes URL or token."
+    )
+    parser.add_argument("minutes_url_or_token", help="minutes URL or minute_token")
+    parser.add_argument(
+        "--output-dir",
+        default=str(Path.home() / ".openclaw" / "workspace" / ".meeting-minutes"),
+        help="artifact output dir",
+    )
+    parser.add_argument("--job-id", help="optional custom job id")
+    return parser.parse_args()
+
+
+def extract_token(raw: str) -> str:
+    if raw.startswith("http://") or raw.startswith("https://"):
+        parsed = urlparse(raw)
+        token = parsed.path.rstrip("/").split("/")[-1]
+        return token
+    return raw.strip()
+
+
+def main() -> int:
+    args = parse_args()
+    token = extract_token(args.minutes_url_or_token)
+    if not token:
+        print(
+            json.dumps(
+                {"status": "failed", "error_message": "missing minute_token"},
+                ensure_ascii=False,
+            )
+        )
+        return 1
+
+    script_dir = Path(__file__).resolve().parent
+    base_dir = script_dir.parent
+    cli_prefix = resolve_lark_cli_prefix(base_dir)
+    runner = script_dir / "openclaw_meeting_minutes.py"
+    job_id = args.job_id or f"meeting-minutes-{token}"
+
+    proc = subprocess.run(
+        [
+            sys.executable,
+            str(runner),
+            *sum([["--lark-cli-prefix", p] for p in cli_prefix], []),
+            "--minute-token",
+            token,
+            "--job-id",
+            job_id,
+            "--output-dir",
+            args.output_dir,
+        ],
+        capture_output=True,
+        text=True,
+    )
+    if proc.stdout:
+        sys.stdout.write(proc.stdout)
+    if proc.stderr:
+        sys.stderr.write(proc.stderr)
+    return proc.returncode
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/notes-hub-assistant/src/scripts/run_note_crud.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+"""Cross-platform entrypoint for note CRUD flow."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+from _resolve_lark_cli import resolve_lark_cli_prefix
+
+
+def main() -> int:
+    script_dir = Path(__file__).resolve().parent
+    base_dir = script_dir.parent
+    cli_prefix = resolve_lark_cli_prefix(base_dir)
+    runner = script_dir / "openclaw_notes_crud.py"
+
+    proc = subprocess.run(
+        [
+            sys.executable,
+            str(runner),
+            *sum([["--lark-cli-prefix", p] for p in cli_prefix], []),
+            *sys.argv[1:],
+        ],
+        capture_output=True,
+        text=True,
+    )
+    if proc.stdout:
+        sys.stdout.write(proc.stdout)
+    if proc.stderr:
+        sys.stderr.write(proc.stderr)
+    return proc.returncode
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/notes-hub-assistant/src/scripts/run_notionbot.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+"""Cross-platform local wrapper for vibe-notionbot."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+
+
+def resolve_prefix() -> list[str]:
+    npx = shutil.which("npx")
+    if npx:
+        return [npx, "-y", "-p", "vibe-notion", "vibe-notionbot"]
+
+    local_bin = shutil.which("vibe-notionbot")
+    if local_bin:
+        return [local_bin]
+
+    raise FileNotFoundError(
+        "missing notion runner: npx or vibe-notionbot not found on PATH."
+    )
+
+
+def main() -> int:
+    prefix = resolve_prefix()
+    proc = subprocess.run(prefix + sys.argv[1:], capture_output=True, text=True)
+    if proc.stdout:
+        sys.stdout.write(proc.stdout)
+    if proc.stderr:
+        sys.stderr.write(proc.stderr)
+    return proc.returncode
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/notes-hub-assistant/src/scripts/run_wolai_note_crud.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+"""Cross-platform entrypoint for Wolai OpenAPI note CRUD flow."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+
+def main() -> int:
+    script_dir = Path(__file__).resolve().parent
+    runner = script_dir / "openclaw_wolai_notes_crud.py"
+    proc = subprocess.run(
+        [sys.executable, str(runner), *sys.argv[1:]],
+        capture_output=True,
+        text=True,
+    )
+    if proc.stdout:
+        sys.stdout.write(proc.stdout)
+    if proc.stderr:
+        sys.stderr.write(proc.stderr)
+    return proc.returncode
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/skillhub/skill.json

@@ -1,12 +1,19 @@
 {
   "name": "skillhub",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "types": [
     "builtin"
   ],
-  "displayName": "",
-  "description": "",
+  "displayName": "技能商店与安装",
+  "description": "在 Sophnet/Sophclaw 上搜索、列出、安装 skill（含 UI 设计等关键词）；SophHub 优先，ClawHub 兜底。",
   "changelog": [
+    {
+      "version": "2.0.1",
+      "date": "2026-04-16",
+      "changes": [
+        "扩充 SKILL.md 触发描述：覆盖「Sophnet UI 设计 skill」「再找一下」等口语检索场景"
+      ]
+    },
     {
       "version": "2.0.0",
       "date": "2026-04-09",
@@ -16,5 +23,5 @@
     }
   ],
   "createdAt": "2026-04-09",
-  "updatedAt": "2026-04-09"
+  "updatedAt": "2026-04-16"
 }

package/skills/skillhub/src/SKILL.md

@@ -1,12 +1,22 @@
 ---
 name: skillhub
-description: 当用户要求搜索、安装 skill （包括Sophnet/Sophclaw平台和clawhub社区） 时使用此 skill。
+description: 当用户要在 Sophnet / Sophclaw / OpenClaw 上查找、搜索、列出或安装 skill（技能、插件）时使用；包括「商店里有没有某某 skill」「Sophnet 有没有 UI 设计 / 前端 / 图表 / 自动化 相关 skill」「再去 SophHub 找一下」「用 npx sophhub 搜 skill」等说法。也适用于 clawhub、社区技能商店、下载 skill 到本地。与具体业务实现无关、仅涉及「发现与安装技能」时选本 skill。
 ---
 
 # SkillHub
 
 统一的技能安装入口，整合 Sophnet 平台 Sophclaw 的技能商店（SophHub，优先）和 **ClawHub**（社区商店，兜底）。
 
+## 何时应使用本 Skill（触发提示）
+
+用户可能用口语或中英文混说，只要意图是 **在商店里找 skill / 安装 skill**，即应走本流程，例如：
+
+- 「Sophnet / sophnet 有没有 **UI 设计** / UX / 界面 / 前端 相关的 skill？」「商店里有没有做海报 / 图表 / 视频的 skill？」
+- 「你再去 **找一下** skill」「在 SophHub / 技能商店 **搜一下**」「**列出** 商店里能装的技能」
+- 「**安装** 某个 skill」「从 Sophnet 平台 **下载** skill 到本地」「npx sophhub 怎么用」
+
+**不要**把「已经知道 skill 名称、只想写业务代码」误判为本 skill；但若用户明确要先在商店里 **检索、确认、安装** 再使用，仍用本 skill。
+
 ## 安装流程
 
 当用户需要安装一个技能时，按以下顺序操作：

package/skills/sophnet-dailynews/skill.json

@@ -0,0 +1,20 @@
+{
+  "name": "sophnet-dailynews",
+  "version": "1.0.0",
+  "types": [
+    "store"
+  ],
+  "displayName": "每日新闻助手",
+  "description": "支持实时新闻检索、分类、摘要与分析，以及基于 AI 的个性化新闻推荐和深度报道。",
+  "changelog": [
+    {
+      "version": "1.0.0",
+      "date": "2026-04-14",
+      "changes": [
+        "初次提交"
+      ]
+    }
+  ],
+  "createdAt": "2026-04-14",
+  "updatedAt": "2026-04-14"
+}