update manifest

Author: QaidVoid

sbuild-meta/src/main.rs

@@ -60,6 +60,10 @@ enum Commands {
         /// GitHub token for registry access
         #[arg(long, env = "GITHUB_TOKEN")]
         github_token: Option<String>,
+
+        /// GHCR owner/organization (default: pkgforge)
+        #[arg(long, default_value = "pkgforge")]
+        ghcr_owner: String,
     },
 
     /// Check if a recipe should be rebuilt
@@ -164,8 +168,9 @@ async fn main() -> Result<()> {
             cache,
             parallel,
             github_token,
+            ghcr_owner,
         } => {
-            cmd_generate(arch, recipes, output, cache_type, cache, parallel, github_token).await
+            cmd_generate(arch, recipes, output, cache_type, cache, parallel, github_token, ghcr_owner).await
         }
 
         Commands::ShouldRebuild {
@@ -212,6 +217,7 @@ async fn cmd_generate(
     _cache: Option<PathBuf>,
     _parallel: usize,
     github_token: Option<String>,
+    ghcr_owner: String,
 ) -> Result<()> {
     info!("Generating metadata for {} (cache: {})", arch, cache_type_filter);
 
@@ -239,7 +245,7 @@ async fn cmd_generate(
 
     for (path, recipe) in recipes {
         // Get all GHCR packages for this recipe (handles multiple binaries)
-        let ghcr_packages = recipe.ghcr_packages_from_path(&path);
+        let ghcr_packages = recipe.ghcr_packages_from_path(&path, &ghcr_owner);
 
         if ghcr_packages.is_empty() {
             warn!("No GHCR packages found for {:?}", path);
@@ -284,7 +290,7 @@ async fn cmd_generate(
                         match client.fetch_manifest(&ghcr_info.ghcr_path, tag).await {
                             Ok(manifest_str) => {
                                 if let Ok(manifest) = OciManifest::from_json(&manifest_str) {
-                                    metadata.enrich_from_manifest(&manifest, tag);
+                                    metadata.enrich_from_manifest(&manifest, &ghcr_info.ghcr_path, tag);
                                 }
                             }
                             Err(e) => {

sbuild-meta/src/metadata.rs

@@ -183,6 +183,9 @@ pub struct PackageMetadata {
 
     #[serde(skip_serializing_if = "is_empty_vec")]
     pub replaces: Option<Vec<String>>,
+
+    #[serde(skip_serializing_if = "is_empty_vec")]
+    pub repology: Option<Vec<String>>,
 }
 
 impl PackageMetadata {
@@ -236,63 +239,87 @@ impl PackageMetadata {
             } else {
                 Some(recipe.provides.clone())
             },
+            repology: if recipe.repology.is_empty() {
+                None
+            } else {
+                Some(recipe.repology.clone())
+            },
             disabled: if recipe.disabled { Some(true) } else { None },
             ..Default::default()
         }
     }
 
     /// Enrich metadata with OCI manifest data
-    pub fn enrich_from_manifest(&mut self, manifest: &OciManifest, tag: &str) {
+    ///
+    /// `ghcr_path` is the repository path (e.g., "pkgforge/bincache/hello/static")
+    pub fn enrich_from_manifest(&mut self, manifest: &OciManifest, ghcr_path: &str, tag: &str) {
         // Get embedded JSON if available
         if let Ok(Some(pkg_json)) = manifest.get_package_json() {
             self.merge_from_json(&pkg_json);
         }
 
-        // GHCR info
-        self.ghcr_pkg = manifest.ghcr_pkg().map(|s| s.to_string());
+        // GHCR info - construct from path and tag
+        let ghcr_pkg = format!("ghcr.io/{}:{}", ghcr_path, tag);
+        self.ghcr_pkg = Some(ghcr_pkg.clone());
+        self.ghcr_url = Some(format!("https://ghcr.io/{}", ghcr_path));
+
         let size = manifest.total_size();
         self.ghcr_size_raw = Some(size);
         self.ghcr_size = Some(format_size(size));
         self.ghcr_files = Some(manifest.filenames().into_iter().map(|s| s.to_string()).collect());
 
+        // Version from annotations
+        if let Some(version) = manifest.get_annotation("dev.pkgforge.soar.version") {
+            self.version = version.to_string();
+        } else if let Some(version) = manifest.get_annotation("org.opencontainers.image.version") {
+            self.version = version.to_string();
+        }
+
+        // Build date from annotations
+        if let Some(date) = manifest.get_annotation("dev.pkgforge.soar.push_date") {
+            self.build_date = Some(date.to_string());
+        } else if let Some(date) = manifest.get_annotation("org.opencontainers.image.created") {
+            self.build_date = Some(date.to_string());
+        }
+
         // Build info from annotations
         if self.build_id.is_none() {
             let build_id = manifest.build_id().map(|s| s.to_string());
             self.build_id = build_id.clone();
 
             // Generate GitHub Actions URL if we have a build ID
             if let Some(ref id) = build_id {
-                // Try to determine the repo from ghcr_pkg
-                if let Some(ref ghcr_pkg) = self.ghcr_pkg {
-                    let cache_type = if ghcr_pkg.contains("pkgcache") { "pkgcache" } else { "bincache" };
-                    self.build_gha = Some(format!(
-                        "https://github.com/pkgforge/{}/actions/runs/{}",
-                        cache_type, id
-                    ));
-                }
+                let cache_type = if ghcr_path.contains("pkgcache") { "pkgcache" } else { "bincache" };
+                self.build_gha = Some(format!(
+                    "https://github.com/pkgforge/{}/actions/runs/{}",
+                    cache_type, id
+                ));
+            }
+        }
+
+        // Build script from annotations
+        if self.build_script.is_none() {
+            if let Some(script) = manifest.get_annotation("dev.pkgforge.soar.build_script") {
+                self.build_script = Some(script.to_string());
             }
         }
 
-        // Generate blob reference for main binary
+        // Generate blob reference and download URLs
         if let Some(filename) = manifest.filenames().first() {
             self.ghcr_blob = manifest.get_blob_ref(filename);
 
             // Generate download URL and manifest URL
-            if let Some(ref ghcr_pkg) = self.ghcr_pkg {
-                let base = ghcr_pkg.split(':').next().unwrap_or(ghcr_pkg);
-                let repo = base.replace("ghcr.io/", "");
-                self.download_url = format!(
-                    "https://api.ghcr.pkgforge.dev/{}?tag={}&download={}",
-                    repo, tag, filename
-                );
-                self.manifest_url = Some(format!(
-                    "https://api.ghcr.pkgforge.dev/{}?tag={}&manifest",
-                    repo, tag
-                ));
-                // Size is usually same as ghcr_size for single binary packages
-                self.size_raw = self.ghcr_size_raw;
-                self.size = self.ghcr_size.clone();
-            }
+            self.download_url = format!(
+                "https://api.ghcr.pkgforge.dev/{}?tag={}&download={}",
+                ghcr_path, tag, filename
+            );
+            self.manifest_url = Some(format!(
+                "https://api.ghcr.pkgforge.dev/{}?tag={}&manifest",
+                ghcr_path, tag
+            ));
+            // Size is usually same as ghcr_size for single binary packages
+            self.size_raw = self.ghcr_size_raw;
+            self.size = self.ghcr_size.clone();
         }
     }
 
@@ -403,8 +430,8 @@ impl MetadataBuilder {
         }
     }
 
-    pub fn with_manifest(mut self, manifest: &OciManifest, tag: &str) -> Self {
-        self.metadata.enrich_from_manifest(manifest, tag);
+    pub fn with_manifest(mut self, manifest: &OciManifest, ghcr_path: &str, tag: &str) -> Self {
+        self.metadata.enrich_from_manifest(manifest, ghcr_path, tag);
         self
     }
 

sbuild-meta/src/recipe.rs

@@ -350,7 +350,7 @@ impl SBuildRecipe {
     }
 
     /// GHCR package information including path components
-    pub fn ghcr_packages_from_path(&self, recipe_path: &Path) -> Vec<GhcrPackageInfo> {
+    pub fn ghcr_packages_from_path(&self, recipe_path: &Path, ghcr_owner: &str) -> Vec<GhcrPackageInfo> {
         let mut packages = Vec::new();
 
         // Determine cache type based on path (bincache for binaries/, pkgcache for packages/)
@@ -382,8 +382,8 @@ impl SBuildRecipe {
             // GHCR path: {owner}/{cache}/{pkg_family}/{recipe_name}
             // e.g., pkgforge/bincache/hello/static
             let ghcr_path = format!(
-                "pkgforge/{}/{}/{}",
-                cache_type, pkg_family, recipe_name
+                "{}/{}/{}/{}",
+                ghcr_owner, cache_type, pkg_family, recipe_name
             );
 
             packages.push(GhcrPackageInfo {
@@ -516,7 +516,7 @@ provides:
 "#;
         let recipe = SBuildRecipe::from_yaml(yaml).unwrap();
         let path = Path::new("binaries/bat/static.yaml");
-        let packages = recipe.ghcr_packages_from_path(path);
+        let packages = recipe.ghcr_packages_from_path(path, "pkgforge");
 
         // bat==batcat means bat is the package, batcat is symlink - only 1 entry
         assert_eq!(packages.len(), 1);
@@ -536,7 +536,7 @@ provides:
 "#;
         let recipe = SBuildRecipe::from_yaml(yaml).unwrap();
         let path = Path::new("binaries/myapp/static.yaml");
-        let packages = recipe.ghcr_packages_from_path(path);
+        let packages = recipe.ghcr_packages_from_path(path, "pkgforge");
 
         // Two separate packages - but same GHCR path (they're in the same recipe)
         assert_eq!(packages.len(), 2);
@@ -556,7 +556,7 @@ provides:
 "#;
         let recipe = SBuildRecipe::from_yaml(yaml).unwrap();
         let path = Path::new("binaries/busybox/static.yaml");
-        let packages = recipe.ghcr_packages_from_path(path);
+        let packages = recipe.ghcr_packages_from_path(path, "pkgforge");
 
         // All entries refer to busybox - should deduplicate to 1
         assert_eq!(packages.len(), 1);
@@ -574,7 +574,7 @@ provides:
 "#;
         let recipe = SBuildRecipe::from_yaml(yaml).unwrap();
         let path = Path::new("packages/0ad/appimage.0ad-matters.stable.yaml");
-        let packages = recipe.ghcr_packages_from_path(path);
+        let packages = recipe.ghcr_packages_from_path(path, "pkgforge");
 
         assert_eq!(packages.len(), 1);
         // New simplified format: {owner}/{cache}/{pkg_family}/{recipe_name}

sbuild/src/main.rs

@@ -4,6 +4,7 @@
 
 use std::{
     env,
+    fs,
     path::{Path, PathBuf},
     process::Command,
     sync::{
@@ -68,6 +69,95 @@ fn parse_ghcr_path(recipe_path: &str) -> Option<(String, String)> {
     Some((pkg_family, recipe_name))
 }
 
+/// Metadata extracted from SBUILD file for GHCR annotations
+#[derive(Debug, Default)]
+struct SbuildMetadata {
+    pkg: String,
+    pkg_id: String,
+    pkg_type: Option<String>,
+    description: Option<String>,
+    homepage: Option<String>,
+    license: Option<String>,
+}
+
+/// Read metadata from SBUILD file in output directory
+fn read_sbuild_metadata(outdir: &Path) -> Option<SbuildMetadata> {
+    let sbuild_path = outdir.join("SBUILD");
+    let content = fs::read_to_string(&sbuild_path).ok()?;
+
+    // Parse YAML content
+    let yaml: serde_yml::Value = serde_yml::from_str(&content).ok()?;
+    let map = yaml.as_mapping()?;
+
+    let pkg = map
+        .get("pkg")
+        .and_then(|v| v.as_str())
+        .unwrap_or("unknown")
+        .to_string();
+
+    let pkg_id = map
+        .get("pkg_id")
+        .and_then(|v| v.as_str())
+        .unwrap_or("unknown")
+        .to_string();
+
+    let pkg_type = map.get("pkg_type").and_then(|v| v.as_str()).map(String::from);
+
+    // Description can be a string or a map with short/long
+    let description = map.get("description").and_then(|v| {
+        if let Some(s) = v.as_str() {
+            Some(s.to_string())
+        } else if let Some(m) = v.as_mapping() {
+            m.get("short").and_then(|s| s.as_str()).map(String::from)
+        } else {
+            None
+        }
+    });
+
+    // Homepage is an array, take the first one
+    let homepage = map.get("homepage").and_then(|v| {
+        if let Some(arr) = v.as_sequence() {
+            arr.first().and_then(|s| s.as_str()).map(String::from)
+        } else {
+            v.as_str().map(String::from)
+        }
+    });
+
+    // License is an array of strings or complex objects
+    let license = map.get("license").and_then(|v| {
+        if let Some(arr) = v.as_sequence() {
+            let licenses: Vec<String> = arr
+                .iter()
+                .filter_map(|item| {
+                    if let Some(s) = item.as_str() {
+                        Some(s.to_string())
+                    } else if let Some(m) = item.as_mapping() {
+                        m.get("id").and_then(|id| id.as_str()).map(String::from)
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+            if licenses.is_empty() {
+                None
+            } else {
+                Some(licenses.join(", "))
+            }
+        } else {
+            v.as_str().map(String::from)
+        }
+    });
+
+    Some(SbuildMetadata {
+        pkg,
+        pkg_id,
+        pkg_type,
+        description,
+        homepage,
+        license,
+    })
+}
+
 /// Log level for build output
 #[derive(Debug, Clone, Copy, ValueEnum, Default)]
 enum LogLevel {
@@ -384,14 +474,21 @@ async fn post_build_processing(
                 (base_repo.clone(), pkg_name.unwrap_or("unknown").to_string())
             };
 
+            // Read metadata from SBUILD file
+            let metadata = read_sbuild_metadata(outdir).unwrap_or_default();
+
             let annotations = PackageAnnotations {
-                pkg: pkg.clone(),
-                pkg_id: "unknown".to_string(),
-                pkg_type: None,
+                pkg: if metadata.pkg.is_empty() || metadata.pkg == "unknown" {
+                    pkg.clone()
+                } else {
+                    metadata.pkg
+                },
+                pkg_id: metadata.pkg_id,
+                pkg_type: metadata.pkg_type,
                 version: version.clone(),
-                description: None,
-                homepage: None,
-                license: None,
+                description: metadata.description,
+                homepage: metadata.homepage,
+                license: metadata.license,
                 build_date: chrono::Utc::now().to_rfc3339(),
                 build_id: env::var("GITHUB_RUN_ID").ok(),
                 build_gha: env::var("GITHUB_RUN_ID")