feat(browser-act): seed channel manifests for 2 packs + interpreter integration tests (PR-D)

Author channel.manifest.json for two real vendored packs (our files, not
upstream bytes), proving the PR-C interpreter drives real packs:
- search-research/google-search-serp: login-free, single-page (mode "none"),
  emits one SERP dict, success required_field "organicResults".
- ecommerce/taobao-keyword-search: url_page pagination (page number),
  stop_when "result_count < 10", product list, required_field "itemId".

Manifest field/arg shapes verified against the real scripts (serp-extract.py
takes no args -> organicResults dict; search-products.py positional keyword +
--page/--sort -> itemId list).

tests/integration/test_browser_act_seeds.py (8 tests): both manifests
load+validate, google happy path, taobao pagination stop_when (12+5=17 over 2
pages), min_count-not-met failure, needs_human on captcha. Real pack scripts
run; only the browser-act eval hop is mocked.

VENDOR.md: Seed-manifests section (prose->manifest translation + limits:
no URL-encoding of params, google seeded single-page since start=(page-1)*num
offset isn't computable from {page} context yet, ~76 packs still manifest-less,
api-skill packs use a different exec shape this interpreter doesn't model).

Interpreter unchanged (purely additive). 1484 -> 1492 passed, zero regression.

Author: 2233admin

backend/browser_act_packs/VENDOR.md

@@ -59,3 +59,112 @@ To pull upstream updates:
    directories verbatim (do not touch our `channel.manifest.json` files when
    they exist — those are ours, not upstream's).
 3. Update the commit hash and date at the top of this file.
+
+## Seed manifests (PR-D)
+
+Two of the 78 vendored packs got a hand-authored `channel.manifest.json`
+(GOAL-7 decision #5), chosen as the pair that can be validated end-to-end
+without a logged-in session: `search-research/google-search-serp` (a
+login-free public search) and `ecommerce/taobao-keyword-search` (a
+login-free public listing search page). Both translations below were
+checked against the pack's real `scripts/*.py` before being written (field
+names / arg shapes match what the script actually emits/accepts).
+
+### `search-research/google-search-serp`
+
+SKILL.md prose → manifest:
+
+- **navigate**: SKILL.md's `navigate https://www.google.com/search?q=...`
+  → `steps[0] = {"op": "navigate", "url_template":
+  "https://www.google.com/search?q={query}&num={num}&hl={lang}&gl={country}"}`.
+  `query`/`num`/`lang`/`country` map straight onto the four querystring
+  params the script's JS itself reads back out of `window.location.search`
+  (`q`, `num`, `hl`, `gl`) — `num`/`lang`/`country` default to `"10"`/`""`/`""`
+  so a bare `{"query": "..."}` config still works.
+- **wait**: SKILL.md's `wait stable` → `steps[1] = {"op": "wait",
+  "wait_mode": "stable"}`.
+- **eval_script**: SKILL.md's `eval "$(python scripts/serp-extract.py)"` →
+  `steps[2] = {"op": "eval_script", "script": "scripts/serp-extract.py",
+  "args": []}`. Confirmed against the real script: `serp-extract.py` takes
+  **no argparse arguments at all** (it emits a fixed JS snippet that reads
+  everything it needs, including `q`/`num`/`hl`/`gl`, straight from
+  `window.location.search` at eval time) — so `args: []` is correct, not an
+  oversight.
+- **pagination**: `{"mode": "none"}` — single page only (see Known
+  limitation #2 below).
+- **success**: `{"min_count": 1, "required_field": "organicResults"}`. The
+  script's JS always returns one JSON **object** (the whole SERP), never a
+  list, so `collect()` wraps it as a single item; `required_field` checks
+  that item has a (truthy) `organicResults` key. Confirmed against the real
+  script: the emitted JS's success-path return value is `{searchQuery,
+  resultsTotal, organicResults, paidResults, relatedQueries, peopleAlsoAsk,
+  aiOverview}` — `organicResults` is present verbatim.
+
+### `ecommerce/taobao-keyword-search`
+
+SKILL.md prose → manifest:
+
+- **navigate**: SKILL.md's `navigate https://s.taobao.com/search?q=...` →
+  `steps[0] = {"op": "navigate", "url_template":
+  "https://s.taobao.com/search?q={keyword}&page={page}&ie=utf8"}`. `{page}`
+  comes from the channel's own per-page loop context (decision #5's
+  `pagination`), not from `param_schema` — page 1 is implicit, page 2+ is
+  driven by `pagination.url_template` below.
+- **wait**: `steps[1] = {"op": "wait", "wait_mode": "stable"}`.
+- **eval_script**: SKILL.md's `eval "$(python scripts/search-products.py
+  {keyword} --page {page} --sort {sort})"` → `steps[2] = {"op":
+  "eval_script", "script": "scripts/search-products.py", "args":
+  ["{keyword}", "--page", "{page}", "--sort", "{sort}"]}`. Confirmed against
+  the real script: `search-products.py`'s argparse takes a **positional**
+  `keyword` (documentation-only per its own comment — the URL already
+  carries `q=`) plus `--page` (default `"1"`) and `--sort` (default `""`,
+  values `""`/`"sale-desc"`/`"price-asc"`/`"price-desc"`) among other
+  optional flags (`--tab`, `--start-price`, `--end-price`) this seed
+  manifest does not yet expose — arg names/order match exactly.
+- **pagination**: `{"mode": "url_page", "url_template":
+  "https://s.taobao.com/search?q={keyword}&page={page}&ie=utf8",
+  "page_param": "page", "stop_when": "result_count < 10"}` — matches
+  SKILL.md's documented "stop when a page returns fewer than 10 results"
+  pagination note; the interpreter's `_stop_when_triggered` regex
+  (`backend/channels/browser_act_channel.py`) parses `"result_count < N"`
+  directly.
+- **success**: `{"min_count": 1, "required_field": "itemId"}`. Confirmed
+  against the real script: the emitted JS's success path returns a JSON
+  **list** of product dicts, each shaped `{itemId, itemUrl, title,
+  subTitle, priceYuan, priceDesc, imageUrl, salesCount, shopName, location,
+  rating, tags}` — `itemId` is present verbatim on every item.
+
+### Known limitations
+
+1. **No URL-encoding of params into `url_template`.** The interpreter
+   (`_run_page` in `backend/channels/browser_act_channel.py`) does
+   `url_template.format(**ctx)` — a plain string substitution, not a
+   URL-encoding one. This is fine for simple ASCII keywords/queries, but
+   SKILL.md's own prose notes that `q` should be URL-encoded (spaces,
+   non-ASCII, `&`/`#`/`?` in the search term would corrupt the querystring
+   otherwise). A real-world caller must pre-encode `query`/`keyword` before
+   passing them in `params`, or a future interpreter enhancement should
+   URL-encode template substitutions itself — out of scope for this PR.
+2. **`google-search-serp` is seeded single-page (`pagination.mode:
+   "none"`).** Its real pagination is a `start=(page-1)*num` offset
+   querystring param (see the script's own `start`/`num` parsing), which
+   this interpreter's `{page}` context (a bare 1-based page counter, not an
+   offset) can't compute without a per-pack formula the generic manifest
+   schema doesn't currently express. Multi-page google is a future
+   enhancement (e.g. a `pagination.mode` that lets a manifest declare an
+   offset formula), not something this seed pretends to support.
+3. **The other ~76 vendored packs have no `channel.manifest.json` yet.**
+   Seeding is intentionally incremental (GOAL-7 PR-D scope: 2 packs to prove
+   the pipeline, not full coverage) — `backend/browser_act_packs/manifest.py`
+   (`PackManifest`) is the extension point; add a `channel.manifest.json`
+   next to a pack's `SKILL.md` as each one is needed, translating its prose
+   the same way as above. In particular, the `*-api-skill` packs (e.g.
+   `search-research/web-search-scraper-api-skill`, confirmed by reading its
+   script: it `requests.post`s straight to `https://api.browseract.com/v2/
+   workflow` with a Bearer API key) use a **different** execution shape
+   entirely — their scripts call the BrowserAct **API** directly (HTTP, no
+   browser session at all) instead of navigate→wait→eval against a live
+   browser-act session, so this channel's navigate/wait/eval_script
+   interpreter does not — and structurally cannot — model them; they would
+   need either a distinct `step.op` (e.g. `"api_call"`) or a separate
+   channel entirely, a decision deferred rather than made silently here.

