basic-memory 0.14.4__py3-none-any.whl → 0.15.1__py3-none-any.whl

basic_memory/cli/commands/cloud/rclone_config.py

@@ -0,0 +1,288 @@
+"""rclone configuration management for Basic Memory Cloud."""
+
+import configparser
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from rich.console import Console
+
+console = Console()
+
+
+class RcloneConfigError(Exception):
+    """Exception raised for rclone configuration errors."""
+
+    pass
+
+
+class RcloneMountProfile:
+    """Mount profile with optimized settings."""
+
+    def __init__(
+        self,
+        name: str,
+        cache_time: str,
+        poll_interval: str,
+        attr_timeout: str,
+        write_back: str,
+        description: str,
+        extra_args: Optional[List[str]] = None,
+    ):
+        self.name = name
+        self.cache_time = cache_time
+        self.poll_interval = poll_interval
+        self.attr_timeout = attr_timeout
+        self.write_back = write_back
+        self.description = description
+        self.extra_args = extra_args or []
+
+
+# Mount profiles based on SPEC-7 Phase 4 testing
+MOUNT_PROFILES = {
+    "fast": RcloneMountProfile(
+        name="fast",
+        cache_time="5s",
+        poll_interval="3s",
+        attr_timeout="3s",
+        write_back="1s",
+        description="Ultra-fast development (5s sync, higher bandwidth)",
+    ),
+    "balanced": RcloneMountProfile(
+        name="balanced",
+        cache_time="10s",
+        poll_interval="5s",
+        attr_timeout="5s",
+        write_back="2s",
+        description="Fast development (10-15s sync, recommended)",
+    ),
+    "safe": RcloneMountProfile(
+        name="safe",
+        cache_time="15s",
+        poll_interval="10s",
+        attr_timeout="10s",
+        write_back="5s",
+        description="Conflict-aware mount with backup",
+        extra_args=[
+            "--conflict-suffix",
+            ".conflict-{DateTimeExt}",
+            "--backup-dir",
+            "~/.basic-memory/conflicts",
+            "--track-renames",
+        ],
+    ),
+}
+
+
+def get_rclone_config_path() -> Path:
+    """Get the path to rclone configuration file."""
+    config_dir = Path.home() / ".config" / "rclone"
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir / "rclone.conf"
+
+
+def backup_rclone_config() -> Optional[Path]:
+    """Create a backup of existing rclone config."""
+    config_path = get_rclone_config_path()
+    if not config_path.exists():
+        return None
+
+    backup_path = config_path.with_suffix(f".conf.backup-{os.getpid()}")
+    shutil.copy2(config_path, backup_path)
+    console.print(f"[dim]Created backup: {backup_path}[/dim]")
+    return backup_path
+
+
+def load_rclone_config() -> configparser.ConfigParser:
+    """Load existing rclone configuration."""
+    config = configparser.ConfigParser()
+    config_path = get_rclone_config_path()
+
+    if config_path.exists():
+        config.read(config_path)
+
+    return config
+
+
+def save_rclone_config(config: configparser.ConfigParser) -> None:
+    """Save rclone configuration to file."""
+    config_path = get_rclone_config_path()
+
+    with open(config_path, "w") as f:
+        config.write(f)
+
+    console.print(f"[dim]Updated rclone config: {config_path}[/dim]")
+
+
+def add_tenant_to_rclone_config(
+    tenant_id: str,
+    bucket_name: str,
+    access_key: str,
+    secret_key: str,
+    endpoint: str = "https://fly.storage.tigris.dev",
+    region: str = "auto",
+) -> str:
+    """Add tenant configuration to rclone config file."""
+
+    # Backup existing config
+    backup_rclone_config()
+
+    # Load existing config
+    config = load_rclone_config()
+
+    # Create section name
+    section_name = f"basic-memory-{tenant_id}"
+
+    # Add/update the tenant section
+    if not config.has_section(section_name):
+        config.add_section(section_name)
+
+    config.set(section_name, "type", "s3")
+    config.set(section_name, "provider", "Other")
+    config.set(section_name, "access_key_id", access_key)
+    config.set(section_name, "secret_access_key", secret_key)
+    config.set(section_name, "endpoint", endpoint)
+    config.set(section_name, "region", region)
+
+    # Save updated config
+    save_rclone_config(config)
+
+    console.print(f"[green]✓ Added tenant {tenant_id} to rclone config[/green]")
+    return section_name
+
+
+def remove_tenant_from_rclone_config(tenant_id: str) -> bool:
+    """Remove tenant configuration from rclone config."""
+    config = load_rclone_config()
+    section_name = f"basic-memory-{tenant_id}"
+
+    if config.has_section(section_name):
+        backup_rclone_config()
+        config.remove_section(section_name)
+        save_rclone_config(config)
+        console.print(f"[green]✓ Removed tenant {tenant_id} from rclone config[/green]")
+        return True
+
+    return False
+
+
+def get_default_mount_path() -> Path:
+    """Get default mount path (fixed location per SPEC-9).
+
+    Returns:
+        Fixed mount path: ~/basic-memory-cloud/
+    """
+    return Path.home() / "basic-memory-cloud"
+
+
+def build_mount_command(
+    tenant_id: str, bucket_name: str, mount_path: Path, profile: RcloneMountProfile
+) -> List[str]:
+    """Build rclone mount command with optimized settings."""
+
+    rclone_remote = f"basic-memory-{tenant_id}:{bucket_name}"
+
+    cmd = [
+        "rclone",
+        "nfsmount",
+        rclone_remote,
+        str(mount_path),
+        "--vfs-cache-mode",
+        "writes",
+        "--dir-cache-time",
+        profile.cache_time,
+        "--vfs-cache-poll-interval",
+        profile.poll_interval,
+        "--attr-timeout",
+        profile.attr_timeout,
+        "--vfs-write-back",
+        profile.write_back,
+        "--daemon",
+    ]
+
+    # Add profile-specific extra arguments
+    cmd.extend(profile.extra_args)
+
+    return cmd
+
+
+def is_path_mounted(mount_path: Path) -> bool:
+    """Check if a path is currently mounted."""
+    if not mount_path.exists():
+        return False
+
+    try:
+        # Check if mount point is actually mounted by looking for mount table entry
+        result = subprocess.run(["mount"], capture_output=True, text=True, check=False)
+
+        if result.returncode == 0:
+            # Look for our mount path in mount output
+            mount_str = str(mount_path.resolve())
+            return mount_str in result.stdout
+
+        return False
+    except Exception:
+        return False
+
+
+def get_rclone_processes() -> List[Dict[str, str]]:
+    """Get list of running rclone processes."""
+    try:
+        # Use ps to find rclone processes
+        result = subprocess.run(
+            ["ps", "-eo", "pid,args"], capture_output=True, text=True, check=False
+        )
+
+        processes = []
+        if result.returncode == 0:
+            for line in result.stdout.split("\n"):
+                if "rclone" in line and "basic-memory" in line:
+                    parts = line.strip().split(None, 1)
+                    if len(parts) >= 2:
+                        processes.append({"pid": parts[0], "command": parts[1]})
+
+        return processes
+    except Exception:
+        return []
+
+
+def kill_rclone_process(pid: str) -> bool:
+    """Kill a specific rclone process."""
+    try:
+        subprocess.run(["kill", pid], check=True)
+        console.print(f"[green]✓ Killed rclone process {pid}[/green]")
+        return True
+    except subprocess.CalledProcessError:
+        console.print(f"[red]✗ Failed to kill rclone process {pid}[/red]")
+        return False
+
+
+def unmount_path(mount_path: Path) -> bool:
+    """Unmount a mounted path."""
+    if not is_path_mounted(mount_path):
+        return True
+
+    try:
+        subprocess.run(["umount", str(mount_path)], check=True)
+        console.print(f"[green]✓ Unmounted {mount_path}[/green]")
+        return True
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]✗ Failed to unmount {mount_path}: {e}[/red]")
+        return False
+
+
+def cleanup_orphaned_rclone_processes() -> int:
+    """Clean up orphaned rclone processes for basic-memory."""
+    processes = get_rclone_processes()
+    killed_count = 0
+
+    for proc in processes:
+        console.print(
+            f"[yellow]Found rclone process: {proc['pid']} - {proc['command'][:80]}...[/yellow]"
+        )
+        if kill_rclone_process(proc["pid"]):
+            killed_count += 1
+
+    return killed_count

