Skip to main content

BrowserDetector

seher::browser::detector

Struct BrowserDetector 

Source 
pub struct BrowserDetector { /* private fields */ }

Implementations§

Source§

impl BrowserDetector

Source

pub fn new() -> Self

Examples found in repository?
examples/test_opencode_go.rs (line 10)
9async fn main() {
10    let detector = BrowserDetector::new();
11    let browsers = detector.detect_browsers();
12
13    for browser in &browsers {
14        for prof in detector.list_profiles(*browser) {
15            let Ok(cookies) = CookieReader::read_cookies(&prof, "opencode.ai") else {
16                continue;
17            };
18            let has_auth = cookies
19                .iter()
20                .any(|c| c.name == "auth" || c.name == "__Host-auth");
21            if !has_auth {
22                continue;
23            }
24            println!(
25                "Using {} - {} ({} opencode.ai cookies)",
26                browser.name(),
27                prof.name,
28                cookies.len(),
29            );
30            match seher::opencode_go::fetch_remote_usage(&cookies).await {
31                Ok(usage) => {
32                    println!("\nSuccess! OpenCode Go usage (hosted dashboard):");
33                    for w in &usage.windows {
34                        println!(
35                            "  {:<8} {:>6.1}%  reset_in_sec={:?}  limited={}",
36                            w.name,
37                            w.used_percent,
38                            w.reset_in_sec,
39                            w.is_limited()
40                        );
41                    }
42                    println!("  => limited: {}", usage.is_limited());
43                    return;
44                }
45                Err(e) => {
46                    println!("\nFailed to fetch OpenCode Go usage: {e}");
47                }
48            }
49        }
50    }
51
52    println!("No opencode.ai session cookie (auth / __Host-auth) found in any browser");
53}
More examples
Hide additional examples
examples/test_copilot.rs (line 5)
4async fn main() {
5    let detector = BrowserDetector::new();
6    let browsers = detector.detect_browsers();
7
8    for browser in &browsers {
9        if !browser.is_chromium_based() {
10            continue;
11        }
12        for prof in detector.list_profiles(*browser) {
13            if let Ok(cookies) = CookieReader::read_cookies(&prof, "github.com") {
14                let has_user_session = cookies
15                    .iter()
16                    .any(|c| c.name == "user_session" || c.name == "__Host-user_session_same_site");
17
18                if !has_user_session {
19                    continue;
20                }
21
22                let dotcom_user = cookies
23                    .iter()
24                    .find(|c| c.name == "dotcom_user")
25                    .map_or("unknown", |c| c.value.as_str());
26                println!(
27                    "Using {} - {} ({} cookies, user={})",
28                    browser.name(),
29                    prof.name,
30                    cookies.len(),
31                    dotcom_user
32                );
33
34                match seher::copilot::CopilotClient::fetch_quota(&cookies).await {
35                    Ok(quota) => {
36                        println!("\nSuccess! Copilot quota:");
37                        println!("  chat_utilization: {:.1}%", quota.chat_utilization);
38                        println!("  premium_utilization: {:.1}%", quota.premium_utilization);
39                        println!("  reset_time: {:?}", quota.reset_time);
40                        println!("  is_limited: {}", quota.is_limited());
41                        return;
42                    }
43                    Err(e) => {
44                        println!("\nFailed to fetch Copilot quota: {e}");
45                    }
46                }
47            }
48        }
49    }
50
51    println!("No github.com session with user_session cookie found");
52}
examples/test_codex.rs (line 5)
4async fn main() {
5    let detector = BrowserDetector::new();
6    let browsers = detector.detect_browsers();
7
8    for browser in &browsers {
9        if !browser.is_chromium_based() {
10            continue;
11        }
12        for prof in detector.list_profiles(*browser) {
13            if let Ok(cookies) = CookieReader::read_cookies(&prof, "chatgpt.com") {
14                let has_session = cookies
15                    .iter()
16                    .any(|c| c.name.starts_with("__Secure-next-auth.session-token"));
17
18                if !has_session {
19                    continue;
20                }
21
22                println!(
23                    "Using {} - {} ({} cookies)",
24                    browser.name(),
25                    prof.name,
26                    cookies.len(),
27                );
28
29                match seher::codex::CodexClient::fetch_usage(&cookies).await {
30                    Ok(usage) => {
31                        println!("\nSuccess! Codex usage:");
32                        println!("  plan_type: {}", usage.plan_type);
33                        println!("  rate_limit limited: {}", usage.rate_limit.is_limited());
34                        println!(
35                            "  rate_limit reset_time: {:?}",
36                            usage.rate_limit.next_reset_time()
37                        );
38                        println!(
39                            "  code_review limited: {}",
40                            usage
41                                .code_review_rate_limit
42                                .as_ref()
43                                .is_some_and(seher::CodexRateLimit::is_limited)
44                        );
45                        return;
46                    }
47                    Err(e) => {
48                        println!("\nFailed to fetch Codex usage: {e}");
49                    }
50                }
51            }
52        }
53    }
54
55    println!("No chatgpt.com session with __Secure-next-auth.session-token found");
56}
Source

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

