Struct BrowserDetector 

pub struct BrowserDetector { /* private fields */ }

Implementations

impl BrowserDetector

pub fn new() -> Self

Examples found in repository

examples/test_copilot.rs (line 5)

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) {
            match CookieReader::read_cookies(&prof, "github.com") {
                Ok(cookies) => {
                    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(|c| c.value.as_str())
                        .unwrap_or("unknown");
                    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);
                        }
                    }
                }
                Err(_) => {}
            }
        }
    }

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

pub fn detect_browsers(&self) -> Vec<BrowserType>

Examples found in repository

examples/test_copilot.rs (line 6)

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) {
            match CookieReader::read_cookies(&prof, "github.com") {
                Ok(cookies) => {
                    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(|c| c.value.as_str())
                        .unwrap_or("unknown");
                    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);
                        }
                    }
                }
                Err(_) => {}
            }
        }
    }

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

pub fn get_browser_base_path( &self, browser_type: BrowserType, ) -> Option<PathBuf>

pub fn list_profiles(&self, browser_type: BrowserType) -> Vec<Profile>

Examples found in repository

examples/test_copilot.rs (line 12)

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) {
            match CookieReader::read_cookies(&prof, "github.com") {
                Ok(cookies) => {
                    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(|c| c.value.as_str())
                        .unwrap_or("unknown");
                    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);
                        }
                    }
                }
                Err(_) => {}
            }
        }
    }

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

pub fn get_profile( &self, browser_type: BrowserType, profile_name: Option<&str>, ) -> Option<Profile>

Trait Implementations

impl Default for BrowserDetector

fn default() -> Self

Returns the “default value” for a type.