basic_memory/cli/commands/cloud/rclone_installer.py

@@ -0,0 +1,198 @@
+"""Cross-platform rclone installation utilities."""
+
+import platform
+import shutil
+import subprocess
+from typing import Optional
+
+from rich.console import Console
+
+console = Console()
+
+
+class RcloneInstallError(Exception):
+    """Exception raised for rclone installation errors."""
+
+    pass
+
+
+def is_rclone_installed() -> bool:
+    """Check if rclone is already installed and available in PATH."""
+    return shutil.which("rclone") is not None
+
+
+def get_platform() -> str:
+    """Get the current platform identifier."""
+    system = platform.system().lower()
+    if system == "darwin":
+        return "macos"
+    elif system == "linux":
+        return "linux"
+    elif system == "windows":
+        return "windows"
+    else:
+        raise RcloneInstallError(f"Unsupported platform: {system}")
+
+
+def run_command(command: list[str], check: bool = True) -> subprocess.CompletedProcess:
+    """Run a command with proper error handling."""
+    try:
+        console.print(f"[dim]Running: {' '.join(command)}[/dim]")
+        result = subprocess.run(command, capture_output=True, text=True, check=check)
+        if result.stdout:
+            console.print(f"[dim]Output: {result.stdout.strip()}[/dim]")
+        return result
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]Command failed: {e}[/red]")
+        if e.stderr:
+            console.print(f"[red]Error output: {e.stderr}[/red]")
+        raise RcloneInstallError(f"Command failed: {e}") from e
+    except FileNotFoundError as e:
+        raise RcloneInstallError(f"Command not found: {' '.join(command)}") from e
+
+
+def install_rclone_macos() -> None:
+    """Install rclone on macOS using Homebrew or official script."""
+    # Try Homebrew first
+    if shutil.which("brew"):
+        try:
+            console.print("[blue]Installing rclone via Homebrew...[/blue]")
+            run_command(["brew", "install", "rclone"])
+            console.print("[green]✓ rclone installed via Homebrew[/green]")
+            return
+        except RcloneInstallError:
+            console.print(
+                "[yellow]Homebrew installation failed, trying official script...[/yellow]"
+            )
+
+    # Fallback to official script
+    console.print("[blue]Installing rclone via official script...[/blue]")
+    try:
+        run_command(["sh", "-c", "curl https://rclone.org/install.sh | sudo bash"])
+        console.print("[green]✓ rclone installed via official script[/green]")
+    except RcloneInstallError:
+        raise RcloneInstallError(
+            "Failed to install rclone. Please install manually: brew install rclone"
+        )
+
+
+def install_rclone_linux() -> None:
+    """Install rclone on Linux using package managers or official script."""
+    # Try snap first (most universal)
+    if shutil.which("snap"):
+        try:
+            console.print("[blue]Installing rclone via snap...[/blue]")
+            run_command(["sudo", "snap", "install", "rclone"])
+            console.print("[green]✓ rclone installed via snap[/green]")
+            return
+        except RcloneInstallError:
+            console.print("[yellow]Snap installation failed, trying apt...[/yellow]")
+
+    # Try apt (Debian/Ubuntu)
+    if shutil.which("apt"):
+        try:
+            console.print("[blue]Installing rclone via apt...[/blue]")
+            run_command(["sudo", "apt", "update"])
+            run_command(["sudo", "apt", "install", "-y", "rclone"])
+            console.print("[green]✓ rclone installed via apt[/green]")
+            return
+        except RcloneInstallError:
+            console.print("[yellow]apt installation failed, trying official script...[/yellow]")
+
+    # Fallback to official script
+    console.print("[blue]Installing rclone via official script...[/blue]")
+    try:
+        run_command(["sh", "-c", "curl https://rclone.org/install.sh | sudo bash"])
+        console.print("[green]✓ rclone installed via official script[/green]")
+    except RcloneInstallError:
+        raise RcloneInstallError(
+            "Failed to install rclone. Please install manually: sudo snap install rclone"
+        )
+
+
+def install_rclone_windows() -> None:
+    """Install rclone on Windows using package managers."""
+    # Try winget first (built into Windows 10+)
+    if shutil.which("winget"):
+        try:
+            console.print("[blue]Installing rclone via winget...[/blue]")
+            run_command(["winget", "install", "Rclone.Rclone"])
+            console.print("[green]✓ rclone installed via winget[/green]")
+            return
+        except RcloneInstallError:
+            console.print("[yellow]winget installation failed, trying chocolatey...[/yellow]")
+
+    # Try chocolatey
+    if shutil.which("choco"):
+        try:
+            console.print("[blue]Installing rclone via chocolatey...[/blue]")
+            run_command(["choco", "install", "rclone", "-y"])
+            console.print("[green]✓ rclone installed via chocolatey[/green]")
+            return
+        except RcloneInstallError:
+            console.print("[yellow]chocolatey installation failed, trying scoop...[/yellow]")
+
+    # Try scoop
+    if shutil.which("scoop"):
+        try:
+            console.print("[blue]Installing rclone via scoop...[/blue]")
+            run_command(["scoop", "install", "rclone"])
+            console.print("[green]✓ rclone installed via scoop[/green]")
+            return
+        except RcloneInstallError:
+            console.print("[yellow]scoop installation failed[/yellow]")
+
+    # No package manager available
+    raise RcloneInstallError(
+        "Could not install rclone automatically. Please install a package manager "
+        "(winget, chocolatey, or scoop) or install rclone manually from https://rclone.org/downloads/"
+    )
+
+
+def install_rclone(platform_override: Optional[str] = None) -> None:
+    """Install rclone for the current platform."""
+    if is_rclone_installed():
+        console.print("[green]rclone is already installed[/green]")
+        return
+
+    platform_name = platform_override or get_platform()
+    console.print(f"[blue]Installing rclone for {platform_name}...[/blue]")
+
+    try:
+        if platform_name == "macos":
+            install_rclone_macos()
+        elif platform_name == "linux":
+            install_rclone_linux()
+        elif platform_name == "windows":
+            install_rclone_windows()
+        else:
+            raise RcloneInstallError(f"Unsupported platform: {platform_name}")
+
+        # Verify installation
+        if not is_rclone_installed():
+            raise RcloneInstallError("rclone installation completed but command not found in PATH")
+
+        console.print("[green]✓ rclone installation completed successfully[/green]")
+
+    except RcloneInstallError:
+        raise
+    except Exception as e:
+        raise RcloneInstallError(f"Unexpected error during installation: {e}") from e
+
+
+def get_rclone_version() -> Optional[str]:
+    """Get the installed rclone version."""
+    if not is_rclone_installed():
+        return None
+
+    try:
+        result = run_command(["rclone", "version"], check=False)
+        if result.returncode == 0:
+            # Parse version from output (format: "rclone v1.64.0")
+            lines = result.stdout.strip().split("\n")
+            for line in lines:
+                if line.startswith("rclone v"):
+                    return line.split()[1]
+        return "unknown"
+    except Exception:
+        return "unknown"

