@1aboveio/skills 0.0.0-stage → 1.0.0

package/skills/content/wechat-publisher/scripts/md_to_wechat_html.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""
+Convert Markdown to WeChat-compatible HTML.
+
+WeChat requirements:
+- All styles must be INLINE (no <style> tags, no external CSS)
+- Images must reference WeChat CDN URLs (not local paths)
+- No <html>/<head>/<body> wrapper needed (WeChat wraps it)
+- Default body block is <div>, not <p>, to avoid phantom editable blank lines in WeChat editor
+- Keep output flat and avoid nested block wrappers where possible
+
+Usage:
+  python3 md_to_wechat_html.py input.md > output.html
+  python3 md_to_wechat_html.py input.md --output output.html
+"""
+
+import argparse
+import re
+import sys
+
+
+# ---------------------------------------------------------------------------
+# Inline style constants
+# ---------------------------------------------------------------------------
+
+STYLES = {
+    "h1": 'font-size:22px;font-weight:bold;color:#1a1a1a;margin:24px 0 12px;line-height:1.4;',
+    "h2": 'font-size:18px;font-weight:bold;color:#1a1a1a;margin:20px 0 10px;line-height:1.4;',
+    "h3": 'font-size:16px;font-weight:bold;color:#333;margin:16px 0 8px;line-height:1.4;',
+    "div": 'font-size:15px;color:#333;line-height:1.8;margin:0 0 12px;',
+    "li": 'font-size:15px;color:#333;line-height:1.8;margin:4px 0;',
+    "code_inline": (
+        'background:#f5f5f5;border-radius:3px;padding:2px 5px;'
+        'font-family:monospace;font-size:13px;color:#e83e8c;'
+    ),
+    "code_block": (
+        'background:#f5f5f5;border-radius:6px;padding:14px 16px;margin:12px 0;'
+        'font-family:monospace;font-size:13px;color:#333;'
+        'white-space:pre-wrap;word-break:break-all;overflow-x:auto;display:block;'
+    ),
+    "hr": 'border:none;border-top:1px solid #e0e0e0;margin:24px 0;',
+    "strong": 'font-weight:bold;color:#1a1a1a;',
+    "em": 'font-style:italic;',
+    "img": 'max-width:100%;height:auto;display:block;margin:12px auto;border-radius:4px;',
+}
+
+
+# ---------------------------------------------------------------------------
+# Converter
+# ---------------------------------------------------------------------------
+
+def md_to_html(md: str) -> str:
+    lines = md.split("\n")
+    html_parts = []
+    i = 0
+
+    while i < len(lines):
+        line = lines[i]
+
+        # --- Fenced code block ---
+        if line.startswith("```"):
+            code_lines = []
+            i += 1
+            while i < len(lines) and not lines[i].startswith("```"):
+                code_lines.append(lines[i])
+                i += 1
+            code = "\n".join(code_lines)
+            code = code.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+            html_parts.append(f'<code style="{STYLES["code_block"]}">{code}</code>')
+            i += 1
+            continue
+
+        # --- Headings ---
+        m = re.match(r'^(#{1,3})\s+(.*)', line)
+        if m:
+            level = len(m.group(1))
+            text = inline(m.group(2))
+            tag = f"h{level}"
+            html_parts.append(f'<{tag} style="{STYLES[tag]}">{text}</{tag}>')
+            i += 1
+            continue
+
+        # --- Horizontal rule ---
+        if re.match(r'^[-*_]{3,}\s*$', line):
+            html_parts.append(f'<hr style="{STYLES["hr"]}">')
+            i += 1
+            continue
+
+        # --- Blockquote lines become normal body blocks ---
+        if line.startswith("> "):
+            bq_lines = []
+            while i < len(lines) and lines[i].startswith("> "):
+                bq_lines.append(lines[i][2:])
+                i += 1
+            content = inline(" ".join(bq_lines))
+            html_parts.append(f'<div style="{STYLES["div"]}">{content}</div>')
+            continue
+
+        # --- Unordered list: flatten into normal body blocks to avoid editor quirks ---
+        if re.match(r'^[-*+]\s+', line):
+            while i < len(lines) and re.match(r'^[-*+]\s+', lines[i]):
+                item = inline(re.sub(r'^[-*+]\s+', '', lines[i]))
+                html_parts.append(f'<div style="{STYLES["div"]}">• {item}</div>')
+                i += 1
+            continue
+
+        # --- Ordered list: flatten into normal body blocks to avoid editor quirks ---
+        if re.match(r'^\d+\.\s+', line):
+            n = 1
+            while i < len(lines) and re.match(r'^\d+\.\s+', lines[i]):
+                item = inline(re.sub(r'^\d+\.\s+', '', lines[i]))
+                html_parts.append(f'<div style="{STYLES["div"]}">{n}. {item}</div>')
+                i += 1
+                n += 1
+            continue
+
+        # --- Blank line ---
+        if line.strip() == "":
+            i += 1
+            continue
+
+        # --- Paragraph ---
+        para_lines = []
+        while i < len(lines) and lines[i].strip() != "" and not lines[i].startswith("#") \
+                and not lines[i].startswith("```") and not lines[i].startswith("> ") \
+                and not re.match(r'^[-*+]\s+', lines[i]) and not re.match(r'^\d+\.\s+', lines[i]) \
+                and not re.match(r'^[-*_]{3,}\s*$', lines[i]):
+            para_lines.append(lines[i])
+            i += 1
+        text = inline(" ".join(para_lines))
+        html_parts.append(f'<div style="{STYLES["div"]}">{text}</div>')
+
+    return "".join(html_parts)
+
+
+def inline(text: str) -> str:
+    """Apply inline formatting: bold, italic, code, links, images."""
+    # Escape HTML first (preserve already-escaped entities)
+    text = text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+
+    # Images: ![alt](url)
+    text = re.sub(
+        r'!\[([^\]]*)\]\(([^)]+)\)',
+        lambda m: f'<img src="{m.group(2)}" alt="{m.group(1)}" style="{STYLES["img"]}">',
+        text
+    )
+    # Links: [text](url)
+    text = re.sub(
+        r'\[([^\]]+)\]\(([^)]+)\)',
+        lambda m: f'<a href="{m.group(2)}" style="color:#07c160;">{m.group(1)}</a>',
+        text
+    )
+    # Bold: **text** or __text__
+    text = re.sub(
+        r'\*\*(.+?)\*\*|__(.+?)__',
+        lambda m: f'<strong style="{STYLES["strong"]}">{m.group(1) or m.group(2)}</strong>',
+        text
+    )
+    # Italic: *text* or _text_
+    text = re.sub(
+        r'\*(.+?)\*|_(.+?)_',
+        lambda m: f'<em style="{STYLES["em"]}">{m.group(1) or m.group(2)}</em>',
+        text
+    )
+    # Inline code: `code`
+    text = re.sub(
+        r'`([^`]+)`',
+        lambda m: f'<code style="{STYLES["code_inline"]}">{m.group(1)}</code>',
+        text
+    )
+    return text
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("input", help="Input Markdown file")
+    parser.add_argument("--output", "-o", help="Output HTML file (default: stdout)")
+    args = parser.parse_args()
+
+    with open(args.input, "r", encoding="utf-8") as f:
+        md = f.read()
+
+    html = md_to_html(md)
+
+    if args.output:
+        with open(args.output, "w", encoding="utf-8") as f:
+            f.write(html)
+        print(f"Written to {args.output}", file=sys.stderr)
+    else:
+        print(html)
+
+
+if __name__ == "__main__":
+    main()

package/skills/content/wechat-publisher/scripts/publish.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+"""
+WeChat Official Account Publisher
+Publishes an article to a WeChat Official Account draft box (and optionally publishes it live).
+
+Usage:
+  python3 publish.py \
+    --appid wx1234567890 \
+    --appsecret <secret> \
+    --title "文章标题" \
+    --html article.html \
+    --thumb-image cover.jpg \
+    [--author "作者"] \
+    [--digest "摘要（最多120字）"] \
+    [--publish]   # push draft live immediately (skips manual review)
+
+Outputs JSON: { "ok": true, "draft_media_id": "...", "publish_id": "..." }
+"""
+
+import argparse
+import json
+import os
+import sys
+import time
+import requests
+
+
+# ---------------------------------------------------------------------------
+# Token management (cached in /tmp to avoid hitting the 2000/day limit)
+# ---------------------------------------------------------------------------
+
+TOKEN_CACHE = "/tmp/wechat_access_token.json"
+
+
+def get_access_token(appid: str, appsecret: str) -> str:
+    """Return a valid access_token, refreshing from cache if still valid.
+    
+    Uses WeChat stable access token API (POST /cgi-bin/stable_token) instead of
+    the legacy GET /cgi-bin/token endpoint. This is required for Agentier and
+    newer WeChat Official Account integrations.
+    """
+    if os.path.exists(TOKEN_CACHE):
+        with open(TOKEN_CACHE) as f:
+            cached = json.load(f)
+        if cached.get("appid") == appid and cached.get("expires_at", 0) > time.time() + 60:
+            return cached["access_token"]
+
+    # Use stable token API (POST) instead of legacy GET endpoint
+    url = "https://api.weixin.qq.com/cgi-bin/stable_token"
+    payload = {
+        "grant_type": "client_credential",
+        "appid": appid,
+        "secret": appsecret,
+        "force_refresh": False
+    }
+    resp = requests.post(
+        url,
+        json=payload,
+        headers={"Content-Type": "application/json"},
+        timeout=10
+    )
+    resp.raise_for_status()
+    data = resp.json()
+
+    if "errcode" in data and data["errcode"] != 0:
+        raise RuntimeError(f"get_access_token failed: {data}")
+
+    token = data["access_token"]
+    expires_at = time.time() + data.get("expires_in", 7200) - 300  # 5-min buffer
+
+    with open(TOKEN_CACHE, "w") as f:
+        json.dump({"appid": appid, "access_token": token, "expires_at": expires_at}, f)
+
+    return token
+
+
+# ---------------------------------------------------------------------------
+# Media upload (cover image → permanent thumb material)
+# ---------------------------------------------------------------------------
+
+def upload_thumb(token: str, image_path: str) -> str:
+    """Upload a cover image as a permanent material and return media_id."""
+    url = f"https://api.weixin.qq.com/cgi-bin/material/add_material?access_token={token}&type=thumb"
+    with open(image_path, "rb") as f:
+        resp = requests.post(url, files={"media": f}, timeout=30)
+    resp.raise_for_status()
+    data = resp.json()
+    if data.get("errcode", 0) != 0:
+        raise RuntimeError(f"upload_thumb failed: {data}")
+    return data["media_id"]
+
+
+def upload_article_image(token: str, image_path: str) -> str:
+    """Upload an image embedded inside an article and return its CDN URL."""
+    url = f"https://api.weixin.qq.com/cgi-bin/media/uploadimg?access_token={token}"
+    with open(image_path, "rb") as f:
+        resp = requests.post(url, files={"media": f}, timeout=30)
+    resp.raise_for_status()
+    data = resp.json()
+    if "url" not in data:
+        raise RuntimeError(f"upload_article_image failed: {data}")
+    return data["url"]
+
+
+# ---------------------------------------------------------------------------
+# Draft creation
+# ---------------------------------------------------------------------------
+
+def add_draft(token: str, title: str, html_content: str, thumb_media_id: str,
+              author: str = "", digest: str = "") -> str:
+    """Create a draft and return its media_id."""
+    url = f"https://api.weixin.qq.com/cgi-bin/draft/add?access_token={token}"
+    payload = {
+        "articles": [
+            {
+                "title": title,
+                "author": author,
+                "digest": digest,
+                "content": html_content,
+                "thumb_media_id": thumb_media_id,
+                "need_open_comment": 0,
+                "only_fans_can_comment": 0,
+            }
+        ]
+    }
+    # Use ensure_ascii=False so Chinese characters are sent as UTF-8, not \uXXXX escapes.
+    # WeChat stores the raw JSON bytes; ensure_ascii=True causes it to show literal \\uXXXX.
+    body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+    resp = requests.post(url, data=body, headers={"Content-Type": "application/json; charset=utf-8"}, timeout=15)
+    resp.raise_for_status()
+    data = resp.json()
+    if data.get("errcode", 0) != 0:
+        raise RuntimeError(f"add_draft failed: {data}")
+    return data["media_id"]
+
+
+# ---------------------------------------------------------------------------
+# Free-publish (optional: push draft live without manual review)
+# ---------------------------------------------------------------------------
+
+def submit_publish(token: str, draft_media_id: str) -> str:
+    """Submit a draft for publishing and return publish_id."""
+    url = f"https://api.weixin.qq.com/cgi-bin/freepublish/submit?access_token={token}"
+    body = json.dumps({"media_id": draft_media_id}, ensure_ascii=False).encode("utf-8")
+    resp = requests.post(url, data=body, headers={"Content-Type": "application/json; charset=utf-8"}, timeout=15)
+    resp.raise_for_status()
+    data = resp.json()
+    if data.get("errcode", 0) != 0:
+        raise RuntimeError(f"submit_publish failed: {data}")
+    return str(data.get("publish_id", ""))
+
+
+def poll_publish_status(token: str, publish_id: str, max_wait: int = 60) -> dict:
+    """Poll until publish completes or times out. Returns status dict."""
+    url = f"https://api.weixin.qq.com/cgi-bin/freepublish/get?access_token={token}"
+    deadline = time.time() + max_wait
+    while time.time() < deadline:
+        body = json.dumps({"publish_id": publish_id}, ensure_ascii=False).encode("utf-8")
+        resp = requests.post(url, data=body, headers={"Content-Type": "application/json; charset=utf-8"}, timeout=10)
+        resp.raise_for_status()
+        data = resp.json()
+        status = data.get("publish_status", -1)
+        # 0 = success, 1 = publishing, 2 = failed, 4 = deleted
+        if status == 0:
+            return {"status": "success", "article_id": data.get("article_id", "")}
+        if status in (2, 4):
+            return {"status": "failed", "detail": data}
+        time.sleep(3)
+    return {"status": "timeout"}
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    parser = argparse.ArgumentParser(description="WeChat Official Account Publisher")
+    parser.add_argument("--appid", required=True)
+    parser.add_argument("--appsecret", required=True)
+    parser.add_argument("--title", required=True)
+    parser.add_argument("--html", required=True, help="Path to HTML article body file")
+    parser.add_argument("--thumb-image", required=True, help="Path to cover image (JPEG/PNG, ≤64KB for thumb)")
+    parser.add_argument("--author", default="")
+    parser.add_argument("--digest", default="", help="Article summary (≤120 chars)")
+    parser.add_argument("--publish", action="store_true", help="Also submit draft for live publishing")
+    args = parser.parse_args()
+
+    result = {}
+
+    try:
+        # 1. Get token
+        token = get_access_token(args.appid, args.appsecret)
+
+        # 2. Upload cover image
+        print(f"Uploading cover image: {args.thumb_image}", file=sys.stderr)
+        thumb_media_id = upload_thumb(token, args.thumb_image)
+
+        # 3. Read HTML content
+        with open(args.html, "r", encoding="utf-8") as f:
+            html_content = f.read()
+
+    # 3b. Validate title and digest byte limits (WeChat uses UTF-8 byte count, not char count)
+        title_bytes = len(args.title.encode("utf-8"))
+        digest_bytes = len(args.digest.encode("utf-8"))
+        if title_bytes > 64:
+            raise ValueError(f"Title exceeds 64-byte limit ({title_bytes} bytes / ~{title_bytes//3} Chinese chars). Shorten the title.")
+        if digest_bytes > 120:
+            raise ValueError(f"Digest exceeds 120-byte limit ({digest_bytes} bytes / ~{digest_bytes//3} Chinese chars). Shorten the digest.")
+
+        # 4. Create draft
+        print(f"Creating draft: {args.title}", file=sys.stderr)
+        draft_media_id = add_draft(
+            token, args.title, html_content, thumb_media_id,
+            author=args.author, digest=args.digest
+        )
+        result["ok"] = True
+        result["draft_media_id"] = draft_media_id
+        print(f"Draft created: {draft_media_id}", file=sys.stderr)
+
+        # 5. Optionally publish live
+        if args.publish:
+            print("Submitting for publishing...", file=sys.stderr)
+            publish_id = submit_publish(token, draft_media_id)
+            result["publish_id"] = publish_id
+            status = poll_publish_status(token, publish_id)
+            result["publish_status"] = status
+            print(f"Publish status: {status}", file=sys.stderr)
+
+    except Exception as e:
+        result["ok"] = False
+        result["error"] = str(e)
+        print(json.dumps(result))
+        sys.exit(1)
+
+    print(json.dumps(result))
+
+
+if __name__ == "__main__":
+    main()

package/skills/content/wechat-search/LICENSE

@@ -0,0 +1,3 @@
+MIT License
+
+Copyright (c) 2026 1AboveIO

package/skills/content/wechat-search/SKILL.md

@@ -0,0 +1,211 @@
+---
+name: wechat-search
+description: "Search WeChat 公众号 articles via Sogou Weixin, or read/summarize an article from a mp.weixin.qq.com URL (读/分析/总结) — suggest proactively when such a URL appears. Use for Chinese WeChat content, industry reports, competitor or trending topics. Requires Chrome Browser Relay. NOT general web search (web_search)."
+release-version: 0.36.0
+---
+**Updates:** Once/session run `node <skill-base-dir>/release-check.mjs`.
+# WeChat Article Search & Reader (搜狗微信搜索)
+
+Two modes:
+1. **Search mode** — search 公众号 articles via Sogou WeChat Search
+2. **Read mode** — read a full article from a `mp.weixin.qq.com` URL
+
+## Step 0: Ensure Chrome is Running (MANDATORY — run before anything else)
+
+**Every session must start here.** Do not skip this step.
+
+### Check if Chrome CDP is available
+
+```bash
+curl -s --max-time 2 http://localhost:18801/json/version
+```
+
+- **Returns JSON** → Chrome is ready, proceed to the workflow
+- **Fails / empty** → Chrome is not running, start it now (see below)
+
+### Start Chrome (Linux)
+
+Run the bundled script — it auto-detects the Chrome binary and waits until CDP is ready:
+
+```bash
+bash {baseDir}/scripts/start-chrome.sh
+```
+
+Expected output:
+```
+🚀 Starting Chrome...
+⏳ Waiting for CDP... ready!
+✅ Chrome CDP available at http://localhost:18801
+```
+
+If the script errors with "Chrome not found", install Chrome:
+```bash
+# Debian/Ubuntu
+sudo apt install google-chrome-stable
+# Fedora
+sudo dnf install google-chrome-stable
+# Snap
+sudo snap install chromium
+```
+
+### Start Chrome (macOS / Windows)
+
+**macOS:**
+```bash
+/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome \
+  --remote-debugging-port=18801 \
+  --user-data-dir=/tmp/chrome-cdp-profile \
+  --no-first-run &
+```
+
+**Windows:**
+```bat
+"C:\Program Files\Google\Chrome\Application\chrome.exe" ^
+  --remote-debugging-port=18801 ^
+  --user-data-dir=%TEMP%\chrome-cdp-profile ^
+  --no-first-run
+```
+
+> **Tip:** Reuse the same `--user-data-dir` across sessions to preserve WeChat login state.
+
+### Get tab ID (required for all browser calls)
+
+```
+browser action=tabs profile=chrome
+```
+
+Use the first `targetId` from the response in all subsequent `browser` calls.
+
+**Key parameters:**
+```
+profile=chrome    # CDP on localhost:18801 (real browser — avoids anti-bot)
+targetId=<id>     # from browser action=tabs
+```
+
+---
+
+## Mode 1: Read Article from URL
+
+Triggered when user provides a `mp.weixin.qq.com` URL.
+
+### Step 1: Try web_fetch first
+
+```
+web_fetch url="<mp.weixin.qq.com URL>"
+```
+
+If successful, extract and present:
+- **标题** — article title
+- **公众号** — account name (author)
+- **发布时间** — publish date
+- **正文** — full body text
+
+### Step 2: If web_fetch blocked (requires login), use browser
+
+```
+# Get attached tab ID
+browser action=tabs profile=chrome
+# → use the first targetId from the response
+
+browser action=navigate profile=chrome targetId=<id> targetUrl="<mp.weixin.qq.com URL>"
+# Wait ~2s for page to load
+browser action=snapshot profile=chrome targetId=<id>
+```
+
+Extract title, 公众号 name, date, and body text from the snapshot.
+
+### Output format (Read mode)
+
+```
+📄 **[标题]**
+公众号：[账号名] · [发布时间]
+
+[正文内容，完整呈现或摘要视长度而定]
+```
+
+---
+
+## Mode 2: Search Articles
+
+Triggered when user wants to search for WeChat content by keyword.
+
+### Step 1: Get tab ID
+
+Complete **Step 0** first. Then get the tab ID:
+
+```
+browser action=tabs profile=chrome
+```
+
+Use the first `targetId` for all subsequent browser calls.
+
+### Step 2: Navigate to Sogou WeChat Search
+
+```
+browser action=navigate profile=chrome targetId=<id> targetUrl="https://weixin.sogou.com/"
+```
+
+### Step 3: Snapshot to find search box
+
+```
+browser action=snapshot profile=chrome targetId=<id>
+```
+
+Look for the `textbox` element (search input).
+
+### Step 4: Type query and submit
+
+```
+browser action=act profile=chrome targetId=<id>
+request: { kind: "type", ref: "<search_box_ref>", text: "<query>", submit: true }
+```
+
+Wait ~2 seconds for results to load, then snapshot.
+
+### Step 5: Parse results
+
+```
+browser action=snapshot profile=chrome targetId=<id> compact=true
+```
+
+If no results (empty list or "未找到相关结果"), report "未找到与「<query>」相关的公众号文章" and suggest refining the keyword.
+
+Extract from snapshot:
+- **Title**: from `heading` elements (h3)
+- **Source** (公众号名): text after the article summary
+- **Date**: text next to source name
+- **Link**: the `/link?url=...` href (Sogou redirect URL)
+
+### Step 6: Pagination (optional)
+
+Click page links to get more results. Max 10 pages.
+
+### Search Types
+
+- **搜文章** (default): `https://weixin.sogou.com/` and search
+- **搜公众号**: navigate to `https://weixin.sogou.com/weixin?type=1&query=<keyword>`
+
+### Output format (Search mode)
+
+```
+1. **<Title>** — <Source> (<Date>)
+   <Link>
+2. **<Title>** — <Source> (<Date>)
+   <Link>
+...
+```
+
+---
+
+## Limitations
+
+- **Rate limiting**: Space out searches — no more than a few per minute
+- **Captcha**: If triggered, screenshot and ask the user to solve it manually
+- **Max 10 pages** per query (~100 results)
+- **Sogou redirect URLs expire** — extract real `mp.weixin.qq.com` URLs promptly if needed
+
+## Anti-Detection Tips
+
+- Use natural delays between actions
+- Don't paginate through all 10 pages rapidly
+- If captcha triggers, wait a few minutes before retrying