overleaf-pull 0.1.0__py3-none-any.whl

overleaf_pull-0.1.0.dist-info/METADATA

@@ -0,0 +1,178 @@
+Metadata-Version: 2.4
+Name: overleaf-pull
+Version: 0.1.0
+Summary: Pull-only Overleaf project sync using Rookie + PyOverleaf
+Project-URL: Homepage, https://github.com/LeanderK/overleaf_sync
+Project-URL: Issues, https://github.com/LeanderK/overleaf_sync/issues
+Author: Leander Kurscheidt
+Keywords: cli,git,latex,overleaf,sync
+Classifier: Environment :: Console
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.10
+Requires-Dist: browsercookie>=0.7
+Requires-Dist: pyoverleaf>=0.1.7
+Requires-Dist: rookiepy==0.5.4
+Provides-Extra: qt
+Requires-Dist: pyside6>=6.6; extra == 'qt'
+Description-Content-Type: text/markdown
+
+# Overleaf Pull-Only Sync CLI
+
+Overview
+- Pull-only tool that periodically clones/pulls your latest Overleaf projects into a local directory.
+- Discovers projects via your browser cookies (Rookie) and lists them via PyOverleaf; syncs using Git.
+- Runs in the background as a macOS LaunchAgent or Linux systemd user timer.
+
+Requirements
+- macOS or Linux with Git installed.
+- Python 3.10+.
+- Packages: rookiepy, pyoverleaf (installed via requirements.txt).
+- Overleaf Git integration enabled on your account to allow cloning/pulling via git.overleaf.com.
+
+Install
+```bash
+# # Using uv (recommended)
+# uv currently not working!
+# uv sync
+
+# Or using conda
+conda env create -f environment.yml
+conda activate overleaf-sync
+
+# Or using pip/venv
+python3 -m venv .venv
+. .venv/bin/activate
+pip install -r requirements.txt
+```
+
+First Run (setup)
+```bash
+overleaf-pull init --install
+# If the console script isn't found, use:
+# uv currently not working!
+# uv run python -m overleaf_sync.cli init --install
+```
+- Prompts for the base directory, interval (1h/12h/24h), count (default 10), browser/profile, and host (default www.overleaf.com).
+- Offers a Qt browser login to capture cookies automatically (default Yes if PySide6 is installed). Falls back to optional manual cookie paste.
+- Prompts for your Overleaf Git authentication token (required for cloning/pulling and background runs). It will offer to open Overleaf in your browser to fetch it.
+- Installs a background job (LaunchAgent on macOS, systemd user timer on Linux).
+- Runs a validation sync before installing the scheduler, to confirm access.
+
+Manual Commands
+- Run once now:
+```bash
+overleaf-pull run-once
+# Or via uv:
+uv run python -m overleaf_sync.cli run-once
+```
+- Manual sync (with optional overrides):
+```bash
+overleaf-pull sync --count 5 --base-dir ~/Overleaf --browser firefox
+# Or via uv:
+uv run python -m overleaf_sync.cli sync --count 5 --base-dir ~/Overleaf --browser firefox
+```
+- Store or clear cookies in config:
+- Folder naming preference:
+```bash
+overleaf-pull set-name-suffix off   # Use display name only
+overleaf-pull set-name-suffix on    # Default: append a short ID to avoid collisions
+```
+This affects the local folder names only; project display names on Overleaf remain unchanged.
+```bash
+overleaf-pull set-cookie "name=value; other=value2"
+overleaf-pull clear-cookie
+```
+- Browser-assisted cookie capture (like olbrowserlogin):
+```bash
+overleaf-pull browser-login
+# This opens Overleaf in your browser and guides you to copy document.cookie.
+```
+Required cookies
+- At minimum: `overleaf_session2` and `GCLB` must be present in your Cookie header for authenticated requests.
+- document.cookie cannot see HttpOnly cookies; copy the full Cookie header from the Network tab for a request to your Overleaf host.
+
+Qt browser login (optional)
+- Use a built-in Qt browser to log in and auto-capture cookies.
+- Conda (recommended on macOS/Linux):
+```bash
+conda activate overleaf-sync
+conda install -c conda-forge pyside6
+overleaf-pull browser-login-qt
+```
+- Pip/venv alternative:
+```bash
+pip install PySide6
+python -m overleaf_sync.cli browser-login-qt
+```
+During setup, if PySide6 is present, the tool will offer the Qt login flow by default.
+
+Git authentication token
+- Overleaf requires a Git auth token for `git clone`/`git pull`.
+- Generate a token in your Overleaf account (see the Git integration/authentication tokens page or the Git instructions shown in your project UI), then set it:
+```bash
+overleaf-pull set-git-token
+# Paste your token when prompted
+
+# Clear it if needed
+overleaf-pull clear-git-token
+```
+- With a token set, the tool will use URLs like `https://git:<TOKEN>@git.overleaf.com/<PROJECT_ID>` automatically.
+- Status from logs:
+```bash
+overleaf-pull status
+```
+- Install or remove background job:
+```bash
+overleaf-pull install-scheduler
+overleaf-pull uninstall-scheduler
+# Or via uv:
+uv run python -m overleaf_sync.cli install-scheduler
+uv run python -m overleaf_sync.cli uninstall-scheduler
+```
+Installing the scheduler is idempotent: it uninstalls any existing instance first, then reinstalls to ensure only one scheduler is active.
+Publish to PyPI (CI)
+- This repo includes a GitHub Actions workflow that publishes on tags `v*` using PyPI Trusted Publishers (OIDC).
+- Trigger a release:
+```bash
+git tag v0.1.0
+git push origin v0.1.0
+```
+- The workflow builds sdist/wheel and publishes without storing secrets.
+- Adjust interval or latest count:
+```bash
+overleaf-pull set-interval 12h
+overleaf-pull set-count 20
+```
+- Change base directory:
+```bash
+overleaf-pull set-base-dir /path/to/Overleaf
+```
+
+macOS Logs
+- Logs: ~/Library/Logs/overleaf_sync/runner.log
+
+Linux Logs
+- `journalctl --user -u overleaf-sync.timer -u overleaf-sync.service`
+- And ~/.local/state/overleaf_sync/logs/ if configured.
+
+Notes
+- This tool is pull-only; it never pushes to Overleaf.
+- Safari cookie access may require permissions; Firefox is often more reliable for unattended use.
+- If Safari access fails, paste Overleaf cookies once via `set-cookie` to avoid elevated access.
+- Use Git credential helpers for smooth pulls:
+```bash
+git config --global credential.helper osxkeychain   # macOS
+git config --global credential.helper libsecret     # Linux
+```
+
+Background runs
+- To avoid interactive Git prompts in schedulers, set an Overleaf Git token once:
+```bash
+overleaf-pull set-git-token
+```
+- Without a token, new clones will fail with 403; existing repos may also fail if their remotes lack the token. Prompts are disabled in background.
+

