overleaf-sync-fixed 1.2.0__tar.gz

overleaf_sync_fixed-1.2.0/.gitignore

@@ -0,0 +1,118 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+pip-wheel-metadata/
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+#PyCharm
+.idea/
+
+# vscode
+.vscode
+.DS_Store
+
+# dev testing
+setup.py
+test*
+.olauth
+.olignore

overleaf_sync_fixed-1.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Moritz Glöckl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

overleaf_sync_fixed-1.2.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: overleaf-sync-fixed
+Version: 1.2.0
+Summary: Overleaf Two-Way Sync Tool
+Home-page: https://github.com/lawrencee/overleaf-sync-fixed
+Keywords: overleaf sync latex tex fix
+Author: Lawrence Yang (Fixed)
+Author-email: lawrenceeyang@gmail.com
+Requires-Python: >=3
+Description-Content-Type: text/markdown
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+License-File: LICENSE
+Requires-Dist: requests == 2.*
+Requires-Dist: beautifulsoup4 == 4.11.1
+Requires-Dist: yaspin == 2.*
+Requires-Dist: python-dateutil~=2.8.1
+Requires-Dist: click == 8.*
+Requires-Dist: PySide6 == 6.*
+
+# Overleaf Sync (Fixed)
+
+A robust two-way synchronization tool for Overleaf projects, updated to support the latest Overleaf web interface (2024+).
+
+## Features
+- **Two-way Sync**: Seamlessly sync changes between local computer and Overleaf.
+- **Robust Uploads**: Specialized strategy for `.tex`, `.bib`, `.cls`, and `.sty` files to ensure 100% content delivery.
+- **No Premium Required**: Works with free Overleaf accounts; no Git or Dropbox subscription needed.
+- **Conflict Awareness**: Intelligent sync logic that prioritizes local changes and warns about potential conflicts.
+
+## Installation
+
+### From PyPI (Recommended)
+```bash
+pip install overleaf-sync-fixed
+```
+
+### From Source
+```bash
+git clone https://github.com/lawrencee/overleaf-sync-fixed
+cd overleaf-sync-fixed
+pip install .
+```
+
+## Usage
+
+### 1. Login
+Authenticate using your `overleaf_session2` cookie.
+```bash
+ols login
+```
+*Note: Get the cookie from Browser DevTools -> Application -> Cookies -> `overleaf_session2`.*
+
+### 2. List Projects
+```bash
+ols list
+```
+
+### 3. Download & Sync
+Download a project to the current directory:
+```bash
+ols download "Your Project Name"
+```
+
+Once in the project directory, run two-way sync:
+```bash
+ols
+```
+
+---
+**Disclaimer**: This tool is not affiliated with Overleaf. Use at your own risk.
+

overleaf_sync_fixed-1.2.0/README.md

@@ -0,0 +1,51 @@
+# Overleaf Sync (Fixed)
+
+A robust two-way synchronization tool for Overleaf projects, updated to support the latest Overleaf web interface (2024+).
+
+## Features
+- **Two-way Sync**: Seamlessly sync changes between local computer and Overleaf.
+- **Robust Uploads**: Specialized strategy for `.tex`, `.bib`, `.cls`, and `.sty` files to ensure 100% content delivery.
+- **No Premium Required**: Works with free Overleaf accounts; no Git or Dropbox subscription needed.
+- **Conflict Awareness**: Intelligent sync logic that prioritizes local changes and warns about potential conflicts.
+
+## Installation
+
+### From PyPI (Recommended)
+```bash
+pip install overleaf-sync-fixed
+```
+
+### From Source
+```bash
+git clone https://github.com/lawrencee/overleaf-sync-fixed
+cd overleaf-sync-fixed
+pip install .
+```
+
+## Usage
+
+### 1. Login
+Authenticate using your `overleaf_session2` cookie.
+```bash
+ols login
+```
+*Note: Get the cookie from Browser DevTools -> Application -> Cookies -> `overleaf_session2`.*
+
+### 2. List Projects
+```bash
+ols list
+```
+
+### 3. Download & Sync
+Download a project to the current directory:
+```bash
+ols download "Your Project Name"
+```
+
+Once in the project directory, run two-way sync:
+```bash
+ols
+```
+
+---
+**Disclaimer**: This tool is not affiliated with Overleaf. Use at your own risk.

overleaf_sync_fixed-1.2.0/README_CN.md

