GitCorner

Code

ossartcraftcraftanything🌐
642d5a256791
use craft_anything_setup::{ActionKind, CheckStatus, DoctorRequest, Host, Os, PlanRequest, apply, clients, config, doctor, plan, uninstall};
use serde_json::json;

fn cli() -> Vec<String> {
    vec!["/b/craft-anything-cli".to_string(), "mcp".to_string()]
}

/// Setup writes into an existing inline `mcp_servers` table (empty or with sibling servers), keeps
/// comments and CRLF endings, stays idempotent, and removes cleanly.
#[test]
fn inline_mcp_servers_table_accepts_our_entry() {
    let all = clients(&Host::with_home("/h"));
    for id in ["codex", "grok_build"] {
        let client = all.iter().find(|c| c.id == id).unwrap();
        let entry = client.desired_entry(&cli());

        for (base, has_other) in [
            ("model = \"x\"\nmcp_servers = {}\n", false),
            ("model = \"x\"\nmcp_servers = { other = { command = \"o\" } } # theirs\n", true),
            ("model = \"x\"\r\nmcp_servers = { other = { command = \"o\" } } # theirs\r\n", true),
        ] {
            let updated = config::set_entry(client, base, &entry).unwrap_or_else(|e| panic!("{id} on {base:?}: {e}"));
            assert_eq!(config::read_entry(client, &updated).unwrap(), Some(entry.clone()), "{id}: {updated}");
            assert_eq!(config::set_entry(client, &updated, &entry).unwrap(), updated, "{id} should be idempotent");
            if base.contains("\r\n") {
                assert_eq!(updated.matches('\n').count(), updated.matches("\r\n").count(), "{id}: {updated:?}");
            }
            if has_other {
                let parsed = config::parse(client, &updated).unwrap();
                assert_eq!(parsed["mcp_servers"]["other"]["command"], "o", "{id}: {updated}");
                assert!(updated.contains("# theirs"), "{id}: {updated}");
            }
            let removed = config::remove_entry(client, &updated).unwrap().expect("our entry can be removed");
            assert_eq!(config::read_entry(client, &removed).unwrap(), None, "{id}: {removed}");
            if has_other {
                assert_eq!(config::parse(client, &removed).unwrap()["mcp_servers"]["other"]["command"], "o");
                assert!(removed.contains("# theirs"), "{id}: {removed}");
            }
        }
    }
}

/// An owned Codex entry inside an inline `mcp_servers` table keeps the person's own flags and
/// sibling servers, while a foreign entry is replaced whole.
#[test]
fn inline_mcp_servers_table_merges_owned_and_replaces_foreign_entries() {
    let all = clients(&Host::with_home("/h"));
    let codex = all.iter().find(|c| c.id == "codex").unwrap();
    let entry = codex.desired_entry(&cli());

    let owned = "mcp_servers = { craft-anything = { command = \"/old/craft-anything-cli\", args = [\"mcp\"], enabled = false, disabled_tools = [\"x\"] }, other = { command = \"o\" } }\n";
    let merged = config::set_entry(codex, owned, &entry).unwrap();
    let got = config::read_entry(codex, &merged).unwrap().unwrap();
    assert_eq!(got["command"], "/b/craft-anything-cli");
    assert_eq!(got["enabled"], false);
    assert_eq!(got["disabled_tools"][0], "x");
    assert_eq!(got["tools"]["rebuild_start"]["approval_mode"], "approve");
    assert_eq!(config::parse(codex, &merged).unwrap()["mcp_servers"]["other"]["command"], "o");
    assert_eq!(config::set_entry(codex, &merged, &entry).unwrap(), merged);

    let foreign = "mcp_servers = { craft-anything = { url = \"https://example.test/mcp\" }, other = { command = \"o\" } }\n";
    let replaced = config::set_entry(codex, foreign, &entry).unwrap();
    let got = config::read_entry(codex, &replaced).unwrap().unwrap();
    assert!(got.get("url").is_none(), "{got}");
    assert_eq!(got, entry);
    assert_eq!(config::parse(codex, &replaced).unwrap()["mcp_servers"]["other"]["command"], "o");
}

/// Non-table `mcp_servers` values are still refused, while a foreign inline entry inside a regular
/// `[mcp_servers]` table continues to be replaced cleanly.
#[test]
fn non_table_mcp_servers_values_are_still_refused() {
    let all = clients(&Host::with_home("/h"));
    let codex = all.iter().find(|c| c.id == "codex").unwrap();
    let entry = codex.desired_entry(&cli());

    for bad in ["mcp_servers = \"nope\"\n", "mcp_servers = 42\n", "mcp_servers = []\n"] {
        let err = config::set_entry(codex, bad, &entry).unwrap_err();
        assert!(err.contains("is not a table"), "{bad}: {err}");
    }

    let regular_foreign = "[mcp_servers]\ncraft-anything = { url = \"https://example.test/mcp\" }\nother = { command = \"o\" }\n";
    let replaced = config::set_entry(codex, regular_foreign, &entry).unwrap();
    let got = config::read_entry(codex, &replaced).unwrap().unwrap();
    assert!(got.get("url").is_none(), "{got}");
    assert_eq!(got, entry);
    assert_eq!(config::parse(codex, &replaced).unwrap()["mcp_servers"]["other"]["command"], "o");
}

/// End-to-end `plan`, `apply`, `doctor`, and `uninstall` succeed when Codex uses an inline
/// `mcp_servers` table.
#[test]
fn setup_plan_apply_doctor_and_uninstall_work_with_inline_mcp_servers() {
    let dir = tempfile::tempdir().unwrap();
    let home = dir.path().to_path_buf();
    let mut host = Host::with_home(&home);
    host.os = Os::Linux;
    std::fs::create_dir_all(home.join(".codex")).unwrap();
    let initial = "# Codex config\nmcp_servers = { other = { command = \"other-server\" } } # theirs\n";
    std::fs::write(home.join(".codex/config.toml"), initial).unwrap();
    let bin = home.join("bin/craft-anything-cli");
    std::fs::create_dir_all(bin.parent().unwrap()).unwrap();
    std::fs::write(&bin, "#!/bin/sh\n").unwrap();

    let req = PlanRequest { clients: vec!["codex".into()], all_detected: false, command: vec![bin.display().to_string(), "mcp".into()], include_skill: false };
    let p = plan(&host, &req).unwrap();
    assert!(!p.blocked, "{p:?}");
    assert_eq!(p.actions[0].action, ActionKind::Update);
    assert_eq!(apply(&p).status, "configured");
    assert_eq!(plan(&host, &req).unwrap().change_count(), 0);

    let rep = doctor(&host, &DoctorRequest { cli_path: Some(bin), self_test: false, engines: false, ..Default::default() });
    assert_eq!(rep.checks.iter().find(|c| c.name == "registration:codex").unwrap().status, CheckStatus::Ok);

    let u = uninstall(&host);
    assert_eq!(u.status, "removed", "{u:?}");
    let after = std::fs::read_to_string(home.join(".codex/config.toml")).unwrap();
    let v: serde_json::Value = config::parse(clients(&host).iter().find(|c| c.id == "codex").unwrap(), &after).unwrap();
    assert_eq!(v["mcp_servers"], json!({"other": {"command": "other-server"}}));
    assert!(after.contains("# theirs"));
}