basic_memory/cli/commands/command_utils.py

@@ -0,0 +1,43 @@
+"""utility functions for commands"""
+
+from typing import Optional
+
+from mcp.server.fastmcp.exceptions import ToolError
+import typer
+
+from rich.console import Console
+
+from basic_memory.mcp.async_client import get_client
+
+from basic_memory.mcp.tools.utils import call_post, call_get
+from basic_memory.mcp.project_context import get_active_project
+from basic_memory.schemas import ProjectInfoResponse
+
+console = Console()
+
+
+async def run_sync(project: Optional[str] = None):
+    """Run sync operation via API endpoint."""
+
+    try:
+        async with get_client() as client:
+            project_item = await get_active_project(client, project, None)
+            response = await call_post(client, f"{project_item.project_url}/project/sync")
+            data = response.json()
+            console.print(f"[green]✓ {data['message']}[/green]")
+    except (ToolError, ValueError) as e:
+        console.print(f"[red]✗ Sync failed: {e}[/red]")
+        raise typer.Exit(1)
+
+
+async def get_project_info(project: str):
+    """Get project information via API endpoint."""
+
+    try:
+        async with get_client() as client:
+            project_item = await get_active_project(client, project, None)
+            response = await call_get(client, f"{project_item.project_url}/project/info")
+            return ProjectInfoResponse.model_validate(response.json())
+    except (ToolError, ValueError) as e:
+        console.print(f"[red]✗ Sync failed: {e}[/red]")
+        raise typer.Exit(1)

basic_memory/cli/commands/import_memory_json.py

@@ -39,8 +39,6 @@ def memory_json(
     1. Read entities and relations from the JSON file
     2. Create markdown files for each entity
     3. Include outgoing relations in each entity's markdown
-
-    After importing, run 'basic-memory sync' to index the new files.
     """
 
     if not json_path.exists():
@@ -82,8 +80,6 @@ def memory_json(
             )
         )
 
-        console.print("\nRun 'basic-memory sync' to index the new files.")
-
     except Exception as e:
         logger.error("Import failed")
         typer.echo(f"Error during import: {e}", err=True)