basic-memory 0.14.3__py3-none-any.whl → 0.15.0__py3-none-any.whl

basic_memory/cli/commands/cloud/core_commands.py

@@ -0,0 +1,288 @@
+"""Core cloud commands for Basic Memory CLI."""
+
+import asyncio
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from basic_memory.cli.app import cloud_app
+from basic_memory.cli.auth import CLIAuth
+from basic_memory.config import ConfigManager
+from basic_memory.cli.commands.cloud.api_client import (
+    CloudAPIError,
+    SubscriptionRequiredError,
+    get_cloud_config,
+    make_api_request,
+)
+from basic_memory.cli.commands.cloud.mount_commands import (
+    mount_cloud_files,
+    setup_cloud_mount,
+    show_mount_status,
+    unmount_cloud_files,
+)
+from basic_memory.cli.commands.cloud.bisync_commands import (
+    run_bisync,
+    run_bisync_watch,
+    run_check,
+    setup_cloud_bisync,
+    show_bisync_status,
+)
+from basic_memory.cli.commands.cloud.rclone_config import MOUNT_PROFILES
+from basic_memory.cli.commands.cloud.bisync_commands import BISYNC_PROFILES
+
+console = Console()
+
+
+@cloud_app.command()
+def login():
+    """Authenticate with WorkOS using OAuth Device Authorization flow and enable cloud mode."""
+
+    async def _login():
+        client_id, domain, host_url = get_cloud_config()
+        auth = CLIAuth(client_id=client_id, authkit_domain=domain)
+
+        try:
+            success = await auth.login()
+            if not success:
+                console.print("[red]Login failed[/red]")
+                raise typer.Exit(1)
+
+            # Test subscription access by calling a protected endpoint
+            console.print("[dim]Verifying subscription access...[/dim]")
+            await make_api_request("GET", f"{host_url.rstrip('/')}/proxy/health")
+
+            # Enable cloud mode after successful login and subscription validation
+            config_manager = ConfigManager()
+            config = config_manager.load_config()
+            config.cloud_mode = True
+            config_manager.save_config(config)
+
+            console.print("[green]✓ Cloud mode enabled[/green]")
+            console.print(f"[dim]All CLI commands now work against {host_url}[/dim]")
+
+        except SubscriptionRequiredError as e:
+            console.print("\n[red]✗ Subscription Required[/red]\n")
+            console.print(f"[yellow]{e.args[0]}[/yellow]\n")
+            console.print(f"Subscribe at: [blue underline]{e.subscribe_url}[/blue underline]\n")
+            console.print(
+                "[dim]Once you have an active subscription, run [bold]bm cloud login[/bold] again.[/dim]"
+            )
+            raise typer.Exit(1)
+
+    asyncio.run(_login())
+
+
+@cloud_app.command()
+def logout():
+    """Disable cloud mode and return to local mode."""
+
+    # Disable cloud mode
+    config_manager = ConfigManager()
+    config = config_manager.load_config()
+    config.cloud_mode = False
+    config_manager.save_config(config)
+
+    console.print("[green]✓ Cloud mode disabled[/green]")
+    console.print("[dim]All CLI commands now work locally[/dim]")
+
+
+@cloud_app.command("status")
+def status(
+    bisync: bool = typer.Option(
+        True,
+        "--bisync/--mount",
+        help="Show bisync status (default) or mount status",
+    ),
+) -> None:
+    """Check cloud mode status and cloud instance health.
+
+    Shows cloud mode status, instance health, and sync/mount status.
+    Use --bisync (default) to show bisync status or --mount for mount status.
+    """
+    # Check cloud mode
+    config_manager = ConfigManager()
+    config = config_manager.load_config()
+
+    console.print("[bold blue]Cloud Mode Status[/bold blue]")
+    if config.cloud_mode:
+        console.print("  Mode: [green]Cloud (enabled)[/green]")
+        console.print(f"  Host: {config.cloud_host}")
+        console.print("  [dim]All CLI commands work against cloud[/dim]")
+    else:
+        console.print("  Mode: [yellow]Local (disabled)[/yellow]")
+        console.print("  [dim]All CLI commands work locally[/dim]")
+        console.print("\n[dim]To enable cloud mode, run: bm cloud login[/dim]")
+        return
+
+    # Get cloud configuration
+    _, _, host_url = get_cloud_config()
+    host_url = host_url.rstrip("/")
+
+    # Prepare headers
+    headers = {}
+
+    try:
+        console.print("\n[blue]Checking cloud instance health...[/blue]")
+
+        # Make API request to check health
+        response = asyncio.run(
+            make_api_request(method="GET", url=f"{host_url}/proxy/health", headers=headers)
+        )
+
+        health_data = response.json()
+
+        console.print("[green]Cloud instance is healthy[/green]")
+
+        # Display status details
+        if "status" in health_data:
+            console.print(f"  Status: {health_data['status']}")
+        if "version" in health_data:
+            console.print(f"  Version: {health_data['version']}")
+        if "timestamp" in health_data:
+            console.print(f"  Timestamp: {health_data['timestamp']}")
+
+        # Show sync/mount status based on flag
+        console.print()
+        if bisync:
+            show_bisync_status()
+        else:
+            show_mount_status()
+
+    except CloudAPIError as e:
+        console.print(f"[red]Error checking cloud health: {e}[/red]")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Unexpected error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+# Mount commands
+
+
+@cloud_app.command("setup")
+def setup(
+    bisync: bool = typer.Option(
+        True,
+        "--bisync/--mount",
+        help="Use bidirectional sync (recommended) or mount as network drive",
+    ),
+    sync_dir: Optional[str] = typer.Option(
+        None,
+        "--dir",
+        help="Custom sync directory for bisync (default: ~/basic-memory-cloud-sync)",
+    ),
+) -> None:
+    """Set up cloud file access with automatic rclone installation and configuration.
+
+    Default: Sets up bidirectional sync (recommended).\n
+    Use --mount: Sets up mount as network drive (alternative workflow).\n
+
+    Examples:\n
+      bm cloud setup              # Setup bisync (default)\n
+      bm cloud setup --mount      # Setup mount instead\n
+      bm cloud setup --dir ~/sync # Custom bisync directory\n
+    """
+    if bisync:
+        setup_cloud_bisync(sync_dir=sync_dir)
+    else:
+        setup_cloud_mount()
+
+
+@cloud_app.command("mount")
+def mount(
+    profile: str = typer.Option(
+        "balanced", help=f"Mount profile: {', '.join(MOUNT_PROFILES.keys())}"
+    ),
+    path: Optional[str] = typer.Option(
+        None, help="Custom mount path (default: ~/basic-memory-{tenant-id})"
+    ),
+) -> None:
+    """Mount cloud files locally for editing."""
+    try:
+        mount_cloud_files(profile_name=profile)
+    except Exception as e:
+        console.print(f"[red]Mount failed: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@cloud_app.command("unmount")
+def unmount() -> None:
+    """Unmount cloud files."""
+    try:
+        unmount_cloud_files()
+    except Exception as e:
+        console.print(f"[red]Unmount failed: {e}[/red]")
+        raise typer.Exit(1)
+
+
+# Bisync commands
+
+
+@cloud_app.command("bisync")
+def bisync(
+    profile: str = typer.Option(
+        "balanced", help=f"Bisync profile: {', '.join(BISYNC_PROFILES.keys())}"
+    ),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Preview changes without syncing"),
+    resync: bool = typer.Option(False, "--resync", help="Force resync to establish new baseline"),
+    watch: bool = typer.Option(False, "--watch", help="Run continuous sync in watch mode"),
+    interval: int = typer.Option(60, "--interval", help="Sync interval in seconds for watch mode"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show detailed sync output"),
+) -> None:
+    """Run bidirectional sync between local files and cloud storage.
+
+    Examples:
+      basic-memory cloud bisync                    # Manual sync with balanced profile
+      basic-memory cloud bisync --dry-run          # Preview what would be synced
+      basic-memory cloud bisync --resync           # Establish new baseline
+      basic-memory cloud bisync --watch            # Continuous sync every 60s
+      basic-memory cloud bisync --watch --interval 30  # Continuous sync every 30s
+      basic-memory cloud bisync --profile safe     # Use safe profile (keep conflicts)
+      basic-memory cloud bisync --verbose          # Show detailed file sync output
+    """
+    try:
+        if watch:
+            run_bisync_watch(profile_name=profile, interval_seconds=interval)
+        else:
+            run_bisync(profile_name=profile, dry_run=dry_run, resync=resync, verbose=verbose)
+    except Exception as e:
+        console.print(f"[red]Bisync failed: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@cloud_app.command("bisync-status")
+def bisync_status() -> None:
+    """Show current bisync status and configuration.
+
+    DEPRECATED: Use 'bm cloud status' instead (bisync is now the default).
+    """
+    console.print(
+        "[yellow]Note: 'bisync-status' is deprecated. Use 'bm cloud status' instead.[/yellow]"
+    )
+    console.print("[dim]Showing bisync status...[/dim]\n")
+    show_bisync_status()
+
+
+@cloud_app.command("check")
+def check(
+    one_way: bool = typer.Option(
+        False,
+        "--one-way",
+        help="Only check for missing files on destination (faster)",
+    ),
+) -> None:
+    """Check file integrity between local and cloud storage using rclone check.
+
+    Verifies that files match between your local bisync directory and cloud storage
+    without transferring any data. This is useful for validating sync integrity.
+
+    Examples:
+      bm cloud check              # Full integrity check
+      bm cloud check --one-way    # Faster check (missing files only)
+    """
+    try:
+        run_check(one_way=one_way)
+    except Exception as e:
+        console.print(f"[red]Check failed: {e}[/red]")
+        raise typer.Exit(1)

basic_memory/cli/commands/cloud/mount_commands.py

@@ -0,0 +1,295 @@
+"""Cloud mount commands for Basic Memory CLI."""
+
+import asyncio
+import subprocess
+import time
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from basic_memory.cli.commands.cloud.api_client import CloudAPIError, make_api_request
+from basic_memory.cli.commands.cloud.rclone_config import (
+    MOUNT_PROFILES,
+    add_tenant_to_rclone_config,
+    build_mount_command,
+    cleanup_orphaned_rclone_processes,
+    get_default_mount_path,
+    get_rclone_processes,
+    is_path_mounted,
+    unmount_path,
+)
+from basic_memory.cli.commands.cloud.rclone_installer import RcloneInstallError, install_rclone
+from basic_memory.config import ConfigManager
+
+console = Console()
+
+
+class MountError(Exception):
+    """Exception raised for mount-related errors."""
+
+    pass
+
+
+async def get_tenant_info() -> dict:
+    """Get current tenant information from cloud API."""
+    try:
+        config_manager = ConfigManager()
+        config = config_manager.config
+        host_url = config.cloud_host.rstrip("/")
+
+        response = await make_api_request(method="GET", url=f"{host_url}/tenant/mount/info")
+
+        return response.json()
+    except Exception as e:
+        raise MountError(f"Failed to get tenant info: {e}") from e
+
+
+async def generate_mount_credentials(tenant_id: str) -> dict:
+    """Generate scoped credentials for mounting."""
+    try:
+        config_manager = ConfigManager()
+        config = config_manager.config
+        host_url = config.cloud_host.rstrip("/")
+
+        response = await make_api_request(method="POST", url=f"{host_url}/tenant/mount/credentials")
+
+        return response.json()
+    except Exception as e:
+        raise MountError(f"Failed to generate mount credentials: {e}") from e
+
+
+def setup_cloud_mount() -> None:
+    """Set up cloud mount with rclone installation and configuration."""
+    console.print("[bold blue]Basic Memory Cloud Setup[/bold blue]")
+    console.print("Setting up local file access to your cloud tenant...\n")
+
+    try:
+        # Step 1: Install rclone
+        console.print("[blue]Step 1: Installing rclone...[/blue]")
+        install_rclone()
+
+        # Step 2: Get tenant info
+        console.print("\n[blue]Step 2: Getting tenant information...[/blue]")
+        tenant_info = asyncio.run(get_tenant_info())
+
+        tenant_id = tenant_info.get("tenant_id")
+        bucket_name = tenant_info.get("bucket_name")
+
+        if not tenant_id or not bucket_name:
+            raise MountError("Invalid tenant information received from cloud API")
+
+        console.print(f"[green]✓ Found tenant: {tenant_id}[/green]")
+        console.print(f"[green]✓ Bucket: {bucket_name}[/green]")
+
+        # Step 3: Generate mount credentials
+        console.print("\n[blue]Step 3: Generating mount credentials...[/blue]")
+        creds = asyncio.run(generate_mount_credentials(tenant_id))
+
+        access_key = creds.get("access_key")
+        secret_key = creds.get("secret_key")
+
+        if not access_key or not secret_key:
+            raise MountError("Failed to generate mount credentials")
+
+        console.print("[green]✓ Generated secure credentials[/green]")
+
+        # Step 4: Configure rclone
+        console.print("\n[blue]Step 4: Configuring rclone...[/blue]")
+        add_tenant_to_rclone_config(
+            tenant_id=tenant_id,
+            bucket_name=bucket_name,
+            access_key=access_key,
+            secret_key=secret_key,
+        )
+
+        # Step 5: Perform initial mount
+        console.print("\n[blue]Step 5: Mounting cloud files...[/blue]")
+        mount_path = get_default_mount_path()
+        MOUNT_PROFILES["balanced"]
+
+        mount_cloud_files(
+            tenant_id=tenant_id,
+            bucket_name=bucket_name,
+            mount_path=mount_path,
+            profile_name="balanced",
+        )
+
+        console.print("\n[bold green]✓ Cloud setup completed successfully![/bold green]")
+        console.print("\nYour cloud files are now accessible at:")
+        console.print(f"  {mount_path}")
+        console.print("\nYou can now edit files locally and they will sync to the cloud!")
+        console.print("\nUseful commands:")
+        console.print("  basic-memory cloud mount-status    # Check mount status")
+        console.print("  basic-memory cloud unmount         # Unmount files")
+        console.print("  basic-memory cloud mount --profile fast  # Remount with faster sync")
+
+    except (RcloneInstallError, MountError, CloudAPIError) as e:
+        console.print(f"\n[red]Setup failed: {e}[/red]")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"\n[red]Unexpected error during setup: {e}[/red]")
+        raise typer.Exit(1)
+
+
+def mount_cloud_files(
+    tenant_id: Optional[str] = None,
+    bucket_name: Optional[str] = None,
+    mount_path: Optional[Path] = None,
+    profile_name: str = "balanced",
+) -> None:
+    """Mount cloud files with specified profile."""
+
+    try:
+        # Get tenant info if not provided
+        if not tenant_id or not bucket_name:
+            tenant_info = asyncio.run(get_tenant_info())
+            tenant_id = tenant_info.get("tenant_id")
+            bucket_name = tenant_info.get("bucket_name")
+
+            if not tenant_id or not bucket_name:
+                raise MountError("Could not determine tenant information")
+
+        # Set default mount path if not provided
+        if not mount_path:
+            mount_path = get_default_mount_path()
+
+        # Get mount profile
+        if profile_name not in MOUNT_PROFILES:
+            raise MountError(
+                f"Unknown profile: {profile_name}. Available: {list(MOUNT_PROFILES.keys())}"
+            )
+
+        profile = MOUNT_PROFILES[profile_name]
+
+        # Check if already mounted
+        if is_path_mounted(mount_path):
+            console.print(f"[yellow]Path {mount_path} is already mounted[/yellow]")
+            console.print("Use 'basic-memory cloud unmount' first, or mount to a different path")
+            return
+
+        # Create mount directory
+        mount_path.mkdir(parents=True, exist_ok=True)
+
+        # Build and execute mount command
+        mount_cmd = build_mount_command(tenant_id, bucket_name, mount_path, profile)
+
+        console.print(
+            f"[blue]Mounting with profile '{profile_name}' ({profile.description})...[/blue]"
+        )
+        console.print(f"[dim]Command: {' '.join(mount_cmd)}[/dim]")
+
+        result = subprocess.run(mount_cmd, capture_output=True, text=True)
+
+        if result.returncode != 0:
+            error_msg = result.stderr or "Unknown error"
+            raise MountError(f"Mount command failed: {error_msg}")
+
+        # Wait a moment for mount to establish
+        time.sleep(2)
+
+        # Verify mount
+        if is_path_mounted(mount_path):
+            console.print(f"[green]✓ Successfully mounted to {mount_path}[/green]")
+            console.print(f"[green]✓ Sync profile: {profile.description}[/green]")
+        else:
+            raise MountError("Mount command succeeded but path is not mounted")
+
+    except MountError:
+        raise
+    except Exception as e:
+        raise MountError(f"Unexpected error during mount: {e}") from e
+
+
+def unmount_cloud_files(tenant_id: Optional[str] = None) -> None:
+    """Unmount cloud files."""
+
+    try:
+        # Get tenant info if not provided
+        if not tenant_id:
+            tenant_info = asyncio.run(get_tenant_info())
+            tenant_id = tenant_info.get("tenant_id")
+
+            if not tenant_id:
+                raise MountError("Could not determine tenant ID")
+
+        mount_path = get_default_mount_path()
+
+        if not is_path_mounted(mount_path):
+            console.print(f"[yellow]Path {mount_path} is not mounted[/yellow]")
+            return
+
+        console.print(f"[blue]Unmounting {mount_path}...[/blue]")
+
+        # Unmount the path
+        if unmount_path(mount_path):
+            console.print(f"[green]✓ Successfully unmounted {mount_path}[/green]")
+
+            # Clean up any orphaned rclone processes
+            killed_count = cleanup_orphaned_rclone_processes()
+            if killed_count > 0:
+                console.print(
+                    f"[green]✓ Cleaned up {killed_count} orphaned rclone process(es)[/green]"
+                )
+        else:
+            console.print(f"[red]✗ Failed to unmount {mount_path}[/red]")
+            console.print("You may need to manually unmount or restart your system")
+
+    except MountError:
+        raise
+    except Exception as e:
+        raise MountError(f"Unexpected error during unmount: {e}") from e
+
+
+def show_mount_status() -> None:
+    """Show current mount status and running processes."""
+
+    try:
+        # Get tenant info
+        tenant_info = asyncio.run(get_tenant_info())
+        tenant_id = tenant_info.get("tenant_id")
+
+        if not tenant_id:
+            console.print("[red]Could not determine tenant ID[/red]")
+            return
+
+        mount_path = get_default_mount_path()
+
+        # Create status table
+        table = Table(title="Cloud Mount Status", show_header=True, header_style="bold blue")
+        table.add_column("Property", style="green", min_width=15)
+        table.add_column("Value", style="dim", min_width=30)
+
+        # Check mount status
+        is_mounted = is_path_mounted(mount_path)
+        mount_status = "[green]✓ Mounted[/green]" if is_mounted else "[red]✗ Not mounted[/red]"
+
+        table.add_row("Tenant ID", tenant_id)
+        table.add_row("Mount Path", str(mount_path))
+        table.add_row("Status", mount_status)
+
+        # Get rclone processes
+        processes = get_rclone_processes()
+        if processes:
+            table.add_row("rclone Processes", f"{len(processes)} running")
+        else:
+            table.add_row("rclone Processes", "None")
+
+        console.print(table)
+
+        # Show running processes details
+        if processes:
+            console.print("\n[bold]Running rclone processes:[/bold]")
+            for proc in processes:
+                console.print(f"  PID {proc['pid']}: {proc['command'][:80]}...")
+
+        # Show mount profiles
+        console.print("\n[bold]Available mount profiles:[/bold]")
+        for name, profile in MOUNT_PROFILES.items():
+            console.print(f"  {name}: {profile.description}")
+
+    except Exception as e:
+        console.print(f"[red]Error getting mount status: {e}[/red]")
+        raise typer.Exit(1)