@ebowwa/pkg-ops 0.1.18 → 0.1.20

package/rust/src/lib.rs

@@ -94,6 +94,52 @@ pub struct InstalledPackageInfo {
     pub version: String,
     pub dist_size_bytes: Option<u64>,
     pub installed_at: Option<String>, // ISO timestamp
+    pub total_versions: Option<u32>,
+    pub versions: Option<Vec<VersionInfo>>,
+}
+
+/// Version information for multi-version support
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VersionInfo {
+    pub version: String,
+    pub installed_at: String,
+    pub dist_size_bytes: Option<u64>,
+    pub file_count: Option<u32>,
+    pub active: bool,
+}
+
+/// Result of switching versions
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SwitchResult {
+    pub success: bool,
+    pub package_name: String,
+    pub from_version: String,
+    pub to_version: String,
+    pub message: String,
+}
+
+/// Result of pruning old versions
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PruneResult {
+    pub success: bool,
+    pub package_name: String,
+    pub removed_versions: Vec<String>,
+    pub kept_versions: Vec<String>,
+    pub freed_bytes: u64,
+    pub message: String,
+}
+
+/// Multi-version package summary
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MultiVersionPackage {
+    pub package_name: String,
+    pub active_version: String,
+    pub total_versions: u32,
+    pub versions: Vec<String>,
 }
 
 // ---------------------------------------------------------------------------
@@ -797,3 +843,395 @@ pub fn get_installed_info() -> Vec<InstalledPackageInfo> {
 
     info_list
 }
