overleaf-sync 2.0.0a1__tar.gz → 2.0.0a3__tar.gz

{overleaf_sync-2.0.0a1 → overleaf_sync-2.0.0a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: overleaf-sync
-Version: 2.0.0a1
+Version: 2.0.0a3
 Summary: Overleaf Two-Way Sync Tool
 Keywords: overleaf,sync,latex,tex
 Author-email: Moritz Glöckl <moritzgloeckl@users.noreply.github.com>
@@ -74,6 +74,24 @@ It then stores your *cookie* (**not** your login credentials) in a hidden file c
 
 Keep the `.olauth` file save, as it can be used to log in into your account.
 
+#### Login without the login window
+On a server without a display, or if the login window doesn't work for your account (e.g. single sign-on via ORCID or your institution), log in with a session cookie instead:
+
+1. Log in to Overleaf in your normal browser.
+2. Open the developer tools → Application (Firefox: Storage) → Cookies → `https://www.overleaf.com` and copy the value of `overleaf_session2` (on a self-hosted server: the cookie `overleaf.sid` of your server).
+3. Run `ols login --cookie` and paste the value at the (hidden) prompt, or provide it via the `OLSYNC_COOKIE` environment variable.
+
+This works without installing the `gui` extra.
+
+### Self-hosted Overleaf servers
+overleaf-sync also works with self-hosted Overleaf servers. It is tested against Overleaf Community Edition; Server Pro shares its code and should work too, but is untested. Pass the server's URL when logging in:
+
+```
+moritz@github:~/test$ ols login --server https://overleaf.example.com
+```
+
+The server is stored together with the login, so all other commands (`ols`, `ols list`, `ols download`) use it automatically. You can also set it with `--server` on any command or with the `OLSYNC_SERVER` environment variable. `ols login --cookie --server ...` works too; self-hosted servers name the session cookie `overleaf.sid` (`sharelatex.sid` before version 5).
+
 ### Listing all projects
 ```
 moritz@github:~/test$ ols list [--store-path -v/--verbose]

{overleaf_sync-2.0.0a1 → overleaf_sync-2.0.0a3}/README.md

@@ -45,6 +45,24 @@ It then stores your *cookie* (**not** your login credentials) in a hidden file c
 
 Keep the `.olauth` file save, as it can be used to log in into your account.
 
+#### Login without the login window
+On a server without a display, or if the login window doesn't work for your account (e.g. single sign-on via ORCID or your institution), log in with a session cookie instead:
+
+1. Log in to Overleaf in your normal browser.
+2. Open the developer tools → Application (Firefox: Storage) → Cookies → `https://www.overleaf.com` and copy the value of `overleaf_session2` (on a self-hosted server: the cookie `overleaf.sid` of your server).
+3. Run `ols login --cookie` and paste the value at the (hidden) prompt, or provide it via the `OLSYNC_COOKIE` environment variable.
+
+This works without installing the `gui` extra.
+
+### Self-hosted Overleaf servers
+overleaf-sync also works with self-hosted Overleaf servers. It is tested against Overleaf Community Edition; Server Pro shares its code and should work too, but is untested. Pass the server's URL when logging in:
+
+```
+moritz@github:~/test$ ols login --server https://overleaf.example.com
+```
+
+The server is stored together with the login, so all other commands (`ols`, `ols list`, `ols download`) use it automatically. You can also set it with `--server` on any command or with the `OLSYNC_SERVER` environment variable. `ols login --cookie --server ...` works too; self-hosted servers name the session cookie `overleaf.sid` (`sharelatex.sid` before version 5).
+
 ### Listing all projects
 ```
 moritz@github:~/test$ ols list [--store-path -v/--verbose]

{overleaf_sync-2.0.0a1 → overleaf_sync-2.0.0a3}/olsync/__init__.py

@@ -1,3 +1,3 @@
 """Overleaf Two-Way Sync Tool"""
 
-__version__ = '2.0.0a1'
+__version__ = '2.0.0a3'

{overleaf_sync-2.0.0a1 → overleaf_sync-2.0.0a3}/olsync/olbrowserlogin.py

@@ -13,13 +13,14 @@ from PySide6.QtWidgets import *
 from PySide6.QtWebEngineWidgets import *
 from PySide6.QtWebEngineCore import QWebEngineProfile, QWebEngineSettings, QWebEnginePage
 
-# Where to get the CSRF Token and where to send the login request to
-LOGIN_URL = "https://www.overleaf.com/login"
-PROJECT_URL = "https://www.overleaf.com/project"  # The dashboard URL
+BASE_URL = "https://www.overleaf.com"  # The default Overleaf server
+LOGIN_PATH = "/login"  # Where the user logs in
+PROJECT_PATH = "/project"  # The dashboard, reached after a successful login
 # JS snippet to extract the csrfToken
 JAVASCRIPT_CSRF_EXTRACTOR = "document.getElementsByName('ol-csrfToken')[0].content"
-# Name of the cookies we want to extract
-COOKIE_NAMES = ["overleaf_session2", "GCLB"]
+# Name of the cookies we want to extract: overleaf.com's session and load balancer cookies, and the session cookie of
+# self-hosted servers (Community Edition; "sharelatex.sid" before version 5)
+COOKIE_NAMES = ["overleaf_session2", "GCLB", "overleaf.sid", "sharelatex.sid"]
 
 
 class OlBrowserLoginWindow(QMainWindow):
@@ -28,9 +29,11 @@ class OlBrowserLoginWindow(QMainWindow):
     Opens a browser window to securely login the user and returns relevant login data.
     """
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, base_url=BASE_URL, *args, **kwargs):
         super(OlBrowserLoginWindow, self).__init__(*args, **kwargs)
 
+        self._base_url = base_url.rstrip("/")
+
         self.webview = QWebEngineView()
 
         self._cookies = {}
@@ -46,7 +49,7 @@ class OlBrowserLoginWindow(QMainWindow):
 
         webpage = QWebEnginePage(self.profile, self)
         self.webview.setPage(webpage)
-        self.webview.load(QUrl.fromUserInput(LOGIN_URL))
+        self.webview.load(QUrl.fromUserInput(self._base_url + LOGIN_PATH))
         self.webview.loadFinished.connect(self.handle_load_finished)
 
         self.setCentralWidget(self.webview)
@@ -58,7 +61,7 @@ class OlBrowserLoginWindow(QMainWindow):
             self._login_success = True
             QCoreApplication.quit()
 
-        if self.webview.url().toString() == PROJECT_URL:
+        if self.webview.url().toString().rstrip("/") == self._base_url + PROJECT_PATH:
             self.webview.page().runJavaScript(
                 JAVASCRIPT_CSRF_EXTRACTOR, 0, callback
             )
@@ -81,14 +84,14 @@ class OlBrowserLoginWindow(QMainWindow):
         return self._login_success
 
 
-def login():
+def login(base_url=BASE_URL):
     from PySide6.QtCore import QLoggingCategory
     QLoggingCategory.setFilterRules('''\
     qt.webenginecontext.info=false
     ''')
 
     app = QApplication([])
-    ol_browser_login_window = OlBrowserLoginWindow()
+    ol_browser_login_window = OlBrowserLoginWindow(base_url)
     ol_browser_login_window.show()
     app.exec()
 

{overleaf_sync-2.0.0a1 → overleaf_sync-2.0.0a3}/olsync/olclient.py

@@ -24,18 +24,32 @@ import time
 if not hasattr(websocket, "SSLError"):
     websocket.SSLError = ssl.SSLError
 
-# Where to get the CSRF Token and where to send the login request to
-LOGIN_URL = "https://www.overleaf.com/login"
-PROJECT_URL = "https://www.overleaf.com/project"  # The dashboard URL
-# The URL to download all the files in zip format
-DOWNLOAD_URL = "https://www.overleaf.com/project/{}/download/zip"
-UPLOAD_URL = "https://www.overleaf.com/project/{}/upload"  # The URL to upload files
-FOLDER_URL = "https://www.overleaf.com/project/{}/folder"  # The URL to create folders
-DELETE_URL = "https://www.overleaf.com/project/{}/doc/{}"  # The URL to delete files
-COMPILE_URL = "https://www.overleaf.com/project/{}/compile?enable_pdf_caching=true"  # The URL to compile the project
-BASE_URL = "https://www.overleaf.com"  # The Overleaf Base URL
+BASE_URL = "https://www.overleaf.com"  # The default Overleaf server; self-hosted servers are passed as base_url
+# Paths relative to the server's base URL
+LOGIN_PATH = "/login"  # Where to get the CSRF Token and where to send the login request to
+PROJECT_PATH = "/project"  # The dashboard
+DOWNLOAD_PATH = "/project/{}/download/zip"  # Download all the files in zip format
+UPLOAD_PATH = "/project/{}/upload"  # Upload files
+FOLDER_PATH = "/project/{}/folder"  # Create folders
+DELETE_PATH = "/project/{}/{}/{}"  # Delete files (entity type: doc or file)
+COMPILE_PATH = "/project/{}/compile?enable_pdf_caching=true"  # Compile the project
+SOCKET_IO_PATH = "/socket.io/1/"  # Real-time service handshake
 PATH_SEP = "/"  # Use hardcoded path separator for both windows and posix system
 
+class RealtimeSocket(SocketIO):
+    """
+    socketIO-client's SocketIO, minus its cleanup quirk: SocketIO.__del__ calls disconnect(), which opens a brand-new
+    connection when the old one is already closed (and, with wait_for_connection=True, retries that forever).
+    """
+
+    def __del__(self):
+        try:
+            if self.connected:
+                self.disconnect()
+        except Exception:
+            pass
+
+
 class OverleafClient(object):
     """
     Overleaf API Wrapper
@@ -51,9 +65,17 @@ class OverleafClient(object):
                 if all(p.get(k) == v for k, v in more_attrs.items()):
                     yield p
 
-    def __init__(self, cookie=None, csrf=None):
+    def __init__(self, cookie=None, csrf=None, base_url=BASE_URL):
         self._cookie = cookie  # Store the cookie for authenticated requests
         self._csrf = csrf  # Store the CSRF token since it is needed for some requests
+        self._base_url = base_url.rstrip("/")  # overleaf.com or a self-hosted server
+
+    @property
+    def base_url(self):
+        return self._base_url
+
+    def _url(self, path):
+        return self._base_url + path
 
     def login(self, username, password):
         """
@@ -63,7 +85,7 @@ class OverleafClient(object):
         Returns: Dict of cookie and CSRF
         """
 
-        get_login = reqs.get(LOGIN_URL)
+        get_login = reqs.get(self._url(LOGIN_PATH))
         self._csrf = BeautifulSoup(get_login.content, 'html.parser').find(
             'input', {'name': '_csrf'}).get('value')
         login_json = {
@@ -71,7 +93,7 @@ class OverleafClient(object):
             "email": username,
             "password": password
         }
-        post_login = reqs.post(LOGIN_URL, json=login_json,
+        post_login = reqs.post(self._url(LOGIN_PATH), json=login_json,
                                cookies=get_login.cookies)
 
         # On a successful authentication the Overleaf API returns a new authenticated cookie.
@@ -84,7 +106,7 @@ class OverleafClient(object):
             self._cookie['GCLB'] = get_login.cookies['GCLB']
 
             # CSRF changes after making the login request, new CSRF token will be on the projects page
-            projects_page = reqs.get(PROJECT_URL, cookies=self._cookie)
+            projects_page = reqs.get(self._url(PROJECT_PATH), cookies=self._cookie)
             self._csrf = BeautifulSoup(projects_page.content, 'html.parser').find('meta', {'name': 'ol-csrfToken'}) \
                 .get('content')
 
@@ -109,12 +131,25 @@ class OverleafClient(object):
             json_content = json_content.get('projects', [])
         return json_content
 
+    def fetch_csrf(self):
+        """
+        Get the CSRF token from the project dashboard, e.g. after logging in with a cookie copied from a browser
+        Returns: the CSRF token, or None if the session cookie is not (or no longer) valid
+        """
+        projects_page = reqs.get(self._url(PROJECT_PATH), cookies=self._cookie, allow_redirects=False)
+        if not projects_page.ok or projects_page.is_redirect:
+            return None
+        csrf_tag = BeautifulSoup(projects_page.content, 'html.parser').find('meta', {'name': 'ol-csrfToken'})
+        if csrf_tag is None:
+            return None
+        return csrf_tag.get('content')
+
     def all_projects(self):
         """
         Get all of a user's active projects (= not archived and not trashed)
         Returns: List of project objects
         """
-        projects_page = reqs.get(PROJECT_URL, cookies=self._cookie)
+        projects_page = reqs.get(self._url(PROJECT_PATH), cookies=self._cookie)
         json_content = OverleafClient._extract_projects(projects_page.content)
         return list(OverleafClient.filter_projects(json_content))
 
@@ -125,7 +160,7 @@ class OverleafClient(object):
         Returns: project object
         """
 
-        projects_page = reqs.get(PROJECT_URL, cookies=self._cookie)
+        projects_page = reqs.get(self._url(PROJECT_PATH), cookies=self._cookie)
         json_content = OverleafClient._extract_projects(projects_page.content)
         return next(OverleafClient.filter_projects(json_content, {"name": project_name}), None)
 
@@ -135,7 +170,7 @@ class OverleafClient(object):
         Params: project_id, the id of the project
         Returns: bytes string (zip file)
         """
-        r = reqs.get(DOWNLOAD_URL.format(project_id),
+        r = reqs.get(self._url(DOWNLOAD_PATH.format(project_id)),
                      stream=True, cookies=self._cookie)
         return r.content
 
@@ -158,7 +193,7 @@ class OverleafClient(object):
         headers = {
             "X-Csrf-Token": self._csrf
         }
-        r = reqs.post(FOLDER_URL.format(project_id),
+        r = reqs.post(self._url(FOLDER_PATH.format(project_id)),
                       cookies=self._cookie, headers=headers, json=params)
 
         if r.ok:
@@ -206,7 +241,7 @@ class OverleafClient(object):
         # a session may not carry every cookie -- this previously raised
         # KeyError here even though overleaf_session2 alone is enough to connect.)
         handshake = reqs.get(
-            "{}/socket.io/1/".format(BASE_URL),
+            self._url(SOCKET_IO_PATH),
             params={"t": int(time.time() * 1000)},
             cookies=self._cookie,
         )
@@ -224,10 +259,12 @@ class OverleafClient(object):
         # handshake"); confirmed it rejects even when projectId is only on
         # the WebSocket upgrade URL -- it must be on the initial
         # /socket.io/1/ GET specifically.
-        socket_io = SocketIO(
-            BASE_URL,
+        socket_io = RealtimeSocket(
+            self._base_url,
             params={'t': int(time.time()), 'projectId': project_id},
-            headers={'Cookie': cookie}
+            headers={'Cookie': cookie},
+            # Fail instead of retrying forever (and hanging the CLI) when the real-time service is unreachable
+            wait_for_connection=False
         )
 
         # Wait until we connect to the socket
@@ -242,15 +279,16 @@ class OverleafClient(object):
         # .on() never registers -- it would return immediately without
         # reading anything. Wait in short slices instead, stopping as soon as
         # the event has actually been processed.
-        socket_io.on('joinProjectResponse', set_project_infos)
-        for _ in range(20):
-            if project_infos is not None:
-                break
-            socket_io.wait(seconds=1)
-
-        # Disconnect from the socket if still connected
-        if socket_io.connected:
-            socket_io.disconnect()
+        try:
+            socket_io.on('joinProjectResponse', set_project_infos)
+            for _ in range(20):
+                if project_infos is not None:
+                    break
+                socket_io.wait(seconds=1)
+        finally:
+            # Disconnect from the socket if still connected
+            if socket_io.connected:
+                socket_io.disconnect()
 
         return project_infos
 
@@ -310,7 +348,7 @@ class OverleafClient(object):
         }
 
         # Upload the file to the predefined folder
-        r = reqs.post(UPLOAD_URL.format(project_id), cookies=self._cookie, params=params, files=files)
+        r = reqs.post(self._url(UPLOAD_PATH.format(project_id)), cookies=self._cookie, params=params, files=files)
 
         # status_code is an int; comparing to str(200) was always False here,
         # so this reported failure on every call regardless of the real
@@ -330,23 +368,21 @@ class OverleafClient(object):
         Returns: True on success, False on fail
         """
 
-        file = None
-
-        # The file name contains path separators, check folders
-        if PATH_SEP in file_name:
-            local_folders = file_name.split(PATH_SEP)[:-1]  # Remove last item since this is the file name
-            current_overleaf_folder = project_infos['rootFolder'][0]['folders']  # Set the current remote folder
-
-            for local_folder in local_folders:
-                for remote_folder in current_overleaf_folder:
-                    if local_folder.lower() == remote_folder['name'].lower():
-                        file = next((v for v in remote_folder['docs'] if v['name'] == file_name.split(PATH_SEP)[-1]),
-                                    None)
-                        current_overleaf_folder = remote_folder['folders']
-                        break
-        # File is in root folder
-        else:
-            file = next((v for v in project_infos['rootFolder'][0]['docs'] if v['name'] == file_name), None)
+        # Walk down to the folder that contains the file (folder names match case-insensitively, as in upload_file)
+        *local_folders, name = file_name.split(PATH_SEP)
+        current_folder = project_infos['rootFolder'][0]
+        for local_folder in local_folders:
+            current_folder = next((f for f in current_folder['folders'] if f['name'].lower() == local_folder.lower()),
+                                  None)
+            if current_folder is None:
+                return False
+
+        # Text files are "docs", binary files (images, PDFs, ...) are "fileRefs" with their own endpoint
+        file = next((v for v in current_folder.get('docs', []) if v['name'] == name), None)
+        entity_type = "doc"
+        if file is None:
+            file = next((v for v in current_folder.get('fileRefs', []) if v['name'] == name), None)
+            entity_type = "file"
 
         # File not found!
         if file is None:
@@ -356,7 +392,8 @@ class OverleafClient(object):
             "X-Csrf-Token": self._csrf
         }
 
-        r = reqs.delete(DELETE_URL.format(project_id, file['_id']), cookies=self._cookie, headers=headers, json={})
+        r = reqs.delete(self._url(DELETE_PATH.format(project_id, entity_type, file['_id'])), cookies=self._cookie,
+                        headers=headers, json={})
 
         # status_code is an int; comparing to str(204) was always False
         # regardless of the real result, same bug class as upload_file and
@@ -380,11 +417,11 @@ class OverleafClient(object):
             "check": "silent",
             "draft": False,
             "incrementalCompilesEnabled": True,
-            "rootDoc_id": "",
+            # No rootDoc_id: Overleaf validates it as an optional ObjectId and rejects "" (400)
             "stopOnFirstError": False
         }
 
-        r = reqs.post(COMPILE_URL.format(project_id), cookies=self._cookie, headers=headers, json=body)
+        r = reqs.post(self._url(COMPILE_PATH.format(project_id)), cookies=self._cookie, headers=headers, json=body)
 
         if not r.ok:
             raise reqs.HTTPError()
@@ -396,7 +433,15 @@ class OverleafClient(object):
 
         pdf_file = next(v for v in compile_result['outputFiles'] if v['type'] == 'pdf')
 
-        download_req = reqs.get(BASE_URL + pdf_file['url'], cookies=self._cookie, headers=headers)
+        # The output is only served (otherwise 404) when the compile group and CLSI server are passed along,
+        # like Overleaf's own frontend does. Self-hosted servers may not send them.
+        params = {}
+        if compile_result.get("compileGroup"):
+            params["compileGroup"] = compile_result["compileGroup"]
+        if compile_result.get("clsiServerId"):
+            params["clsiserverid"] = compile_result["clsiServerId"]
+
+        download_req = reqs.get(self._url(pdf_file['url']), cookies=self._cookie, headers=headers, params=params)
 
         if download_req.ok:
             return pdf_file['path'], download_req.content

{overleaf_sync-2.0.0a1 → overleaf_sync-2.0.0a3}/olsync/olsync.py

@@ -23,10 +23,19 @@ from pathlib import Path
 
 try:
     # Import for pip installation / wheel
-    from olsync.olclient import OverleafClient
+    from olsync.olclient import BASE_URL, OverleafClient
 except ImportError:
     # Import for development
-    from olclient import OverleafClient
+    from olclient import BASE_URL, OverleafClient
+
+# Session cookie names: overleaf.com, and self-hosted servers (Community Edition, "sharelatex.sid" before version 5)
+OVERLEAF_COM_SESSION_COOKIES = ["overleaf_session2"]
+SELF_HOSTED_SESSION_COOKIES = ["overleaf.sid", "sharelatex.sid"]
+
+server_option = click.option(
+    '--server', 'server', default=None, envvar='OLSYNC_SERVER', metavar='URL',
+    help="URL of a self-hosted Overleaf server (default: the server used at login, or https://www.overleaf.com). "
+         "Can also be set with OLSYNC_SERVER.")
 
 
 def configure_console():
@@ -54,20 +63,14 @@ def configure_console():
 @click.option('-i', '--olignore', 'olignore_path', default=".olignore", type=click.Path(exists=False),
               help="Path to the .olignore file relative to sync path (ignored if syncing from remote to local). See "
                    "fnmatch / unix filename pattern matching for information on how to use it.")
+@server_option
 @click.option('-v', '--verbose', 'verbose', is_flag=True, help="Enable extended error logging.")
 @click.version_option(package_name='overleaf-sync')
 @click.pass_context
-def main(ctx, local, remote, project_name, cookie_path, sync_path, olignore_path, verbose):
+def main(ctx, local, remote, project_name, cookie_path, sync_path, olignore_path, server, verbose):
     configure_console()
     if ctx.invoked_subcommand is None:
-        if not os.path.isfile(cookie_path):
-            raise click.ClickException(
-                "Persisted Overleaf cookie not found. Please login or check store path.")
-
-        with open(cookie_path, 'rb') as f:
-            store = pickle.load(f)
-
-        overleaf_client = OverleafClient(store["cookie"], store["csrf"])
+        overleaf_client = load_client(cookie_path, server)
 
         # Change the current directory to the specified sync path
         os.chdir(sync_path)
@@ -98,9 +101,11 @@ def main(ctx, local, remote, project_name, cookie_path, sync_path, olignore_path
         sync = not (local or remote)
 
         if remote or sync:
+            remote_files = zip_file.namelist()
+            deleted_files = [] if sync else [f for f in olignore_keep_list(olignore_path) if f not in remote_files]
             sync_func(
-                files_from=zip_file.namelist(),
-                deleted_files=[f for f in olignore_keep_list(olignore_path) if f not in zip_file.namelist() and not sync],
+                files_from=remote_files,
+                deleted_files=deleted_files,
                 create_file_at_to=lambda name: write_file(name, zip_file.read(name)),
                 delete_file_at_to=lambda name: delete_file(name),
                 create_file_at_from=lambda name: overleaf_client.upload_file(
@@ -113,9 +118,12 @@ def main(ctx, local, remote, project_name, cookie_path, sync_path, olignore_path
                 to_name="local",
                 verbose=verbose)
         if local or sync:
+            # Computed once (#60), and after the remote -> local pass so newly downloaded files are included
+            local_files = olignore_keep_list(olignore_path)
+            deleted_files = [] if sync else [f for f in zip_file.namelist() if f not in local_files]
             sync_func(
-                files_from=olignore_keep_list(olignore_path),
-                deleted_files=[f for f in zip_file.namelist() if f not in olignore_keep_list(olignore_path) and not sync],
+                files_from=local_files,
+                deleted_files=deleted_files,
                 create_file_at_to=lambda name: overleaf_client.upload_file(
                     project["id"], project_infos, name, os.path.getsize(name), open(name, 'rb')),
                 delete_file_at_to=lambda name: overleaf_client.delete_file(project["id"], project_infos, name),
@@ -132,14 +140,32 @@ def main(ctx, local, remote, project_name, cookie_path, sync_path, olignore_path
 @main.command()
 @click.option('--path', 'cookie_path', default=".olauth", type=click.Path(exists=False),
               help="Path to store the persisted Overleaf cookie.")
+@click.option('--cookie', 'use_cookie', is_flag=True,
+              help="Log in without the login window, using the session cookie from a browser that is logged in to "
+                   "Overleaf (`overleaf_session2` on overleaf.com, `overleaf.sid` on self-hosted servers), asked for "
+                   "at a hidden prompt or read from OLSYNC_COOKIE. Useful on servers without a display and for single "
+                   "sign-on accounts.")
+@server_option
 @click.option('-v', '--verbose', 'verbose', is_flag=True, help="Enable extended error logging.")
-def login(cookie_path, verbose):
+@click.pass_context
+def login(ctx, cookie_path, use_cookie, server, verbose):
+    server = resolve_login_server(ctx, server)
     if os.path.isfile(cookie_path) and not click.confirm(
             'Persisted Overleaf cookie already exist. Do you want to override it?'):
         return
+    if use_cookie:
+        cookie_names = OVERLEAF_COM_SESSION_COOKIES if server == BASE_URL else SELF_HOSTED_SESSION_COOKIES
+        # Never accept the cookie as a command line argument, it would end up in the shell history
+        cookie = os.environ.get("OLSYNC_COOKIE") or click.prompt(f"Value of the {cookie_names[0]} cookie",
+                                                                 hide_input=True)
+        execute_action(lambda: cookie_login_handler(cookie.strip(), cookie_path, server, cookie_names), "Login",
+                       "Login successful. Cookie persisted as `" + click.format_filename(
+                           cookie_path) + "`. You may now sync your project.",
+                       "Login failed: the cookie is not valid (expired, or copied incompletely).", verbose)
+        return
     olbrowserlogin = load_browser_login()
     click.clear()
