Enum BrowserType 

pub enum BrowserType {
    Chrome,
    Edge,
    Brave,
    Chromium,
    Vivaldi,
    Comet,
    Dia,
    Atlas,
    Firefox,
    Safari,
}

Variants

Chrome

Edge

Brave

Chromium

Vivaldi

Comet

Dia

Atlas

Firefox

Safari

Implementations

impl BrowserType

pub fn name(&self) -> &str

Examples found in repository

examples/test_opencode_go.rs (line 26)

async fn main() {
    let detector = BrowserDetector::new();
    let browsers = detector.detect_browsers();

    for browser in &browsers {
        for prof in detector.list_profiles(*browser) {
            let Ok(cookies) = CookieReader::read_cookies(&prof, "opencode.ai") else {
                continue;
            };
            let has_auth = cookies
                .iter()
                .any(|c| c.name == "auth" || c.name == "__Host-auth");
            if !has_auth {
                continue;
            }
            println!(
                "Using {} - {} ({} opencode.ai cookies)",
                browser.name(),
                prof.name,
                cookies.len(),
            );
            match seher::opencode_go::fetch_remote_usage(&cookies).await {
                Ok(usage) => {
                    println!("\nSuccess! OpenCode Go usage (hosted dashboard):");
                    for w in &usage.windows {
                        println!(
                            "  {:<8} {:>6.1}%  reset_in_sec={:?}  limited={}",
                            w.name,
                            w.used_percent,
                            w.reset_in_sec,
                            w.is_limited()
                        );
                    }
                    println!("  => limited: {}", usage.is_limited());
                    return;
                }
                Err(e) => {
                    println!("\nFailed to fetch OpenCode Go usage: {e}");
                }
            }
        }
    }

    println!("No opencode.ai session cookie (auth / __Host-auth) found in any browser");
}

examples/test_copilot.rs (line 28)

async fn main() {
    let detector = BrowserDetector::new();
    let browsers = detector.detect_browsers();

    for browser in &browsers {
        if !browser.is_chromium_based() {
            continue;
        }
        for prof in detector.list_profiles(*browser) {
            if let Ok(cookies) = CookieReader::read_cookies(&prof, "github.com") {
                let has_user_session = cookies
                    .iter()
                    .any(|c| c.name == "user_session" || c.name == "__Host-user_session_same_site");

                if !has_user_session {
                    continue;
                }

                let dotcom_user = cookies
                    .iter()
                    .find(|c| c.name == "dotcom_user")
                    .map_or("unknown", |c| c.value.as_str());
                println!(
                    "Using {} - {} ({} cookies, user={})",
                    browser.name(),
                    prof.name,
                    cookies.len(),
                    dotcom_user
                );

                match seher::copilot::CopilotClient::fetch_quota(&cookies).await {
                    Ok(quota) => {
                        println!("\nSuccess! Copilot quota:");
                        println!("  chat_utilization: {:.1}%", quota.chat_utilization);
                        println!("  premium_utilization: {:.1}%", quota.premium_utilization);
                        println!("  reset_time: {:?}", quota.reset_time);
                        println!("  is_limited: {}", quota.is_limited());
                        return;
                    }
                    Err(e) => {
                        println!("\nFailed to fetch Copilot quota: {e}");
                    }
                }
            }
        }
    }

    println!("No github.com session with user_session cookie found");
}

examples/test_codex.rs (line 24)

async fn main() {
    let detector = BrowserDetector::new();
    let browsers = detector.detect_browsers();

    for browser in &browsers {
        if !browser.is_chromium_based() {
            continue;
        }
        for prof in detector.list_profiles(*browser) {
            if let Ok(cookies) = CookieReader::read_cookies(&prof, "chatgpt.com") {
                let has_session = cookies
                    .iter()
                    .any(|c| c.name.starts_with("__Secure-next-auth.session-token"));

                if !has_session {
                    continue;
                }

                println!(
                    "Using {} - {} ({} cookies)",
                    browser.name(),
                    prof.name,
                    cookies.len(),
                );

                match seher::codex::CodexClient::fetch_usage(&cookies).await {
                    Ok(usage) => {
                        println!("\nSuccess! Codex usage:");
                        println!("  plan_type: {}", usage.plan_type);
                        println!("  rate_limit limited: {}", usage.rate_limit.is_limited());
                        println!(
                            "  rate_limit reset_time: {:?}",
                            usage.rate_limit.next_reset_time()
                        );
                        println!(
                            "  code_review limited: {}",
                            usage
                                .code_review_rate_limit
                                .as_ref()
                                .is_some_and(seher::CodexRateLimit::is_limited)
                        );
                        return;
                    }
                    Err(e) => {
                        println!("\nFailed to fetch Codex usage: {e}");
                    }
                }
            }
        }
    }

    println!("No chatgpt.com session with __Secure-next-auth.session-token found");
}

