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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: overleaf-sync
-Version: 2.0.0a2
+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>
@@ -78,11 +78,20 @@ Keep the `.olauth` file save, as it can be used to log in into your account.
 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`.
+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.0a2 → overleaf_sync-2.0.0a3}/README.md

@@ -49,11 +49,20 @@ Keep the `.olauth` file save, as it can be used to log in into your account.
 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`.
+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.0a2 → overleaf_sync-2.0.0a3}/olsync/__init__.py

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

{overleaf_sync-2.0.0a2 → 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.0a2 → 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/{}/{}/{}"  # The URL to delete files (entity type: doc or file)
-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')
 
@@ -114,7 +136,7 @@ class OverleafClient(object):
         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(PROJECT_URL, cookies=self._cookie, allow_redirects=False)
+        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'})
@@ -127,7 +149,7 @@ class OverleafClient(object):
         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))
 
@@ -138,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)
 
@@ -148,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
 
@@ -171,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:
@@ -219,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,
         )
@@ -237,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
@@ -255,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
 
@@ -323,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
@@ -367,7 +392,7 @@ class OverleafClient(object):
             "X-Csrf-Token": self._csrf
         }
 
-        r = reqs.delete(DELETE_URL.format(project_id, entity_type, file['_id']), cookies=self._cookie,
+        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
@@ -396,7 +421,7 @@ class OverleafClient(object):
             "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()
@@ -416,7 +441,7 @@ class OverleafClient(object):
         if compile_result.get("clsiServerId"):
             params["clsiserverid"] = compile_result["clsiServerId"]
 
-        download_req = reqs.get(BASE_URL + pdf_file['url'], cookies=self._cookie, headers=headers, params=params)
+        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.0a2 → 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)
@@ -138,26 +141,31 @@ def main(ctx, local, remote, project_name, cookie_path, sync_path, olignore_path
 @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 `overleaf_session2` cookie from a browser that is "
-                   "logged in to Overleaf (asked for at a hidden prompt, or read from OLSYNC_COOKIE). Useful on "
-                   "servers without a display and for single sign-on accounts.")
+              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, use_cookie, 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("Value of the overleaf_session2 cookie",
+        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), "Login",
+        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)
@@ -166,8 +174,10 @@ def login(cookie_path, use_cookie, 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:
@@ -175,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",
@@ -196,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())
@@ -217,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()
 
@@ -262,23 +260,46 @@ def load_browser_login():
     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):
-    cookies = {"overleaf_session2": cookie}
-    csrf = OverleafClient(cookies).fetch_csrf()
-    if csrf is None:
-        return False
-    with open(path, 'wb+') as f:
-        pickle.dump({"cookie": cookies, "csrf": csrf}, 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):