Examples found in repository?
examples/test_opencode_go.rs (line 11)
9async fn main() {
10    let detector = BrowserDetector::new();
11    let browsers = detector.detect_browsers();
12
13    for browser in &browsers {
14        for prof in detector.list_profiles(*browser) {
15            let Ok(cookies) = CookieReader::read_cookies(&prof, "opencode.ai") else {
16                continue;
17            };
18            let has_auth = cookies
19                .iter()
20                .any(|c| c.name == "auth" || c.name == "__Host-auth");
21            if !has_auth {
22                continue;
23            }
24            println!(
25                "Using {} - {} ({} opencode.ai cookies)",
26                browser.name(),
27                prof.name,
28                cookies.len(),
29            );
30            match seher::opencode_go::fetch_remote_usage(&cookies).await {
31                Ok(usage) => {
32                    println!("\nSuccess! OpenCode Go usage (hosted dashboard):");
33                    for w in &usage.windows {
34                        println!(
35                            "  {:<8} {:>6.1}%  reset_in_sec={:?}  limited={}",
36                            w.name,
37                            w.used_percent,
38                            w.reset_in_sec,
39                            w.is_limited()
40                        );
41                    }
42                    println!("  => limited: {}", usage.is_limited());
43                    return;
44                }
45                Err(e) => {
46                    println!("\nFailed to fetch OpenCode Go usage: {e}");
47                }
48            }
49        }
50    }
51
52    println!("No opencode.ai session cookie (auth / __Host-auth) found in any browser");
53}
More examples
Hide additional examples
examples/test_copilot.rs (line 6)
4async fn main() {
5    let detector = BrowserDetector::new();
6    let browsers = detector.detect_browsers();
7
8    for browser in &browsers {
9        if !browser.is_chromium_based() {
10            continue;
11        }
12        for prof in detector.list_profiles(*browser) {
13            if let Ok(cookies) = CookieReader::read_cookies(&prof, "github.com") {
14                let has_user_session = cookies
15                    .iter()
16                    .any(|c| c.name == "user_session" || c.name == "__Host-user_session_same_site");
17
18                if !has_user_session {
19                    continue;
20                }
21
22                let dotcom_user = cookies
23                    .iter()
24                    .find(|c| c.name == "dotcom_user")
25                    .map_or("unknown", |c| c.value.as_str());
26                println!(
27                    "Using {} - {} ({} cookies, user={})",
28                    browser.name(),
29                    prof.name,
30                    cookies.len(),
31                    dotcom_user
32                );
33
34                match seher::copilot::CopilotClient::fetch_quota(&cookies).await {
35                    Ok(quota) => {
36                        println!("\nSuccess! Copilot quota:");
37                        println!("  chat_utilization: {:.1}%", quota.chat_utilization);
38                        println!("  premium_utilization: {:.1}%", quota.premium_utilization);
39                        println!("  reset_time: {:?}", quota.reset_time);
40                        println!("  is_limited: {}", quota.is_limited());
41                        return;
42                    }
43                    Err(e) => {
44                        println!("\nFailed to fetch Copilot quota: {e}");
45                    }
46                }
47            }
48        }
49    }
50
51    println!("No github.com session with user_session cookie found");
52}
examples/test_codex.rs (line 6)
4async fn main() {
5    let detector = BrowserDetector::new();
6    let browsers = detector.detect_browsers();
7
8    for browser in &browsers {
9        if !browser.is_chromium_based() {
10            continue;
11        }
12        for prof in detector.list_profiles(*browser) {
13            if let Ok(cookies) = CookieReader::read_cookies(&prof, "chatgpt.com") {
14                let has_session = cookies
15                    .iter()
16                    .any(|c| c.name.starts_with("__Secure-next-auth.session-token"));
17
18                if !has_session {
19                    continue;
20                }
21
22                println!(
23                    "Using {} - {} ({} cookies)",
24                    browser.name(),
25                    prof.name,
26                    cookies.len(),
27                );
28
29                match seher::codex::CodexClient::fetch_usage(&cookies).await {
30                    Ok(usage) => {
31                        println!("\nSuccess! Codex usage:");
32                        println!("  plan_type: {}", usage.plan_type);
33                        println!("  rate_limit limited: {}", usage.rate_limit.is_limited());
34                        println!(
35                            "  rate_limit reset_time: {:?}",
36                            usage.rate_limit.next_reset_time()
37                        );
38                        println!(
39                            "  code_review limited: {}",
40                            usage
41                                .code_review_rate_limit
42                                .as_ref()
43                                .is_some_and(seher::CodexRateLimit::is_limited)
44                        );
45                        return;
46                    }
47                    Err(e) => {
48                        println!("\nFailed to fetch Codex usage: {e}");
49                    }
50                }
51            }
52        }
53    }
54
55    println!("No chatgpt.com session with __Secure-next-auth.session-token found");
56}
Source

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

