add initial support for replaces

Author: rmitchellscott

src/apk/compat.rs

@@ -56,6 +56,7 @@ mod tests {
             name: name.to_string(),
             version: version.to_string(),
             depends: depends.into_iter().map(|s| s.to_string()).collect(),
+            replaces: Vec::new(),
         }
     }
 

src/apk/exec.rs

@@ -128,4 +128,14 @@ impl Apk {
     pub fn cache_purge(&self) -> Result<()> {
         self.run_silent(&["cache", "purge"])
     }
+
+    pub fn fetch(&self, packages: &[&str]) -> Result<()> {
+        let mut args = vec!["fetch", "--cache"];
+        args.extend(packages);
+        self.run_silent(&args)
+    }
+
+    pub fn cache_dir(&self) -> PathBuf {
+        self.root.join("etc").join("apk").join("cache")
+    }
 }

src/apk/index.rs

@@ -12,6 +12,7 @@ pub struct Package {
     pub name: String,
     pub version: String,
     pub depends: Vec<String>,
+    pub replaces: Vec<String>,
 }
 
 impl Package {
@@ -88,6 +89,55 @@ pub fn find_best_compatible_version<'a>(
     compatible.first().copied()
 }
 
+pub fn parse_apk_file(path: &str) -> Result<Package> {
+    let f = File::open(path)?;
+    let mut data = Vec::new();
+    BufReader::new(f).read_to_end(&mut data)?;
+
+    let gz = MultiGzDecoder::new(Cursor::new(data));
+    let mut archive = Archive::new(gz);
+
+    for entry in archive.entries()? {
+        let mut entry = entry?;
+        let entry_path = entry.path()?;
+
+        if entry_path.to_string_lossy() == ".PKGINFO" {
+            let mut content = String::new();
+            entry.read_to_string(&mut content)?;
+            return parse_pkginfo(&content);
+        }
+    }
+
+    Err(anyhow!(".PKGINFO not found in package"))
+}
+
+fn parse_pkginfo(content: &str) -> Result<Package> {
+    let mut pkg = Package::default();
+
+    for line in content.lines() {
+        let line = line.trim();
+        if line.is_empty() || line.starts_with('#') {
+            continue;
+        }
+
+        if let Some((key, val)) = line.split_once(" = ") {
+            match key {
+                "pkgname" => pkg.name = val.to_string(),
+                "pkgver" => pkg.version = val.to_string(),
+                "depend" => pkg.depends.push(val.to_string()),
+                "replaces" => pkg.replaces.push(val.to_string()),
+                _ => {}
+            }
+        }
+    }
+
+    if pkg.name.is_empty() {
+        return Err(anyhow!("pkgname not found in .PKGINFO"));
+    }
+
+    Ok(pkg)
+}
+
 fn parse_index_from_tar_gz<R: Read>(reader: R) -> Result<Vec<Package>> {
     let mut data = Vec::new();
     let mut reader = reader;
@@ -140,6 +190,7 @@ fn parse_apkindex<R: BufRead>(reader: R) -> Result<Vec<Package>> {
             b'P' => current.name = val.to_string(),
             b'V' => current.version = val.to_string(),
             b'D' => current.depends = val.split_whitespace().map(|s| s.to_string()).collect(),
+            b'r' => current.replaces = val.split_whitespace().map(|s| s.to_string()).collect(),
             _ => {}
         }
     }
@@ -161,6 +212,7 @@ mod tests {
             name: name.to_string(),
             version: version.to_string(),
             depends: depends.into_iter().map(|s| s.to_string()).collect(),
+            replaces: Vec::new(),
         }
     }
 
@@ -328,4 +380,25 @@ mod tests {
         assert_eq!(packages[0].version, "1.0.0");
         assert!(packages[0].depends.is_empty());
     }
+
+    #[test]
+    fn parse_apkindex_replaces_field() {
+        let input = "P:new-pkg\nV:1.0.0\nr:old-pkg-a old-pkg-b\n";
+        let reader = BufReader::new(input.as_bytes());
+        let packages = parse_apkindex(reader).unwrap();
+
+        assert_eq!(packages.len(), 1);
+        assert_eq!(packages[0].name, "new-pkg");
+        assert_eq!(packages[0].replaces, vec!["old-pkg-a", "old-pkg-b"]);
+    }
+
+    #[test]
+    fn parse_apkindex_replaces_empty() {
+        let input = "P:test-pkg\nV:1.0.0\n";
+        let reader = BufReader::new(input.as_bytes());
+        let packages = parse_apkindex(reader).unwrap();
+
+        assert_eq!(packages.len(), 1);
+        assert!(packages[0].replaces.is_empty());
+    }
 }

src/apk/mod.rs

@@ -6,6 +6,6 @@ mod version;
 
 pub use compat::check_os_compatibility;
 pub use exec::Apk;
