nia-sync 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

api_client.py

@@ -0,0 +1,104 @@
+"""
+HTTP client helpers for Nia Local Sync CLI.
+
+Centralizes API base URL, auth headers, timeouts, and error handling.
+"""
+import httpx
+from typing import Any
+
+from config import get_api_key, get_api_base_url
+
+DEFAULT_TIMEOUT = 30
+CONNECT_TIMEOUT = 10
+
+
+def _build_url(path: str) -> str:
+    base_url = get_api_base_url().rstrip("/")
+    return f"{base_url}{path}"
+
+
+def _build_headers() -> dict[str, str]:
+    api_key = get_api_key()
+    if not api_key:
+        return {}
+    return {"Authorization": f"Bearer {api_key}"}
+
+
+def request_json(
+    method: str,
+    path: str,
+    *,
+    payload: dict[str, Any] | None = None,
+    params: dict[str, Any] | None = None,
+    timeout: int = DEFAULT_TIMEOUT,
+    requires_auth: bool = True,
+) -> tuple[Any | None, str | None]:
+    api_key = get_api_key()
+    if requires_auth and not api_key:
+        return None, "Not authenticated"
+
+    url = _build_url(path)
+    headers = _build_headers()
+
+    try:
+        with httpx.Client(timeout=httpx.Timeout(timeout, connect=CONNECT_TIMEOUT)) as client:
+            response = client.request(
+                method,
+                url,
+                headers=headers,
+                json=payload,
+                params=params,
+            )
+    except httpx.RequestError as e:
+        return None, f"Network error: {e}"
+
+    if 200 <= response.status_code < 300:
+        try:
+            return response.json(), None
+        except ValueError:
+            return response.text, None
+
+    if response.status_code == 401:
+        return None, "Authentication failed"
+
+    try:
+        detail = response.json().get("detail", response.text)
+    except ValueError:
+        detail = response.text or f"HTTP {response.status_code}"
+    return None, f"API error: {detail}"
+
+
+def get_sources() -> list[dict[str, Any]]:
+    data, error = request_json("GET", "/v2/daemon/sources")
+    if error or not isinstance(data, list):
+        return []
+    return data
+
+
+def add_source(path: str, detected_type: str | None = None) -> dict[str, Any] | None:
+    data, error = request_json(
+        "POST",
+        "/v2/daemon/sources",
+        payload={"path": path, "detected_type": detected_type},
+    )
+    if error or not isinstance(data, dict):
+        return None
+    return data
+
+
+def remove_source(local_folder_id: str) -> bool:
+    data, error = request_json("DELETE", f"/v2/daemon/sources/{local_folder_id}")
+    if error:
+        return False
+    return bool(data)
+
+
+def enable_source_sync(local_folder_id: str, path: str) -> bool:
+    data, error = request_json(
+        "POST",
+        f"/v2/daemon/sources/{local_folder_id}/enable",
+        payload={"path": path},
+    )
+    if error:
+        return False
+    return bool(data)

auth.py

@@ -18,7 +18,7 @@ from config import (
     load_config,
     save_config,
     clear_config,
-    API_BASE_URL,
+    get_api_base_url,
 )
 
 console = Console()
@@ -54,7 +54,7 @@ def login() -> bool:
         console.print("Starting authentication...")
 
         with httpx.Client(timeout=30) as client:
-            response = client.post(f"{API_BASE_URL}/public/mcp-device/start")
+            response = client.post(f"{get_api_base_url()}/public/mcp-device/start")
             response.raise_for_status()
 
             data = response.json()