-    execute_action(lambda: login_handler(olbrowserlogin, cookie_path), "Login",
+    execute_action(lambda: login_handler(olbrowserlogin, cookie_path, server), "Login",
                    "Login successful. Cookie persisted as `" + click.format_filename(
                        cookie_path) + "`. You may now sync your project.",
                    "Login failed. Please try again.", verbose)
@@ -148,8 +174,10 @@ def login(cookie_path, verbose):
 @main.command(name='list')
 @click.option('--store-path', 'cookie_path', default=".olauth", type=click.Path(exists=False),
               help="Relative path to load the persisted Overleaf cookie.")
+@server_option
 @click.option('-v', '--verbose', 'verbose', is_flag=True, help="Enable extended error logging.")
-def list_projects(cookie_path, verbose):
+@click.pass_context
+def list_projects(ctx, cookie_path, server, verbose):
     def query_projects():
         for index, p in enumerate(sorted(overleaf_client.all_projects(), key=lambda x: x['lastUpdated'], reverse=True)):
             if not index:
@@ -157,14 +185,7 @@ def list_projects(cookie_path, verbose):
             click.echo(f"{dateutil.parser.isoparse(p['lastUpdated']).strftime('%m/%d/%Y, %H:%M:%S')} - {p['name']}")
         return True
 
-    if not os.path.isfile(cookie_path):
-        raise click.ClickException(
-            "Persisted Overleaf cookie not found. Please login or check store path.")
-
-    with open(cookie_path, 'rb') as f:
-        store = pickle.load(f)
-
-    overleaf_client = OverleafClient(store["cookie"], store["csrf"])
+    overleaf_client = load_client(cookie_path, server or ctx.find_root().params.get("server"))
 
     click.clear()
     execute_action(query_projects, "Querying all projects",
@@ -178,8 +199,10 @@ def list_projects(cookie_path, verbose):
 @click.option('--download-path', 'download_path', default=".", type=click.Path(exists=True))
 @click.option('--store-path', 'cookie_path', default=".olauth", type=click.Path(exists=False),
               help="Relative path to load the persisted Overleaf cookie.")
+@server_option
 @click.option('-v', '--verbose', 'verbose', is_flag=True, help="Enable extended error logging.")
-def download_pdf(project_name, download_path, cookie_path, verbose):
+@click.pass_context
+def download_pdf(ctx, project_name, download_path, cookie_path, server, verbose):
     def download_project_pdf():
         nonlocal project_name
         project_name = project_name or os.path.basename(os.getcwd())
@@ -199,14 +222,7 @@ def download_pdf(project_name, download_path, cookie_path, verbose):
 
         return True
 
-    if not os.path.isfile(cookie_path):
-        raise click.ClickException(
-            "Persisted Overleaf cookie not found. Please login or check store path.")
-
-    with open(cookie_path, 'rb') as f:
-        store = pickle.load(f)
-
-    overleaf_client = OverleafClient(store["cookie"], store["csrf"])
+    overleaf_client = load_client(cookie_path, server or ctx.find_root().params.get("server"))
 
     click.clear()
 
@@ -225,27 +241,67 @@ def load_browser_login():
             # Import for pip installation / wheel
             import olsync.olbrowserlogin as olbrowserlogin
         except ImportError as e:
-            if (e.name or "").startswith("PySide6"):
+            if not (e.name or "").startswith("olsync"):
                 raise
-            # Import for development
+            # Import for development (running olsync.py from inside the olsync folder)
             import olbrowserlogin
     except ImportError as e:
-        if not (e.name or "").startswith("PySide6"):
-            raise
+        if (e.name or "").startswith("PySide6"):
+            raise click.ClickException(
+                "The login window needs PySide6. Install it with: pip install \"overleaf-sync[gui]\"\n"
+                "Alternatively, log in without the window: ols login --cookie")
+        # PySide6 is installed but can't be loaded, e.g. because another Qt installation (such as Anaconda's)
+        # conflicts with it (#59)
         raise click.ClickException(
-            "The login window needs PySide6. Install it with: pip install \"overleaf-sync[gui]\"")
+            f"The login window could not be loaded: {e}\n"
+            "This usually means another Qt installation (e.g. from Anaconda) conflicts with PySide6. Installing "
+            "overleaf-sync into a fresh virtual environment based on a non-conda Python usually helps.\n"
+            "Alternatively, log in without the window: ols login --cookie")
     return olbrowserlogin
 
 
-def login_handler(olbrowserlogin, path):
-    store = olbrowserlogin.login()
+def resolve_login_server(ctx, server):
+    """--server on the login command, else on the group (both also read OLSYNC_SERVER), else overleaf.com"""
+    return (server or ctx.find_root().params.get("server") or BASE_URL).rstrip("/")
+
+
+def load_client(cookie_path, server=None):
+    """
+    Create an OverleafClient from the persisted login. The server is --server/OLSYNC_SERVER if given, otherwise the
+    server stored at login (auth files from before 2.0.0a3 have none and mean overleaf.com).
+    """
+    if not os.path.isfile(cookie_path):
+        raise click.ClickException(
+            "Persisted Overleaf cookie not found. Please login or check store path.")
+
+    with open(cookie_path, 'rb') as f:
+        store = pickle.load(f)
+
+    return OverleafClient(store["cookie"], store["csrf"], base_url=server or store.get("server") or BASE_URL)
+
+
+def login_handler(olbrowserlogin, path, server):
+    store = olbrowserlogin.login(server)
     if store is None:
         return False
+    store["server"] = server
     with open(path, 'wb+') as f:
         pickle.dump(store, f)
     return True
 
 
+def cookie_login_handler(cookie, path, server, cookie_names):
+    # Self-hosted servers name the session cookie differently depending on the version, so try each name
+    for cookie_name in cookie_names:
+        cookies = {cookie_name: cookie}
+        csrf = OverleafClient(cookies, base_url=server).fetch_csrf()
+        if csrf is not None:
+            with open(path, 'wb+') as f:
+                pickle.dump({"cookie": cookies, "csrf": csrf, "server": server}, f)
+            return True
+    return False
+
+
 def delete_file(path):
     _dir = os.path.dirname(path)
     if _dir == path:
@@ -410,7 +466,8 @@ def olignore_keep_list(olignore_path):
     else:
         click.echo("\n.olignore: using %s to filter items" % olignore_path)
         with open(olignore_path, 'r') as f:
-            ignore_pattern = f.read().splitlines()
+            # "./main.tex" and "main.tex" mean the same file, matched paths have no "./" prefix (#72)
+            ignore_pattern = [pattern.removeprefix("./") for pattern in f.read().splitlines()]
 
         keep_list = [f for f in files if not any(
             fnmatch.fnmatch(f, ignore) for ignore in ignore_pattern)]