Backing up database file via the cli #704 (#712)

## Description
Feature]: Backing up database file via the CLI #704

## Related Issues
#704

Closes #

## Checklist when merging to main
<!-- Mark items with "x" when completed -->

- [x] No compiler warnings (if applicable)
- [x] Code is formatted with `rustfmt`
- [x] No useless or dead code (if applicable)
- [x] Code is easy to understand
- [x] Doc comments are used for all functions, enums, structs, and
fields (where appropriate)
- [x] All tests pass
- [x] Performance has not regressed (assuming change was not to fix a
bug)
- [x] Version number has been updated in `helix-cli/Cargo.toml` and
`helixdb/Cargo.toml`

## Additional Notes
Implemented a backup CLI to back up the selected instance using the
command: cargo run --bin helix backup dev --output <output-path>. This
addresses the issue mentioned in the feature request: "Backing up
database file via the CLI" (#704).

If a path is not provided, the CLI will create a directory in the
current path with a timestamp. If the file size exceeds 10GB, the CLI
will prompt for confirmation before proceeding. Additionally, if
read/write permissions are unavailable, it will print a permission error
message.

<!-- greptile_comment -->

<h3>Greptile Summary</h3>


- Implements `helix backup` CLI command to copy instance database files
(`data.mdb` and `lock.mdb`) to a backup directory with optional custom
output path
- Adds size warnings for backups over 10GB and permission checks before
copying files

<details><summary><h3>Important Files Changed</h3></summary>




| Filename | Overview |
|----------|----------|
| helix-cli/src/commands/backup.rs | New backup command implementation
with permission checks and size warnings; missing lock_file existence
check before metadata call |

</details>


</details>


<details><summary><h3>Sequence Diagram</h3></summary>

```mermaid
sequenceDiagram
    participant User
    participant CLI as "helix backup"
    participant ProjectContext
    participant FileSystem

    User->>CLI: "helix backup <instance> --output <path>"
    CLI->>ProjectContext: "find_and_load()"
    ProjectContext-->>CLI: "project context"
    CLI->>ProjectContext: "get_instance(instance_name)"
    ProjectContext-->>CLI: "instance config"
    CLI->>FileSystem: "check data_file.exists()"
    FileSystem-->>CLI: "exists"
    CLI->>FileSystem: "metadata(data_file)"
    FileSystem-->>CLI: "file size"
    CLI->>FileSystem: "metadata(lock_file)"
    FileSystem-->>CLI: "file size"
    alt size > 10GB
        CLI->>User: "Warn: size is X GB"
        CLI->>User: "Confirm: continue?"
        User-->>CLI: "yes/no"
        alt user cancels
            CLI->>User: "Backup aborted"
        end
    end
    CLI->>FileSystem: "check_read_write_permission(data_file)"
    FileSystem-->>CLI: "permissions ok"
    CLI->>FileSystem: "check_read_write_permission(lock_file)"
    FileSystem-->>CLI: "permissions ok"
    CLI->>FileSystem: "copy(data_file)"
    FileSystem-->>CLI: "copied"
    CLI->>FileSystem: "copy(lock_file)"
    FileSystem-->>CLI: "copied"
    CLI->>User: "Backup created successfully"
```
</details>


<!-- greptile_other_comments_section -->

<!-- /greptile_comment -->

Author: xav-db

Cargo.lock

@@ -25,6 +25,7 @@ dotenvy = "0.15.7"
 tokio-tungstenite = "0.27.0"
 futures-util = "0.3.31"
 regex = "1.11.2"
+heed3 = "0.22.0"
 open = "5.3"
 
 [dev-dependencies]

helix-cli/Cargo.toml

