leaflink 0.1.0__py3-none-any.whl

leaflink/__init__.py

@@ -0,0 +1,5 @@
+"""leaflink package."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

leaflink/__main__.py

@@ -0,0 +1,3 @@
+from leaflink.cli import main
+
+raise SystemExit(main())

leaflink/auth/__init__.py

@@ -0,0 +1 @@
+"""Authentication helpers."""

leaflink/auth/browser_login.py

@@ -0,0 +1,165 @@
+"""Browser-assisted login using Playwright when available."""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import Iterable
+from urllib.parse import urlparse
+
+from leaflink.client.models import SessionCookie
+from leaflink.exceptions import AuthenticationError
+from leaflink.utils.console import print_console
+
+SUPPORTED_HOSTS = {"www.overleaf.com", "cn.overleaf.com"}
+SUPPORTED_COOKIE_DOMAINS = {"overleaf.com", *SUPPORTED_HOSTS}
+IMPORTANT_COOKIE_NAMES = {
+    "sharelatex.sid",
+    "overleaf_session2",
+    "connect.sid",
+    "_csrf",
+    "XSRF-TOKEN",
+}
+COOKIE_NAME_BLACKLIST_PREFIXES = (
+    "_ga",
+    "_gid",
+    "_gat",
+    "ajs_",
+    "amplitude_",
+    "mp_",
+)
+
+
+@dataclass(slots=True)
+class BrowserLoginResult:
+    base_url: str
+    cookies: list[SessionCookie]
+
+
+def select_relevant_cookies(cookies: Iterable[dict[str, object]]) -> list[SessionCookie]:
+    selected: list[SessionCookie] = []
+    fallback: list[SessionCookie] = []
+    seen: set[tuple[str, str, str]] = set()
+    for item in cookies:
+        name = str(item.get("name", ""))
+        domain = str(item.get("domain", "")).lstrip(".").lower()
+        if not is_supported_cookie_domain(domain):
+            continue
+        cookie = SessionCookie(
+            name=name,
+            value=str(item.get("value", "")),
+            domain=str(item.get("domain", "")),
+            path=str(item.get("path", "/")),
+            secure=bool(item.get("secure", True)),
+            http_only=bool(item.get("httpOnly", True)),
+        )
+        key = (cookie.domain, cookie.path, cookie.name)
+        if key in seen:
+            continue
+        seen.add(key)
+        if name in IMPORTANT_COOKIE_NAMES or name.endswith(".sid"):
+            selected.append(cookie)
+            continue
+        if not any(name.startswith(prefix) for prefix in COOKIE_NAME_BLACKLIST_PREFIXES):
+            fallback.append(cookie)
+    return selected or fallback
+
+
+def select_supported_cookies(cookies: Iterable[dict[str, object]]) -> list[SessionCookie]:
+    supported: list[SessionCookie] = []
+    for item in cookies:
+        domain = str(item.get("domain", "")).lstrip(".").lower()
+        if not is_supported_cookie_domain(domain):
+            continue
+        supported.append(
+            SessionCookie(
+                name=str(item.get("name", "")),
+                value=str(item.get("value", "")),
+                domain=str(item.get("domain", "")),
+                path=str(item.get("path", "/")),
+                secure=bool(item.get("secure", True)),
+                http_only=bool(item.get("httpOnly", True)),
+            )
+        )
+    return supported
+
+
+def has_supported_cookies(cookies: Iterable[dict[str, object]]) -> bool:
+    for item in cookies:
+        domain = str(item.get("domain", "")).lstrip(".").lower()
+        if is_supported_cookie_domain(domain):
+            return True
+    return False
+
+
+def is_supported_cookie_domain(domain: str) -> bool:
+    normalized = domain.lstrip(".").lower()
+    if normalized in SUPPORTED_COOKIE_DOMAINS:
+        return True
+    return any(host.endswith(f".{normalized}") for host in SUPPORTED_HOSTS)
+
+
+def is_project_dashboard(urls: Iterable[str]) -> bool:
+    for url in urls:
+        parsed = urlparse(url)
+        if parsed.netloc in SUPPORTED_HOSTS and parsed.path.startswith("/project"):
+            return True
+    return False
+
+
+def detect_base_url(urls: Iterable[str], fallback: str) -> str:
+    detected = fallback.rstrip("/")
+    for url in urls:
+        host = urlparse(url).netloc
+        if host in SUPPORTED_HOSTS:
+            detected = f"https://{host}"
+    return detected
+
+
+def login_with_browser(base_url: str, timeout_seconds: int = 300) -> BrowserLoginResult:
+    try:
+        from playwright.sync_api import Error as PlaywrightError
+        from playwright.sync_api import sync_playwright
+    except ImportError as exc:  # pragma: no cover
+        raise AuthenticationError(
+            "Playwright is not installed. Install `leaflink[browser]` or use `--cookie-file`."
+        ) from exc
+
+    login_url = f"{base_url.rstrip('/')}/login"
+    with sync_playwright() as playwright:  # pragma: no cover
+        browser = playwright.chromium.launch(headless=False)
+        context = browser.new_context()
+        page = context.new_page()
+        page.goto(login_url, wait_until="domcontentloaded")
+        print_console(
+            "auth",
+            "Complete login in the browser window. leaflink will detect the session automatically and close the browser.",
+        )
+        deadline = time.monotonic() + timeout_seconds
+        last_urls = [page.url]
+        while time.monotonic() < deadline:
+            try:
+                context.pages
+                urls = [current.url for current in context.pages]
+                last_urls = urls or last_urls
+                browser_cookies = context.cookies()
+                cookies = select_relevant_cookies(browser_cookies)
+            except PlaywrightError as exc:
+                raise AuthenticationError(
+                    "The browser window was closed before leaflink captured a reusable session. "
+                    "Please run `leaflink login` again and leave the browser open until leaflink confirms success."
+                ) from exc
+
+            if is_project_dashboard(last_urls) and has_supported_cookies(browser_cookies):
+                if not cookies:
+                    cookies = select_supported_cookies(browser_cookies)
+                resolved_base_url = detect_base_url(last_urls, fallback=base_url)
+                browser.close()
+                return BrowserLoginResult(base_url=resolved_base_url, cookies=cookies)
+            page.wait_for_timeout(1000)
+
+        browser.close()
+    raise AuthenticationError(
+        "Timed out waiting for a successful Overleaf session. "
+        "Please make sure the project dashboard opens in the browser before closing it."
+    )

leaflink/auth/cookie_import.py

@@ -0,0 +1,26 @@
+"""Load cookies from a JSON file."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from leaflink.client.models import SessionCookie
+
+
+def import_cookies_from_file(path: Path) -> list[SessionCookie]:
+    raw = json.loads(path.read_text(encoding="utf-8"))
+    cookies: list[SessionCookie] = []
+    items = raw["cookies"] if isinstance(raw, dict) and "cookies" in raw else raw
+    for item in items:
+        cookies.append(
+            SessionCookie(
+                name=item["name"],
+                value=item["value"],
+                domain=item["domain"],
+                path=item.get("path", "/"),
+                secure=bool(item.get("secure", True)),
+                http_only=bool(item.get("httpOnly", item.get("http_only", True))),
+            )
+        )
+    return cookies