backend/browser_act_packs/ecommerce/taobao-keyword-search/channel.manifest.json

@@ -0,0 +1,15 @@
+{
+  "domain": "ecommerce",
+  "capability": "taobao-keyword-search",
+  "param_schema": [
+    {"name": "keyword", "required": true},
+    {"name": "sort", "required": false, "default": ""}
+  ],
+  "steps": [
+    {"op": "navigate", "url_template": "https://s.taobao.com/search?q={keyword}&page={page}&ie=utf8"},
+    {"op": "wait", "wait_mode": "stable"},
+    {"op": "eval_script", "script": "scripts/search-products.py", "args": ["{keyword}", "--page", "{page}", "--sort", "{sort}"]}
+  ],
+  "pagination": {"mode": "url_page", "url_template": "https://s.taobao.com/search?q={keyword}&page={page}&ie=utf8", "page_param": "page", "stop_when": "result_count < 10"},
+  "success": {"min_count": 1, "required_field": "itemId"}
+}

backend/browser_act_packs/search-research/google-search-serp/channel.manifest.json

@@ -0,0 +1,17 @@
+{
+  "domain": "search-research",
+  "capability": "google-search-serp",
+  "param_schema": [
+    {"name": "query", "required": true},
+    {"name": "num", "required": false, "default": "10"},
+    {"name": "lang", "required": false, "default": ""},
+    {"name": "country", "required": false, "default": ""}
+  ],
+  "steps": [
+    {"op": "navigate", "url_template": "https://www.google.com/search?q={query}&num={num}&hl={lang}&gl={country}"},
+    {"op": "wait", "wait_mode": "stable"},
+    {"op": "eval_script", "script": "scripts/serp-extract.py", "args": []}
+  ],
+  "pagination": {"mode": "none"},
+  "success": {"min_count": 1, "required_field": "organicResults"}
+}

