icloud-cli-tools 0.1.0__py3-none-any.whl

icloud_cli/__init__.py

@@ -0,0 +1,3 @@
+"""icloud-cli-tools: Access iCloud services from Linux."""
+
+__version__ = "0.1.0"

icloud_cli/auth.py

@@ -0,0 +1,273 @@
+"""Authentication management for icloud-cli.
+
+Handles Apple ID login, 2FA verification, session caching,
+and credential storage via OS keyring.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import click
+import keyring
+from pyicloud import PyiCloudService
+from pyicloud.exceptions import (
+    PyiCloudFailedLoginException,
+)
+
+from icloud_cli.config import Config
+from icloud_cli.output import error, info, success, warning
+
+KEYRING_SERVICE = "icloud-cli-tools"
+KEYRING_IMAP_SERVICE = "icloud-cli-tools-imap"
+
+
+class AuthManager:
+    """Manages iCloud authentication, sessions, and credentials."""
+
+    def __init__(self, config: Config):
+        self.config = config
+        self._api: PyiCloudService | None = None
+
+    @property
+    def api(self) -> PyiCloudService:
+        """Get authenticated PyiCloudService instance."""
+        if self._api is None:
+            self._api = self._get_session()
+        return self._api
+
+    def login(self) -> bool:
+        """Interactive login flow with 2FA support.
+
+        Returns True if login was successful.
+        """
+        # Get Apple ID — always allow changing
+        apple_id = self.config.apple_id
+        if apple_id:
+            apple_id = click.prompt("Apple ID (email)", default=apple_id)
+        else:
+            apple_id = click.prompt("Apple ID (email)")
+        self.config.apple_id = apple_id
+        self.config.save()
+
+        # Get password from keyring or prompt
+        password = keyring.get_password(KEYRING_SERVICE, apple_id)
+        if not password:
+            password = click.prompt("Password", hide_input=True)
+            if click.confirm("Save password to system keyring?", default=True):
+                keyring.set_password(KEYRING_SERVICE, apple_id, password)
+                success("Password saved to keyring.")
+
+        # Authenticate
+        try:
+            session_dir = Path(self.config.session_dir)
+            session_dir.mkdir(parents=True, exist_ok=True)
+
+            self._api = PyiCloudService(
+                apple_id=apple_id,
+                password=password,
+                cookie_directory=str(session_dir),
+            )
+        except PyiCloudFailedLoginException as e:
+            error(f"Login failed: {e}")
+            return False
+        except Exception as e:
+            error(f"Connection error: {e}")
+            return False
+
+        # Handle 2FA
+        if self._api.requires_2fa:
+            return self._handle_2fa()
+
+        if self._api.requires_2sa:
+            return self._handle_2sa()
+
+        success(f"Logged in as {apple_id}")
+        return True
+
+    def _handle_2fa(self) -> bool:
+        """Handle two-factor authentication (trusted device code)."""
+        info("Two-factor authentication required.")
+        info("A verification code has been sent to your trusted devices.")
+
+        code = click.prompt("Enter 2FA code")
+
+        try:
+            result = self._api.validate_2fa_code(code)
+            if not result:
+                error("Invalid 2FA code.")
+                return False
+
+            # Trust this session
+            if not self._api.is_trusted_session:
+                info("Trusting this session...")
+                self._api.trust_session()
+
+            success("2FA verification successful!")
+            return True
+        except Exception as e:
+            error(f"2FA verification failed: {e}")
+            return False
+
+    def _handle_2sa(self) -> bool:
+        """Handle two-step authentication (SMS/phone-based)."""
+        info("Two-step authentication required.")
+
+        devices = self._api.trusted_devices
+        if not devices:
+            error("No trusted devices found.")
+            return False
+
+        # Show available devices
+        for i, device in enumerate(devices):
+            phone = device.get("phoneNumber", "Unknown")
+            info(f"  {i + 1}. {phone}")
+
+        device_idx = click.prompt("Choose device number", type=int, default=1) - 1
+        if device_idx < 0 or device_idx >= len(devices):
+            error("Invalid device number.")
+            return False
+
+        device = devices[device_idx]
+        if not self._api.send_verification_code(device):
+            error("Failed to send verification code.")
+            return False
+
+        code = click.prompt("Enter verification code")
+        if not self._api.validate_verification_code(device, code):
+            error("Invalid verification code.")
+            return False
+
+        success("2SA verification successful!")
+        return True
+
+    def logout(self) -> None:
+        """Clear all stored credentials and sessions."""
+        # Remove keyring credentials
+        apple_id = self.config.apple_id
+        if apple_id:
+            try:
+                keyring.delete_password(KEYRING_SERVICE, apple_id)
+                info("Removed password from keyring.")
+            except keyring.errors.PasswordDeleteError:
+                pass
+
+            try:
+                keyring.delete_password(KEYRING_IMAP_SERVICE, apple_id)
+                info("Removed IMAP password from keyring.")
+            except keyring.errors.PasswordDeleteError:
+                pass
+
+        # Clear session cookies
+        session_dir = Path(self.config.session_dir)
+        if session_dir.exists():
+            for f in session_dir.iterdir():
+                f.unlink()
+            info("Cleared session cookies.")
+
+        self._api = None
+        success("Logged out successfully.")
+
+    def get_status(self) -> dict:
+        """Return current authentication status."""
+        apple_id = self.config.apple_id
+        has_password = bool(
+            apple_id and keyring.get_password(KEYRING_SERVICE, apple_id)
+        )
+        has_imap_password = bool(
+            apple_id and keyring.get_password(KEYRING_IMAP_SERVICE, apple_id)
+        )
+        has_session = self._has_cached_session()
+
+        return {
+            "apple_id": apple_id or "(not set)",
+            "password_stored": "Yes" if has_password else "No",
+            "imap_password_stored": "Yes" if has_imap_password else "No",
+            "session_cached": "Yes" if has_session else "No",
+            "session_dir": self.config.session_dir,
+        }
+
+    def setup_imap_password(self) -> bool:
+        """Guide user through setting up an app-specific password for Notes (IMAP).
+
+        Returns True if password was stored successfully.
+        """
+        apple_id = self.config.apple_id
+        if not apple_id:
+            error("Please login first with 'icloud-cli login'.")
+            return False
+
+        info("Notes access requires an app-specific password.")
+        info("Generate one at: https://appleid.apple.com/account/manage")
+        info("  → Sign In & Security → App-Specific Passwords → Generate")
+        print()
+
+        password = click.prompt("Enter app-specific password", hide_input=True)
+        keyring.set_password(KEYRING_IMAP_SERVICE, apple_id, password)
+        self.config.imap_password_in_keyring = True
+        self.config.save()
+
+        success("IMAP password saved to keyring.")
+        return True
+
+    def get_imap_credentials(self) -> tuple[str, str] | None:
+        """Get IMAP credentials (apple_id, app-specific password).
+
+        Returns None if not configured.
+        """
+        apple_id = self.config.apple_id
+        if not apple_id:
+            return None
+
+        password = keyring.get_password(KEYRING_IMAP_SERVICE, apple_id)
+        if not password:
+            return None
+
+        return (apple_id, password)
+
+    def _get_session(self) -> PyiCloudService:
+        """Get or restore a cached PyiCloudService session."""
+        apple_id = self.config.apple_id
+        if not apple_id:
+            error("Not logged in. Run 'icloud-cli login' first.")
+            sys.exit(1)
+
+        password = keyring.get_password(KEYRING_SERVICE, apple_id)
+        if not password:
+            # No saved password — prompt interactively
+            warning("No stored password found.")
+            password = click.prompt("Password", hide_input=True)
+            if click.confirm("Save password to system keyring?", default=True):
+                keyring.set_password(KEYRING_SERVICE, apple_id, password)
+                success("Password saved to keyring.")
+
+        try:
+            session_dir = Path(self.config.session_dir)
+            session_dir.mkdir(parents=True, exist_ok=True)
+
+            api = PyiCloudService(
+                apple_id=apple_id,
+                password=password,
+                cookie_directory=str(session_dir),
+            )
+
+            if api.requires_2fa or api.requires_2sa:
+                warning("Session expired. Please re-authenticate.")
+                error("Run 'icloud-cli login' to refresh your session.")
+                sys.exit(1)
+
+            return api
+        except PyiCloudFailedLoginException:
+            error("Authentication failed. Run 'icloud-cli login' to re-authenticate.")
+            sys.exit(1)
+        except Exception as e:
+            error(f"Failed to connect to iCloud: {e}")
+            sys.exit(1)
+
+    def _has_cached_session(self) -> bool:
+        """Check if a cached session exists."""
+        session_dir = Path(self.config.session_dir)
+        if not session_dir.exists():
+            return False
+        return any(session_dir.iterdir())

icloud_cli/config.py

@@ -0,0 +1,122 @@
+"""Configuration management for icloud-cli.
+
+Config file: ~/.config/icloud-cli/config.toml
+Cache dir:   ~/.local/share/icloud-cli/cache/
+Session dir: ~/.config/icloud-cli/session/
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import toml
+
+# XDG-compliant default paths
+DEFAULT_CONFIG_DIR = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / "icloud-cli"
+DEFAULT_DATA_DIR = (
+    Path(os.environ.get("XDG_DATA_HOME", Path.home() / ".local" / "share")) / "icloud-cli"
+)
+DEFAULT_CONFIG_FILE = DEFAULT_CONFIG_DIR / "config.toml"
+DEFAULT_SESSION_DIR = DEFAULT_CONFIG_DIR / "session"
+DEFAULT_CACHE_DIR = DEFAULT_DATA_DIR / "cache"
+
+
+@dataclass
+class Config:
+    """Application configuration."""
+
+    # General
+    default_format: str = "table"
+    verbose: bool = False
+
+    # Auth
+    apple_id: str = ""
+    session_dir: str = str(DEFAULT_SESSION_DIR)
+
+    # Notes (IMAP)
+    imap_password_in_keyring: bool = False
+
+    # Sync
+    sync_interval_minutes: int = 15
+    cache_dir: str = str(DEFAULT_CACHE_DIR)
+
+    # Calendar
+    default_calendar: str = ""
+
+    # Reminders
+    default_reminder_list: str = ""
+
+    # Paths (not serialized)
+    config_file: Path = field(default=DEFAULT_CONFIG_FILE, repr=False)
+
+    @classmethod
+    def load(cls, config_path: Path | None = None) -> Config:
+        """Load config from TOML file, falling back to defaults."""
+        path = config_path or DEFAULT_CONFIG_FILE
+        config = cls(config_file=path)
+
+        if path.exists():
+            data = toml.load(path)
+            general = data.get("general", {})
+            auth = data.get("auth", {})
+            notes = data.get("notes", {})
+            sync = data.get("sync", {})
+            calendar = data.get("calendar", {})
+            reminders = data.get("reminders", {})
+
+            config.default_format = general.get("default_format", config.default_format)
+            config.verbose = general.get("verbose", config.verbose)
+            config.apple_id = auth.get("apple_id", config.apple_id)
+            config.session_dir = auth.get("session_dir", config.session_dir)
+            config.imap_password_in_keyring = notes.get(
+                "imap_password_in_keyring", config.imap_password_in_keyring
+            )
+            config.sync_interval_minutes = sync.get(
+                "sync_interval_minutes", config.sync_interval_minutes
+            )
+            config.cache_dir = sync.get("cache_dir", config.cache_dir)
+            config.default_calendar = calendar.get("default_calendar", config.default_calendar)
+            config.default_reminder_list = reminders.get(
+                "default_reminder_list", config.default_reminder_list
+            )
+
+        return config
+
+    def save(self) -> None:
+        """Save config to TOML file."""
+        self.config_file.parent.mkdir(parents=True, exist_ok=True)
+
+        data = {
+            "general": {
+                "default_format": self.default_format,
+                "verbose": self.verbose,
+            },
+            "auth": {
+                "apple_id": self.apple_id,
+                "session_dir": self.session_dir,
+            },
+            "notes": {
+                "imap_password_in_keyring": self.imap_password_in_keyring,
+            },
+            "sync": {
+                "sync_interval_minutes": self.sync_interval_minutes,
+                "cache_dir": self.cache_dir,
+            },
+            "calendar": {
+                "default_calendar": self.default_calendar,
+            },
+            "reminders": {
+                "default_reminder_list": self.default_reminder_list,
+            },
+        }
+
+        with open(self.config_file, "w") as f:
+            toml.dump(data, f)
+
+    def ensure_dirs(self) -> None:
+        """Create required directories."""
+        Path(self.session_dir).mkdir(parents=True, exist_ok=True)
+        Path(self.cache_dir).mkdir(parents=True, exist_ok=True)
+        self.config_file.parent.mkdir(parents=True, exist_ok=True)

