@acedatacloud/skills 2026.630.1 → 2026.701.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acedatacloud/skills",
-  "version": "2026.630.1",
+  "version": "2026.701.0",
   "description": "Agent Skills for AceDataCloud AI services — music, image, video generation, LLM chat, web search. Compatible with Claude Code, GitHub Copilot, Gemini CLI, OpenAI Codex, and 30+ AI coding agents.",
   "keywords": [
     "agent-skills",

package/skills/zhihu/SKILL.md

@@ -1,34 +1,102 @@
 ---
 name: zhihu
-description: Read and publish on Zhihu (知乎) with the user's own login cookies (BYOC) — list their published articles with vote/comment stats, inspect one article, and publish a new article. Use when the user mentions 知乎 / Zhihu, "我的知乎文章", reading their article stats (点赞/评论), or publishing/发文 to Zhihu.
+description: Search Zhihu & the web, get trending topics, and read/publish on Zhihu (知乎) — search Zhihu content or the entire web via the official Developer Platform API, get hot topics (热榜), list published articles & answers with stats, inspect content, publish articles, and answer questions. Use when the user mentions 知乎 / Zhihu, 搜索知乎, 全网搜索, 热榜, "我的知乎文章/回答", reading stats, 发文, or 回答问题.
 when_to_use: |
-  Trigger for anything on the user's Zhihu (知乎) account driven by their own
-  login cookie: show who they are, list their published articles with
-  vote-up / comment counts, look at one article's stats, or publish a new
-  article. This acts as the user's real account, so writes are gated behind
-  an explicit confirmation.
+  Trigger for anything involving Zhihu (知乎):
+  - Searching Zhihu content (站内搜索) or the entire web (全网搜索)
+  - Getting Zhihu trending topics (热榜)
+  - Reading the user's own articles/answers with stats
+  - Publishing articles or answering questions (gated behind confirmation)
+  Search commands use the Zhihu Developer Platform API (Bearer token auth).
+  Read/write commands use the user's login cookies (BYOC).
 connections: [zhihu]
 allowed_tools: [Bash]
 license: Apache-2.0
 metadata:
   author: acedatacloud
-  version: "1.1"
+  version: "2.0"
 ---
 
-# zhihu — read & publish on Zhihu via your own cookies
+# zhihu — search, read & publish on Zhihu
 
-Drives the user's **real** Zhihu account through the same web APIs the site's
-own editor uses, authenticated by the login cookie they captured with the ACE
-extension. No browser, no third-party deps — just `urllib`.
+Two authentication layers, two scripts:
 
-The connector injects the cookie jar as an env var:
+| Script | Auth | Capabilities |
+|---|---|---|
+| `scripts/search.py` | `ZHIHU_DEVELOPER_TOKEN` (Bearer) | Search Zhihu, search the web, get hot topics |
+| `scripts/blog.py` | `ZHIHU_COOKIES` (login cookie) | Read/write own articles & answers |
 
+No browser, no third-party deps — just `urllib`.
+
+The connector injects credentials as env vars:
+
+- `ZHIHU_DEVELOPER_TOKEN` — Zhihu Developer Platform access secret (Bearer token).
+  Used for search and hot-list queries. **Secret — never echo or print it.**
 - `ZHIHU_COOKIES` — a JSON array of `{name, value, domain, path, ...}` cookies.
-  **Secret — never echo or print it.** The CLI reads it for you.
+  Used for reading/writing the user's own content. **Secret — never echo or print it.**
+
+## Search CLI (search.py)
+
+[`scripts/search.py`](scripts/search.py) — search Zhihu and the web. Requires
+only `ZHIHU_DEVELOPER_TOKEN` (no cookies needed).
+
+```sh
+SEARCH=$SKILL_DIR/scripts/search.py
+
+# Search Zhihu content (站内搜索) — questions, answers, articles
+python3 $SEARCH search "Python 爬虫"
+python3 $SEARCH search "Python 爬虫" --count 5
+
+# Search the entire web (全网搜索) — all indexed sites
+python3 $SEARCH global "AI Agent"
+python3 $SEARCH global "AI Agent" --count 15
+
+# Filter by site or time
+python3 $SEARCH global "React" --filter 'host=="github.com"'
+python3 $SEARCH global "新闻" --filter 'publish_time>=1720000000'
+python3 $SEARCH global "技术" --filter 'host=="github.com" AND publish_time>=1720000000'
+python3 $SEARCH global "实时新闻" --db realtime
+
+# Get Zhihu trending topics (热榜)
+python3 $SEARCH hot
+python3 $SEARCH hot --limit 10
+```
+
+### Search commands
+
+| Goal | Command |
+|---|---|
+| Search Zhihu (max 10 results) | `python3 $SEARCH search "<query>" --count N` |
+| Search entire web (max 20) | `python3 $SEARCH global "<query>" --count N` |
+| Filter by site | `--filter 'host=="example.com"'` |
+| Filter by time | `--filter 'publish_time>=<unix_ts>'` |
+| Search only realtime/static index | `--db realtime` or `--db static` |
+| Zhihu trending topics (max 30) | `python3 $SEARCH hot --limit N` |
+
+### Search result fields
 
-## CLI
+**zhihu_search** returns: title, type (Article/Answer), content_id, url,
+excerpt, vote_up (赞同), comments, author, authority level, edit_time.
+
+**global_search** returns the same fields plus has_more indicator. The `url`
+includes utm tracking params from Zhihu's platform.
+
+**hot_list** returns: rank, title, url, summary, thumbnail.
+
+### global_search Filter syntax
+
+- `host=="example.com"` — filter by domain (note: `host=="zhihu.com"` not
+  supported — use `search` command instead)
+- `publish_time>=1720000000` — filter by publish time (unix seconds)
+- Logical operators: `AND`, `OR` (must be uppercase)
+- Parentheses for grouping: `(host=="a.com" OR host=="b.com") AND publish_time>=T`
+
+---
+
+## Blog CLI (blog.py)
 
 The skill ships [`scripts/blog.py`](scripts/blog.py) — self-contained, stdlib only.
+Requires `ZHIHU_COOKIES` (login cookie).
 
 ```sh
 BLOG=$SKILL_DIR/scripts/blog.py
@@ -37,6 +105,9 @@ BLOG=$SKILL_DIR/scripts/blog.py
 python3 $BLOG whoami                       # who is logged in
 python3 $BLOG articles --limit 20          # my published articles + stats
 python3 $BLOG article <article-id>         # one article's details + stats
+python3 $BLOG answers --limit 20           # my published answers + stats
+python3 $BLOG answer <answer-id>           # one answer's details + stats
+python3 $BLOG question <question-id>       # a question's info + whether I answered it
 ```
 
 ## Verify the connection first
@@ -56,11 +127,21 @@ extension). Do **not** retry in a loop.
 |---|---|
 | Who am I | `python3 $BLOG whoami` |
 | My latest articles + vote/comment counts | `python3 $BLOG articles --limit 20` |
