browser-workspace 0.4.0

package/platforms/wechat-channels/actions/_common.py

@@ -0,0 +1,163 @@
+"""Pure helpers shared by WeChat Channels browser actions."""
+from __future__ import annotations
+
+import json
+import re
+from typing import Any, Optional
+from urllib.parse import parse_qs, urlparse
+
+MANAGER_URL = "https://channels.weixin.qq.com/platform/post"
+
+STATUS_LABELS: tuple[tuple[str, str], ...] = (
+    ("审核中", "reviewing"),
+    ("未通过", "rejected"),
+    ("草稿", "draft"),
+    ("已发布", "published"),
+    ("已发表", "published"),
+)
+
+_ID_PRIORITY: tuple[str, ...] = (
+    "finderobjectid",
+    "postid",
+    "contentid",
+    "videoid",
+    "objectid",
+    "exportid",
+    "feedid",
+    "mediaid",
+)
+
+
+def status_label(text: str) -> tuple[Optional[str], Optional[str]]:
+    for label, status in STATUS_LABELS:
+        if label in text:
+            return status, label
+    return None, None
+
+
+def _normalized_key(key: str) -> str:
+    return re.sub(r"[^a-z0-9]", "", key.lower())
+
+
+def _ids_from_query(value: str) -> dict[str, str]:
+    parsed = urlparse(value)
+    if not parsed.query:
+        return {}
+    result: dict[str, str] = {}
+    for key, values in parse_qs(parsed.query).items():
+        normalized = _normalized_key(key)
+        if normalized in _ID_PRIORITY and values:
+            result[normalized] = values[0]
+    return result
+
+
+def extract_stable_id(row: dict[str, Any]) -> Optional[str]:
+    ids = dict(row.get("stable_ids") or {})
+    for source in row.get("urls") or []:
+        ids.update(_ids_from_query(str(source)))
+    for key in _ID_PRIORITY:
+        if ids.get(key):
+            return ids[key]
+    return None
+
+
+def choose_manager_row(
+    rows: list[dict[str, Any]],
+    post_id: Optional[str],
+    title: Optional[str],
+    desc: Optional[str],
+) -> Optional[dict[str, Any]]:
+    if post_id:
+        matches = [row for row in rows if extract_stable_id(row) == post_id]
+    elif title:
+        matches = [row for row in rows if title in row.get("text", "")]
+    elif desc:
+        matches = [row for row in rows if desc in row.get("text", "")]
+    else:
+        return None
+    if not matches:
+        return None
+    return min(matches, key=lambda row: len(row.get("text", "")))
+
+
+def manager_scan_expression(
+    post_id: Optional[str],
+    title: Optional[str],
+    desc: Optional[str],
+) -> str:
+    values = (
+        json.dumps(post_id or ""),
+        json.dumps(title or ""),
+        json.dumps(desc or ""),
+    )
+    return """
+(() => {
+  const root = document.querySelector('wujie-app')?.shadowRoot;
+  const body = root?.querySelector('body') || root;
+  if (!body) return '[]';
+  const priority = ['finderobjectid', 'postid', 'contentid', 'videoid', 'objectid', 'exportid', 'feedid', 'mediaid'];
+  const labels = ['审核中', '未通过', '草稿', '已发布', '已发表'];
+  const normalize = (value) => value.toLowerCase().replace(/[^a-z0-9]/g, '');
+  const targetPostId = %s;
+  const targetTitle = %s;
+  const targetDesc = %s;
+  const candidates = new Map();
+  const addCandidate = (element, kind, stableIds) => {
+    const attributes = {};
+    for (const attribute of element.attributes || []) {
+      const name = attribute.name.toLowerCase();
+      if (name.startsWith('data-') || ['aria-label', 'title'].includes(name)) attributes[name] = attribute.value;
+    }
+    const urls = [];
+    for (const anchor of element.querySelectorAll('a[href]')) {
+      if (anchor.href) urls.push(anchor.href);
+    }
+    const text = (element.innerText || element.textContent || '').replace(/\\s+/g, ' ').trim();
+    if (!text || text.length > 3000) return;
+    const encodedIds = Array.from(stableIds.entries()).sort().map(([key, value]) => `${key}=${value}`).join(';');
+    const key = `${kind}:${encodedIds}:${text}`;
+    if (candidates.has(key)) return;
+    candidates.set(key, {kind, stable_ids: Object.fromEntries(stableIds), attributes, urls, text, tag: element.tagName.toLowerCase()});
+  };
+  const collectIds = (element) => {
+    const ids = new Map();
+    for (const attribute of element.attributes || []) {
+      const normalized = normalize(attribute.name);
+      const value = attribute.value.trim();
+      if (value && priority.includes(normalized)) ids.set(normalized, value);
+    }
+    return ids;
+  };
+  for (const element of body.querySelectorAll('*')) {
+    const ids = collectIds(element);
+    const text = element.innerText || element.textContent || '';
+    if ((targetTitle && text.includes(targetTitle)) || (targetDesc && text.includes(targetDesc))) {
+      let textCandidate = element;
+      let textIds = ids;
+      for (let depth = 0; textCandidate && textCandidate !== body && depth < 12; depth += 1) {
+        const candidateText = textCandidate.innerText || textCandidate.textContent || '';
+        const candidateIds = collectIds(textCandidate);
+        if (labels.some((label) => candidateText.includes(label)) || candidateIds.size) {
+          textIds = candidateIds;
+          break;
+        }
+        textCandidate = textCandidate.parentElement;
+      }
+      addCandidate(textCandidate && textCandidate !== body ? textCandidate : element, 'text', textIds);
+    }
+    if (!ids.size) continue;
+    let labeled = null;
+    let cursor = element;
+    for (let depth = 0; cursor && cursor !== body && depth < 12; depth += 1) {
+      const cursorText = cursor.innerText || cursor.textContent || '';
+      if (labels.some((label) => cursorText.includes(label))) {
+        labeled = cursor;
+        break;
+      }
+      cursor = cursor.parentElement;
+    }
+    addCandidate(labeled || element, 'id', ids);
+  }
+  return JSON.stringify(Array.from(candidates.values()));
+})()
+""".strip() % values

