npm - @gajae-code/coding-agent - Versions diffs - 0.7.0 → 0.7.2 - Mend

@gajae-code/coding-agent 0.7.0 → 0.7.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (101) hide show

package/CHANGELOG.md +28 -0
package/dist/types/cli/notify-cli.d.ts +2 -0
package/dist/types/config/settings-schema.d.ts +39 -2
package/dist/types/extensibility/shared-events.d.ts +1 -0
package/dist/types/gjc-runtime/launch-tmux.d.ts +1 -0
package/dist/types/gjc-runtime/ralplan-runtime.d.ts +1 -1
package/dist/types/gjc-runtime/tmux-common.d.ts +3 -0
package/dist/types/gjc-runtime/tmux-sessions.d.ts +2 -0
package/dist/types/lsp/types.d.ts +2 -0
package/dist/types/notifications/attachment-registry.d.ts +17 -0
package/dist/types/notifications/chat-adapters.d.ts +9 -0
package/dist/types/notifications/config.d.ts +9 -1
package/dist/types/notifications/engine.d.ts +59 -0
package/dist/types/notifications/managed-daemon.d.ts +48 -0
package/dist/types/notifications/telegram-daemon.d.ts +19 -0
package/dist/types/notifications/threaded-inbound.d.ts +19 -0
package/dist/types/notifications/threaded-render.d.ts +6 -1
package/dist/types/session/agent-session.d.ts +2 -0
package/dist/types/tools/fetch.d.ts +23 -0
package/dist/types/tools/index.d.ts +1 -0
package/dist/types/tools/telegram-send.d.ts +32 -0
package/dist/types/web/insane/bridge.d.ts +103 -0
package/dist/types/web/insane/url-guard.d.ts +22 -0
package/dist/types/web/search/provider.d.ts +18 -1
package/dist/types/web/search/providers/insane.d.ts +53 -0
package/dist/types/web/search/providers/text-citations.d.ts +23 -0
package/dist/types/web/search/types.d.ts +12 -4
package/package.json +10 -8
package/scripts/verify-insane-vendor.ts +132 -0
package/src/cli/args.ts +1 -1
package/src/cli/fast-help.ts +1 -1
package/src/cli/notify-cli.ts +152 -5
package/src/cli.ts +1 -3
package/src/commands/team.ts +1 -1
package/src/config/settings-schema.ts +30 -1
package/src/defaults/gjc/skills/ralplan/SKILL.md +11 -4
package/src/edit/modes/replace.ts +1 -1
package/src/extensibility/shared-events.ts +1 -0
package/src/gjc-runtime/launch-tmux.ts +27 -5
package/src/gjc-runtime/ledger-event-renderer.ts +1 -0
package/src/gjc-runtime/ralplan-runtime.ts +2 -2
package/src/gjc-runtime/tmux-common.ts +8 -0
package/src/gjc-runtime/tmux-sessions.ts +8 -1
package/src/gjc-runtime/workflow-manifest.generated.json +29 -0
package/src/gjc-runtime/workflow-manifest.ts +7 -2
package/src/hashline/hash.ts +1 -1
package/src/internal-urls/docs-index.generated.ts +9 -8
package/src/lsp/config.ts +16 -3
package/src/lsp/defaults.json +7 -0
package/src/lsp/types.ts +2 -0
package/src/modes/controllers/event-controller.ts +15 -0
package/src/modes/interactive-mode.ts +46 -2
package/src/modes/utils/context-usage.ts +2 -2
package/src/notifications/attachment-registry.ts +23 -0
package/src/notifications/chat-adapters.ts +147 -0
package/src/notifications/config.ts +23 -2
package/src/notifications/engine.ts +100 -0
package/src/notifications/index.ts +224 -45
package/src/notifications/managed-daemon.ts +163 -0
package/src/notifications/telegram-daemon.ts +235 -14
package/src/notifications/threaded-inbound.ts +60 -4
package/src/notifications/threaded-render.ts +20 -2
package/src/session/agent-session.ts +82 -51
package/src/tools/ask.ts +3 -2
package/src/tools/fetch.ts +78 -1
package/src/tools/index.ts +3 -0
package/src/tools/telegram-send.ts +137 -0
package/src/web/insane/bridge.ts +350 -0
package/src/web/insane/url-guard.ts +155 -0
package/src/web/search/provider.ts +77 -18
package/src/web/search/providers/anthropic.ts +70 -3
package/src/web/search/providers/codex.ts +1 -119
package/src/web/search/providers/gemini.ts +99 -0
package/src/web/search/providers/insane.ts +551 -0
package/src/web/search/providers/openai-compatible.ts +66 -32
package/src/web/search/providers/text-citations.ts +111 -0
package/src/web/search/types.ts +13 -2
package/vendor/insane-search/LICENSE +21 -0
package/vendor/insane-search/MANIFEST.json +24 -0
package/vendor/insane-search/engine/__init__.py +23 -0
package/vendor/insane-search/engine/__main__.py +128 -0
package/vendor/insane-search/engine/bias_check.py +183 -0
package/vendor/insane-search/engine/executor.py +254 -0
package/vendor/insane-search/engine/fetch_chain.py +725 -0
package/vendor/insane-search/engine/learning.py +175 -0
package/vendor/insane-search/engine/phase0.py +214 -0
package/vendor/insane-search/engine/safety.py +91 -0
package/vendor/insane-search/engine/templates/package.json +11 -0
package/vendor/insane-search/engine/templates/playwright_mobile_chrome.js +188 -0
package/vendor/insane-search/engine/templates/playwright_real_chrome.js +243 -0
package/vendor/insane-search/engine/tests/test_hardening.py +57 -0
package/vendor/insane-search/engine/tests/test_smoke.py +152 -0
package/vendor/insane-search/engine/tests/test_u1.py +200 -0
package/vendor/insane-search/engine/tests/test_u4.py +131 -0
package/vendor/insane-search/engine/tests/test_u5.py +163 -0
package/vendor/insane-search/engine/tests/test_u7.py +124 -0
package/vendor/insane-search/engine/transport.py +211 -0
package/vendor/insane-search/engine/url_transforms.py +98 -0
package/vendor/insane-search/engine/validators.py +331 -0
package/vendor/insane-search/engine/waf_detector.py +214 -0
package/vendor/insane-search/engine/waf_profiles.yaml +162 -0