@@ -0,0 +1,110 @@
+use crate::project::ProjectContext;
+use crate::utils::{print_confirm, print_status, print_success, print_warning};
+use eyre::Result;
+use heed3::{CompactionOption, EnvFlags, EnvOpenOptions};
+use std::fs;
+use std::fs::create_dir_all;
+use std::path::Path;
+use std::path::PathBuf;
+
+pub async fn run(output: Option<PathBuf>, instance_name: String) -> Result<()> {
+    // Load project context
+    let project = ProjectContext::find_and_load(None)?;
+
+    // Get instance config
+    let _instance_config = project.config.get_instance(&instance_name)?;
+
+    print_status("BACKUP", &format!("Backing up instance '{instance_name}'"));
+
+    // Get the instance volume
+    let volumes_dir = project
+        .root
+        .join(".helix")
+        .join(".volumes")
+        .join(&instance_name)
+        .join("user");
+
+    let data_file = volumes_dir.join("data.mdb");
+    let lock_file = volumes_dir.join("lock.mdb");
+
+    let env_path = Path::new(&volumes_dir);
+
+    // Validate existence of environment
+    if !env_path.exists() {
+        return Err(eyre::eyre!(
+            "Instance LMDB environment not found at {:?}",
+            env_path
+        ));
+    }
+
+    // Check existence of data_file before calling metadata()
+    if !data_file.exists() {
+        return Err(eyre::eyre!(
+            "instance data file not found at {:?}",
+            data_file
+        ));
+    }
+
+    // Check existence of lock_file before calling metadata()
+    if !lock_file.exists() {
+        return Err(eyre::eyre!(
+            "instance lock file not found at {:?}",
+            lock_file
+        ));
+    }
+
+    // Get path to backup instance
+    let backup_dir = match output {
+        Some(path) => path,
+        None => {
+            let ts = chrono::Local::now()
+                .format("backup-%Y%m%d-%H%M%S")
+                .to_string();
+            project.root.join("backups").join(ts)
+        }
+    };
+
+    create_dir_all(&backup_dir)?;
+
+    // Get the size of the data
+    let total_size = fs::metadata(&data_file)?.len() + std::fs::metadata(&lock_file)?.len();
+
+    const TEN_GB: u64 = 10 * 1024 * 1024 * 1024;
+
+    // Check and warn if file is greater than 10 GB
+
+    if total_size > TEN_GB {
+        let size_gb = (total_size as f64) / (1024.0 * 1024.0 * 1024.0);
+        print_warning(&format!(
+            "Backup size is {:.2} GB. Taking atomic snapshot… this may take time depending on DB size",
+            size_gb
+        ));
+        let confirmed = print_confirm("Do you want to continue?");
+        if !confirmed? {
+            print_status("CANCEL", "Backup aborted by user");
+            return Ok(());
+        }
+    }
+
+    // Open LMDB read-only snapshot environment
+    let env = unsafe {
+        EnvOpenOptions::new()
+            .flags(EnvFlags::READ_ONLY)
+            .max_dbs(200)
+            .max_readers(200)
+            .open(env_path)?
+    };
+
+    println!("Copying {:?} → {:?}", &data_file, &backup_dir);
+
+    // backup database to given database
+    env.copy_to_path(backup_dir.join("data.mdb"), CompactionOption::Disabled)?;
+    env.copy_to_path(backup_dir.join("lock.mdb"), CompactionOption::Disabled)?;
+
+    print_success(&format!(
+        "Backup for '{instance_name}' created at {:?}",
+        backup_dir
+    ));
+
+    Ok(())
+}

helix-cli/src/commands/backup.rs

@@ -1,5 +1,6 @@
 pub mod add;
 pub mod auth;
+pub mod backup;
 pub mod build;
 pub mod check;
 pub mod compile;

helix-cli/src/commands/mod.rs

@@ -1,7 +1,9 @@
 use clap::{Parser, Subcommand};
 use eyre::Result;
+use std::path::PathBuf;
 use helix_cli::{AuthAction, CloudDeploymentTypeCommand, DashboardAction, MetricsAction};
 
+
 mod cleanup;
 mod commands;
 mod config;
@@ -163,6 +165,16 @@ enum Commands {
         #[clap(long)]
         no_backup: bool,
     },
+
+    /// Backup instance at the given path
+    Backup {
+        /// Instance name to backup
+        instance: String,
+
+        /// Output directory for the backup. If omitted, ./backups/backup-<ts>/ will be used
+        #[arg(short, long)]
+        output: Option<PathBuf>,
+    },
 }
 
 #[tokio::main]
@@ -212,7 +224,10 @@ async fn main() -> Result<()> {
             port,
             dry_run,
             no_backup,
-        } => commands::migrate::run(path, queries_dir, instance_name, port, dry_run, no_backup).await,
+        } => {
+            commands::migrate::run(path, queries_dir, instance_name, port, dry_run, no_backup).await
+        }
+        Commands::Backup { instance, output } => commands::backup::run(output, instance).await,
     };
 
     // Shutdown metrics sender