-| Next page | `python3 $BLOG articles --limit 20 --offset 20` |
+| My latest answers + like/favorite/comment counts | `python3 $BLOG answers --limit 20` |
+| Next page (any list) | add `--offset 20` |
 | One article's stats | `python3 $BLOG article <id>` |
+| One answer's stats (incl. 赞同 voteup) | `python3 $BLOG answer <id>` |
+| A question's info + my answer id (if any) | `python3 $BLOG question <id>` |
+
+Article stats: `voteup_count` (赞同), `comment_count` (评论). Zhihu does not
+expose per-article read counts on these endpoints.
 
-Stats come straight from Zhihu: `voteup_count` (赞同), `comment_count` (评论).
-Zhihu does not expose per-article read counts on these endpoints.
+**Answer stat caveat:** the `answers` *list* endpoint does **not** return
+`voteup_count` (赞同) — it only exposes `like_count` (喜欢), `favorite_count`
+(收藏) and `comment_count`. For the authoritative 赞同 count of an answer, call
+`answer <id>` (the single-answer endpoint returns `voteup_count`). `question <id>`
+reports `already_answered` + `my_answer_id` so you know whether to use
+`answer-question` (new) or `edit-answer` (update).
 
 ## Publishing — GATED (dry-run unless trailing `--confirm`)
 
@@ -88,10 +169,46 @@ python3 $BLOG publish --title "标题" --content-file article.html --confirm
   reports `images_found`. Pass `--no-images` to skip this. So you can hand the
   CLI HTML/Markdown with normal public image URLs and the pictures survive.
 
