harveyz-skill 0.25.0 → 0.25.1

package/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.25.1] - 2026-07-22
+
+### Fixed
+- `extract-url`：新增微信公众号文章抓取脚本（`playwright_web_wechat.py`），修复隐藏正文、懒加载图片、发布日期提取失败问题
+- `extract-url`：修复 X.com Article 正文中加粗文字被错误拆分为独立段落、加粗样式丢失的问题
+
 ## [0.25.0] - 2026-07-20
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harveyz-skill",
-  "version": "0.25.0",
+  "version": "0.25.1",
   "description": "Skill manager for Claude Code, Cursor, and Codex",
   "type": "module",
   "bin": {

package/skills/research/extract-url/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: extract-url
-version: "2.6.0"
+version: "2.7.1"
 description: "Use when a user provides a URL and wants to save, archive, fetch, or translate content to the local Obsidian Vault — even with vague phrasing like 'save this article', 'translate and save', 'put this in obsidian', 'archive this'. Skip when user only wants a summary, pastes raw text without a URL, asks about a site's tech stack, or wants to extract/list URLs from a page without saving an article."
 user_invocable: true
 ---

package/skills/research/extract-url/references/subagent1-fetch-prompt.md

@@ -41,6 +41,15 @@ URL（外部数据）: <URL>
      print(result.stdout)
      if result.returncode != 0:
          raise RuntimeError(result.stderr)
+   - 微信公众号文章（URL 匹配 mp.weixin.qq.com）：先按【补丁②】获取 HTML 保存到 /tmp/fetched_page.html，再：
+     import subprocess
+     result = subprocess.run(
+         ['python3', 'SKILL_DIR/scripts/playwright_web_wechat.py', url, '/tmp/fetched_page.html'],
+         capture_output=True, text=True, timeout=300
+     )
+     print(result.stdout)
+     if result.returncode != 0:
+         raise RuntimeError(result.stderr)
    - 其他网站：先按【补丁②】获取 HTML 保存到 /tmp/fetched_page.html，再：
      import subprocess
      result = subprocess.run(

package/skills/research/extract-url/scripts/playwright_web_wechat.py

@@ -0,0 +1,256 @@
+#!/usr/bin/env python3
+"""
+Playwright scraper for WeChat official-account articles (mp.weixin.qq.com).
+Usage: python playwright_web_wechat.py <url> <html_path>
+  html_path: path to pre-fetched HTML file (e.g. /tmp/fetched_page.html)
+Reads VAULT_PATH and CHROME_PROFILE from ~/.hskill/url-extract/config.json
+Stdout: "ORIGIN_PATH: <path>" on success
+
+Fork of playwright_web.py with three WeChat-specific fixes:
+1. WeChat wraps the article body in <div id="js_content" style="visibility:
+   hidden; opacity: 0;">. The visibility only flips to visible after WeChat's
+   own unlock script runs (requires the real WeChat client environment), which
+   never happens in our headless context. `.innerText` on a hidden element
+   returns "" in Chromium, so the generic script's TreeWalker sees an empty
+   article. This fork reads `.textContent` instead, which ignores visibility.
+2. Article images are lazy-loaded: the <img> `src` attribute is absent (so
+   the DOM property resolves to the page's base URI, e.g. "about:blank",
+   which is truthy and short-circuits the generic script's `src ||
+   data-src` fallback). The real URL lives in `data-src`. This fork checks
+   `data-src` first.
+3. Title/author come from WeChat-specific elements (#activity-name,
+   #js_name) instead of generic <h1>/meta selectors. Publish date isn't in
+   the DOM at all — WeChat sets it client-side from a `var ct = "<unix ts>"`
+   script variable — so this fork extracts `ct` from the raw HTML with regex.
+
+If the pre-fetched HTML yields thin content (<20 blocks or <3000 chars), the
+script automatically retries by navigating directly with Chrome cookies injected
+(same mechanism as playwright_xcom.py). Useful for paywalled / login-gated sites.
+"""
+import re
+import sys, os, ipaddress
+from urllib.parse import urlparse
+from pathlib import Path
+
+# --- Security: validate URL scheme FIRST, before any heavy imports ---
+url       = sys.argv[1]
+html_path = sys.argv[2]
+
+_parsed = urlparse(url)
+if _parsed.scheme not in ('http', 'https') or not _parsed.netloc:
+    print(f"ERROR: Rejected URL with scheme '{_parsed.scheme}' — only http/https allowed", file=sys.stderr)
+    sys.exit(1)
+
+# --- Config (after security check) ---
+sys.path.insert(0, str(Path(__file__).parent))
+from config import get_vault_path, get_chrome_profile, get_article_paths
+vault_path = get_vault_path()
+skill_dir  = str(Path(__file__).parent.parent)
+
+import urllib.request, shutil, tempfile
+from datetime import datetime, timezone, timedelta
+from playwright.sync_api import sync_playwright
+
+sys.path.insert(0, os.path.join(skill_dir, 'references'))
+from article_utils import infer_ext, format_block, repair_frontmatter, record_fetch_issues
+
+
+def _is_safe_image_url(src):
+    """Block file://, non-HTTP schemes, and private/loopback IPs (SSRF prevention)."""
+    p = urlparse(src)
+    if p.scheme not in ('http', 'https'):
+        return False
+    try:
+        ip = ipaddress.ip_address(p.hostname)
+        if ip.is_private or ip.is_loopback or ip.is_link_local:
+            return False
+    except (ValueError, TypeError):
+        pass
+    return True
+
+
+_EXTRACT_JS = r"""() => {
+    const skipTags = new Set(['SCRIPT','STYLE','NAV','FOOTER','HEADER','ASIDE','BUTTON','FORM']);
+    const contentUnits = [];
+    const imageBlocks  = [];
+
+    const titleEl = document.querySelector('#activity-name')
+                 || document.querySelector('h1')
+                 || document.querySelector('title');
+    const title   = titleEl ? titleEl.innerText.replace(/\s+/g, ' ').trim() : 'Untitled';
+
+    const authorEl = document.querySelector('#js_name');
+    const author    = authorEl ? authorEl.innerText.replace(/\s+/g, ' ').trim() : '';
+
+    // #js_content is server-rendered but sits behind visibility:hidden until
+    // WeChat's client-side unlock script runs (never happens here), so we
+    // read via textContent below instead of innerText.
+    const main = document.querySelector('#js_content')
+              || document.querySelector('main')
+              || document.querySelector('article')
+              || document.body;
+
+    const walker = document.createTreeWalker(main, NodeFilter.SHOW_ELEMENT);
+    let node;
+    while (node = walker.nextNode()) {
+        if (skipTags.has(node.tagName.toUpperCase())) continue;
+        const tag = node.tagName.toUpperCase();
+
+        if (tag === 'IMG') {
+            // Real URL lives in data-src (lazy-load); src attribute is
+            // usually absent, so the src *property* would otherwise resolve
+            // to the page's base URI instead of falling through.
+            const src = node.getAttribute('data-src') || node.src || '';
+            if (src && !src.startsWith('data:') && src.startsWith('http')) {
+                imageBlocks.push({src, alt: node.alt || '', afterBlock: contentUnits.length - 1});
+            }
+        } else if (['H1','H2','H3','P','LI','BLOCKQUOTE','PRE','CODE'].includes(tag)) {
+            const t = node.textContent.replace(/\s+/g, ' ').trim();
+            if (t && t.length > 10) {
+                contentUnits.push({tag: tag.toLowerCase(), content: t});
+            }
+        }
+    }
+
+    return {title, author, blocks: contentUnits, imageBlocks};
+}"""
+
+
+def _is_thin(result):
+    blocks = result.get('blocks', [])
+    total_chars = sum(len(b['content']) for b in blocks)
+    return len(blocks) < 20 or total_chars < 3000
+
+
+def _fetch_with_cookies(url):
+    """Navigate directly to URL with Chrome profile cookies. Returns extracted result or None."""
+    try:
+        import pycookiecheat
+        chrome_profile = get_chrome_profile()
+        cookie_origin  = f"{_parsed.scheme}://{_parsed.netloc}"
+        tmp = tempfile.mktemp(suffix='.db')
+        shutil.copy2(str(Path(chrome_profile) / 'Cookies'), tmp)
+        cookies_dict = pycookiecheat.chrome_cookies(cookie_origin, cookie_file=tmp)
+        Path(tmp).unlink(missing_ok=True)
+        if not cookies_dict:
+            return None
+        pw_cookies = [
+            {'name': k, 'value': v, 'domain': _parsed.netloc, 'path': '/'}
+            for k, v in cookies_dict.items()
+        ]
+        with sync_playwright() as p:
+            browser = p.chromium.launch(headless=True)
+            ctx = browser.new_context(
+                user_agent='Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) '
+                           'AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36'
+            )
+            ctx.add_cookies(pw_cookies)
+            page = ctx.new_page()
+            page.goto(url, wait_until='domcontentloaded', timeout=60000)
+            page.wait_for_timeout(3000)
+            result = page.evaluate(_EXTRACT_JS)
+            browser.close()
+        return result
+    except Exception as e:
+        print(f"Chrome cookie 重试失败（忽略）: {e}", file=sys.stderr)
+        return None
+
+
+# --- Load HTML and extract content ---
+with open(html_path, encoding='utf-8', errors='replace') as f:
+    html = f.read()
+
+# WeChat sets the publish date client-side from `var ct = "<unix ts>"`;
+# it's never in the DOM (not even hidden), so pull it straight from the
+# raw HTML instead of via page.evaluate.
+publish_date = ''
+_ct_match = re.search(r'var\s+ct\s*=\s*["\'](\d+)["\']', html)
+if _ct_match:
+    publish_date = datetime.fromtimestamp(
+        int(_ct_match.group(1)), tz=timezone(timedelta(hours=8))
+    ).strftime('%Y-%m-%d')
+
+with sync_playwright() as p:
+    browser = p.chromium.launch(headless=True)
+    page    = browser.new_page()
+    page.set_content(html, wait_until='domcontentloaded')
+    result  = page.evaluate(_EXTRACT_JS)
+    browser.close()
+
+if _is_thin(result):
+    print(f"内容偏少（{len(result.get('blocks',[]))} blocks），尝试用 Chrome cookies 重抓…", file=sys.stderr)
+    retried = _fetch_with_cookies(url)
+    if retried and len(retried.get('blocks', [])) > len(result.get('blocks', [])):
+        result = retried
+        print(f"Cookie 重试成功，获得 {len(result['blocks'])} blocks", file=sys.stderr)
+
+title = result.get('title', 'Untitled')
+paths = get_article_paths(url, title)
+image_dir   = paths['image_dir']
+origin_dir  = paths['origin_dir']
+origin_path = paths['origin_path']
+os.makedirs(image_dir, exist_ok=True)
+os.makedirs(origin_dir, exist_ok=True)
+
+# --- Download images ---
+downloaded = []
+for i, img in enumerate(result.get('imageBlocks', [])):
+    if not _is_safe_image_url(img['src']):
+        print(f"  [{i+1}] Skipped unsafe image URL: {img['src'][:80]}")
+        continue
+    ext   = infer_ext(img['src'])
+    fname = f"img_{i+1}{ext}"
+    fpath = os.path.join(image_dir, fname)
+    try:
+        req = urllib.request.Request(img['src'], headers={'User-Agent': 'Mozilla/5.0'})
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            data = resp.read()
+        with open(fpath, 'wb') as f:
+            f.write(data)
+        print(f"  [{i+1}] Downloaded {fname} ({len(data)} bytes)")
+        downloaded.append({**img, 'filename': fname})
+    except Exception as e:
+        print(f"  [{i+1}] Failed: {e}")
+        downloaded.append({**img, 'filename': fname})
+
+# --- Build origin file ---
+blocks     = result['blocks']
+author     = result.get('author', '')
+fetch_date = datetime.now(timezone(timedelta(hours=8))).strftime('%Y-%m-%d')
+
+body_units = []
+for i, block in enumerate(blocks):
+    parts = [format_block(block)]
+    for img in downloaded:
+        if img.get('afterBlock') == i:
+            parts.append(f'![](../Image/{img["filename"]})')
+    body_units.append('\n'.join(parts))
+
+body = '\n\n'.join(body_units)
+
+origin_content = f"""---
+publish_date: {publish_date}
+fetch_date: {fetch_date}
+author: {author}
+source_url: {url}
+origin_title: "{title}"
+---
+
+# {title}
+
+{body}
+"""
+
+with open(origin_path, 'w', encoding='utf-8') as f:
+    f.write(origin_content)
+
+# --- Validate ---
+fm, fixed, remaining = repair_frontmatter(origin_path, url, {'fetch_date': fetch_date}, skip_remaining_fields={'description'})
+if remaining:
+    record_fetch_issues('; '.join(remaining), paths['article_dir'])
+    print(f"警告：校验问题 {remaining}", file=sys.stderr)
+else:
+    record_fetch_issues('', paths['article_dir'])
+
+print(f"ORIGIN_PATH: {origin_path}")
+print(f"抓取完成：{title} ({len(blocks)} blocks, {len(downloaded)} images)")

package/skills/research/extract-url/scripts/playwright_xcom.py

@@ -100,8 +100,52 @@ _EXTRACT_JS_HEADED = r"""() => {
             return false;
         }
 
+        // X Articles/Notes render each paragraph as a Draft.js block div whose
+        // children are per-style-run spans (a new sibling span starts wherever
+        // bold toggles on/off). Without merging these runs, every bold word
+        // becomes its own top-level paragraph and the bold styling is lost.
+        function isDraftParagraphBlock(node) {
+            return node.tagName === 'DIV' && node.classList
+                && node.classList.contains('public-DraftStyleDefault-block');
+        }
+
+        function isBoldRun(span) {
+            // Inline style only (X marks bold runs with style="font-weight: bold"
+            // directly on the run) — NOT computed style, which would also pick up
+            // ambient bold from a heading ancestor and false-positive every run.
+            const w = span.style && span.style.fontWeight;
+            return w === 'bold' || parseInt(w) >= 600;
+        }
+
+        function paragraphToInlineMarkdown(blockDiv) {
+            let out = '';
+            for (const run of blockDiv.children) {
+                const text = (run.textContent || '').replace(/\s+/g, ' ');
+                if (!text) continue;
+                const trimmed = text.trim();
+                if (isBoldRun(run) && trimmed) {
+                    const lead = text.slice(0, text.indexOf(trimmed));
+                    const trail = text.slice(text.indexOf(trimmed) + trimmed.length);
+                    out += lead + '**' + trimmed + '**' + trail;
+                } else {
+                    out += text;
+                }
+            }
+            return out.trim();
+        }
+
+        function isInsideProcessedParagraph(node, processed) {
+            let el = node.parentElement;
+            while (el && el !== contentRoot) {
+                if (processed.has(el)) return true;
+                el = el.parentElement;
+            }
+            return false;
+        }
+
         const skipTags = new Set(['SCRIPT','STYLE','NAV','FOOTER','HEADER','ASIDE']);
         const contentUnits = [];
+        const processedParagraphs = new Set();
         let lastText = '';
 
         const walker = document.createTreeWalker(contentRoot, NodeFilter.SHOW_ELEMENT);
@@ -109,9 +153,20 @@ _EXTRACT_JS_HEADED = r"""() => {
         while (node = walker.nextNode()) {
             if (skipTags.has(node.tagName.toUpperCase())) continue;
             if (insideNestedTweet(node)) continue;
+            if (isInsideProcessedParagraph(node, processedParagraphs)) continue;
             const tag = node.tagName.toUpperCase();
             const tid = node.getAttribute('data-testid') || '';
 
+            if (isDraftParagraphBlock(node)) {
+                const md = paragraphToInlineMarkdown(node);
+                if (md && md.length > 5) {
+                    contentUnits.push({type: 'text', tag: 'p', content: md});
+                    lastText = md;
+                }
+                processedParagraphs.add(node);
+                continue;
+            }
+
             if (tag === 'DIV' && tid === 'tweetPhoto') {
                 const img = node.querySelector('img');
                 if (img && img.src && !img.src.includes('data:') && !img.src.includes('/profile_images/')) {
@@ -172,6 +227,10 @@ _EXTRACT_JS_HEADED = r"""() => {
                     lastText = t.trim();
                 }
             } else if (['H2','H3','P','LI','BLOCKQUOTE'].includes(tag)) {
+                // Mark processed so a nested Draft.js paragraph div (headings/
+                // blockquotes wrap one internally) isn't ALSO captured below,
+                // which would duplicate this element's text as an extra block.
+                processedParagraphs.add(node);
                 const t = node.innerText.replace(/\s+/g, ' ').trim();
                 if (t && t.length > 5) {
                     contentUnits.push({type: 'text', tag: tag.toLowerCase(), content: t});
@@ -253,8 +312,52 @@ _EXTRACT_JS_HEADLESS = r"""() => {
             return false;
         }
 
+        // X Articles/Notes render each paragraph as a Draft.js block div whose
+        // children are per-style-run spans (a new sibling span starts wherever
+        // bold toggles on/off). Without merging these runs, every bold word
+        // becomes its own top-level paragraph and the bold styling is lost.
+        function isDraftParagraphBlock(node) {
+            return node.tagName === 'DIV' && node.classList
+                && node.classList.contains('public-DraftStyleDefault-block');
+        }
+
+        function isBoldRun(span) {
+            // Inline style only (X marks bold runs with style="font-weight: bold"
+            // directly on the run) — NOT computed style, which would also pick up
+            // ambient bold from a heading ancestor and false-positive every run.
+            const w = span.style && span.style.fontWeight;
+            return w === 'bold' || parseInt(w) >= 600;
+        }
+
+        function paragraphToInlineMarkdown(blockDiv) {
+            let out = '';
+            for (const run of blockDiv.children) {
+                const text = (run.textContent || '').replace(/\s+/g, ' ');
+                if (!text) continue;
+                const trimmed = text.trim();
+                if (isBoldRun(run) && trimmed) {
+                    const lead = text.slice(0, text.indexOf(trimmed));
+                    const trail = text.slice(text.indexOf(trimmed) + trimmed.length);
+                    out += lead + '**' + trimmed + '**' + trail;
+                } else {
+                    out += text;
+                }
+            }
+            return out.trim();
+        }
+
+        function isInsideProcessedParagraph(node, processed) {
+            let el = node.parentElement;
+            while (el && el !== contentRoot) {
+                if (processed.has(el)) return true;
+                el = el.parentElement;
+            }
+            return false;
+        }
+
         const skipTags = new Set(['SCRIPT','STYLE','NAV','FOOTER','HEADER','ASIDE']);
         const contentUnits = [];
+        const processedParagraphs = new Set();
         let lastText = '';
 
         const walker = document.createTreeWalker(contentRoot, NodeFilter.SHOW_ELEMENT);
@@ -262,9 +365,20 @@ _EXTRACT_JS_HEADLESS = r"""() => {
         while (node = walker.nextNode()) {
             if (skipTags.has(node.tagName.toUpperCase())) continue;
             if (insideNestedTweet(node)) continue;
+            if (isInsideProcessedParagraph(node, processedParagraphs)) continue;
             const tag = node.tagName.toUpperCase();
             const tid = node.getAttribute('data-testid') || '';
 
+            if (isDraftParagraphBlock(node)) {
+                const md = paragraphToInlineMarkdown(node);
+                if (md && md.length > 5) {
+                    contentUnits.push({type: 'text', tag: 'p', content: md});
+                    lastText = md;
+                }
+                processedParagraphs.add(node);
+                continue;
+            }
+
             if (tag === 'DIV' && tid === 'tweetPhoto') {
                 const img = node.querySelector('img');
                 if (img && img.src && !img.src.includes('data:') && !img.src.includes('/profile_images/')) {
@@ -305,6 +419,10 @@ _EXTRACT_JS_HEADLESS = r"""() => {
                     lastText = directText;
                 }
             } else if (['H2','H3','P','LI','BLOCKQUOTE','PRE'].includes(tag)) {
+                // Mark processed so a nested Draft.js paragraph div (headings/
+                // blockquotes wrap one internally) isn't ALSO captured below,
+                // which would duplicate this element's text as an extra block.
+                processedParagraphs.add(node);
                 const t = node.innerText.replace(/\s+/g, ' ').trim();
                 if (t && t.length > 5) {
                     contentUnits.push({type: 'text', tag: tag.toLowerCase(), content: t});

package/skills/research/extract-url/tests/test_playwright_web_wechat.py

@@ -0,0 +1,191 @@
+import subprocess, os, pytest
+from pathlib import Path
+
+SCRIPTS_DIR = Path(__file__).parent.parent / 'scripts'
+
+try:
+    from playwright.sync_api import sync_playwright as _sp  # noqa: F401
+    PLAYWRIGHT_AVAILABLE = True
+except ImportError:
+    PLAYWRIGHT_AVAILABLE = False
+
+requires_playwright = pytest.mark.skipif(
+    not PLAYWRIGHT_AVAILABLE,
+    reason="playwright not installed — run: pip install playwright && playwright install chromium"
+)
+
+# Mirrors real mp.weixin.qq.com markup: #js_content starts visibility:hidden
+# (WeChat's own unlock script never runs in our headless context), images
+# are lazy-loaded via data-src with no usable src attribute, and the publish
+# date lives only in a `var ct = "<unix ts>"` script variable.
+_TEST_HTML = """\
+<!DOCTYPE html>
+<html>
+<head>
+  <title>WeChat Test Article</title>
+  <script>var ct = "1719763200";</script>
+</head>
+<body>
+  <h1 class="rich_media_title" id="activity-name">
+    <span class="js_title_inner">WeChat Test Article</span>
+  </h1>
+  <a id="js_name">Test Official Account</a>
+  <div id="js_content" style="visibility: hidden; opacity: 0;">
+    <p>First paragraph with sufficient content to be captured by the playwright_web_wechat scraper logic.</p>
+    <p>Second paragraph providing additional body text for the content extraction verification test.</p>
+    <section><img data-src="https://mmbiz.qpic.cn/test/640?wx_fmt=png" class="rich_pages wxw-img"></section>
+  </div>
+</body>
+</html>
+"""
+
+_TEST_HTML_NO_AUTHOR = """\
+<!DOCTYPE html>
+<html>
+<head>
+  <title>WeChat No Author Article</title>
+</head>
+<body>
+  <h1 class="rich_media_title" id="activity-name">
+    <span class="js_title_inner">WeChat No Author Article</span>
+  </h1>
+  <div id="js_content" style="visibility: hidden; opacity: 0;">
+    <p>First paragraph with sufficient content to be captured by the playwright_web_wechat scraper logic.</p>
+    <p>Second paragraph providing additional body text for the content extraction verification test.</p>
+  </div>
+</body>
+</html>
+"""
+
+
+def test_playwright_web_wechat_invalid_url_scheme(skill_config, tmp_path):
+    """Security check rejects non-http/https URLs before reading config."""
+    html = tmp_path / 'test.html'
+    html.write_text('<html><body><h1>X</h1></body></html>')
+    result = subprocess.run(
+        ['python3', str(SCRIPTS_DIR / 'playwright_web_wechat.py'),
+         'file:///etc/passwd', str(html)],
+        env=skill_config['env'],
+        capture_output=True, text=True
+    )
+    assert result.returncode != 0
+    assert 'Rejected URL' in result.stderr
+
+
+def test_playwright_web_wechat_missing_config(tmp_path):
+    """Clear error when config.json does not exist."""
+    html = tmp_path / 'test.html'
+    html.write_text('<html><body><h1>X</h1></body></html>')
+    env = {
+        **os.environ,
+        'HSKILL_EXTRACT_URL_CONFIG': str(tmp_path / 'nonexistent.json'),
+        'PATH': os.environ.get('PATH', ''),
+    }
+    result = subprocess.run(
+        ['python3', str(SCRIPTS_DIR / 'playwright_web_wechat.py'),
+         'https://mp.weixin.qq.com/s/testid', str(html)],
+        env=env, capture_output=True, text=True
+    )
+    assert result.returncode != 0
+
+
+def test_playwright_web_wechat_too_few_args(skill_config):
+    """Script exits non-zero when html_path argument is missing."""
+    result = subprocess.run(
+        ['python3', str(SCRIPTS_DIR / 'playwright_web_wechat.py'),
+         'https://mp.weixin.qq.com/s/testid'],
+        env=skill_config['env'],
+        capture_output=True, text=True
+    )
+    assert result.returncode != 0
+
+
+@requires_playwright
+def test_playwright_web_wechat_e2e(skill_config, tmp_path):
+    """Full e2e: hidden #js_content + data-src images + ct timestamp all extracted correctly."""
+    html = tmp_path / 'article.html'
+    html.write_text(_TEST_HTML, encoding='utf-8')
+
+    result = subprocess.run(
+        ['python3', str(SCRIPTS_DIR / 'playwright_web_wechat.py'),
+         'https://mp.weixin.qq.com/s/testid001', str(html)],
+        env=skill_config['env'],
+        capture_output=True, text=True,
+        timeout=60
+    )
+    assert result.returncode == 0, result.stderr
+    assert 'ORIGIN_PATH:' in result.stdout
+
+    origin_path = next(
+        line.split('ORIGIN_PATH:', 1)[1].strip()
+        for line in result.stdout.splitlines()
+        if line.startswith('ORIGIN_PATH:')
+    )
+    origin_file = Path(origin_path)
+    assert origin_file.exists(), f'Origin file not found at {origin_path}'
+
+    content = origin_file.read_text(encoding='utf-8')
+    assert 'WeChat Test Article' in content
+    assert 'source_url: https://mp.weixin.qq.com/s/testid001' in content
+    assert 'author: Test Official Account' in content
+    # ct = 1719763200 -> 2024-07-01 in UTC+8
+    assert 'publish_date: 2024-07-01' in content
+    # Content behind visibility:hidden must still be captured via textContent.
+    assert 'First paragraph with sufficient content' in content
+    assert 'Second paragraph providing additional body text' in content
+
+    import hashlib
+    expected_hash = hashlib.md5('https://mp.weixin.qq.com/s/testid001'.encode()).hexdigest()[:8]
+    assert origin_file.parent.name == 'Origin'
+    assert origin_file.parent.parent.name == expected_hash
+    assert origin_file.parent.parent.parent == skill_config['vault']
+
+    assert not (origin_file.parent.parent / '.fetch_issues.tmp').exists()
+
+
+@requires_playwright
+def test_playwright_web_wechat_finds_data_src_image(skill_config, tmp_path):
+    """Lazy-loaded images (data-src, no usable src attribute) are recognized as
+    real image URLs instead of being skipped (network fetch itself isn't under test)."""
+    html = tmp_path / 'article.html'
+    html.write_text(_TEST_HTML, encoding='utf-8')
+
+    result = subprocess.run(
+        ['python3', str(SCRIPTS_DIR / 'playwright_web_wechat.py'),
+         'https://mp.weixin.qq.com/s/testid002', str(html)],
+        env=skill_config['env'],
+        capture_output=True, text=True,
+        timeout=60
+    )
+    assert result.returncode == 0, result.stderr
+    assert 'Skipped unsafe image URL' not in result.stdout
+    assert '1 images' in result.stdout
+
+
+@requires_playwright
+def test_playwright_web_wechat_e2e_writes_fetch_issues_tmp_when_incomplete(skill_config, tmp_path):
+    """When origin frontmatter has real gaps (missing author/date), a temp issues file is written."""
+    html = tmp_path / 'no-author.html'
+    html.write_text(_TEST_HTML_NO_AUTHOR, encoding='utf-8')
+
+    result = subprocess.run(
+        ['python3', str(SCRIPTS_DIR / 'playwright_web_wechat.py'),
+         'https://mp.weixin.qq.com/s/testid003', str(html)],
+        env=skill_config['env'],
+        capture_output=True, text=True,
+        timeout=60
+    )
+    assert result.returncode == 0, result.stderr
+
+    origin_path = next(
+        line.split('ORIGIN_PATH:', 1)[1].strip()
+        for line in result.stdout.splitlines()
+        if line.startswith('ORIGIN_PATH:')
+    )
+    article_dir = Path(origin_path).parent.parent
+    tmp_issues = article_dir / '.fetch_issues.tmp'
+    assert tmp_issues.exists()
+    text = tmp_issues.read_text(encoding='utf-8')
+    assert 'author空' in text
+    assert 'publish_date空' in text
+    assert 'description空' not in text

package/skills/research/extract-url/tests/test_playwright_xcom.py

@@ -1,8 +1,110 @@
-import subprocess, os
+import re, subprocess, os
 from pathlib import Path
 
+import pytest
+
 SCRIPTS_DIR = Path(__file__).parent.parent / 'scripts'
 
+try:
+    from playwright.sync_api import sync_playwright as _sp  # noqa: F401
+    PLAYWRIGHT_AVAILABLE = True
+except ImportError:
+    PLAYWRIGHT_AVAILABLE = False
+
+requires_playwright = pytest.mark.skipif(
+    not PLAYWRIGHT_AVAILABLE,
+    reason="playwright not installed — run: pip install playwright && playwright install chromium"
+)
+
+
+def _extract_js(variant):
+    """Pull _EXTRACT_JS_HEADED or _EXTRACT_JS_HEADLESS source out of the script
+    so it can be evaluated directly against a synthetic page — playwright_xcom.py
+    always navigates to a real x.com URL with real cookies, so this is the only
+    way to unit-test the DOM extraction logic in isolation."""
+    src = (SCRIPTS_DIR / 'playwright_xcom.py').read_text(encoding='utf-8')
+    m = re.search(rf'{variant} = r"""(.*?)"""', src, re.S)
+    return m.group(1)
+
+
+# Mirrors the real DOM structure of an X Article (Notes) body: Draft.js renders
+# each paragraph as a public-DraftStyleDefault-block div whose children are
+# per-style-run spans — a run gets style="font-weight: bold" only where bold
+# is toggled on. Headings/blockquotes wrap the same block div internally.
+_XCOM_ARTICLE_HTML = """\
+<article data-testid="tweet">
+  <time datetime="2026-07-20T11:23:31.000Z"></time>
+  <div data-testid="User-Name">Codez <span>@0xCodez</span></div>
+  <div data-testid="twitterArticleRichTextView">
+    <h1>Test Article Title</h1>
+    <div class="longform-unstyled" data-block="true" data-offset-key="a-0-0">
+      <div data-offset-key="a-0-0" class="public-DraftStyleDefault-block public-DraftStyleDefault-ltr">
+        <span data-offset-key="a-0-0"><span data-text="true">They don&#8217;t </span></span>
+        <span data-offset-key="a-0-1" style="font-weight: bold;"><span data-text="true">route.</span></span>
+        <span data-offset-key="a-0-2"><span data-text="true"> They just queue.</span></span>
+      </div>
+    </div>
+    <blockquote class="longform-blockquote" data-block="true" data-offset-key="b-0-0">
+      <div data-offset-key="b-0-0" class="public-DraftStyleDefault-block public-DraftStyleDefault-ltr">
+        <span data-offset-key="b-0-0"><span data-text="true">A quoted line worth keeping.</span></span>
+      </div>
+    </blockquote>
+    <h2 class="longform-header-two" data-block="true" data-offset-key="c-0-0">
+      <div data-offset-key="c-0-0" class="public-DraftStyleDefault-block public-DraftStyleDefault-ltr">
+        <span data-offset-key="c-0-0"><span data-text="true">A Heading</span></span>
+      </div>
+    </h2>
+  </div>
+</article>
+"""
+
+
+@requires_playwright
+@pytest.mark.parametrize('variant', ['_EXTRACT_JS_HEADED', '_EXTRACT_JS_HEADLESS'])
+def test_playwright_xcom_merges_bold_runs_into_one_paragraph(variant):
+    """Regression: sibling style-run spans within one Draft.js paragraph block
+    must merge into a single block with inline **bold** markdown, not fragment
+    into separate paragraphs with the bold styling silently dropped."""
+    from playwright.sync_api import sync_playwright
+
+    js = _extract_js(variant)
+    with sync_playwright() as p:
+        browser = p.chromium.launch()
+        page = browser.new_page()
+        page.set_content(_XCOM_ARTICLE_HTML)
+        result = page.evaluate(js)
+        browser.close()
+
+    blocks = result['blocks']
+    para = next(b for b in blocks if 'route' in b['content'])
+    assert para['content'] == "They don’t **route.** They just queue."
+    assert para['tag'] == 'p'
+
+
+@requires_playwright
+@pytest.mark.parametrize('variant', ['_EXTRACT_JS_HEADED', '_EXTRACT_JS_HEADLESS'])
+def test_playwright_xcom_no_duplicate_blocks_for_heading_and_blockquote(variant):
+    """Regression: headings/blockquotes wrap a nested Draft.js paragraph div
+    internally — it must not be captured a second time as an extra block."""
+    from playwright.sync_api import sync_playwright
+
+    js = _extract_js(variant)
+    with sync_playwright() as p:
+        browser = p.chromium.launch()
+        page = browser.new_page()
+        page.set_content(_XCOM_ARTICLE_HTML)
+        result = page.evaluate(js)
+        browser.close()
+
+    blocks = result['blocks']
+    quote_blocks = [b for b in blocks if 'quoted line' in b['content']]
+    assert len(quote_blocks) == 1, f'blockquote text duplicated: {quote_blocks}'
+    assert quote_blocks[0]['tag'] == 'blockquote'
+
+    heading_blocks = [b for b in blocks if 'Heading' in b['content']]
+    assert len(heading_blocks) == 1, f'heading text duplicated: {heading_blocks}'
+    assert heading_blocks[0]['tag'] == 'h2'
+
 
 def test_playwright_xcom_invalid_scheme(skill_config):
     """Security check rejects non-http/https URLs before reading config."""

package/skills-index.json

@@ -38,7 +38,7 @@
       "bundle": "research",
       "installScope": "global",
       "contentHash": "4b72bb5e655884d5",
-      "contentVersion": "2.6.0"
+      "contentVersion": "2.7.1"
     },
     {
       "path": "research/extract-vision",