+
+// ---------------------------------------------------------------------------
+// Multi-Version Operations
+// ---------------------------------------------------------------------------
+
+/// Directory for storing multiple package versions
+const VERSIONS_DIR: &str = "/opt/pkg-ops/versions";
+
+/// List all installed versions of a package
+pub fn list_versions(package_name: &str) -> Vec<VersionInfo> {
+    info!("Listing versions for {}", package_name);
+
+    let mut versions = Vec::new();
+
+    // Check the multi-version directory
+    let package_versions_dir = Path::new(VERSIONS_DIR)
+        .join(package_name.replace("@", "").replace("/", "-"));
+
+    if package_versions_dir.exists() {
+        if let Ok(entries) = fs::read_dir(&package_versions_dir) {
+            for entry in entries.flatten() {
+                let version_dir = entry.path();
+                if !version_dir.is_dir() {
+                    continue;
+                }
+
+                let version = entry.file_name().to_string_lossy().to_string();
+                let dist_path = version_dir.join("dist");
+
+                // Get installed timestamp from directory mtime
+                let installed_at = fs::metadata(&version_dir)
+                    .ok()
+                    .and_then(|m| m.modified().ok())
+                    .map(|t| {
+                        let datetime: chrono::DateTime<chrono::Utc> = t.into();
+                        datetime.to_rfc3339()
+                    })
+                    .unwrap_or_else(|| "unknown".to_string());
+
+                let (dist_size, file_count) = if dist_path.exists() {
+                    let (size, count) = calculate_dir_size(&dist_path);
+                    (Some(size), Some(count))
+                } else {
+                    (None, None)
+                };
+
+                versions.push(VersionInfo {
+                    version,
+                    installed_at,
+                    dist_size_bytes: dist_size,
+                    file_count,
+                    active: false, // Will be set below
+                });
+            }
+        }
+    }
+
+    // Also check the active version in node_modules
+    let active_version = get_installed_version(package_name);
+    if let Some(ref active) = active_version {
+        // Mark active version
+        for v in &mut versions {
+            if &v.version == active {
+                v.active = true;
+            }
+        }
+
+        // If active version not in versions list, add it
+        if !versions.iter().any(|v| &v.version == active) {
+            let package_path = Path::new(WORK_DIR)
+                .join("node_modules")
+                .join(package_name);
+
+            let dist_path = package_path.join("dist");
+            let (dist_size, file_count) = if dist_path.exists() {
+                let (size, count) = calculate_dir_size(&dist_path);
+                (Some(size), Some(count))
+            } else {
+                (None, None)
+            };
+
+            let installed_at = package_path.join("package.json")
+                .exists()
+                .then(|| {
+                    fs::metadata(package_path.join("package.json"))
+                        .ok()
+                        .and_then(|m| m.modified().ok())
+                        .map(|t| {
+                            let datetime: chrono::DateTime<chrono::Utc> = t.into();
+                            datetime.to_rfc3339()
+                        })
+                })
+                .flatten()
+                .unwrap_or_else(|| "unknown".to_string());
+
+            versions.push(VersionInfo {
+                version: active.clone(),
+                installed_at,
+                dist_size_bytes: dist_size,
+                file_count,
+                active: true,
+            });
+        }
+    }
+
+    // Sort by version descending (newest first)
+    versions.sort_by(|a, b| {
+        // Simple semver comparison
+        let a_parts: Vec<u32> = a.version
+            .split('.')
+            .filter_map(|s| s.parse().ok())
+            .collect();
+        let b_parts: Vec<u32> = b.version
+            .split('.')
+            .filter_map(|s| s.parse().ok())
+            .collect();
+
+        for i in 0..std::cmp::min(a_parts.len(), b_parts.len()) {
+            match b_parts.get(i).cmp(&a_parts.get(i)) {
+                std::cmp::Ordering::Equal => continue,
+                other => return other,
+            }
+        }
+        b_parts.len().cmp(&a_parts.len())
+    });
+
+    versions
+}
+
+/// Switch to a specific installed version
+pub fn switch_version(package_name: &str, target_version: &str) -> SwitchResult {
+    info!("Switching {} to version {}", package_name, target_version);
+
+    let current_version = match get_installed_version(package_name) {
+        Some(v) => v,
+        None => {
+            return SwitchResult {
+                success: false,
+                package_name: package_name.to_string(),
+                from_version: "none".to_string(),
+                to_version: target_version.to_string(),
+                message: "Package not installed".to_string(),
+            };
+        }
+    };
+
+    if current_version == target_version {
+        return SwitchResult {
+            success: true,
+            package_name: package_name.to_string(),
+            from_version: current_version.clone(),
+            to_version: target_version.to_string(),
+            message: "Already on target version".to_string(),
+        };
+    }
+
+    // Check if target version exists in versions directory
+    let version_dir = Path::new(VERSIONS_DIR)
+        .join(package_name.replace("@", "").replace("/", "-"))
+        .join(target_version);
+
+    if !version_dir.exists() {
+        // Try installing from npm
+        let package_spec = format!("{}@{}", package_name, target_version);
+        let output = match Command::new("bun")
+            .args(["add", &package_spec])
+            .current_dir(WORK_DIR)
+            .output()
+        {
+            Ok(o) => o,
+            Err(e) => {
+                return SwitchResult {
+                    success: false,
+                    package_name: package_name.to_string(),
+                    from_version: current_version,
+                    to_version: target_version.to_string(),
+                    message: format!("Failed to run bun add: {}", e),
+                };
+            }
+        };
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            return SwitchResult {
+                success: false,
+                package_name: package_name.to_string(),
+                from_version: current_version,
+                to_version: target_version.to_string(),
+                message: format!("Version {} not found locally or on npm: {}", target_version, stderr),
+            };
+        }
+
+        return SwitchResult {
+            success: true,
+            package_name: package_name.to_string(),
+            from_version: current_version,
+            to_version: target_version.to_string(),
+            message: format!("Installed and switched to {}", target_version),
+        };
+    }
+
+    // Backup current version to versions directory
+    let current_version_dir = Path::new(VERSIONS_DIR)
+        .join(package_name.replace("@", "").replace("/", "-"))
+        .join(&current_version);
+
+    let current_package_path = Path::new(WORK_DIR)
+        .join("node_modules")
+        .join(package_name);
+
+    if current_package_path.exists() {
+        // Create versions directory if needed
+        let _ = fs::create_dir_all(current_version_dir.parent().unwrap());
+
+        // Copy current version to versions dir (if not already there)
+        if !current_version_dir.exists() {
+            if let Err(e) = copy_dir_all(&current_package_path, &current_version_dir) {
+                error!("Failed to backup current version: {}", e);
+            }
+        }
+    }
+
+    // Remove current version from node_modules
+    if let Err(e) = fs::remove_dir_all(&current_package_path) {
+        error!("Failed to remove current version: {}", e);
+    }
+
+    // Copy target version to node_modules
+    if let Err(e) = copy_dir_all(&version_dir, &current_package_path) {
+        return SwitchResult {
+            success: false,
+            package_name: package_name.to_string(),
+            from_version: current_version,
+            to_version: target_version.to_string(),
+            message: format!("Failed to copy target version: {}", e),
+        };
+    }
+
+    info!("Switched {} from {} to {}", package_name, current_version, target_version);
+
+    SwitchResult {
+        success: true,
+        package_name: package_name.to_string(),
+        from_version: current_version,
+        to_version: target_version.to_string(),
+        message: format!("Switched from {} to {}", current_version, target_version),
+    }
+}
+
+/// Prune old versions, keeping only N most recent
+pub fn prune_versions(package_name: &str, keep_count: u32) -> PruneResult {
+    info!("Pruning {} versions, keeping {}", package_name, keep_count);
+
+    let versions = list_versions(package_name);
+
+    if versions.len() <= keep_count as usize {
+        return PruneResult {
+            success: true,
+            package_name: package_name.to_string(),
+            removed_versions: vec![],
+            kept_versions: versions.iter().map(|v| v.version.clone()).collect(),
+            freed_bytes: 0,
+            message: format!("Only {} versions installed, nothing to prune", versions.len()),
+        };
+    }
+
+    let package_versions_dir = Path::new(VERSIONS_DIR)
+        .join(package_name.replace("@", "").replace("/", "-"));
+
+    // Sort by installed date (newest first) and keep top N
+    let mut sorted_versions: Vec<_> = versions.into_iter().collect();
+    sorted_versions.sort_by(|a, b| b.installed_at.cmp(&a.installed_at));
+
+    let kept: Vec<_> = sorted_versions.iter()
+        .take(keep_count as usize)
+        .map(|v| v.version.clone())
+        .collect();
+
+    let mut removed = Vec::new();
+    let mut freed_bytes = 0u64;
+
+    for version_info in sorted_versions.iter().skip(keep_count as usize) {
+        // Don't remove active version
+        if version_info.active {
+            continue;
+        }
+
+        let version_dir = package_versions_dir.join(&version_info.version);
+        if version_dir.exists() {
+            // Calculate size before removing
+            let (size, _) = calculate_dir_size(&version_dir);
+            freed_bytes += size;
+
+            if let Err(e) = fs::remove_dir_all(&version_dir) {
+                error!("Failed to remove version {}: {}", version_info.version, e);
+            } else {
+                removed.push(version_info.version.clone());
+            }
+        }
+    }
+
+    PruneResult {
+        success: true,
+        package_name: package_name.to_string(),
+        removed_versions: removed.clone(),
+        kept_versions: kept,
+        freed_bytes,
+        message: if removed.is_empty() {
+            "No versions to remove".to_string()
+        } else {
+            format!("Removed {} version(s), freed {} bytes", removed.len(), freed_bytes)
+        },
+    }
+}
+
+/// Remove a specific version
+pub fn remove_version(package_name: &str, version: &str) -> Result<String, String> {
+    info!("Removing {}@{}", package_name, version);
+
+    // Check if this is the active version
+    let active_version = get_installed_version(package_name);
+    if active_version.as_deref() == Some(version) {
+        return Err("Cannot remove active version. Switch to another version first.".to_string());
+    }
+
+    let version_dir = Path::new(VERSIONS_DIR)
+        .join(package_name.replace("@", "").replace("/", "-"))
+        .join(version);
+
+    if !version_dir.exists() {
+        return Err(format!("Version {} not found", version));
+    }
+
+    let (size, _) = calculate_dir_size(&version_dir);
+
+    if let Err(e) = fs::remove_dir_all(&version_dir) {
+        return Err(format!("Failed to remove version: {}", e));
+    }
+
+    Ok(format!("Removed {}@{} (freed {} bytes)", package_name, version, size))
+}
+
+/// Get packages with multiple versions installed
+pub fn get_multi_version_packages() -> Vec<MultiVersionPackage> {
+    info!("Getting packages with multiple versions");
+
+    let packages = list_packages();
+    let mut result = Vec::new();
+
+    for pkg in packages {
+        if !pkg.installed {
+            continue;
+        }
+
+        let versions = list_versions(&pkg.name);
+        if versions.len() > 1 {
+            let active_version = versions.iter()
+                .find(|v| v.active)
+                .map(|v| v.version.clone())
+                .unwrap_or_else(|| pkg.version.clone());
+
+            result.push(MultiVersionPackage {
+                package_name: pkg.name.clone(),
+                active_version,
+                total_versions: versions.len() as u32,
+                versions: versions.iter().map(|v| v.version.clone()).collect(),
+            });
+        }
+    }
+
+    result
+}
+
+/// Helper to recursively copy a directory
+fn copy_dir_all(src: &Path, dst: &Path) -> std::io::Result<()> {
+    fs::create_dir_all(dst)?;
+
+    for entry in fs::read_dir(src)? {
+        let entry = entry?;
+        let ty = entry.file_type()?;
+        let src_path = entry.path();
+        let dst_path = dst.join(entry.file_name());
+
+        if ty.is_dir() {
+            copy_dir_all(&src_path, &dst_path)?;
+        } else {
+            fs::copy(&src_path, &dst_path)?;
+        }
+    }
+
+    Ok(())
+}