icloud_cli/daemon.py

@@ -0,0 +1,198 @@
+"""Background sync daemon for icloud-cli.
+
+Provides one-shot sync and a background daemon that periodically
+caches iCloud data to local JSON files.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import signal
+import sys
+import time
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any
+
+from icloud_cli.auth import AuthManager
+from icloud_cli.config import Config
+from icloud_cli.output import error, info, success, warning
+
+PID_FILE_NAME = "icloud-cli-daemon.pid"
+
+
+def sync_all(auth: AuthManager, config: Config) -> None:
+    """Run a one-shot sync of all services to local cache."""
+    cache_dir = Path(config.cache_dir)
+    cache_dir.mkdir(parents=True, exist_ok=True)
+
+    info("Syncing iCloud data...")
+
+    # Sync Calendar
+    try:
+        from icloud_cli.services.calendar import CalendarService
+
+        cal_service = CalendarService(auth.api, config)
+        now = datetime.now()
+        events = cal_service.list_events(
+            from_date=now.strftime("%Y-%m-%d"),
+            to_date=(now + timedelta(days=30)).strftime("%Y-%m-%d"),
+        )
+        _save_cache(cache_dir / "calendar.json", events)
+        success(f"Calendar: {len(events)} events synced.")
+    except Exception as e:
+        warning(f"Calendar sync failed: {e}")
+
+    # Sync Reminders
+    try:
+        from icloud_cli.services.reminders import RemindersService
+
+        rem_service = RemindersService(auth.api, config)
+        reminders = rem_service.list_reminders(show_completed=True)
+        _save_cache(cache_dir / "reminders.json", reminders)
+        success(f"Reminders: {len(reminders)} items synced.")
+    except Exception as e:
+        warning(f"Reminders sync failed: {e}")
+
+    # Sync Notes
+    try:
+        credentials = auth.get_imap_credentials()
+        if credentials:
+            from icloud_cli.services.notes import NotesService
+
+            notes_service = NotesService(*credentials)
+            notes = notes_service.list_notes()
+            _save_cache(cache_dir / "notes.json", notes)
+            success(f"Notes: {len(notes)} notes synced.")
+        else:
+            info("Notes: Skipped (IMAP not configured).")
+    except Exception as e:
+        warning(f"Notes sync failed: {e}")
+
+    # Sync Find My
+    try:
+        from icloud_cli.services.findmy import FindMyService
+
+        findmy_service = FindMyService(auth.api)
+        devices = findmy_service.list_devices()
+        _save_cache(cache_dir / "devices.json", devices)
+        success(f"Find My: {len(devices)} devices synced.")
+    except Exception as e:
+        warning(f"Find My sync failed: {e}")
+
+    # Write sync timestamp
+    _save_cache(cache_dir / "last_sync.json", {
+        "timestamp": datetime.now().isoformat(),
+        "status": "ok",
+    })
+
+    success("Sync complete!")
+
+
+def start_daemon(auth: AuthManager, config: Config) -> None:
+    """Start the background sync daemon."""
+    pid_file = Path(config.cache_dir) / PID_FILE_NAME
+
+    # Check if already running
+    if pid_file.exists():
+        try:
+            pid = int(pid_file.read_text().strip())
+            os.kill(pid, 0)  # Check if process exists
+            error(f"Daemon already running (PID {pid}).")
+            return
+        except (ProcessLookupError, ValueError):
+            # Stale PID file
+            pid_file.unlink(missing_ok=True)
+
+    interval = config.sync_interval_minutes
+    info(f"Starting daemon (sync every {interval} minutes)...")
+    info("Press Ctrl+C to stop, or use 'icloud-cli daemon stop'.")
+
+    # Write PID file
+    pid_file.parent.mkdir(parents=True, exist_ok=True)
+    pid_file.write_text(str(os.getpid()))
+
+    # Handle graceful shutdown
+    def _shutdown(signum, frame):
+        info("\nDaemon stopping...")
+        pid_file.unlink(missing_ok=True)
+        sys.exit(0)
+
+    signal.signal(signal.SIGTERM, _shutdown)
+    signal.signal(signal.SIGINT, _shutdown)
+
+    try:
+        while True:
+            try:
+                sync_all(auth, config)
+            except Exception as e:
+                warning(f"Sync cycle failed: {e}")
+
+            info(f"Next sync in {interval} minutes...")
+            time.sleep(interval * 60)
+    finally:
+        pid_file.unlink(missing_ok=True)
+
+
+def stop_daemon(config: Config) -> None:
+    """Stop the background sync daemon."""
+    pid_file = Path(config.cache_dir) / PID_FILE_NAME
+
+    if not pid_file.exists():
+        error("Daemon is not running.")
+        return
+
+    try:
+        pid = int(pid_file.read_text().strip())
+        os.kill(pid, signal.SIGTERM)
+        success(f"Daemon stopped (PID {pid}).")
+        pid_file.unlink(missing_ok=True)
+    except ProcessLookupError:
+        warning("Daemon process not found (stale PID file).")
+        pid_file.unlink(missing_ok=True)
+    except ValueError:
+        error("Invalid PID file.")
+        pid_file.unlink(missing_ok=True)
+
+
+def get_daemon_status(config: Config) -> dict[str, Any]:
+    """Get daemon status information."""
+    pid_file = Path(config.cache_dir) / PID_FILE_NAME
+    cache_dir = Path(config.cache_dir)
+    last_sync_file = cache_dir / "last_sync.json"
+
+    # Check if daemon is running
+    running = False
+    pid = None
+    if pid_file.exists():
+        try:
+            pid = int(pid_file.read_text().strip())
+            os.kill(pid, 0)
+            running = True
+        except (ProcessLookupError, ValueError):
+            pass
+
+    # Last sync info
+    last_sync = "Never"
+    if last_sync_file.exists():
+        try:
+            data = json.loads(last_sync_file.read_text())
+            last_sync = data.get("timestamp", "Unknown")
+        except (json.JSONDecodeError, KeyError):
+            pass
+
+    return {
+        "running": "Yes" if running else "No",
+        "pid": str(pid) if pid and running else "N/A",
+        "sync_interval": f"{config.sync_interval_minutes} minutes",
+        "last_sync": last_sync,
+        "cache_dir": config.cache_dir,
+    }
+
+
+def _save_cache(path: Path, data: Any) -> None:
+    """Save data to a JSON cache file."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w") as f:
+        json.dump(data, f, indent=2, default=str)