avios-cli 0.1.4__tar.gz → 0.1.5__tar.gz

{avios_cli-0.1.4 → avios_cli-0.1.5}/CHANGELOG.md

@@ -6,6 +6,19 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.1.5] - 2026-07-24
+
+### Fixed
+- **`--from-browser` only read Chrome's `Default` profile.** If you were logged
+  into avios.com in another profile (Profile 1, a work profile, ...), it grabbed
+  the wrong profile's cookies and every call failed with "Session expired". It now
+  **scans all Chrome profiles, verifies which one actually authenticates**
+  (against `/auth-gateway/user`), and uses that — and reports which profile it used.
+
+### Added
+- `avios login --from-browser --profile "Profile 1"` to target a specific browser
+  profile, and a clear warning when the imported cookies aren't a logged-in session.
+
 ## [0.1.4] - 2026-07-24
 
 ### Fixed
@@ -74,7 +87,8 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - Reward-flight **availability** search is not yet implemented (needs a British
   Airways capture).
 
-[Unreleased]: https://github.com/alexechoi/avios-cli/compare/v0.1.4...HEAD
+[Unreleased]: https://github.com/alexechoi/avios-cli/compare/v0.1.5...HEAD
+[0.1.5]: https://github.com/alexechoi/avios-cli/compare/v0.1.4...v0.1.5
 [0.1.4]: https://github.com/alexechoi/avios-cli/compare/v0.1.3...v0.1.4
 [0.1.3]: https://github.com/alexechoi/avios-cli/compare/v0.1.2...v0.1.3
 [0.1.2]: https://github.com/alexechoi/avios-cli/compare/v0.1.1...v0.1.2

