oh-my-opencode 5.1.48 → 5.1.51

package/packages/omo-codex/plugin/skills/ultimate-browsing/engine/tests/test_fetch_chain.py

@@ -1,77 +0,0 @@
-from __future__ import annotations
-
-import sys
-import unittest
-from pathlib import Path
-from unittest.mock import patch
-
-sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
-
-from engine.fetch_chain import fetch  # noqa: E402
-from engine.result_schema import Attempt  # noqa: E402
-from engine.validators import Verdict  # noqa: E402
-
-
-class _Resp:
-    def __init__(self, text: str = "<article>ok</article>", url: str = "https://example.com/"):
-        self.text = text
-        self.url = url
-
-
-class _Hit:
-    profile_id = "cloudflare_turnstile"
-    confidence = 1.0
-    signals = ["test"]
-
-
-class FetchChain(unittest.TestCase):
-    def test_probe_success_returns_without_grid(self) -> None:
-        attempt = Attempt(
-            phase="probe",
-            executor="curl_cffi",
-            url="https://example.com",
-            url_transform="original",
-            impersonate="safari",
-            referer="self_root",
-            verdict=Verdict.WEAK_OK.value,
-        )
-
-        with patch("engine.fetch_chain._load_profiles", return_value={}), \
-                patch("engine.fetch_chain.last_load_error", return_value=None), \
-                patch("engine.fetch_chain.run_attempt", return_value=(attempt, _Resp())) as run_attempt:
-            result = fetch("https://example.com", enable_playwright=False)
-
-        self.assertTrue(result.ok)
-        self.assertEqual(result.verdict, Verdict.WEAK_OK.value)
-        self.assertEqual(len(result.trace), 1)
-        self.assertEqual(run_attempt.call_count, 1)
-
-    def test_max_attempts_stops_after_probe_before_grid(self) -> None:
-        attempt = Attempt(
-            phase="probe",
-            executor="curl_cffi",
-            url="https://example.com",
-            url_transform="original",
-            impersonate="safari",
-            referer="self_root",
-            verdict=Verdict.CHALLENGE.value,
-        )
-
-        with patch("engine.fetch_chain._load_profiles", return_value={}), \
-                patch("engine.fetch_chain.last_load_error", return_value=None), \
-                patch("engine.fetch_chain.run_attempt", return_value=(attempt, _Resp("blocked"))), \
-                patch("engine.fetch_chain.detect", return_value=[_Hit()]), \
-                patch("engine.fetch_chain.load_profile", return_value={
-                    "tls_impersonate_candidates": [["chrome"]],
-                    "referer_strategies": ["self_root"],
-                    "url_transform_order": ["original"],
-                }):
-            result = fetch("https://example.com", max_attempts=1, enable_playwright=False)
-
-        self.assertFalse(result.ok)
-        self.assertEqual(len(result.trace), 1)
-        self.assertEqual(result.trace[0].phase, "probe")
-
-
-if __name__ == "__main__":
-    unittest.main()

package/packages/omo-codex/plugin/skills/ultimate-browsing/engine/tests/test_playwright_stealth.py

