gflow-cli 0.18.0__tar.gz → 0.19.0__tar.gz

{gflow_cli-0.18.0 → gflow_cli-0.19.0}/.env.template

@@ -106,6 +106,15 @@
 # visible window). The session is still reused from the persistent profile.
 # GFLOW_CLI_HEADLESS=true
 
+# Browser automation engine — playwright (default) | patchright
+# patchright is an OPT-IN, drop-in patched Playwright (Chromium) that avoids the
+# Runtime.enable CDP leak for stronger reCAPTCHA-Enterprise evasion on the HEADED
+# path. It is NOT a headless unlock. Requires a separate install:
+#   pip install patchright        (or: pip install 'gflow-cli[patchright]')
+# When using system Chrome (channel=chrome, the gflow default) you do NOT need
+# `patchright install chromium`. Unset to revert to the default playwright engine.
+# GFLOW_CLI_BROWSER_ENGINE=playwright
+
 # BCP-47 locale tag passed to Playwright's launch `locale=` parameter
 # (controls Accept-Language only — Chrome's UI language is forced to
 # en-US via the `--lang=en-US` launch arg regardless of this setting, so

{gflow_cli-0.18.0 → gflow_cli-0.19.0}/CHANGELOG.md

@@ -7,6 +7,28 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.19.0] — 2026-06-12
+
+### Added
+
+- **Opt-in Patchright browser engine** via `GFLOW_CLI_BROWSER_ENGINE=patchright`
+  (default `playwright`, unchanged). Patchright is a drop-in patched Playwright
+  (Chromium) that runs page evaluations in an isolated execution context to
+  avoid the `Runtime.enable` CDP leak, for stronger reCAPTCHA-Enterprise evasion
+  on the **headed** path. It is **not** a headless unlock and must be installed
+  separately: `pip install 'gflow-cli[patchright]'`. The default engine is
+  byte-identical to before. `gflow auth status` now reports the active engine.
+- `BrowserEngineUnavailableError` (exit code 24): selecting `patchright` without
+  the package installed now fails with a clear `pip install patchright`
+  remediation hint instead of a raw `ImportError` hashed to a generic exit 1.
+
+### Fixed
+
+- An invalid `GFLOW_CLI_*` enum value (e.g. a typo'd `GFLOW_CLI_BROWSER_ENGINE`,
+  `GFLOW_CLI_PROVIDER`, or `GFLOW_CLI_LOG_LEVEL`) now fails with a clean
+  configuration error and **exit code 11** naming the offending variable, instead
+  of leaking a raw pydantic `ValidationError` traceback and exiting 1.
+
 ## [0.18.0] — 2026-06-12
 
 ### Added
@@ -1527,7 +1549,8 @@ shell-script template that branches on these codes.
 
 First skeleton. Not functional end-to-end yet.
 
-[Unreleased]: https://github.com/ffroliva/gflow-cli/compare/v0.18.0...HEAD
+[Unreleased]: https://github.com/ffroliva/gflow-cli/compare/v0.19.0...HEAD
+[0.19.0]: https://github.com/ffroliva/gflow-cli/compare/v0.18.0...v0.19.0
 [0.18.0]: https://github.com/ffroliva/gflow-cli/compare/v0.17.0...v0.18.0
 [0.17.0]: https://github.com/ffroliva/gflow-cli/compare/v0.16.0...v0.17.0
 [0.16.0]: https://github.com/ffroliva/gflow-cli/compare/v0.15.1...v0.16.0