tests/integration/test_browser_act_seeds.py

@@ -0,0 +1,192 @@
+"""Integration tests for GOAL-7 PR-D seed manifests.
+
+Exercises the two hand-authored ``channel.manifest.json`` seeds
+(``search-research/google-search-serp``, ``ecommerce/taobao-keyword-search``)
+against the REAL vendored pack tree (``PackCatalog()`` at its default root --
+no synthetic ``tmp_path`` pack like PR-C's unit tests use) and the REAL pack
+scripts (``scripts/serp-extract.py``, ``scripts/search-products.py`` run for
+real via ``run_pack_script``, PR-C's second subprocess hop). Only the
+browser-act eval hop -- the one that would need an actual browser/DOM -- is
+mocked, at the same seam PR-C's ``tests/unit/channels/
+test_browser_act_channel.py`` patches: ``backend.browser_act.cli._run``. This
+proves the two manifests authored in this PR are wired correctly against the
+real vendored files, not a stand-in.
+"""
+
+import json
+
+import pytest
+from unittest.mock import patch
+
+from backend.browser_act.cli import BrowserActResult
+from backend.browser_act_packs.catalog import PackCatalog
+from backend.browser_act_packs.manifest import PackManifest, load_manifest
+from backend.channels.browser_act_channel import BrowserActChannel
+
+GOOGLE_PACK = "search-research/google-search-serp"
+TAOBAO_PACK = "ecommerce/taobao-keyword-search"
+
+
+def _run_side_effect(eval_responses: list[str]):
+    """Same seam/shape as PR-C's test_browser_act_channel.py helper: answer
+    "eval" subcommands from eval_responses in order (repeating the last one
+    once exhausted), no-op every other subcommand (navigate/wait/click/input).
+    """
+    responses = list(eval_responses)
+    state = {"i": 0}
+
+    async def _side_effect(args, *, timeout=None, env=None):
+        subcommand = args[2] if len(args) > 2 else None
+        if subcommand == "eval":
+            i = min(state["i"], len(responses) - 1)
+            state["i"] += 1
+            return BrowserActResult(returncode=0, stdout=responses[i], stderr="")
+        return BrowserActResult(returncode=0, stdout="", stderr="")
+
+    return _side_effect
+
+
+@pytest.fixture
+def channel():
+    # Real vendored-packs root (no tmp_path override) -- these tests exercise
+    # the actual PR-D manifests + actual PR-A/scripts.py files on disk.
+    return BrowserActChannel(catalog=PackCatalog())
+
+
+# ── (a) both seed manifests load + validate ──────────────────────────────
+
+
+def test_google_seed_manifest_loads_and_validates():
+    manifest_path = (
+        PackCatalog().root
+        / "search-research"
+        / "google-search-serp"
+        / "channel.manifest.json"
+    )
+    manifest = load_manifest(manifest_path)
+    assert isinstance(manifest, PackManifest)
+    assert manifest.domain == "search-research"
+    assert manifest.capability == "google-search-serp"
+
+
+def test_taobao_seed_manifest_loads_and_validates():
+    manifest_path = (
+        PackCatalog().root
+        / "ecommerce"
+        / "taobao-keyword-search"
+        / "channel.manifest.json"
+    )
+    manifest = load_manifest(manifest_path)
+    assert isinstance(manifest, PackManifest)
+    assert manifest.domain == "ecommerce"
+    assert manifest.capability == "taobao-keyword-search"
+
+
+@pytest.mark.asyncio
+async def test_google_seed_validate_config_valid(channel):
+    errors = await channel.validate_config({"pack": GOOGLE_PACK, "params": {"query": "x"}})
+    assert errors == []
+
+
+@pytest.mark.asyncio
+async def test_taobao_seed_validate_config_valid(channel):
+    errors = await channel.validate_config(
+        {"pack": TAOBAO_PACK, "params": {"keyword": "x"}}
+    )
+    assert errors == []
+
+
+# ── (b) google seed happy path (single page, mode "none") ────────────────
+
+
+@pytest.mark.asyncio
+async def test_google_seed_happy_path_single_page(channel):
+    serp = {
+        "searchQuery": {"term": "machine learning"},
+        "organicResults": [
+            {"position": 1, "title": "A", "url": "http://a"},
+            {"position": 2, "title": "B", "url": "http://b"},
+        ],
+        "paidResults": [],
+        "relatedQueries": [],
+    }
+    with patch(
+        "backend.browser_act.cli._run",
+        side_effect=_run_side_effect([json.dumps(serp)]),
+    ):
+        result = await channel.collect(
+            {"pack": GOOGLE_PACK, "params": {"query": "machine learning"}}, {}
+        )
+
+    assert result.success is True
+    # The real serp-extract.py JS emits one dict (the whole SERP), so
+    # collect() wraps it as a single item -- not one item per organic result.
+    assert len(result.items) == 1
+    assert len(result.items[0]["organicResults"]) == 2
+    assert result.metadata["pages_fetched"] == 1
+
+
+# ── (c) taobao seed pagination + stop_when (multi page) ──────────────────
+
+
+@pytest.mark.asyncio
+async def test_taobao_seed_paginates_and_stops_on_stop_when(channel):
+    page1 = [{"itemId": str(n), "title": f"p{n}"} for n in range(12)]
+    page2 = [{"itemId": str(n), "title": f"p{n}"} for n in range(5)]
+
+    with patch(
+        "backend.browser_act.cli._run",
+        side_effect=_run_side_effect([json.dumps(page1), json.dumps(page2)]),
+    ) as mock_run:
+        result = await channel.collect(
+            {"pack": TAOBAO_PACK, "params": {"keyword": "耳机"}}, {}
+        )
+
+    eval_calls = [
+        call
+        for call in mock_run.call_args_list
+        if len(call.args[0]) > 2 and call.args[0][2] == "eval"
+    ]
+    # page1 has 12 items (>= 10) -> pagination continues; page2 has 5 items
+    # (< 10) -> "result_count < 10" stop_when fires after that page.
+    assert len(eval_calls) == 2
+    assert result.success is True
+    assert len(result.items) == 17
+    assert result.metadata["pages_fetched"] == 2
+
+
+# ── (d) success.min_count not met -> failure ──────────────────────────────
+
+
+@pytest.mark.asyncio
+async def test_taobao_seed_empty_page_fails_min_count(channel):
+    with patch(
+        "backend.browser_act.cli._run",
+        side_effect=_run_side_effect([json.dumps([])]),
+    ):
+        result = await channel.collect(
+            {"pack": TAOBAO_PACK, "params": {"keyword": "耳机"}}, {}
+        )
+
+    assert result.success is False
+    assert result.error_type == "error"
+    assert "min_count" in result.error
+
+
+# ── (e) needs_human still works with a real seed ──────────────────────────
+
+
+@pytest.mark.asyncio
+async def test_google_seed_needs_human_on_captcha(channel):
+    with patch(
+        "backend.browser_act.cli._run",
+        side_effect=_run_side_effect(
+            [json.dumps({"error": True, "message": "captcha required"})]
+        ),
+    ):
+        result = await channel.collect(
+            {"pack": GOOGLE_PACK, "params": {"query": "machine learning"}}, {}
+        )
+
+    assert result.success is False
+    assert result.error_type == "needs_human"