leaflink/auth/manager.py

@@ -0,0 +1,100 @@
+"""Persist and load authentication state."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict
+from pathlib import Path
+
+from leaflink.auth.browser_login import BrowserLoginResult, login_with_browser
+from leaflink.auth.cookie_import import import_cookies_from_file
+from leaflink.client.models import AuthSession, SessionCookie
+from leaflink.utils.paths import app_config_dir
+from leaflink.utils.time import utc_now_iso
+
+
+class AuthManager:
+    """Store auth sessions in the user config directory."""
+
+    def __init__(self, root: Path | None = None) -> None:
+        self.root = root or app_config_dir()
+        self.root.mkdir(parents=True, exist_ok=True)
+        self.auth_path = self.root / "auth.json"
+
+    def load_all(self) -> dict[str, AuthSession]:
+        if not self.auth_path.exists():
+            return {}
+        raw = json.loads(self.auth_path.read_text(encoding="utf-8"))
+        sessions: dict[str, AuthSession] = {}
+        for base_url, item in raw.items():
+            sessions[base_url] = AuthSession(
+                base_url=base_url,
+                cookies=[SessionCookie(**cookie) for cookie in item["cookies"]],
+                created_at=item["created_at"],
+                updated_at=item["updated_at"],
+            )
+        return sessions
+
+    def load(self, base_url: str) -> AuthSession | None:
+        return self.load_all().get(base_url.rstrip("/"))
+
+    def save(self, session: AuthSession) -> None:
+        sessions = self.load_all()
+        sessions[session.base_url.rstrip("/")] = session
+        payload = {
+            base_url: {
+                "cookies": [asdict(cookie) for cookie in saved.cookies],
+                "created_at": saved.created_at,
+                "updated_at": saved.updated_at,
+            }
+            for base_url, saved in sessions.items()
+        }
+        self.auth_path.write_text(
+            json.dumps(payload, indent=2, sort_keys=True),
+            encoding="utf-8",
+        )
+
+    def login(self, base_url: str, cookie_file: Path | None = None) -> AuthSession:
+        base_url = base_url.rstrip("/")
+        if cookie_file is not None:
+            cookies = import_cookies_from_file(cookie_file)
+            resolved_base_url = base_url
+        else:
+            browser_result = login_with_browser(base_url)
+            cookies = browser_result.cookies
+            resolved_base_url = browser_result.base_url
+        existing = self.load(base_url)
+        now = utc_now_iso()
+        session = AuthSession(
+            base_url=resolved_base_url,
+            cookies=cookies,
+            created_at=existing.created_at if existing else now,
+            updated_at=now,
+        )
+        self.save(session)
+        return session
+
+    def logout(self, base_url: str | None = None) -> int:
+        if not self.auth_path.exists():
+            return 0
+        if base_url is None:
+            self.auth_path.unlink()
+            return 1
+        sessions = self.load_all()
+        removed = 1 if sessions.pop(base_url.rstrip("/"), None) else 0
+        if sessions:
+            payload = {
+                url: {
+                    "cookies": [asdict(cookie) for cookie in session.cookies],
+                    "created_at": session.created_at,
+                    "updated_at": session.updated_at,
+                }
+                for url, session in sessions.items()
+            }
+            self.auth_path.write_text(
+                json.dumps(payload, indent=2, sort_keys=True),
+                encoding="utf-8",
+            )
+        elif self.auth_path.exists():
+            self.auth_path.unlink()
+        return removed