Source

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

Examples found in repository?
examples/test_opencode_go.rs (line 14)
9async fn main() {
10    let detector = BrowserDetector::new();
11    let browsers = detector.detect_browsers();
12
13    for browser in &browsers {
14        for prof in detector.list_profiles(*browser) {
15            let Ok(cookies) = CookieReader::read_cookies(&prof, "opencode.ai") else {
16                continue;
17            };
18            let has_auth = cookies
19                .iter()
20                .any(|c| c.name == "auth" || c.name == "__Host-auth");
21            if !has_auth {
22                continue;
23            }
24            println!(
25                "Using {} - {} ({} opencode.ai cookies)",
26                browser.name(),
27                prof.name,
28                cookies.len(),
29            );
30            match seher::opencode_go::fetch_remote_usage(&cookies).await {
31                Ok(usage) => {
32                    println!("\nSuccess! OpenCode Go usage (hosted dashboard):");
33                    for w in &usage.windows {
34                        println!(
35                            "  {:<8} {:>6.1}%  reset_in_sec={:?}  limited={}",
36                            w.name,
37                            w.used_percent,
38                            w.reset_in_sec,
39                            w.is_limited()
40                        );
41                    }
42                    println!("  => limited: {}", usage.is_limited());
43                    return;
44                }
45                Err(e) => {
46                    println!("\nFailed to fetch OpenCode Go usage: {e}");
47                }
48            }
49        }
50    }
51
52    println!("No opencode.ai session cookie (auth / __Host-auth) found in any browser");
53}
More examples
Hide additional examples
examples/test_copilot.rs (line 12)
4async fn main() {
5    let detector = BrowserDetector::new();
6    let browsers = detector.detect_browsers();
7
8    for browser in &browsers {
9        if !browser.is_chromium_based() {
10            continue;
11        }
12        for prof in detector.list_profiles(*browser) {
13            if let Ok(cookies) = CookieReader::read_cookies(&prof, "github.com") {
14                let has_user_session = cookies
15                    .iter()
16                    .any(|c| c.name == "user_session" || c.name == "__Host-user_session_same_site");
17
18                if !has_user_session {
19                    continue;
20                }
21
22                let dotcom_user = cookies
23                    .iter()
24                    .find(|c| c.name == "dotcom_user")
25                    .map_or("unknown", |c| c.value.as_str());
26                println!(
27                    "Using {} - {} ({} cookies, user={})",
28                    browser.name(),
29                    prof.name,
30                    cookies.len(),
31                    dotcom_user
32                );
33
34                match seher::copilot::CopilotClient::fetch_quota(&cookies).await {
35                    Ok(quota) => {
36                        println!("\nSuccess! Copilot quota:");
37                        println!("  chat_utilization: {:.1}%", quota.chat_utilization);
38                        println!("  premium_utilization: {:.1}%", quota.premium_utilization);
39                        println!("  reset_time: {:?}", quota.reset_time);
40                        println!("  is_limited: {}", quota.is_limited());
41                        return;
42                    }
43                    Err(e) => {
44                        println!("\nFailed to fetch Copilot quota: {e}");
45                    }
46                }
47            }
48        }
49    }
50
51    println!("No github.com session with user_session cookie found");
52}
examples/test_codex.rs (line 12)
4async fn main() {
5    let detector = BrowserDetector::new();
6    let browsers = detector.detect_browsers();
7
8    for browser in &browsers {
9        if !browser.is_chromium_based() {
10            continue;
11        }
12        for prof in detector.list_profiles(*browser) {
13            if let Ok(cookies) = CookieReader::read_cookies(&prof, "chatgpt.com") {
14                let has_session = cookies
15                    .iter()
16                    .any(|c| c.name.starts_with("__Secure-next-auth.session-token"));
17
18                if !has_session {
19                    continue;
20                }
21
22                println!(
23                    "Using {} - {} ({} cookies)",
24                    browser.name(),
25                    prof.name,
26                    cookies.len(),
27                );
28
29                match seher::codex::CodexClient::fetch_usage(&cookies).await {
30                    Ok(usage) => {
31                        println!("\nSuccess! Codex usage:");
32                        println!("  plan_type: {}", usage.plan_type);
33                        println!("  rate_limit limited: {}", usage.rate_limit.is_limited());
34                        println!(
35                            "  rate_limit reset_time: {:?}",
36                            usage.rate_limit.next_reset_time()
37                        );
38                        println!(
39                            "  code_review limited: {}",
40                            usage
41                                .code_review_rate_limit
42                                .as_ref()
43                                .is_some_and(seher::CodexRateLimit::is_limited)
44                        );
45                        return;
46                    }
47                    Err(e) => {
48                        println!("\nFailed to fetch Codex usage: {e}");
49                    }
50                }
51            }
52        }
53    }
54
55    println!("No chatgpt.com session with __Secure-next-auth.session-token found");
56}
Source

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

