overleaf-pull 0.1.0__py3-none-any.whl

overleaf_sync/config.py

@@ -0,0 +1,197 @@
+import json
+import os
+import platform
+import webbrowser
+from dataclasses import dataclass, asdict
+from typing import Optional, Tuple, Dict
+
+APP_NAME = "overleaf_sync"
+
+@dataclass
+class Config:
+    base_dir: str
+    sync_interval: str = "1h"  # one of: 1h, 12h, 24h
+    count: int = 10
+    browser: str = "safari"  # safari|firefox
+    profile: Optional[str] = None
+    host: str = "www.overleaf.com"
+    git_helper: bool = True
+    cookies: Optional[Dict[str, str]] = None
+    git_token: Optional[str] = None
+    append_id_suffix: bool = True
+
+
+def _mac_paths() -> Tuple[str, str, str]:
+    home = os.path.expanduser("~")
+    support = os.path.join(home, "Library", "Application Support", APP_NAME)
+    logs = os.path.join(home, "Library", "Logs", APP_NAME)
+    caches = os.path.join(home, "Library", "Caches", APP_NAME)
+    return support, logs, caches
+
+
+def _linux_paths() -> Tuple[str, str, str]:
+    home = os.path.expanduser("~")
+    config_home = os.environ.get("XDG_CONFIG_HOME", os.path.join(home, ".config"))
+    state_home = os.environ.get("XDG_STATE_HOME", os.path.join(home, ".local", "state"))
+    cache_home = os.environ.get("XDG_CACHE_HOME", os.path.join(home, ".cache"))
+    support = os.path.join(config_home, APP_NAME)
+    logs = os.path.join(state_home, APP_NAME, "logs")
+    caches = os.path.join(cache_home, APP_NAME)
+    return support, logs, caches
+
+
+def get_app_paths() -> Tuple[str, str, str]:
+    if platform.system() == "Darwin":
+        return _mac_paths()
+    return _linux_paths()
+
+
+def get_config_path() -> str:
+    support, _, _ = get_app_paths()
+    os.makedirs(support, exist_ok=True)
+    return os.path.join(support, "config.json")
+
+
+def get_logs_dir() -> str:
+    _, logs, _ = get_app_paths()
+    os.makedirs(logs, exist_ok=True)
+    return logs
+
+
+def get_cache_dir() -> str:
+    _, _, caches = get_app_paths()
+    os.makedirs(caches, exist_ok=True)
+    return caches
+
+
+def load_config() -> Optional[Config]:
+    cfg_path = get_config_path()
+    if not os.path.exists(cfg_path):
+        return None
+    with open(cfg_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    return Config(**data)
+
+
+def save_config(cfg: Config) -> None:
+    cfg_path = get_config_path()
+    with open(cfg_path, "w", encoding="utf-8") as f:
+        json.dump(asdict(cfg), f, indent=2)
+
+
+def default_base_dir() -> str:
+    home = os.path.expanduser("~")
+    if platform.system() == "Darwin":
+        return os.path.join(home, "Documents", "Overleaf")
+    # Linux default
+    return os.path.join(home, "Overleaf")
+
+
+def prompt_first_run() -> Config:
+    print("First-time setup for Overleaf Sync")
+    # Base directory
+    default_dir = default_base_dir()
+    base_dir = input(f"Base directory to clone projects into [{default_dir}]: ").strip() or default_dir
+    os.makedirs(base_dir, exist_ok=True)
+
+    # Interval
+    interval_options = {"1": "1h", "2": "12h", "3": "24h"}
+    print("Select sync interval:")
+    print("  1) 1 hour (default)")
+    print("  2) 12 hours")
+    print("  3) 24 hours")
+    interval_choice = input("Choice [1/2/3]: ").strip() or "1"
+    sync_interval = interval_options.get(interval_choice, "1h")
+
+    # Count
+    count_in = input("Number of latest projects to sync [10]: ").strip()
+    try:
+        count = int(count_in) if count_in else 10
+    except ValueError:
+        count = 10
+
+    # Browser default
+    browser_default = "safari" if platform.system() == "Darwin" else "firefox"
+    browser_in = input(f"Browser to read Overleaf cookies from [safari|firefox] (default {browser_default}): ").strip().lower()
+    if browser_in not in ("safari", "firefox", ""):
+        browser = browser_default
+    else:
+        browser = browser_in or browser_default
+
+    # Host
+    host_in = input("Overleaf host [www.overleaf.com]: ").strip()
+    host = host_in or "www.overleaf.com"
+
+    # Prefer Qt browser login to capture cookies automatically (if available)
+    cookies: Optional[Dict[str, str]] = None
+    try_qt = input("Use Qt browser to login and auto-capture cookies now? [Y/n]: ").strip().lower()
+    if try_qt != "n":
+        try:
+            from .olbrowser_login import login_via_qt
+            store = login_via_qt()
+            if store and store.get("cookie"):
+                cookies = store.get("cookie")
+                print("Stored cookies from Qt browser login.")
+            else:
+                print("Qt login did not complete; skipping.")
+        except RuntimeError as e:
+            print(str(e))
+        except Exception:
+            print("Qt login failed; you can set cookies later via 'overleaf-pull set-cookie'.")
+
+    # Git helper
+    git_helper_ans = input("Enable OS Git credential helper? [Y/n]: ").strip().lower()
+    git_helper = (git_helper_ans != "n")
+
+    # Git token (required for cloning/pulling)
+    print("Overleaf now requires a Git authentication token for cloning/pulling.")
+    print("Find it via your Overleaf project's Git panel or account settings.")
+    open_help = input("Open Overleaf in your browser to fetch the token now? [Y/n]: ").strip().lower()
+    if open_help != "n":
+        try:
+            webbrowser.open(f"https://{host}/project")
+        except Exception:
+            pass
+    git_token = ""
+    while not git_token:
+        git_token = input("Enter Overleaf Git token (required): ").strip()
+        if not git_token:
+            print("Token cannot be empty. Please paste your token.")
+
+    # Folder naming preference
+    ans = input("Append short project ID to folder names to avoid collisions? [Y/n]: ").strip().lower()
+    append_id_suffix = (ans != "n")
+
+    # Optional: paste Overleaf cookies (JSON map or Cookie header) if not captured
+    if not cookies:
+        print("Optional: paste Overleaf cookies to avoid browser access (press Enter to skip).")
+        cookie_in = input("Cookies (JSON map or 'name=value; name2=value2'): ").strip()
+        if cookie_in:
+            from .cookies import parse_cookie_string
+            try:
+                cookies = parse_cookie_string(cookie_in)
+            except Exception:
+                try:
+                    # Try JSON
+                    import json as _json
+                    data = _json.loads(cookie_in)
+                    if isinstance(data, dict):
+                        cookies = {str(k): str(v) for k, v in data.items()}
+                except Exception:
+                    cookies = None
+
+    cfg = Config(
+        base_dir=base_dir,
+        sync_interval=sync_interval,
+        count=count,
+        browser=browser,
+        profile=None,
+        host=host,
+        git_helper=git_helper,
+        cookies=cookies,
+        git_token=git_token,
+        append_id_suffix=append_id_suffix,
+    )
+    save_config(cfg)
+    print(f"Saved config to {get_config_path()}")
+    return cfg

overleaf_sync/cookies.py

@@ -0,0 +1,82 @@
+import os
+import shutil
+import tempfile
+from typing import Dict, List
+
+try:
+    from rookiepy import safari as rookie_safari
+    from rookiepy import firefox as rookie_firefox
+except Exception:  # pragma: no cover
+    rookie_safari = None
+    rookie_firefox = None
+
+try:
+    import browsercookie  # type: ignore
+except Exception:  # pragma: no cover
+    browsercookie = None
+
+OVERLEAF_DOMAINS = ["overleaf.com", ".overleaf.com", "www.overleaf.com"]
+
+
+def _to_cookie_dict(cookies: List[dict]) -> Dict[str, str]:
+    jar: Dict[str, str] = {}
+    for c in cookies:
+        name = c.get("name") or c.get("Name")
+        value = c.get("value") or c.get("Value")
+        domain = c.get("domain") or c.get("Domain")
+        if not name or value is None:
+            continue
+        if domain and not any(d in domain for d in OVERLEAF_DOMAINS):
+            continue
+        jar[name] = value
+    return jar
+
+
+def parse_cookie_string(s: str) -> Dict[str, str]:
+    """Parse a Cookie header or simple `name=value; name2=value2` string into a dict.
+
+    Accepts optional leading 'Cookie:' and trims whitespace.
+    """
+    s = s.strip()
+    if s.lower().startswith("cookie:"):
+        s = s.split(":", 1)[1].strip()
+    jar: Dict[str, str] = {}
+    parts = [p.strip() for p in s.split(";") if p.strip()]
+    for part in parts:
+        if "=" not in part:
+            continue
+        name, value = part.split("=", 1)
+        jar[name.strip()] = value.strip()
+    return jar
+
+
+def load_overleaf_cookies(browser: str, profile: str | None = None) -> Dict[str, str]:
+    """Load Overleaf cookies using Rookie from the selected browser/profile.
+
+    Returns a dict of cookie name -> value suitable for PyOverleaf Api.login_from_cookies.
+    """
+    if browser == "safari":
+        if rookie_safari is None:
+            raise RuntimeError("Safari cookie access requires rookiepy; install with 'uv add rookiepy' or 'pip install rookiepy'. On macOS, granting Full Disk Access to your terminal may be required.")
+        # Rookie handles Safari paths internally
+        cookies = rookie_safari(OVERLEAF_DOMAINS)
+        return _to_cookie_dict(cookies)
+    elif browser == "firefox":
+        if rookie_firefox is None:
+            # Fallback to browsercookie for Firefox if rookiepy is unavailable
+            if browsercookie is None:
+                raise RuntimeError("Firefox cookie access requires rookiepy or browsercookie.")
+            cj = browsercookie.firefox()
+            jar: Dict[str, str] = {}
+            for c in cj:
+                domain = getattr(c, "domain", None)
+                if domain and not any(d in domain for d in OVERLEAF_DOMAINS):
+                    continue
+                jar[c.name] = c.value
+            return jar
+        # Firefox may lock cookies.sqlite; Rookie generally reads via its own logic,
+        # but if needed, we can copy the profile dir to a temp path.
+        cookies = rookie_firefox(OVERLEAF_DOMAINS)
+        return _to_cookie_dict(cookies)
+    else:
+        raise ValueError("Unsupported browser; choose 'safari' or 'firefox'.")

overleaf_sync/git_ops.py

@@ -0,0 +1,167 @@
+import os
+import subprocess
+from typing import Optional
+
+REMOTE_NAME = "overleaf"
+REMOTE_URL_FMT = "https://git.overleaf.com/{id}"
+
+
+def build_remote_url(project_id: str, token: Optional[str] = None) -> str:
+    if token:
+        return f"https://git:{token}@git.overleaf.com/{project_id}"
+    return REMOTE_URL_FMT.format(id=project_id)
+
+
+def _git_env() -> dict:
+    env = os.environ.copy()
+    env.setdefault("GIT_TERMINAL_PROMPT", "0")
+    return env
+
+
+def _run(cmd: list[str], cwd: Optional[str] = None) -> subprocess.CompletedProcess:
+    return subprocess.run(cmd, cwd=cwd, check=False, capture_output=True, text=True, env=_git_env())
+
+
+def _run_stream(cmd: list[str], cwd: Optional[str] = None, mask_token: Optional[str] = None) -> tuple[int, str]:
+    """Run a command and stream combined stdout/stderr live to the console.
+
+    Returns (returncode, combined_output). Masks token occurrences in output if provided.
+    """
+    proc = subprocess.Popen(
+        cmd,
+        cwd=cwd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        env=_git_env(),
+        bufsize=1,
+    )
+    combined: list[str] = []
+    if proc.stdout is not None:
+        for line in proc.stdout:
+            s = line.rstrip("\n")
+            if mask_token:
+                s = s.replace(mask_token, "***")
+            print(s)
+            combined.append(s)
+    rc = proc.wait()
+    return rc, "\n".join(combined)
+
+
+def repo_exists(path: str) -> bool:
+    return os.path.isdir(os.path.join(path, ".git"))
+
+
+def clone_if_missing(base_dir: str, folder: str, project_id: str, token: Optional[str] = None) -> str:
+    path = os.path.join(base_dir, folder)
+    if not repo_exists(path):
+        url = build_remote_url(project_id, token)
+        safe_url = url
+        if token:
+            safe_url = url.replace(token, "***")
+        print(f"$ git clone {safe_url} {path}")
+        rc, combined = _run_stream(["git", "clone", url, path], mask_token=token)
+        if rc != 0:
+            raise RuntimeError(f"git clone failed: {combined.splitlines()[-1] if combined else 'unknown error'}")
+    return path
+
+
+def ensure_remote(path: str, project_id: str, token: Optional[str] = None) -> None:
+    # If token is provided, ensure remote URL includes it; if not, avoid overriding
+    target_url = build_remote_url(project_id, token) if token else None
+    res = _run(["git", "remote", "get-url", REMOTE_NAME], cwd=path)
+    if res.returncode != 0:
+        if target_url:
+            safe_url = target_url
+            if token:
+                safe_url = target_url.replace(token, "***")
+            print(f"$ git remote add {REMOTE_NAME} {safe_url}")
+            _run(["git", "remote", "add", REMOTE_NAME, target_url], cwd=path)
+        return
+    current = res.stdout.strip()
+    if target_url and current != target_url:
+        safe_url = target_url
+        if token:
+            safe_url = target_url.replace(token, "***")
+        print(f"$ git remote set-url {REMOTE_NAME} {safe_url}")
+        _run(["git", "remote", "set-url", REMOTE_NAME, target_url], cwd=path)
+
+
+def detect_default_branch(path: str) -> str:
+    # Try remote heads (quiet)
+    res = _run(["git", "ls-remote", "--heads", REMOTE_NAME], cwd=path)
+    heads = res.stdout.splitlines()
+    for line in heads:
+        if line.endswith("refs/heads/master"):
+            return "master"
+    for line in heads:
+        if line.endswith("refs/heads/main"):
+            return "main"
+    # Fallback to local current
+    res2 = _run(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=path)
+    return res2.stdout.strip() or "master"
+
+
+def pull_remote(path: str, branch: str) -> None:
+    print(f"$ git pull {REMOTE_NAME} {branch}")
+    rc, combined = _run_stream(["git", "pull", REMOTE_NAME, branch], cwd=path)
+    if rc != 0:
+        raise RuntimeError(f"git pull failed: {combined.splitlines()[-1] if combined else 'unknown error'}")
+
+
+def get_remote_branch_head(path: str, branch: str) -> Optional[str]:
+    """Return the remote branch head commit SHA for the given branch, or None if not found (quiet)."""
+    ref = f"refs/heads/{branch}"
+    res = _run(["git", "ls-remote", REMOTE_NAME, ref], cwd=path)
+    if res.returncode != 0:
+        return None
+    line = (res.stdout or "").strip()
+    if not line:
+        return None
+    sha = line.split("\t")[0]
+    return sha or None
+
+
+def get_local_branch_head(path: str, branch: str) -> Optional[str]:
+    """Return the local branch head commit SHA, or HEAD if branch missing."""
+    res = _run(["git", "rev-parse", f"refs/heads/{branch}"], cwd=path)
+    if res.returncode == 0:
+        return (res.stdout or "").strip() or None
+    # Fallback to HEAD
+    res2 = _run(["git", "rev-parse", "HEAD"], cwd=path)
+    if res2.returncode == 0:
+        return (res2.stdout or "").strip() or None
+    return None
+
+
+def is_worktree_clean(path: str) -> bool:
+    """Return True if working tree and index are clean (no local modifications)."""
+    res = _run(["git", "status", "--porcelain"], cwd=path)
+    return res.returncode == 0 and (res.stdout.strip() == "")
+
+
+def has_unpushed_commits(path: str, branch: str) -> Optional[bool]:
+    """Return True if local is ahead of remote for branch. None if cannot determine."""
+    # Ensure remote ref exists locally; do a quiet ls-remote to confirm
+    rsha = get_remote_branch_head(path, branch)
+    if not rsha:
+        return None
+    # Count commits that are in HEAD but not in remote branch
+    res = _run(["git", "rev-list", f"overleaf/{branch}..HEAD", "--count"], cwd=path)
+    if res.returncode != 0:
+        return None
+    try:
+        cnt = int((res.stdout or "0").strip())
+    except ValueError:
+        return None
+    return cnt > 0
+
+
+def enable_git_helper(os_name: str) -> None:
+    if os_name == "Darwin":
+        _run(["git", "config", "--global", "credential.helper", "osxkeychain"]) 
+    else:
+        # Desktop Linux: libsecret; headless fallback to store
+        res = _run(["git", "config", "--global", "credential.helper", "libsecret"]) 
+        if res.returncode != 0:
+            _run(["git", "config", "--global", "credential.helper", "store"]) 

overleaf_sync/olbrowser_login.py

@@ -0,0 +1,71 @@
+LOGIN_URL = "https://www.overleaf.com/login"
+PROJECT_URL = "https://www.overleaf.com/project"
+
+
+def login_via_qt():
+    """Open a Qt WebEngine browser to login and capture cookies + CSRF.
+
+    Returns a dict: {"cookie": {name: value, ...}, "csrf": str}
+    Requires PySide6 with Qt WebEngine.
+    """
+    try:
+        from PySide6.QtCore import QUrl, QCoreApplication
+        from PySide6.QtWidgets import QApplication, QMainWindow
+        from PySide6.QtWebEngineWidgets import QWebEngineView
+        from PySide6.QtWebEngineCore import QWebEngineProfile, QWebEngineSettings, QWebEnginePage
+    except Exception as e:
+        raise RuntimeError(
+            "PySide6 (Qt WebEngine) is required for this command. Install with 'conda install -c conda-forge pyside6' or 'pip install PySide6'."
+        ) from e
+
+    class _Window(QMainWindow):
+        def __init__(self):
+            super().__init__()
+            self.webview = QWebEngineView()
+            self._cookies = {}
+            self._csrf = ""
+            self._done = False
+
+            self.profile = QWebEngineProfile(self.webview)
+            self.cookie_store = self.profile.cookieStore()
+            self.cookie_store.cookieAdded.connect(self._on_cookie_added)
+            self.profile.setPersistentCookiesPolicy(QWebEngineProfile.NoPersistentCookies)
+            self.profile.settings().setAttribute(QWebEngineSettings.JavascriptEnabled, True)
+
+            webpage = QWebEnginePage(self.profile, self)
+            self.webview.setPage(webpage)
+            self.webview.load(QUrl.fromUserInput(LOGIN_URL))
+            self.webview.loadFinished.connect(self._on_load_finished)
+
+            self.setCentralWidget(self.webview)
+            self.resize(700, 900)
+
+        def _on_cookie_added(self, cookie):
+            name = cookie.name().data().decode("utf-8")
+            if name in ("overleaf_session2", "GCLB"):
+                self._cookies[name] = cookie.value().data().decode("utf-8")
+
+        def _on_load_finished(self):
+            # When arriving at dashboard, extract csrf from meta
+            if self.webview.url().toString().startswith(PROJECT_URL):
+                def _cb(result):
+                    self._csrf = result or ""
+                    self._done = True
+                    QCoreApplication.quit()
+
+                js = """
+                (function(){
+                  var m = document.querySelector('meta[name="ol-csrfToken"]');
+                  return m ? m.content : '';
+                })();
+                """
+                self.webview.page().runJavaScript(js, 0, _cb)
+
+    app = QApplication([])
+    win = _Window()
+    win.show()
+    app.exec()
+
+    if not win._done:
+        return None
+    return {"cookie": win._cookies, "csrf": win._csrf}

overleaf_sync/overleaf_api.py

@@ -0,0 +1,38 @@
+from typing import List, Dict, Any
+
+# Attempt to import PyOverleaf Api with flexibility (module paths may vary)
+try:
+    from pyoverleaf.api import Api  # type: ignore
+except Exception:  # pragma: no cover
+    try:
+        from pyoverleaf import Api  # type: ignore
+    except Exception:
+        Api = None  # type: ignore
+
+
+def create_api(host: str = "www.overleaf.com"):
+    if Api is None:
+        raise RuntimeError("pyoverleaf not installed; install with 'pip install pyoverleaf'.")
+    return Api(host=host)
+
+
+def list_projects_sorted_by_last_updated(api, cookies: Dict[str, str], limit: int) -> List[Dict[str, Any]]:
+    """Login with cookies and list projects, sorted by lastUpdated descending, limited to 'limit'."""
+    api.login_from_cookies(cookies)
+    projects = api.get_projects()
+    # Each project likely has attributes: id, name, lastUpdated
+    def last_updated(p):
+        # p may be a dict or an object; support both
+        v = getattr(p, "lastUpdated", None)
+        if v is None:
+            v = p.get("lastUpdated") if isinstance(p, dict) else None
+        return v or 0
+
+    projects_sorted = sorted(projects, key=last_updated, reverse=True)
+    result: List[Dict[str, Any]] = []
+    for p in projects_sorted[:limit]:
+        pid = getattr(p, "id", None) or (p.get("id") if isinstance(p, dict) else None)
+        name = getattr(p, "name", None) or (p.get("name") if isinstance(p, dict) else None)
+        lu = getattr(p, "lastUpdated", None) or (p.get("lastUpdated") if isinstance(p, dict) else None)
+        result.append({"id": pid, "name": name, "lastUpdated": lu})
+    return result

overleaf_sync/projects.py

@@ -0,0 +1,18 @@
+import os
+import re
+from typing import Dict
+
+SAFE_CHARS = re.compile(r"[^A-Za-z0-9._-]+")
+
+
+def folder_name_for(project_name: str | None, project_id: str) -> str:
+    if not project_name:
+        return project_id
+    base = SAFE_CHARS.sub("-", project_name).strip("-._")
+    suffix = project_id[:8] if project_id else ""
+    name = f"{base}-{suffix}" if suffix else base
+    return name or (project_id or "overleaf-project")
+
+
+def ensure_dir(path: str) -> None:
+    os.makedirs(path, exist_ok=True)