claudesync 0.2.5__tar.gz → 0.2.7__tar.gz

{claudesync-0.2.5/src/claudesync.egg-info → claudesync-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: claudesync
-Version: 0.2.5
+Version: 0.2.7
 Summary: A tool to synchronize local files with Claude.ai projects
 Author-email: Jahziah Wagner <jahziah.wagner+pypi@gmail.com>
 Project-URL: Homepage, https://github.com/jahwag/claudesync

{claudesync-0.2.5 → claudesync-0.2.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claudesync"
-version = "0.2.5"
+version = "0.2.7"
 authors = [
     {name = "Jahziah Wagner", email = "jahziah.wagner+pypi@gmail.com"},
 ]

{claudesync-0.2.5 → claudesync-0.2.7}/src/claudesync/file_handler.py

@@ -1,11 +1,13 @@
 import os
+import mimetypes
+import time
 from watchdog.events import FileSystemEventHandler
 from .debounce import DebounceHandler
 from .gitignore_utils import load_gitignore, should_ignore
 import requests
 
 class FileUploadHandler(FileSystemEventHandler):
-    def __init__(self, api_endpoint, session_key, base_path, delay=5):
+    def __init__(self, api_endpoint, session_key, base_path, delay=5, max_file_size=1024*320):  # 320 KB limit or roughly 4k lines
         self.api_endpoint = api_endpoint
         self.session_key = session_key
         self.base_path = os.path.abspath(base_path)
@@ -19,6 +21,11 @@ class FileUploadHandler(FileSystemEventHandler):
         self.debouncer = DebounceHandler(delay)
         self.gitignore = load_gitignore(self.base_path)
         self.log_callback = None
+        self.max_file_size = max_file_size
+        self.backoff_time = 1
+        self.max_backoff_time = 60
+        self.session_expiration_time = 180  # 3 minutes
+        self.session_expiration_start = None
 
     def log(self, message):
         if self.log_callback:
@@ -35,46 +42,72 @@ class FileUploadHandler(FileSystemEventHandler):
             self.debouncer.debounce(self.upload_file, event.src_path)
 
     def should_ignore_file(self, file_path):
-            # Check if the file is in the .git directory
-            rel_path = os.path.relpath(file_path, self.base_path)
-            if rel_path.startswith('.git' + os.path.sep) or rel_path == '.git':
-                return True
+        # Check if the file is in the .git directory
+        rel_path = os.path.relpath(file_path, self.base_path)
+        if rel_path.startswith('.git' + os.path.sep) or rel_path == '.git':
+            return True
+
+        # Check file size
+        if os.path.getsize(file_path) > self.max_file_size:
+            self.log(f"Ignoring large file: {file_path}")
+            return True
+
+        # Check file type
+        mime_type, _ = mimetypes.guess_type(file_path)
+        if mime_type and not mime_type.startswith('text/'):
+            self.log(f"Ignoring non-text file: {file_path}")
+            return True
 
-            # Check if the file should be ignored based on .gitignore
-            return should_ignore(self.gitignore, file_path, self.base_path)
+        # Check if the file should be ignored based on .gitignore
+        return should_ignore(self.gitignore, file_path, self.base_path)
 
     def api_request(self, method, url, **kwargs):
-        try:
-            response = requests.request(method, url, headers=self.headers, cookies=self.cookies, **kwargs)
-            response.raise_for_status()
-            return response.json() if response.text else None
-        except requests.RequestException as e:
-            print(f"API request error: {str(e)}")
-            return None
+        while True:
+            try:
+                response = requests.request(method, url, headers=self.headers, cookies=self.cookies, **kwargs)
+                if response.status_code == 403:
+                    if self.session_expiration_start is None:
+                        self.session_expiration_start = time.time()
+                    elif time.time() - self.session_expiration_start > self.session_expiration_time:
+                        self.log("Session key has likely expired. Please restart ClaudeSync with a new session key.")
+                        raise SystemExit(1)
+
+                    self.log(f"Received 403 error. Backing off for {self.backoff_time} seconds.")
+                    time.sleep(self.backoff_time)
+                    self.backoff_time = min(self.backoff_time * 2, self.max_backoff_time)
+                else:
+                    self.session_expiration_start = None
+                    self.backoff_time = 1
+                    response.raise_for_status()
+                    return response.json() if response.text else None
+            except requests.RequestException as e:
+                if response.status_code != 403:
+                    self.log(f"API request error: {str(e)}")
+                    return None
 
     def get_documents(self):
         return self.api_request('GET', self.api_endpoint) or []
 
     def delete_document(self, uuid):
         if self.api_request('DELETE', f"{self.api_endpoint}/{uuid}"):
-            print(f"Deleted document: {uuid}")
+            self.log(f"Deleted document: {uuid}")
 
     def delete_all_documents(self):
         for doc in self.get_documents():
             self.delete_document(doc['uuid'])
-        print("All documents deleted.")
+        self.log("All documents deleted.")
 
     def upload_file(self, file_path):
         if not os.path.isfile(file_path) or self.should_ignore_file(file_path):
             return
         if os.path.getsize(file_path) == 0:
-            print(f"Skipping empty file: {file_path}")
+            self.log(f"Skipping empty file: {file_path}")
             return
         try:
             with open(file_path, 'r', encoding='utf-8') as file:
                 content = file.read()
             if not content.strip():
-                print(f"Skipping file with only whitespace: {file_path}")
+                self.log(f"Skipping file with only whitespace: {file_path}")
                 return
 
             rel_path = os.path.relpath(file_path, self.base_path)
@@ -87,5 +120,4 @@ class FileUploadHandler(FileSystemEventHandler):
             if self.api_request('POST', self.api_endpoint, json=payload):
                 self.log(f"Uploaded: {file_name}")
         except Exception as e:
-            print(f"Error processing file {file_path}: {str(e)}")
-
+            self.log(f"Error processing file {file_path}: {str(e)}")

claudesync-0.2.7/src/claudesync/main.py

@@ -0,0 +1,163 @@
+import blessed
+import time
+import argparse
+import json
+import os
+import sys
+from watchdog.observers import Observer
+from .manual_auth import get_session_key, get_or_update_config_value, get_config, save_config
+from .file_handler import FileUploadHandler
+from .api_utils import fetch_user_id, fetch_projects, select_project
+
+class ClaudeSyncTUI:
+    def __init__(self, session_key, watch_dir, user_id, project_id, delay):
+        self.term = blessed.Terminal()
+        self.session_key = session_key
+        self.watch_dir = watch_dir
+        self.user_id = user_id
+        self.project_id = project_id
+        self.delay = delay
+        self.log_messages = []
+        self.observer = None
+        self.handler = None
+        self.scroll_position = 0
+        self.max_log_lines = 1000
+        self.auto_scroll = True
+        self.is_syncing = False
+
+    def setup(self):
+        if not self.user_id:
+            self.user_id = fetch_user_id(self.session_key)
+        if not self.project_id:
+            projects = fetch_projects(self.user_id, self.session_key)
+            self.project_id = select_project(projects, self.user_id, self.session_key)
+
+        api_endpoint = f"https://claude.ai/api/organizations/{self.user_id}/projects/{self.project_id}/docs"
+        self.handler = FileUploadHandler(api_endpoint, self.session_key, self.watch_dir, self.delay)
+        self.handler.log_callback = self.add_log_message
+
+        self.observer = Observer()
+        self.observer.schedule(self.handler, self.watch_dir, recursive=True)
+
+    def initial_sync(self):
+        self.is_syncing = True
+        self.add_log_message("Starting initial synchronization...")
+        for root, dirs, files in os.walk(self.watch_dir):
+            for file in files:
+                file_path = os.path.join(root, file)
+                if not self.handler.should_ignore_file(file_path):
+                    self.handler.upload_file(file_path)
+                    self.draw()  # Redraw the TUI after each file upload
+        self.add_log_message("Initial synchronization completed.")
+        self.is_syncing = False
+
+    def add_log_message(self, message):
+        self.log_messages.append(message)
+        if len(self.log_messages) > self.max_log_lines:
+            self.log_messages.pop(0)
+        if self.auto_scroll:
+            self.scroll_to_bottom()
+
+    def scroll_to_bottom(self):
+        self.scroll_position = max(0, len(self.log_messages) - (self.term.height - 11))
+
+    def draw(self):
+        print(self.term.clear())
+        print(self.term.move_y(0) + self.term.black_on_skyblue(self.term.center('ClaudeSync TUI')))
+
+        print(self.term.move_y(2) + f"Watching directory: {self.watch_dir}")
+        print(f"Upload delay: {self.delay} seconds")
+        print(f"User ID: {self.user_id}")
+        print(f"Project ID: {self.project_id}")
+        print(f"Auto-scroll: {'ON' if self.auto_scroll else 'OFF'}")
+
+        if self.is_syncing:
+            print(self.term.move_y(7) + self.term.red("Initial sync in progress..."))
+
+        print(self.term.move_y(8) + self.term.black_on_skyblue(self.term.center('Recent Activity')))
+
+        log_height = self.term.height - 12
+        visible_logs = self.log_messages[self.scroll_position:self.scroll_position + log_height]
+        for i, message in enumerate(visible_logs):
+            print(self.term.move_y(10 + i) + message)
+
+        print(self.term.move_y(self.term.height - 1) + "Press 'q' to quit, 'j'/'k' to scroll, 'a' to toggle auto-scroll")
+
+    def run(self):
+        with self.term.cbreak(), self.term.hidden_cursor():
+            self.draw()  # Initial draw before starting sync
+            self.initial_sync()
+            self.observer.start()
+            while True:
+                self.draw()
+                inp = self.term.inkey(timeout=0.1)
+                if inp == 'q':
+                    break
+                elif inp == 'j':
+                    self.auto_scroll = False
+                    self.scroll_position = min(len(self.log_messages) - 1, self.scroll_position + 1)
+                elif inp == 'k':
+                    self.auto_scroll = False
+                    self.scroll_position = max(0, self.scroll_position - 1)
+                elif inp == 'a':
+                    self.auto_scroll = not self.auto_scroll
+                    if self.auto_scroll:
+                        self.scroll_to_bottom()
+
+        self.observer.stop()
+        self.observer.join()
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Sync local files with Claude.ai projects.")
+    parser.add_argument("--session-key", help="Session key for authentication")
+    parser.add_argument("--watch-dir", default=".", help="Directory to watch for changes")
+    parser.add_argument("--user-id", help="User ID for Claude API")
+    parser.add_argument("--project-id", help="Project ID for Claude API")
+    parser.add_argument("--delay", type=int, help="Delay in seconds before uploading")
+    args = parser.parse_args()
+
+    config = get_config()
+
+    # Get or update session key
+    session_key = args.session_key or get_session_key()
+
+    # Get or update watch directory
+    watch_dir = args.watch_dir or get_or_update_config_value('watch_dir', "Enter the directory to watch", ".")
+
+    # Get or fetch user ID
+    user_id = args.user_id or config.get('user_id')
+    if not user_id:
+        print("Fetching user ID...")
+        user_id = fetch_user_id(session_key)
+        config['user_id'] = user_id
+        save_config(config)
+        print(f"User ID fetched and stored: {user_id}")
+
+    # Get or select project ID
+    project_id = args.project_id or config.get('project_id')
+    if not project_id:
+        print("No project ID found. Fetching projects...")
+        projects = fetch_projects(user_id, session_key)
+        project_id = select_project(projects, user_id, session_key)
+        config['project_id'] = project_id
+        save_config(config)
+        print(f"Project ID selected and stored: {project_id}")
+    else:
+        use_stored = input(f"Found stored project ID: {project_id}. Use it? (y/n): ").strip().lower()
+        if use_stored != 'y':
+            projects = fetch_projects(user_id, session_key)
+            project_id = select_project(projects, user_id, session_key)
+            config['project_id'] = project_id
+            save_config(config)
+            print(f"New project ID selected and stored: {project_id}")
+
+    # Get or update delay
+    delay = args.delay or int(get_or_update_config_value('delay', "Enter the delay in seconds before uploading", "5"))
+
+    tui = ClaudeSyncTUI(session_key, watch_dir, user_id, project_id, delay)
+    tui.setup()
+    tui.run()
+
+if __name__ == "__main__":
+    main()

claudesync-0.2.7/src/claudesync/manual_auth.py

@@ -0,0 +1,77 @@
+import webbrowser
+import os
+import json
+
+CONFIG_DIR = os.path.expanduser('~/.claudesync')
+CONFIG_FILE = os.path.join(CONFIG_DIR, 'config.json')
+
+def get_config():
+    if os.path.exists(CONFIG_FILE):
+        with open(CONFIG_FILE, 'r') as f:
+            return json.load(f)
+    return {}
+
+def save_config(config):
+    os.makedirs(CONFIG_DIR, exist_ok=True)
+    with open(CONFIG_FILE, 'w') as f:
+        json.dump(config, f, indent=2)
+
+def get_session_key():
+    config = get_config()
+    stored_session_key = config.get('sessionKey')
+
+    if stored_session_key:
+        use_stored = input(f"Found stored sessionKey. Use it? (y/n): ").strip().lower()
+        if use_stored == 'y':
+            return stored_session_key
+
+    print("To obtain your session key, please follow these steps:")
+    print("1. Open your web browser and go to https://claude.ai")
+    print("2. Log in to your Claude account if you haven't already")
+    print("3. Once logged in, open your browser's developer tools:")
+    print("   - Chrome/Edge: Press F12 or Ctrl+Shift+I (Cmd+Option+I on Mac)")
+    print("   - Firefox: Press F12 or Ctrl+Shift+I (Cmd+Option+I on Mac)")
+    print("   - Safari: Enable developer tools in Preferences > Advanced, then press Cmd+Option+I")
+    print("4. In the developer tools, go to the 'Application' tab (Chrome/Edge) or 'Storage' tab (Firefox)")
+    print("5. In the left sidebar, expand 'Cookies' and select 'https://claude.ai'")
+    print("6. Find the cookie named 'sessionKey' and copy its value")
+
+    try:
+        webbrowser.open("https://claude.ai")
+    except:
+        print("Unable to automatically open the browser. Please navigate to https://claude.ai manually.")
+
+    while True:
+        session_key = input("Please enter your sessionKey value: ").strip()
+        if session_key:
+            config['sessionKey'] = session_key
+            save_config(config)
+            print(f"SessionKey stored in {CONFIG_FILE}")
+            return session_key
+        else:
+            print("Session key cannot be empty. Please try again.")
+
+def get_or_update_config_value(key, prompt, current_value=None):
+    config = get_config()
+    stored_value = config.get(key, current_value)
+
+    if stored_value is not None:
+        use_stored = input(f"Found stored {key}: {stored_value}. Use it? (y/n): ").strip().lower()
+        if use_stored == 'y':
+            return stored_value
+
+    while True:
+        new_value = input(f"{prompt}: ").strip()
+        if new_value:
+            config[key] = new_value
+            save_config(config)
+            print(f"{key} stored in {CONFIG_FILE}")
+            return new_value
+        elif current_value is not None:
+            return current_value
+        else:
+            print(f"{key} cannot be empty. Please try again.")
+
+if __name__ == "__main__":
+    session_key = get_session_key()
+    print(f"Session key obtained: {session_key}")

{claudesync-0.2.5 → claudesync-0.2.7/src/claudesync.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: claudesync
-Version: 0.2.5
+Version: 0.2.7
 Summary: A tool to synchronize local files with Claude.ai projects
 Author-email: Jahziah Wagner <jahziah.wagner+pypi@gmail.com>
 Project-URL: Homepage, https://github.com/jahwag/claudesync

claudesync-0.2.5/src/claudesync/main.py

@@ -1,100 +0,0 @@
-import blessed
-import time
-import argparse
-import json
-import os
-import sys
-from watchdog.observers import Observer
-from .file_handler import FileUploadHandler
-from .api_utils import fetch_user_id, fetch_projects, select_project, create_project
-
-from .manual_auth import get_session_key
-
-class ClaudeSyncTUI:
-    def __init__(self, session_key, watch_dir, user_id, project_id, delay):
-        self.term = blessed.Terminal()
-        self.session_key = session_key
-        self.watch_dir = watch_dir
-        self.user_id = user_id
-        self.project_id = project_id
-        self.delay = delay
-        self.log_messages = []
-        self.observer = None
-        self.handler = None
-
-    def setup(self):
-        if not self.user_id:
-            self.user_id = fetch_user_id(self.session_key)
-        if not self.project_id:
-            projects = fetch_projects(self.user_id, self.session_key)
-            self.project_id = select_project(projects, self.user_id, self.session_key)
-
-        api_endpoint = f"https://claude.ai/api/organizations/{self.user_id}/projects/{self.project_id}/docs"
-        self.handler = FileUploadHandler(api_endpoint, self.session_key, self.watch_dir, self.delay)
-        self.handler.log_callback = self.add_log_message
-
-        self.observer = Observer()
-        self.observer.schedule(self.handler, self.watch_dir, recursive=True)
-
-    def add_log_message(self, message):
-        self.log_messages.append(message)
-        if len(self.log_messages) > 10:
-            self.log_messages.pop(0)
-
-    def draw(self):
-        print(self.term.clear())
-        print(self.term.move_y(0) + self.term.black_on_skyblue(self.term.center('ClaudeSync TUI')))
-
-        print(self.term.move_y(2) + f"Watching directory: {self.watch_dir}")
-        print(f"Upload delay: {self.delay} seconds")
-        print(f"User ID: {self.user_id}")
-        print(f"Project ID: {self.project_id}")
-
-        print(self.term.move_y(7) + self.term.black_on_skyblue(self.term.center('Recent Activity')))
-        for i, message in enumerate(self.log_messages):
-            print(self.term.move_y(9 + i) + message)
-
-        print(self.term.move_y(20) + "Press 'q' to quit")
-
-    def run(self):
-        with self.term.cbreak(), self.term.hidden_cursor():
-            self.observer.start()
-            while True:
-                self.draw()
-                inp = self.term.inkey(timeout=1)
-                if inp == 'q':
-                    break
-        self.observer.stop()
-        self.observer.join()
-
-def main():
-    parser = argparse.ArgumentParser(description="Sync local files with Claude.ai projects.")
-    parser.add_argument("--session-key", help="Session key for authentication")
-    parser.add_argument("--watch-dir", default=".", help="Directory to watch for changes")
-    parser.add_argument("--user-id", help="User ID for Claude API (optional, will be fetched if not provided)")
-    parser.add_argument("--project-id", help="Project ID for Claude API")
-    parser.add_argument("--delay", type=int, default=5, help="Delay in seconds before uploading (default: 5)")
-    args = parser.parse_args()
-
-    # Load config from file if it exists
-    config = {}
-    if os.path.exists('config.json'):
-        with open('config.json', 'r') as f:
-            config = json.load(f)
-
-    # If session key is not provided, use the manual input method
-    session_key = args.session_key
-    if not session_key:
-        session_key = get_session_key()
-
-    watch_dir = args.watch_dir
-    user_id = args.user_id or config.get('user_id')
-    project_id = args.project_id or config.get('project_id')
-    delay = args.delay
-
-    tui = ClaudeSyncTUI(session_key, watch_dir, user_id, project_id, delay)
-    tui.setup()
-    tui.run()
-
-if __name__ == "__main__":
-    main()

claudesync-0.2.5/src/claudesync/manual_auth.py

@@ -1,30 +0,0 @@
-import webbrowser
-
-def get_session_key():
-    print("To obtain your session key, please follow these steps:")
-    print("1. Open your web browser and go to https://claude.ai")
-    print("2. Log in to your Claude account if you haven't already")
-    print("3. Once logged in, open your browser's developer tools:")
-    print("   - Chrome/Edge: Press F12 or Ctrl+Shift+I (Cmd+Option+I on Mac)")
-    print("   - Firefox: Press F12 or Ctrl+Shift+I (Cmd+Option+I on Mac)")
-    print("   - Safari: Enable developer tools in Preferences > Advanced, then press Cmd+Option+I")
-    print("4. In the developer tools, go to the 'Application' tab (Chrome/Edge) or 'Storage' tab (Firefox)")
-    print("5. In the left sidebar, expand 'Cookies' and select 'https://claude.ai'")
-    print("6. Find the cookie named 'sessionKey' and copy its value")
-
-    # Attempt to open the Claude.ai website for the user
-    try:
-        webbrowser.open("https://claude.ai")
-    except:
-        print("Unable to automatically open the browser. Please navigate to https://claude.ai manually. ")
-
-    while True:
-        session_key = input("Please enter your sessionKey value: ").strip()
-        if session_key:
-            return session_key
-        else:
-            print("Session key cannot be empty. Please try again.")
-
-if __name__ == "__main__":
-    session_key = get_session_key()
-    print(f"Session key obtained: {session_key}")