nia-sync 0.1.0__py3-none-any.whl

auth.py

@@ -0,0 +1,168 @@
+"""
+Authentication module using the existing MCP device flow.
+
+Reuses the existing endpoints:
+- POST /public/mcp-device/start -> get user_code + session_id
+- POST /public/mcp-device/exchange -> exchange for API key
+"""
+import os
+import time
+import webbrowser
+import httpx
+from rich.console import Console
+from rich.panel import Panel
+
+from config import (
+    NIA_SYNC_DIR,
+    CONFIG_FILE,
+    load_config,
+    save_config,
+    clear_config,
+    API_BASE_URL,
+)
+
+console = Console()
+
+# Polling configuration
+POLL_INTERVAL_SECONDS = 2
+MAX_POLL_ATTEMPTS = 150  # 5 minutes max
+
+
+def is_authenticated() -> bool:
+    """Check if user is authenticated (has API key stored)."""
+    config = load_config()
+    return bool(config.get("api_key"))
+
+
+def get_api_key() -> str | None:
+    """Get the stored API key."""
+    config = load_config()
+    return config.get("api_key")
+
+
+def login() -> bool:
+    """
+    Authenticate using the MCP device flow.
+
+    1. Call /public/mcp-device/start to get user_code
+    2. Open browser for user to authenticate
+    3. Poll /public/mcp-device/exchange until ready
+    4. Store API key locally
+    """
+    try:
+        # Step 1: Start device session
+        console.print("Starting authentication...")
+
+        with httpx.Client(timeout=30) as client:
+            response = client.post(f"{API_BASE_URL}/public/mcp-device/start")
+            response.raise_for_status()
+
+            data = response.json()
+            user_code = data["user_code"]
+            authorization_session_id = data["authorization_session_id"]
+            verification_url = data["verification_url"]
+
+        # Step 2: Show code and open browser
+        console.print()
+        console.print(Panel.fit(
+            f"[bold cyan]Your code: {user_code}[/bold cyan]\n\n"
+            "1. A browser window will open\n"
+            "2. Sign in to your Nia account\n"
+            "3. The code will be pre-filled\n"
+            "4. Complete the setup, then return here",
+            title="Authentication Code",
+        ))
+        console.print()
+
+        # Open browser
+        webbrowser.open(verification_url)
+        console.print(f"[dim]Browser opened to: {verification_url}[/dim]")
+        console.print()
+        console.print("Waiting for authentication...")
+
+        # Step 3: Poll for completion
+        api_key = _poll_for_api_key(authorization_session_id, user_code)
+
+        if not api_key:
+            return False
+
+        # Step 4: Store credentials
+        save_config({
+            "api_key": api_key,
+        })
+
+        return True
+
+    except httpx.HTTPStatusError as e:
+        console.print(f"[red]HTTP error: {e.response.status_code}[/red]")
+        return False
+    except Exception as e:
+        console.print(f"[red]Error during login: {e}[/red]")
+        return False
+
+
+def _poll_for_api_key(session_id: str, user_code: str) -> str | None:
+    """Poll the exchange endpoint until authentication completes."""
+    with httpx.Client(timeout=30) as client:
+        for attempt in range(MAX_POLL_ATTEMPTS):
+            try:
+                response = client.post(
+                    f"{API_BASE_URL}/public/mcp-device/exchange",
+                    json={
+                        "authorization_session_id": session_id,
+                        "user_code": user_code,
+                    }
+                )
+
+                if response.status_code == 200:
+                    data = response.json()
+                    console.print("[green]Authentication successful![/green]")
+                    return data.get("api_key")
+
+                elif response.status_code == 400:
+                    # Not ready yet - still pending or authorized but not ready
+                    detail = response.json().get("detail", "")
+                    if "not yet authorized" in detail.lower() or "complete the setup" in detail.lower():
+                        # Still waiting for user to complete in browser
+                        _show_waiting_indicator(attempt)
+                        time.sleep(POLL_INTERVAL_SECONDS)
+                        continue
+                    else:
+                        console.print(f"[red]Error: {detail}[/red]")
+                        return None
+
+                elif response.status_code == 410:
+                    console.print("[red]Session expired. Please try again.[/red]")
+                    return None
+
+                elif response.status_code == 409:
+                    console.print("[red]Session already used. Please try again.[/red]")
+                    return None
+
+                elif response.status_code == 404:
+                    console.print("[red]Invalid session. Please try again.[/red]")
+                    return None
+
+                else:
+                    console.print(f"[red]Unexpected error: {response.status_code}[/red]")
+                    return None
+
+            except httpx.RequestError as e:
+                console.print(f"[yellow]Network error, retrying... ({e})[/yellow]")
+                time.sleep(POLL_INTERVAL_SECONDS)
+                continue
+
+    console.print("[red]Timeout waiting for authentication. Please try again.[/red]")
+    return None
+
+
+def _show_waiting_indicator(attempt: int):
+    """Show a waiting indicator."""
+    dots = "." * ((attempt % 3) + 1)
+    console.print(f"\r[dim]Waiting for browser authentication{dots}   [/dim]", end="")
+
+
+def logout():
+    """Clear stored credentials."""
+    clear_config()
+    console.print("[green]Credentials cleared.[/green]")