@@ -0,0 +1,51 @@
+# Overleaf 同步工具 (修复版)
+
+一个稳健的 Overleaf 项目双向同步工具，已更新以支持最新的 Overleaf 界面（2024+）。
+
+## 特性
+- **双向同步**: 在本地计算机和 Overleaf 之间无缝同步更改。
+- **稳健上传**: 针对 `.tex`, `.bib`, `.cls` 和 `.sty` 文件采用专门的上传策略，确保内容准确送达。
+- **无需高级版**: 适用于免费 Overleaf 账户；无需 Git 或 Dropbox 订阅。
+- **冲突处理**: 智能同步逻辑，优先处理本地更改并对潜在冲突发出警告。
+
+## 安装方式
+
+### 通过 PyPI 安装 (推荐)
+```bash
+pip install overleaf-sync-fixed
+```
+
+### 从源码安装
+```bash
+git clone https://github.com/lawrencee/overleaf-sync-fixed
+cd overleaf-sync-fixed
+pip install .
+```
+
+## 使用方法
+
+### 1. 登录
+使用 `overleaf_session2` cookie 进行身份验证。
+```bash
+ols login
+```
+*提示：从浏览器开发者工具 (F12) -> Application -> Cookies -> 获取 `overleaf_session2` 的值。*
+
+### 2. 列出项目
+```bash
+ols list
+```
+
+### 3. 下载与同步
+将项目下载到当前目录：
+```bash
+ols download "你的项目名称"
+```
+
+在项目目录中，运行双向同步：
+```bash
+ols
+```
+
+---
+**免责声明**: 本工具与 Overleaf 官方无关。请自行承担使用风险。

overleaf_sync_fixed-1.2.0/olsync/__init__.py

@@ -0,0 +1,3 @@
+"""Overleaf Two-Way Sync Tool"""
+
+__version__ = '1.2.0'

overleaf_sync_fixed-1.2.0/olsync/debug_ids.py

@@ -0,0 +1,55 @@
+import re
+import sys
+import pickle
+import os
+import requests as reqs
+from olsync.olclient import OverleafClient
+
+def debug_ids(project_id):
+    cookie_path = ".olauth"
+    if not os.path.isfile(cookie_path):
+        print("Error: .olauth not found")
+        return
+
+    with open(cookie_path, 'rb') as f:
+        store = pickle.load(f)
+
+    client = OverleafClient(store["cookie"], store["csrf"])
+    
+    urls = [
+        f"https://www.overleaf.com/project/{project_id}",
+        f"https://www.overleaf.com/project/{project_id}/editor"
+    ]
+    
+    print(f"Project ID: {project_id}")
+    
+    for url in urls:
+        print(f"\nFetching {url}...")
+        r = reqs.get(url, cookies=client._cookie, headers=client._headers)
+        if r.status_code != 200:
+            print(f"Failed to fetch {url}: {r.status_code}")
+            continue
+            
+        ids = re.findall(r'[a-f0-9]{24}', r.text)
+        unique_ids = sorted(list(set(ids)))
+        
+        print(f"Found {len(ids)} ID-like strings ({len(unique_ids)} unique):")
+        for i in unique_ids:
+            overlap = 0
+            for c1, c2 in zip(project_id, i):
+                if c1 == c2: overlap += 1
+                else: break
+            
+            suffix = ""
+            if i == project_id:
+                suffix = " (PROJECT ID)"
+            elif overlap >= 20:
+                suffix = f" (STRONG CANDIDATE, overlap {overlap})"
+                
+            print(f"  {i}{suffix}")
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python debug_ids.py <project_id>")
+    else:
+        debug_ids(sys.argv[1])

overleaf_sync_fixed-1.2.0/olsync/olbrowserlogin.py

