browser-workspace 0.4.1 → 0.4.2

package/README.md

@@ -20,7 +20,7 @@ browser-workspace session stop SESSION_ID
 
 `--workspace` is hidden from normal CLI help. Normal sessions use `Harness`; product integrations may set an explicit workspace internally when they require isolation.
 
-`session stop` closes all tabs created/owned by that session while leaving unrelated browser tabs untouched.
+`session stop` closes all tabs created/owned by that session while leaving unrelated browser tabs untouched. Raw session CDP cannot create targets: `Target.createTarget` is rejected and callers must use `new_tab()` so workspace/session ownership is preserved.
 
 ## Included layers
 

package/SKILL.md

@@ -18,22 +18,24 @@ $BW_CLI status
 
 On first use, Browser Workspace bootstraps its own `.venv` automatically.
 
-Use one of two execution paths:
+Use one session-owned execution path for orchestrated browser work:
 
 ```text
-known platform flow
-  -> $BW_CLI platform run <platform> <action> [--config FILE]
-  -> runner creates the browser session
-  -> runner executes the platform action
-  -> runner always stops and cleans up
-
-custom browser workflow
-  -> $BW_CLI session start
-  -> $BW_CLI session exec <session_id>
-  -> $BW_CLI session stop <session_id>
+start one Browser Workspace session
+  -> retain SESSION_ID for the whole workflow
+  -> platform run <platform> <action> --session-id SESSION_ID
+  -> inspect each result
+  -> on recoverable failure, diagnose and self-heal in the SAME session
+  -> write every successful site-specific repair back to the platform code
+  -> continue until the external workflow reaches a terminal outcome
+  -> verify the terminal external state
+finally
+  -> stop SESSION_ID
 ```
 
-Do not manually create a session around a platform action unless product code intentionally owns a longer-lived browser context. There are no separate top-level `open`, `tabs`, `status`, or `screenshot` commands.
+`platform run` therefore requires `--session-id` by default. If omitted, the CLI returns a structured error that recommends the `session start -> platform run --session-id -> self-heal -> session stop` workflow. `--auto-session` is an explicit one-shot escape hatch: it creates and cleans up a temporary session automatically, but **does not provide orchestrator self-heal** after failure.
+
+There are no separate top-level `open`, `tabs`, `status`, or `screenshot` commands.
 
 Every logical browser workflow must follow:
 