Trait Implementations§

Source§

impl Default for BrowserDetector

Source§

fn default() -> Self

Returns the “default value” for a type. Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

Source§

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

Source§

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

Source§

fn implicit( self, class: Class, constructed: bool, tag: u32, ) -> TaggedParser<'a, Implicit, Self, E>

Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T> Instrument for T

Source§

fn instrument(self, _span: NoopSpan) -> Self

Instruments this future with a span (no-op when disabled).
Source§

fn in_current_span(self) -> Self

Instruments this future with the current span (no-op when disabled).
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> NoneValue for T
where T: Default,

Source§

type NoneType = T

Source§

fn null_value() -> T

The none-equivalent value.
Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<T> PolicyExt for T
where T: ?Sized,

Source§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow only if self and other return Action::Follow. Read more
Source§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow if either self or other returns Action::Follow. Read more
Source§

impl<R, P> ReadPrimitive<R> for P
where R: Read + ReadEndian<P>, P: Default,

Source§

fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian().
Source§

fn read_from_big_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian().
Source§

fn read_from_native_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian().
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

Source§

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

Source§

impl<T> ParallelSend for T

Source§

impl<T> Read<Exclusive, BecauseExclusive> for T
where T: ?Sized,

Source§

impl<T> Send for T
where T: ?Sized,

Source§

impl<T> Sync for T
where T: ?Sized,