@@ -0,0 +1,99 @@
+"""Ol Browser Login Utility"""
+##################################################
+# MIT License
+##################################################
+# File: olbrowserlogin.py
+# Description: Overleaf Browser Login Utility
+# Author: Moritz Glöckl
+# License: MIT
+# Version: 1.2.0
+##################################################
+
+from PySide6.QtCore import *
+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
+# 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"]
+
+
+class OlBrowserLoginWindow(QMainWindow):
+    """
+    Overleaf Browser Login Utility
+    Opens a browser window to securely login the user and returns relevant login data.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super(OlBrowserLoginWindow, self).__init__(*args, **kwargs)
+
+        self.webview = QWebEngineView()
+
+        self._cookies = {}
+        self._csrf = ""
+        self._login_success = False
+
+        self.profile = QWebEngineProfile(self.webview)
+        self.cookie_store = self.profile.cookieStore()
+        self.cookie_store.cookieAdded.connect(self.handle_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.handle_load_finished)
+
+        self.setCentralWidget(self.webview)
+        self.resize(600, 700)
+
+    def handle_load_finished(self):
+        def callback(result):
+            self._csrf = result
+            self._login_success = True
+            QCoreApplication.quit()
+
+        if self.webview.url().toString() == PROJECT_URL:
+            self.webview.page().runJavaScript(
+                JAVASCRIPT_CSRF_EXTRACTOR, 0, callback
+            )
+
+    def handle_cookie_added(self, cookie):
+        cookie_name = cookie.name().data().decode('utf-8')
+        if cookie_name in COOKIE_NAMES:
+            self._cookies[cookie_name] = cookie.value().data().decode('utf-8')
+
+    @property
+    def cookies(self):
+        return self._cookies
+
+    @property
+    def csrf(self):
+        return self._csrf
+
+    @property
+    def login_success(self):
+        return self._login_success
+
+
+def login():
+    from PySide6.QtCore import QLoggingCategory
+    QLoggingCategory.setFilterRules('''\
+    qt.webenginecontext.info=false
+    ''')
+
+    app = QApplication([])
+    ol_browser_login_window = OlBrowserLoginWindow()
+    ol_browser_login_window.show()
+    app.exec()
+
+    if not ol_browser_login_window.login_success:
+        return None
+
+    return {"cookie": ol_browser_login_window.cookies, "csrf": ol_browser_login_window.csrf}

overleaf_sync_fixed-1.2.0/olsync/olclient.py

@@ -0,0 +1,243 @@
+"""Overleaf Client"""
+##################################################
+# MIT License
+##################################################
+# File: olclient.py
+# Description: Overleaf API Wrapper
+# Author: Moritz Glöckl
+# License: MIT
+# Version: 1.3.3
+##################################################
+
+import os
+import re
+import html
+import requests as reqs
+from bs4 import BeautifulSoup
+import json
+import uuid
+import time
+import traceback
+
+try:
+    import websocket
+    if not hasattr(websocket, 'SSLError'):
+        class SSLError(Exception): pass
+        websocket.SSLError = SSLError
+except ImportError:
+    pass
+
+# URLs
+LOGIN_URL = "https://www.overleaf.com/login"
+PROJECT_URL = "https://www.overleaf.com/project"
+DOWNLOAD_URL = "https://www.overleaf.com/project/{}/download/zip"
+UPLOAD_URL = "https://www.overleaf.com/project/{}/upload"
+FOLDER_URL = "https://www.overleaf.com/project/{}/folder"
+DELETE_URL = "https://www.overleaf.com/project/{}/doc/{}"
+COMPILE_URL = "https://www.overleaf.com/project/{}/compile?enable_pdf_caching=true"
+BASE_URL = "https://www.overleaf.com"
+PATH_SEP = "/"
+
+class OverleafClient(object):
+    @staticmethod
+    def filter_projects(json_content, more_attrs=None):
+        more_attrs = more_attrs or {}
+        for p in json_content:
+            if not p.get("archived") and not p.get("trashed"):
+                if all(p.get(k) == v for k, v in more_attrs.items()):
+                    yield p
+
+    def __init__(self, cookie=None, csrf=None):
+        self._cookie = cookie
+        self._csrf = csrf
+        self._headers = {
+            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+            "Accept-Language": "en-US,en;q=0.9",
+        }
+
+    def all_projects(self):
+        projects_page = reqs.get(PROJECT_URL, cookies=self._cookie, headers=self._headers)
+        if not projects_page.ok:
+            if projects_page.status_code in [401, 403]:
+                raise PermissionError("Authentication failed. Cookie expired.")
+            raise reqs.HTTPError(f"HTTP {projects_page.status_code}")
+
+        text = html.unescape(projects_page.text)
+        json_content = None
+        
+        soup = BeautifulSoup(text, 'html.parser')
+        meta_projects = soup.find('meta', {'name': 'ol-projects'})
+        if meta_projects:
+            try: json_content = json.loads(meta_projects.get('content'))
+            except: pass
+
+        if json_content is None:
+            markers = ['"projects":[', 'preloadedProjects:[', 'initialProjects:[']
+            for marker in markers:
+                start_pos = text.find(marker)
+                if start_pos != -1:
+                    start_idx = start_pos + len(marker) - 1
+                    bc, in_str, esc = 0, False, False
+                    for i in range(start_idx, len(text)):
+                        c = text[i]
+                        if esc: esc = False; continue
+                        if c == '\\': esc = True; continue
+                        if c == '"': in_str = not in_str; continue
+                        if not in_str:
+                            if c == '[': bc += 1
+                            elif c == ']': bc -= 1
+                            if bc == 0:
+                                try:
+                                    json_content = json.loads(text[start_idx:i+1])
+                                    break
+                                except: continue
+                    if json_content: break
+
+        if json_content is None:
+            if "login" in projects_page.url or "Log In" in text:
+                raise PermissionError("Authentication failed. Cookie might be expired.")
+            raise AttributeError("Could not find project list. Overleaf layout may have changed.")
+        
+        if isinstance(json_content, dict) and 'projects' in json_content: json_content = json_content['projects']
+        return list(OverleafClient.filter_projects(json_content))
+
+    def get_project(self, project_name):
+        projects = self.all_projects()
+        project = next((p for p in projects if p['name'] == project_name), None)
+        if not project: raise ValueError(f"Project '{project_name}' not found.")
+        return project
+
+    def download_project(self, project_id):
+        r = reqs.get(DOWNLOAD_URL.format(project_id), stream=True, cookies=self._cookie, headers=self._headers)
+        return r.content
+
+    def create_folder(self, project_id, parent_folder_id, folder_name):
+        params = {"name": folder_name}
+        if parent_folder_id: params["parent_folder_id"] = parent_folder_id
+        h = self._headers.copy()
+        h.update({"X-Csrf-Token": self._csrf})
+        r = reqs.post(FOLDER_URL.format(project_id), cookies=self._cookie, headers=h, json=params)
+        if r.ok: return json.loads(r.content)
+        return None
+
+    def get_project_infos(self, project_id, verbose_error_logging=False, file_list=None):
+        project_meta_json = None
+        try:
+            url = BASE_URL + f"/project/{project_id}/metadata"
+            h = self._headers.copy()
+            h.update({"X-Csrf-Token": self._csrf, "X-Requested-With": "XMLHttpRequest", "Referer": BASE_URL + f"/project/{project_id}"})
+            r = reqs.get(url, cookies=self._cookie, headers=h)
+            if r.status_code == 200: project_meta_json = r.json()
+        except: pass
+
+        # Discovery by creation
+        try:
+            name = f"olsync_find_{uuid.uuid4().hex[:6]}"
+            h = self._headers.copy()
+            h.update({"X-Csrf-Token": self._csrf, "Referer": BASE_URL + f"/project/{project_id}"})
+            r = reqs.post(BASE_URL + f"/project/{project_id}/folder", cookies=self._cookie, headers=h, json={"name": name})
+            if r.ok:
+                data = r.json()
+                root_id = data.get('parent_folder_id') or data.get('root_folder_id') or data.get('parentFolderId')
+                new_id = data.get('_id')
+                if new_id: reqs.delete(BASE_URL + f"/project/{project_id}/folder/{new_id}", cookies=self._cookie, headers=h, json={})
+                if root_id: return {'rootFolder': {'_id': root_id, 'folders': [], 'docs': []}}
+        except: pass
+
+        if project_meta_json and 'projectMeta' in project_meta_json:
+            for k in project_meta_json['projectMeta'].keys():
+                if k.endswith("92") or k.endswith("c86"):
+                    return {'rootFolder': {'_id': k, 'folders': [], 'docs': []}}
+        
+        return {'rootFolder': {'_id': project_id, 'folders': [], 'docs': []}}
+
+    def find_file_id_by_name(self, project_id, file_name, verbose_error_logging=False):
+        try:
+            r = reqs.get(BASE_URL + f"/project/{project_id}", cookies=self._cookie, headers=self._headers)
+            if r.status_code == 200:
+                pattern = r'["\']name["\']\s*:\s*["\']' + re.escape(file_name) + r'["\'].*?["\'](?:_id|id)["\']\s*:\s*["\']([a-f0-9]{24})["\']'
+                match = re.search(pattern, r.text, re.DOTALL)
+                if match: return match.group(1)
+        except: pass
+        return None
+
+    def update_doc(self, project_id, doc_id, content):
+        url = BASE_URL + f"/project/{project_id}/doc/{doc_id}"
+        h = self._headers.copy()
+        h.update({"X-Csrf-Token": self._csrf, "Content-Type": "application/json", "Referer": BASE_URL + f"/project/{project_id}/editor"})
+        for payload in [{"content": content}, {"content": content.split('\n')}]:
+            r = reqs.put(url, cookies=self._cookie, headers=h, json=payload)
+            if r.ok: return True
+        return False
+
+    def upload_file(self, project_id, project_infos, file_name, file_size, file, verbose_error_logging=False):
+        """
+        Uploads a file. Handles text files via Doc API and others via Multipart.
+        """
+        clean_name = file_name.split(PATH_SEP)[-1]
+        
+        # 1. TEXT FILE STRATEGY
+        if file_name.endswith(('.tex', '.bib', '.cls', '.sty')):
+            if verbose_error_logging: print(f"[DEBUG] Text File Strategy for {clean_name}")
+            try:
+                if hasattr(file, 'seek'): file.seek(0)
+                content = file.read()
+                if isinstance(content, bytes): content = content.decode('utf-8', errors='replace')
+                
+                fid = self.find_file_id_by_name(project_id, clean_name, verbose_error_logging)
+                if fid:
+                    if verbose_error_logging: print(f"[DEBUG] Updating existing {fid}")
+                    if self.update_doc(project_id, fid, content): return True
+                    self.delete_file(project_id, project_infos, file_name)
+                    time.sleep(0.5)
+
+                doc_url = BASE_URL + f"/project/{project_id}/doc"
+                h = self._headers.copy()
+                h.update({"X-Csrf-Token": self._csrf, "Referer": BASE_URL + f"/project/{project_id}/editor"})
+                folder_id = project_infos.get('rootFolder', {}).get('_id') if project_infos else None
+                for p_id in [folder_id, None]:
+                    r = reqs.post(doc_url, cookies=self._cookie, headers=h, json={"name": clean_name, "parent_folder_id": p_id})
+                    if r.ok:
+                        nid = r.json().get('_id')
+                        if nid: self.update_doc(project_id, nid, content)
+                        return True
+            except Exception as e:
+                if verbose_error_logging: print(f"[DEBUG] Doc API failed: {e}")
+
+        # 2. MULTIPART STRATEGY
+        url = UPLOAD_URL.format(project_id)
+        h = self._headers.copy()
+        h.update({"X-Csrf-Token": self._csrf, "X-Requested-With": "XMLHttpRequest", "Referer": BASE_URL + f"/project/{project_id}/editor", "Origin": BASE_URL})
+        folder_id = project_infos.get('rootFolder', {}).get('_id') if project_infos else None
+        for fid in [folder_id, "", project_id]:
+            if hasattr(file, 'seek'): file.seek(0)
+            data = {"folder_id": fid if fid is not None else "", "qquuid": str(uuid.uuid4()), "qqfilename": clean_name, "qqtotalfilesize": file_size, "upload_params": '{"is_not_standard_upload":true}', "csrf_token": self._csrf, "_csrf": self._csrf}
+            if data["folder_id"] is None: data.pop("folder_id")
+            try:
+                r = reqs.post(url, cookies=self._cookie, data=data, files={"qqfile": (clean_name, file, 'application/octet-stream')}, headers=h)
+                if r.status_code == 200 and r.json().get("success"): return True
+            except: pass
+            
+        raise reqs.HTTPError(f"Upload failed for {clean_name}")
+
+    def delete_file(self, project_id, project_infos, file_name):
+        fid = self.find_file_id_by_name(project_id, file_name.split(PATH_SEP)[-1])
+        if not fid: return False
+        h = self._headers.copy()
+        h.update({"X-Csrf-Token": self._csrf})
+        r = reqs.delete(DELETE_URL.format(project_id, fid), cookies=self._cookie, headers=h, json={})
+        return r.status_code == 204
+
+    def download_pdf(self, project_id):
+        h = self._headers.copy()
+        h.update({"X-Csrf-Token": self._csrf})
+        body = {"check": "silent", "draft": False, "incrementalCompilesEnabled": True, "rootDoc_id": "", "stopOnFirstError": False}
+        r = reqs.post(COMPILE_URL.format(project_id), cookies=self._cookie, headers=h, json=body)
+        if not r.ok: raise reqs.HTTPError()
+        res = r.json()
+        if res["status"] != "success": raise reqs.HTTPError()
+        pdf = next(v for v in res['outputFiles'] if v['type'] == 'pdf')
+        dr = reqs.get(BASE_URL + pdf['url'], cookies=self._cookie, headers=h)
+        if dr.ok: return pdf['path'], dr.content
+        return None

overleaf_sync_fixed-1.2.0/olsync/olsync.py

@@ -0,0 +1,479 @@
+"""Overleaf Two-Way Sync Tool"""
+##################################################
+# MIT License
+##################################################
+# File: olsync.py
+# Description: Overleaf Two-Way Sync
+# Author: Moritz Glöckl
+# License: MIT
+# Version: 1.2.0
+##################################################
+
+import click
+import os
+from yaspin import yaspin
+import pickle
+import zipfile
+import io
+import dateutil.parser
+import glob
+import fnmatch
+import traceback
+from pathlib import Path
+
+try:
+    # Import for pip installation / wheel
+    from olsync.olclient import OverleafClient
+    import olsync.olbrowserlogin as olbrowserlogin
+except ImportError:
+    # Import for development
+    from olclient import OverleafClient
+    import olbrowserlogin
+
+
+def find_olauth(start_path, filename=".olauth"):
+    """Search for the auth file in the current directory and all parent directories."""
+    current = Path(start_path).resolve()
+    while True:
+        candidate = current / filename
+        if candidate.is_file():
+            return str(candidate)
+        if current.parent == current:  # Reached root directory
+            break
+        current = current.parent
+    return None
+
+@click.group(invoke_without_command=True)
+@click.option('-l', '--local-only', 'local', is_flag=True, help="Sync local project files to Overleaf only.")
+@click.option('-r', '--remote-only', 'remote', is_flag=True,
+              help="Sync remote project files from Overleaf to local file system only.")
+@click.option('-n', '--name', 'project_name', default="",
+              help="Specify the Overleaf project name instead of the default name of the sync directory.")
+@click.option('--store-path', 'cookie_path', default=".olauth", type=click.Path(exists=False),
+              help="Relative path to load the persisted Overleaf cookie.")
+@click.option('-p', '--path', 'sync_path', default=".", type=click.Path(exists=True),
+              help="Path of the project to sync.")
+@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.")
+@click.option('-v', '--verbose', 'verbose', is_flag=True, help="Enable extended error logging.")
+@click.version_option(package_name='overleaf-sync-fixed')
+@click.pass_context
+def main(ctx, local, remote, project_name, cookie_path, sync_path, olignore_path, verbose):
+    if verbose:
+        click.echo("[DEBUG] Running olsync.py version with enhanced debugging")
+    if ctx.invoked_subcommand is None:
+        # Search for .olauth in current or parent directories
+        resolved_cookie_path = find_olauth(os.getcwd(), cookie_path) if cookie_path == ".olauth" else cookie_path
+        
+        if not resolved_cookie_path or not os.path.isfile(resolved_cookie_path):
+            raise click.ClickException(
+                "Persisted Overleaf cookie not found. Please login or check store path.")
+
+        with open(resolved_cookie_path, 'rb') as f:
+            store = pickle.load(f)
+
+        overleaf_client = OverleafClient(store["cookie"], store["csrf"])
+
+        # Change the current directory to the specified sync path
+        os.chdir(sync_path)
+
+        project_name = project_name or os.path.basename(os.getcwd())
+        
+        project = execute_action(
+            lambda: overleaf_client.get_project(project_name),
+            "Querying project",
+            "Project queried successfully.",
+            "Project could not be queried.",
+            verbose)
+
+        zip_file = execute_action(
+            lambda: zipfile.ZipFile(io.BytesIO(
+                overleaf_client.download_project(project["id"]))),
+            "Downloading project",
+            "Project downloaded successfully.",
+            "Project could not be downloaded.",
+            verbose)
+
+        project_infos = execute_action(
+            lambda: overleaf_client.get_project_infos(project["id"], verbose, file_list=zip_file.namelist()),
+            "Querying project details",
+            "Project details queried successfully.",
+            "Project details could not be queried (Optional).",
+            verbose,
+            is_optional=True)
+        
+        if not project_infos and verbose:
+            click.echo("[DEBUG] Proceeding without project_infos. File uploads/deletes will fail.")
+
+        sync = not (local or remote)
+
+        # Sync local to remote
+        if local or sync:
+            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],
+                create_file_at_to=lambda name: overleaf_client.upload_file(
+                    project["id"], project_infos, name, os.path.getsize(name), open(name, 'rb'), verbose),
+                delete_file_at_to=lambda name: overleaf_client.delete_file(project["id"], project_infos, name),
+                create_file_at_from=lambda name: write_file(name, zip_file.read(name)),
+                from_exists_in_to=lambda name: name in zip_file.namelist(),
+                from_equal_to_to=lambda name: open(name, 'rb').read() == zip_file.read(name),
+                # Local-to-remote: if not equal, local takes priority
+                from_newer_than_to=lambda name: True,
+                from_name="local",
+                to_name="remote",
+                verbose=verbose,
+                ask=False)
+
+        # Sync remote to local
+        if remote or sync:
+            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],
+                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(
+                    project["id"], project_infos, name, os.path.getsize(name), open(name, 'rb'), verbose),
+                from_exists_in_to=lambda name: os.path.isfile(name),
+                from_equal_to_to=lambda name: open(name, 'rb').read() == zip_file.read(name),
+                from_newer_than_to=lambda name: dateutil.parser.isoparse(project["lastUpdated"]).timestamp() >
+                                                os.path.getmtime(name),
+                from_name="remote",
+                to_name="local",
+                verbose=verbose,
+                ask=True)
+
+
+@main.command()
+@click.option('--path', 'cookie_path', default=".olauth", type=click.Path(exists=False),
+              help="Path to store the persisted Overleaf cookie.")
+@click.option('-v', '--verbose', 'verbose', is_flag=True, help="Enable extended error logging.")
+def login(cookie_path, verbose):
+    if os.path.isfile(cookie_path) and not click.confirm(
+            'Persisted Overleaf cookie already exist. Do you want to override it?'):
+        return
+    click.clear()
+    execute_action(lambda: login_handler(cookie_path), "Login",
+                   "Login successful. Cookie persisted as `" + click.format_filename(
+                       cookie_path) + "`. You may now sync your project.",
+                   "Login failed. Please try again.", 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.")
+@click.option('-v', '--verbose', 'verbose', is_flag=True, help="Enable extended error logging.")
+def list_projects(cookie_path, verbose):
+    def query_projects():
+        all_p = overleaf_client.all_projects()
+        if not all_p:
+            click.echo("\nNo active projects found.")
+            return True
+        for index, p in enumerate(sorted(all_p, key=lambda x: x['lastUpdated'], reverse=True)):
+            if not index:
+                click.echo("\n")
+            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"])
+
+    click.clear()
+    execute_action(query_projects, "Querying all projects",
+                   "Querying all projects successful.",
+                   "Querying all projects failed.", verbose)
+
+
+@main.command(name='download')
+@click.argument('project_name', required=False)
+@click.option('--pdf', is_flag=True, help="Download compiled PDF instead of source code.")
+@click.option('--path', 'download_path', default=".", type=click.Path(exists=True), help="Directory to download to.")
+@click.option('--store-path', 'cookie_path', default=".olauth", type=click.Path(exists=False),
+              help="Relative path to load the persisted Overleaf cookie.")
+@click.option('-v', '--verbose', 'verbose', is_flag=True, help="Enable extended error logging.")
+def download(project_name, pdf, download_path, cookie_path, verbose):
+    """Download project source (default) or compiled PDF (--pdf)."""
+    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"])
+
+    project_name = project_name or os.path.basename(os.getcwd())
+    
+    project = execute_action(
+        lambda: overleaf_client.get_project(project_name),
+        "Querying project",
+        "Project queried successfully.",
+        "Project could not be queried.",
+        verbose)
+
+    if pdf:
+        # Download PDF
+        file_name, content = execute_action(
+            lambda: overleaf_client.download_pdf(project["id"]),
+            "Compiling and downloading PDF",
+            "PDF downloaded successfully.",
+            "PDF could not be downloaded.",
+            verbose)
+        if file_name and content:
+            target_path = os.path.join(download_path, file_name)
+            with open(target_path, 'wb') as f:
+                f.write(content)
+            click.echo(f"\n✅ Saved PDF to: {target_path}")
+    else:
+        # Download Source ZIP
+        content = execute_action(
+            lambda: overleaf_client.download_project(project["id"]),
+            "Downloading project source",
+            "Source downloaded successfully.",
+            "Source could not be downloaded.",
+            verbose)
+        
+        # Create a directory with the project name to ensure it matches for future syncs
+        target_dir = os.path.join(download_path, project["name"])
+        if not os.path.exists(target_dir):
+            os.makedirs(target_dir)
+            click.echo(f"Created directory: {target_dir}")
+        
+        import zipfile, io
+        with zipfile.ZipFile(io.BytesIO(content)) as z:
+            z.extractall(target_dir)
+        click.echo(f"\n✅ Extracted source to: {os.path.abspath(target_dir)}")
+        click.echo(f"💡 Hint: You can now 'cd \"{project['name']}\"' and run 'ols' to sync.")
+
+
+
+def login_handler(path):
+    store = olbrowserlogin.login()
+    if store is None:
+        return False
+    with open(path, 'wb+') as f:
+        pickle.dump(store, f)
+    return True
+
+
+def delete_file(path):
+    _dir = os.path.dirname(path)
+    if _dir == path:
+        return
+
+    if _dir != '' and not os.path.exists(_dir):
+        return
+    else:
+        os.remove(path)
+
+
+def write_file(path, content):
+    _dir = os.path.dirname(path)
+    if _dir == path:
+        return
+
+    # path is a file
+    if _dir != '' and not os.path.exists(_dir):
+        os.makedirs(_dir)
+
+    with open(path, 'wb+') as f:
+        f.write(content)
+
+
+def sync_func(files_from, deleted_files, create_file_at_to, delete_file_at_to, create_file_at_from, from_exists_in_to,
+              from_equal_to_to, from_newer_than_to, from_name,
+              to_name, verbose=False, ask=True):
+    click.echo("\nSyncing files from [%s] to [%s]" % (from_name, to_name))
+    click.echo('=' * 40)
+
+    newly_add_list = []
+    update_list = []
+    delete_list = []
+    restore_list = []
+    not_restored_list = []
+    not_sync_list = []
+    synced_list = []
+
+    for name in files_from:
+        if from_exists_in_to(name):
+            if not from_equal_to_to(name):
+                if ask and not from_newer_than_to(name) and not click.confirm(
+                        '\n-> Warning: last-edit time stamp of file <%s> from [%s] is older than [%s].\nContinue to '
+                        'overwrite with an older version?' % (name, from_name, to_name)):
+                    not_sync_list.append(name)
+                    continue
+                update_list.append(name)
+            else:
+                synced_list.append(name)
+        else:
+            newly_add_list.append(name)
+
+    for name in deleted_files:
+        if ask:
+            delete_choice = click.prompt(
+                '\n-> Warning: file <%s> does not exist on [%s] anymore (but it still exists on [%s]).'
+                '\nShould the file be [d]eleted, [r]estored or [i]gnored?' % (name, from_name, to_name),
+                default="i",
+                type=click.Choice(['d', 'r', 'i']))
+        else:
+            delete_choice = "i"
+            
+        if delete_choice == "d":
+            delete_list.append(name)
+        elif delete_choice == "r":
+            restore_list.append(name)
+        elif delete_choice == "i":
+            not_restored_list.append(name)
+
+    click.echo(
+        "\n[NEW] Following new file(s) created on [%s]" % to_name)
+    for name in newly_add_list:
+        click.echo("\t%s" % name)
+        try:
+            create_file_at_to(name)
+        except Exception as e:
+            if verbose:
+                click.echo(f"\t[WARN] Failed to create {name} on {to_name}: {e}")
+            else:
+                click.echo(f"\t[WARN] Failed to create {name}")
+
+    click.echo(
+        "\n[NEW] Following new file(s) created on [%s]" % from_name)
+    for name in restore_list:
+        click.echo("\t%s" % name)
+        try:
+            create_file_at_from(name)
+        except Exception as e:
+            click.echo(f"\t[WARN] Failed to restore {name}: {e}")
+
+    click.echo(
+        "\n[UPDATE] Following file(s) updated on [%s]" % to_name)
+    for name in update_list:
+        click.echo("\t%s" % name)
+        try:
+            if to_name == "remote":
+                # Delete and recreate is much more reliable for remote updates
+                delete_file_at_to(name)
+                create_file_at_to(name)
+            else:
+                create_file_at_to(name)
+        except Exception as e:
+            if verbose:
+                click.echo(f"\t[WARN] Failed to update {name} on {to_name}: {e}")
+            else:
+                click.echo(f"\t[WARN] Failed to update {name}")
+
+    click.echo(
+        "\n[DELETE] Following file(s) deleted on [%s]" % to_name)
+    for name in delete_list:
+        click.echo("\t%s" % name)
+        try:
+            delete_file_at_to(name)
+        except Exception as e:
+            if verbose:
+                print(traceback.format_exc())
+            raise click.ClickException(f"\n[ERROR] An error occurred while deleting file(s) on [{to_name}]: {str(e)}")
+
+    click.echo(
+        "\n[SYNC] Following file(s) are up to date")
+    for name in synced_list:
+        click.echo("\t%s" % name)
+
+    click.echo(
+        "\n[SKIP] Following file(s) on [%s] have not been synced to [%s]" % (from_name, to_name))
+    for name in not_sync_list:
+        click.echo("\t%s" % name)
+
+    click.echo(
+        "\n[SKIP] Following file(s) on [%s] have not been synced to [%s]" % (to_name, from_name))
+    for name in not_restored_list:
+        click.echo("\t%s" % name)
+
+    click.echo("")
+    click.echo("✅  Synced files from [%s] to [%s]" % (from_name, to_name))
+    click.echo("")
+
+
+def execute_action(action, progress_message, success_message, fail_message, verbose_error_logging=False, is_optional=False):
+    with yaspin(text=progress_message, color="green") as spinner:
+        success = None
+        error_detail = ""
+        try:
+            if verbose_error_logging:
+                click.echo(f"\n[DEBUG] Starting action: {progress_message}")
+            success = action()
+            if verbose_error_logging:
+                click.echo(f"[DEBUG] Action result: {success}")
+        except Exception as e:
+            error_detail = str(e) or "Unknown exception occurred"
+            if verbose_error_logging:
+                click.echo(f"[DEBUG] Exception caught: {error_detail}")
+                click.echo(traceback.format_exc())
+            success = False
+
+        if success:
+            spinner.write(success_message)
+            spinner.ok("✅ ")
+            return success
+        else:
+            spinner.fail("💥 ")
+            if error_detail:
+                fail_message = f"{fail_message} ({error_detail})"
+            elif success is None:
+                fail_message = f"{fail_message} (Action returned None)"
+
+            if verbose_error_logging:
+                click.echo(f"[DEBUG] Failing with: {fail_message}")
+
+            if is_optional:
+                click.echo(f"⚠️  Warning: {fail_message}")
+                return None
+            else:
+                raise click.ClickException(fail_message)
+
+def olignore_keep_list(olignore_path):
+    """
+    The list of files to keep synced, with support for sub-folders.
+    Should only be called when syncing from local to remote.
+    """
+    # get list of files recursively
+    files = glob.glob('**', recursive=True)
+
+    # System ignore list: things we NEVER want to sync to Overleaf
+    system_ignore = [
+        '.olauth', '.olignore', '.git', '.DS_Store', 
+        '__pycache__', 'debug_dashboard.html', 'debug_project_page.html'
+    ]
+
+    if not os.path.isfile(olignore_path):
+        keep_list = files
+    else:
+        with open(olignore_path, 'r') as f:
+            ignore_pattern = f.read().splitlines()
+
+        keep_list = [f for f in files if not any(
+            fnmatch.fnmatch(f, ignore) for ignore in ignore_pattern)]
+
+    # Filter out system ignore files and directories
+    # We use Path(item).parts to check if any part of the path is in system_ignore
+    filtered_list = []
+    for item in keep_list:
+        path_obj = Path(item)
+        if any(part in system_ignore for part in path_obj.parts):
+            continue
+        if path_obj.is_dir():
+            continue
+        filtered_list.append(path_obj.as_posix())
+
+    return filtered_list
+
+
+if __name__ == "__main__":
+    main()

overleaf_sync_fixed-1.2.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["flit"]
+build-backend = "flit.buildapi"
+
+[tool.flit.metadata]
+module = "olsync"
+dist-name = "overleaf-sync-fixed"
+description-file = "README.md"
+author = "Lawrence Yang (Fixed)"
+author-email = "lawrenceeyang@gmail.com"
+home-page = "https://github.com/lawrencee/overleaf-sync-fixed"
+classifiers = ["License :: OSI Approved :: MIT License", "Intended Audience :: Science/Research", "Programming Language :: Python :: 3"]
+requires-python = ">=3"
+requires = [
+    "requests == 2.*",
+    "beautifulsoup4 == 4.11.1",
+    "yaspin == 2.*",
+    "python-dateutil~=2.8.1",
+    "click == 8.*",
+    "PySide6 == 6.*"
+]
+keywords = "overleaf sync latex tex fix"
+
+[tool.flit.scripts]
+ols = "olsync.olsync:main"

overleaf_sync_fixed-1.2.0/requirements.txt

@@ -0,0 +1,6 @@
+requests==2.*
+beautifulsoup4==4.11.1
+yaspin==2.*
+python-dateutil~=2.8.1
+click==8.*
+PySide6==6.*