@@ -1,86 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-import subprocess
-import tempfile
-import unittest
-from pathlib import Path
-
-from test_playwright_templates import (
-    TEMPLATE_NAMES,
-    TEMPLATES_DIR,
-    _install_fake_playwright,
-    _write_file,
-)
-
-
-class PlaywrightTemplateStealth(unittest.TestCase):
-    def test_extracts_html_and_closes_wrapped_chrome_when_stealth_is_installed(self) -> None:
-        for template_name in TEMPLATE_NAMES:
-            with self.subTest(template_name=template_name), tempfile.TemporaryDirectory() as tmp:
-                # Given: core has no plugin API; only addExtra supplies a registered wrapper.
-                root = Path(tmp)
-                modules = root / "node_modules"
-                profile = root / "profile"
-                receipt = root / "launch.json"
-                _install_fake_playwright(modules)
-                _write_file(modules / "puppeteer-extra-plugin-stealth/index.js", """
-                    module.exports = () => ({ name: 'stealth' });
-                """)
-                _write_file(modules / "playwright-extra/index.js", """
-                    const assert = require('node:assert/strict');
-                    const fs = require('node:fs');
-                    exports.addExtra = (core) => {
-                      assert.equal(core, require('playwright-core').chromium);
-                      assert.equal(Object.hasOwn(core, 'use'), false);
-                      const events = ['wrap'];
-                      let registered = false;
-                      return {
-                        use(plugin) {
-                          assert.equal(plugin.name, 'stealth');
-                          registered = true;
-                          events.push(plugin.name);
-                        },
-                        async launchPersistentContext(profileDir, options) {
-                          assert.equal(registered, true);
-                          events.push({ profileDir, channel: options.channel, viewport: options.viewport });
-                          const context = await core.launchPersistentContext(profileDir, options);
-                          return {
-                            ...context,
-                            async close() {
-                              await context.close();
-                              events.push('close');
-                              fs.writeFileSync(process.env.STEALTH_RECEIPT, JSON.stringify(events));
-                            },
-                          };
-                        },
-                      };
-                    };
-                """)
-                script = root / template_name
-                script.write_bytes((TEMPLATES_DIR / template_name).read_bytes())
-                env = {key: value for key, value in os.environ.items() if key != "NODE_PATH"}
-                env["STEALTH_RECEIPT"] = str(receipt)
-
-                # When: the actual bundled entry point consumes its normal stdin protocol.
-                result = subprocess.run(
-                    ["node", str(script)],
-                    input=json.dumps({"url": "https://example.com/", "profileDir": str(profile), "headless": True}),
-                    text=True, capture_output=True, timeout=5, env=env, check=False,
-                )
-
-                # Then: HTML arrives through the registered wrapper and the context is closed.
-                self.assertEqual(result.returncode, 0, result.stderr)
-                self.assertEqual(result.stdout, "<html><article>ok</article></html>")
-                self.assertEqual(result.stderr, "")
-                viewport = {"width": 390, "height": 844} if "mobile" in template_name else {"width": 1366, "height": 900}
-                self.assertEqual(json.loads(receipt.read_text(encoding="utf-8")), [
-                    "wrap", "stealth",
-                    {"profileDir": str(profile), "channel": "chrome", "viewport": viewport},
-                    "close",
-                ])
-
-
-if __name__ == "__main__":
-    unittest.main()

package/packages/omo-codex/plugin/skills/ultimate-browsing/engine/tests/test_playwright_templates.py