package/platforms/wechat-channels/actions/_manage.py

@@ -0,0 +1,130 @@
+import json
+import os
+import time
+from urllib.parse import urlparse
+
+from _common import (
+    MANAGER_URL,
+    choose_manager_row,
+    extract_stable_id,
+    manager_scan_expression,
+    status_label,
+)
+
+CFG = json.load(open("__CFG_PATH__"))
+OP = CFG["operation"]
+POST_ID = CFG.get("post_id")
+TITLE = CFG.get("title")
+DESC = CFG.get("desc")
+
+
+def out(payload: dict) -> None:
+    print(json.dumps(payload, ensure_ascii=False, separators=(",", ":")))
+
+
+def open_or_reuse_wechat(url: str) -> dict:
+    current = current_tab()
+    tabs = [
+        tab
+        for tab in list_tabs()
+        if urlparse(tab.get("url") or "").hostname == "channels.weixin.qq.com"
+    ]
+    target = (
+        current
+        if urlparse(current.get("url") or "").hostname == "channels.weixin.qq.com"
+        else tabs[0] if tabs else None
+    )
+    if target is None:
+        new_tab(url)
+        return current_tab()
+    switch_tab(target)
+    if page_info().get("url") != url:
+        goto_url(url)
+    return current_tab()
+
+
+def wait_for_shadow(timeout_seconds: int = 20) -> bool:
+    expression = (
+        'document.querySelector("wujie-app")?.shadowRoot?.querySelector("body") '
+        '? "yes" : "no"'
+    )
+    deadline = time.monotonic() + timeout_seconds
+    while time.monotonic() < deadline:
+        if js(expression) == "yes":
+            return True
+        time.sleep(0.5)
+    return False
+
+
+def manager_has_content() -> bool:
+    expression = (
+        '(document.querySelector("wujie-app")?.shadowRoot?.querySelector("body")'
+        '?.innerText || "").trim()'
+    )
+    return bool(js(expression))
+
+
+def manager_rows(
+    post_id: str | None,
+    title: str | None,
+    desc: str | None,
+) -> list[dict]:
+    try:
+        raw = json.loads(js(manager_scan_expression(post_id, title, desc)) or "[]")
+    except (TypeError, json.JSONDecodeError):
+        return []
+    return raw if isinstance(raw, list) else []
+
+
+def resolve_manager() -> tuple[str, dict]:
+    open_or_reuse_wechat(MANAGER_URL)
+    if not wait_for_shadow():
+        return "unknown", {"reason": "manager_shadow_root_missing"}
+    deadline = time.monotonic() + 30
+    content_deadline = time.monotonic() + 12
+    row = None
+    while time.monotonic() < deadline:
+        rows = manager_rows(POST_ID, TITLE, DESC)
+        row = choose_manager_row(rows, POST_ID, TITLE, DESC)
+        if row is not None:
+            break
+        if manager_has_content() and time.monotonic() >= content_deadline:
+            return "not_found", {"reason": "no_matching_manager_row"}
+        time.sleep(1)
+    if row is None:
+        return "unknown", {"reason": "manager_did_not_load"}
+    status, label = status_label(row.get("text", ""))
+    return status or "unknown", {
+        "reason": None if status else "status_label_not_found",
+        "row": row,
+        "post_id": extract_stable_id(row) or POST_ID,
+        "status_label": label,
+    }
+
+
+if OP != "status":
+    out(
+        {
+            "ok": False,
+            "platform": "wechat-channels",
+            "operation": OP,
+            "error": "unsupported_operation",
+            "supported_operations": ["status"],
+        }
+    )
+    raise SystemExit(2)
+
+status, details = resolve_manager()
+result = {
+    "ok": status in {"published", "reviewing", "rejected", "draft"},
+    "platform": "wechat-channels",
+    "operation": "status",
+    "status": status,
+    "post_id": details.get("post_id"),
+    "status_label": details.get("status_label"),
+    "target": {"post_id": POST_ID, "title": TITLE, "desc": DESC},
+    "reason": details.get("reason"),
+    "row": details.get("row"),
+}
+out(result)
+raise SystemExit(0 if result["ok"] else 2)