+## Answering questions — GATED (dry-run unless trailing `--confirm`)
+
+Two write commands cover the question/answer side. Both gate exactly like
+`publish`: no trailing `--confirm` → **dry-run**; `--confirm` is honored **only
+as the last argument**. Always show the dry-run, get an explicit "yes", then
+re-run with `--confirm` last.
+
+```sh
+# Content is HTML (same as articles). For Markdown, convert to HTML first.
+
+# Post a NEW answer to a question
+python3 $BLOG answer-question --question <qid> --content-file ans.html                       # dry-run
+python3 $BLOG answer-question --question <qid> --content-file ans.html --draft-only --confirm  # PRIVATE draft (safe)
+python3 $BLOG answer-question --question <qid> --content-file ans.html --confirm               # PUBLIC, goes live
+
+# Edit an EXISTING answer (replaces its live, public content)
+python3 $BLOG edit-answer --id <answer-id> --content-file ans.html             # dry-run
+python3 $BLOG edit-answer --id <answer-id> --content-file ans.html --confirm   # overwrites live answer
+```
+
+- **One answer per question.** Zhihu allows a single answer per user per
+  question. If the user already answered, `answer-question --confirm` returns a
+  clear error telling you to use `edit-answer` instead — find the existing answer
+  id with `answers` or `question <qid>` (which reports `my_answer_id`).
+- **`--draft-only` is the safe path for new answers** — it saves a *private*
+  draft on the question (nothing public). The user reviews it on Zhihu, then you
+  re-run without `--draft-only` (with `--confirm`) to publish. Prefer this unless
+  the user clearly asked to go live immediately.
+- **`edit-answer` has no private mode** — the answer is already public, so any
+  `--confirm` edit is live immediately. It preserves the answer's current repost
+  setting unless you override with `--repost allowed|disallowed`.
+- **转载授权** (`--repost allowed|disallowed`): new answers default to
+  `disallowed` (don't grant repost rights); editing keeps the current setting.
+- **Images are auto-hosted** for answers too — same behavior and `--no-images`
+  flag as `publish`.
+
 ## Gotchas — surface before the user is surprised
 
-- **This is the user's real Zhihu account.** Confirm before any publish; reading
-  exposes their own private drafts.
+- **This is the user's real Zhihu account.** Confirm before any publish / answer /
+  edit; reading exposes their own private drafts.
 - **Cookie expiry**: Zhihu cookies are short-lived. A `401`/`403` means
   reconnect at auth.acedata.cloud/user/connections — never loop-retry.
 - **ToS**: cookie automation is against most platforms' terms. This only ever

package/skills/zhihu/scripts/blog.py

@@ -165,6 +165,12 @@ ZH = {
     "articles": "https://www.zhihu.com/api/v4/members/{token}/articles",
     "article": "https://www.zhihu.com/api/v4/articles/{id}",
     "create_draft": "https://zhuanlan.zhihu.com/api/articles/drafts",
+    # Answers (回答) — the question/answer side of Zhihu, distinct from articles.
+    "member_answers": "https://www.zhihu.com/api/v4/members/{token}/answers",
+    "answer": "https://www.zhihu.com/api/v4/answers/{id}",
+    "question": "https://www.zhihu.com/api/v4/questions/{id}",
+    "question_answers": "https://www.zhihu.com/api/v4/questions/{id}/answers",
+    "question_draft": "https://www.zhihu.com/api/v4/questions/{id}/draft",
 }
 ZH_FETCH = {"x-requested-with": "fetch"}
 
@@ -245,6 +251,141 @@ def cmd_article(jar, args):
     out(res)
 
 
+# ── Answers (回答) ───────────────────────────────────────────────────
+#
+# Answers are Zhihu's question/answer side, separate from articles. A user has
+# at most ONE answer per question (a second POST returns RepeatedActionException
+# 103003 — surface that and point at edit-answer). Writes go through the same
+# cookie-only web APIs as articles; no x-zse signature is required.
+
+ZH_ANSWER_LIST_INCLUDE = (
+    "data[*].comment_count,created_time,updated_time,question"
+)
+
+
+def _fmt_answer(a: dict) -> dict:
+    aid = a.get("id")
+    q = a.get("question") or {}
+    qid = q.get("id")
+    # The member/answers endpoint never returns voteup_count (赞同); it only
+    # exposes like_count / favorites under reaction.statistics. The authoritative
+    # 赞同 count lives on the single-answer detail endpoint (`answer <id>`).
+    react = (a.get("reaction") or {}).get("statistics") or {}
+    return {
+        "answer_id": str(aid) if aid is not None else None,
+        "question_id": str(qid) if qid is not None else None,
+        "question_title": q.get("title"),
+        "url": (f"https://www.zhihu.com/question/{qid}/answer/{aid}" if (qid and aid) else None),
+        "voteup_count": a.get("voteup_count"),
+        "like_count": react.get("like_count"),
+        "favorite_count": react.get("favorites"),
+        "comment_count": a.get("comment_count"),
+        "created_time": a.get("created_time"),
+        "updated_time": a.get("updated_time"),
+    }
+
+
+def cmd_answers(jar, args):
+    me = zh_me(jar)
+    token = me.get("url_token")
+    if not token:
+        die("Zhihu profile has no url_token; cannot list answers.")
+    url = ZH["member_answers"].format(token=token)
+    q = urllib.parse.urlencode({
+        "include": ZH_ANSWER_LIST_INCLUDE,
+        "limit": args.limit,
+        "offset": args.offset,
+    })
+    _, data = get_json(f"{url}?{q}", jar, headers=ZH_FETCH)
+    items = data.get("data", []) if isinstance(data, dict) else []
+    out({
+        "total": (data.get("paging") or {}).get("totals") if isinstance(data, dict) else None,
+        "count": len(items),
+        "answers": [_fmt_answer(a) for a in items],
+    })
+
+
+def cmd_answer(jar, args):
+    base = ZH["answer"].format(id=args.id)
+    q = urllib.parse.urlencode({
+        "include": "content,voteup_count,comment_count,created_time,updated_time,question",
+    })
+    _, a = get_json(f"{base}?{q}", jar, headers=ZH_FETCH)
+    if not isinstance(a, dict) or not a.get("id"):
+        die(f"answer {args.id} not found or not accessible: {str(a)[:300]}")
+    res = _fmt_answer(a)
+    res["content_excerpt"] = (a.get("excerpt") or "")[:200]
+    out(res)
+
+
+def cmd_question(jar, args):
+    base = ZH["question"].format(id=args.id)
+    q = urllib.parse.urlencode({
+        "include": "answer_count,follower_count,visit_count,comment_count,detail",
+    })
+    _, qd = get_json(f"{base}?{q}", jar, headers=ZH_FETCH)
+    if not isinstance(qd, dict) or not (qd.get("id") or qd.get("title")):
+        die(f"question {args.id} not found or not accessible: {str(qd)[:300]}")
+    # Detect whether the logged-in user already answered this question so the
+    # caller knows to use `edit-answer` instead of `answer-question`.
+    mine = _my_answer_for_question(jar, args.id)
+    out({
+        "question_id": str(qd.get("id") or args.id),
+        "title": qd.get("title"),
+        "url": f"https://www.zhihu.com/question/{args.id}",
+        "answer_count": qd.get("answer_count"),
+        "follower_count": qd.get("follower_count"),
+        "visit_count": qd.get("visit_count"),
+        "detail_excerpt": _strip_tags(qd.get("detail") or "")[:300],
+        "my_answer_id": mine,
+        "already_answered": bool(mine),
+    })
+
+
+_TAG_RE = re.compile(r"<[^>]+>")
+
+
+def _strip_tags(html: str) -> str:
+    return _TAG_RE.sub("", html or "").strip()
+
+
+def _my_answer_for_question(jar, question_id: str):
+    """Return the logged-in user's answer id for a question, or None.
+
+    Scans the *user's own* answers (bounded by their answer count) and matches
+    on question id. This is reliable even for popular questions — unlike walking
+    the question's own answer list, which may have thousands of entries. For an
+    account with more answers than the scan cap this is best-effort.
+    """
+    me = zh_me(jar)
+    token = me.get("url_token")
+    if not token:
+        return None
+    url = ZH["member_answers"].format(token=token)
+    qid = str(question_id)
+    offset = 0
+    for _ in range(15):  # up to 300 of the user's own answers
+        q = urllib.parse.urlencode({
+            "include": "data[*].question",
+            "limit": 20,
+            "offset": offset,
+        })
+        status, data = request("GET", f"{url}?{q}", jar, headers=ZH_FETCH)
+        try:
+            data = json.loads(data)
+        except json.JSONDecodeError:
+            return None
+        items = data.get("data", []) if isinstance(data, dict) else []
+        for a in items:
+            if str((a.get("question") or {}).get("id")) == qid:
+                return str(a.get("id"))
+        if (data.get("paging") or {}).get("is_end", True) or not items:
+            return None
+        offset += 20
+    return None
+
+
+
 # ── Image re-hosting ────────────────────────────────────────
 #
 # Zhihu silently drops any <img> whose src is not on its own CDN, so external
@@ -539,11 +680,187 @@ def cmd_publish(jar, args):
     })
 
 