{gflow_cli-0.18.0 → gflow_cli-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gflow-cli
-Version: 0.18.0
+Version: 0.19.0
 Summary: Unofficial CLI for Google Flow — drive Veo image-to-video generations from the terminal.
 Project-URL: Homepage, https://github.com/ffroliva/gflow-cli
 Project-URL: Issues, https://github.com/ffroliva/gflow-cli/issues
@@ -58,6 +58,8 @@ Requires-Dist: ruff>=0.15.16; extra == 'dev'
 Provides-Extra: gcs
 Requires-Dist: gcsfs>=2024.2.0; extra == 'gcs'
 Requires-Dist: universal-pathlib>=0.2.5; extra == 'gcs'
+Provides-Extra: patchright
+Requires-Dist: patchright==1.60.1; extra == 'patchright'
 Provides-Extra: s3
 Requires-Dist: s3fs>=2024.2.0; extra == 's3'
 Requires-Dist: universal-pathlib>=0.2.5; extra == 's3'

{gflow_cli-0.18.0 → gflow_cli-0.19.0}/docs/CONFIGURATION.md

@@ -190,6 +190,16 @@ GFLOW_CLI_HISTORY_PROMPTS=redacted gflow image t2i "confidential brief"
 **Default:** `true`
 **When to flip to `false`:** if reCAPTCHA Enterprise refuses to mint tokens (Google's bot-detection sometimes refuses headless Chromium but accepts a visible window). Set to `false` and re-run; the browser will appear during generation but the session is still reused from the persistent profile.
 
+### `GFLOW_CLI_BROWSER_ENGINE`
+
+**What:** Selects the browser-automation engine backing the Playwright API.
+**Values:** `playwright` | `patchright`
+**Default:** `playwright`
+**What `patchright` is:** an opt-in, drop-in patched Playwright (Chromium) that runs page evaluations in an isolated execution context to avoid the `Runtime.enable` CDP leak, for stronger reCAPTCHA-Enterprise evasion on the **headed** path. It is **not** a headless unlock — Google still detects headless Chromium regardless of engine.
+**Install:** `pip install 'gflow-cli[patchright]'` (or `pip install patchright`). Selecting `patchright` without it installed fails fast with exit code 24 and a pip remediation hint. When using system Chrome (the gflow default, `channel=chrome`) you do **not** need `patchright install chromium`.
+**Reverting:** unset the variable (or set `playwright`) — the default path is byte-identical to a build without this feature, with no profile migration.
+**Security note:** the `patchright` extra ships a *patched Chromium driver* that handles your live Google session cookies; it is exact-pinned and treated as a security-review-required dependency. See [SECURITY.md § Dependencies](SECURITY.md).
+
 ### `GFLOW_CLI_LOCALE`
 
 **What:** BCP-47 locale tag passed to Playwright's `launch_persistent_context(locale=...)` — controls the `Accept-Language` HTTP header only.

{gflow_cli-0.18.0 → gflow_cli-0.19.0}/docs/INDEX.md

@@ -111,7 +111,7 @@ Slash commands for Claude Code, stored in `.claude/commands/gflow/`. All prefixe
 **"A gflow command hangs / fails — where do I start?"** → [DEBUGGING § Quick reference](DEBUGGING.md#quick-reference)
 **"Flow's UI broke a selector — how do I diagnose it?"** → [DEBUGGING § Inspecting Flow's live UI](DEBUGGING.md#inspecting-flows-live-ui)
 **"What does each `ui_automation.*` log event mean?"** → [DEBUGGING § Listener & HTTP-layer debugging](DEBUGGING.md#listener--http-layer-debugging)
-**"What was actually live-verified for the latest release?"** → latest: [LIVE_VERIFICATION_v0.18.0](LIVE_VERIFICATION_v0.18.0.md) (#183 exit-23 selector-drift error: live drift simulation + happy path, credit-free). v0.14.0 / v0.15.0 / v0.15.1 shipped without a dedicated doc (CI + the v0.13.0 baseline). Prior: [v0.17.0](LIVE_VERIFICATION_v0.17.0.md) · [v0.16.0](LIVE_VERIFICATION_v0.16.0.md) · [v0.13.0](LIVE_VERIFICATION_v0.13.0.md) · [v0.12.0](LIVE_VERIFICATION_v0.12.0.md) · [v0.11.0](LIVE_VERIFICATION_v0.11.0.md) · [v0.10.0](LIVE_VERIFICATION_v0.10.0.md) · [v0.9.1](LIVE_VERIFICATION_v0.9.1.md) · [v0.9.0](LIVE_VERIFICATION_v0.9.0.md) · [v0.8.1](LIVE_VERIFICATION_v0.8.1.md) · [v0.7.0](LIVE_VERIFICATION_v0.7.0.md)
+**"What was actually live-verified for the latest release?"** → latest: [LIVE_VERIFICATION_v0.19.0](LIVE_VERIFICATION_v0.19.0.md) (opt-in patchright engine: credit-free `image t2i` end-to-end under `GFLOW_CLI_BROWSER_ENGINE=patchright`, 5-layer ledger + missing-dep/invalid-enum/default-path checks; 403→200 premise documented as pending a hot profile). v0.14.0 / v0.15.0 / v0.15.1 shipped without a dedicated doc (CI + the v0.13.0 baseline). Prior: [v0.18.0](LIVE_VERIFICATION_v0.18.0.md) · [v0.17.0](LIVE_VERIFICATION_v0.17.0.md) · [v0.16.0](LIVE_VERIFICATION_v0.16.0.md) · [v0.13.0](LIVE_VERIFICATION_v0.13.0.md) · [v0.12.0](LIVE_VERIFICATION_v0.12.0.md) · [v0.11.0](LIVE_VERIFICATION_v0.11.0.md) · [v0.10.0](LIVE_VERIFICATION_v0.10.0.md) · [v0.9.1](LIVE_VERIFICATION_v0.9.1.md) · [v0.9.0](LIVE_VERIFICATION_v0.9.0.md) · [v0.8.1](LIVE_VERIFICATION_v0.8.1.md) · [v0.7.0](LIVE_VERIFICATION_v0.7.0.md)
 **"Where is the reverse-engineered wire protocol for a feature?"** → the `*_RECON.md` design docs: [CHARACTER_RECON](CHARACTER_RECON.md) (Flow character entity protocol), [IMAGE_UPSCALE_RECON](IMAGE_UPSCALE_RECON.md) (`/v1/flow/upsampleImage` wire). Naming convention: one `<FEATURE>_RECON.md` per reverse-engineered surface, kept as the durable spec after the feature ships.
 **"What was live-verified for the data layer (PR #58)?"** → [LIVE_VERIFICATION_data_layer](LIVE_VERIFICATION_data_layer.md) — 1 Imagen + 1 Veo credit on denon82, 6-layer ledger (file + magic + Pillow + DB rows + CLI round-trip + structlog)
 **"What was live-verified for the video-download feature (#29)?"** → [LIVE_VERIFICATION_video_download](LIVE_VERIFICATION_video_download.md)

gflow_cli-0.19.0/docs/LIVE_VERIFICATION_v0.19.0.md

@@ -0,0 +1,60 @@
+# Live Verification — v0.19.0
+
+Feature under test: **opt-in Patchright browser engine** (`GFLOW_CLI_BROWSER_ENGINE=patchright`).
+Verified 2026-06-12 against live Google Flow on a real authenticated profile. Image
+generation is credit-free, so the end-to-end run cost **$0**.
+
+## Layer 1 — file count
+
+One image produced by `gflow image t2i` through the integrated patchright path:
+
+```
+scripts/dev/_spike_out/patch_verify/images/2026-06-12/6cb21d9e-e4f9-40ba-897c-eb25c6333892_1.jpg
+```
+
+(written to a throwaway `GFLOW_CLI_OUTPUT_DIR`, since cleaned up).
+
+## Layer 2 — magic bytes
+
+`b[:3] == FF D8 FF` → **valid JPEG**. Size 723,911 bytes.
+
+## Layer 3 — dimensions / shape
+
+Pillow: `format=JPEG dims=(768, 1376)` → correct **9:16** portrait (the default aspect).
+
+## Layer 4 — structlog invariants
+
+From the live run (`correlation_id=40877345-0af4-472f-966a-94f88112f0d9`):
+
+- `browser.engine_selected engine=patchright` — the **settings resolver** selected
+  patchright (the real wired path, not a test monkeypatch).
+- `ui_automation.batch_request_body` — prompt submitted (`bytes=5054`).
+- `ui_automation.batch_response_seen status=200` and
+  `ui_automation.batch_response_captured status=200` — `batchGenerateImages`
+  returned 200 and the response body parsed under patchright.
+
+## Layer 5 — user-confirmable artifact
+
+A studio-lit image of "a small green cactus in a terracotta pot" — visually
+inspectable, matches the prompt.
+
+## Supporting checks (same release)
+
+| Check | Evidence | Result |
+|---|---|---|
+| Default path byte-identical | client-level `navigator.webdriver` read through real `FlowApiClient`: `playwright → None` (masked), `patchright → False` (both non-bot) | ✅ default still stealthed |
+| Missing-dependency UX | `GFLOW_CLI_BROWSER_ENGINE=patchright` with patchright uninstalled → `image t2i` | ✅ **exit 24**, `BrowserEngineUnavailableError` + `pip install patchright` hint, no traceback, no browser launched |
+| Invalid enum setting | `GFLOW_CLI_BROWSER_ENGINE=patchwright` (and `GFLOW_CLI_PROVIDER=bogus`) | ✅ **exit 11**, clean "Configuration error" naming the variable, no raw pydantic traceback |
+| reCAPTCHA mint under patchright | `TokenMinter.mint` with `isolated_context=False` | ✅ returns a real token (the predicted isolated-world break, fixed) |
+| Retry across engine boundary | patchright's distinct `TimeoutError` through the real retry policy | ✅ retried (unit test) |
+
+## Premise still pending (documented, not a blocker)
+
+The *value* premise — does patchright reduce real 403s vs Playwright — could **not**
+be measured this cycle: the documented hot profile (`denon82`) had cooled, so plain
+Playwright also returned 200 (no 403 to flip). A faithful 403 cannot be emulated
+locally (a route-injected 403 is engine-blind; inflating real WAF heat risks the
+account). The feature ships as a **proven non-breaking, opt-in escape-hatch** with
+the default unchanged. Re-fire trigger: the instant any profile actually 403s, run
+`scripts/dev/spike_patchright.py --profile <hot> --engines playwright,patchright`
+to capture the `WAF_403 → OK_200` differential.

{gflow_cli-0.18.0 → gflow_cli-0.19.0}/docs/SECURITY.md

@@ -201,6 +201,26 @@ Audited with `pip-audit` in CI on every push. Major dependency surface:
 
 No transitive dep with known CVEs at the time of v0.1.0 scaffold.
 
+### Optional `patchright` engine — elevated supply-chain trust
+
+The `gflow-cli[patchright]` extra (opt-in via `GFLOW_CLI_BROWSER_ENGINE=patchright`)
+installs **Patchright**, a single-maintainer package that ships a **patched
+Chromium driver**. Because that driver *is* the browser process that loads your
+real Google session — it has direct access to session cookies, the OAuth Bearer
+token, and SAPISID — it carries a higher blast radius than an ordinary Python
+dependency: a compromised release could exfiltrate the full Google session.
+
+Controls:
+
+- **Optional-only** — never in the base `dependencies`; the default install pulls
+  neither the package nor its driver.
+- **Exact-pinned** (`patchright==1.60.1`) so a release cannot silently move the
+  browser binary underneath you.
+- **Security-review-required on bump** — a Patchright version change is treated
+  like a browser-binary change, NOT a routine dependabot auto-merge.
+- Default engine is `playwright` (Microsoft, security-reviewed); patchright is an
+  experiment you opt into per the trade-off above.
+
 ## Reporting
 
 | Issue type | How |

{gflow_cli-0.18.0 → gflow_cli-0.19.0}/docs/USAGE.md

@@ -1031,6 +1031,7 @@ shell scripts can branch on the failure mode without parsing stderr.
 | `21` | `ChainPartialError`   | A video chain stopped mid-way; earlier links completed | Resume from the last completed link shown in the error     |
 | `22` | `UpscaleUnavailableError` | 4K upscale is gated to Flow **Ultra** accounts (HTTP 403) | Use `--scale 2k`, or upgrade the Flow plan                |
 | `23` | `UiSelectorDriftError` | A Flow editor control could not be located — Google changed the frontend (issue #183) | Update gflow-cli; file a bug with the probe name + debug screenshot from the error message |
+| `24` | `BrowserEngineUnavailableError` | `GFLOW_CLI_BROWSER_ENGINE=patchright` but the engine is not installed | `pip install 'gflow-cli[patchright]'`, or unset `GFLOW_CLI_BROWSER_ENGINE` |
 | `130`| SIGINT                | User-interrupted (Ctrl-C)                        | —                                                          |
 
 **Exit code 16 — data store / migration error.** Fires when:

{gflow_cli-0.18.0 → gflow_cli-0.19.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gflow-cli"
-version = "0.18.0"
+version = "0.19.0"
 description = "Unofficial CLI for Google Flow — drive Veo image-to-video generations from the terminal."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -58,6 +58,15 @@ s3 = [
 chain = [
     "av>=12",
 ]
+# Patchright engine extra — opt-in, drop-in patched Playwright (Chromium) that
+# avoids the Runtime.enable CDP leak on the headed path. Selected via
+# GFLOW_CLI_BROWSER_ENGINE=patchright. Ships a PATCHED Chromium driver that
+# handles live Google session cookies/Bearer/SAPISID, so it is EXACT-pinned and
+# treated as a security-review-required bump (NOT a dependabot auto-merge) —
+# see SECURITY.md. Not a headless unlock.
+patchright = [
+    "patchright==1.60.1",
+]
 
 [project.scripts]
 gflow = "gflow_cli.cli:main"

gflow_cli-0.19.0/scripts/dev/spike_patchright.py

@@ -0,0 +1,357 @@
+#!/usr/bin/env python3
+r"""Patchright engine spike — the Phase-0 kill-gate for the opt-in browser engine.
+
+Plan: docs/superpowers/plans/2026-06-12-patchright-engine/{PLAN.md,SCENARIO.md}
+Predict verdict: CAUTION 6/10 — this spike must prove the premise before any
+production file is touched.
+
+Touches ZERO production files. It swaps the browser engine at RUNTIME (monkeypatch
+of the module-level ``async_playwright`` that ``client.py`` / ``ui_automation.py``
+import) and reuses the real ``FlowApiClient.generate_image`` path so the 403→200
+comparison is faithful — not a hand-rolled request that could 403 for the wrong
+reason. Image generation is credit-free (memory: flow-credits-videos-only), so the
+decisive hot-profile leg costs $0.
+
+Two probe phases per engine (``playwright`` baseline vs ``patchright``):
+
+  A. PRIMITIVE PROBE (owns its own page; full control)
+     - launch the real profile with the EXACT production launch kwargs
+       (replicates client._persistent_context_kwargs + the navigator.webdriver mask)
+     - record channel (scenario 7), navigator.webdriver (scenario 3 baseline)
+     - discover_site_key (scenario 8 / Leg 2)
+     - MINT A/B (scenario 1 / Leg 1, the make-or-break): under patchright, call the
+       reCAPTCHA execute JS with the default (isolated) context AND with
+       isolated_context=False — record which returns a token. This directly
+       validates/invalidates the "isolated_context default breaks grecaptcha"
+       hypothesis from predict.
+     - listener smoke (Legs 3/4 lite): page.on("response")/page.on("request") fire.
+
+  B. FAITHFUL GENERATION (scenario 2 / Leg 6 — DECISIVE, + real Leg 3)
+     - swap engine on client.py + ui_automation.py
+     - patch recaptcha.TokenMinter.mint to inject isolated_context=False (patchright)
+     - attach a context-page response listener capturing the batchGenerateImages
+       HTTP status + whether response.json() parses
+     - run the real generate_image and classify the outcome (200 / 403-WAF /
+       mint-broken / other)
+
+Run it on a HOT profile (one currently 403ing under playwright) for the decisive
+comparison. Pass-bar = patchright measurably flips 403→200 AND mint works AND
+listeners parse. Any red leg → STOP (write SPIKE-RESULTS.md, recommend
+cadence-shaping). See PLAN.md Phase 0.
+
+Usage (headed, supervised; PYTHONUTF8=1 on Windows):
+
+    .venv\Scripts\python.exe scripts\dev\spike_patchright.py ^
+        --profile denon82 --engines playwright,patchright ^
+        --prompt "a red ceramic mug on a wooden table, studio light"
+
+    # primitives only (no generation), e.g. on a clean profile:
+    .venv\Scripts\python.exe scripts\dev\spike_patchright.py ^
+        --profile ffroliva --skip-generation
+
+Outputs (gitignored): scripts/dev/_spike_out/spike_patchright_<ts>.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+import time
+import traceback
+from pathlib import Path
+from typing import Any
+
+_ROOT = Path(__file__).resolve().parents[2]
+_SRC = _ROOT / "src"
+if _SRC.exists() and str(_SRC) not in sys.path:
+    sys.path.insert(0, str(_SRC))
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from _spike_common import default_out_path, resolve_profile_dir, step  # noqa: E402
+
+# Production surfaces under test (worktree src/ via the bootstrap above).
+import gflow_cli.api.client as client_mod  # noqa: E402
+import gflow_cli.api.transports.ui_automation as ui_mod  # noqa: E402
+from gflow_cli.api import recaptcha as recaptcha_mod  # noqa: E402
+from gflow_cli.api import routes  # noqa: E402
+from gflow_cli.api.client import FlowApiClient  # noqa: E402
+from gflow_cli.api.image import Aspect, GenerateImageRequest, Model  # noqa: E402
+from gflow_cli.api.recaptcha import RecaptchaError, discover_site_key  # noqa: E402
+from gflow_cli.browser_manager import channel_for_profile  # noqa: E402
+
+_EXECUTE_JS = recaptcha_mod._EXECUTE_JS  # noqa: SLF001 — spike reuses the production mint JS
+
+# Original references so each engine run restores a clean module state.
+_PW_ASYNC = client_mod.async_playwright
+_ORIG_MINT = recaptcha_mod.TokenMinter.mint
+
+
+def _engine_async_playwright(engine: str) -> Any:
+    """Return the async_playwright factory for *engine* (imports patchright lazily)."""
+    if engine == "playwright":
+        return _PW_ASYNC
+    if engine == "patchright":
+        from patchright.async_api import async_playwright as patch_async
+
+        return patch_async
+    msg = f"unknown engine {engine!r}"
+    raise ValueError(msg)
+
+
+def _launch_kwargs(profile_dir: Path) -> dict[str, Any]:
+    """Replicate client._persistent_context_kwargs verbatim (headed, identical for
+    both engines so ENGINE is the only variable in the comparison)."""
+    return {
+        "user_data_dir": str(profile_dir),
+        "headless": False,
+        "viewport": {"width": 1280, "height": 720},
+        "locale": "en-US",
+        "extra_http_headers": {"Accept-Language": "en-US,en;q=0.9"},
+        "channel": channel_for_profile(profile_dir),
+        "ignore_default_args": ["--enable-automation", "--no-sandbox", "--password-store=basic"],
+        "args": ["--disable-blink-features=AutomationControlled", "--disable-dev-shm-usage"],
+    }
+
+
+async def _eval_token(page: Any, site_key: str, action: str, *, isolated: bool | None) -> Any:
+    """Run the production reCAPTCHA execute JS. ``isolated=None`` → engine default
+    (no kwarg, valid for both engines); ``isolated=False`` → patchright main-world."""
+    if isolated is None:
+        return await page.evaluate(_EXECUTE_JS, [site_key, action])
+    return await page.evaluate(_EXECUTE_JS, [site_key, action], isolated_context=isolated)
+
+
+async def probe_primitives(engine: str, profile_dir: Path, action: str) -> dict[str, Any]:
+    """Phase A — primitives on a self-owned page. No FlowApiClient, full control."""
+    out: dict[str, Any] = {"engine": engine, "channel": channel_for_profile(profile_dir)}
+    apw = _engine_async_playwright(engine)
+    req_count = {"request": 0, "response": 0}
+    try:
+        async with apw() as pw:
+            try:
+                ctx = await pw.chromium.launch_persistent_context(**_launch_kwargs(profile_dir))
+            except Exception as exc:  # noqa: BLE001
+                out["launch_error"] = f"{type(exc).__name__}: {exc}"
+                out["hint"] = (
+                    "patchright may need `patchright install chromium` if channel='chrome' "
+                    "is not honoured — scenario 7."
+                )
+                return out
+            out["launch_ok"] = True
+            await ctx.add_init_script(
+                "Object.defineProperty(navigator,'webdriver',{get:()=>undefined})",
+            )
+            page = ctx.pages[0] if ctx.pages else await ctx.new_page()
+            page.on("request", lambda *_: req_count.__setitem__("request", req_count["request"] + 1))
+            page.on(
+                "response", lambda *_: req_count.__setitem__("response", req_count["response"] + 1)
+            )
+            await page.goto(routes.EDITOR_BOOTSTRAP_URL, wait_until="domcontentloaded", timeout=60_000)
+            await page.wait_for_timeout(4000)
+
+            out["navigator_webdriver"] = await page.evaluate("() => navigator.webdriver")
+            try:
+                site_key = await discover_site_key(page)
+                out["site_key_prefix"] = site_key[:12]
+                out["discover_site_key"] = "ok"
+            except RecaptchaError as exc:
+                out["discover_site_key"] = f"FAIL: {exc}"
+                site_key = ""
+
+            # MINT A/B — the make-or-break (Leg 1 / scenario 1).
+            if site_key:
+                # Engine default (playwright: main world; patchright: isolated world).
+                try:
+                    tok = await _eval_token(page, site_key, action, isolated=None)
+                    out["mint_default"] = "ok" if (isinstance(tok, str) and tok) else "empty"
+                except Exception as exc:  # noqa: BLE001
+                    out["mint_default"] = f"FAIL: {type(exc).__name__}: {str(exc)[:80]}"
+                # Patchright-only: force main world.
+                if engine == "patchright":
+                    try:
+                        tok2 = await _eval_token(page, site_key, action, isolated=False)
+                        out["mint_isolated_false"] = (
+                            "ok" if (isinstance(tok2, str) and tok2) else "empty"
+                        )
+                    except Exception as exc:  # noqa: BLE001
+                        out["mint_isolated_false"] = f"FAIL: {type(exc).__name__}: {str(exc)[:80]}"
+
+            out["listener_counts"] = dict(req_count)
+            await ctx.close()
+    except Exception as exc:  # noqa: BLE001
+        out["error"] = f"{type(exc).__name__}: {exc}"
+        out["traceback"] = traceback.format_exc(limit=4)
+    return out
+
+
+def _install_engine(engine: str) -> None:
+    """Runtime engine swap on the production modules + mint fix for patchright."""
+    apw = _engine_async_playwright(engine)
+    client_mod.async_playwright = apw
+    ui_mod.async_playwright = apw
+    if engine == "patchright":
+
+        async def _patched_mint(self: Any, action: str) -> str:
+            site_key = await self.site_key()
+            token = await self._page.evaluate(  # noqa: SLF001
+                _EXECUTE_JS, [site_key, action], isolated_context=False
+            )
+            if not isinstance(token, str) or not token:
+                msg = f"empty token (patched main-world mint) for action={action!r}"
+                raise RecaptchaError(msg)
+            return token
+
+        recaptcha_mod.TokenMinter.mint = _patched_mint  # type: ignore[method-assign]
+    else:
+        recaptcha_mod.TokenMinter.mint = _ORIG_MINT  # type: ignore[method-assign]
+
+
+def _restore_engine() -> None:
+    client_mod.async_playwright = _PW_ASYNC
+    ui_mod.async_playwright = _PW_ASYNC
+    recaptcha_mod.TokenMinter.mint = _ORIG_MINT  # type: ignore[method-assign]
+
+
+async def probe_generation(
+    engine: str, profile_dir: Path, *, prompt: str, aspect: str, model: str, action: str
+) -> dict[str, Any]:
+    """Phase B — faithful generate_image under *engine*; classify 200 vs 403 (Leg 6)."""
+    out: dict[str, Any] = {"engine": engine}
+    batch_hits: list[dict[str, Any]] = []
+    _install_engine(engine)
+    try:
+        req = GenerateImageRequest(
+            prompt=prompt, aspect=Aspect.from_cli(aspect), model=Model.from_cli(model)
+        )
+        async with FlowApiClient(profile_dir=profile_dir, headless=False) as client:
+            # Attach a response listener to every pooled page (scenario 4 — assert
+            # the batchGenerateImages body parses, not just that a callback fires).
+            def _on_response(resp: Any) -> None:
+                if "batchGenerateImages" in resp.url:
+                    asyncio.create_task(_record(resp))
+
+            async def _record(resp: Any) -> None:
+                entry: dict[str, Any] = {"status": resp.status}
+                try:
+                    body = await resp.json()
+                    entry["json_ok"] = True
+                    entry["has_media"] = bool(
+                        isinstance(body, dict) and (body.get("media") or body.get("results"))
+                    )
+                except Exception as exc:  # noqa: BLE001
+                    entry["json_ok"] = False
+                    entry["json_err"] = type(exc).__name__
+                batch_hits.append(entry)
+
+            for p in getattr(client, "_pages", []):
+                p.on("response", _on_response)
+
+            t0 = time.time()
+            try:
+                img = await client.generate_image(req=req, recaptcha_action=action)
+                out["result"] = "OK_200"
+                out["media_url_present"] = bool(getattr(img, "url", None) or getattr(img, "name", None))
+            except RecaptchaError as exc:
+                out["result"] = "MINT_BROKEN"
+                out["detail"] = str(exc)[:160]
+            except client_mod.WafRejectionError as exc:
+                out["result"] = "WAF_403"
+                out["detail"] = str(exc)[:160]
+            except Exception as exc:  # noqa: BLE001
+                out["result"] = f"OTHER:{type(exc).__name__}"
+                out["detail"] = str(exc)[:160]
+            out["elapsed_s"] = round(time.time() - t0, 1)
+            await asyncio.sleep(0.5)  # let any in-flight _record tasks settle
+            out["batch_responses"] = batch_hits
+    except Exception as exc:  # noqa: BLE001
+        out["error"] = f"{type(exc).__name__}: {exc}"
+        out["traceback"] = traceback.format_exc(limit=4)
+    finally:
+        _restore_engine()
+    return out
+
+
+async def _run(args: argparse.Namespace, profile_dir: Path, out_path: Path) -> int:
+    engines = [e.strip() for e in args.engines.split(",") if e.strip()]
+    results: dict[str, Any] = {
+        "spike": "patchright-engine-phase0",
+        "capturedAt": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        "profile": args.profile,
+        "engines": engines,
+        "action": args.action,
+        "primitives": [],
+        "generation": [],
+    }
+    for engine in engines:
+        step("A", f"[{engine}] primitive probe", prefix="patch")
+        results["primitives"].append(await probe_primitives(engine, profile_dir, args.action))
+        if not args.skip_generation:
+            step("B", f"[{engine}] faithful generation (credit-free image)", prefix="patch")
+            results["generation"].append(
+                await probe_generation(
+                    engine,
+                    profile_dir,
+                    prompt=args.prompt,
+                    aspect=args.aspect,
+                    model=args.model,
+                    action=args.action,
+                )
+            )
+
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_text(json.dumps(results, indent=2, ensure_ascii=False), encoding="utf-8")
+
+    # Console summary — the at-a-glance gate readout.
+    print("\n================ PATCHRIGHT SPIKE SUMMARY ================", flush=True)
+    for p in results["primitives"]:
+        eng = p["engine"]
+        print(
+            f"[A {eng:10}] launch={p.get('launch_ok', p.get('launch_error', '?'))} "
+            f"channel={p.get('channel')} webdriver={p.get('navigator_webdriver')} "
+            f"discover={p.get('discover_site_key')} mint_default={p.get('mint_default')} "
+            f"mint_iso_false={p.get('mint_isolated_false', 'n/a')} "
+            f"listeners={p.get('listener_counts')}",
+            flush=True,
+        )
+    for g in results["generation"]:
+        eng = g["engine"]
+        print(
+            f"[B {eng:10}] result={g.get('result', g.get('error'))} "
+            f"elapsed={g.get('elapsed_s')}s batch={g.get('batch_responses')}",
+            flush=True,
+        )
+    print(f"\n[patch] full results -> {out_path}", flush=True)
+    print(
+        "[patch] GATE: pass = patchright mint works (mint_iso_false=ok) AND "
+        "(on a hot profile) patchright result=OK_200 while playwright result=WAF_403.",
+        flush=True,
+    )
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(description="Patchright engine Phase-0 spike (credit-free).")
+    p.add_argument("--profile", default="ffroliva", help="gflow profile name (use a HOT one for the decisive leg)")
+    p.add_argument("--engines", default="playwright,patchright", help="comma list")
+    p.add_argument("--prompt", default="a red ceramic mug on a wooden table, soft studio light")
+    p.add_argument("--aspect", default="9:16")
+    p.add_argument("--model", default="nano2")
+    p.add_argument("--action", default="imageGeneration", help="reCAPTCHA action (memory: action mismatch → silent 403)")
+    p.add_argument("--skip-generation", action="store_true", help="primitives only (no credit-free gen)")
+    p.add_argument("--out", default=None)
+    args = p.parse_args(argv)
+
+    profile_dir = resolve_profile_dir(args.profile)
+    out_path = Path(args.out) if args.out else default_out_path("spike_patchright", ".json")
+    step("--", f"profile={args.profile} engines={args.engines} gen={not args.skip_generation}", prefix="patch")
+    try:
+        return asyncio.run(_run(args, profile_dir, out_path))
+    except KeyboardInterrupt:
+        print("[patch] aborted", file=sys.stderr)
+        return 130
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{gflow_cli-0.18.0 → gflow_cli-0.19.0}/src/gflow_cli/__init__.py

@@ -1,3 +1,3 @@
 """gflow-cli — unofficial CLI for Google Flow."""
 
-__version__ = "0.18.0"
+__version__ = "0.19.0"