package/platforms/wechat-channels/actions/_post.py

@@ -0,0 +1,232 @@
+import json
+import os
+import time
+from urllib.parse import urlparse
+
+from _common import (
+    MANAGER_URL,
+    choose_manager_row,
+    extract_stable_id,
+    manager_scan_expression,
+    status_label,
+)
+
+CFG = json.load(open("__CFG_PATH__"))
+
+SB = 'document.querySelector("wujie-app").shadowRoot.querySelector("body")'
+
+def open_or_reuse_wechat(url):
+    current = current_tab()
+    tabs = [tab for tab in list_tabs() if urlparse(tab.get("url") or "").hostname == "channels.weixin.qq.com"]
+    target = current if urlparse(current.get("url") or "").hostname == "channels.weixin.qq.com" else (tabs[0] if tabs else None)
+    if target is None:
+        new_tab(url)
+        return current_tab()
+    switch_tab(target)
+    if page_info().get("url") != url:
+        goto_url(url)
+    return current_tab()
+
+def shadow_js(expr):
+    return js(SB + expr)
+
+def find_rect(sel):
+    code = SB + '.querySelector("' + sel + '") ? (function(){ var r = ' + SB + '.querySelector("' + sel + '").getBoundingClientRect(); return JSON.stringify({x:Math.round(r.x+r.width/2), y:Math.round(r.y+r.height/2)}); })() : "null"'
+    r = js(code)
+    if r and r != "null":
+        return json.loads(r)
+    return None
+
+print("[1/6] Opening or reusing the WeChat Channels create tab...")
+open_or_reuse_wechat("https://channels.weixin.qq.com/platform/post/create")
+wait_for_load()
+time.sleep(4)
+
+url = page_info()["url"]
+if "login" in url.lower():
+    print("ERROR: Not logged in. Scan QR at https://channels.weixin.qq.com/")
+    capture_screenshot()
+    raise SystemExit(1)
+
+for i in range(10):
+    sc = js('document.querySelector("wujie-app")?.shadowRoot ? "ok" : "no"')
+    if sc == "ok":
+        break
+    time.sleep(1)
+else:
+    print("ERROR: Shadow DOM not found after 10s.")
+    capture_screenshot()
+    raise SystemExit(1)
+
+for i in range(10):
+    has_upload = shadow_js('.querySelector(".upload") ? "ok" : "no"')
+    if has_upload == "ok":
+        break
+    time.sleep(1)
+else:
+    print("ERROR: Upload area not found.")
+    capture_screenshot()
+    raise SystemExit(1)
+
+print("  -> Logged in, page loaded.")
+
+print("[2/6] Uploading video: " + CFG["video"])
+doc = cdp("DOM.getDocument", depth=-1, pierce=True)
+sr = cdp("DOM.performSearch", query='input[type="file"][accept*="video"]')
+if sr.get("resultCount", 0) > 0:
+    nodes = cdp("DOM.getSearchResults", searchId=sr["searchId"], fromIndex=0, toIndex=1)
+    nid = nodes["nodeIds"][0]
+    cdp("DOM.setFileInputFiles", files=[CFG["video"]], nodeId=nid)
+    cdp("DOM.discardSearchResults", searchId=sr["searchId"])
+    print("  -> Video file set via DOM.")
+else:
+    print("ERROR: Cannot find video file input.")
+    capture_screenshot()
+    raise SystemExit(1)
+
+print("  -> Waiting for upload...")
+for attempt in range(120):
+    time.sleep(5)
+    btn_cls = shadow_js('.querySelector(".weui-desktop-btn_primary")?.classList?.contains("weui-desktop-btn_disabled") ? "disabled" : "enabled"')
+    vid_ok = shadow_js('.querySelector(".cover-wrap, video, [class*=uploaded], [class*=video-info], .upload-success, .post-edit-wrap") ? "ready" : "wait"')
+    if vid_ok == "ready" or btn_cls == "enabled":
+        print("  -> Upload done!")
+        break
+    if attempt % 6 == 5:
+        pct = shadow_js('.querySelector("[class*=progress], .percent")?.textContent || "..."')
+        print("  -> Uploading... " + str(pct) + " (" + str((attempt+1)*5) + "s)")
+else:
+    print("WARNING: Upload timeout.")
+    capture_screenshot()
+time.sleep(2)
+
+print("[3/6] Setting description...")
+tags = CFG.get("tags", [])
+desc = CFG["desc"]
+if tags:
+    desc = desc + " " + " ".join(f"#{t}" for t in tags)
+desc_s = json.dumps(desc)
+shadow_js('.querySelector(".input-editor[contenteditable=true]")?.focus()')
+time.sleep(0.3)
+js(SB + '.querySelector(".input-editor").textContent = ' + desc_s)
+js(SB + '.querySelector(".input-editor").dispatchEvent(new Event("input", {bubbles:true}))')
+time.sleep(0.5)
+actual = shadow_js('.querySelector(".input-editor")?.textContent?.substring(0,50) || ""')
+if actual:
+    print("  -> Description: " + actual)
+else:
+    print("  -> WARNING: Description may not have been set, trying click+type...")
+    c = find_rect(".input-editor")
+    if c:
+        click_at_xy(c["x"], c["y"])
+        time.sleep(0.5)
+        type_text(CFG["desc"])
+        time.sleep(0.5)
+
+if CFG["title"]:
+    print("[4/6] Setting short title: " + CFG["title"])
+    title_s = json.dumps(CFG["title"])
+    shadow_js('.querySelector(".weui-desktop-form__input")?.focus()')
+    time.sleep(0.2)
+    js('Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "value").set.call(' + SB + '.querySelector(".weui-desktop-form__input"), ' + title_s + ')')
+    js(SB + '.querySelector(".weui-desktop-form__input").dispatchEvent(new Event("input", {bubbles:true}))')
+    time.sleep(0.3)
+else:
+    print("[4/6] No short title, skipping...")
+
+# Scroll down to make buttons visible
+shadow_js('.scrollTo(0, 99999)')
+js('document.querySelector("wujie-app").shadowRoot.querySelector("html")?.scrollTo(0, 99999)')
+time.sleep(1)
+
+print("[5/6] Pre-action screenshot...")
+capture_screenshot()
+time.sleep(1)
+
+def find_btn_by_text(text):
+    # Find a visible button by its text content (avoids matching hidden dialog buttons)
+    r = js(SB + '.querySelectorAll(".weui-desktop-btn").forEach(function(b){}); var found=null; ' + SB + '.querySelectorAll(".weui-desktop-btn").forEach(function(b){ var rect=b.getBoundingClientRect(); if(b.textContent.trim()==="' + text + '" && rect.width>0 && !b.classList.contains("weui-desktop-btn_disabled")){ found={x:Math.round(rect.x+rect.width/2), y:Math.round(rect.y+rect.height/2)}; }}); found ? JSON.stringify(found) : "null"')
+    if r and r != "null":
+        return json.loads(r)
+    return None
+
+if CFG["publish"]:
+    print("[6/6] Publishing...")
+    c = find_btn_by_text("\u53d1\u8868")  # 发表
+    if c:
+        click_at_xy(c["x"], c["y"])
+        time.sleep(3)
+        # Handle confirmation dialog
+        shadow_js('.querySelectorAll(".weui-desktop-dialog__wrp").forEach(function(d){ if(d.style.display !== "none"){ var b = d.querySelector(".weui-desktop-btn_primary"); if(b) b.click(); }})')
+        time.sleep(3)
+        print("  -> Publish action submitted; verifying manager state...")
+        action = "publish"
+    else:
+        print("ERROR: Publish button disabled/not found. Check manager before retrying.")
+        capture_screenshot()
+        raise SystemExit(1)
+else:
+    print("[6/6] Saving draft...")
+    c = find_btn_by_text("\u4fdd\u5b58\u8349\u7a3f")  # 保存草稿
+    if c:
+        click_at_xy(c["x"], c["y"])
+        time.sleep(3)
+        print("  -> Draft action submitted; verifying manager state...")
+        action = "draft"
+    else:
+        print("ERROR: Save draft button disabled/not found. Check manager before retrying.")
+        capture_screenshot()
+        raise SystemExit(1)
+
+def verify_manager():
+    open_or_reuse_wechat(MANAGER_URL)
+    expected_title = CFG.get("title") or ""
+    expected_desc = CFG.get("desc") or ""
+    deadline = time.time() + 40
+    content_deadline = time.time() + 15
+    while time.time() < deadline:
+        ready = js('document.querySelector("wujie-app")?.shadowRoot?.querySelector("body") ? "yes" : "no"') == "yes"
+        if ready:
+            raw = js(manager_scan_expression("", expected_title, expected_desc)) or "[]"
+            try:
+                rows = json.loads(raw)
+            except json.JSONDecodeError:
+                rows = []
+            row = choose_manager_row(rows, None, expected_title, expected_desc)
+            if row:
+                status, label = status_label(row.get("text", ""))
+                return {
+                    "status": status or "unknown",
+                    "status_label": label,
+                    "post_id": extract_stable_id(row),
+                    "row": row,
+                    "reason": None if status else "status_label_not_found",
+                }
+            has_content = bool(js('document.querySelector("wujie-app")?.shadowRoot?.querySelector("body")?.innerText?.trim() || ""'))
+            if has_content and time.time() >= content_deadline:
+                return {"status": "not_found", "status_label": None, "post_id": None, "row": None, "reason": "no_matching_manager_row"}
+        time.sleep(1)
+    return {"status": "unknown", "status_label": None, "post_id": None, "row": None, "reason": "manager_did_not_load"}
+
+verification = verify_manager()
+result = {
+    "ok": verification["status"] in {"published", "reviewing"} if action == "publish" else verification["status"] == "draft",
+    "platform": "wechat-channels",
+    "operation": action,
+    "status": verification["status"],
+    "status_label": verification["status_label"],
+    "post_id": verification["post_id"],
+    "title": CFG.get("title"),
+    "desc": CFG.get("desc"),
+    "verified": verification["status"] in {"published", "reviewing", "rejected", "draft"},
+    "reason": verification["reason"],
+    "row": verification["row"],
+    "retry_safe": False,
+}
+print(json.dumps(result, ensure_ascii=False, separators=(",", ":")))
+time.sleep(1)
+capture_screenshot()
+if not result["ok"]:
+    raise SystemExit(7 if verification["status"] in {"unknown", "not_found"} else 8)
+
+print("Done!")