+def _read_content(args) -> str:
+    content = args.content
+    if args.content_file:
+        try:
+            with open(args.content_file, encoding="utf-8") as f:
+                content = f.read()
+        except OSError as e:
+            die(f"cannot read --content-file: {e}")
+    if content is None:
+        die("provide --content-file <path> or --content <html>")
+    return content
+
+
+def _reshipment(value):
+    # Zhihu accepts "allowed" / "disallowed" for 转载授权 (repost permission).
+    return value if value in ("allowed", "disallowed") else None
+
+
+def cmd_answer_question(jar, args):
+    """Post a NEW answer to a question (GATED). --draft-only saves a private draft."""
+    qid = args.question
+    if not qid:
+        die("--question <question-id> is required")
+    content = _read_content(args)
+    # Fetch the question title so the dry-run shows what is being answered.
+    title = None
+    try:
+        _, qd = get_json(
+            f"{ZH['question'].format(id=qid)}?{urllib.parse.urlencode({'include': 'title'})}",
+            jar, headers=ZH_FETCH,
+        )
+        title = qd.get("title") if isinstance(qd, dict) else None
+    except SystemExit:
+        raise
+    except Exception:
+        pass
+
+    reship = _reshipment(args.repost) or "disallowed"
+
+    if not CONFIRM:
+        out({
+            "dry_run": True,
+            "command": "answer-question",
+            "platform": "zhihu",
+            "question_id": str(qid),
+            "question_title": title,
+            "draft_only": args.draft_only,
+            "reshipment_settings": reship,
+            "content_bytes": len(content),
+            "images_found": count_images(content),
+            "note": "re-run with --confirm as the LAST argument to actually write. "
+                    "Without --draft-only this publishes a PUBLIC answer on the user's real "
+                    "account. One answer per question — if you already answered, use edit-answer.",
+        })
+        return
+
+    image_stats = {"found": 0, "rehosted": 0, "failed": 0}
+    if not args.no_images:
+        content, image_stats = rehost_images(jar, content)
+
+    if args.draft_only:
+        # Private autosave draft on the question — nothing goes public.
+        status, text = request(
+            "PUT", ZH["question_draft"].format(id=qid), jar,
+            headers=ZH_FETCH, body={"content": content, "delta_time": 5},
+        )
+        if status >= 400:
+            die(f"save-draft failed ({status}) for question {qid}: {text[:300]}")
+        out({
+            "ok": True,
+            "draft_only": True,
+            "question_id": str(qid),
+            "images": image_stats,
+            "review_url": f"https://www.zhihu.com/question/{qid}",
+            "note": "Private draft saved. Open the question to review, then re-run "
+                    "without --draft-only (and --confirm) to publish.",
+        })
+        return
+
+    status, text = request(
+        "POST", ZH["question_answers"].format(id=qid), jar,
+        headers=ZH_FETCH, body={"content": content, "reshipment_settings": reship},
+    )
+    try:
+        res = json.loads(text)
+    except json.JSONDecodeError:
+        res = {}
+    if status >= 400:
+        # Zhihu's `error` is usually a dict {code, name, message} but can be a
+        # bare string; guard both. `code` may arrive as int or str.
+        err = res.get("error") if isinstance(res, dict) and isinstance(res.get("error"), dict) else {}
+        if str(err.get("code")) == "103003":
+            die(
+                f"you already answered question {qid}; Zhihu allows one answer per "
+                f"question. Find your answer id with `answers` and use "
+                f"`edit-answer --id <answer-id>` instead."
+            )
+        die(f"publish answer failed ({status}) for question {qid}: {text[:300]}")
+    aid = res.get("id") if isinstance(res, dict) else None
+    if not aid:
+        die(f"publish answer returned no id ({status}): {text[:300]}")
+    out({
+        "ok": True,
+        "published": True,
+        "question_id": str(qid),
+        "answer_id": str(aid),
+        "images": image_stats,
+        "url": f"https://www.zhihu.com/question/{qid}/answer/{aid}",
+    })
+
+
+def cmd_edit_answer(jar, args):
+    """Edit an EXISTING answer's content (GATED). The answer stays public."""
+    aid = args.id
+    if not aid:
+        die("--id <answer-id> is required")
+    content = _read_content(args)
+    # Read the current answer to preserve its repost setting and show context.
+    cur = {}
+    try:
+        _, cur = get_json(
+            f"{ZH['answer'].format(id=aid)}?{urllib.parse.urlencode({'include': 'reshipment_settings,question'})}",
+            jar, headers=ZH_FETCH,
+        )
+    except SystemExit:
+        raise
+    except Exception:
+        cur = {}
+    if not isinstance(cur, dict):
+        cur = {}
+    # Keep the answer's current repost setting; if it couldn't be read and the
+    # user gave no override, fall back to the conservative "disallowed" rather
+    # than silently granting repost rights.
+    reship = _reshipment(args.repost) or cur.get("reshipment_settings") or "disallowed"
+    q = cur.get("question") or {}
+
+    if not CONFIRM:
+        out({
+            "dry_run": True,
+            "command": "edit-answer",
+            "platform": "zhihu",
+            "answer_id": str(aid),
+            "question_title": q.get("title"),
+            "reshipment_settings": reship,
+            "content_bytes": len(content),
+            "images_found": count_images(content),
+            "note": "re-run with --confirm as the LAST argument to actually overwrite. "
+                    "This replaces the live, public answer's content on the user's real account.",
+        })
+        return
+
+    image_stats = {"found": 0, "rehosted": 0, "failed": 0}
+    if not args.no_images:
+        content, image_stats = rehost_images(jar, content)
+
+    status, text = request(
+        "PUT", ZH["answer"].format(id=aid), jar,
+        headers=ZH_FETCH, body={"content": content, "reshipment_settings": reship},
+    )
+    if status >= 400:
+        die(f"edit answer failed ({status}) for {aid}: {text[:300]}")
+    qid = q.get("id")
+    out({
+        "ok": True,
+        "edited": True,
+        "answer_id": str(aid),
+        "images": image_stats,
+        "url": (f"https://www.zhihu.com/question/{qid}/answer/{aid}" if qid else None),
+    })
+
+
 COMMANDS = {
     "whoami": cmd_whoami,
     "articles": cmd_articles,
     "article": cmd_article,
     "publish": cmd_publish,
+    "answers": cmd_answers,
+    "answer": cmd_answer,
+    "question": cmd_question,
+    "answer-question": cmd_answer_question,
+    "edit-answer": cmd_edit_answer,
 }
 
 
