How the Agent Reach `cookie_extract` Module Parses and Imports Browser Cookies for Twitter/X and XiaoHongShu

The agent_reach.cookie_extract module automatically pulls authentication cookies from Chrome, Firefox, Edge, Brave, or Opera, normalizes them through a backend-library abstraction, and maps them into platform-specific configuration values for Twitter/X and XiaoHongShu.

The cookie_extract module in Agent Reach is the bridge between your local browser profile and the framework's configuration layer. Located in the open-source Panniantong/Agent-Reach repository, it removes the need to manually copy cookies by reading them directly from supported browsers and injecting them into the global Config object. This article explains exactly how the module parses and imports browser cookies for Twitter/X and XiaoHongShu based on the source implementation.

Browser Selection and Extraction Backends in Agent Reach

The entry point for all cookie retrieval is extract_all(browser: str = "chrome") inside agent_reach/cookie_extract.py (around lines 70–75). This function validates the requested browser name against an internal allow-list, then proceeds to load the raw cookie store from the user's local profile.

Behind the scenes, the module prefers the Rust-based rookiepy library when available. If rookiepy is not installed, it falls back to browser-cookie3. The dual-path logic is controlled by a use_rookiepy flag set during module initialization (lines 55–68). When the flag is true, the module follows the rookiepy path (lines 78–99); otherwise it uses the browser-cookie3 path (lines 100–114).

How cookie_extract Normalizes Cookie Objects with the _Cookie Wrapper

Because rookiepy returns plain dictionaries while browser-cookie3 returns objects with .name, .value, and .domain attributes, extract_all defines a lightweight _Cookie class (lines 88–94). This wrapper translates rookiepy dicts into uniform objects so that downstream filtering code can consume every cookie through the same interface.

Platform Specifications in PLATFORM_SPECS

The module declares what to extract in a top-level constant named PLATFORM_SPECS (lines 15–28). Each entry specifies target domains, required cookie names, and the configuration key used later in the pipeline.

Twitter/X Cookie Requirements

For Twitter/X, the spec lists the domains ".x.com" and ".twitter.com" and explicitly requires the cookie names auth_token and ct0. These values are mapped to the "twitter" config key.

# Platform spec for Twitter/X

{
    "name": "Twitter/X",
    "domains": [".x.com", ".twitter.com"],
    "cookies": ["auth_token", "ct0"],
    "config_key": "twitter",
}

XiaoHongShu Cookie Requirements

For XiaoHongShu, the spec declares only the domain ".xiaohongshu.com" and sets cookies: None. This sentinel instructs the extractor to gather every cookie for that domain and bundle it into a single header string, stored under the "xhs" config key.

# Platform spec for XiaoHongShu

{
    "name": "XiaoHongShu",
    "domains": [".xiaohongshu.com"],
    "cookies": None,
    "config_key": "xhs",
}

Domain Filtering and Result Construction

Once the cookie jar is loaded and normalized, the module iterates over every cookie and checks whether cookie.domain ends with one of the domains listed in the relevant platform spec (any(cookie.domain.endswith(d) ...)). This domain-matching logic appears around lines 24–27, with the collection logic following at lines 33–36.

Selective Extraction for Twitter/X

When a spec provides an explicit list of cookie names—such as ["auth_token", "ct0"] for Twitter/X—the code retains only those named cookies. The resulting dictionary, for example {"auth_token": "...", "ct0": "..."}, is assigned to results["twitter"] (lines 39–47).

Header String Construction for XiaoHongShu

When cookies is None, as it is for XiaoHongShu, all matching domain cookies are concatenated into a standard header string: "name1=val1; name2=val2; ...". The resulting structure is stored as results["xhs"]["cookie_string"].

The function returns a mapping such as { "twitter": {...}, "xhs": {"cookie_string": "..."} } around lines 48–49.

Writing Cookies to the Agent Reach Config

The public convenience function configure_from_browser() calls extract_all(), then persists the returned values into the global Config object via config.set(...). For Twitter/X, it writes individual keys such as twitter_auth_token and twitter_ct0 (around lines 21–28). For XiaoHongShu, it writes the full header under xhs_cookie (around lines 36–41).

The function also attempts best-effort compatibility writes, including a legacy xfetch session file and a Bird-CLI environment file for Twitter, but these are non-blocking.

CLI and Programmatic Usage

You can trigger the extraction pipeline without writing Python by using the --from-browser flag exposed in agent_reach/cli.py (lines 252–259).

# Extract from Chrome (default)

agent-reach configure --from-browser chrome

# Extract from Firefox

agent-reach configure --from-browser firefox

The CLI prints a concise table showing which platforms succeeded. Programmatically, the same flow looks like this:

from agent_reach.cookie_extract import configure_from_browser
from agent_reach.config import Config

cfg = Config()
report = configure_from_browser("chrome", cfg)

for platform, ok, msg in report:
    print(f"{platform}: {'✅' if ok else '❌'} – {msg}")

# cfg now contains:

#   cfg.get("twitter_auth_token")  → auth_token string

#   cfg.get("twitter_ct0")         → ct0 string

#   cfg.get("xhs_cookie")          → full cookie header string

Summary

• extract_all() in agent_reach/cookie_extract.py validates the browser name, loads cookies via rookiepy (preferred) or browser-cookie3, and normalizes them with a _Cookie wrapper.
• PLATFORM_SPECS (lines 15–28) defines domain and cookie-name rules for each supported platform.
• Twitter/X cookies are selectively filtered for auth_token and ct0 across .x.com and .twitter.com.
• XiaoHongShu cookies are bulk-collected for .xiaohongshu.com and joined into a single cookie_string header.
• configure_from_browser() writes the results into the Agent Reach Config object, and the --from-browser CLI flag exposes the same behavior to terminal users.

Frequently Asked Questions

Which browsers does the Agent Reach cookie_extract module support?

The module supports Chrome, Firefox, Edge, Brave, and Opera. The caller passes the browser name to extract_all(browser: str = "chrome"), which validates it against an internal allow-list before attempting extraction.

What backend libraries does Agent Reach use to read browser cookies?

The source code in agent_reach/cookie_extract.py first attempts to import the Rust-based rookiepy library. If that is unavailable, it transparently falls back to browser-cookie3. Both libraries return the raw cookie data that the module normalizes and filters.

Why does XiaoHongShu use a full cookie header string while Twitter/X uses specific tokens?

The PLATFORM_SPECS constant sets cookies: None for XiaoHongShu and cookies: ["auth_token", "ct0"] for Twitter/X. When cookies is None, the module concatenates every matching domain cookie into a cookie_string. When a list is provided, only those exact names are extracted into a dictionary. This difference reflects the authentication expectations of each platform channel inside Agent Reach.

How do I trigger cookie extraction from the command line?

Run agent-reach configure --from-browser <browser>. This flag is handled in agent_reach/cli.py (lines 252–259) and invokes configure_from_browser(), producing a concise table that shows whether each platform’s cookies were found and imported.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}