overleaf_pull-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+overleaf_sync/__init__.py,sha256=DvTRO9kaeQIQAhZ70jOnDdO0QLpW6BVfQZzQRjE-OZM,35
+overleaf_sync/cli.py,sha256=5KlQAs-lbBBv2edSak8ucdKwhX2FrcBUkvMfRcP-pb8,16209
+overleaf_sync/config.py,sha256=76Fn4jLm7k0hEt-T_EUGF2XazDQNzTqxd-rU0HUjMPU,6772
+overleaf_sync/cookies.py,sha256=VxAfKGpfcFO8XMDmFwHS-MB0yuF56B-Cd5Gcpd_Vg74,3069
+overleaf_sync/git_ops.py,sha256=O2BTgFSRqzTERBDsFlQ-d_K7IUZFIcZEtUHEGft_BEY,6131
+overleaf_sync/olbrowser_login.py,sha256=hLDlpGqfE4jRVh3FjC7uEyI5rnzZl8eFyVqMJITZ35w,2749
+overleaf_sync/overleaf_api.py,sha256=jFAy91MAji3KiNCFtRxYE6707BlRZEHLryiDMALFzr0,1613
+overleaf_sync/projects.py,sha256=n0V5D-1jJ7V1G8klikJVEfx2SkZj3I6q_VaPDWWR_B8,500
+overleaf_sync/scheduler.py,sha256=qRZcpq-jzF4Ko6QEs-OKDw7kteLqoGG3lL25e6cAImA,4012
+overleaf_sync/sync.py,sha256=Rv76Em39ZRVesS7aSIOsh1w-l3ER2mKOylUJ4KKY4Js,4252
+overleaf_pull-0.1.0.dist-info/METADATA,sha256=5B_sU7VRfR7PIgHp2udLuGQyGtFSrGiGVI5zlVqNQI4,6349
+overleaf_pull-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+overleaf_pull-0.1.0.dist-info/entry_points.txt,sha256=5eOqjySKRXlUJ5Xxudo4-JDn7HXkQYgodqXFx593Mns,57
+overleaf_pull-0.1.0.dist-info/RECORD,,