@@ -571,6 +888,38 @@ def main() -> None:
     sp.add_argument("--no-images", action="store_true",
                     help="skip re-hosting external images to Zhihu's CDN")
 
+    sp = sub.add_parser("answers", help="list the user's published answers + stats")
+    sp.add_argument("--limit", type=int, default=20)
+    sp.add_argument("--offset", type=int, default=0)
+
+    sp = sub.add_parser("answer", help="one answer's details + stats")
+    sp.add_argument("id")
+
+    sp = sub.add_parser("question", help="a question's info + whether you already answered it")
+    sp.add_argument("id")
+
+    sp = sub.add_parser("answer-question",
+                        help="post a NEW answer to a question (GATED by trailing --confirm)")
+    sp.add_argument("--question", help="question id to answer")
+    sp.add_argument("--content", help="HTML content inline")
+    sp.add_argument("--content-file", help="path to an HTML file")
+    sp.add_argument("--draft-only", action="store_true",
+                    help="save a private draft on the question; do NOT go public")
+    sp.add_argument("--repost", choices=["allowed", "disallowed"],
+                    help="转载授权: allow or disallow reposting (default disallowed)")
+    sp.add_argument("--no-images", action="store_true",
+                    help="skip re-hosting external images to Zhihu's CDN")
+
+    sp = sub.add_parser("edit-answer",
+                        help="overwrite an existing answer's content (GATED by trailing --confirm)")
+    sp.add_argument("--id", help="answer id to edit")
+    sp.add_argument("--content", help="HTML content inline")
+    sp.add_argument("--content-file", help="path to an HTML file")
+    sp.add_argument("--repost", choices=["allowed", "disallowed"],
+                    help="转载授权: override repost permission (default keeps current)")
+    sp.add_argument("--no-images", action="store_true",
+                    help="skip re-hosting external images to Zhihu's CDN")
+
     args = p.parse_args(ARGV)
     jar = load_cookies(args.platform)
     COMMANDS[args.command](jar, args)

