main.py

"""
Continuous Folder Monitor Daemon Example
"""

import os
import sys
import time
import logging
from pathlib import Path
from dotenv import load_dotenv

# Ensure SDK root is in python path
sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))

from librechat_client import LibreChatClient
from tracker import FileStateTracker

try:
    from watchdog.observers import Observer
    from watchdog.events import FileSystemEventHandler
    HAS_WATCHDOG = True
except ImportError:
    HAS_WATCHDOG = False

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] (FileMonitor) %(message)s"
)
logger = logging.getLogger("FileMonitor")

def run_monitor():
    load_dotenv()
    
    watch_dir = Path(os.getenv("WATCH_DIR", "./watch_folder")).resolve()
    output_dir = Path(os.getenv("OUTPUT_DIR", "./output_folder")).resolve()
    
    watch_dir.mkdir(parents=True, exist_ok=True)
    output_dir.mkdir(parents=True, exist_ok=True)
    
    base_url = os.getenv("LIBRECHAT_BASE_URL", "https://chat.example.com")
    refresh_token = os.getenv("LIBRECHAT_REFRESH_TOKEN")
    connect_sid = os.getenv("LIBRECHAT_CONNECT_SID")
    
    if not refresh_token or refresh_token == "YOUR_REFRESH_TOKEN_HERE":
        logger.error("LIBRECHAT_REFRESH_TOKEN is not set in .env!")
        return

    client = LibreChatClient(
        base_url=base_url,
        refresh_token=refresh_token,
        connect_sid=connect_sid
    )
    tracker = FileStateTracker()
    
    logger.info(f"Monitoring folder: {watch_dir}")
    
    def process_file(filepath: Path):
        if not filepath.is_file() or filepath.name.startswith(".") or tracker.is_processed(filepath):
            return
        logger.info(f"Processing new file: {filepath.name}")
        try:
            content = filepath.read_text(encoding="utf-8")
            response = client.send_agent_message(prompt=f"Summarize:\n\n{content}")
            
            output_file = output_dir / f"{filepath.stem}_summary_{int(time.time())}.md"
            output_file.write_text(str(response.get("text", response)), encoding="utf-8")
            
            tracker.mark_processed(filepath, output_file)
            logger.info(f"[✓] Saved response to: {output_file}")
        except Exception as e:
            logger.error(f"Failed to process '{filepath.name}': {e}")

    # Initial scan for offline changes across reboots
    for p in watch_dir.rglob("*"):
        process_file(p)

    if HAS_WATCHDOG:
        class Handler(FileSystemEventHandler):
            def on_created(self, event):
                process_file(Path(event.src_path))
            def on_modified(self, event):
                process_file(Path(event.src_path))

        observer = Observer()
        observer.schedule(Handler(), str(watch_dir), recursive=True)
        observer.start()

    try:
        while True:
            time.sleep(30)
            for p in watch_dir.rglob("*"):
                process_file(p)
    except KeyboardInterrupt:
        logger.info("Monitor stopped.")
        if HAS_WATCHDOG:
            observer.stop()

if __name__ == "__main__":
    run_monitor()