pub fn is_chromium_based(&self) -> bool

Examples found in repository

examples/test_copilot.rs (line 9)

async fn main() {
    let detector = BrowserDetector::new();
    let browsers = detector.detect_browsers();

    for browser in &browsers {
        if !browser.is_chromium_based() {
            continue;
        }
        for prof in detector.list_profiles(*browser) {
            if let Ok(cookies) = CookieReader::read_cookies(&prof, "github.com") {
                let has_user_session = cookies
                    .iter()
                    .any(|c| c.name == "user_session" || c.name == "__Host-user_session_same_site");

                if !has_user_session {
                    continue;
                }

                let dotcom_user = cookies
                    .iter()
                    .find(|c| c.name == "dotcom_user")
                    .map_or("unknown", |c| c.value.as_str());
                println!(
                    "Using {} - {} ({} cookies, user={})",
                    browser.name(),
                    prof.name,
                    cookies.len(),
                    dotcom_user
                );

                match seher::copilot::CopilotClient::fetch_quota(&cookies).await {
                    Ok(quota) => {
                        println!("\nSuccess! Copilot quota:");
                        println!("  chat_utilization: {:.1}%", quota.chat_utilization);
                        println!("  premium_utilization: {:.1}%", quota.premium_utilization);
                        println!("  reset_time: {:?}", quota.reset_time);
                        println!("  is_limited: {}", quota.is_limited());
                        return;
                    }
                    Err(e) => {
                        println!("\nFailed to fetch Copilot quota: {e}");
                    }
                }
            }
        }
    }

    println!("No github.com session with user_session cookie found");
}

examples/test_codex.rs (line 9)

async fn main() {
    let detector = BrowserDetector::new();
    let browsers = detector.detect_browsers();

    for browser in &browsers {
        if !browser.is_chromium_based() {
            continue;
        }
        for prof in detector.list_profiles(*browser) {
            if let Ok(cookies) = CookieReader::read_cookies(&prof, "chatgpt.com") {
                let has_session = cookies
                    .iter()
                    .any(|c| c.name.starts_with("__Secure-next-auth.session-token"));

                if !has_session {
                    continue;
                }

                println!(
                    "Using {} - {} ({} cookies)",
                    browser.name(),
                    prof.name,
                    cookies.len(),
                );

                match seher::codex::CodexClient::fetch_usage(&cookies).await {
                    Ok(usage) => {
                        println!("\nSuccess! Codex usage:");
                        println!("  plan_type: {}", usage.plan_type);
                        println!("  rate_limit limited: {}", usage.rate_limit.is_limited());
                        println!(
                            "  rate_limit reset_time: {:?}",
                            usage.rate_limit.next_reset_time()
                        );
                        println!(
                            "  code_review limited: {}",
                            usage
                                .code_review_rate_limit
                                .as_ref()
                                .is_some_and(seher::CodexRateLimit::is_limited)
                        );
                        return;
                    }
                    Err(e) => {
                        println!("\nFailed to fetch Codex usage: {e}");
                    }
                }
            }
        }
    }

    println!("No chatgpt.com session with __Secure-next-auth.session-token found");
}

Trait Implementations

impl Clone for BrowserType

fn clone(&self) -> BrowserType

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BrowserType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromStr for BrowserType

type Err = String

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq for BrowserType

fn eq(&self, other: &BrowserType) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for BrowserType

impl Eq for BrowserType

impl StructuralPartialEq for BrowserType