app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

runtime_ownership.rs (13494B)


      1 //! Runtime input ownership data. Output declarations never exempt source from audits.
      2 use serde::Deserialize;
      3 use std::collections::BTreeSet;
      4 
      5 pub const MAP_PATH: &str = "config/repository/runtime-ownership.v1.json";
      6 
      7 #[derive(Clone, Copy, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd)]
      8 #[serde(rename_all = "snake_case")]
      9 pub enum Owner {
     10     Native,
     11     Web,
     12     Interop,
     13     Governance,
     14 }
     15 
     16 #[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
     17 #[serde(rename_all = "snake_case")]
     18 enum Kind {
     19     Exact,
     20     Prefix,
     21 }
     22 
     23 #[derive(Debug, Deserialize)]
     24 #[serde(deny_unknown_fields)]
     25 struct Rule {
     26     path: String,
     27     kind: Kind,
     28     owners: Vec<Owner>,
     29 }
     30 
     31 #[derive(Debug, Deserialize)]
     32 #[serde(deny_unknown_fields)]
     33 pub struct OwnershipMap {
     34     schema_version: u32,
     35     owners: Vec<Owner>,
     36     inputs: Vec<Rule>,
     37     outputs: Vec<Rule>,
     38 }
     39 
     40 #[derive(Debug, Eq, PartialEq)]
     41 pub struct Classification {
     42     pub owners: Vec<Owner>,
     43     pub reason: Option<String>,
     44 }
     45 
     46 fn validate_path(path: &str) -> Result<(), String> {
     47     if path.is_empty()
     48         || path
     49             .chars()
     50             .any(|c| c.is_control() || matches!(c, '\\' | ':' | '%' | '*' | '?'))
     51         || path.split('/').any(|part| matches!(part, "" | "." | ".."))
     52     {
     53         return Err(format!(
     54             "invalid repository-relative ownership path: {path:?}"
     55         ));
     56     }
     57     Ok(())
     58 }
     59 
     60 // Ownership declarations forbid glob syntax. Inventory paths are literal file
     61 // identities: brackets in Svelte routes are never interpreted as patterns.
     62 fn validate_declaration_path(path: &str) -> Result<(), String> {
     63     validate_path(path)?;
     64     if path.contains(['[', ']']) {
     65         return Err(format!(
     66             "invalid repository-relative ownership declaration: {path:?}"
     67         ));
     68     }
     69     Ok(())
     70 }
     71 
     72 impl Rule {
     73     fn matches(&self, path: &str) -> bool {
     74         path == self.path
     75             || (self.kind == Kind::Prefix
     76                 && path
     77                     .strip_prefix(&self.path)
     78                     .is_some_and(|rest| rest.starts_with('/')))
     79     }
     80 }
     81 
     82 impl OwnershipMap {
     83     pub fn parse(source: &str) -> Result<Self, String> {
     84         // No escaped path aliases, including unicode-escaped separators or field names.
     85         if source.contains('\\') {
     86             return Err("ownership JSON escapes are not allowed".to_owned());
     87         }
     88         let map: Self = serde_json::from_str(source)
     89             .map_err(|error| format!("invalid ownership JSON: {error}"))?;
     90         if map.schema_version != 1 {
     91             return Err("unsupported ownership schema version".to_owned());
     92         }
     93         if map.owners.len() != 4 || map.owners.iter().copied().collect::<BTreeSet<_>>().len() != 4 {
     94             return Err(
     95                 "ownership map must declare each of the four owners exactly once".to_owned(),
     96             );
     97         }
     98         for rules in [&map.inputs, &map.outputs] {
     99             if rules.is_empty() {
    100                 return Err("ownership rule list is empty".to_owned());
    101             }
    102             for (index, rule) in rules.iter().enumerate() {
    103                 validate_declaration_path(&rule.path)?;
    104                 if rule.owners.is_empty()
    105                     || rule.owners.iter().copied().collect::<BTreeSet<_>>().len()
    106                         != rule.owners.len()
    107                 {
    108                     return Err(format!("empty or duplicate owners for {}", rule.path));
    109                 }
    110                 for previous in &rules[..index] {
    111                     if previous.matches(&rule.path) || rule.matches(&previous.path) {
    112                         return Err(format!(
    113                             "overlapping ownership declarations: {} and {}",
    114                             previous.path, rule.path
    115                         ));
    116                     }
    117                 }
    118             }
    119         }
    120         Ok(map)
    121     }
    122 
    123     pub fn classify(&self, path: &str) -> Result<Classification, String> {
    124         validate_path(path)?;
    125         match self.inputs.iter().find(|rule| rule.matches(path)) {
    126             Some(rule) => Ok(Classification {
    127                 owners: rule.owners.clone(),
    128                 reason: None,
    129             }),
    130             None => Ok(Classification {
    131                 owners: self.owners.clone(),
    132                 reason: Some(format!(
    133                     "unclassified input {path}: conservatively select all potential owners"
    134                 )),
    135             }),
    136         }
    137     }
    138 
    139     pub fn validate_native_inputs(&self, paths: &[String]) -> Result<(), String> {
    140         for required in required_native_inputs() {
    141             if !paths.iter().any(|path| path == required) {
    142                 return Err(format!("required native input is missing: {required}"));
    143             }
    144         }
    145         for path in paths {
    146             if required_native_inputs().contains(&path.as_str())
    147                 || [
    148                     "app/",
    149                     "core/",
    150                     "gradle/",
    151                     "build-logic/",
    152                     "tools/design_catalog/",
    153                     "tools/xtask/",
    154                 ]
    155                 .iter()
    156                 .any(|prefix| path.starts_with(prefix))
    157             {
    158                 let classification = self.classify(path)?;
    159                 if classification.reason.is_some()
    160                     || !classification.owners.contains(&Owner::Native)
    161                 {
    162                     return Err(format!("native input has no explicit native owner: {path}"));
    163                 }
    164             }
    165         }
    166         Ok(())
    167     }
    168 }
    169 
    170 fn required_native_inputs() -> Vec<&'static str> {
    171     vec![
    172         "build.gradle.kts",
    173         "settings.gradle.kts",
    174         "gradle.properties",
    175         "gradlew",
    176         "gradlew.bat",
    177         "radroots.lib.source-lock.v1.toml",
    178         "config/design/harvestcircle-v1.toml",
    179         "config/detekt/detekt.yml",
    180         "config/licenses/allowed-licenses.json",
    181         "config/product/harvestcircle-v1.properties",
    182         "config/verification/lanes-v3.properties",
    183         "contracts/release/harvestcircle-artifact-contract.v3.json",
    184         "contracts/rshr-201-step-gates.v1.json",
    185         "tools/rshr_201_step_gate.py",
    186         "tools/run-linux-x86_64-development-check.sh",
    187         "tools/test-build-logic-stability.sh",
    188         "tools/test-build-modes.sh",
    189         "tools/verify-storage-api.sh",
    190         "core/Cargo.toml",
    191         "core/Cargo.lock",
    192         "core/rust-toolchain.toml",
    193         "core/deny.toml",
    194         "core/provenance/harvestcircle-v1.toml",
    195         "tools/xtask/Cargo.toml",
    196         "tools/xtask/Cargo.lock",
    197         "gradle/libs.versions.toml",
    198         "gradle/verification-metadata.xml",
    199         "gradle/wrapper/gradle-wrapper.jar",
    200         "gradle/wrapper/gradle-wrapper.properties",
    201         "build-logic/settings.gradle.kts",
    202         "build-logic/contracts/build.gradle.kts",
    203         "build-logic/plugins/build.gradle.kts",
    204         "app/design_system/build.gradle.kts",
    205         "app/shared/build.gradle.kts",
    206         "app/desktop/build.gradle.kts",
    207         "tools/design_catalog/build.gradle.kts",
    208         "Makefile",
    209     ]
    210 }
    211 
    212 #[cfg(test)]
    213 mod tests {
    214     use super::*;
    215     const MAP: &str = include_str!("../../../config/repository/runtime-ownership.v1.json");
    216 
    217     #[test]
    218     fn rejects_malformed_unknown_and_duplicate_json() {
    219         for source in [
    220             "{",
    221             &MAP.replace("\"schema_version\": 1", "\"schema_version\": 2"),
    222             &MAP.replace(
    223                 "\"schema_version\": 1",
    224                 "\"schema_version\": 1, \"extra\": true",
    225             ),
    226             &MAP.replace(
    227                 "\"schema_version\": 1",
    228                 "\"schema_version\": 1, \"schema_version\": 1",
    229             ),
    230             &MAP.replace("\"native\"", "\"invented\""),
    231         ] {
    232             assert!(OwnershipMap::parse(source).is_err(), "accepted {source}");
    233         }
    234     }
    235 
    236     #[test]
    237     fn rejects_traversal_absolutes_backslashes_and_escapes() {
    238         for path in [
    239             "../app",
    240             "/app",
    241             "app/../core",
    242             "app/./src",
    243             "app//src",
    244             "app/",
    245             "C:/app",
    246             "app\\src",
    247             "app/*",
    248             "app/%2e%2e",
    249             "app\\u002fcore",
    250         ] {
    251             let source = MAP.replacen("\"app\"", &format!("\"{path}\""), 1);
    252             assert!(OwnershipMap::parse(&source).is_err(), "accepted {path}");
    253         }
    254     }
    255 
    256     #[test]
    257     fn rejects_ambiguous_declarations_and_accepts_explicit_shared_owners() {
    258         let map = OwnershipMap::parse(MAP).unwrap();
    259         let shared = map.classify("tools/xtask/Cargo.lock").unwrap();
    260         assert!(shared.owners.contains(&Owner::Native));
    261         assert!(shared.owners.contains(&Owner::Governance));
    262         let rule = r#"{"path":"app/src", "kind":"prefix", "owners":["web"]}"#;
    263         let source = MAP.replacen("\"inputs\": [", &format!("\"inputs\": [{rule},"), 1);
    264         assert!(OwnershipMap::parse(&source).is_err());
    265         assert!(
    266             OwnershipMap::parse(&MAP.replacen(
    267                 "\"owners\": [\n        \"native\"",
    268                 "\"owners\": [\n        \"native\", \"native\"",
    269                 1
    270             ))
    271             .is_err()
    272         );
    273     }
    274 
    275     #[test]
    276     fn prefix_boundaries_and_unknown_inputs_widen_with_reason() {
    277         let map = OwnershipMap::parse(MAP).unwrap();
    278         assert_eq!(
    279             map.classify("app/src/test.kt").unwrap().owners,
    280             vec![Owner::Native]
    281         );
    282         for path in [
    283             "application/src/test.kt",
    284             "config/new.json",
    285             "tools/new.rs",
    286             "contracts/new.json",
    287             "new_runtime/main.rs",
    288         ] {
    289             let result = map.classify(path).unwrap();
    290             assert_eq!(result.owners.len(), 4);
    291             assert!(result.reason.unwrap().contains(path));
    292         }
    293         assert!(map.classify("../app").is_err());
    294         assert!(
    295             map.classify("web/src/main.ts")
    296                 .unwrap()
    297                 .owners
    298                 .contains(&Owner::Web)
    299         );
    300         assert!(
    301             map.classify("contracts/interop/food.json")
    302                 .unwrap()
    303                 .owners
    304                 .contains(&Owner::Interop)
    305         );
    306     }
    307 
    308     #[test]
    309     fn current_repository_native_inputs_are_explicitly_covered() {
    310         let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../..");
    311         let inventory = crate::Inventory::load(&root).unwrap();
    312         let mut findings = Vec::new();
    313         crate::runtime_ownership_audit(&root, &inventory, &mut findings);
    314         assert!(findings.is_empty(), "{findings:?}");
    315     }
    316 
    317     #[test]
    318     fn outputs_do_not_exempt_tracked_inputs_and_exact_paths_do_not_expand() {
    319         let map = OwnershipMap::parse(MAP).unwrap();
    320         let output = map.classify("core/target/tracked-malicious.rs").unwrap();
    321         assert_eq!(output.owners, vec![Owner::Native]);
    322         assert!(map.classify("gradlew-extra").unwrap().reason.is_some());
    323         assert!(
    324             map.classify("config/design/harvestcircle-v1.toml/child")
    325                 .unwrap()
    326                 .reason
    327                 .is_some()
    328         );
    329     }
    330 
    331     #[test]
    332     fn literal_svelte_route_inputs_are_classified_without_glob_declarations() {
    333         let map = OwnershipMap::parse(MAP).unwrap();
    334         for path in [
    335             "web/src/routes/messages/[conversationId=local_id]/+page.svelte",
    336             "web/src/routes/my/listings/[listingId=local_id]/+page.svelte",
    337             "web/src/routes/[id]/+page.svelte",
    338         ] {
    339             let result = map.classify(path).unwrap();
    340             assert_eq!(result.owners, vec![Owner::Web]);
    341             assert!(result.reason.is_none());
    342         }
    343         let literal = "new_runtime/[literal].rs";
    344         let unknown = map.classify(literal).unwrap();
    345         assert_eq!(unknown.owners.len(), 4);
    346         assert!(unknown.reason.unwrap().contains(literal));
    347         for declaration in ["app/[id]", "app/[[optional]]", "app/[a-z]"] {
    348             let source = MAP.replacen("\"app\"", &format!("\"{declaration}\""), 1);
    349             assert!(
    350                 OwnershipMap::parse(&source).is_err(),
    351                 "accepted {declaration}"
    352             );
    353         }
    354         for hostile in [
    355             "web/../[id]",
    356             "web//[id]",
    357             "/web/[id]",
    358             "web/[id]\\child",
    359             "web/[id]%2fchild",
    360             "web/[id]*",
    361             "web/[id]?",
    362         ] {
    363             assert!(map.classify(hostile).is_err(), "accepted {hostile}");
    364         }
    365     }
    366 
    367     #[test]
    368     fn rejects_uncovered_and_missing_native_inputs() {
    369         let map = OwnershipMap::parse(MAP).unwrap();
    370         let paths = required_native_inputs()
    371             .into_iter()
    372             .map(str::to_owned)
    373             .collect::<Vec<_>>();
    374         assert!(map.validate_native_inputs(&paths).is_ok());
    375         for missing in [
    376             "core/Cargo.lock",
    377             "tools/xtask/Cargo.lock",
    378             "core/rust-toolchain.toml",
    379         ] {
    380             let partial = paths
    381                 .iter()
    382                 .filter(|path| path.as_str() != missing)
    383                 .cloned()
    384                 .collect::<Vec<_>>();
    385             assert!(
    386                 map.validate_native_inputs(&partial).is_err(),
    387                 "accepted missing {missing}"
    388             );
    389         }
    390         let wrong = OwnershipMap::parse(&MAP.replace("\"core\",", "\"elsewhere\",")).unwrap();
    391         assert!(wrong.validate_native_inputs(&paths).is_err());
    392     }
    393 }