{avios_cli-0.1.4 → avios_cli-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: avios-cli
-Version: 0.1.4
+Version: 0.1.5
 Summary: A CLI and TUI for avios.com — view your Avios balance and transactions from the terminal.
 Project-URL: Homepage, https://github.com/alexechoi/avios-cli
 Project-URL: Repository, https://github.com/alexechoi/avios-cli
@@ -97,6 +97,14 @@ into avios.com with:
 uvx --from 'avios-cli[login]' avios login --from-browser
 ```
 
+This scans **all your Chrome profiles** and uses whichever one is actually logged
+into avios.com (it tells you which). If you have several profiles, you can target
+one directly:
+
+```bash
+uvx --from 'avios-cli[login]' avios login --from-browser --profile "Profile 1"
+```
+
 Plain `uvx avios-cli login` won't work — the isolated environment doesn't include
 the `login` extra.
 

{avios_cli-0.1.4 → avios_cli-0.1.5}/README.md

@@ -62,6 +62,14 @@ into avios.com with:
 uvx --from 'avios-cli[login]' avios login --from-browser
 ```
 
+This scans **all your Chrome profiles** and uses whichever one is actually logged
+into avios.com (it tells you which). If you have several profiles, you can target
+one directly:
+
+```bash
+uvx --from 'avios-cli[login]' avios login --from-browser --profile "Profile 1"
+```
+
 Plain `uvx avios-cli login` won't work — the isolated environment doesn't include
 the `login` extra.
 

{avios_cli-0.1.4 → avios_cli-0.1.5}/src/avios/__init__.py

@@ -3,4 +3,4 @@
 View your Avios balance, transactions and account details from the terminal.
 """
 
-__version__ = "0.1.4"
+__version__ = "0.1.5"

{avios_cli-0.1.4 → avios_cli-0.1.5}/src/avios/auth.py

@@ -17,22 +17,62 @@ Two strategies, both requiring the optional ``login`` extra
 
 from __future__ import annotations
 
+import contextlib
 from collections.abc import Callable, Iterable
+from dataclasses import dataclass
+from pathlib import Path
 from typing import Any, Protocol
 
+import httpx
+
 from avios import endpoints
-from avios.session import Session
+from avios.config import Settings
+from avios.session import Session, cookie_header_from
 
 DASHBOARD_PATH = "/manage-avios/dashboard"
 LOGIN_TIMEOUT_MS = 300_000  # 5 minutes to complete password + captcha + MFA
 LOGIN_POLL_MS = 2_000  # how often to check whether the session is authenticated
 SUPPORTED_BROWSERS = ("chrome", "firefox", "edge", "brave", "safari", "chromium")
 
+# Chromium-family user-data roots per browser (relative to home), used to discover
+# per-profile cookie databases (Default, "Profile 1", ...).
+_CHROMIUM_ROOTS = {
+    "chrome": [
+        "Library/Application Support/Google/Chrome",
+        ".config/google-chrome",
+        "AppData/Local/Google/Chrome/User Data",
+    ],
+    "brave": [
+        "Library/Application Support/BraveSoftware/Brave-Browser",
+        ".config/BraveSoftware/Brave-Browser",
+        "AppData/Local/BraveSoftware/Brave-Browser/User Data",
+    ],
+    "edge": [
+        "Library/Application Support/Microsoft Edge",
+        ".config/microsoft-edge",
+        "AppData/Local/Microsoft/Edge/User Data",
+    ],
+    "chromium": [
+        "Library/Application Support/Chromium",
+        ".config/chromium",
+        "AppData/Local/Chromium/User Data",
+    ],
+}
+
 
 class LoginError(RuntimeError):
     """Login could not be completed."""
 
 
+@dataclass
+class ImportResult:
+    """Outcome of importing cookies from a browser."""
+
+    count: int
+    profile: str | None
+    authenticated: bool
+
+
 class _RawCookie(Protocol):
     name: str
     value: str
@@ -143,8 +183,7 @@ def _open_login_context(pw: Any, *, headless: bool, user_data_dir: str) -> Any:
     )
 
 
-def _default_loader(browser: str) -> Callable[[], Iterable[_RawCookie]]:
-    """Return a callable that reads avios.com cookies from ``browser``."""
+def _bc3() -> Any:
     try:
         import browser_cookie3 as bc3
     except ImportError as exc:
@@ -152,30 +191,118 @@ def _default_loader(browser: str) -> Callable[[], Iterable[_RawCookie]]:
             "browser-cookie3 isn't installed. Run with the 'login' extra:\n"
             "  uvx --from 'avios-cli[login]' avios login --from-browser"
         ) from exc
+    return bc3
+
+
+def _browser_fn(bc3: Any, browser: str) -> Any:
     fn = getattr(bc3, browser, None)
     if fn is None:
         raise LoginError(
             f"Unknown browser '{browser}'. Choose from: {', '.join(SUPPORTED_BROWSERS)}"
         )
-    return lambda: fn(domain_name="avios.com")
+    return fn
+
+
+def _profile_cookie_files(browser: str, profile: str | None) -> list[tuple[str, Path]]:
+    """Discover (profile_name, Cookies-db) pairs for a chromium-family browser."""
+    found: list[tuple[str, Path]] = []
+    for rel in _CHROMIUM_ROOTS.get(browser, []):
+        root = Path.home() / rel
+        if not root.exists():
+            continue
+        for prof in sorted(p for p in root.iterdir() if p.is_dir()):
+            if profile and prof.name != profile:
+                continue
+            for db in (prof / "Cookies", prof / "Network" / "Cookies"):
+                if db.exists():
+                    found.append((prof.name, db))
+                    break
+    return found
+
+
+def _candidate_cookie_sets(
+    browser: str, profile: str | None
+) -> list[tuple[str, list[dict[str, Any]]]]:
+    """Return [(profile_name, avios_cookies)] to try, most specific first."""
+    bc3 = _bc3()
+    fn = _browser_fn(bc3, browser)
+    candidates: list[tuple[str, list[dict[str, Any]]]] = []
+    for name, db in _profile_cookie_files(browser, profile):
+        try:
+            raw = fn(domain_name="avios.com", cookie_file=str(db))
+        except Exception:
+            continue
+        candidates.append((name, _only_avios(_to_cookie_dicts(raw))))
+    if not profile:
+        # Fallback to browser_cookie3's own default lookup.
+        with contextlib.suppress(Exception):
+            raw = fn(domain_name="avios.com")
+            candidates.append(("default", _only_avios(_to_cookie_dicts(raw))))
+    return candidates
+
+
+def _cookies_authenticate(settings: Settings, cookies: list[dict[str, Any]]) -> bool:
+    """True if these cookies yield a 200 from the auth endpoint."""
+    header = cookie_header_from(cookies)
+    if not header:
+        return False
+    try:
+        with httpx.Client(
+            base_url=settings.base_url,
+            timeout=15.0,
+            follow_redirects=False,
+            headers={
+                "accept": "application/json",
+                "user-agent": settings.user_agent,
+                "cookie": header,
+            },
+        ) as client:
+            return client.get(endpoints.AUTH_USER).status_code == 200
+    except httpx.HTTPError:
+        return False
 
 
 def import_from_browser(
     session: Session | None = None,
     browser: str = "chrome",
     *,
+    profile: str | None = None,
     loader: Callable[[], Iterable[_RawCookie]] | None = None,
-) -> int:
-    """Import the avios.com session cookie from a running browser.
+    authenticator: Callable[[list[dict[str, Any]]], bool] | None = None,
+) -> ImportResult:
+    """Import the avios.com session cookie from a browser profile.
 
-    Returns the number of avios.com cookies imported.
+    Scans the browser's profiles, prefers the one whose cookies actually
+    authenticate, and saves them. ``loader``/``authenticator`` are test seams.
     """
     session = session or Session()