package/rust/src/main.rs

@@ -227,6 +227,183 @@ fn handle_installed_info(req: Request) -> ResponseEnvelope {
     }
 }
 
+// ---------------------------------------------------------------------------
+// Multi-Version Handlers
+// ---------------------------------------------------------------------------
+
+fn handle_list_versions(req: Request) -> ResponseEnvelope {
+    let params = match req.params.as_ref() {
+        Some(p) => p,
+        None => {
+            return ResponseEnvelope::Error(ErrorResponse::new(
+                req.id,
+                ErrorObject::invalid_params("Missing params"),
+            ));
+        }
+    };
+
+    let package_name = match params["packageName"].as_str() {
+        Some(n) => n,
+        None => {
+            return ResponseEnvelope::Error(ErrorResponse::new(
+                req.id,
+                ErrorObject::invalid_params("Missing packageName"),
+            ));
+        }
+    };
+
+    let versions = list_versions(package_name);
+
+    match Response::new(req.id.clone(), &versions) {
+        Ok(r) => ResponseEnvelope::Success(r),
+        Err(e) => ResponseEnvelope::Error(ErrorResponse::new(
+            req.id,
+            ErrorObject::internal_error(e.to_string()),
+        )),
+    }
+}
+
+fn handle_switch_version(req: Request) -> ResponseEnvelope {
+    let params = match req.params.as_ref() {
+        Some(p) => p,
+        None => {
+            return ResponseEnvelope::Error(ErrorResponse::new(
+                req.id,
+                ErrorObject::invalid_params("Missing params"),
+            ));
+        }
+    };
+
+    let package_name = match params["packageName"].as_str() {
+        Some(n) => n,
+        None => {
+            return ResponseEnvelope::Error(ErrorResponse::new(
+                req.id,
+                ErrorObject::invalid_params("Missing packageName"),
+            ));
+        }
+    };
+
+    let version = match params["version"].as_str() {
+        Some(v) => v,
+        None => {
+            return ResponseEnvelope::Error(ErrorResponse::new(
+                req.id,
+                ErrorObject::invalid_params("Missing version"),
+            ));
+        }
+    };
+
+    let result = switch_version(package_name, version);
+
+    match Response::new(req.id.clone(), &result) {
+        Ok(r) => ResponseEnvelope::Success(r),
+        Err(e) => ResponseEnvelope::Error(ErrorResponse::new(
+            req.id,
+            ErrorObject::internal_error(e.to_string()),
+        )),
+    }
+}
+
+fn handle_prune_versions(req: Request) -> ResponseEnvelope {
+    let params = match req.params.as_ref() {
+        Some(p) => p,
+        None => {
+            return ResponseEnvelope::Error(ErrorResponse::new(
+                req.id,
+                ErrorObject::invalid_params("Missing params"),
+            ));
+        }
+    };
+
+    let package_name = match params["packageName"].as_str() {
+        Some(n) => n,
+        None => {
+            return ResponseEnvelope::Error(ErrorResponse::new(
+                req.id,
+                ErrorObject::invalid_params("Missing packageName"),
+            ));
+        }
+    };
+
+    let keep_count = params["keepCount"].as_u64().unwrap_or(2) as u32;
+
+    let result = prune_versions(package_name, keep_count);
+
+    match Response::new(req.id.clone(), &result) {
+        Ok(r) => ResponseEnvelope::Success(r),
+        Err(e) => ResponseEnvelope::Error(ErrorResponse::new(
+            req.id,
+            ErrorObject::internal_error(e.to_string()),
+        )),
+    }
+}
+
+fn handle_remove_version(req: Request) -> ResponseEnvelope {
+    let params = match req.params.as_ref() {
+        Some(p) => p,
+        None => {
+            return ResponseEnvelope::Error(ErrorResponse::new(
+                req.id,
+                ErrorObject::invalid_params("Missing params"),
+            ));
+        }
+    };
+
+    let package_name = match params["packageName"].as_str() {
+        Some(n) => n,
+        None => {
+            return ResponseEnvelope::Error(ErrorResponse::new(
+                req.id,
+                ErrorObject::invalid_params("Missing packageName"),
+            ));
+        }
+    };
+
+    let version = match params["version"].as_str() {
+        Some(v) => v,
+        None => {
+            return ResponseEnvelope::Error(ErrorResponse::new(
+                req.id,
+                ErrorObject::invalid_params("Missing version"),
+            ));
+        }
+    };
+
+    let result = remove_version(package_name, version);
+
+    let response = match result {
+        Ok(msg) => serde_json::json!({
+            "success": true,
+            "message": msg
+        }),
+        Err(msg) => serde_json::json!({
+            "success": false,
+            "message": msg
+        }),
+    };
+
+    match Response::new(req.id.clone(), &response) {
+        Ok(r) => ResponseEnvelope::Success(r),
+        Err(e) => ResponseEnvelope::Error(ErrorResponse::new(
+            req.id,
+            ErrorObject::internal_error(e.to_string()),
+        )),
+    }
+}
+
+fn handle_get_multi_version_packages(req: Request) -> ResponseEnvelope {
+    let packages = get_multi_version_packages();
+
+    match Response::new(req.id.clone(), &packages) {
+        Ok(r) => ResponseEnvelope::Success(r),
+        Err(e) => ResponseEnvelope::Error(ErrorResponse::new(
+            req.id,
+            ErrorObject::internal_error(e.to_string()),
+        )),
+    }
+}
+
 // ---------------------------------------------------------------------------
 // Router
 // ---------------------------------------------------------------------------
@@ -247,6 +424,12 @@ fn route_request(request: Request) -> (ResponseEnvelope, bool) {
         "scan" => handle_audit(request), // alias for audit
         "sizes" => handle_sizes(request),
         "installedInfo" => handle_installed_info(request),
+        // Multi-version methods
+        "listVersions" => handle_list_versions(request),
+        "switchVersion" => handle_switch_version(request),
+        "pruneVersions" => handle_prune_versions(request),
+        "removeVersion" => handle_remove_version(request),
+        "getMultiVersionPackages" => handle_get_multi_version_packages(request),
         method => ResponseEnvelope::Error(ErrorResponse::new(
             request.id,
             ErrorObject::method_not_found(method),

package/src/index.ts

@@ -1109,8 +1109,10 @@ async function main(): Promise<void> {
   await command.handler(commandArgs);
 }
 
-// Run CLI only when executed directly (not when imported)
-if (import.meta.main) {
+// Run CLI only when executed directly via bin (not when imported as library)
+// This check works after bundling where import.meta.main gets transformed
+const isCliInvocation = process.argv[1]?.includes("pkg-ops");
+if (isCliInvocation) {
   main().catch((error) => {
     console.error("Fatal error:", error);
     process.exit(1);