@@ -110,7 +112,7 @@ A Python file may also be used with `--code-file`.
 $BW_CLI session stop <session_id>
 ```
 
-Stopping closes every tab owned or opened by that session—including tabs created with `new_tab()`, `bh.new_tab()`, direct `Target.createTarget`, and detected child/popup tabs—then destroys the session's Python namespace. It does not close unrelated browser tabs. Do not reuse the ID afterward.
+Stopping closes every tab owned or opened by that session—including tabs created with `new_tab()`, `bh.new_tab()`, and detected child/popup tabs—then destroys the session's Python namespace. Raw `cdp("Target.createTarget", ...)` is rejected; use `new_tab()` so Browser Workspace can own and group the tab. It does not close unrelated browser tabs. Do not reuse the ID afterward.
 
 A safe shell structure is:
 
@@ -216,21 +218,41 @@ platforms/<name>/
 
 Platform rules:
 
-- Platform actions may use browser helpers such as `new_tab()`, `current_tab()`, `snapshot()`, `js()`, `cdp()`, uploads, downloads, and screenshots.
+- Platform actions may use semantic browser helpers such as `new_tab()`, `current_tab()`, `snapshot()`, `click(selector)`, `fill_input(selector, text)`, `js()`, `cdp()`, uploads, downloads, and screenshots. `cdp()` must not create targets; `Target.createTarget` is blocked and tab creation must use `new_tab()`.
+- Platform interaction code must be **semantic and element-based**. It must not use screen coordinates, viewport coordinates, `x/y` click targets, `click_at_xy()`, or coordinate calculations to interact with the page. Browser size, zoom, display resolution, and viewport geometry must not affect correctness.
 - Platform actions must **not** create/stop Browser Workspace sessions, choose a workspace, call workspace-management APIs, invoke the Browser Workspace CLI, or import session/workspace infrastructure.
+- The orchestrator owns the session lifecycle for normal platform execution: start once, retain the same session across execution and recovery, and stop only after terminal success, terminal failure, or an explicit human blocker.
+- On any recoverable failure, the orchestrator must inspect the live page in the same session, diagnose the failure, repair/recover, and resume from the safest point rather than restarting the whole workflow.
+- **Self-heal writeback is mandatory:** if recovery discovers a site-specific selector, flow, wait condition, validation rule, or other adapter fix that makes the action work, write that repair back to `platforms/<name>/actions/` (and update platform docs/verification metadata when applicable) before declaring the workflow complete. A repair that exists only in an ad-hoc session snippet is not complete.
+- After a possible external side effect (publish, send, payment, delete, submit, etc.), recovery must be verification-first. Never repeat the side effect until read-only evidence proves the previous attempt did not take effect.
 - Platform `README.md` and flow docs should describe site behavior, preconditions, side effects, and verification evidence—not Browser Workspace lifecycle mechanics.
-- Platform actions must remain usable in either a generic runner-owned session or a product-owned browser context.
-- The generic runner owns the normal lifecycle: start a default Harness session, inject browser helpers/config, execute the action, then always stop the session and close its owned tabs.
-- Products that require a dedicated or persistent browser context (for example Family Tutor or Agents Relay) may execute the same platform action inside product-owned infrastructure. The platform code itself stays unchanged.
 - Do not rediscover a known site's mechanics when a verified platform flow/action already exists.
 
-Run a platform action through the generic runner:
+Normal orchestrator workflow:
+
+```bash
+SESSION_JSON=$($BW_CLI session start --url https://example.com)
+SESSION_ID=$(python3 -c 'import json,sys; print(json.loads(sys.argv[1])["session_id"])' "$SESSION_JSON")
+
+$BW_CLI platform run microsoft-teams meeting \
+  --session-id "$SESSION_ID" \
+  --config /path/to/config.json
+
+# If it fails: inspect/self-heal using the same SESSION_ID, write the repair
+# back to the platform implementation, then resume safely.
+
+$BW_CLI session stop "$SESSION_ID"
+```
+
+One-shot mode is explicit and is not self-healing:
 
 ```bash
-$BW_CLI platform run microsoft-teams meeting --config /path/to/config.json
+$BW_CLI platform run microsoft-teams meeting \
+  --auto-session \
+  --config /path/to/config.json
 ```
 
-The runner output hides the raw session ID. It returns the platform/action result, optional workspace-extension warning, and cleanup evidence.
+Use `--auto-session` only when losing the browser state after a failure is acceptable.
 
 ### Platform verification contract
 

package/bin/browser-workspace

@@ -30,18 +30,165 @@ def status():
     }
 
 def main():
-    p=argparse.ArgumentParser(prog='browser-workspace')
-    sp=p.add_subparsers(dest='group',required=True)
-    sp.add_parser('status')
-    session=sp.add_parser('session'); ssp=session.add_subparsers(dest='cmd',required=True)
-    start=ssp.add_parser('start'); start.add_argument('--workspace', help=argparse.SUPPRESS); start.add_argument('--url')
-    ssp.add_parser('list')
-    ex=ssp.add_parser('exec'); ex.add_argument('session_id'); ex.add_argument('--code-file')
-    stop=ssp.add_parser('stop'); stop.add_argument('session_id', nargs='?'); stop.add_argument('--all', action='store_true', dest='stop_all')
-    platform=sp.add_parser('platform'); psp=platform.add_subparsers(dest='pcmd',required=True)
-    profile=psp.add_parser('profile'); profile.add_argument('platform')
-    source=psp.add_parser('source'); source.add_argument('platform'); source.add_argument('action'); source.add_argument('--config')
-    run=psp.add_parser('run'); run.add_argument('platform'); run.add_argument('action'); run.add_argument('--config'); run.add_argument('--url'); run.add_argument('--session-id')
+    fmt=argparse.RawDescriptionHelpFormatter
+    p=argparse.ArgumentParser(
+        prog='browser-workspace',
+        description='Control the shared Browser Workspace Chrome, browser sessions, and platform automations.',
+        epilog='''Examples:
+  browser-workspace status
+  browser-workspace session start --url https://example.com
+  browser-workspace session list
+  browser-workspace session exec SESSION_ID --code-file script.py
+  browser-workspace session stop SESSION_ID
+  browser-workspace session stop --all
+  browser-workspace platform profile wechat-channels
+  browser-workspace platform run wechat-channels manage --session-id SESSION_ID --config status.json
+  browser-workspace platform run wechat-channels post --session-id SESSION_ID --config post.json
+  browser-workspace platform run wechat-channels manage --auto-session --config status.json
+''',
+        formatter_class=fmt,
+    )
+    sp=p.add_subparsers(dest='group',required=True,title='commands',metavar='COMMAND')
+
+    sp.add_parser(
+        'status',
+        help='Show Browser Workspace runtime, managed Chrome, daemon, and active-session status.',
+        description='Show Browser Workspace runtime, managed Chrome, daemon, and active-session status.',
+        epilog='Example:\n  browser-workspace status',
+        formatter_class=fmt,
+    )
+
+    session=sp.add_parser(
+        'session',
+        help='Create, inspect, execute code in, and stop browser sessions.',
+        description='Manage Browser Workspace sessions.',
+        epilog='''Examples:
+  browser-workspace session start --url https://example.com
+  browser-workspace session list
+  browser-workspace session exec SESSION_ID --code-file script.py
+  cat script.py | browser-workspace session exec SESSION_ID
+  browser-workspace session stop SESSION_ID
+  browser-workspace session stop --all
+''',
+        formatter_class=fmt,
+    )
+    ssp=session.add_subparsers(dest='cmd',required=True,title='session commands',metavar='COMMAND')
+
+    start=ssp.add_parser(
+        'start',
+        help='Start a browser session, optionally opening a URL.',
+        description='Start a browser session. The shared managed Chrome is reused; this does not launch a separate browser per session.',
+        epilog='''Examples:
+  browser-workspace session start
+  browser-workspace session start --url https://example.com
+''',
+        formatter_class=fmt,
+    )
+    start.add_argument('--workspace', help=argparse.SUPPRESS)
+    start.add_argument('--url', metavar='URL', help='URL to open when the session starts.')
+
+    ssp.add_parser(
+        'list',
+        help='List currently active Browser Workspace sessions.',
+        description='List currently active Browser Workspace sessions and their target tabs.',
+        epilog='Example:\n  browser-workspace session list',
+        formatter_class=fmt,
+    )
+
+    ex=ssp.add_parser(
+        'exec',
+        help='Execute Browser Workspace Python helpers inside an existing session.',
+        description='Execute Python using Browser Workspace helpers in an existing session. Read code from --code-file or stdin.',
+        epilog='''Examples:
+  browser-workspace session exec SESSION_ID --code-file script.py
+
+  browser-workspace session exec SESSION_ID <<'PY'
+  print(page_info())
+  print(snapshot(interactive_only=False))
+  PY
+''',
+        formatter_class=fmt,
+    )
+    ex.add_argument('session_id', metavar='SESSION_ID', help='Session ID returned by "session start" or "session list".')
+    ex.add_argument('--code-file', metavar='PATH', help='Read Python code from this file instead of stdin.')
+
+    stop=ssp.add_parser(
+        'stop',
+        help='Stop one session or all sessions and release their Browser Workspace tabs.',
+        description='Stop one Browser Workspace session, or all sessions with --all.',
+        epilog='''Examples:
+  browser-workspace session stop SESSION_ID
+  browser-workspace session stop --all
+''',
+        formatter_class=fmt,
+    )
+    stop.add_argument('session_id', nargs='?', metavar='SESSION_ID', help='Session ID to stop.')
+    stop.add_argument('--all', action='store_true', dest='stop_all', help='Stop all active Browser Workspace sessions.')
+
+    platform=sp.add_parser(
+        'platform',
+        help='Inspect and run reusable website-specific platform automations.',
+        description='Inspect and run reusable Browser Workspace platform automations.',
+        epilog='''Examples:
+  browser-workspace platform profile wechat-channels
+  browser-workspace platform source wechat-channels post --config post.json
+  browser-workspace session start --url https://channels.weixin.qq.com/platform/post/list
+  browser-workspace platform run wechat-channels manage --session-id SESSION_ID --config status.json
+  browser-workspace platform run wechat-channels post --session-id SESSION_ID --config post.json
+  browser-workspace session stop SESSION_ID
+
+One-shot mode (no orchestrator self-heal):
+  browser-workspace platform run wechat-channels manage --auto-session --config status.json
+''',
+        formatter_class=fmt,
+    )
+    psp=platform.add_subparsers(dest='pcmd',required=True,title='platform commands',metavar='COMMAND')
+
+    profile=psp.add_parser(
+        'profile',
+        help='Show a platform manifest/profile: fields, media rules, and capabilities.',
+        description='Show the declared Browser Workspace profile for a platform.',
+        epilog='Example:\n  browser-workspace platform profile wechat-channels',
+        formatter_class=fmt,
+    )
+    profile.add_argument('platform', metavar='PLATFORM', help='Platform name, for example "wechat-channels".')
+
+    source=psp.add_parser(
+        'source',
+        help='Print the fully prepared Python source for one platform action without running it.',
+        description='Render the action source after injecting the optional JSON config path. No browser action is executed.',
+        epilog='''Examples:
+  browser-workspace platform source wechat-channels post --config post.json
+  browser-workspace platform source wechat-channels manage --config status.json
+''',
+        formatter_class=fmt,
+    )
+    source.add_argument('platform', metavar='PLATFORM', help='Platform name, for example "wechat-channels".')
+    source.add_argument('action', metavar='ACTION', help='Declared action name, for example "post" or "manage".')
+    source.add_argument('--config', metavar='PATH', help='JSON configuration file used to prepare the action.')
+
+    run=psp.add_parser(
+        'run',
+        help='Run one platform action in Browser Workspace.',
+        description='Run a declared platform action. A caller-owned --session-id is required by default so an orchestrator can inspect failures, self-heal in the same browser state, write repairs back to platform code, and close the session only after completion. --auto-session is an explicit one-shot mode without orchestrator self-heal.',
+        epilog='''Examples:
+  browser-workspace session start --url https://channels.weixin.qq.com/platform/post/list
+  browser-workspace platform run wechat-channels manage --session-id SESSION_ID --config status.json
+  browser-workspace platform run wechat-channels post --session-id SESSION_ID --config post.json
+  browser-workspace session stop SESSION_ID
+
+One-shot mode (no orchestrator self-heal):
+  browser-workspace platform run wechat-channels manage --auto-session --config status.json
+''',
+        formatter_class=fmt,
+    )
+    run.add_argument('platform', metavar='PLATFORM', help='Platform name, for example "wechat-channels".')
+    run.add_argument('action', metavar='ACTION', help='Declared action name, for example "post" or "manage".')
+    run.add_argument('--config', metavar='PATH', help='JSON configuration file for the platform action.')
+    run.add_argument('--url', metavar='URL', help='Optional initial URL for a temporary session.')
+    session_mode = run.add_mutually_exclusive_group()
+    session_mode.add_argument('--session-id', metavar='SESSION_ID', help='Required by default. Reuse a caller-owned session so failures can be inspected and self-healed before the session is closed.')
+    session_mode.add_argument('--auto-session', action='store_true', help='Explicit one-shot mode: create and clean up a temporary session automatically. No orchestrator self-heal is available after failure.')
     args=p.parse_args()
     if args.group=='status': emit(status()); return
     if args.group=='session' and args.cmd=='list':
@@ -71,5 +218,19 @@ def main():
         from platform_runner import platform_profile
         emit(platform_profile(args.platform)); return
     if args.group=='platform' and args.pcmd=='run':
-        r=run_platform_action(args.platform,args.action,config_path=args.config,url=args.url,session_id=args.session_id); emit(r); raise SystemExit(0 if (r.get('result') or {}).get('ok',False) else 1)
+        if not args.session_id and not args.auto_session:
+            emit({
+                'ok': False,
+                'error': 'session_id_required',
+                'message': 'platform run requires --session-id by default so the orchestrator can self-heal failures in the same browser session.',
+                'suggested_workflow': [
+                    'browser-workspace session start --url <URL>',
+                    'browser-workspace platform run <PLATFORM> <ACTION> --session-id SESSION_ID [--config FILE]',
+                    'inspect/self-heal failures in the same SESSION_ID and write successful repairs back to platform code',
+                    'browser-workspace session stop SESSION_ID',
+                ],
+                'auto_session': 'Use --auto-session only for a one-shot run. It creates and closes its own session and does not provide orchestrator self-heal.',
+            })
+            raise SystemExit(2)
+        r=run_platform_action(args.platform,args.action,config_path=args.config,url=args.url,session_id=args.session_id,auto_session=args.auto_session); emit(r); raise SystemExit(0 if (r.get('result') or {}).get('ok',False) else 1)
 if __name__=='__main__': main()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "browser-workspace",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "Agent browser workspace with persistent sessions, tab leasing, snapshots, and platform workflows.",
   "bin": {
     "browser-workspace": "bin/browser-workspace"

package/platform_runner.py

@@ -102,11 +102,16 @@ def declared_actions(platform: str) -> dict[str, Path]:
         raise ValueError(f"{platform}/manifest.yaml has no actions block")
 
     actions: dict[str, Path] = {}
-    for name, relative in re.findall(
-        r'^\s{2}([\w-]+):\s*["\']([^"\']+)["\']\s*$',
-        match.group("body"),
-        flags=re.MULTILINE,
-    ):
+    for line in match.group("body").splitlines():
+        entry = re.match(r'^\s{2}([\w-]+):\s*(.+?)\s*$', line)
+        if not entry:
+            continue
+        name, relative = entry.groups()
+        if len(relative) >= 2 and relative[0] == relative[-1] and relative[0] in {"\"", "'"}:
+            relative = relative[1:-1]
+        # Actions are simple relative file paths; comments and nested mappings are not runnable actions.
+        if not relative or relative.startswith(("#", "{", "[")) or " #" in relative:
+            continue
         path = PLATFORMS / platform / relative
         if not path.is_file():
             raise FileNotFoundError(f"declared platform action missing: {platform}/{name} -> {relative}")
@@ -146,6 +151,7 @@ def run_platform_action(
     config_path: str | None = None,
     url: str | None = None,
     session_id: str | None = None,
+    auto_session: bool = False,
 ) -> dict:
     path = action_path(platform, action)
     config_file = Path(config_path) if config_path else None
@@ -156,7 +162,16 @@ def run_platform_action(
         validate_platform_config(platform, action, config)
     code = prepare_action(path, config_file)
 
-    owned_session = not bool(session_id)
+    if not session_id and not auto_session:
+        raise ValueError(
+            "platform run requires session_id; orchestrators should use: "
+            "session start -> platform run --session-id SESSION_ID -> self-heal in the same session -> session stop. "
+            "Use auto_session=True only for a one-shot run without orchestrator self-heal."
+        )
+    if session_id and auto_session:
+        raise ValueError("session_id and auto_session are mutually exclusive")
+
+    owned_session = bool(auto_session)
     started = request({"op": "start", "workspace": None, "url": url}) if owned_session else {"session_id": session_id, "workspace_supported": None}
     sid = started["session_id"]
     result = None
@@ -168,6 +183,8 @@ def run_platform_action(
             "platform": platform,
             "action": action,
             "workspace_supported": started.get("workspace_supported"),
+            "session_mode": "auto_session_no_self_heal" if owned_session else "caller_owned_self_heal_capable",
+            "self_heal_capable": not owned_session,
             "result": result,
         }
         if started.get("warning"):

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

@@ -6,7 +6,7 @@ import re
 from typing import Any, Optional
 from urllib.parse import parse_qs, urlparse
 
-MANAGER_URL = "https://channels.weixin.qq.com/platform/post"
+MANAGER_URL = "https://channels.weixin.qq.com/platform/post/list"
 
 STATUS_LABELS: tuple[tuple[str, str], ...] = (
     ("审核中", "reviewing"),

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

@@ -30,13 +30,6 @@ def open_or_reuse_wechat(url):
 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()
@@ -87,17 +80,23 @@ else:
 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":
+    upload_state = js(SB + '.innerText ? (function(text){ var match=text.match(/(?:^|\\n)(\\d{1,3})%(?:\\n|$)/); var percent=match?parseInt(match[1],10):null; var uploading=text.indexOf(\"取消上传\")>=0; return JSON.stringify({percent:percent,uploading:uploading}); })(' + SB + '.innerText) : JSON.stringify({percent:null,uploading:false})')
+    try:
+        state = json.loads(upload_state or "{}")
+    except Exception:
+        state = {}
+    # Do not infer completion from editor/preview presence or Publish enabled state:
+    # those can appear while the video is still uploading.
+    if state.get("percent") is None and not state.get("uploading"):
         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)")
+    if attempt % 3 == 2:
+        pct = state.get("percent")
+        print("  -> Uploading... " + ((str(pct) + "%") if pct is not None else "processing") + " (" + str((attempt+1)*5) + "s)")
 else:
-    print("WARNING: Upload timeout.")
+    print("ERROR: Upload did not reach a completed state before timeout.")
     capture_screenshot()
+    raise SystemExit(1)
 time.sleep(2)
 
 print("[3/6] Setting description...")
@@ -115,13 +114,12 @@ 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)
+    print("  -> WARNING: Description may not have been set; retrying through the semantic editor element...")
+    retry_desc = json.dumps(CFG["desc"])
+    js(SB + '.querySelector(".input-editor")?.focus()')
+    js(SB + '.querySelector(".input-editor").textContent = ' + retry_desc)
+    js(SB + '.querySelector(".input-editor").dispatchEvent(new Event("input", {bubbles:true}))')
+    time.sleep(0.5)
 
 if CFG["title"]:
     print("[4/6] Setting short title: " + CFG["title"])
@@ -135,28 +133,30 @@ 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
+def click_btn_by_text(text):
+    # Semantic DOM click only. Never derive or use viewport/screen coordinates.
+    text_s = json.dumps(text)
+    return js(
+        '(function(){ var body=' + SB + '; var target=null; '
+        'body.querySelectorAll(".weui-desktop-btn").forEach(function(btn){ '
+        'var style=getComputedStyle(btn); '
+        'if(btn.textContent.trim()===' + text_s + ' && '
+        '!btn.disabled && !btn.classList.contains("weui-desktop-btn_disabled") && '
+        'style.display!=="none" && style.visibility!=="hidden"){ target=btn; } }); '
+        'if(!target) return false; target.click(); return true; })()'
+    )
+
 
 if CFG["publish"]:
     print("[6/6] Publishing...")
-    c = find_btn_by_text("\u53d1\u8868")  # 发表
-    if c:
-        click_at_xy(c["x"], c["y"])
+    clicked = click_btn_by_text("发表")
+    if clicked:
         time.sleep(3)
-        # Handle confirmation dialog
+        # Handle confirmation dialog semantically as well.
         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...")
@@ -167,9 +167,8 @@ if CFG["publish"]:
         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"])
+    clicked = click_btn_by_text("保存草稿")
+    if clicked:
         time.sleep(3)
         print("  -> Draft action submitted; verifying manager state...")
         action = "draft"

package/platforms/wechat-channels/manifest.yaml

@@ -1,14 +1,15 @@
 platform: wechat-channels
-status: migrated_unverified
-last_verified: null
+status: partially_verified
+last_verified: '2026-10-04'
 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.
+  status: partially_verified
+  last_verified: '2026-10-04'
+  evidence: Live publish succeeded with creator confirmation 已发表 and manager list
+    count increasing to 4. Exact title/description manager-row matching remains unverified
+    because list rows do not expose those fields in visible text.
 url_patterns:
 - https://channels.weixin.qq.com/*
 authentication:
@@ -19,17 +20,18 @@ provenance:
   migrated_code: true
 flows:
   post:
-    status: migrated_unverified
-    evidence: Migrated action; current Browser Workspace live verification pending.
+    status: verified
+    evidence: Live publish succeeded on 2026-10-04; creator UI showed 已发表 and manager
+      list gained a new 10:33 row.
   manage:
-    status: migrated_unverified
-    evidence: Migrated manager action; current Browser Workspace live verification
-      pending.
+    status: partially_verified
+    evidence: Live manager list at /platform/post/list loaded and exposed video count/timestamps;
+      exact title/description row matching is not yet verified.
 display_name: WeChat Channels
 aliases:
 - wechat
 - channels
-implementation_status: code_only_live_ui_unverified
+implementation_status: live_publish_verified_manager_matching_partial
 media:
   modes:
   - video
@@ -49,12 +51,14 @@ fields:
     implemented: true
   title:
     cli: --title
-    required: false
+    required: true
     type: string
     min_chars: 6
     max_chars: 16
     implemented: true
     meaning: short title
+    note: Live creator UI on 2026-10-04 kept Publish disabled until a valid short
+      title was provided.
   tags:
     cli: --tags
     required: false
@@ -116,3 +120,5 @@ notes:
   state before any deliberate retry.
 - Update/edit, comment reading, comments, and replies are intentionally unimplemented
   until their exact creator UI is observed.
+- Live creator UI requires a valid short title before Publish becomes enabled; treat
+  title as required for post actions.

package/platforms/xhs/actions/_post.py

@@ -26,6 +26,8 @@ def open_or_reuse_xhs(url):
 images = CFG.get("images", [CFG.get("image", "")])
 video = CFG.get("video", "")
 tags = CFG.get("tags", [])
+collection = (CFG.get("collection") or "").strip()
+collection_description = (CFG.get("collection_description") or "").strip()
 
 # Calculate steps dynamically
 base_steps = 6  # navigate, tab, upload, title, body, action
@@ -82,20 +84,21 @@ if mode == "video":
             raise SystemExit(1)
 
     next_step("Waiting for video upload...")
-    for attempt in range(120):
-        time.sleep(5)
-        # Check if upload is complete by looking for video preview or progress
-        done = js('document.querySelector("[class*=video-player],[class*=videoPreview],video,.upload-success,[class*=uploadDone]") ? "ready" : "wait"')
-        if done == "ready":
-            print("  -> Upload done!")
+    for attempt in range(180):
+        time.sleep(1)
+        # A preview/video element appears immediately, even while XHS still says
+        # "上传中 0%". Treat the editor's completed state as authoritative.
+        upload_state = js('(function(){var t=document.body.innerText||""; if(/上传中\\s*\\d*%?/.test(t)||t.indexOf("取消上传")>=0)return "uploading"; if(t.indexOf("重新上传")>=0||t.indexOf("检测为高清视频")>=0)return "ready"; return "waiting"})()')
+        if upload_state == "ready":
+            print("  -> Upload processed and editor-ready!")
             break
-        if attempt % 6 == 5:
+        if attempt % 15 == 14:
             pct = js('var el=document.querySelector("[class*=progress],.percent,[class*=uploadProgress]"); el ? el.textContent : "..."')
-            print(f"  -> Uploading... {pct} ({(attempt+1)*5}s)")
+            print(f"  -> Upload state {upload_state}; {pct} ({attempt+1}s)")
     else:
-        print("WARNING: Upload may still be processing.")
+        print("ERROR: video upload never reached the editor-ready state")
         capture_screenshot()
-    time.sleep(2)
+        raise SystemExit(1)
 
 else:
     # Image mode — click the 2nd tab (上传图文)
@@ -153,32 +156,118 @@ time.sleep(0.5)
 if tags:
     next_step(f"Tags appended: {', '.join(tags)}")
 
+def choose_collection(name, description):
+    if not name:
+        return None
+    opened = js('var es=Array.from(document.querySelectorAll("*")).filter(function(e){var t=(e.innerText||e.textContent||"").trim(); return e.offsetParent && e.children.length===0 && t==="选择合集"}); if(es.length){es[0].click();"yes"}else{"no"}')
+    if opened != "yes":
+        raise RuntimeError("collection chooser not found")
+    time.sleep(.5)
+    selected = js('var es=Array.from(document.querySelectorAll("*")).filter(function(e){return e.offsetParent && e.children.length===0 && (e.innerText||e.textContent||"").trim()===' + json.dumps(name) + '}); if(es.length){es[0].click();"yes"}else{"no"}')
+    if selected == "yes":
+        time.sleep(.5)
+        return "selected"
+    create = js('var es=Array.from(document.querySelectorAll("button,*")).filter(function(e){return e.offsetParent && e.children.length===0 && (e.innerText||e.textContent||"").trim()==="创建合集"}); if(es.length){es[0].click();"yes"}else{"no"}')
+    if create != "yes":
+        raise RuntimeError("collection not found and create control missing")
+    time.sleep(.5)
+    fill_input('input[placeholder="好的合集名称能吸引更多用户"]', name, clear_first=True, timeout=20)
+    if description:
+        fill_input('input[placeholder="简单介绍你的合集"],textarea[placeholder="简单介绍你的合集"]', description, clear_first=True, timeout=20)
+    created = js('var b=Array.from(document.querySelectorAll("button")).find(function(e){return e.offsetParent && (e.innerText||e.textContent||"").trim()==="创建并加入"}); if(b&&!b.disabled){b.click();"yes"}else{"no"}')
+    if created != "yes":
+        raise RuntimeError("create-and-join collection control unavailable")
+    for _ in range(20):
+        time.sleep(.5)
+        visible = js('(document.body.innerText||"").indexOf(' + json.dumps(name) + ')>=0 && (document.body.innerText||"").indexOf("创建并加入")<0 ? "yes" : "no"')
+        if visible == "yes":
+            return "created"
+    raise RuntimeError("collection creation was not verified")
+
+if collection:
+    next_step("Joining collection: " + collection)
+    print("  -> Collection " + choose_collection(collection, collection_description))
+
+def creator_manager_receipt(title):
+    goto_url("https://creator.xiaohongshu.com/new/note-manager")
+    try:
+        wait_for_load()
+    except Exception:
+        pass
+    rows = []
+    for _ in range(30):
+        time.sleep(.5)
+        raw = js('Array.from(document.querySelectorAll(".note-card")).map(function(c){var t=c.querySelector(".note-card__title"); return JSON.stringify({title:t?(t.innerText||t.textContent||"").trim():"", text:(c.innerText||"").trim(), impression:c.dataset.impression||""})}).join("\\n")') or ""
+        rows = []
+        for line in raw.splitlines():
+            try:
+                row = json.loads(line)
+                imp = json.loads(row.get("impression") or "{}")
+                row["note_id"] = (((imp.get("noteTarget") or {}).get("value") or {}).get("noteId"))
+                if row.get("title") == title:
+                    rows.append(row)
+            except Exception:
+                pass
+        if rows:
+            break
+    if not rows:
+        return None
+    newest = rows[0]
+    text = newest.get("text") or ""
+    status = "reviewing" if "审核中" in text else "rejected" if "未通过" in text else "published"
+    return {"note_id": newest.get("note_id"), "title": title, "status": status, "duplicate_count": len(rows), "card_text": text}
+
 if CFG["action"] == "publish":
     next_step("Publishing...")
-    publish_result = js('var btn=[...document.querySelectorAll("button,[role=button]")].find(function(b){return b.offsetParent && (b.innerText||b.textContent||"").trim()==="发布"}) || document.querySelector(".publishBtn,.publish-btn,button.css-k01wfk,[class*=submit]");if(btn){btn.scrollIntoView({block:"center"});btn.click();"clicked"}else{"missing"}')
+    # XHS can render the publish button before video processing is complete. A
+    # programmatic click on a disabled button is a no-op, so wait for the real
+    # control to become enabled before clicking it.
+    publish_result = "missing"
+    for attempt in range(180):
+        publish_result = js('var btn=[...document.querySelectorAll("button,[role=button]")].find(function(b){return b.offsetParent && (b.innerText||b.textContent||"").trim()==="发布"}) || document.querySelector(".publishBtn,.publish-btn,button.css-k01wfk,[class*=submit]");if(!btn){"missing"}else if(btn.disabled || btn.getAttribute("aria-disabled")==="true" || btn.classList.contains("disabled")){"disabled"}else{btn.scrollIntoView({block:"center"});btn.click();"clicked"}')
+        if publish_result == "clicked":
+            break
+        if attempt % 15 == 14:
+            print(f"  -> Publish control {publish_result}; waiting for processing... ({attempt+1}s)")
+        time.sleep(1)
     if publish_result != "clicked":
         # XHS may expose the publish control only through the accessibility tree.
         nodes = cdp("Accessibility.getFullAXTree")["nodes"]
         target = next((n for n in nodes if (n.get("role") or {}).get("value") == "button" and (n.get("name") or {}).get("value") == "发布" and n.get("backendDOMNodeId")), None)
         if target:
-            box = cdp("DOM.getBoxModel", backendNodeId=target["backendDOMNodeId"])["model"]["content"]
-            x = sum(box[0::2]) / 4
-            y = sum(box[1::2]) / 4
-            click_at_xy(x, y)
-            publish_result = "clicked"
-        else:
+            resolved = cdp("DOM.resolveNode", backendNodeId=target["backendDOMNodeId"])["object"]
+            object_id = resolved.get("objectId")
+            if object_id:
+                cdp(
+                    "Runtime.callFunctionOn",
+                    objectId=object_id,
+                    functionDeclaration="function(){ this.click(); return true; }",
+                    returnByValue=True,
+                )
+                publish_result = "clicked"
+        if publish_result != "clicked":
             print("ERROR: publish button not found")
             capture_screenshot()
             raise SystemExit(1)
-    verified = False
+    redirect_verified = False
     for _ in range(20):
         time.sleep(1)
         state = js('location.href.indexOf("publish/success")>=0 || /发布成功|成功发布/.test(document.body.innerText||"") ? "success" : "wait"')
         if state == "success":
-            verified = True
+            redirect_verified = True
             break
+    receipt = creator_manager_receipt(CFG["title"])
+    if not receipt or not receipt.get("note_id"):
+        print("ERROR: publish was not verified in creator manager")
+        capture_screenshot()
+        raise SystemExit(2)
+    receipt["redirect_verified"] = redirect_verified
+    receipt["collection"] = collection or None
+    print("XHS_RECEIPT " + json.dumps(receipt, ensure_ascii=False, separators=(",", ":")))
+    verified = receipt["status"] in {"published", "reviewing"}
     if not verified:
-        print("WARNING: publish click completed but success state is not yet verified")
+        print("ERROR: creator manager reports " + receipt["status"])
+        raise SystemExit(2)
 else:
     next_step("Saving as draft...")
     # Find 暂存 button by unicode

package/platforms/xhs/manifest.yaml

@@ -2,8 +2,8 @@ platform: xhs
 status: migrated_unverified
 last_verified: null
 actions:
-  post: actions/_post.py
-  manage: actions/_manage.py
+  post: "actions/_post.py"
+  manage: "actions/_manage.py"
 verification:
   status: migrated_unverified
   last_verified: null
@@ -72,12 +72,22 @@ fields:
     type: boolean
     default: false
     implemented: true
+  collection:
+    required: false
+    type: string
+    max_chars: 20
+    implemented: true
+  collection_description:
+    required: false
+    type: string
+    max_chars: 50
+    implemented: true
 capabilities:
   draft: true
   publish: true
   visibility: false
   custom_thumbnail: false
-  series_or_collection: false
+  series_or_collection: true
   post_status: true
   read_comments: true
   write_comment: true
@@ -94,5 +104,4 @@ notes:
   and use that card's live xsec detail route.
 - The opened post detail view is the canonical place to read comments, write a top-level
   comment, and reply to comments.
-- The current adapter does not expose the Neo Vlog collection/series field even though
-  a prior manual browser-harness session created and attached a collection.
+- Optional `collection` selects an existing exact-name collection or creates and joins it when absent.

package/platforms/xhs/tests/test_contract.py

@@ -15,3 +15,20 @@ def test_actions_use_current_tab_url_for_navigation_identity():
     manage = (HERE / "actions" / "_manage.py").read_text()
     assert '(current_tab().get("url") or "") != url' in post
     assert '(current_tab().get("url") or "") != url' in manage
+
+
+def test_video_readiness_uses_editor_state_not_preview():
+    source=(HERE/'actions'/'_post.py').read_text()
+    assert '上传中' in source
+    assert '重新上传' in source
+    assert 'Upload processed and editor-ready!' in source
+
+def test_collection_and_receipt_contracts_are_present():
+    source=(HERE/'actions'/'_post.py').read_text()
+    manifest=(HERE/'manifest.yaml').read_text()
+    assert 'choose_collection' in source
+    assert 'creator_manager_receipt' in source
+    assert 'XHS_RECEIPT' in source
+    assert 'duplicate_count' in source
+    assert 'series_or_collection: true' in manifest
+    assert 'collection:' in manifest

package/platforms/youtube/actions/_post.py

@@ -12,11 +12,14 @@ def next_step(label):
     print(f"[{step[0]}/{total_steps}] {label}")
 
 def click_btn(text):
+    text_s = json.dumps(text)
     for _ in range(5):
-        r = js('var btns=document.querySelectorAll("ytcp-button");var b=Array.from(btns).find(function(x){return x.textContent.trim()==="' + text + '"});b?JSON.stringify(b.getBoundingClientRect()):null')
-        if r and r != "None":
-            rect = json.loads(r)
-            click_at_xy(int(rect["x"]+rect["width"]/2), int(rect["y"]+rect["height"]/2))
+        clicked = js(
+            '(function(){ var btns=document.querySelectorAll("ytcp-button"); '
+            'var b=Array.from(btns).find(function(el){return el.textContent.trim()===' + text_s + ' && !el.disabled;}); '
+            'if(!b)return false; b.click(); return true; })()'
+        )
+        if clicked:
             return True
         time.sleep(1)
     return False

package/session_client.py

@@ -78,20 +78,30 @@ def ping():
     try: return request({'op':'ping'},ensure=False)
     except Exception: return None
 
+def owner_is_running():
+    """An exclusive owner lock means a live daemon already exists."""
+    owner_path=RUNTIME_DIR/'session.lock'
+    with open(owner_path,'a+b') as owner:
+        try:
+            fcntl.flock(owner,fcntl.LOCK_EX|fcntl.LOCK_NB)
+        except BlockingIOError:
+            return True
+        finally:
+            try: fcntl.flock(owner,fcntl.LOCK_UN)
+            except OSError: pass
+    return False
+
 def ensure_daemon():
     p=ping()
     if p and p.get('ok'): return p
     RUNTIME_DIR.mkdir(parents=True,exist_ok=True)
-    lock_path=RUNTIME_DIR/'session-daemon.lock'
-    with open(lock_path,'a+b') as lock:
-        fcntl.flock(lock,fcntl.LOCK_EX)
-        p=ping()
+    if owner_is_running():
+        raise RuntimeError('browser-workspace daemon is alive but its socket is unreachable; refusing duplicate startup')
+    runtime_python=ensure_runtime_python()
+    log=open(RUNTIME_DIR/'session-daemon.log','ab',buffering=0)
+    subprocess.Popen([str(runtime_python),str(SOURCE/'session_daemon.py')],stdin=subprocess.DEVNULL,stdout=log,stderr=log,start_new_session=True,close_fds=True)
+    deadline=time.time()+15
+    while time.time()<deadline:
+        time.sleep(.1); p=ping()
         if p and p.get('ok'): return p
-        runtime_python=ensure_runtime_python()
-        log=open(RUNTIME_DIR/'session-daemon.log','ab',buffering=0)
-        subprocess.Popen([str(runtime_python),str(SOURCE/'session_daemon.py')],stdin=subprocess.DEVNULL,stdout=log,stderr=log,start_new_session=True,close_fds=True)
-        deadline=time.time()+15
-        while time.time()<deadline:
-            time.sleep(.1); p=ping()
-            if p and p.get('ok'): return p
     raise RuntimeError(f'browser-workspace session daemon did not start; see {RUNTIME_DIR / "session-daemon.log"}')

package/session_daemon.py

@@ -21,7 +21,7 @@ from browser_harness import helpers as bh
 DEFAULT_WORKSPACE = os.environ.get('BH_WORKSPACE_NAME','Harness')
 RUNTIME_DIR = Path.home()/'.config/browser-workspace/runtime'
 SOCKET_PATH = (Path(os.environ['BROWSER_WORKSPACE_SESSION_SOCKET']) if os.environ.get('BROWSER_WORKSPACE_TEST_MODE')=='1' and os.environ.get('BROWSER_WORKSPACE_SESSION_SOCKET') else RUNTIME_DIR/'session.sock')
-OWNER_LOCK_PATH = RUNTIME_DIR/'session-daemon.owner.lock'
+OWNER_LOCK_PATH = RUNTIME_DIR/'session.lock'
 SESSIONS = {}
 SESSIONS_LOCK = threading.Lock()
 BROWSER_LOCK = threading.RLock()
@@ -84,10 +84,13 @@ class Session:
         return result
 
     def _cdp(self, method, **kwargs):
+        if method == 'Target.createTarget':
+            raise RuntimeError(
+                'Target.createTarget is disabled in Browser Workspace sessions; '
+                'use new_tab(url) so the tab is owned by the active session/workspace'
+            )
         result=bh.cdp(method, **kwargs)
-        if method == 'Target.createTarget' and isinstance(result, dict):
-            self._remember_target(result.get('targetId'))
-        elif method == 'Target.closeTarget':
+        if method == 'Target.closeTarget':
             self.owned_target_ids.discard(kwargs.get('targetId'))
         return result
 
@@ -253,12 +256,25 @@ def stop_session(sid):
         if errors: release_error='; '.join(errors)
     return {'session_id':sid,'workspace':s.workspace,'target_id':s.target_id,'closed_tabs':closed_count,'release_error':release_error}
 
+SOCKET_IDENTITY = None
+
+def remove_owned_socket():
+    """Never unlink a socket replaced by another owner."""
+    if SOCKET_IDENTITY is None:
+        return
+    try:
+        st = SOCKET_PATH.lstat()
+        if (st.st_dev, st.st_ino) == SOCKET_IDENTITY:
+            SOCKET_PATH.unlink()
+    except FileNotFoundError:
+        pass
+
 def cleanup():
     with SESSIONS_LOCK: ids=list(SESSIONS)
     for sid in ids:
         try: stop_session(sid)
         except Exception: pass
-    try: SOCKET_PATH.unlink(missing_ok=True)
+    try: remove_owned_socket()
     except Exception: pass
 atexit.register(cleanup)
 
@@ -306,6 +322,7 @@ def serve_conn(conn):
         f.write((json.dumps(result,ensure_ascii=False)+'\n').encode()); f.flush()
 
 def main():
+    global SOCKET_IDENTITY
     RUNTIME_DIR.mkdir(parents=True,exist_ok=True)
     try: os.chmod(RUNTIME_DIR,0o700)
     except Exception: pass
@@ -315,8 +332,9 @@ def main():
         fcntl.flock(owner,fcntl.LOCK_EX|fcntl.LOCK_NB)
     except BlockingIOError:
         owner.close(); return
+    # Lock ownership is required before changing the shared socket path.
     SOCKET_PATH.unlink(missing_ok=True)
-    srv=socket.socket(socket.AF_UNIX,socket.SOCK_STREAM); srv.bind(str(SOCKET_PATH)); os.chmod(SOCKET_PATH,0o600); srv.listen(32)
+    srv=socket.socket(socket.AF_UNIX,socket.SOCK_STREAM); srv.bind(str(SOCKET_PATH)); os.chmod(SOCKET_PATH,0o600); SOCKET_IDENTITY=(SOCKET_PATH.stat().st_dev, SOCKET_PATH.stat().st_ino); srv.listen(32)
     try:
         while True:
             conn,_=srv.accept(); threading.Thread(target=serve_conn,args=(conn,),daemon=True).start()