@@ -108,7 +108,7 @@ def _poll_for_api_key(session_id: str, user_code: str) -> str | None:
             for attempt in range(MAX_POLL_ATTEMPTS):
                 try:
                     response = client.post(
-                        f"{API_BASE_URL}/public/mcp-device/exchange",
+                        f"{get_api_base_url()}/public/mcp-device/exchange",
                         json={
                             "authorization_session_id": session_id,
                             "user_code": user_code,

config.py

@@ -9,14 +9,12 @@ 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://apigcp.trynia.ai")
+DEFAULT_API_BASE_URL = "https://apigcp.trynia.ai"
 
 # Default directories to search for folders (no config needed)
 DEFAULT_WATCH_DIRS = [
@@ -35,6 +33,15 @@ DEFAULT_WATCH_DIRS = [
 ]
 
 
+def get_api_base_url() -> str:
+    """Get API base URL, preferring env var over config."""
+    env_url = os.getenv("NIA_API_URL")
+    if env_url:
+        return env_url
+    config = load_config()
+    return config.get("api_url", DEFAULT_API_BASE_URL)
+
+
 def get_watch_dirs() -> list[str]:
     """Get directories to search for folders. Uses defaults + any custom ones."""
     config = load_config()
@@ -44,6 +51,37 @@ def get_watch_dirs() -> list[str]:
     return list(dict.fromkeys(all_dirs))
 
 
+def set_watch_dirs(dirs: list[str]) -> None:
+    normalized = [os.path.abspath(os.path.expanduser(d)) for d in dirs if d]
+    save_config({"watch_dirs": list(dict.fromkeys(normalized))})
+
+
+def add_watch_dir(path: str) -> bool:
+    if not path:
+        return False
+    expanded = os.path.abspath(os.path.expanduser(path))
+    config = load_config()
+    custom = config.get("watch_dirs", [])
+    if expanded in custom:
+        return False
+    custom.append(expanded)
+    save_config({"watch_dirs": custom})
+    return True
+
+
+def remove_watch_dir(path: str) -> bool:
+    if not path:
+        return False
+    expanded = os.path.abspath(os.path.expanduser(path))
+    config = load_config()
+    custom = config.get("watch_dirs", [])
+    if expanded not in custom:
+        return False
+    custom = [d for d in custom if d != expanded]
+    save_config({"watch_dirs": custom})
+    return True
+
+
 def find_folder_path(folder_name: str, max_depth: int = 3) -> str | None:
     """
     Search watch directories recursively for a folder with the given name.
@@ -141,100 +179,75 @@ def get_api_key() -> str | None:
     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 []
+def get_config_value(key: str) -> Any:
+    config = load_config()
+    if not key:
+        return config
+    return config.get(key)
 
-    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
+def set_config_value(key: str, value: Any) -> None:
+    if not key:
+        return
+    save_config({key: value})
 
-    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 get_ignore_patterns() -> dict[str, list[str]]:
+    config = load_config()
+    return {
+        "dirs": list(config.get("ignore_dirs", [])),
+        "files": list(config.get("ignore_files", [])),
+        "extensions": list(config.get("ignore_extensions", [])),
+        "path_patterns": list(config.get("ignore_path_patterns", [])),
+    }
 
 
-def remove_source(local_folder_id: str) -> bool:
-    """
-    Remove a source from daemon sync.
+def add_ignore_pattern(kind: str, value: str) -> bool:
+    if not kind or not value:
+        return False
+    config = load_config()
+    key_map = {
+        "dir": "ignore_dirs",
+        "file": "ignore_files",
+        "ext": "ignore_extensions",
+        "path": "ignore_path_patterns",
+    }
+    key = key_map.get(kind)
+    if not key:
+        return False
+    current = list(config.get(key, []))
+    normalized = value.strip()
+    if kind == "ext" and not normalized.startswith("."):
+        normalized = f".{normalized}"
+    if normalized in current:
+        return False
+    current.append(normalized)
+    save_config({key: current})
+    return True
 
-    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:
+def remove_ignore_pattern(kind: str, value: str) -> bool:
+    if not kind or not value:
         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:
+    config = load_config()
+    key_map = {
+        "dir": "ignore_dirs",
+        "file": "ignore_files",
+        "ext": "ignore_extensions",
+        "path": "ignore_path_patterns",
+    }
+    key = key_map.get(kind)
+    if not key:
         return False
-    except httpx.RequestError:
+    current = list(config.get(key, []))
+    normalized = value.strip()
+    if kind == "ext" and not normalized.startswith("."):
+        normalized = f".{normalized}"
+    if normalized not in current:
         return False
+    current = [item for item in current if item != normalized]
+    save_config({key: current})
+    return True
 
 
 def update_source_cursor(local_folder_id: str, cursor: dict[str, Any]) -> bool:
@@ -247,33 +260,3 @@ def update_source_cursor(local_folder_id: str, cursor: dict[str, Any]) -> bool:
     # 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

extractor.py

@@ -122,6 +122,27 @@ SKIP_PATH_PATTERNS = {
     "id_rsa", "id_dsa", "id_ecdsa", "id_ed25519",
 }
 
+
+def _get_custom_ignore_sets() -> tuple[set[str], set[str], set[str], set[str]]:
+    try:
+        from config import get_ignore_patterns
+    except Exception:
+        return set(), set(), set(), set()
+
+    patterns = get_ignore_patterns()
+    custom_dirs = {p for p in patterns.get("dirs", []) if p}
+    custom_files = {p for p in patterns.get("files", []) if p}
+    custom_exts = set()
+    for ext in patterns.get("extensions", []) or []:
+        if not ext:
+            continue
+        normalized = ext.strip().lower()
+        if not normalized.startswith("."):
+            normalized = f".{normalized}"
+        custom_exts.add(normalized)
+    custom_path_patterns = {p.lower() for p in patterns.get("path_patterns", []) if p}
+    return custom_dirs, custom_files, custom_exts, custom_path_patterns
+
 # Type identifiers
 TYPE_IMESSAGE = "imessage"
 TYPE_SAFARI_HISTORY = "safari_history"
@@ -769,6 +790,11 @@ def _extract_folder(
     max_mtime = last_mtime
     max_path = last_path
     extracted_count = 0
+    custom_dirs, custom_files, custom_exts, custom_path_patterns = _get_custom_ignore_sets()
+    skip_dirs = SKIP_DIRS | custom_dirs
+    skip_files = SKIP_FILES | custom_files
+    skip_exts = SKIP_EXTENSIONS | custom_exts
+    skip_path_patterns = SKIP_PATH_PATTERNS | custom_path_patterns
 
     # Allowed text file extensions
     text_extensions = {
@@ -786,7 +812,7 @@ def _extract_folder(
         # Filter out excluded directories IN-PLACE to prevent os.walk from descending
         dirs[:] = [
             d for d in dirs
-            if d not in SKIP_DIRS
+            if d not in skip_dirs
             and not d.startswith(".")
             and not d.endswith(".egg-info")
         ]
@@ -798,7 +824,7 @@ def _extract_folder(
                 break
 
             # Skip by filename
-            if filename in SKIP_FILES:
+            if filename in skip_files:
                 continue
 
             # Skip hidden files
@@ -807,13 +833,13 @@ def _extract_folder(
 
             # Skip files matching security patterns (credentials, secrets, keys)
             filename_lower = filename.lower()
-            if any(pattern in filename_lower for pattern in SKIP_PATH_PATTERNS):
+            if any(pattern in filename_lower for pattern in skip_path_patterns):
                 continue
 
             ext = Path(filename).suffix.lower()
 
             # Skip by extension
-            if ext in SKIP_EXTENSIONS:
+            if ext in skip_exts:
                 continue
 
             # Only include known text extensions