package/vendor/insane-search/engine/tests/test_u4.py ADDED Viewed

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""U4 tests — SessionPool, root warmup, browser→curl cookie bridge.
+Offline unit tests + a couple of benign online checks (example.com). Run:
+    python3 engine/tests/test_u4.py
+"""
+from __future__ import annotations
+import os
+import sys
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.abspath(os.path.join(HERE, "..", ""))
+sys.path.insert(0, os.path.abspath(os.path.join(HERE, "..", "..")))
+from engine.transport import SessionPool, _host_of, _root_of  # noqa: E402
+from engine.executor import _parse_envelope  # noqa: E402
+def t_host_and_root_helpers():
+    assert _host_of("https://www.x.com/a/b?q=1") == "www.x.com"
+    assert _root_of("https://www.x.com/a/b?q=1") == "https://www.x.com/"
+    print("  ✓ host/root helpers")
+def t_session_reuse_same_key():
+    p = SessionPool()
+    e1 = p.get("www.x.com", "safari")
+    e2 = p.get("www.x.com", "safari")
+    e3 = p.get("www.x.com", "chrome")
+    if e1 is None:
+        print("  ⚠ curl_cffi unavailable — skipped reuse check")
+        return
+    assert e1 is e2, "same (host,impersonate) must reuse entry"
+    assert e1 is not e3, "different impersonate must be separate session"
+    assert p.stats()["sessions"] == 2, p.stats()
+    print(f"  ✓ session reuse (same key→same, diff impersonate→new): {p.stats()}")
+def t_inject_cookies_then_present():
+    p = SessionPool()
+    ok = p.inject_cookies("www.x.com", "chrome",
+                          [{"name": "cf_clearance", "value": "abc", "domain": "www.x.com"}],
+                          user_agent="UA/1.0")
+    ent = p.get("www.x.com", "chrome")
+    if ent is None:
+        print("  ⚠ curl_cffi unavailable — skipped cookie inject check")
+        return
+    assert ok, "inject should report success"
+    assert ent.injected_ua == "UA/1.0"
+    names = {c.name for c in ent.session.cookies.jar}
+    assert "cf_clearance" in names, names
+    print(f"  ✓ injected cookies present on session: {sorted(names)}")
+def t_parse_envelope_json():
+    env = '{"html":"<h1>hi</h1>","finalUrl":"https://x/p","status":200,' \
+          '"cookies":[{"name":"a","value":"b"}],"userAgent":"UA"}'
+    html, final, status, cookies, ua, automation = _parse_envelope(env, "https://x/q")
+    assert html == "<h1>hi</h1>" and final == "https://x/p" and status == 200
+    assert cookies and cookies[0]["name"] == "a" and ua == "UA"
+    print("  ✓ envelope JSON parsed")
+def t_parse_envelope_raw_html_fallback():
+    html, final, status, cookies, ua, automation = _parse_envelope("<html>raw</html>", "https://x/q")
+    assert html == "<html>raw</html>" and final == "https://x/q" and status == 200
+    assert cookies == [] and ua is None
+    print("  ✓ raw-HTML fallback (non-JSON stdout)")
+def t_warmup_once_guard_online():
+    p = SessionPool()
+    first = p.warmup("example.com", "safari", "https://example.com/", timeout=15)
+    second = p.warmup("example.com", "safari", "https://example.com/", timeout=15)
+    ent = p.get("example.com", "safari")
+    if ent is None:
+        print("  ⚠ curl_cffi unavailable — skipped warmup check")
+        return
+    # first may be True (network) or False (offline); second must be False (guard).
+    assert second is False, "warmup must be idempotent"
+    assert ent.warmed is True
+    print(f"  ✓ warmup once-guard (first={first}, second={second})")
+def t_fetch_many_reuses_pool_online():
+    from engine import transport
+    from engine.fetch_chain import fetch_many
+    transport.POOL.reset()
+    results = fetch_many(
+        ["https://example.com/", "https://example.com/index.html"],
+        success_selectors=["h1", "p"], timeout=15, max_attempts=2, enable_playwright=False,
+    )
+    st = transport.POOL.stats()
+    assert len(results) == 2
+    # Same host → should not spawn a separate session per URL per identity.
+    assert st["sessions"] <= 2, st
+    oks = sum(1 for r in results if r.ok)
+    print(f"  ✓ fetch_many reused pool: stats={st}, ok={oks}/2")
+ALL = [
+    ("host_and_root_helpers", t_host_and_root_helpers),
+    ("session_reuse_same_key", t_session_reuse_same_key),
+    ("inject_cookies_then_present", t_inject_cookies_then_present),
+    ("parse_envelope_json", t_parse_envelope_json),
+    ("parse_envelope_raw_html_fallback", t_parse_envelope_raw_html_fallback),
+    ("warmup_once_guard_online", t_warmup_once_guard_online),
+    ("fetch_many_reuses_pool_online", t_fetch_many_reuses_pool_online),
+]
+def main() -> int:
+    p = f = 0
+    for name, fn in ALL:
+        try:
+            print(f"[{name}]")
+            fn()
+            p += 1
+        except AssertionError as e:
+            f += 1
+            print(f"  ✗ FAIL: {e}")
+        except Exception as e:
+            f += 1
+            print(f"  ✗ ERROR: {type(e).__name__}: {e}")
+    print(f"\n{p} passed, {f} failed")
+    return 0 if f == 0 else 1
+if __name__ == "__main__":
+    sys.exit(main())

package/vendor/insane-search/engine/tests/test_u5.py ADDED Viewed

@@ -0,0 +1,163 @@
+"""U5 self-learning store — unit coverage (no network).
+Run:  python3 -m engine.tests.test_u5
+Covers: round-trip, win counting, failure striking + eviction at 2,
+transient vs real-failure classification, TTL prune, LRU cap, key scoping,
+grid priority reordering, and winning-route extraction from a trace."""
+from __future__ import annotations
+import os
+import tempfile
+from datetime import datetime, timezone, timedelta
+from engine import learning
+from engine.fetch_chain import _build_plan, _winning_route, _load_profiles, FetchResult, Attempt
+from engine.validators import Verdict
+_passed = 0
+_failed = 0
+def check(name: str, cond: bool, detail: str = ""):
+    global _passed, _failed
+    if cond:
+        _passed += 1
+        print(f"[{name}]\n  ✓ {detail or 'ok'}")
+    else:
+        _failed += 1
+        print(f"[{name}]\n  ✗ FAIL {detail}")
+def _tmp() -> str:
+    fd, path = tempfile.mkstemp(suffix="_learned.json")
+    os.close(fd)
+    os.unlink(path)  # start empty
+    return path
+U = "https://example.com/some/page"
+ROUTE_A = {"transform": "original", "impersonate": "chrome", "referer": "self_root", "phase": "grid"}
+ROUTE_B = {"transform": "mobile_subdomain", "impersonate": "safari_ios", "referer": "none", "phase": "grid"}
+# 1) round-trip + win counting
+p = _tmp()
+learning.record_success(U, "desktop", ROUTE_A, path=p)
+check("roundtrip_lookup", learning.lookup(U, "desktop", path=p) == ROUTE_A,
+      f"learned route returned: {learning.lookup(U, 'desktop', path=p)}")
+learning.record_success(U, "desktop", ROUTE_A, path=p)
+data = learning.load(p)
+check("wins_increment_same_route", data[learning.key_for(U, "desktop")]["wins"] == 2,
+      f"wins={data[learning.key_for(U, 'desktop')]['wins']}")
+learning.record_success(U, "desktop", ROUTE_B, path=p)
+data = learning.load(p)
+check("wins_reset_on_new_route", data[learning.key_for(U, "desktop")]["wins"] == 1
+      and learning.lookup(U, "desktop", path=p) == ROUTE_B, "new route replaces, wins=1")
+# 2) transient failure does NOT strike; refreshes last_used
+p = _tmp()
+learning.record_success(U, "desktop", ROUTE_A, path=p)
+learning.record_failure(U, "desktop", penalize=False, path=p)
+data = learning.load(p)
+k = learning.key_for(U, "desktop")
+check("transient_no_strike", k in data and data[k]["consecutive_fails"] == 0,
+      "entry kept, consecutive_fails stays 0 on transient")
+# 3) real failure strikes; evicts after 2
+p = _tmp()
+learning.record_success(U, "desktop", ROUTE_A, path=p)
+learning.record_failure(U, "desktop", penalize=True, path=p)
+data = learning.load(p)
+check("real_failure_strike_1", data[k]["consecutive_fails"] == 1, "1st strike kept, fails=1")
+learning.record_failure(U, "desktop", penalize=True, path=p)
+check("evict_after_2_strikes", learning.lookup(U, "desktop", path=p) is None,
+      "evicted after 2nd consecutive real failure")
+# 3b) success resets the strike counter
+p = _tmp()
+learning.record_success(U, "desktop", ROUTE_A, path=p)
+learning.record_failure(U, "desktop", penalize=True, path=p)
+learning.record_success(U, "desktop", ROUTE_A, path=p)
+data = learning.load(p)
+check("success_resets_strikes", data[k]["consecutive_fails"] == 0, "strike reset to 0 after a win")
+# 4) is_real_failure classification
+real = all(learning.is_real_failure(r) for r in ("exhausted", "challenge", "blocked"))
+nonreal = not any(learning.is_real_failure(r) for r in
+                  ("rate_limited", "unknown", "budget", "auth_required", "not_found", "success", ""))
+check("classify_real_failures", real and nonreal,
+      "exhausted/challenge/blocked strike; 429/unknown/budget/auth/404 do not")
+# 5) TTL prune on load (monkeypatch a small TTL)
+p = _tmp()
+old_ttl = learning.TTL_DAYS
+learning.TTL_DAYS = 30
+stale_ts = (datetime.now(timezone.utc) - timedelta(days=31)).isoformat()
+fresh_ts = datetime.now(timezone.utc).isoformat()
+learning.save({
+    "stale.com::desktop": {"route": ROUTE_A, "wins": 1, "consecutive_fails": 0,
+                           "last_used": stale_ts, "last_success": stale_ts},
+    "fresh.com::desktop": {"route": ROUTE_B, "wins": 1, "consecutive_fails": 0,
+                           "last_used": fresh_ts, "last_success": fresh_ts},
+}, path=p)
+data = learning.load(p)
+check("ttl_prunes_stale", "stale.com::desktop" not in data and "fresh.com::desktop" in data,
+      f"31-day-old dropped, fresh kept (kept={list(data)})")
+learning.TTL_DAYS = old_ttl
+# 6) LRU cap (monkeypatch small cap)
+p = _tmp()
+old_max = learning.MAX_ENTRIES
+learning.MAX_ENTRIES = 5
+now = datetime.now(timezone.utc)
+big = {}
+for i in range(12):
+    ts = (now - timedelta(minutes=i)).isoformat()  # i=0 newest
+    big[f"h{i}.com::desktop"] = {"route": ROUTE_A, "wins": 1, "consecutive_fails": 0,
+                                 "last_used": ts, "last_success": ts}
+learning.save(big, path=p)
+data = learning.load(p)
+kept_newest = all(f"h{i}.com::desktop" in data for i in range(5))
+check("lru_cap", len(data) == 5 and kept_newest,
+      f"capped to 5, kept 5 most-recent (n={len(data)})")
+learning.MAX_ENTRIES = old_max
+# 7) key scoping: desktop vs mobile distinct; auto == desktop
+check("key_scoping",
+      learning.key_for(U, "mobile") != learning.key_for(U, "desktop")
+      and learning.key_for(U, "auto") == learning.key_for(U, "desktop"),
+      "mobile/desktop separate; auto folds into desktop")
+# 8) grid priority reordering (no network)
+profiles = _load_profiles()
+hits = [type("H", (), {"profile_id": "unknown_challenge", "confidence": 0.5})()]
+plan = _build_plan(U, hits, profiles, "desktop", "safari", "self_root")
+target = plan[min(3, len(plan) - 1)]
+prio = {"transform": target.transform, "impersonate": target.impersonate, "referer": target.referer}
+plan2 = _build_plan(U, hits, profiles, "desktop", "safari", "self_root", priority=prio)
+check("priority_moves_to_front",
+      plan2[0].transform == target.transform and plan2[0].impersonate == target.impersonate
+      and plan2[0].referer == target.referer and len(plan2) == len(plan),
+      "learned candidate promoted to plan[0], no items lost")
+# 9) winning-route extraction from trace
+r_ok = FetchResult(ok=True, trace=[
+    Attempt(phase="probe", executor="curl_cffi", url=U, url_transform="original",
+            impersonate="safari", referer="self_root", verdict=Verdict.CHALLENGE.value),
+    Attempt(phase="grid", executor="curl_cffi", url=U, url_transform="mobile_subdomain",
+            impersonate="chrome", referer="none", verdict=Verdict.STRONG_OK.value),
+])
+check("winning_route_from_grid",
+      _winning_route(r_ok) == {"transform": "mobile_subdomain", "impersonate": "chrome",
+                               "referer": "none", "phase": "grid"},
+      f"extracted: {_winning_route(r_ok)}")
+r_browser = FetchResult(ok=True, trace=[
+    Attempt(phase="fallback", executor="playwright_real_chrome", url=U, url_transform="original",
+            impersonate=None, referer="", verdict=Verdict.STRONG_OK.value),
+])
+check("winning_route_skips_browser", _winning_route(r_browser) is None,
+      "browser-only win is not learnable (None)")
+print(f"\n{_passed} passed, {_failed} failed")
+import sys
+sys.exit(1 if _failed else 0)

package/vendor/insane-search/engine/tests/test_u7.py ADDED Viewed

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""U7 tests — SSRF / redirect guard. Offline & deterministic.
+Run:  python3 engine/tests/test_u7.py
+"""
+from __future__ import annotations
+import os
+import sys
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, os.path.abspath(os.path.join(HERE, "..", "..")))
+from engine.safety import classify_url            # noqa: E402
+from engine.transport import SessionPool          # noqa: E402
+def t_classify_blocks_internal():
+    blocked = [
+        "http://127.0.0.1/",
+        "http://169.254.169.254/latest/meta-data/",   # cloud metadata
+        "http://10.0.0.1/",
+        "http://192.168.1.1/admin",
+        "http://172.16.0.1/",
+        "http://[::1]/",
+        "http://0.0.0.0/",
+        "ftp://example.com/",                          # scheme
+        "file:///etc/passwd",                          # scheme
+        "http://localhost/",                           # resolves to loopback
+    ]
+    for u in blocked:
+        ok, reason = classify_url(u, allow_private=False)
+        assert not ok, f"should block {u} (got ok, reason={reason})"
+    print(f"  ✓ blocks {len(blocked)} internal/metadata/scheme targets")
+def t_classify_allows_public():
+    for u in ["https://1.1.1.1/", "http://8.8.8.8/"]:   # public IP literals (no DNS)
+        ok, reason = classify_url(u, allow_private=False)
+        assert ok, f"should allow public {u} ({reason})"
+    print("  ✓ allows public IP literals")
+def t_allow_private_optin():
+    ok, _ = classify_url("http://127.0.0.1:8080/", allow_private=True)
+    assert ok, "allow_private=True must permit loopback"
+    print("  ✓ allow_private=True opt-in permits loopback (local testing)")
+def t_request_blocks_localhost_by_default():
+    p = SessionPool()
+    resp, err = p.request("http://127.0.0.1:9/", impersonate="chrome")  # no fetch happens
+    assert resp is None and err and err.startswith("ssrf_blocked"), (resp, err)
+    print(f"  ✓ POOL.request blocks loopback pre-fetch: {err}")
+class _FakeResp:
+    def __init__(self, status, headers=None):
+        self.status_code = status
+        self.headers = headers or {}
+        self.text = "ok"
+def t_redirect_to_metadata_blocked():
+    def do_get(u):
+        if "evil" in u:
+            return _FakeResp(302, {"Location": "http://169.254.169.254/latest/meta-data/"})
+        return _FakeResp(200)
+    resp, err = SessionPool._fetch_following(do_get, "https://evil.test/", False, 5, None)
+    assert resp is None and err and err.startswith("ssrf_redirect_blocked"), (resp, err)
+    print(f"  ✓ redirect into metadata IP blocked: {err}")
+def t_safe_redirect_followed():
+    hops = {"n": 0}
+    def do_get(u):
+        hops["n"] += 1
+        if "start" in u:
+            return _FakeResp(302, {"Location": "http://1.1.1.1/landing"})  # public
+        return _FakeResp(200)
+    resp, err = SessionPool._fetch_following(do_get, "https://start.test/", False, 5, None)
+    assert err is None and resp is not None and resp.status_code == 200, (resp, err)
+    assert hops["n"] == 2, hops
+    print(f"  ✓ safe redirect to public IP followed ({hops['n']} hops → 200)")
+def t_too_many_redirects():
+    def do_get(u):
+        return _FakeResp(302, {"Location": "http://1.1.1.1/loop"})
+    resp, err = SessionPool._fetch_following(do_get, "http://1.1.1.1/loop", False, 3, None)
+    assert resp is None and err == "too_many_redirects", (resp, err)
+    print("  ✓ redirect loop capped (too_many_redirects)")
+ALL = [
+    ("classify_blocks_internal", t_classify_blocks_internal),
+    ("classify_allows_public", t_classify_allows_public),
+    ("allow_private_optin", t_allow_private_optin),
+    ("request_blocks_localhost_by_default", t_request_blocks_localhost_by_default),
+    ("redirect_to_metadata_blocked", t_redirect_to_metadata_blocked),
+    ("safe_redirect_followed", t_safe_redirect_followed),
+    ("too_many_redirects", t_too_many_redirects),
+]
+def main() -> int:
+    p = f = 0
+    for name, fn in ALL:
+        try:
+            print(f"[{name}]")
+            fn()
+            p += 1
+        except AssertionError as e:
+            f += 1
+            print(f"  ✗ FAIL: {e}")
+        except Exception as e:
+            f += 1
+            print(f"  ✗ ERROR: {type(e).__name__}: {e}")
+    print(f"\n{p} passed, {f} failed")
+    return 0 if f == 0 else 1
+if __name__ == "__main__":
+    sys.exit(main())

