Skip to content

Give your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.

6.3 KB
Raw Blame
"""Site-scoped local session reuse. Source browsers are read-only and never cloned.

The user removed the dedicated-only policy. Use existing connected browsers,
then saved Reach state, before requesting a human login. No password/keychain API.
"""
from __future__ import annotations

import json
import time

from agent_reach.utils.paths import PrivatePathError, read_small_text_no_follow

from . import browser, cdp, state
from .browser_binding import wait_lock
from .result import NEED_SETUP, UPSTREAM_BROKEN, ReachError


def _cookies(rows, domains) -> list:
    out = []
    for row in rows:
        if not isinstance(row, dict) or not row.get("name") or "value" not in row:
            continue
        if not any(cdp.domain_matches(str(row.get("domain", "")), domain) for domain in domains):
            continue
        expires = row.get("expires", row.get("expirationDate", -1))
        if not isinstance(expires, (int, float)) or (0 < expires <= time.time()):
            continue
        cookie = {k: row[k] for k in ("name", "value", "domain", "path", "secure", "httpOnly") if k in row}
        cookie["expires"] = expires
        same = {"no_restriction": "None", "lax": "Lax", "strict": "Strict",
                "None": "None", "Lax": "Lax", "Strict": "Strict"}.get(str(row.get("sameSite", "")))
        if same:
            cookie["sameSite"] = same
        out.append(cookie)
    return out


def profiles() -> list:
    return [{"id": context, "dedicated": context == browser.bound_context()}
            for context in browser.connected_contexts()]


def use(profile: str) -> dict:
    if profile == browser.bound_context() or profile not in browser.connected_contexts():
        raise ReachError(NEED_SETUP, "Choose a connected local browser profile from browser profiles")
    def select(data):
        data["local_browser_source"] = profile
        data["session_reuse"] = {name: record for name, record in data.get("session_reuse", {}).items()
                                 if record.get("blocked") or record.get("source") == "manual"}
    state.mutate(select)
    return {"source_profile": profile, "scope": "requested site only", "source_changed": False}


def _source_cookies(channel: str, domains) -> tuple[list, str]:
    from agent_reach.backends.opencli import export_site_cookies
    try:
        contexts = [p["id"] for p in profiles() if not p["dedicated"]]
    except ReachError as exc:
        if exc.code != NEED_SETUP:
            raise
        # Native CLI sessions remain usable when optional OpenCLI/source
        # discovery is absent or incompatible. Account ambiguity below still
        # requires a choice rather than silently using another account.
        contexts = []
    preferred = state.load().get("local_browser_source")
    if preferred:
        contexts = [preferred] if preferred in contexts else []
    found = []
    for context in contexts:
        try:
            cookies = _cookies([c for domain in domains for c in export_site_cookies(context, domain)], domains)
        except ReachError:
            continue  # a disconnected source must not prevent use of saved Reach login
        if cookies:
            found.append((cookies, context))
    if len(found) > 1:
        raise ReachError(NEED_SETUP, "Several local browsers have cookies for this site; choose which account to reuse",
                         hint="Run agent-reach browser profiles, then browser use ID. No account was copied.")
    if found:
        return found[0]
    # Older Reach versions stored the user's login in a per-site owned snapshot.
    source = state.root() / "sessions" / (channel + "-cloak") / "profile" / "reach-session.json"
    try:
        data = json.loads(read_small_text_no_follow(source, max_bytes=2 * 1024 * 1024) or "{}")
        cookies = _cookies(data.get("cookies", []), domains)
    except (OSError, ValueError, PrivatePathError):
        cookies = []
    return cookies, "saved-reach-session" if cookies else "saved-profile"


def prepare(channel: str, *, force: bool = False) -> dict:
    """Reuse an imported site session until explicitly refreshed; verify access separately."""
    from .manage import _channel, site_domains
    ch = _channel(channel)
    if not ch.login_url:
        return {"source": "not_required", "copied_cookies": 0}
    # One copy per site at a time; queries of other sites keep running.
    with wait_lock(f"session:{channel}"):
        browser.ensure_running()
        record = state.load().get("session_reuse", {}).get(channel, {})
        if not force and (record.get("blocked") or record.get("source") == "manual"
                          or (record.get("cookie_snapshot") == 1 and record.get("copied_cookies", 0) > 0)):
            return record
        cookies, source = _source_cookies(channel, site_domains(ch))
        if cookies:
            current = cdp.call("Storage.getCookies")
            if current is None:
                raise ReachError(UPSTREAM_BROKEN, "Could not inspect the saved site session; the original browser is unchanged")
            previous = _cookies(current.get("cookies", []), site_domains(ch))
            def key(cookie):
                return cookie.get("name"), cookie.get("domain"), cookie.get("path", "/")
            incoming = {key(c) for c in cookies}
            # The source is a site snapshot, not an overlay onto another account.
            # Expire destination-only cookies (including stale UI preferences),
            # preserving all other sites and every cookie supplied by the source.
            stale = [{**c, "value": "", "expires": 1} for c in previous if key(c) not in incoming]
            if cdp.call("Storage.setCookies", {"cookies": stale + cookies}) is None:
                old = {key(c) for c in previous}
                rollback = [{**c, "value": "", "expires": 1} for c in cookies if key(c) not in old] + previous
                cdp.call("Storage.setCookies", {"cookies": rollback})
                raise ReachError(UPSTREAM_BROKEN, "Could not apply the local site session; saved state retained and the original browser is unchanged")
            browser.save_session()
        result = {"source": source, "copied_cookies": len(cookies), "at": state.now(),
                  "verified": False, "source_changed": False, "cookie_snapshot": 1}
        state.mutate(lambda data: data.setdefault("session_reuse", {}).__setitem__(channel, result))
        return result