@@ -1,279 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-import shutil
-import subprocess
-import tempfile
-import textwrap
-import unittest
-from pathlib import Path
-
-TEMPLATES_DIR = Path(__file__).resolve().parents[1] / "templates"
-TEMPLATE_NAMES = ("playwright_real_chrome.js", "playwright_mobile_chrome.js")
-JsonValue = None | bool | int | float | str | list["JsonValue"] | dict[str, "JsonValue"]
-
-
-def _write_file(path: Path, content: str) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(textwrap.dedent(content).lstrip(), encoding="utf-8")
-
-
-def _install_fake_playwright(node_modules: Path) -> None:
-    _write_file(
-        node_modules / "playwright-core" / "index.js",
-        """
-        const page = {
-          async goto() {},
-          async waitForTimeout() {},
-          async waitForSelector(selector) {
-            if (process.env.PW_FAKE_SELECTOR_FAIL === '1') {
-              throw new Error(`missing selector ${selector}`);
-            }
-          },
-          async reload() {},
-          async content() {
-            return '<html><article>ok</article></html>';
-          },
-        };
-
-        const context = {
-          async newPage() { return page; },
-          async close() {
-            if (process.env.PW_FAKE_CLOSE_FAIL === '1') {
-              throw new Error('close failed');
-            }
-          },
-        };
-
-        exports.chromium = {
-          async launchPersistentContext() { return context; },
-        };
-        exports.devices = {
-          'iPhone 13 Pro': { viewport: { width: 390, height: 844 }, userAgent: 'fake-mobile' },
-        };
-        """,
-    )
-
-
-def _install_broken_playwright_extra(node_modules: Path) -> None:
-    _write_file(
-        node_modules / "playwright-extra" / "index.js",
-        """
-        const error = new Error('stealth init failed');
-        error.code = 'EACCES';
-        throw error;
-        """,
-    )
-    _write_file(
-        node_modules / "puppeteer-extra-plugin-stealth" / "index.js",
-        """
-        module.exports = function stealth() { return {}; };
-        """,
-    )
-
-
-def _install_working_playwright_extra(node_modules: Path) -> None:
-    _write_file(
-        node_modules / "playwright-extra" / "index.js",
-        """
-        exports.addExtra = (browserType) => browserType;
-        """,
-    )
-
-
-def _install_playwright_extra_with_internal_missing_dependency(node_modules: Path) -> None:
-    _write_file(
-        node_modules / "playwright-extra" / "index.js",
-        """
-        require('transitive-stealth-runtime');
-        """,
-    )
-
-
-def _install_self_missing_optional_module(node_modules: Path, module_name: str) -> None:
-    _write_file(
-        node_modules / module_name / "index.js",
-        f"""
-        const error = new Error("Cannot find module '{module_name}'");
-        error.code = 'MODULE_NOT_FOUND';
-        throw error;
-        """,
-    )
-
-
-def _run_template(
-    template_name: str,
-    payload: dict[str, JsonValue],
-    *,
-    include_broken_extra: bool = False,
-    include_working_extra: bool = False,
-    include_internal_missing_extra: bool = False,
-    include_self_missing_module: str | None = None,
-    env_overrides: dict[str, str] | None = None,
-) -> subprocess.CompletedProcess[str]:
-    with tempfile.TemporaryDirectory(prefix="ultimate-browsing-template-test-") as tmp:
-        tmp_path = Path(tmp)
-        node_modules = tmp_path / "node_modules"
-        _install_fake_playwright(node_modules)
-        if include_working_extra:
-            _install_working_playwright_extra(node_modules)
-        if include_broken_extra:
-            _install_broken_playwright_extra(node_modules)
-        if include_internal_missing_extra:
-            _install_playwright_extra_with_internal_missing_dependency(node_modules)
-        if include_self_missing_module:
-            _install_self_missing_optional_module(node_modules, include_self_missing_module)
-
-        script_path = tmp_path / template_name
-        script_path.write_text((TEMPLATES_DIR / template_name).read_text(encoding="utf-8"), encoding="utf-8")
-
-        env = os.environ.copy()
-        env.pop("NODE_PATH", None)
-        if env_overrides:
-            env.update(env_overrides)
-
-        return subprocess.run(
-            ["node", str(script_path)],
-            input=json.dumps(payload),
-            text=True,
-            capture_output=True,
-            timeout=5,
-            env=env,
-            check=False,
-        )
-
-
-@unittest.skipUnless(shutil.which("node"), "node is required for Playwright template tests")
-class PlaywrightTemplateErrorHandling(unittest.TestCase):
-    def test_missing_playwright_extra_warns_and_falls_back_to_playwright_core(self) -> None:
-        for template_name in TEMPLATE_NAMES:
-            with self.subTest(template_name=template_name):
-                result = _run_template(
-                    template_name,
-                    {
-                        "url": "https://example.com/article",
-                        "profileDir": "/tmp/ultimate-browsing-test-profile",
-                        "headless": True,
-                    },
-                )
-
-                self.assertEqual(result.returncode, 0, result.stderr)
-                self.assertIn("<article>ok</article>", result.stdout)
-                self.assertIn("best-effort optional module playwright-extra failed:", result.stderr)
-                self.assertIn("Cannot find module 'playwright-extra'", result.stderr)
-
-    def test_missing_stealth_plugin_warns_and_falls_back_to_playwright_core(self) -> None:
-        for template_name in TEMPLATE_NAMES:
-            with self.subTest(template_name=template_name):
-                result = _run_template(
-                    template_name,
-                    {
-                        "url": "https://example.com/article",
-                        "profileDir": "/tmp/ultimate-browsing-test-profile",
-                        "headless": True,
-                    },
-                    include_working_extra=True,
-                )
-
-                self.assertEqual(result.returncode, 0, result.stderr)
-                self.assertIn("<article>ok</article>", result.stdout)
-                self.assertIn("best-effort optional module puppeteer-extra-plugin-stealth failed:", result.stderr)
-                self.assertIn("Cannot find module 'puppeteer-extra-plugin-stealth'", result.stderr)
-
-    def test_non_missing_stealth_dependency_error_is_not_swallowed(self) -> None:
-        for template_name in TEMPLATE_NAMES:
-            with self.subTest(template_name=template_name):
-                result = _run_template(
-                    template_name,
-                    {
-                        "url": "https://example.com/article",
-                        "profileDir": "/tmp/ultimate-browsing-test-profile",
-                        "headless": True,
-                    },
-                    include_broken_extra=True,
-                )
-
-                self.assertNotEqual(result.returncode, 0)
-                self.assertIn("stealth init failed", result.stderr)
-                self.assertNotIn("best-effort optional module", result.stderr)
-                self.assertEqual(result.stdout, "")
-
-    def test_internal_module_resolution_error_is_not_treated_as_optional_missing_dependency(self) -> None:
-        for template_name in TEMPLATE_NAMES:
-            with self.subTest(template_name=template_name):
-                result = _run_template(
-                    template_name,
-                    {
-                        "url": "https://example.com/article",
-                        "profileDir": "/tmp/ultimate-browsing-test-profile",
-                        "headless": True,
-                    },
-                    include_internal_missing_extra=True,
-                )
-
-                self.assertNotEqual(result.returncode, 0)
-                self.assertIn("Cannot find module 'transitive-stealth-runtime'", result.stderr)
-                self.assertNotIn("best-effort optional module", result.stderr)
-                self.assertEqual(result.stdout, "")
-
-    def test_present_optional_module_self_missing_error_is_not_swallowed(self) -> None:
-        cases = (("playwright-extra", False), ("puppeteer-extra-plugin-stealth", True))
-        for template_name in TEMPLATE_NAMES:
-            for module_name, include_working_extra in cases:
-                with self.subTest(template_name=template_name, module_name=module_name):
-                    result = _run_template(
-                        template_name,
-                        {
-                            "url": "https://example.com/article",
-                            "profileDir": "/tmp/ultimate-browsing-test-profile",
-                            "headless": True,
-                        },
-                        include_working_extra=include_working_extra,
-                        include_self_missing_module=module_name,
-                    )
-
-                    self.assertNotEqual(result.returncode, 0)
-                    self.assertIn(f"Cannot find module '{module_name}'", result.stderr)
-                    self.assertNotIn("best-effort optional module", result.stderr)
-                    self.assertEqual(result.stdout, "")
-
-    def test_selector_failures_are_reported_as_best_effort_warnings(self) -> None:
-        for template_name in TEMPLATE_NAMES:
-            with self.subTest(template_name=template_name):
-                result = _run_template(
-                    template_name,
-                    {
-                        "url": "https://example.com/article",
-                        "profileDir": "/tmp/ultimate-browsing-test-profile",
-                        "headless": True,
-                        "waitSelector": "article.ready",
-                    },
-                    env_overrides={"PW_FAKE_SELECTOR_FAIL": "1"},
-                )
-
-                self.assertEqual(result.returncode, 0, result.stderr)
-                self.assertIn("<article>ok</article>", result.stdout)
-                self.assertIn("best-effort waitSelector failed:", result.stderr)
-                self.assertNotIn("waitSelector article.ready", result.stderr)
-
-    def test_context_close_failures_are_reported_after_successful_html_output(self) -> None:
-        for template_name in TEMPLATE_NAMES:
-            with self.subTest(template_name=template_name):
-                result = _run_template(
-                    template_name,
-                    {
-                        "url": "https://example.com/article",
-                        "profileDir": "/tmp/ultimate-browsing-test-profile",
-                        "headless": True,
-                    },
-                    env_overrides={"PW_FAKE_CLOSE_FAIL": "1"},
-                )
-
-                self.assertEqual(result.returncode, 0, result.stderr)
-                self.assertIn("<article>ok</article>", result.stdout)
-                self.assertIn("best-effort browser context close failed:", result.stderr)
-
-
-if __name__ == "__main__":
-    unittest.main()