package/platforms/wechat-channels/manifest.yaml

@@ -0,0 +1,118 @@
+platform: wechat-channels
+status: migrated_unverified
+last_verified: null
+actions:
+  post: actions/_post.py
+  manage: actions/_manage.py
+verification:
+  status: migrated_unverified
+  last_verified: null
+  evidence: Existing post/shadow-DOM and manager mechanics migrated from the working
+    post adapter. Current Browser Workspace live verification pending.
+url_patterns:
+- https://channels.weixin.qq.com/*
+authentication:
+  required: true
+  notes: Use the caller's authenticated browser context; never store credentials.
+provenance:
+  source: skills/post/scripts/platforms/wechat-channels
+  migrated_code: true
+flows:
+  post:
+    status: migrated_unverified
+    evidence: Migrated action; current Browser Workspace live verification pending.
+  manage:
+    status: migrated_unverified
+    evidence: Migrated manager action; current Browser Workspace live verification
+      pending.
+display_name: WeChat Channels
+aliases:
+- wechat
+- channels
+implementation_status: code_only_live_ui_unverified
+media:
+  modes:
+  - video
+  video:
+    required: true
+    formats:
+    - mp4
+    codec_hint: H.264
+    max_size_gb: 20
+    max_duration_hours: 8
+fields:
+  desc:
+    cli: --desc
+    required: true
+    type: string
+    max_chars: 1000
+    implemented: true
+  title:
+    cli: --title
+    required: false
+    type: string
+    min_chars: 6
+    max_chars: 16
+    implemented: true
+    meaning: short title
+  tags:
+    cli: --tags
+    required: false
+    type: string_list
+    implemented: true
+    render: 'append as #tag'
+  publish:
+    cli: --publish
+    required: false
+    type: boolean
+    default: false
+    implemented: true
+  draft:
+    cli: --draft
+    required: false
+    type: boolean
+    default: true
+    implemented: true
+    note: default behavior already saves draft when --publish is absent
+  status:
+    cli: status
+    required: false
+    type: operation
+    implemented: true
+    verified: false
+    target_fields:
+    - post_id
+    - title
+    - desc
+    values:
+    - published
+    - reviewing
+    - rejected
+    - draft
+    - unknown
+    - not_found
+capabilities:
+  draft: true
+  publish: true
+  visibility: false
+  custom_thumbnail: false
+  post_status: true
+  update_post: false
+  read_comments: false
+  write_comment: false
+  reply_comments: false
+content_mapping:
+  headline: title
+  main_text: desc
+  discovery_terms: tags
+notes:
+- The adapter reuses one existing channels.weixin.qq.com tab and creates one only
+  when none exists.
+- After submit/draft, the adapter inspects the creator manager and returns structured
+  status JSON.
+- The manager probe is semantic but this implementation run could not verify the live
+  creator UI; unknown/not_found must be treated as authoritative uncertainty.
+- An uncertain submit is not retried automatically; run status and inspect manager
+  state before any deliberate retry.
+- Update/edit, comment reading, comments, and replies are intentionally unimplemented
+  until their exact creator UI is observed.

