@ebowwa/pkg-ops 0.1.9

package/rust/src/lib.rs

@@ -0,0 +1,799 @@
+//! VPS Manager Core Library
+//!
+//! Package management operations for VPS.
+
+pub mod protocol;
+
+// Re-export protocol types for convenience
+pub use protocol::{ErrorObject, ErrorResponse, Request, Response, ResponseEnvelope};
+
+use serde::{Deserialize, Serialize};
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/// Package information
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PackageInfo {
+    pub name: String,
+    pub version: String,
+    pub installed: bool,
+    pub service: Option<String>,
+}
+
+/// Install result
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct InstallResult {
+    pub success: bool,
+    pub version: String,
+    pub previous_version: Option<String>,
+    pub message: String,
+}
+
+/// Rollback result
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RollbackResult {
+    pub success: bool,
+    pub previous_version: String,
+    pub current_version: String,
+    pub message: String,
+}
+
+/// Health check result
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct HealthCheckResult {
+    pub healthy: bool,
+    pub services: Vec<ServiceHealth>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ServiceHealth {
+    pub name: String,
+    pub status: String,
+    pub pid: u32,
+}
+
+/// Package verification result
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VerifyResult {
+    pub package_name: String,
+    pub version: String,
+    pub success: bool,
+    pub dist_exists: bool,
+    pub checksum: Option<String>,
+    pub message: String,
+}
+
+/// Security audit result
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AuditResult {
+    pub package_name: String,
+    pub severity: String, // "critical", "high", "moderate", "low"
+    pub vulnerability: String,
+    pub description: String,
+}
+
+/// Bundle size information
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BundleSize {
+    pub package_name: String,
+    pub version: String,
+    pub dist_size_bytes: u64,
+    pub file_count: u32,
+}
+
+/// Installed package information
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct InstalledPackageInfo {
+    pub package_name: String,
+    pub version: String,
+    pub dist_size_bytes: Option<u64>,
+    pub installed_at: Option<String>, // ISO timestamp
+}
+
+// ---------------------------------------------------------------------------
+// Package Operations
+// ---------------------------------------------------------------------------
+
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+use tracing::{debug, error, info};
+
+const WORK_DIR: &str = "/opt/vps-manager";
+const BACKUP_DIR: &str = "/opt/vps-manager/backups";
+
+/// Install a package using bun
+pub fn install_package(package_name: &str, version: &str) -> InstallResult {
+    info!("Installing {}@{}", package_name, version);
+
+    // Get previous version if installed
+    let previous_version = get_installed_version(package_name);
+
+    // Create backup if package already installed
+    if let Some(ref prev) = &previous_version {
+        create_backup(package_name, prev);
+        debug!("Created backup for {}@{}", package_name, prev);
+    }
+
+    // Ensure work directory exists
+    if let Err(e) = fs::create_dir_all(WORK_DIR) {
+        error!("Failed to create work directory: {}", e);
+        return InstallResult {
+            success: false,
+            version: version.to_string(),
+            previous_version,
+            message: format!("Failed to create work directory: {}", e),
+        };
+    }
+
+    // Run bun add
+    let package_spec = if version == "latest" {
+        package_name.to_string()
+    } else {
+        format!("{}@{}", package_name, version)
+    };
+
+    let output = match Command::new("bun")
+        .args(["add", &package_spec])
+        .current_dir(WORK_DIR)
+        .output()
+    {
+        Ok(o) => o,
+        Err(e) => {
+            error!("Failed to run bun add: {}", e);
+            return InstallResult {
+                success: false,
+                version: version.to_string(),
+                previous_version,
+                message: format!("Failed to run bun add: {}", e),
+            };
+        }
+    };
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        error!("bun add failed: {}", stderr);
+        return InstallResult {
+            success: false,
+            version: version.to_string(),
+            previous_version,
+            message: format!("bun add failed: {}", stderr),
+        };
+    }
+
+    // Get the actual installed version
+    let installed_version = get_installed_version(package_name)
+        .unwrap_or_else(|| version.to_string());
+
+    info!("Successfully installed {}@{}", package_name, installed_version);
+
+    InstallResult {
+        success: true,
+        version: installed_version,
+        previous_version,
+        message: format!("Installed {}@{}", package_name, version),
+    }
+}
+
+/// Update a package to latest version
+pub fn update_package(package_name: &str) -> InstallResult {
+    info!("Updating {} to latest", package_name);
+
+    let previous_version = get_installed_version(package_name);
+
+    // Just install latest version
+    let package_spec = package_name.to_string();
+
+    let output = match Command::new("bun")
+        .args(["add", &package_spec])
+        .current_dir(WORK_DIR)
+        .output()
+    {
+        Ok(o) => o,
+        Err(e) => {
+            error!("Failed to run bun add: {}", e);
+            return InstallResult {
+                success: false,
+                version: "unknown".to_string(),
+                previous_version,
+                message: format!("Failed to run bun add: {}", e),
+            };
+        }
+    };
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        error!("bun add failed: {}", stderr);
+        return InstallResult {
+            success: false,
+            version: "unknown".to_string(),
+            previous_version,
+            message: format!("bun add failed: {}", stderr),
+        };
+    }
+
+    let installed_version = get_installed_version(package_name)
+        .unwrap_or_else(|| "latest".to_string());
+
+    info!("Successfully updated {} to {}", package_name, installed_version);
+
+    InstallResult {
+        success: true,
+        version: installed_version.clone(),
+        previous_version,
+        message: format!("Updated {} to {}", package_name, installed_version),
+    }
+}
+
+/// Update all @ebowwa packages
+pub fn update_all_packages() -> Vec<InstallResult> {
+    let packages = list_packages();
+    packages
+        .iter()
+        .filter(|p| p.installed)
+        .map(|p| update_package(&p.name))
+        .collect()
+}
+
+/// List installed @ebowwa packages by scanning node_modules/@ebowwa/
+pub fn list_packages() -> Vec<PackageInfo> {
+    let ebowwa_dir = Path::new(WORK_DIR).join("node_modules").join("@ebowwa");
+    let mut packages = Vec::new();
+
+    if !ebowwa_dir.exists() || !ebowwa_dir.is_dir() {
+        debug!("No @ebowwa directory found at {:?}", ebowwa_dir);
+        return packages;
+    }
+
+    if let Ok(entries) = fs::read_dir(&ebowwa_dir) {
+        for entry in entries.flatten() {
+            let pkg_dir = entry.path();
+            if !pkg_dir.is_dir() {
+                continue;
+            }
+
+            let pkg_name = format!("@ebowwa/{}", entry.file_name().to_string_lossy());
+            let pkg_json_path = pkg_dir.join("package.json");
+
+            let version = if pkg_json_path.exists() {
+                if let Ok(content) = fs::read_to_string(&pkg_json_path) {
+                    if let Ok(pkg_json) = serde_json::from_str::<serde_json::Value>(&content) {
+                        pkg_json
+                            .get("version")
+                            .and_then(|v| v.as_str())
+                            .unwrap_or("unknown")
+                            .to_string()
+                    } else {
+                        "unknown".to_string()
+                    }
+                } else {
+                    "unknown".to_string()
+                }
+            } else {
+                "unknown".to_string()
+            };
+
+            packages.push(PackageInfo {
+                name: pkg_name,
+                version,
+                installed: true,
+                service: Some(entry.file_name().to_string_lossy().to_string()),
+            });
+        }
+    }
+
+    packages
+}
+
+/// Rollback a package to previous version
+pub fn rollback_package(package_name: &str) -> RollbackResult {
+    info!("Rolling back {}", package_name);
+
+    let current_version = match get_installed_version(package_name) {
+        Some(v) => v,
+        None => {
+            return RollbackResult {
+                success: false,
+                previous_version: "unknown".to_string(),
+                current_version: "unknown".to_string(),
+                message: "Package not installed".to_string(),
+            };
+        }
+    };
+
+    // Find backup
+    let backup_version = match find_backup(package_name) {
+        Some(v) => v,
+        None => {
+            return RollbackResult {
+                success: false,
+                previous_version: current_version.clone(),
+                current_version,
+                message: "No backup found".to_string(),
+            };
+        }
+    };
+
+    // Install the backup version
+    let package_spec = format!("{}@{}", package_name, backup_version);
+    let output = match Command::new("bun")
+        .args(["add", &package_spec])
+        .current_dir(WORK_DIR)
+        .output()
+    {
+        Ok(o) => o,
+        Err(e) => {
+            return RollbackResult {
+                success: false,
+                previous_version: current_version.clone(),
+                current_version,
+                message: format!("Failed to run bun add: {}", e),
+            };
+        }
+    };
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return RollbackResult {
+            success: false,
+            previous_version: current_version.clone(),
+            current_version,
+            message: format!("bun add failed: {}", stderr),
+        };
+    }
+
+    info!("Rolled back {} from {} to {}", package_name, current_version, backup_version);
+
+    RollbackResult {
+        success: true,
+        previous_version: current_version,
+        current_version: backup_version,
+        message: format!("Rolled back {}", package_name),
+    }
+}
+
+/// Check health of systemd services
+pub fn check_health() -> HealthCheckResult {
+    let packages = list_packages();
+    let mut services = Vec::new();
+
+    for pkg in packages {
+        if let Some(service_name) = &pkg.service {
+            let health = check_service_health(service_name);
+            services.push(health);
+        }
+    }
+
+    let all_healthy = services.iter().all(|s| s.status == "running");
+
+    HealthCheckResult {
+        healthy: all_healthy,
+        services,
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Private Helpers
+// ---------------------------------------------------------------------------
+
+fn get_installed_version(package_name: &str) -> Option<String> {
+    let package_json_path = Path::new(WORK_DIR).join("package.json");
+
+    if !package_json_path.exists() {
+        return None;
+    }
+
+    let content = fs::read_to_string(&package_json_path).ok()?;
+    let package_json: serde_json::Value = serde_json::from_str(&content).ok()?;
+
+    package_json
+        .get("dependencies")
+        .and_then(|d| d.get(package_name))
+        .and_then(|v| v.as_str())
+        .map(|s| s.trim_start_matches(|c| c == '^' || c == '~').to_string())
+}
+
+fn create_backup(package_name: &str, version: &str) {
+    let _ = fs::create_dir_all(BACKUP_DIR);
+
+    let backup_file = Path::new(BACKUP_DIR)
+        .join(format!("{}.json", package_name.replace("@", "").replace("/", "-")));
+
+    let backup_data = serde_json::json!({
+        "package": package_name,
+        "version": version,
+    });
+
+    let _ = fs::write(&backup_file, serde_json::to_string_pretty(&backup_data).unwrap());
+}
+
+fn find_backup(package_name: &str) -> Option<String> {
+    let backup_file = Path::new(BACKUP_DIR)
+        .join(format!("{}.json", package_name.replace("@", "").replace("/", "-")));
+
+    if !backup_file.exists() {
+        return None;
+    }
+
+    let content = fs::read_to_string(&backup_file).ok()?;
+    let backup: serde_json::Value = serde_json::from_str(&content).ok()?;
+
+    backup.get("version").and_then(|v| v.as_str()).map(|s| s.to_string())
+}
+
+fn check_service_health(service_name: &str) -> ServiceHealth {
+    let output = Command::new("systemctl")
+        .args(["show", service_name, "--property=ActiveState,SubState,MainPID"])
+        .output();
+
+    match output {
+        Ok(o) if o.status.success() => {
+            let stdout = String::from_utf8_lossy(&o.stdout);
+            let mut active_state = "unknown".to_string();
+            let mut sub_state = "unknown".to_string();
+            let mut pid: u32 = 0;
+
+            for line in stdout.lines() {
+                if line.starts_with("ActiveState=") {
+                    active_state = line.split('=').nth(1).unwrap_or("unknown").to_string();
+                } else if line.starts_with("SubState=") {
+                    sub_state = line.split('=').nth(1).unwrap_or("unknown").to_string();
+                } else if line.starts_with("MainPID=") {
+                    pid = line.split('=').nth(1).unwrap_or("0").parse().unwrap_or(0);
+                }
+            }
+
+            ServiceHealth {
+                name: service_name.to_string(),
+                status: format!("{}/{}", active_state, sub_state),
+                pid,
+            }
+        }
+        _ => ServiceHealth {
+            name: service_name.to_string(),
+            status: "unknown".to_string(),
+            pid: 0,
+        },
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Package Verification & Audit Operations
+// ---------------------------------------------------------------------------
+
+use sha2::{Digest, Sha256};
+
+/// Verify installed package integrity
+pub fn verify_package(package_name: &str) -> VerifyResult {
+    info!("Verifying package: {}", package_name);
+
+    // Check that package exists in node_modules
+    let package_path = Path::new(WORK_DIR)
+        .join("node_modules")
+        .join(package_name);
+
+    if !package_path.exists() {
+        return VerifyResult {
+            package_name: package_name.to_string(),
+            version: "unknown".to_string(),
+            success: false,
+            dist_exists: false,
+            checksum: None,
+            message: "Package not found in node_modules".to_string(),
+        };
+    }
+
+    // Read version from the package's own package.json
+    let pkg_json_path = package_path.join("package.json");
+    let version = if pkg_json_path.exists() {
+        if let Ok(content) = fs::read_to_string(&pkg_json_path) {
+            if let Ok(pkg_json) = serde_json::from_str::<serde_json::Value>(&content) {
+                pkg_json
+                    .get("version")
+                    .and_then(|v| v.as_str())
+                    .unwrap_or("unknown")
+                    .to_string()
+            } else {
+                "unknown".to_string()
+            }
+        } else {
+            "unknown".to_string()
+        }
+    } else {
+        "unknown".to_string()
+    };
+
+    // Check dist/ directory exists
+    let dist_path = package_path.join("dist");
+    let dist_exists = dist_path.exists() && dist_path.is_dir();
+
+    if !dist_exists {
+        return VerifyResult {
+            package_name: package_name.to_string(),
+            version,
+            success: false,
+            dist_exists: false,
+            checksum: None,
+            message: "dist/ directory not found".to_string(),
+        };
+    }
+
+    // Find main entry point (dist/index.js or from package.json)
+    let main_file = if let Ok(pkg_content) = fs::read_to_string(package_path.join("package.json")) {
+        if let Ok(pkg_json) = serde_json::from_str::<serde_json::Value>(&pkg_content) {
+            pkg_json
+                .get("main")
+                .and_then(|m| m.as_str())
+                .map(|m| package_path.join(m))
+                .unwrap_or_else(|| dist_path.join("index.js"))
+        } else {
+            dist_path.join("index.js")
+        }
+    } else {
+        dist_path.join("index.js")
+    };
+
+    // Calculate checksum of main entry point
+    let checksum = if main_file.exists() {
+        match fs::read(&main_file) {
+            Ok(content) => {
+                let mut hasher = Sha256::new();
+                hasher.update(&content);
+                Some(format!("{:x}", hasher.finalize()))
+            }
+            Err(e) => {
+                error!("Failed to read main file for checksum: {}", e);
+                None
+            }
+        }
+    } else {
+        None
+    };
+
+    let has_checksum = checksum.is_some();
+    let message = if has_checksum {
+        "Package verified successfully".to_string()
+    } else {
+        "Package exists but checksum could not be calculated".to_string()
+    };
+
+    VerifyResult {
+        package_name: package_name.to_string(),
+        version,
+        success: dist_exists && has_checksum,
+        dist_exists,
+        checksum,
+        message,
+    }
+}
+
+/// Check for vulnerabilities using bun audit or npm audit
+pub fn audit_packages() -> Vec<AuditResult> {
+    info!("Running security audit");
+
+    // Try bun audit first, fall back to npm audit
+    let output = match Command::new("bun")
+        .args(["audit", "--json"])
+        .current_dir(WORK_DIR)
+        .output()
+    {
+        Ok(o) if o.status.success() => Some(o),
+        _ => {
+            // Fallback to npm audit
+            Command::new("npm")
+                .args(["audit", "--json"])
+                .current_dir(WORK_DIR)
+                .output()
+                .ok()
+        }
+    };
+
+    let output = match output {
+        Some(o) => o,
+        None => {
+            error!("Failed to run audit command");
+            return vec![];
+        }
+    };
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    parse_audit_output(&stdout)
+}
+
+fn parse_audit_output(output: &str) -> Vec<AuditResult> {
+    let mut results = Vec::new();
+
+    let audit_json: serde_json::Value = match serde_json::from_str(output) {
+        Ok(v) => v,
+        Err(e) => {
+            error!("Failed to parse audit output: {}", e);
+            return results;
+        }
+    };
+
+    // npm audit --json format
+    if let Some(advisories) = audit_json.get("advisories").and_then(|a| a.as_object()) {
+        for (_, advisory) in advisories {
+            let result = AuditResult {
+                package_name: advisory["module_name"]
+                    .as_str()
+                    .unwrap_or("unknown")
+                    .to_string(),
+                severity: advisory["severity"]
+                    .as_str()
+                    .unwrap_or("unknown")
+                    .to_lowercase(),
+                vulnerability: advisory["title"]
+                    .as_str()
+                    .unwrap_or("unknown")
+                    .to_string(),
+                description: advisory["url"]
+                    .as_str()
+                    .unwrap_or("No description available")
+                    .to_string(),
+            };
+            results.push(result);
+        }
+    }
+
+    // bun audit format (may differ)
+    if let Some(vulnerabilities) = audit_json.get("vulnerabilities").and_then(|v| v.as_array()) {
+        for vuln in vulnerabilities {
+            let result = AuditResult {
+                package_name: vuln["name"]
+                    .as_str()
+                    .unwrap_or("unknown")
+                    .to_string(),
+                severity: vuln["severity"]
+                    .as_str()
+                    .unwrap_or("unknown")
+                    .to_lowercase(),
+                vulnerability: vuln["title"]
+                    .as_str()
+                    .unwrap_or("unknown")
+                    .to_string(),
+                description: vuln["url"]
+                    .as_str()
+                    .unwrap_or("No description available")
+                    .to_string(),
+            };
+            results.push(result);
+        }
+    }
+
+    results
+}
+
+/// Get dist/ sizes for all installed @ebowwa packages
+pub fn get_bundle_sizes() -> Vec<BundleSize> {
+    info!("Getting bundle sizes for @ebowwa packages");
+
+    let packages = list_packages();
+    let mut sizes = Vec::new();
+
+    for pkg in packages {
+        if !pkg.installed {
+            continue;
+        }
+
+        let package_path = Path::new(WORK_DIR)
+            .join("node_modules")
+            .join(&pkg.name);
+
+        // Check dist/ first, fall back to src/ for source-only packages
+        let dist_path = package_path.join("dist");
+        let src_path = package_path.join("src");
+
+        let (size_bytes, file_count) = if dist_path.exists() {
+            calculate_dir_size(&dist_path)
+        } else if src_path.exists() {
+            // Source-only package (no bundled dist/)
+            calculate_dir_size(&src_path)
+        } else {
+                // Check for .ts files in root (some packages have .ts directly)
+            let mut has_ts = false;
+            if let Ok(entries) = fs::read_dir(&package_path) {
+                for entry in entries.flatten() {
+                    let name = entry.file_name();
+                    let name_str = name.to_string_lossy();
+                    if name_str.ends_with(".ts") && !name_str.contains("target") {
+                        has_ts = true;
+                        break;
+                    }
+                }
+            }
+            if has_ts {
+                calculate_dir_size(&package_path)
+            } else {
+                (0, 0)
+            }
+        };
+
+        sizes.push(BundleSize {
+            package_name: pkg.name.clone(),
+            version: pkg.version.clone(),
+            dist_size_bytes: size_bytes,
+            file_count: file_count,
+        });
+    }
+
+    sizes
+}
+
+fn calculate_dir_size(path: &Path) -> (u64, u32) {
+    let mut total_size = 0u64;
+    let mut file_count = 0u32;
+
+    if let Ok(entries) = fs::read_dir(path) {
+        for entry in entries.flatten() {
+            let entry_path = entry.path();
+            if entry_path.is_dir() {
+                let (sub_size, sub_count) = calculate_dir_size(&entry_path);
+                total_size += sub_size;
+                file_count += sub_count;
+            } else if entry_path.is_file() {
+                if let Ok(metadata) = entry.metadata() {
+                    total_size += metadata.len();
+                    file_count += 1;
+                }
+            }
+        }
+    }
+
+    (total_size, file_count)
+}
+
+/// Get installed package information with dist sizes and timestamps
+pub fn get_installed_info() -> Vec<InstalledPackageInfo> {
+    info!("Getting installed package info");
+
+    let packages = list_packages();
+    let mut info_list = Vec::new();
+
+    for pkg in packages {
+        if !pkg.installed {
+            continue;
+        }
+
+        let package_path = Path::new(WORK_DIR)
+            .join("node_modules")
+            .join(&pkg.name);
+
+        let dist_path = package_path.join("dist");
+        let dist_size = if dist_path.exists() {
+            let (size, _) = calculate_dir_size(&dist_path);
+            Some(size)
+        } else {
+            None
+        };
+
+        // Try to get install timestamp from package.json mtime
+        let pkg_json_path = package_path.join("package.json");
+        let installed_at = if pkg_json_path.exists() {
+            fs::metadata(&pkg_json_path)
+                .ok()
+                .and_then(|m| m.modified().ok())
+                .map(|t| {
+                    let datetime: chrono::DateTime<chrono::Utc> = t.into();
+                    datetime.to_rfc3339()
+                })
+        } else {
+            None
+        };
+
+        info_list.push(InstalledPackageInfo {
+            package_name: pkg.name.clone(),
+            version: pkg.version.clone(),
+            dist_size_bytes: dist_size,
+            installed_at,
+        });
+    }
+
+    info_list
+}