-    load = loader or _default_loader(browser)
-    cookies = _only_avios(_to_cookie_dicts(load()))
-    if not cookies:
+    authenticate = authenticator or (lambda c: _cookies_authenticate(session.settings, c))
+
+    if loader is not None:
+        candidates: list[tuple[str, list[dict[str, Any]]]] = [
+            ("browser", _only_avios(_to_cookie_dicts(loader())))
+        ]
+    else:
+        candidates = _candidate_cookie_sets(browser, profile)
+
+    working: tuple[str, list[dict[str, Any]]] | None = None
+    fallback: tuple[str, list[dict[str, Any]]] | None = None
+    for name, cookies in candidates:
+        if not cookies:
+            continue
+        if fallback is None:
+            fallback = (name, cookies)
+        if authenticate(cookies):
+            working = (name, cookies)
+            break
+
+    chosen = working or fallback
+    if chosen is None:
+        where = f"profile '{profile}'" if profile else browser
         raise LoginError(
-            f"No avios.com cookies found in {browser}. Log into avios.com there first."
+            f"No avios.com cookies found in {where}. Log into avios.com in that "
+            "browser first (and check the profile with --profile)."
         )
+    name, cookies = chosen
     session.save_cookies(cookies)
-    return len(cookies)
+    return ImportResult(count=len(cookies), profile=name, authenticated=working is not None)

{avios_cli-0.1.4 → avios_cli-0.1.5}/src/avios/cli.py

@@ -98,6 +98,9 @@ def login(
         False, "--from-browser", help="Import the cookie from a running browser (no popup)."
     ),
     browser: str = typer.Option("chrome", help="Browser to import from (with --from-browser)."),
+    profile: str | None = typer.Option(
+        None, help="Browser profile name for --from-browser (e.g. 'Default', 'Profile 1')."
+    ),
     headless: bool = typer.Option(
         False, help="Run the login browser headless (only works without captcha/MFA)."
     ),