-pub use index::{fetch_remote_index, find_best_compatible_version, parse_index_tar_gz, Package};
+pub use index::{fetch_remote_index, find_best_compatible_version, parse_apk_file, parse_index_tar_gz, Package};
 pub use package::{generate_device_package, generate_remarkable_os_package};
 pub use version::version_lt;

src/commands/add.rs

@@ -1,7 +1,10 @@
 use std::fs;
 use std::process;
 
-use crate::apk::{fetch_remote_index, find_best_compatible_version, parse_index_tar_gz, Apk, Package};
+use crate::apk::{
+    fetch_remote_index, find_best_compatible_version, parse_apk_file, parse_index_tar_gz, Apk,
+    Package,
+};
 use crate::constants::VELLUM_ROOT;
 use crate::device::get_apk_arch;
 
@@ -22,6 +25,7 @@ pub fn handle_add(apk: &Apk, args: &[String]) {
 
     let mut resolved_args: Vec<String> = Vec::new();
     let mut resolved_packages: Vec<String> = Vec::new();
+    let mut local_apk_packages: Vec<Package> = Vec::new();
     let mut has_incompatible = false;
 
     for arg in args {
@@ -30,6 +34,14 @@ pub fn handle_add(apk: &Apk, args: &[String]) {
             continue;
         }
 
+        if arg.ends_with(".apk") {
+            resolved_args.push(arg.clone());
+            if let Ok(pkg) = parse_apk_file(arg) {
+                local_apk_packages.push(pkg);
+            }
+            continue;
+        }
+
         match find_best_compatible_version(arg, &os_version, &index) {
             Some(pkg) => {
                 resolved_args.push(format!("{}={}", pkg.name, pkg.version));
@@ -51,6 +63,34 @@ pub fn handle_add(apk: &Apk, args: &[String]) {
         process::exit(1);
     }
 
+    let fetch_args: Vec<&str> = resolved_args
+        .iter()
+        .filter(|a| !a.starts_with('-') && !a.ends_with(".apk"))
+        .map(|s| s.as_str())
+        .collect();
+    if !fetch_args.is_empty() {
+        let _ = apk.fetch(&fetch_args);
+    }
+
+    let cached_packages = find_cached_apk_packages(apk, &resolved_args);
+    let mut packages_to_replace = find_packages_to_replace(apk, &cached_packages);
+    packages_to_replace.extend(find_packages_to_replace(apk, &local_apk_packages));
+    if !packages_to_replace.is_empty() {
+        println!("The following packages will be replaced:");
+        for pkg in &packages_to_replace {
+            println!("  - {pkg}");
+        }
+        println!();
+
+        let del_args: Vec<&str> = packages_to_replace.iter().map(|s| s.as_str()).collect();
+        let mut del_cmd = vec!["del"];
+        del_cmd.extend(del_args);
+        if let Err(e) = apk.run(&del_cmd) {
+            eprintln!("Failed to remove replaced packages: {e}");
+            process::exit(1);
+        }
+    }
+
     let mut cmd_args = vec!["add", "--cache-predownload"];
     cmd_args.extend(resolved_args.iter().map(|s| s.as_str()));
 
@@ -148,3 +188,70 @@ fn clean_world_file_pins(packages: &[String]) {
 
     let _ = fs::write(&world_path, new_content + "\n");
 }
+
+fn find_packages_to_replace(apk: &Apk, cached_packages: &[Package]) -> Vec<String> {
+    let installed = match apk.list_installed() {
+        Ok(list) => list,
+        Err(_) => return Vec::new(),
+    };
+
+    let mut to_replace = Vec::new();
+
+    for pkg in cached_packages {
+        for replaced in &pkg.replaces {
+            if installed.contains(replaced) && !to_replace.contains(replaced) {
+                to_replace.push(replaced.clone());
+            }
+        }
+    }
+
+    to_replace
+}
+
+fn find_cached_apk_packages(apk: &Apk, package_specs: &[String]) -> Vec<Package> {
+    let cache_dir = apk.cache_dir();
+    let entries = match fs::read_dir(&cache_dir) {
+        Ok(e) => e,
+        Err(_) => return Vec::new(),
+    };
+
+    let apk_files: Vec<_> = entries
+        .flatten()
+        .filter_map(|entry| {
+            let path = entry.path();
+            let name = path.file_name()?.to_str()?;
+            if name.ends_with(".apk") {
+                Some(path)
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    let mut packages = Vec::new();
+
+    for spec in package_specs {
+        let pkg_name = spec.split('=').next().unwrap_or(spec);
+
+        for apk_path in &apk_files {
+            let file_name = match apk_path.file_name().and_then(|n| n.to_str()) {
+                Some(n) => n,
+                None => continue,
+            };
+
+            if file_name.starts_with(&format!("{pkg_name}-")) {
+                if let Some(path_str) = apk_path.to_str() {
+                    if let Ok(pkg) = parse_apk_file(path_str) {
+                        if pkg.name == pkg_name {
+                            packages.push(pkg);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    packages
+}
+