catalog.rs (69957B)
1 use std::{ 2 collections::{BTreeMap, BTreeSet}, 3 fs, 4 path::{Component, Path}, 5 process::Command, 6 }; 7 8 use serde::Deserialize; 9 use sha2::{Digest, Sha256}; 10 11 use crate::contract::artifact_bundle::{ 12 GeneratedArtifact, read_regular_file, with_artifact_bundle_transaction, 13 }; 14 15 const CATALOG_RELATIVE: &str = "contracts/crates/catalog.v2.toml"; 16 const RELEASE_RELATIVE: &str = "contracts/crates/release.v2.toml"; 17 const CONSOLIDATION_RELATIVE: &str = "contracts/consolidation/architecture.v1.toml"; 18 const GROUPS_RELATIVE: &str = "contracts/crates/generated/package_groups.v1.toml"; 19 const PLATFORMS_RELATIVE: &str = "contracts/crates/generated/platform_inventory.v1.toml"; 20 const RELEASE_INVENTORY_RELATIVE: &str = "contracts/crates/generated/release_inventory.v2.toml"; 21 const COVERAGE_RELATIVE: &str = "contracts/coverage.toml"; 22 const CATALOG_SCHEMA: &str = "radroots.workspace.catalog.v2"; 23 const RELEASE_ID: &str = "radroots.crates.release.v2"; 24 const CONSOLIDATION_ID: &str = "radroots.rust.consolidation.v1"; 25 const VERSION: &str = "0.1.0-alpha"; 26 // Implemented public owners from the approved shared SDK target. Native 27 // introduction provenance is independent of publication eligibility. 28 const NATIVE_PUBLIC_PACKAGES: &[&str] = &[ 29 "radroots_domain", 30 "radroots_execution", 31 "radroots_transport_nostr_native", 32 ]; 33 const APPLICATION_RETIREMENT: &str = 34 "contracts/architecture/decisions/tera_application_ownership.v1.json"; 35 const RETIRED_APPLICATION_PACKAGES: [&str; 4] = [ 36 "radroots_mobile_bindgen", 37 "radroots_mobile_core", 38 "radroots_mobile_ffi", 39 "radroots_mobile_wasm", 40 ]; 41 42 #[derive(Debug, Deserialize)] 43 #[serde(deny_unknown_fields)] 44 struct ApplicationRetirement { 45 schema: String, 46 source_repository: String, 47 source_catalog_revision: String, 48 source_catalog_sha256: String, 49 transfer_donor_commit: String, 50 transfer_donor_tree: String, 51 target_repository: String, 52 target_revision: String, 53 transfer_evidence_sha256: String, 54 package: Vec<RetiredApplication>, 55 } 56 57 #[derive(Debug, Deserialize)] 58 #[serde(deny_unknown_fields)] 59 struct RetiredApplication { 60 former_catalog_entry: CatalogPackage, 61 target_name: String, 62 target_path: String, 63 projected_commit: String, 64 projected_tree: String, 65 } 66 67 #[derive(Debug, Deserialize)] 68 #[serde(deny_unknown_fields)] 69 struct Catalog { 70 schema_version: u16, 71 schema: String, 72 architecture: String, 73 consolidation: String, 74 version: String, 75 rust_version: String, 76 edition: String, 77 resolver: String, 78 public_package_count: usize, 79 package_count: usize, 80 digest_algorithm: String, 81 source_tree_digest_algorithm: String, 82 native_introduction_tree_digest_algorithm: String, 83 source_provenance_policy: String, 84 provenance_correction_contract: String, 85 retired_packages: Vec<String>, 86 package: Vec<CatalogPackage>, 87 } 88 89 #[derive(Debug, Deserialize)] 90 #[serde(deny_unknown_fields)] 91 struct CatalogPackage { 92 name: String, 93 path: String, 94 state: String, 95 tier: String, 96 visibility: String, 97 publish: bool, 98 version: String, 99 license: String, 100 platforms: Vec<String>, 101 groups: Vec<String>, 102 owners: Vec<String>, 103 permitted_dependency_tiers: Vec<String>, 104 provenance_kind: String, 105 source_repository: Option<String>, 106 source_revision: Option<String>, 107 source_path: Option<String>, 108 source_tree_sha256: Option<String>, 109 introduction_tree_sha256: Option<String>, 110 compatibility: Vec<String>, 111 removal_gate: Option<String>, 112 replaces: Vec<String>, 113 } 114 115 #[derive(Debug, Deserialize)] 116 #[serde(deny_unknown_fields)] 117 struct ReleaseV2 { 118 schema_version: u16, 119 spec_id: String, 120 status: String, 121 supersedes_without_mutation: String, 122 canonical_repository: String, 123 version: String, 124 public_package_count: usize, 125 publication_authorized: bool, 126 public_packages: Vec<String>, 127 v1_artifact: Vec<V1Artifact>, 128 v1_retired_human_artifact: Vec<RetiredV1HumanArtifact>, 129 } 130 131 #[derive(Debug, Deserialize)] 132 #[serde(deny_unknown_fields)] 133 struct V1Artifact { 134 path: String, 135 sha256: String, 136 } 137 138 #[derive(Debug, Deserialize)] 139 #[serde(deny_unknown_fields)] 140 struct RetiredV1HumanArtifact { 141 former_path: String, 142 sha256: String, 143 } 144 145 #[derive(Debug, Deserialize)] 146 #[serde(deny_unknown_fields)] 147 struct ConsolidationV1 { 148 schema_version: u16, 149 consolidation_id: String, 150 architecture: String, 151 canonical_rust_repository: String, 152 donor_repositories: Vec<String>, 153 consumer_repositories: Vec<String>, 154 source_retirement_requires: Vec<String>, 155 repository_archival_requires: Vec<String>, 156 } 157 158 #[derive(Debug, Deserialize)] 159 struct CoveragePolicy { 160 required: CoverageRequired, 161 } 162 163 #[derive(Debug, Deserialize)] 164 struct CoverageRequired { 165 crates: Vec<String>, 166 } 167 168 #[derive(Debug, Deserialize)] 169 struct CargoMetadata { 170 packages: Vec<CargoPackage>, 171 workspace_members: Vec<String>, 172 } 173 174 #[derive(Debug, Deserialize)] 175 struct CargoPackage { 176 id: String, 177 name: String, 178 version: String, 179 manifest_path: String, 180 license: Option<String>, 181 publish: Option<Vec<String>>, 182 dependencies: Vec<CargoDependency>, 183 } 184 185 #[derive(Debug, Deserialize)] 186 struct CargoDependency { 187 name: String, 188 source: Option<String>, 189 req: String, 190 path: Option<String>, 191 kind: Option<String>, 192 target: Option<String>, 193 } 194 195 pub fn run(args: &[String], workspace_root: &Path) -> Result<(), String> { 196 match args { 197 [command] if command == "check" => check(workspace_root), 198 [command] if command == "write" => write(workspace_root), 199 _ => Err("catalog accepts check or write".to_owned()), 200 } 201 } 202 203 pub(crate) fn check(workspace_root: &Path) -> Result<(), String> { 204 check_with_provenance(workspace_root, true) 205 } 206 207 pub(crate) fn check_source_export(workspace_root: &Path) -> Result<(), String> { 208 check_with_provenance(workspace_root, false) 209 } 210 211 pub(crate) fn active_group(workspace_root: &Path, group: &str) -> Result<Vec<String>, String> { 212 validate_identifier(group, "package group")?; 213 active_packages_matching(workspace_root, |package| { 214 package.groups.iter().any(|candidate| candidate == group) 215 }) 216 } 217 218 pub(crate) fn active_packages(workspace_root: &Path) -> Result<Vec<String>, String> { 219 active_packages_matching(workspace_root, |_| true) 220 } 221 222 pub(crate) fn public_packages(workspace_root: &Path) -> Result<Vec<String>, String> { 223 let catalog = parse_file::<Catalog>(workspace_root, CATALOG_RELATIVE)?; 224 validate_catalog(&catalog)?; 225 let release = parse_file::<ReleaseV2>(workspace_root, RELEASE_RELATIVE)?; 226 validate_release(&release, &catalog, workspace_root)?; 227 Ok(release.public_packages) 228 } 229 230 fn active_packages_matching( 231 workspace_root: &Path, 232 predicate: impl Fn(&CatalogPackage) -> bool, 233 ) -> Result<Vec<String>, String> { 234 let catalog = parse_file::<Catalog>(workspace_root, CATALOG_RELATIVE)?; 235 validate_catalog(&catalog)?; 236 validate_application_retirement(&catalog, workspace_root)?; 237 let mut packages = catalog 238 .package 239 .iter() 240 .filter(|package| package.state == "active" && predicate(package)) 241 .map(|package| package.name.clone()) 242 .collect::<Vec<_>>(); 243 packages.sort_unstable(); 244 Ok(packages) 245 } 246 247 fn check_with_provenance( 248 workspace_root: &Path, 249 require_git_provenance: bool, 250 ) -> Result<(), String> { 251 let loaded = load_and_validate(workspace_root, require_git_provenance)?; 252 for artifact in render_projections(&loaded.catalog, &loaded.catalog_digest) { 253 let current = read_regular_file(workspace_root, artifact.relative)?; 254 if current != artifact.contents { 255 return Err(format!( 256 "generated catalog projection {} is stale; run catalog write", 257 artifact.relative 258 )); 259 } 260 } 261 Ok(()) 262 } 263 264 fn write(workspace_root: &Path) -> Result<(), String> { 265 let loaded = load_and_validate(workspace_root, true)?; 266 let artifacts = render_projections(&loaded.catalog, &loaded.catalog_digest); 267 with_artifact_bundle_transaction(workspace_root, |transaction| transaction.write(artifacts)) 268 } 269 270 struct LoadedCatalog { 271 catalog: Catalog, 272 catalog_digest: String, 273 } 274 275 fn load_and_validate( 276 workspace_root: &Path, 277 require_git_provenance: bool, 278 ) -> Result<LoadedCatalog, String> { 279 let catalog_bytes = read_regular_file(workspace_root, CATALOG_RELATIVE)?; 280 let catalog = parse_toml::<Catalog>(CATALOG_RELATIVE, &catalog_bytes)?; 281 let release = parse_file::<ReleaseV2>(workspace_root, RELEASE_RELATIVE)?; 282 let consolidation = parse_file::<ConsolidationV1>(workspace_root, CONSOLIDATION_RELATIVE)?; 283 let coverage = parse_file::<CoveragePolicy>(workspace_root, COVERAGE_RELATIVE)?; 284 validate_catalog(&catalog)?; 285 validate_application_retirement(&catalog, workspace_root)?; 286 validate_coverage_authority(&catalog, &coverage)?; 287 validate_release(&release, &catalog, workspace_root)?; 288 validate_consolidation(&consolidation)?; 289 validate_workspace_manifest(&catalog, workspace_root)?; 290 let metadata = cargo_metadata(workspace_root)?; 291 validate_metadata(&catalog, &metadata, workspace_root)?; 292 if require_git_provenance { 293 validate_active_source_provenance(&catalog, workspace_root)?; 294 } 295 Ok(LoadedCatalog { 296 catalog, 297 catalog_digest: sha256(&catalog_bytes), 298 }) 299 } 300 301 fn parse_file<T: for<'de> Deserialize<'de>>( 302 workspace_root: &Path, 303 relative: &str, 304 ) -> Result<T, String> { 305 let bytes = read_regular_file(workspace_root, relative)?; 306 parse_toml(relative, &bytes) 307 } 308 309 fn parse_toml<T: for<'de> Deserialize<'de>>(relative: &str, bytes: &[u8]) -> Result<T, String> { 310 let raw = 311 std::str::from_utf8(bytes).map_err(|error| format!("{relative} is not UTF-8: {error}"))?; 312 toml::from_str(raw).map_err(|error| format!("parse {relative}: {error}")) 313 } 314 315 fn validate_catalog(catalog: &Catalog) -> Result<(), String> { 316 if catalog.schema_version != 2 317 || catalog.schema != CATALOG_SCHEMA 318 || catalog.architecture != RELEASE_ID 319 || catalog.consolidation != CONSOLIDATION_ID 320 || catalog.version != VERSION 321 || catalog.rust_version != crate::architecture::STABLE_TOOLCHAIN 322 || catalog.edition != "2024" 323 || catalog.resolver != "3" 324 || catalog.public_package_count != expected_public_packages().len() 325 || catalog.package_count != catalog.package.len() 326 || catalog.digest_algorithm != "sha256-raw-bytes-v1" 327 || catalog.source_tree_digest_algorithm != "sha256-git-ls-tree-r-v1" 328 || catalog.native_introduction_tree_digest_algorithm != "sha256-git-tree-records-z-v1" 329 || catalog.source_provenance_policy != "imported_revision_tree_or_native_introduction_tree" 330 || catalog.provenance_correction_contract != "approved_correction_record_required" 331 { 332 return Err("catalog identity, toolchain, or cardinality drifted".to_owned()); 333 } 334 335 let expected_public = expected_public_packages(); 336 let allowed_states = BTreeSet::from(["active", "reserved_import", "reserved_refactor"]); 337 let allowed_visibilities = BTreeSet::from([ 338 "public_release", 339 "private_runtime", 340 "private_adapter", 341 "private_boundary", 342 "private_codegen", 343 "private_fixture", 344 "private_tool", 345 ]); 346 let allowed_licenses = BTreeSet::from([ 347 "MIT OR Apache-2.0", 348 "GPL-3.0-only", 349 "GPL-3.0-or-later", 350 "MPL-2.0", 351 ]); 352 let mut names = BTreeSet::new(); 353 let mut paths = BTreeSet::new(); 354 let mut public = BTreeSet::new(); 355 let mut package_by_name = BTreeMap::new(); 356 let mut groups = BTreeSet::new(); 357 for package in &catalog.package { 358 validate_identifier(&package.name, "package name")?; 359 validate_relative_path(&package.path)?; 360 validate_identifier(&package.tier, "package tier")?; 361 let expected_path = match package.name.as_str() { 362 "radroots" => "crates/radroots".to_owned(), 363 // shared_sdk_refactor.v1.json fixes the browser artifact-root path. 364 "radroots_browser" => "crates/radroots_browser".to_owned(), 365 // The same approved decision fixes the concrete native boundary. 366 "radroots_ffi" => "crates/radroots_ffi".to_owned(), 367 "xtask" => "tools/xtask".to_owned(), 368 name => format!( 369 "crates/{}", 370 name.strip_prefix("radroots_") 371 .ok_or_else(|| format!("package {name} lacks the radroots_ prefix"))? 372 ), 373 }; 374 if package.path != expected_path { 375 return Err(format!( 376 "package {} must use canonical path {expected_path}", 377 package.name 378 )); 379 } 380 if !names.insert(package.name.as_str()) || !paths.insert(package.path.as_str()) { 381 return Err(format!( 382 "duplicate package name or path for {}", 383 package.name 384 )); 385 } 386 if !allowed_states.contains(package.state.as_str()) 387 || !allowed_visibilities.contains(package.visibility.as_str()) 388 || !allowed_licenses.contains(package.license.as_str()) 389 || package.version != VERSION 390 || package.platforms.is_empty() 391 || package.groups.is_empty() 392 || package.owners.is_empty() 393 || package.permitted_dependency_tiers.is_empty() 394 || package.compatibility.is_empty() 395 { 396 return Err(format!("catalog package {} is incomplete", package.name)); 397 } 398 validate_unique_identifiers(&package.platforms, "platform")?; 399 validate_unique_identifiers(&package.groups, "group")?; 400 validate_unique_identifiers(&package.owners, "owner")?; 401 validate_unique_identifiers( 402 &package.permitted_dependency_tiers, 403 "permitted dependency tier", 404 )?; 405 validate_unique_identifiers(&package.compatibility, "compatibility authority")?; 406 for group in &package.groups { 407 groups.insert(group.as_str()); 408 } 409 if package.visibility == "public_release" { 410 public.insert(package.name.as_str()); 411 if !package.publish || package.license != "MIT OR Apache-2.0" { 412 return Err(format!( 413 "public package {} must be permissive and publication-eligible", 414 package.name 415 )); 416 } 417 } else if package.publish { 418 return Err(format!( 419 "private package {} must set publish=false", 420 package.name 421 )); 422 } 423 if package.license.starts_with("GPL-") 424 && !matches!( 425 package.visibility.as_str(), 426 "private_runtime" | "private_adapter" | "private_boundary" | "private_codegen" 427 ) 428 { 429 return Err(format!("GPL package {} has an invalid class", package.name)); 430 } 431 validate_package_provenance(package)?; 432 for replaced in &package.replaces { 433 validate_package_identity(replaced, "replaced package")?; 434 } 435 if package.state == "active" && package.removal_gate.is_some() { 436 return Err(format!( 437 "active package {} has a removal gate", 438 package.name 439 )); 440 } 441 if package.state != "active" 442 && package 443 .removal_gate 444 .as_deref() 445 .is_none_or(|gate| gate.trim().is_empty()) 446 { 447 return Err(format!( 448 "reserved package {} lacks a removal gate", 449 package.name 450 )); 451 } 452 package_by_name.insert(package.name.as_str(), package); 453 } 454 if public != expected_public { 455 return Err("catalog must contain exactly the approved public allocation".to_owned()); 456 } 457 let required_groups = BTreeSet::from([ 458 "boundaries", 459 "coverage_required", 460 "portable", 461 "preview", 462 "public_native", 463 "sdk", 464 "tools", 465 "wasm", 466 ]); 467 if !required_groups.is_subset(&groups) { 468 return Err("catalog is missing one or more required package groups".to_owned()); 469 } 470 let portable = catalog 471 .package 472 .iter() 473 .filter(|package| package.groups.iter().any(|group| group == "portable")) 474 .map(|package| package.name.as_str()) 475 .collect::<BTreeSet<_>>(); 476 if portable != expected_public { 477 return Err("portable group must contain exactly the public allocation".to_owned()); 478 } 479 for package in &catalog.package { 480 for tier in &package.permitted_dependency_tiers { 481 if !catalog 482 .package 483 .iter() 484 .any(|candidate| candidate.tier == *tier) 485 { 486 return Err(format!( 487 "package {} permits unknown tier {tier}", 488 package.name 489 )); 490 } 491 } 492 } 493 let retired = catalog 494 .retired_packages 495 .iter() 496 .map(String::as_str) 497 .collect::<BTreeSet<_>>(); 498 if retired.len() != catalog.retired_packages.len() 499 || retired 500 .iter() 501 .any(|name| package_by_name.contains_key(name)) 502 || !expected_retired_packages().is_subset(&retired) 503 { 504 return Err("retired package identities are incomplete or reused".to_owned()); 505 } 506 let xtasks = catalog 507 .package 508 .iter() 509 .filter(|package| package.name == "xtask") 510 .collect::<Vec<_>>(); 511 if xtasks.len() != 1 512 || xtasks[0].path != "tools/xtask" 513 || xtasks[0].visibility != "private_tool" 514 || xtasks[0].state != "active" 515 { 516 return Err("catalog must contain exactly one canonical xtask".to_owned()); 517 } 518 Ok(()) 519 } 520 521 fn validate_package_provenance(package: &CatalogPackage) -> Result<(), String> { 522 match package.provenance_kind.as_str() { 523 "imported" => { 524 let source_repository = package.source_repository.as_deref().ok_or_else(|| { 525 format!("imported package {} lacks source repository", package.name) 526 })?; 527 let source_revision = package.source_revision.as_deref().ok_or_else(|| { 528 format!("imported package {} lacks source revision", package.name) 529 })?; 530 let source_path = package 531 .source_path 532 .as_deref() 533 .ok_or_else(|| format!("imported package {} lacks source path", package.name))?; 534 let source_tree_sha256 = package.source_tree_sha256.as_deref().ok_or_else(|| { 535 format!("imported package {} lacks source tree digest", package.name) 536 })?; 537 if package.introduction_tree_sha256.is_some() { 538 return Err(format!( 539 "imported package {} declares native introduction provenance", 540 package.name 541 )); 542 } 543 if source_repository 544 != format!( 545 "https://github.com/radrootslabs/{}", 546 source_repository_name(source_repository)? 547 ) 548 { 549 return Err(format!( 550 "package {} source repository is noncanonical", 551 package.name 552 )); 553 } 554 validate_oid(source_revision, "source revision")?; 555 validate_relative_path(source_path)?; 556 validate_sha256(source_tree_sha256, "source tree digest") 557 } 558 "native" => { 559 if package.source_repository.is_some() 560 || package.source_revision.is_some() 561 || package.source_path.is_some() 562 || package.source_tree_sha256.is_some() 563 { 564 return Err(format!( 565 "native package {} must not declare imported provenance", 566 package.name 567 )); 568 } 569 let introduction_tree_sha256 = 570 package.introduction_tree_sha256.as_deref().ok_or_else(|| { 571 format!( 572 "native package {} lacks introduction tree digest", 573 package.name 574 ) 575 })?; 576 validate_sha256(introduction_tree_sha256, "introduction tree digest")?; 577 let public = package.publish || package.visibility == "public_release"; 578 if package.state != "active" 579 || (public 580 && (!NATIVE_PUBLIC_PACKAGES.contains(&package.name.as_str()) 581 || !package.publish 582 || package.visibility != "public_release")) 583 { 584 return Err(format!( 585 "native package {} must be active and use its approved publication boundary", 586 package.name 587 )); 588 } 589 Ok(()) 590 } 591 _ => Err(format!( 592 "package {} has unknown provenance kind {}", 593 package.name, package.provenance_kind 594 )), 595 } 596 } 597 598 fn validate_coverage_authority(catalog: &Catalog, coverage: &CoveragePolicy) -> Result<(), String> { 599 let catalog_required = catalog 600 .package 601 .iter() 602 .filter(|package| { 603 package.state == "active" 604 && package 605 .groups 606 .iter() 607 .any(|group| group == "coverage_required") 608 }) 609 .map(|package| package.name.as_str()) 610 .collect::<BTreeSet<_>>(); 611 let policy_required = coverage 612 .required 613 .crates 614 .iter() 615 .map(String::as_str) 616 .collect::<BTreeSet<_>>(); 617 if policy_required.len() != coverage.required.crates.len() { 618 return Err("coverage policy contains duplicate required packages".to_owned()); 619 } 620 if catalog_required != policy_required { 621 return Err( 622 "coverage required packages must exactly match the catalog coverage_required group" 623 .to_owned(), 624 ); 625 } 626 Ok(()) 627 } 628 629 fn validate_release( 630 release: &ReleaseV2, 631 catalog: &Catalog, 632 workspace_root: &Path, 633 ) -> Result<(), String> { 634 if release.schema_version != 2 635 || release.spec_id != RELEASE_ID 636 || release.status != "approved_not_published" 637 || release.supersedes_without_mutation != "radroots.crates.release.v1" 638 || release.canonical_repository != "https://github.com/radrootslabs/lib" 639 || release.version != VERSION 640 || release.public_package_count != expected_public_packages().len() 641 || release.publication_authorized 642 || release 643 .public_packages 644 .iter() 645 .map(String::as_str) 646 .collect::<BTreeSet<_>>() 647 != expected_public_packages() 648 { 649 return Err("release v2 identity or public allocation drifted".to_owned()); 650 } 651 if release.public_packages.len() != release.public_package_count 652 || catalog.public_package_count != release.public_package_count 653 { 654 return Err("release v2 package cardinality drifted".to_owned()); 655 } 656 let mut paths = BTreeSet::new(); 657 for artifact in &release.v1_artifact { 658 validate_relative_path(&artifact.path)?; 659 validate_sha256(&artifact.sha256, "v1 artifact digest")?; 660 if !paths.insert(artifact.path.as_str()) { 661 return Err("release v2 repeats a v1 artifact".to_owned()); 662 } 663 let bytes = read_regular_file(workspace_root, &artifact.path)?; 664 if sha256(&bytes) != artifact.sha256 { 665 return Err(format!("historical v1 artifact {} drifted", artifact.path)); 666 } 667 } 668 let expected = BTreeSet::from([ 669 "contracts/crates/release_v1/radroots_crates_release_v1.dot", 670 "contracts/crates/release_v1/radroots_crates_release_v1.sha256", 671 "contracts/crates/release_v1/radroots_crates_release_v1.toml", 672 "contracts/crates/release_v1/radroots_crates_release_v1_inventory.csv", 673 ]); 674 if paths != expected { 675 return Err("release v2 must pin every historical v1 machine artifact".to_owned()); 676 } 677 if release.v1_retired_human_artifact.len() != 1 { 678 return Err("release v2 must record the retired v1 human artifact".to_owned()); 679 } 680 let retired = &release.v1_retired_human_artifact[0]; 681 validate_relative_path(&retired.former_path)?; 682 validate_sha256(&retired.sha256, "retired v1 human artifact digest")?; 683 if retired.former_path != "docs/specs/radroots_crates_release_v1.md" 684 || retired.sha256 != "ea2c1f0f5c53fae56a247ae7519b065c9a0d62dafb998b75a48075f4a875b5eb" 685 { 686 return Err("release v2 retired v1 human artifact drifted".to_owned()); 687 } 688 Ok(()) 689 } 690 691 fn validate_consolidation(contract: &ConsolidationV1) -> Result<(), String> { 692 if contract.schema_version != 1 693 || contract.consolidation_id != CONSOLIDATION_ID 694 || contract.architecture != RELEASE_ID 695 || contract.canonical_rust_repository != "https://github.com/radrootslabs/lib" 696 || contract 697 .donor_repositories 698 .iter() 699 .map(String::as_str) 700 .collect::<BTreeSet<_>>() 701 != BTreeSet::from([ 702 "https://github.com/radrootslabs/app_rt", 703 "https://github.com/radrootslabs/sdk", 704 "https://github.com/radrootslabs/studio_app", 705 ]) 706 || contract 707 .consumer_repositories 708 .iter() 709 .map(String::as_str) 710 .collect::<BTreeSet<_>>() 711 != BTreeSet::from([ 712 "https://github.com/radrootslabs/sdk", 713 "https://github.com/radrootslabs/studio_app", 714 ]) 715 || contract.source_retirement_requires.is_empty() 716 || contract.repository_archival_requires.is_empty() 717 { 718 return Err("consolidation v1 repository authority drifted".to_owned()); 719 } 720 validate_unique_identifiers( 721 &contract.source_retirement_requires, 722 "source retirement requirement", 723 )?; 724 validate_unique_identifiers( 725 &contract.repository_archival_requires, 726 "repository archival requirement", 727 ) 728 } 729 730 fn cargo_metadata(workspace_root: &Path) -> Result<CargoMetadata, String> { 731 let output = Command::new("cargo") 732 .args(["metadata", "--format-version", "1", "--locked", "--no-deps"]) 733 .current_dir(workspace_root) 734 .output() 735 .map_err(|error| format!("run cargo metadata: {error}"))?; 736 if !output.status.success() { 737 return Err(format!( 738 "cargo metadata failed: {}", 739 String::from_utf8_lossy(&output.stderr).trim() 740 )); 741 } 742 serde_json::from_slice(&output.stdout) 743 .map_err(|error| format!("parse cargo metadata output: {error}")) 744 } 745 746 fn validate_workspace_manifest(catalog: &Catalog, workspace_root: &Path) -> Result<(), String> { 747 let bytes = read_regular_file(workspace_root, "Cargo.toml")?; 748 let raw = 749 std::str::from_utf8(&bytes).map_err(|error| format!("Cargo.toml is not UTF-8: {error}"))?; 750 let manifest = 751 toml::from_str::<toml::Value>(raw).map_err(|error| format!("parse Cargo.toml: {error}"))?; 752 let workspace = manifest 753 .get("workspace") 754 .and_then(toml::Value::as_table) 755 .ok_or_else(|| "Cargo.toml lacks [workspace]".to_owned())?; 756 let members = workspace 757 .get("members") 758 .and_then(toml::Value::as_array) 759 .ok_or_else(|| "Cargo.toml lacks explicit workspace members".to_owned())? 760 .iter() 761 .map(|value| { 762 value 763 .as_str() 764 .ok_or_else(|| "workspace member must be a string".to_owned()) 765 }) 766 .collect::<Result<BTreeSet<_>, _>>()?; 767 let active_paths = catalog 768 .package 769 .iter() 770 .filter(|package| package.state == "active") 771 .map(|package| package.path.as_str()) 772 .collect::<BTreeSet<_>>(); 773 if members != active_paths 774 || members 775 .iter() 776 .any(|member| member.contains('*') || member.contains('?') || member.contains('[')) 777 { 778 return Err( 779 "Cargo workspace members must exactly match explicit active catalog paths".to_owned(), 780 ); 781 } 782 let default_members = workspace 783 .get("default-members") 784 .and_then(toml::Value::as_array) 785 .ok_or_else(|| "Cargo.toml lacks explicit default members".to_owned())? 786 .iter() 787 .map(|value| { 788 value 789 .as_str() 790 .ok_or_else(|| "default member must be a string".to_owned()) 791 }) 792 .collect::<Result<BTreeSet<_>, _>>()?; 793 let expected_defaults = catalog 794 .package 795 .iter() 796 .filter(|package| { 797 package.state == "active" 798 && (package.groups.iter().any(|group| group == "portable") 799 || package.name == "xtask") 800 }) 801 .map(|package| package.path.as_str()) 802 .collect::<BTreeSet<_>>(); 803 if default_members != expected_defaults { 804 return Err( 805 "Cargo default members must match active portable packages plus xtask".to_owned(), 806 ); 807 } 808 if workspace.get("resolver").and_then(toml::Value::as_str) != Some("3") { 809 return Err("Cargo workspace resolver must remain 3".to_owned()); 810 } 811 let dependencies = manifest 812 .get("workspace") 813 .and_then(|workspace| workspace.get("dependencies")) 814 .and_then(toml::Value::as_table) 815 .ok_or_else(|| "Cargo.toml lacks [workspace.dependencies]".to_owned())?; 816 for (name, value) in dependencies { 817 let name = value 818 .get("package") 819 .and_then(toml::Value::as_str) 820 .unwrap_or(name); 821 validate_foundation_dependency(name, value.get("git").and_then(toml::Value::as_str))?; 822 } 823 for package in catalog 824 .package 825 .iter() 826 .filter(|package| package.state == "active" && package.name != "xtask") 827 { 828 let dependency = dependencies 829 .get(&package.name) 830 .and_then(toml::Value::as_table) 831 .ok_or_else(|| format!("workspace dependency {} is missing", package.name))?; 832 if dependency.get("path").and_then(toml::Value::as_str) != Some(package.path.as_str()) 833 || dependency.get("version").and_then(toml::Value::as_str) 834 != Some(format!("={VERSION}").as_str()) 835 || ["git", "rev", "branch", "tag"] 836 .iter() 837 .any(|key| dependency.contains_key(*key)) 838 { 839 return Err(format!( 840 "workspace dependency {} must use its catalog path and exact version only", 841 package.name 842 )); 843 } 844 } 845 Ok(()) 846 } 847 848 fn validate_foundation_dependency(name: &str, source: Option<&str>) -> Result<(), String> { 849 if expected_retired_packages().contains(name) 850 || name == "tera" 851 || name.starts_with("tera_") 852 || source.is_some_and(|source| source.contains("radrootslabs/tera")) 853 { 854 return Err(format!( 855 "shared foundation cannot depend on retired or application package {name}" 856 )); 857 } 858 Ok(()) 859 } 860 861 fn validate_application_retirement(catalog: &Catalog, root: &Path) -> Result<(), String> { 862 let bytes = read_regular_file(root, APPLICATION_RETIREMENT)?; 863 let retirement: ApplicationRetirement = serde_json::from_slice(&bytes) 864 .map_err(|error| format!("parse application ownership decision: {error}"))?; 865 if retirement.schema != "radroots.tera.application-ownership.v1" 866 || retirement.source_repository != "https://github.com/radrootslabs/lib" 867 || retirement.target_repository != "https://github.com/radrootslabs/tera" 868 || retirement.package.len() != RETIRED_APPLICATION_PACKAGES.len() 869 { 870 return Err("application ownership decision identity drifted".to_owned()); 871 } 872 validate_oid( 873 &retirement.source_catalog_revision, 874 "former catalog revision", 875 )?; 876 validate_oid( 877 &retirement.transfer_donor_commit, 878 "application donor commit", 879 )?; 880 validate_oid(&retirement.transfer_donor_tree, "application donor tree")?; 881 validate_oid(&retirement.target_revision, "application target revision")?; 882 validate_sha256(&retirement.source_catalog_sha256, "former catalog digest")?; 883 validate_sha256( 884 &retirement.transfer_evidence_sha256, 885 "transfer evidence digest", 886 )?; 887 let mut names = BTreeSet::new(); 888 for transferred in &retirement.package { 889 let former = &transferred.former_catalog_entry; 890 if !RETIRED_APPLICATION_PACKAGES.contains(&former.name.as_str()) 891 || !names.insert(former.name.as_str()) 892 || !catalog.retired_packages.contains(&former.name) 893 || catalog 894 .package 895 .iter() 896 .any(|package| package.name == former.name) 897 || former.state != "active" 898 || former.publish 899 || former.license != "GPL-3.0-or-later" 900 || former.path != format!("crates/{}", former.name.trim_start_matches("radroots_")) 901 || transferred.target_name != former.name.replacen("radroots_mobile_", "tera_", 1) 902 || transferred.target_path != format!("core/crates/{}", transferred.target_name) 903 { 904 return Err( 905 "application package retirement or retained attribution drifted".to_owned(), 906 ); 907 } 908 validate_package_provenance(former)?; 909 validate_oid( 910 &transferred.projected_commit, 911 "application projected commit", 912 )?; 913 validate_oid(&transferred.projected_tree, "application projected tree")?; 914 match fs::symlink_metadata(root.join(&former.path)) { 915 Err(error) if error.kind() == std::io::ErrorKind::NotFound => {} 916 Err(error) => return Err(format!("inspect retired application path: {error}")), 917 Ok(_) => { 918 return Err(format!( 919 "retired application path {} remains present", 920 former.path 921 )); 922 } 923 } 924 } 925 Ok(()) 926 } 927 928 fn validate_metadata( 929 catalog: &Catalog, 930 metadata: &CargoMetadata, 931 workspace_root: &Path, 932 ) -> Result<(), String> { 933 let workspace_ids = metadata 934 .workspace_members 935 .iter() 936 .map(String::as_str) 937 .collect::<BTreeSet<_>>(); 938 let workspace_packages = metadata 939 .packages 940 .iter() 941 .filter(|package| workspace_ids.contains(package.id.as_str())) 942 .map(|package| (package.name.as_str(), package)) 943 .collect::<BTreeMap<_, _>>(); 944 let catalog_by_name = catalog 945 .package 946 .iter() 947 .map(|package| (package.name.as_str(), package)) 948 .collect::<BTreeMap<_, _>>(); 949 let active = catalog 950 .package 951 .iter() 952 .filter(|package| package.state == "active") 953 .map(|package| package.name.as_str()) 954 .collect::<BTreeSet<_>>(); 955 if workspace_packages.keys().copied().collect::<BTreeSet<_>>() != active { 956 return Err("active catalog packages and Cargo workspace members differ".to_owned()); 957 } 958 for package in catalog 959 .package 960 .iter() 961 .filter(|package| package.state != "active") 962 { 963 if workspace_root.join(&package.path).exists() { 964 return Err(format!( 965 "reserved package path {} exists before its catalog activation", 966 package.path 967 )); 968 } 969 } 970 let canonical_root = fs::canonicalize(workspace_root) 971 .map_err(|error| format!("canonicalize {}: {error}", workspace_root.display()))?; 972 for (name, cargo) in &workspace_packages { 973 let package = catalog_by_name[name]; 974 let manifest = Path::new(&cargo.manifest_path); 975 let relative_manifest = manifest 976 .strip_prefix(&canonical_root) 977 .map_err(|_| format!("manifest {} escapes workspace", manifest.display()))?; 978 let actual_path = relative_manifest 979 .parent() 980 .ok_or_else(|| format!("manifest {} has no package root", manifest.display()))? 981 .to_string_lossy() 982 .replace('\\', "/"); 983 let cargo_publish = cargo 984 .publish 985 .as_ref() 986 .is_some_and(|registries| !registries.is_empty()); 987 if package.path != actual_path 988 || package.version != cargo.version 989 || package.license != cargo.license.as_deref().unwrap_or("") 990 || package.publish != cargo_publish 991 { 992 return Err(format!("catalog and Cargo metadata drifted for {name}")); 993 } 994 for dependency in &cargo.dependencies { 995 validate_foundation_dependency(&dependency.name, dependency.source.as_deref())?; 996 let Some(target) = catalog_by_name.get(dependency.name.as_str()) else { 997 continue; 998 }; 999 if dependency.path.is_none() || dependency.req != format!("={VERSION}") { 1000 return Err(format!( 1001 "first-party dependency {name} -> {} must use path plus ={VERSION}", 1002 dependency.name 1003 )); 1004 } 1005 if !package 1006 .permitted_dependency_tiers 1007 .iter() 1008 .any(|tier| tier == &target.tier) 1009 { 1010 return Err(format!( 1011 "catalog tier policy forbids {name} -> {} ({:?}, {:?})", 1012 dependency.name, dependency.kind, dependency.target 1013 )); 1014 } 1015 if package.visibility == "public_release" && target.visibility != "public_release" { 1016 return Err(format!( 1017 "public package {name} depends on private package {}", 1018 dependency.name 1019 )); 1020 } 1021 if package.license == "MIT OR Apache-2.0" && target.license.starts_with("GPL-") { 1022 return Err(format!( 1023 "permissive package {name} depends on GPL package {}", 1024 dependency.name 1025 )); 1026 } 1027 } 1028 } 1029 Ok(()) 1030 } 1031 1032 fn validate_active_source_provenance( 1033 catalog: &Catalog, 1034 workspace_root: &Path, 1035 ) -> Result<(), String> { 1036 for package in catalog 1037 .package 1038 .iter() 1039 .filter(|package| package.state == "active") 1040 { 1041 match package.provenance_kind.as_str() { 1042 "imported" 1043 if package.source_repository.as_deref() 1044 == Some("https://github.com/radrootslabs/lib") => 1045 { 1046 validate_imported_source_provenance(package, workspace_root)?; 1047 } 1048 "native" => validate_native_source_provenance(package, workspace_root)?, 1049 _ => {} 1050 } 1051 } 1052 Ok(()) 1053 } 1054 1055 fn validate_imported_source_provenance( 1056 package: &CatalogPackage, 1057 workspace_root: &Path, 1058 ) -> Result<(), String> { 1059 let source_revision = package 1060 .source_revision 1061 .as_deref() 1062 .ok_or_else(|| format!("imported package {} lacks source revision", package.name))?; 1063 let source_path = package 1064 .source_path 1065 .as_deref() 1066 .ok_or_else(|| format!("imported package {} lacks source path", package.name))?; 1067 let expected = package 1068 .source_tree_sha256 1069 .as_deref() 1070 .ok_or_else(|| format!("imported package {} lacks source tree digest", package.name))?; 1071 let output = Command::new("git") 1072 .args(["ls-tree", "-r", source_revision, "--", source_path]) 1073 .current_dir(workspace_root) 1074 .output() 1075 .map_err(|error| format!("run git ls-tree for {}: {error}", package.name))?; 1076 if !output.status.success() { 1077 return Err(format!( 1078 "source revision for {} is unavailable: {}", 1079 package.name, 1080 String::from_utf8_lossy(&output.stderr).trim() 1081 )); 1082 } 1083 if sha256(&output.stdout) != expected { 1084 return Err(format!( 1085 "source tree provenance drifted for {}", 1086 package.name 1087 )); 1088 } 1089 Ok(()) 1090 } 1091 1092 fn validate_native_source_provenance( 1093 package: &CatalogPackage, 1094 workspace_root: &Path, 1095 ) -> Result<(), String> { 1096 let expected = package 1097 .introduction_tree_sha256 1098 .as_deref() 1099 .ok_or_else(|| format!("native package {} lacks introduction digest", package.name))?; 1100 let introducing_commit = native_introducing_commit(workspace_root, &package.path)?; 1101 let actual = if let Some(commit) = introducing_commit { 1102 committed_tree_digest(workspace_root, &commit, &package.path)? 1103 } else { 1104 staged_tree_digest(workspace_root, &package.path)? 1105 }; 1106 if actual != expected { 1107 return Err(format!( 1108 "native introduction tree provenance drifted for {}", 1109 package.name 1110 )); 1111 } 1112 Ok(()) 1113 } 1114 1115 fn native_introducing_commit( 1116 workspace_root: &Path, 1117 package_path: &str, 1118 ) -> Result<Option<String>, String> { 1119 let output = Command::new("git") 1120 .args([ 1121 "log", 1122 "--format=%H", 1123 "--diff-filter=A", 1124 "--reverse", 1125 "--no-renames", 1126 "HEAD", 1127 "--", 1128 package_path, 1129 ]) 1130 .current_dir(workspace_root) 1131 .output() 1132 .map_err(|error| format!("derive native introduction commit: {error}"))?; 1133 if !output.status.success() { 1134 return Err(format!( 1135 "derive native introduction commit for {package_path}: {}", 1136 String::from_utf8_lossy(&output.stderr).trim() 1137 )); 1138 } 1139 let stdout = std::str::from_utf8(&output.stdout) 1140 .map_err(|error| format!("native introduction history is not UTF-8: {error}"))?; 1141 let Some(commit) = stdout.lines().next() else { 1142 return Ok(None); 1143 }; 1144 validate_oid(commit, "native introducing commit")?; 1145 Ok(Some(commit.to_owned())) 1146 } 1147 1148 fn committed_tree_digest( 1149 workspace_root: &Path, 1150 commit: &str, 1151 package_path: &str, 1152 ) -> Result<String, String> { 1153 let output = Command::new("git") 1154 .args(["ls-tree", "-r", "-z", commit, "--", package_path]) 1155 .current_dir(workspace_root) 1156 .output() 1157 .map_err(|error| format!("read native introduction tree: {error}"))?; 1158 if !output.status.success() { 1159 return Err(format!( 1160 "read native introduction tree for {package_path}: {}", 1161 String::from_utf8_lossy(&output.stderr).trim() 1162 )); 1163 } 1164 if output.stdout.is_empty() { 1165 return Err(format!( 1166 "native introducing commit {commit} has no tree at {package_path}" 1167 )); 1168 } 1169 Ok(sha256(&output.stdout)) 1170 } 1171 1172 fn staged_tree_digest(workspace_root: &Path, package_path: &str) -> Result<String, String> { 1173 let output = Command::new("git") 1174 .args(["ls-files", "--stage", "-z", "--", package_path]) 1175 .current_dir(workspace_root) 1176 .output() 1177 .map_err(|error| format!("read staged native tree: {error}"))?; 1178 if !output.status.success() { 1179 return Err(format!( 1180 "read staged native tree for {package_path}: {}", 1181 String::from_utf8_lossy(&output.stderr).trim() 1182 )); 1183 } 1184 let records = canonical_staged_tree_records(&output.stdout)?; 1185 if records.is_empty() { 1186 return Err(format!( 1187 "native package {package_path} has no committed introduction or staged tree" 1188 )); 1189 } 1190 Ok(sha256(&records)) 1191 } 1192 1193 fn canonical_staged_tree_records(input: &[u8]) -> Result<Vec<u8>, String> { 1194 let mut output = Vec::new(); 1195 for record in input 1196 .split(|byte| *byte == 0) 1197 .filter(|record| !record.is_empty()) 1198 { 1199 let tab = record 1200 .iter() 1201 .position(|byte| *byte == b'\t') 1202 .ok_or_else(|| "staged tree record lacks a path separator".to_owned())?; 1203 let header = std::str::from_utf8(&record[..tab]) 1204 .map_err(|error| format!("staged tree record header is not UTF-8: {error}"))?; 1205 let fields = header.split(' ').collect::<Vec<_>>(); 1206 if fields.len() != 3 || fields[2] != "0" { 1207 return Err("staged native tree must contain only stage-zero records".to_owned()); 1208 } 1209 let mode = fields[0]; 1210 let oid = fields[1]; 1211 if mode.len() != 6 || !mode.bytes().all(|byte| matches!(byte, b'0'..=b'7')) { 1212 return Err("staged native tree contains an invalid mode".to_owned()); 1213 } 1214 validate_oid(oid, "staged native object")?; 1215 if oid.bytes().all(|byte| byte == b'0') { 1216 return Err("staged native tree contains an intent-to-add object".to_owned()); 1217 } 1218 if record[tab + 1..].is_empty() { 1219 return Err("staged native tree contains an empty path".to_owned()); 1220 } 1221 let object_type = if mode == "160000" { "commit" } else { "blob" }; 1222 output.extend_from_slice(mode.as_bytes()); 1223 output.push(b' '); 1224 output.extend_from_slice(object_type.as_bytes()); 1225 output.push(b' '); 1226 output.extend_from_slice(oid.as_bytes()); 1227 output.push(b'\t'); 1228 output.extend_from_slice(&record[tab + 1..]); 1229 output.push(0); 1230 } 1231 Ok(output) 1232 } 1233 1234 fn render_projections(catalog: &Catalog, digest: &str) -> Vec<GeneratedArtifact> { 1235 let mut groups = BTreeMap::<&str, Vec<&str>>::new(); 1236 let mut active_groups = BTreeMap::<&str, Vec<&str>>::new(); 1237 let mut reserved_groups = BTreeMap::<&str, Vec<&str>>::new(); 1238 let mut platforms = BTreeMap::<&str, Vec<&str>>::new(); 1239 let mut public = Vec::new(); 1240 let mut private = Vec::new(); 1241 let mut reserved = Vec::new(); 1242 for package in &catalog.package { 1243 for group in &package.groups { 1244 groups.entry(group).or_default().push(&package.name); 1245 if package.state == "active" { 1246 active_groups.entry(group).or_default().push(&package.name); 1247 } else { 1248 reserved_groups 1249 .entry(group) 1250 .or_default() 1251 .push(&package.name); 1252 } 1253 } 1254 for platform in &package.platforms { 1255 platforms.entry(platform).or_default().push(&package.name); 1256 } 1257 if package.visibility == "public_release" { 1258 public.push(package.name.as_str()); 1259 } else { 1260 private.push(package.name.as_str()); 1261 } 1262 if package.state != "active" { 1263 reserved.push(package.name.as_str()); 1264 } 1265 } 1266 sort_map_values(&mut groups); 1267 sort_map_values(&mut active_groups); 1268 sort_map_values(&mut reserved_groups); 1269 sort_map_values(&mut platforms); 1270 public.sort_unstable(); 1271 private.sort_unstable(); 1272 reserved.sort_unstable(); 1273 vec![ 1274 GeneratedArtifact { 1275 relative: GROUPS_RELATIVE, 1276 contents: render_group_projection( 1277 digest, 1278 &groups, 1279 &active_groups, 1280 &reserved_groups, 1281 ) 1282 .into_bytes(), 1283 }, 1284 GeneratedArtifact { 1285 relative: PLATFORMS_RELATIVE, 1286 contents: render_map_projection( 1287 "radroots.workspace.platform-inventory.v1", 1288 digest, 1289 "platform", 1290 &platforms, 1291 ) 1292 .into_bytes(), 1293 }, 1294 GeneratedArtifact { 1295 relative: RELEASE_INVENTORY_RELATIVE, 1296 contents: format!( 1297 "schema = \"radroots.workspace.release-inventory.v2\"\ncatalog_sha256 = \"{digest}\"\narchitecture = \"{RELEASE_ID}\"\nversion = \"{VERSION}\"\npublic_packages = {}\nprivate_packages = {}\nreserved_packages = {}\n", 1298 toml_array(&public), 1299 toml_array(&private), 1300 toml_array(&reserved) 1301 ) 1302 .into_bytes(), 1303 }, 1304 ] 1305 } 1306 1307 fn render_group_projection( 1308 digest: &str, 1309 groups: &BTreeMap<&str, Vec<&str>>, 1310 active: &BTreeMap<&str, Vec<&str>>, 1311 reserved: &BTreeMap<&str, Vec<&str>>, 1312 ) -> String { 1313 let mut output = format!( 1314 "schema = \"radroots.workspace.package-groups.v1\"\ncatalog_sha256 = \"{digest}\"\n" 1315 ); 1316 for (id, packages) in groups { 1317 output.push_str(&format!( 1318 "\n[[group]]\nid = \"{id}\"\npackages = {}\nactive_packages = {}\nreserved_packages = {}\n", 1319 toml_array(packages), 1320 toml_array(active.get(id).map(Vec::as_slice).unwrap_or_default()), 1321 toml_array(reserved.get(id).map(Vec::as_slice).unwrap_or_default()), 1322 )); 1323 } 1324 output 1325 } 1326 1327 fn render_map_projection( 1328 schema: &str, 1329 digest: &str, 1330 table: &str, 1331 values: &BTreeMap<&str, Vec<&str>>, 1332 ) -> String { 1333 let mut output = format!("schema = \"{schema}\"\ncatalog_sha256 = \"{digest}\"\n"); 1334 for (id, packages) in values { 1335 output.push_str(&format!( 1336 "\n[[{table}]]\nid = \"{id}\"\npackages = {}\n", 1337 toml_array(packages) 1338 )); 1339 } 1340 output 1341 } 1342 1343 fn toml_array(values: &[&str]) -> String { 1344 format!( 1345 "[{}]", 1346 values 1347 .iter() 1348 .map(|value| format!("\"{value}\"")) 1349 .collect::<Vec<_>>() 1350 .join(", ") 1351 ) 1352 } 1353 1354 fn sort_map_values(values: &mut BTreeMap<&str, Vec<&str>>) { 1355 for packages in values.values_mut() { 1356 packages.sort_unstable(); 1357 packages.dedup(); 1358 } 1359 } 1360 1361 fn expected_public_packages() -> BTreeSet<&'static str> { 1362 let mut packages = BTreeSet::from([ 1363 "radroots", 1364 "radroots_blossom", 1365 "radroots_core", 1366 "radroots_event", 1367 "radroots_event_codec", 1368 "radroots_geonames", 1369 "radroots_identity", 1370 "radroots_nostr", 1371 "radroots_nostr_connect", 1372 "radroots_protocol", 1373 "radroots_sdk", 1374 "radroots_secrets", 1375 "radroots_signing", 1376 "radroots_storage", 1377 "radroots_storage_sqlite", 1378 "radroots_sync", 1379 "radroots_trade", 1380 "radroots_transport", 1381 "radroots_transport_nostr", 1382 ]); 1383 packages.extend(NATIVE_PUBLIC_PACKAGES.iter().copied()); 1384 packages 1385 } 1386 1387 fn expected_retired_packages() -> BTreeSet<&'static str> { 1388 BTreeSet::from([ 1389 "radroots-studio-application", 1390 "radroots-studio-domain", 1391 "radroots-studio-ffi", 1392 "radroots-studio-nostr", 1393 "radroots-studio-storage", 1394 "radroots-studio-uniffi-bindgen", 1395 "radroots_studio_application", 1396 "radroots_studio_domain", 1397 "radroots_studio_ffi", 1398 "radroots_studio_nostr", 1399 "radroots_studio_preferences", 1400 "radroots_studio_runtime", 1401 "radroots_studio_storage", 1402 "radroots_studio_uniffi_bindgen", 1403 "radroots_app_bindgen", 1404 "radroots_app_core", 1405 "radroots_app_ffi", 1406 "radroots_app_wasm", 1407 "radroots_mobile_bindgen", 1408 "radroots_mobile_core", 1409 "radroots_mobile_ffi", 1410 "radroots_mobile_wasm", 1411 "radroots_sdk_xtask", 1412 ]) 1413 } 1414 1415 fn validate_unique_identifiers(values: &[String], context: &str) -> Result<(), String> { 1416 let mut unique = BTreeSet::new(); 1417 for value in values { 1418 validate_identifier(value, context)?; 1419 if !unique.insert(value.as_str()) { 1420 return Err(format!("duplicate {context} {value}")); 1421 } 1422 } 1423 Ok(()) 1424 } 1425 1426 fn validate_identifier(value: &str, context: &str) -> Result<(), String> { 1427 if value.is_empty() 1428 || !value 1429 .bytes() 1430 .all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit() || byte == b'_') 1431 { 1432 return Err(format!("{context} must use lowercase snake case")); 1433 } 1434 Ok(()) 1435 } 1436 1437 fn validate_package_identity(value: &str, context: &str) -> Result<(), String> { 1438 if value.is_empty() 1439 || !value.bytes().all(|byte| { 1440 byte.is_ascii_lowercase() || byte.is_ascii_digit() || matches!(byte, b'_' | b'-') 1441 }) 1442 { 1443 return Err(format!("{context} is invalid")); 1444 } 1445 Ok(()) 1446 } 1447 1448 fn validate_relative_path(value: &str) -> Result<(), String> { 1449 let path = Path::new(value); 1450 if value.is_empty() 1451 || path.is_absolute() 1452 || value.contains('\\') 1453 || value 1454 .split('/') 1455 .any(|segment| segment.is_empty() || matches!(segment, "." | "..")) 1456 || path 1457 .components() 1458 .any(|component| !matches!(component, Component::Normal(_))) 1459 { 1460 return Err(format!("catalog path {value:?} is unsafe")); 1461 } 1462 Ok(()) 1463 } 1464 1465 fn validate_oid(value: &str, context: &str) -> Result<(), String> { 1466 if value.len() != 40 1467 || !value 1468 .bytes() 1469 .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte)) 1470 { 1471 return Err(format!("{context} must be lowercase full 40-hex")); 1472 } 1473 Ok(()) 1474 } 1475 1476 fn validate_sha256(value: &str, context: &str) -> Result<(), String> { 1477 if value.len() != 64 1478 || !value 1479 .bytes() 1480 .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte)) 1481 { 1482 return Err(format!("{context} must be lowercase 64-hex")); 1483 } 1484 Ok(()) 1485 } 1486 1487 fn source_repository_name(url: &str) -> Result<&str, String> { 1488 url.strip_prefix("https://github.com/radrootslabs/") 1489 .filter(|name| { 1490 !name.is_empty() 1491 && name 1492 .bytes() 1493 .all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit() || byte == b'_') 1494 }) 1495 .ok_or_else(|| format!("invalid canonical source repository {url}")) 1496 } 1497 1498 fn sha256(bytes: &[u8]) -> String { 1499 format!("{:x}", Sha256::digest(bytes)) 1500 } 1501 1502 #[cfg(test)] 1503 mod tests { 1504 use super::*; 1505 use tempfile::TempDir; 1506 1507 fn checked_in_catalog() -> Catalog { 1508 parse_file(&crate::workspace_root(), CATALOG_RELATIVE).expect("checked-in catalog") 1509 } 1510 1511 fn git(root: &Path, args: &[&str]) { 1512 let output = Command::new("git") 1513 .args(args) 1514 .current_dir(root) 1515 .output() 1516 .expect("run git fixture command"); 1517 assert!( 1518 output.status.success(), 1519 "git {} failed: {}", 1520 args.join(" "), 1521 String::from_utf8_lossy(&output.stderr) 1522 ); 1523 } 1524 1525 fn git_fixture() -> TempDir { 1526 let root = tempfile::tempdir().expect("temporary git fixture"); 1527 git(root.path(), &["init", "--quiet"]); 1528 git(root.path(), &["config", "user.name", "Catalog Test"]); 1529 git( 1530 root.path(), 1531 &["config", "user.email", "catalog-test@example.invalid"], 1532 ); 1533 fs::write(root.path().join("README.md"), "# Fixture\n").expect("baseline file"); 1534 git(root.path(), &["add", "README.md"]); 1535 git(root.path(), &["commit", "--quiet", "-m", "baseline"]); 1536 root 1537 } 1538 1539 fn native_package<'a>( 1540 catalog: &'a mut Catalog, 1541 path: &str, 1542 digest: &str, 1543 ) -> &'a mut CatalogPackage { 1544 let package = catalog 1545 .package 1546 .iter_mut() 1547 .find(|package| package.name == "radroots_nostrdb") 1548 .expect("private package fixture"); 1549 package.path = path.to_owned(); 1550 package.provenance_kind = "native".to_owned(); 1551 package.source_repository = None; 1552 package.source_revision = None; 1553 package.source_path = None; 1554 package.source_tree_sha256 = None; 1555 package.introduction_tree_sha256 = Some(digest.to_owned()); 1556 package 1557 } 1558 1559 #[test] 1560 fn public_inventory_is_exact() { 1561 assert_eq!(expected_public_packages().len(), 22); 1562 assert!(expected_public_packages().contains("radroots")); 1563 assert!(expected_public_packages().contains("radroots_sdk")); 1564 } 1565 1566 #[test] 1567 fn paths_and_digests_fail_closed() { 1568 assert!(validate_relative_path("crates/sdk").is_ok()); 1569 assert!(validate_relative_path("../sdk").is_err()); 1570 assert!(validate_relative_path("crates/./sdk").is_err()); 1571 assert!(validate_sha256(&"a".repeat(64), "digest").is_ok()); 1572 assert!(validate_sha256(&"A".repeat(64), "digest").is_err()); 1573 } 1574 1575 #[test] 1576 fn browser_artifact_keeps_its_approved_directory_instead_of_prefix_stripping() { 1577 let mut catalog = checked_in_catalog(); 1578 validate_catalog(&catalog).expect("approved catalog"); 1579 let browser = catalog 1580 .package 1581 .iter_mut() 1582 .find(|package| package.name == "radroots_browser") 1583 .expect("browser artifact"); 1584 assert_eq!(browser.path, "crates/radroots_browser"); 1585 browser.path = "crates/browser".to_owned(); 1586 assert!(validate_catalog(&catalog).is_err()); 1587 } 1588 1589 #[test] 1590 fn only_approved_shared_native_packages_can_be_public() { 1591 for name in [ 1592 "radroots_domain", 1593 "radroots_execution", 1594 "radroots_transport_nostr_native", 1595 ] { 1596 let mut catalog = checked_in_catalog(); 1597 let package = catalog.package.iter_mut().find(|p| p.name == name).unwrap(); 1598 package.visibility = "public_release".to_owned(); 1599 package.publish = true; 1600 validate_package_provenance(package).expect("approved native public allocation"); 1601 package.source_revision = Some("a".repeat(40)); 1602 assert!(validate_package_provenance(package).is_err()); 1603 } 1604 let mut catalog = checked_in_catalog(); 1605 let other = native_package(&mut catalog, "crates/nostrdb", &"a".repeat(64)); 1606 other.visibility = "public_release".to_owned(); 1607 other.publish = true; 1608 assert!(validate_package_provenance(other).is_err()); 1609 } 1610 1611 #[test] 1612 fn provenance_kinds_are_disjoint_and_native_is_unpublished() { 1613 let mut catalog = checked_in_catalog(); 1614 let imported = catalog 1615 .package 1616 .iter_mut() 1617 .find(|package| package.name == "radroots_core") 1618 .expect("imported fixture"); 1619 imported.source_revision = None; 1620 assert!(validate_package_provenance(imported).is_err()); 1621 1622 let mut catalog = checked_in_catalog(); 1623 let native = native_package(&mut catalog, "crates/nostrdb", &"a".repeat(64)); 1624 assert!(validate_package_provenance(native).is_ok()); 1625 native.source_revision = Some("a".repeat(40)); 1626 assert!(validate_package_provenance(native).is_err()); 1627 1628 let mut catalog = checked_in_catalog(); 1629 let public = catalog 1630 .package 1631 .iter_mut() 1632 .find(|package| package.name == "radroots_core") 1633 .expect("public fixture"); 1634 public.provenance_kind = "native".to_owned(); 1635 public.source_repository = None; 1636 public.source_revision = None; 1637 public.source_path = None; 1638 public.source_tree_sha256 = None; 1639 public.introduction_tree_sha256 = Some("a".repeat(64)); 1640 assert!(validate_package_provenance(public).is_err()); 1641 } 1642 1643 #[test] 1644 fn native_provenance_matches_staged_then_derived_introduction_tree() { 1645 let root = git_fixture(); 1646 let package_root = root.path().join("crates/native_fixture"); 1647 fs::create_dir_all(&package_root).expect("native package root"); 1648 fs::write( 1649 package_root.join("Cargo.toml"), 1650 "[package]\nname='fixture'\n", 1651 ) 1652 .expect("native manifest"); 1653 fs::write(package_root.join("lib.rs"), "pub fn initial() {}\n").expect("native source"); 1654 git(root.path(), &["add", "crates/native_fixture"]); 1655 1656 let staged = 1657 staged_tree_digest(root.path(), "crates/native_fixture").expect("staged tree digest"); 1658 assert_eq!( 1659 native_introducing_commit(root.path(), "crates/native_fixture") 1660 .expect("precommit history"), 1661 None 1662 ); 1663 let mut catalog = checked_in_catalog(); 1664 let package = native_package(&mut catalog, "crates/native_fixture", &staged); 1665 validate_native_source_provenance(package, root.path()).expect("staged provenance"); 1666 1667 fs::write(package_root.join("lib.rs"), "unstaged change\n").expect("unstaged change"); 1668 validate_native_source_provenance(package, root.path()) 1669 .expect("only the staged introduction is authoritative before commit"); 1670 git( 1671 root.path(), 1672 &["commit", "--quiet", "-m", "add native package"], 1673 ); 1674 1675 let introducing = native_introducing_commit(root.path(), "crates/native_fixture") 1676 .expect("committed history") 1677 .expect("introducing commit"); 1678 assert_eq!( 1679 committed_tree_digest(root.path(), &introducing, "crates/native_fixture") 1680 .expect("committed introduction digest"), 1681 staged 1682 ); 1683 validate_native_source_provenance(package, root.path()) 1684 .expect("derived committed provenance"); 1685 1686 git(root.path(), &["add", "crates/native_fixture/lib.rs"]); 1687 git( 1688 root.path(), 1689 &["commit", "--quiet", "-m", "change native package"], 1690 ); 1691 validate_native_source_provenance(package, root.path()) 1692 .expect("later changes do not rewrite introduction provenance"); 1693 package.introduction_tree_sha256 = Some("b".repeat(64)); 1694 assert!(validate_native_source_provenance(package, root.path()).is_err()); 1695 } 1696 1697 #[test] 1698 fn native_precommit_provenance_requires_stage_zero_index_records() { 1699 let root = git_fixture(); 1700 fs::create_dir_all(root.path().join("crates/native_fixture")).expect("native package root"); 1701 fs::write( 1702 root.path().join("crates/native_fixture/lib.rs"), 1703 "pub fn unstaged() {}\n", 1704 ) 1705 .expect("unstaged native source"); 1706 assert!(staged_tree_digest(root.path(), "crates/native_fixture").is_err()); 1707 1708 let oid = "a".repeat(40); 1709 let conflicted = format!("100644 {oid} 1\tcrates/native_fixture/lib.rs\0"); 1710 assert!(canonical_staged_tree_records(conflicted.as_bytes()).is_err()); 1711 1712 let intent_to_add = format!( 1713 "100644 {} 0\tcrates/native_fixture/lib.rs\0", 1714 "0".repeat(40) 1715 ); 1716 assert!(canonical_staged_tree_records(intent_to_add.as_bytes()).is_err()); 1717 } 1718 1719 #[test] 1720 fn generated_maps_are_sorted_and_digest_bound() { 1721 let mut values = BTreeMap::from([("sdk", vec!["z", "a", "a"])]); 1722 sort_map_values(&mut values); 1723 let rendered = render_map_projection("fixture.v1", &"a".repeat(64), "group", &values); 1724 assert!(rendered.contains("catalog_sha256")); 1725 assert!(rendered.contains("packages = [\"a\", \"z\"]")); 1726 } 1727 1728 #[test] 1729 fn checked_in_catalog_structure_is_valid() { 1730 validate_catalog(&checked_in_catalog()).expect("catalog structure"); 1731 } 1732 1733 #[test] 1734 fn retired_application_packages_cannot_return_as_dependencies_or_sources() { 1735 for name in 1736 RETIRED_APPLICATION_PACKAGES 1737 .into_iter() 1738 .chain(["tera", "tera_core", "tera_ffi"]) 1739 { 1740 assert!(validate_foundation_dependency(name, None).is_err()); 1741 } 1742 for source in [ 1743 "git+https://github.com/radrootslabs/tera?rev=immutable", 1744 "https://github.com/radrootslabs/tera.git", 1745 "ssh://git@github.com/radrootslabs/tera.git", 1746 ] { 1747 assert!(validate_foundation_dependency("renamed_application", Some(source)).is_err()); 1748 } 1749 validate_foundation_dependency("radroots_sdk", None).expect("shared SDK remains owned"); 1750 validate_foundation_dependency("radroots_storage_sqlite", None) 1751 .expect("shared storage remains owned"); 1752 let catalog = checked_in_catalog(); 1753 validate_application_retirement(&catalog, &crate::workspace_root()) 1754 .expect("retirement is coherent"); 1755 let fixture = tempfile::TempDir::new().expect("retirement fixture"); 1756 let decision = fixture.path().join(APPLICATION_RETIREMENT); 1757 fs::create_dir_all(decision.parent().expect("decision parent")) 1758 .expect("decision directory"); 1759 fs::copy( 1760 crate::workspace_root().join(APPLICATION_RETIREMENT), 1761 &decision, 1762 ) 1763 .expect("decision"); 1764 validate_application_retirement(&catalog, fixture.path()).expect("no application source"); 1765 fs::create_dir_all(fixture.path().join("crates/mobile_core")).expect("reintroduced source"); 1766 assert!(validate_application_retirement(&catalog, fixture.path()).is_err()); 1767 } 1768 1769 #[test] 1770 fn retirement_rejects_missing_duplicate_or_modified_package_evidence() { 1771 let fixture = tempfile::TempDir::new().expect("retirement fixture"); 1772 let path = fixture.path().join(APPLICATION_RETIREMENT); 1773 fs::create_dir_all(path.parent().expect("parent")).expect("decision directory"); 1774 let original: serde_json::Value = serde_json::from_slice( 1775 &fs::read(crate::workspace_root().join(APPLICATION_RETIREMENT)).expect("decision"), 1776 ) 1777 .expect("decision JSON"); 1778 let catalog = checked_in_catalog(); 1779 for case in 0..5 { 1780 let mut changed = original.clone(); 1781 match case { 1782 0 => { 1783 changed["package"].as_array_mut().expect("packages").pop(); 1784 } 1785 1 => { 1786 changed["package"][1] = changed["package"][0].clone(); 1787 } 1788 2 => { 1789 changed["package"][0]["former_catalog_entry"]["license"] = "MIT".into(); 1790 } 1791 3 => { 1792 changed["package"][0]["target_path"] = "../outside".into(); 1793 } 1794 _ => { 1795 changed["unknown"] = true.into(); 1796 } 1797 } 1798 fs::write(&path, serde_json::to_vec(&changed).expect("encode")) 1799 .expect("altered decision"); 1800 assert!(validate_application_retirement(&catalog, fixture.path()).is_err()); 1801 } 1802 let mut reactivated = checked_in_catalog(); 1803 reactivated 1804 .retired_packages 1805 .retain(|name| name != "radroots_mobile_core"); 1806 assert!(validate_catalog(&reactivated).is_err()); 1807 } 1808 1809 #[test] 1810 fn catalog_rejects_obsolete_and_floating_compiler_minimum() { 1811 let mut catalog = checked_in_catalog(); 1812 catalog.rust_version = "1.99.0".to_owned(); 1813 validate_catalog(&catalog).expect("exact current compiler minimum"); 1814 for minimum in ["1.97.1", "1.98.0", "stable", "1.100.0"] { 1815 catalog.rust_version = minimum.to_owned(); 1816 assert!(validate_catalog(&catalog).is_err(), "accepted {minimum}"); 1817 } 1818 } 1819 1820 #[test] 1821 fn catalog_rejects_version_visibility_license_and_retirement_drift() { 1822 let mut catalog = checked_in_catalog(); 1823 catalog 1824 .package 1825 .iter_mut() 1826 .find(|package| package.name == "xtask") 1827 .expect("xtask") 1828 .publish = true; 1829 assert!(validate_catalog(&catalog).is_err()); 1830 1831 let mut catalog = checked_in_catalog(); 1832 catalog 1833 .package 1834 .iter_mut() 1835 .find(|package| package.name == "radroots_core") 1836 .expect("core") 1837 .license = "GPL-3.0-only".to_owned(); 1838 assert!(validate_catalog(&catalog).is_err()); 1839 1840 let mut catalog = checked_in_catalog(); 1841 catalog 1842 .package 1843 .iter_mut() 1844 .find(|package| package.name == "radroots_sdk_ffi") 1845 .expect("sdk ffi") 1846 .version = "0.1.0-alpha.1".to_owned(); 1847 assert!(validate_catalog(&catalog).is_err()); 1848 1849 let mut catalog = checked_in_catalog(); 1850 catalog.retired_packages.push("radroots_core".to_owned()); 1851 assert!(validate_catalog(&catalog).is_err()); 1852 } 1853 1854 #[test] 1855 fn catalog_rejects_naming_path_and_package_count_drift() { 1856 let mut catalog = checked_in_catalog(); 1857 catalog.package_count -= 1; 1858 assert!(validate_catalog(&catalog).is_err()); 1859 1860 let mut catalog = checked_in_catalog(); 1861 catalog.package[0].name = "radroots-bad-name".to_owned(); 1862 assert!(validate_catalog(&catalog).is_err()); 1863 1864 let mut catalog = checked_in_catalog(); 1865 catalog.package[0].path = "../escape".to_owned(); 1866 assert!(validate_catalog(&catalog).is_err()); 1867 } 1868 1869 #[test] 1870 fn metadata_rejects_floating_sources_and_tier_edges() { 1871 let workspace_root = crate::workspace_root(); 1872 let catalog = checked_in_catalog(); 1873 let mut metadata = cargo_metadata(&workspace_root).expect("cargo metadata"); 1874 let dependency = metadata 1875 .packages 1876 .iter_mut() 1877 .find(|package| package.name == "radroots_event") 1878 .and_then(|package| { 1879 package 1880 .dependencies 1881 .iter_mut() 1882 .find(|dependency| dependency.name == "radroots_core") 1883 }) 1884 .expect("event to core dependency"); 1885 dependency.path = None; 1886 dependency.req = "*".to_owned(); 1887 assert!(validate_metadata(&catalog, &metadata, &workspace_root).is_err()); 1888 1889 let mut catalog = checked_in_catalog(); 1890 catalog 1891 .package 1892 .iter_mut() 1893 .find(|package| package.name == "radroots_event") 1894 .expect("event") 1895 .permitted_dependency_tiers 1896 .retain(|tier| tier != "foundation"); 1897 let metadata = cargo_metadata(&workspace_root).expect("cargo metadata"); 1898 assert!(validate_metadata(&catalog, &metadata, &workspace_root).is_err()); 1899 } 1900 }