@@ -106,7 +109,19 @@ def login(
     session = Session()
     try:
         if from_browser:
-            count = import_from_browser(session, browser)
+            result = import_from_browser(session, browser, profile=profile)
+            where = f" from {browser} profile '{result.profile}'" if result.profile else ""
+            if not result.authenticated:
+                console.print(
+                    f"[yellow]Imported {result.count} cookie(s){where}, but they're not a "
+                    "logged-in avios session.[/]"
+                )
+                console.print(
+                    "Log into avios.com in that profile, pick another with "
+                    "[bold]--profile[/], or use [bold]avios login[/] (browser)."
+                )
+                raise typer.Exit(2)
+            console.print(f"[green]Logged in{where}.[/] Saved {result.count} cookie(s).")
         else:
             console.print(
                 "Opening a browser — log in normally (password, captcha, SMS code). "
@@ -114,11 +129,11 @@ def login(
                 "captures your session automatically."
             )
             count = login_via_browser(session, headless=headless)
+            console.print(f"[green]Logged in.[/] Saved {count} avios cookie(s).")
     except LoginError as exc:
         console.print(f"[red]{escape(str(exc))}[/]")
         raise typer.Exit(1) from exc
 
-    console.print(f"[green]Logged in.[/] Saved {count} avios cookie(s).")
     try:
         balance = AviosClient(session).get_balance()
         console.print(

{avios_cli-0.1.4 → avios_cli-0.1.5}/tests/test_auth.py

@@ -14,8 +14,9 @@ import types
 import pytest
 
 from avios.auth import (
+    ImportResult,
     LoginError,
-    _default_loader,
+    _browser_fn,
     _only_avios,
     _open_login_context,
     _to_cookie_dicts,
@@ -52,52 +53,49 @@ def test_only_avios_filters_foreign_domains() -> None:
     assert _only_avios(cookies) == [cookies[0]]
 
 
-def test_import_from_browser_saves_only_avios(settings: Settings) -> None:
+def test_import_from_browser_uses_authenticated_cookies(settings: Settings) -> None:
     session = _session(settings)
-    count = import_from_browser(
+    result = import_from_browser(
         session,
         loader=lambda: [
             FakeCookie("appSession", "abc", "www.avios.com"),
             FakeCookie("_ga", "junk", ".google.com"),
         ],
+        authenticator=lambda cookies: True,
     )
-    assert count == 1
-    assert session.is_authenticated()
+    assert isinstance(result, ImportResult)
+    assert result.count == 1  # only the avios cookie
+    assert result.authenticated is True
     assert session.load_cookies() == [
         {"name": "appSession", "value": "abc", "domain": "www.avios.com"}
     ]
 
 
-def test_import_from_browser_no_cookies_raises(settings: Settings) -> None:
-    with pytest.raises(LoginError, match="No avios.com cookies"):
-        import_from_browser(_session(settings), loader=lambda: [FakeCookie("_ga", "j", ".x.com")])
-
-
-def _fake_bc3(monkeypatch: pytest.MonkeyPatch, **funcs: object) -> None:
-    module = types.ModuleType("browser_cookie3")
-    for name, fn in funcs.items():
-        setattr(module, name, fn)
-    monkeypatch.setitem(sys.modules, "browser_cookie3", module)
-
-
-def test_default_loader_passes_domain(monkeypatch: pytest.MonkeyPatch) -> None:
-    seen: dict[str, str] = {}
+def test_import_from_browser_reports_unauthenticated(settings: Settings) -> None:
+    session = _session(settings)
+    result = import_from_browser(
+        session,
+        loader=lambda: [FakeCookie("appSession", "stale", "www.avios.com")],
+        authenticator=lambda cookies: False,  # cookies exist but don't authenticate
+    )
+    assert result.count == 1
+    assert result.authenticated is False  # saved as best-effort, flagged as not working
 
-    def chrome(**kwargs: str) -> list[FakeCookie]:
-        seen.update(kwargs)
-        return [FakeCookie("appSession", "x", "www.avios.com")]
 
-    _fake_bc3(monkeypatch, chrome=chrome)
-    loader = _default_loader("chrome")
-    cookies = list(loader())
-    assert seen["domain_name"] == "avios.com"
-    assert cookies[0].name == "appSession"
+def test_import_from_browser_no_cookies_raises(settings: Settings) -> None:
+    with pytest.raises(LoginError, match="No avios.com cookies"):
+        import_from_browser(
+            _session(settings),
+            loader=lambda: [FakeCookie("_ga", "j", ".x.com")],
+            authenticator=lambda cookies: True,
+        )
 
 
-def test_default_loader_unknown_browser(monkeypatch: pytest.MonkeyPatch) -> None:
-    _fake_bc3(monkeypatch, chrome=lambda **k: [])
+def test_browser_fn_unknown_browser() -> None:
+    bc3 = types.ModuleType("browser_cookie3")
+    bc3.chrome = lambda **k: []  # type: ignore[attr-defined]
     with pytest.raises(LoginError, match="Unknown browser"):
-        _default_loader("nope")
+        _browser_fn(bc3, "nope")
 
 
 def test_login_via_browser_without_playwright(

{avios_cli-0.1.4 → avios_cli-0.1.5}/tests/test_cli.py

@@ -13,7 +13,7 @@ import pytest
 from typer.testing import CliRunner
 
 from avios import __version__
-from avios.auth import LoginError
+from avios.auth import ImportResult, LoginError
 from avios.cli import app
 from avios.models import Account, Balance, Overview, Profile, Transaction
 from avios.session import NotAuthenticated, SessionExpired
@@ -134,16 +134,31 @@ def test_session_expired(monkeypatch: pytest.MonkeyPatch) -> None:
 
 # -- login / logout ----------------------------------------------------------
 def test_login_from_browser(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setattr("avios.cli.import_from_browser", lambda session, browser: 2)
+    monkeypatch.setattr(
+        "avios.cli.import_from_browser",
+        lambda session, browser, profile=None: ImportResult(2, "Default", True),
+    )
     monkeypatch.setattr("avios.cli.AviosClient", FakeClient)
     result = runner.invoke(app, ["login", "--from-browser"])
     assert result.exit_code == 0
     assert "Logged in" in result.stdout
+    assert "Default" in result.stdout
     assert "Balance" in result.stdout
 
 
+def test_login_from_browser_unauthenticated(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(
+        "avios.cli.import_from_browser",
+        lambda session, browser, profile=None: ImportResult(20, "Default", False),
+    )
+    result = runner.invoke(app, ["login", "--from-browser"])
+    assert result.exit_code == 2
+    normalized = " ".join(result.stdout.split())  # Rich wraps lines
+    assert "not a logged-in avios session" in normalized
+
+
 def test_login_error(monkeypatch: pytest.MonkeyPatch) -> None:
-    def boom(session: Any, browser: str) -> int:
+    def boom(session: Any, browser: str, profile: str | None = None) -> ImportResult:
         raise LoginError("nope")
 
     monkeypatch.setattr("avios.cli.import_from_browser", boom)