config.py

@@ -0,0 +1,276 @@
+"""
+Configuration management for Nia Local Sync CLI.
+
+Handles:
+- Local config storage (~/.nia-sync/config.json)
+- Fetching source configuration from cloud API
+"""
+import os
+import json
+from pathlib import Path
+from typing import Any
+import httpx
+
+# Configuration paths
+NIA_SYNC_DIR = Path.home() / ".nia-sync"
+CONFIG_FILE = NIA_SYNC_DIR / "config.json"
+
+# API configuration
+API_BASE_URL = os.getenv("NIA_API_URL", "https://api.trynia.ai")
+
+# Default directories to search for folders (no config needed)
+DEFAULT_WATCH_DIRS = [
+    "~/Documents",
+    "~/Desktop",
+    "~/Projects",
+    "~/Developer",
+    "~/Code",
+    "~/dev",
+    "~/repos",
+    "~/Downloads",
+    "~/src",
+    "~/work",
+    "~/workspace",
+    "~/github",
+]
+
+
+def get_watch_dirs() -> list[str]:
+    """Get directories to search for folders. Uses defaults + any custom ones."""
+    config = load_config()
+    custom = config.get("watch_dirs", [])
+    # Combine defaults + custom, dedupe
+    all_dirs = DEFAULT_WATCH_DIRS + custom
+    return list(dict.fromkeys(all_dirs))
+
+
+def find_folder_path(folder_name: str, max_depth: int = 3) -> str | None:
+    """
+    Search watch directories recursively for a folder with the given name.
+    Returns the full path if found, None otherwise.
+
+    Searches up to max_depth levels deep to avoid scanning entire filesystem.
+    """
+    def search_dir(base: str, depth: int) -> str | None:
+        if depth > max_depth:
+            return None
+
+        try:
+            for entry in os.scandir(base):
+                if not entry.is_dir():
+                    continue
+                # Skip hidden directories and common large dirs
+                if entry.name.startswith('.') or entry.name in ('node_modules', 'venv', '__pycache__', 'build', 'dist'):
+                    continue
+
+                if entry.name == folder_name:
+                    return entry.path
+
+                # Recurse into subdirectory
+                if depth < max_depth:
+                    found = search_dir(entry.path, depth + 1)
+                    if found:
+                        return found
+        except PermissionError:
+            pass
+
+        return None
+
+    for watch_dir in get_watch_dirs():
+        expanded = os.path.expanduser(watch_dir)
+        if not os.path.isdir(expanded):
+            continue
+
+        # Check direct child first (fast path)
+        candidate = os.path.join(expanded, folder_name)
+        if os.path.exists(candidate):
+            return candidate
+
+        # Search recursively
+        found = search_dir(expanded, 1)
+        if found:
+            return found
+
+    return None
+
+
+def ensure_config_dir():
+    """Ensure the config directory exists."""
+    NIA_SYNC_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_config() -> dict[str, Any]:
+    """Load configuration from disk."""
+    if not CONFIG_FILE.exists():
+        return {}
+
+    try:
+        with open(CONFIG_FILE, "r") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError):
+        return {}
+
+
+def save_config(config: dict[str, Any]):
+    """Save configuration to disk."""
+    ensure_config_dir()
+
+    # Merge with existing config
+    existing = load_config()
+    existing.update(config)
+
+    with open(CONFIG_FILE, "w") as f:
+        json.dump(existing, f, indent=2)
+
+    # Secure the file (readable only by owner)
+    os.chmod(CONFIG_FILE, 0o600)
+
+
+def clear_config():
+    """Clear all stored configuration."""
+    if CONFIG_FILE.exists():
+        CONFIG_FILE.unlink()
+
+
+def get_api_key() -> str | None:
+    """Get the stored API key."""
+    config = load_config()
+    return config.get("api_key")
+
+
+def get_sources() -> list[dict[str, Any]]:
+    """
+    Fetch configured sources from the cloud API.
+
+    Returns list of sources with:
+    - local_folder_id: UUID of the local folder
+    - path: Local path to sync (e.g., ~/Library/Messages/chat.db)
+    - detected_type: Type of source (imessage, safari_history, folder, etc.)
+    - cursor: Current sync cursor (for incremental sync)
+    - last_synced: ISO timestamp of last sync
+    """
+    api_key = get_api_key()
+    if not api_key:
+        return []
+
+    try:
+        with httpx.Client(timeout=30) as client:
+            response = client.get(
+                f"{API_BASE_URL}/v2/daemon/sources",
+                headers={"Authorization": f"Bearer {api_key}"},
+            )
+            response.raise_for_status()
+            return response.json()
+
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code == 401:
+            # Invalid/expired API key
+            return []
+        raise
+    except httpx.RequestError:
+        # Network error - return empty for now
+        return []
+
+
+def add_source(path: str, detected_type: str | None = None) -> dict[str, Any] | None:
+    """
+    Add a new source for daemon sync.
+
+    Args:
+        path: Local path to sync
+        detected_type: Optional detected type
+
+    Returns:
+        Created source info or None on failure
+    """
+    api_key = get_api_key()
+    if not api_key:
+        return None
+
+    try:
+        with httpx.Client(timeout=30) as client:
+            response = client.post(
+                f"{API_BASE_URL}/v2/daemon/sources",
+                headers={"Authorization": f"Bearer {api_key}"},
+                json={
+                    "path": path,
+                    "detected_type": detected_type,
+                },
+            )
+            response.raise_for_status()
+            return response.json()
+
+    except httpx.HTTPStatusError:
+        return None
+    except httpx.RequestError:
+        return None
+
+
+def remove_source(local_folder_id: str) -> bool:
+    """
+    Remove a source from daemon sync.
+
+    Args:
+        local_folder_id: ID of the source to remove
+
+    Returns:
+        True on success, False on failure
+    """
+    api_key = get_api_key()
+    if not api_key:
+        return False
+
+    try:
+        with httpx.Client(timeout=30) as client:
+            response = client.delete(
+                f"{API_BASE_URL}/v2/daemon/sources/{local_folder_id}",
+                headers={"Authorization": f"Bearer {api_key}"},
+            )
+            return response.status_code == 200
+
+    except httpx.HTTPStatusError:
+        return False
+    except httpx.RequestError:
+        return False
+
+
+def update_source_cursor(local_folder_id: str, cursor: dict[str, Any]) -> bool:
+    """
+    Update the sync cursor for a source after successful sync.
+
+    This is called by the sync engine after pushing data to the backend.
+    The backend updates the cursor in the database.
+    """
+    # Note: Cursor is updated by the /daemon/sync endpoint, not a separate call
+    # This function is here for potential future use
+    return True
+
+
+def enable_source_sync(local_folder_id: str, path: str) -> bool:
+    """
+    Enable daemon sync for a source that exists locally.
+
+    Args:
+        local_folder_id: ID of the source
+        path: Local path where the source exists
+
+    Returns:
+        True on success, False on failure
+    """
+    api_key = get_api_key()
+    if not api_key:
+        return False
+
+    try:
+        with httpx.Client(timeout=30) as client:
+            response = client.post(
+                f"{API_BASE_URL}/v2/daemon/sources/{local_folder_id}/enable",
+                headers={"Authorization": f"Bearer {api_key}"},
+                json={"path": path},
+            )
+            return response.status_code == 200
+
+    except httpx.HTTPStatusError:
+        return False
+    except httpx.RequestError:
+        return False