overleaf_pull-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

overleaf_pull-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+overleaf-pull = overleaf_sync.cli:main

overleaf_sync/__init__.py

@@ -0,0 +1,2 @@
+__all__ = []
+__version__ = "0.1.0"

overleaf_sync/cli.py

@@ -0,0 +1,449 @@
+import argparse
+import webbrowser
+import os
+import platform
+import sys
+import concurrent.futures
+
+from .config import load_config, prompt_first_run, save_config, Config, get_logs_dir
+from .sync import run_sync_once, run_sync, run_sync_validate_first
+from .scheduler import install_macos_launchagent, uninstall_macos_launchagent, install_systemd_user, uninstall_systemd_user
+from .olbrowser_login import login_via_qt
+
+
+def cmd_init(args):
+    cfg = load_config()
+    if cfg is None:
+        cfg = prompt_first_run()
+    else:
+        print("Config already exists; run with --reset to reconfigure.")
+    # Optionally install scheduler
+    if args.install:
+        install_scheduler(cfg)
+
+
+def install_scheduler(cfg: Config):
+    os_name = platform.system()
+    interval = cfg.sync_interval
+    if os_name == "Darwin":
+        install_macos_launchagent(interval)
+    else:
+        install_systemd_user(interval)
+
+
+def uninstall_scheduler():
+    os_name = platform.system()
+    if os_name == "Darwin":
+        uninstall_macos_launchagent()
+    else:
+        uninstall_systemd_user()
+
+
+def cmd_install(args):
+    cfg = load_config() or prompt_first_run()
+    # Run a manual sync first to validate config and access
+    try:
+        print("Running a validation sync before installing scheduler...")
+        run_sync_validate_first(cfg)
+    except Exception as e:
+        print(f"Validation sync failed: {e}")
+        print("Not installing scheduler. Fix the issue and retry.")
+        return
+    # Uninstall any existing scheduler instance, then install fresh
+    print("Ensuring scheduler is installed exactly once (uninstalling any existing instance)...")
+    try:
+        uninstall_scheduler()
+    except Exception:
+        # Ignore uninstall errors (e.g., not installed)
+        pass
+    install_scheduler(cfg)
+
+
+def cmd_uninstall(args):
+    uninstall_scheduler()
+
+
+def cmd_run_once(args):
+    run_sync_once()
+def cmd_sync(args):
+    cfg = load_config() or prompt_first_run()
+    # Apply one-off overrides
+    if getattr(args, "count", None):
+        cfg.count = args.count
+    if getattr(args, "base_dir", None):
+        cfg.base_dir = args.base_dir
+    if getattr(args, "browser", None):
+        cfg.browser = args.browser
+    if getattr(args, "profile", None):
+        cfg.profile = args.profile
+    run_sync(cfg)
+
+
+
+def cmd_set_interval(args):
+    cfg = load_config() or prompt_first_run()
+    val = args.interval
+    if val not in ("1h", "12h", "24h"):
+        print("Invalid interval; choose 1h, 12h, or 24h")
+        sys.exit(2)
+    cfg.sync_interval = val
+    save_config(cfg)
+    print("Updated interval; reinstall scheduler if needed.")
+
+
+def cmd_set_count(args):
+    cfg = load_config() or prompt_first_run()
+    cfg.count = args.count
+    save_config(cfg)
+    print("Updated latest projects count.")
+
+
+def cmd_set_base_dir(args):
+    cfg = load_config() or prompt_first_run()
+    cfg.base_dir = args.base_dir
+    save_config(cfg)
+    print("Updated base directory.")
+
+
+def cmd_set_cookie(args):
+    cfg = load_config() or prompt_first_run()
+    value = args.value
+    if not value:
+        print("Paste cookie string, then press Ctrl-D (EOF):")
+        try:
+            value = sys.stdin.read()
+        except KeyboardInterrupt:
+            value = ""
+    from .cookies import parse_cookie_string
+    try:
+        cfg.cookies = parse_cookie_string(value)
+        save_config(cfg)
+        missing = [k for k in ("overleaf_session2", "GCLB") if k not in cfg.cookies]
+        print("Stored cookies in config.")
+        if missing:
+            print(f"Warning: missing expected cookie(s): {', '.join(missing)}. Make sure you copied the full Cookie header from the Network tab for a request to {cfg.host}.")
+    except Exception as e:
+        print(f"Failed to parse cookies: {e}")
+
+
+def cmd_clear_cookie(args):
+    cfg = load_config() or prompt_first_run()
+    cfg.cookies = None
+    save_config(cfg)
+    print("Cleared stored cookies from config.")
+
+
+def cmd_set_git_token(args):
+    cfg = load_config() or prompt_first_run()
+    token = args.value
+    if not token:
+        try:
+            token = input("Overleaf Git authentication token: ").strip()
+        except KeyboardInterrupt:
+            token = ""
+    if not token:
+        print("No token provided.")
+        return
+    cfg.git_token = token
+    save_config(cfg)
+    print("Stored Overleaf Git token in config. Keep it secret.")
+
+
+def cmd_clear_git_token(args):
+    cfg = load_config() or prompt_first_run()
+    cfg.git_token = None
+    save_config(cfg)
+    print("Cleared Overleaf Git token from config.")
+
+
+def cmd_set_name_suffix(args):
+    cfg = load_config() or prompt_first_run()
+    val = args.value.lower()
+    if val not in ("on", "off"):
+        print("Invalid value; use 'on' or 'off'")
+        return
+    cfg.append_id_suffix = (val == "on")
+    save_config(cfg)
+    print(f"Folder name ID suffix {'enabled' if cfg.append_id_suffix else 'disabled'}.")
+
+
+def _tail(path: str, lines: int = 50) -> list[str]:
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            content = f.readlines()
+        return content[-lines:]
+    except Exception:
+        return []
+
+
+def cmd_status(args):
+    # Sync health check: verify local repos match remote heads
+    cfg = load_config() or prompt_first_run()
+    if not cfg.git_token:
+        print("Git token missing. Run 'overleaf-pull set-git-token'.")
+        return
+    # Gather projects
+    cookies = cfg.cookies if cfg.cookies else None
+    if not cookies:
+        from .cookies import load_overleaf_cookies
+        cookies = load_overleaf_cookies(cfg.browser, cfg.profile)
+    from .overleaf_api import create_api, list_projects_sorted_by_last_updated
+    api = create_api(cfg.host)
+    projects = list_projects_sorted_by_last_updated(api, cookies, cfg.count)
+
+    from .projects import folder_name_for
+    from .git_ops import ensure_remote, detect_default_branch, get_remote_branch_head, get_local_branch_head
+
+    total = len(projects)
+    if total == 0:
+        print("No projects found.")
+        return
+    print(f"Checking status for {total} latest project(s)...", flush=True)
+
+    def _check(p: dict):
+        pid = p.get("id")
+        name = p.get("name")
+        folder = folder_name_for(name, pid)
+        repo_path = os.path.join(cfg.base_dir, folder)
+        if not os.path.isdir(os.path.join(repo_path, ".git")):
+            return ("missing", f"Missing: {name}")
+        try:
+            ensure_remote(repo_path, pid, cfg.git_token)
+            branch = detect_default_branch(repo_path)
+            rhead = get_remote_branch_head(repo_path, branch)
+            lhead = get_local_branch_head(repo_path, branch)
+            if not rhead or not lhead:
+                return ("outdated", f"Outdated: {name} (unable to determine heads)")
+            if rhead != lhead:
+                return ("outdated", f"Outdated: {name} (remote {rhead[:7]} vs local {lhead[:7]})")
+            return ("up", None)
+        except Exception as e:
+            return ("outdated", f"Outdated: {name} (error: {e})")
+
+    up_to_date = 0
+    missing = 0
+    outdated = 0
+    issues: list[str] = []
+    done = 0
+    max_workers = min(16, total)
+    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as ex:
+        futures = [ex.submit(_check, p) for p in projects]
+        for fut in concurrent.futures.as_completed(futures):
+            status, msg = fut.result()
+            done += 1
+            if status == "up":
+                up_to_date += 1
+            elif status == "missing":
+                missing += 1
+                if msg:
+                    issues.append(msg)
+            else:
+                outdated += 1
+                if msg:
+                    issues.append(msg)
+    print(f"Summary: {up_to_date}/{total} up to date, {missing}/{total} missing, {outdated}/{total} outdated.")
+
+    # Identify old projects (not in latest set)
+    from .projects import folder_name_for
+    expected = {folder_name_for(p.get("name"), p.get("id")) for p in projects}
+    old_repos = []
+    for entry in os.listdir(cfg.base_dir):
+        path = os.path.join(cfg.base_dir, entry)
+        if os.path.isdir(os.path.join(path, ".git")) and entry not in expected:
+            old_repos.append(path)
+
+    lingering = []
+    removed = []
+    if args.prune and old_repos:
+        import shutil
+        from .git_ops import is_worktree_clean, has_unpushed_commits
+        for repo in old_repos:
+            branch = detect_default_branch(repo)
+            clean = is_worktree_clean(repo)
+            ahead = has_unpushed_commits(repo, branch)
+            if clean and ahead is False:
+                try:
+                    shutil.rmtree(repo)
+                    removed.append(repo)
+                except Exception:
+                    lingering.append(repo)
+            else:
+                lingering.append(repo)
+
+    if removed:
+        print(f"Pruned {len(removed)} old project(s).")
+    if lingering:
+        print(f"Lingering old projects (cannot delete safely): {len(lingering)}")
+        for r in lingering[:5]:
+            print(f"- {r}")
+
+    if not issues:
+        # Everything OK
+        logs_dir = get_logs_dir()
+        app_log = os.path.join(logs_dir, "app.log")
+        runner_log = os.path.join(logs_dir, "runner.log")
+        runner_err = os.path.join(logs_dir, "runner.err.log")
+        has_runner_logs = (os.path.exists(runner_log) or os.path.exists(runner_err))
+        last_success = None
+        if os.path.exists(app_log):
+            lines = _tail(app_log, 200)
+            for line in reversed(lines):
+                line = line.strip()
+                if line.startswith("[") and "] Synced" in line:
+                    last_success = line
+                    break
+        if last_success and has_runner_logs:
+            print(f"Background runner OK. {last_success}")
+        elif last_success:
+            print(f"Manual sync OK. {last_success}")
+        else:
+            if has_runner_logs:
+                print("Everything OK. No successful sync recorded yet.")
+            else:
+                print("Everything OK. No background runs recorded yet.")
+        return
+
+    # Print brief issues overview
+    if issues:
+        print("Issues:")
+        for msg in issues[:10]:
+            print(f"- {msg}")
+
+
+def cmd_browser_login(args):
+    """Guide the user to obtain cookies via the browser (manual copy)."""
+    cfg = load_config() or prompt_first_run()
+    url = f"https://{cfg.host}/project"
+    print("Opening Overleaf in your default browser. If not logged in, please log in.")
+    try:
+        webbrowser.open(url)
+    except Exception:
+        print(f"Please open {url} manually.")
+
+    print("\nAfter login, copy your cookie string:")
+    print("- Open Developer Tools → Network, select any request to your Overleaf host.")
+    print("- Copy the full 'Cookie' header value (it includes HttpOnly cookies).")
+    print("- document.cookie is insufficient; it misses HttpOnly cookies like overleaf_session2.")
+    print("Paste cookie below and press Ctrl-D (EOF) when done:\n")
+    try:
+        value = sys.stdin.read()
+    except KeyboardInterrupt:
+        print("Aborted.")
+        return
+    if not value.strip():
+        print("No cookie provided.")
+        return
+    from .cookies import parse_cookie_string
+    try:
+        cfg.cookies = parse_cookie_string(value)
+        save_config(cfg)
+        print("Stored cookies in config.")
+        # Optional quick validation
+        try:
+            run_sync(cfg)
+            print("Cookie validation succeeded (projects synced).")
+        except Exception as e:
+            print(f"Validation failed (will keep cookies saved): {e}")
+    except Exception as e:
+        print(f"Failed to parse cookies: {e}")
+
+
+def cmd_browser_login_qt(args):
+    """Open a Qt WebEngine window to login and capture cookies automatically."""
+    cfg = load_config() or prompt_first_run()
+    try:
+        store = login_via_qt()
+    except RuntimeError as e:
+        print(str(e))
+        return
+    if not store:
+        print("Login did not complete.")
+        return
+    # Store captured cookies and csrf
+    cfg.cookies = store.get("cookie")
+    save_config(cfg)
+    missing = [k for k in ("overleaf_session2", "GCLB") if not cfg.cookies or k not in cfg.cookies]
+    if missing:
+        print(f"Warning: missing expected cookie(s): {', '.join(missing)}")
+    print("Stored cookies from Qt browser login.")
+    # Optional quick validation
+    try:
+        run_sync(cfg)
+        print("Cookie validation succeeded (projects synced).")
+    except Exception as e:
+        print(f"Validation failed (will keep cookies saved): {e}")
+
+
+def main():
+    parser = argparse.ArgumentParser(prog="overleaf-pull", description="Pull-only Overleaf project sync")
+    sub = parser.add_subparsers(dest="cmd")
+
+    p_init = sub.add_parser("init", help="First-run setup and optional scheduler install")
+    p_init.add_argument("--install", action="store_true", help="Install background scheduler after setup")
+    p_init.set_defaults(func=cmd_init)
+
+    p_install = sub.add_parser("install-scheduler", help="Install background scheduler (LaunchAgent/systemd)")
+    p_install.set_defaults(func=cmd_install)
+
+    p_uninstall = sub.add_parser("uninstall-scheduler", help="Uninstall background scheduler")
+    p_uninstall.set_defaults(func=cmd_uninstall)
+
+    p_run = sub.add_parser("run-once", help="Run a single pull-only sync now")
+    p_run.set_defaults(func=cmd_run_once)
+
+    p_sync = sub.add_parser("sync", help="Manual sync with optional overrides")
+    p_sync.add_argument("--count", type=int, help="Override latest projects count for this run")
+    p_sync.add_argument("--base-dir", help="Override base directory for this run")
+    p_sync.add_argument("--browser", choices=["safari", "firefox"], help="Override browser for this run")
+    p_sync.add_argument("--profile", help="Override profile for this run")
+    p_sync.set_defaults(func=cmd_sync)
+
+    p_si = sub.add_parser("set-interval", help="Set sync interval (1h|12h|24h)")
+    p_si.add_argument("interval", choices=["1h", "12h", "24h"])
+    p_si.set_defaults(func=cmd_set_interval)
+
+    p_sc = sub.add_parser("set-count", help="Set latest projects count")
+    p_sc.add_argument("count", type=int)
+    p_sc.set_defaults(func=cmd_set_count)
+
+    p_sb = sub.add_parser("set-base-dir", help="Set base directory for clones")
+    p_sb.add_argument("base_dir")
+    p_sb.set_defaults(func=cmd_set_base_dir)
+
+    p_scook = sub.add_parser("set-cookie", help="Store Overleaf cookies in config (paste or pass string)")
+    p_scook.add_argument("value", nargs="?", help="Cookie header or 'name=value; name2=value2' string")
+    p_scook.set_defaults(func=cmd_set_cookie)
+
+    p_ccook = sub.add_parser("clear-cookie", help="Clear stored cookies from config")
+    p_ccook.set_defaults(func=cmd_clear_cookie)
+
+    p_status = sub.add_parser("status", help="Show current sync state; optional prune old projects")
+    p_status.add_argument("--prune", action="store_true", help="Remove old local projects not in latest set if safe")
+    p_status.set_defaults(func=cmd_status)
+
+    p_blogin = sub.add_parser("browser-login", help="Open browser and guide you to copy cookies")
+    p_blogin.set_defaults(func=cmd_browser_login)
+
+    p_blogin_qt = sub.add_parser("browser-login-qt", help="Use a Qt browser to login and auto-capture cookies (requires PySide6)")
+    p_blogin_qt.set_defaults(func=cmd_browser_login_qt)
+
+    p_sgt = sub.add_parser("set-git-token", help="Store Overleaf Git authentication token for cloning/pulling")
+    p_sgt.add_argument("value", nargs="?", help="Token string")
+    p_sgt.set_defaults(func=cmd_set_git_token)
+
+    p_cgt = sub.add_parser("clear-git-token", help="Clear stored Overleaf Git token")
+    p_cgt.set_defaults(func=cmd_clear_git_token)
+
+    p_ns = sub.add_parser("set-name-suffix", help="Toggle appending short project ID to folder names (on|off)")
+    p_ns.add_argument("value", choices=["on", "off"])
+    p_ns.set_defaults(func=cmd_set_name_suffix)
+
+    args = parser.parse_args()
+    if not hasattr(args, "func"):
+        parser.print_help()
+        sys.exit(1)
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()