package/vendor/insane-search/engine/transport.py ADDED Viewed

@@ -0,0 +1,211 @@
+"""Per-host curl_cffi Session pool + root warmup + browser→curl cookie bridge.
+Why (multi-AI review 2026-06-21):
+  * v1 issued a brand-new `curl_cffi.requests.get()` per attempt, so cookies
+    set by a WAF (e.g. an Akamai `_abck` sensor or a CF `cf_clearance`) and
+    the warm TLS/connection were thrown away between attempts and between
+    pages of the same host. That caps both success rate (sensor cookies never
+    mature) and throughput (handshake per request).
+  * A browser fallback that punches through a JS challenge produces exactly the
+    cookies + User-Agent a plain HTTP client needs — but v1 discarded them
+    (`_FakeResp` kept only HTML). The bridge here lets one expensive browser
+    pass convert into cheap curl_cffi throughput (the FlareSolverr pattern).
+No-Site-Name Rule: keys are hashed hosts; no site names are stored or branched.
+"""
+from __future__ import annotations
+import os
+import threading
+from dataclasses import dataclass, field
+from typing import Any, Optional
+from urllib.parse import urlsplit
+def _host_of(url: str) -> str:
+    return (urlsplit(url).hostname or "unknown").lower()
+def _root_of(url: str) -> str:
+    p = urlsplit(url)
+    return f"{p.scheme}://{p.netloc}/"
+@dataclass
+class _Entry:
+    session: Any
+    warmed: bool = False
+    injected_ua: Optional[str] = None
+    requests_made: int = 0
+@dataclass
+class SessionPool:
+    """Thread-safe pool of curl_cffi Sessions keyed by (host, impersonate)."""
+    _entries: dict = field(default_factory=dict)
+    _lock: Any = field(default_factory=threading.Lock)
+    def _key(self, host: str, impersonate: str) -> tuple:
+        return (host, impersonate)
+    def get(self, host: str, impersonate: str) -> Optional[_Entry]:
+        """Return (creating if needed) the pool entry, or None if curl_cffi
+        is unavailable."""
+        key = self._key(host, impersonate)
+        with self._lock:
+            ent = self._entries.get(key)
+            if ent is not None:
+                return ent
+            try:
+                from curl_cffi import requests as cffi_requests
+            except ImportError:
+                return None
+            try:
+                sess = cffi_requests.Session(impersonate=impersonate)
+            except Exception:
+                # Some impersonate names need a newer curl_cffi; let caller
+                # fall back to a one-shot get by returning None.
+                return None
+            ent = _Entry(session=sess)
+            self._entries[key] = ent
+            return ent
+    def warmup(self, host: str, impersonate: str, root_url: str, timeout: int = 15) -> bool:
+        """Hit the site root once per (host, impersonate) so a WAF sensor can
+        set a resolved session cookie before the real (deep) request. Idempotent."""
+        ent = self.get(host, impersonate)
+        if ent is None or ent.warmed:
+            return False
+        from . import safety
+        ok, _reason = safety.classify_url(root_url, safety.allow_private_default())
+        if not ok:
+            ent.warmed = True   # don't retry a blocked root
+            return False
+        ent.warmed = True  # mark first to avoid duplicate warmups under race
+        def _do_get(u):
+            return ent.session.get(u, timeout=timeout, allow_redirects=False)
+        resp, err = self._fetch_following(_do_get, root_url, allow_private, DEFAULT_MAX_REDIRECTS, ent)
+        return resp is not None and err is None
+    def inject_cookies(self, host: str, impersonate: str,
+                       cookies: list[dict], user_agent: Optional[str] = None) -> bool:
+        """Seed a session with cookies harvested by a real browser. Subsequent
+        requests on this (host, impersonate) reuse the browser-cleared state."""
+        ent = self.get(host, impersonate)
+        if ent is None:
+            return False
+        ok = False
+        for c in cookies or []:
+            name = c.get("name")
+            value = c.get("value")
+            if not name:
+                continue
+            try:
+                ent.session.cookies.set(name, value, domain=c.get("domain") or host)
+                ok = True
+            except Exception:
+                try:
+                    ent.session.cookies.set(name, value)
+                    ok = True
+                except Exception:
+                    continue
+        if user_agent:
+            ent.injected_ua = user_agent
+        return ok
+    def request(self, url: str, *, impersonate: str, referer: str = "",
+                timeout: int = 25, extra_headers: Optional[dict] = None,
+                allow_private: Optional[bool] = None,
+                max_redirects: Optional[int] = None) -> tuple[Any, Optional[str]]:
+        """GET via the pooled session (cookie + connection reuse), with an SSRF
+        guard: the initial URL and EVERY redirect hop are validated against the
+        private/loopback/link-local/metadata block-list before being fetched.
+        Falls back to a one-shot get if no session could be created."""
+        from . import safety
+        if allow_private is None:
+            allow_private = safety.allow_private_default()
+        if max_redirects is None:
+            max_redirects = safety.DEFAULT_MAX_REDIRECTS
+        ok, reason = safety.classify_url(url, allow_private)
+        if not ok:
+            return None, f"ssrf_blocked:{reason}"
+        host = _host_of(url)
+        headers = {
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            "Accept-Language": "ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7",
+        }
+        if referer:
+            headers["Referer"] = referer
+        if extra_headers:
+            headers.update(extra_headers)
+        ent = self.get(host, impersonate)
+        if ent is None:
+            try:
+                from curl_cffi import requests as cffi_requests
+            except ImportError:
+                return None, "curl_cffi not installed"
+            def _do_get(u):
+                return cffi_requests.get(u, impersonate=impersonate, headers=headers,
+                                         timeout=timeout, allow_redirects=False)
+            return self._fetch_following(_do_get, url, allow_private, max_redirects, None)
+        if ent.injected_ua:
+            headers.setdefault("User-Agent", ent.injected_ua)
+        def _do_get(u):
+            return ent.session.get(u, headers=headers, timeout=timeout, allow_redirects=False)
+        return self._fetch_following(_do_get, url, allow_private, max_redirects, ent)
+    @staticmethod
+    def _fetch_following(do_get, url: str, allow_private: bool, max_redirects: int,
+                         ent) -> tuple[Any, Optional[str]]:
+        """Manually follow redirects so each hop is SSRF-validated (curl_cffi's
+        own allow_redirects=True would skip the per-hop check)."""
+        from . import safety
+        cur = url
+        for _ in range(max_redirects + 1):
+            try:
+                resp = do_get(cur)
+            except Exception as e:
+                return None, f"{type(e).__name__}:{str(e)[:200]}"
+            if ent is not None:
+                ent.requests_made += 1
+            if safety.is_redirect(resp):
+                loc = safety.location_of(resp)
+                if not loc:
+                    return resp, None     # redirect w/o Location → return as-is
+                nxt = safety.resolve_redirect(cur, loc)
+                ok, reason = safety.classify_url(nxt, allow_private)
+                if not ok:
+                    return None, f"ssrf_redirect_blocked:{reason}"
+                cur = nxt
+                continue
+            return resp, None
+        return None, "too_many_redirects"
+    def stats(self) -> dict:
+        with self._lock:
+            return {
+                "sessions": len(self._entries),
+                "warmed": sum(1 for e in self._entries.values() if e.warmed),
+                "requests": sum(e.requests_made for e in self._entries.values()),
+            }
+    def reset(self) -> None:
+        with self._lock:
+            for e in self._entries.values():
+                try:
+                    e.session.close()
+                except Exception:
+                    pass
+            self._entries.clear()
+# Process-wide pool. Disable via INSANE_NO_SESSION_POOL=1 (one-shot mode).
+POOL = SessionPool()
+def pool_enabled() -> bool:
+    return os.environ.get("INSANE_NO_SESSION_POOL", "") not in ("1", "true", "yes")