package/platforms/wechat-channels/tests/test_contract.py

@@ -0,0 +1,36 @@
+from importlib.util import module_from_spec, spec_from_file_location
+from pathlib import Path
+
+HERE=Path(__file__).resolve().parents[1]
+
+
+def load_common():
+    path=HERE/'actions'/'_common.py'
+    spec=spec_from_file_location('wechat_channels_common',path)
+    assert spec and spec.loader
+    mod=module_from_spec(spec); spec.loader.exec_module(mod); return mod
+
+
+def test_status_label_mapping():
+    c=load_common()
+    assert c.status_label('审核中 1 分钟前') == ('reviewing','审核中')
+    assert c.status_label('已发表 2026-09-15') == ('published','已发表')
+    assert c.status_label('no status') == (None,None)
+
+
+def test_stable_id_prefers_url_finder_id():
+    c=load_common()
+    row={'stable_ids':{'objectid':'object-1'},'urls':['https://channels.weixin.qq.com/platform/post?finderObjectId=finder-2']}
+    assert c.extract_stable_id(row) == 'finder-2'
+
+
+def test_choose_manager_row_prefers_post_id():
+    c=load_common()
+    rows=[{'text':'审核中 title','stable_ids':{'postid':'post-1'},'urls':[]},{'text':'已发布 other','stable_ids':{'postid':'post-2'},'urls':[]}]
+    assert c.choose_manager_row(rows,'post-2','title',None)['text'] == '已发布 other'
+    assert c.choose_manager_row(rows,None,'title',None)['text'] == '审核中 title'
+
+
+def test_rejected_publish_is_not_success():
+    source=(HERE/'actions'/'_post.py').read_text()
+    assert 'verification["status"] in {"published", "reviewing"}' in source

package/platforms/xhs/README.md

@@ -0,0 +1,10 @@
+---
+name: xhs-platform
+description: "Xiaohongshu Browser Workspace posting and creator-manager assets."
+---
+
+# Xiaohongshu
+
+Use the parent Browser Workspace skill contract first. The
+`actions/` directory contains the canonical migrated mechanics used by
+`skills/post`; posting-domain validation and publish semantics remain in `post`.