package/skills/zhihu/scripts/search.py

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+"""
+zhihu search — search Zhihu and the web via the Zhihu Developer Platform API.
+Standard-library only (urllib), no third-party deps.
+
+Auth: Bearer token via ``ZHIHU_DEVELOPER_TOKEN`` env var.
+Does NOT require login cookies — independent of blog.py.
+
+Endpoints:
+  zhihu_search  — search Zhihu content (questions/answers/articles)
+  global_search — search the entire web with optional filters
+  hot_list      — current Zhihu trending topics
+
+Quick examples:
+  python3 $SKILL_DIR/scripts/search.py search "Python 爬虫"
+  python3 $SKILL_DIR/scripts/search.py search "Python 爬虫" --count 5
+  python3 $SKILL_DIR/scripts/search.py global "AI Agent" --count 10
+  python3 $SKILL_DIR/scripts/search.py global "React" --filter 'host=="github.com"'
+  python3 $SKILL_DIR/scripts/search.py global "新闻" --db realtime
+  python3 $SKILL_DIR/scripts/search.py hot
+  python3 $SKILL_DIR/scripts/search.py hot --limit 10
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+
+BASE_URL = "https://developer.zhihu.com/api/v1/content"
+
+
+def out(obj) -> None:
+    json.dump(obj, sys.stdout, ensure_ascii=False, indent=2)
+    sys.stdout.write("\n")
+
+
+def die(msg: str, code: int = 1) -> None:
+    sys.stderr.write(f"ERROR: {msg}\n")
+    sys.exit(code)
+
+
+def get_token() -> str:
+    token = os.environ.get("ZHIHU_DEVELOPER_TOKEN", "").strip()
+    if not token:
+        die(
+            "ZHIHU_DEVELOPER_TOKEN not set. "
+            "Set this env var to your Zhihu Developer Platform access secret."
+        )
+    return token
+
+
+def api_get(endpoint: str, params: dict | None = None) -> dict:
+    """GET request to the Zhihu Developer Platform API."""
+    token = get_token()
+    url = f"{BASE_URL}/{endpoint}"
+    if params:
+        # Filter out None values
+        params = {k: v for k, v in params.items() if v is not None}
+        if params:
+            url += "?" + urllib.parse.urlencode(params)
+
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "X-Request-Timestamp": str(int(time.time())),
+        "Content-Type": "application/json",
+    }
+
+    req = urllib.request.Request(url, headers=headers, method="GET")
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            return json.loads(resp.read().decode())
+    except urllib.error.HTTPError as e:
+        body = e.read().decode() if e.fp else ""
+        die(f"HTTP {e.code}: {body[:500]}")
+    except urllib.error.URLError as e:
+        die(f"Network error: {e.reason}")
+    return {}
+
+
+def _fmt_zhihu_item(item: dict) -> dict:
+    """Format a zhihu_search result item for display."""
+    return {
+        "title": item.get("Title", ""),
+        "type": item.get("ContentType", ""),
+        "content_id": item.get("ContentID", ""),
+        "url": item.get("Url", ""),
+        "excerpt": item.get("ContentText", "")[:200],
+        "vote_up": item.get("VoteUpCount", 0),
+        "comments": item.get("CommentCount", 0),
+        "author": item.get("AuthorName", ""),
+        "authority": item.get("AuthorityLevel", ""),
+        "edit_time": item.get("EditTime", 0),
+    }
+
+
+def _fmt_global_item(item: dict) -> dict:
+    """Format a global_search result item for display."""
+    return {
+        "title": item.get("Title", ""),
+        "type": item.get("ContentType", ""),
+        "content_id": item.get("ContentID", ""),
+        "url": item.get("Url", ""),
+        "excerpt": item.get("ContentText", "")[:300],
+        "vote_up": item.get("VoteUpCount", 0),
+        "comments": item.get("CommentCount", 0),
+        "author": item.get("AuthorName", ""),
+        "authority": item.get("AuthorityLevel", ""),
+        "edit_time": item.get("EditTime", 0),
+    }
+
+
+def _fmt_hot_item(item: dict, rank: int) -> dict:
+    """Format a hot_list result item for display."""
+    return {
+        "rank": rank,
+        "title": item.get("Title", ""),
+        "url": item.get("Url", ""),
+        "summary": item.get("Summary", ""),
+        "thumbnail": item.get("ThumbnailUrl", ""),
+    }
+
+
+def cmd_search(args):
+    """Search Zhihu content (站内搜索)."""
+    params = {"Query": args.query, "Count": args.count}
+    resp = api_get("zhihu_search", params)
+
+    if resp.get("Code") != 0:
+        die(f"API error: Code={resp.get('Code')} Message={resp.get('Message')}")
+
+    data = resp.get("Data", {})
+    items = data.get("Items") or []
+
+    result = {
+        "query": args.query,
+        "count": len(items),
+        "results": [_fmt_zhihu_item(it) for it in items],
+    }
+    if data.get("EmptyReason"):
+        result["empty_reason"] = data["EmptyReason"]
+
+    out(result)
+
+
+def cmd_global(args):
+    """Search the entire web (全网搜索)."""
+    params: dict = {"Query": args.query, "Count": args.count}
+    if args.filter:
+        params["Filter"] = args.filter
+    if args.db:
+        params["SearchDB"] = args.db
+
+    resp = api_get("global_search", params)
+
+    if resp.get("Code") != 0:
+        die(f"API error: Code={resp.get('Code')} Message={resp.get('Message')}")
+
+    data = resp.get("Data", {})
+    items = data.get("Items") or []
+
+    result = {
+        "query": args.query,
+        "has_more": data.get("HasMore", False),
+        "count": len(items),
+        "results": [_fmt_global_item(it) for it in items],
+    }
+    out(result)
+
+
+def cmd_hot(args):
+    """Get current Zhihu trending topics (热榜)."""
+    params = {"Limit": args.limit}
+    resp = api_get("hot_list", params)
+
+    if resp.get("Code") != 0:
+        die(f"API error: Code={resp.get('Code')} Message={resp.get('Message')}")
+
+    data = resp.get("Data", {})
+    items = data.get("Items") or []
+
+    result = {
+        "total": data.get("Total", len(items)),
+        "items": [_fmt_hot_item(it, i + 1) for i, it in enumerate(items)],
+    }
+    out(result)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="zhihu-search",
+        description="Search Zhihu and the web via the Zhihu Developer Platform API",
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    # search (zhihu_search)
+    p_search = sub.add_parser("search", help="Search Zhihu content (站内搜索)")
+    p_search.add_argument("query", help="Search query")
+    p_search.add_argument("--count", type=int, default=10, help="Results count (max 10)")
+
+    # global (global_search)
+    p_global = sub.add_parser("global", help="Search the entire web (全网搜索)")
+    p_global.add_argument("query", help="Search query")
+    p_global.add_argument("--count", type=int, default=10, help="Results count (max 20)")
+    p_global.add_argument(
+        "--filter",
+        help='Advanced filter expression, e.g. host=="example.com" AND publish_time>=1700000000',
+    )
+    p_global.add_argument(
+        "--db",
+        choices=["all", "realtime", "static"],
+        help="Index to search: all (default), realtime, static",
+    )
+
+    # hot (hot_list)
+    p_hot = sub.add_parser("hot", help="Get Zhihu trending topics (热榜)")
+    p_hot.add_argument("--limit", type=int, default=30, help="Number of items (max 30)")
+
+    args = parser.parse_args()
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    dispatch = {"search": cmd_search, "global": cmd_global, "hot": cmd_hot}
+    dispatch[args.command](args)
+
+
+if __name__ == "__main__":
+    main()