//! `oxy mcp` (oxygen#159) end to end: an MCP client talks to the server over

//! stdio, lists its tools, reads the repository, commits by path as the

//! configured identity, and is refused what it may not do.

use serde_json::{json, Value};

use std::io::{BufRead, BufReader, Write};

use std::path::Path;

use std::process::{Command, Stdio};

fn oxy(dir: &Path, home: &Path, args: &[&str]) -> i32 {

    Command::new(env!("CARGO_BIN_EXE_oxy"))

        .arg("--plain")

        .args(args)

        .current_dir(dir)

        .env("OXY_HOME", home)

        .env("NO_COLOR", "1")

        .status()

        .unwrap()

        .code()

        .unwrap_or(-1)

}

/// Send each request in turn and collect the replies, one per request (the

/// notification gets none).

fn session(dir: &Path, home: &Path, extra: &[&str], requests: &[Value]) -> Vec<Value> {

    let mut child = Command::new(env!("CARGO_BIN_EXE_oxy"))

        .arg("mcp")

        .args(extra)

        .current_dir(dir)

        .env("OXY_HOME", home)

        .env("NO_COLOR", "1")

        .stdin(Stdio::piped())

        .stdout(Stdio::piped())

        .stderr(Stdio::null())

        .spawn()

        .unwrap();

    let mut stdin = child.stdin.take().unwrap();

    let mut stdout = BufReader::new(child.stdout.take().unwrap());

    let mut replies = vec![];

    for r in requests {

        writeln!(stdin, "{r}").unwrap();

        stdin.flush().unwrap();

        if r.get("id").is_some() {

            let mut line = String::new();

            stdout.read_line(&mut line).unwrap();

            replies.push(

                serde_json::from_str(&line).unwrap_or_else(|e| panic!("not JSON ({e}): {line}")),

            );

        }

    }

    drop(stdin);

    assert!(

        child.wait().unwrap().success(),

        "the server ends cleanly when its input does"

    );

    replies

}

fn call(id: u64, name: &str, args: Value) -> Value {

    json!({"jsonrpc": "2.0", "id": id, "method": "tools/call", "params": {"name": name, "arguments": args}})

}

#[test]

fn an_agent_reads_and_commits_through_mcp() {

    let tmp = tempfile::tempdir().unwrap();

    let home = tmp.path().join("home");

    std::fs::create_dir_all(&home).unwrap();

    let repo = tmp.path().join("repo");

    assert_eq!(oxy(tmp.path(), &home, &["init", repo.to_str().unwrap()]), 0);

    assert_eq!(

        oxy(

            &repo,

            &home,

            &[

                "identity",

                "create",

                "--name",

                "Ada",

                "--email",

                "[email protected]"

            ]

        ),

        0

    );

    assert_eq!(

        oxy(&repo, &home, &["config", "--user", "core.sign", "change"]),

        0

    );

    std::fs::write(repo.join("a.txt"), "one\n").unwrap();

    std::fs::write(repo.join("b.txt"), "two\n").unwrap();

    let r = session(

        &repo,

        &home,

        &[],

        &[

            json!({"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"protocolVersion": "2025-06-18", "capabilities": {}, "clientInfo": {"name": "test", "version": "0"}}}),

            json!({"jsonrpc": "2.0", "method": "notifications/initialized"}),

            json!({"jsonrpc": "2.0", "id": 2, "method": "tools/list"}),

            call(3, "status", json!({})),

            call(4, "commit", json!({"message": "everything"})),

            call(5, "commit", json!({"message": "Add a", "paths": ["a.txt"]})),

            call(6, "log", json!({"limit": 5})),

            call(7, "status", json!({})),

            call(8, "undo", json!({})),

            call(9, "push", json!({"force": true})),

            call(10, "cat", json!({"path": "a.txt", "change": "@"})),

        ],

    );

    let init = &r[0]["result"];

    assert_eq!(init["serverInfo"]["name"], "oxy");

    let said = init["instructions"].as_str().unwrap();

    assert!(

        said.contains("Ada"),

        "initialize says who changes are signed as: {said}"

    );

    assert!(

        said.contains("Destructive tools (undo, forced push) are off"),

        "{said}"

    );

    let names: Vec<&str> = r[1]["result"]["tools"]

        .as_array()

        .unwrap()

        .iter()

        .map(|t| t["name"].as_str().unwrap())

        .collect();

    for t in [

        "status",

        "diff",

        "log",

        "show",

        "cat",

        "blame",

        "bookmarks",

        "commit",

        "amend",

        "push",

        "pull",

        "tlog_verify",

    ] {

        assert!(names.contains(&t), "{t} is offered: {names:?}");

    }

    assert!(!names.contains(&"undo"), "undo needs --allow-destructive");

    let before = &r[2]["result"];

    assert_eq!(before["isError"], false, "{before}");

    assert!(

        before["structuredContent"].is_object(),

        "status comes back as JSON: {before}"

    );

    assert!(before["content"][0]["text"]

        .as_str()

        .unwrap()

        .contains("b.txt"));

    assert_eq!(

        r[3]["result"]["isError"], true,

        "a commit names its paths or all: {}",

        r[3]

    );

    assert!(r[3]["result"]["content"][0]["text"]

        .as_str()

        .unwrap()

        .contains("all: true"));

    assert_eq!(r[4]["result"]["isError"], false, "commit by path: {}", r[4]);

    let log = r[5]["result"]["content"][0]["text"].as_str().unwrap();

    assert!(log.contains("Add a"), "{log}");

    assert!(

        r[5]["result"]["structuredContent"].is_object(),

        "a JSON array comes wrapped: {}",

        r[5]

    );

    let after = r[6]["result"]["content"][0]["text"].as_str().unwrap();

    assert!(

        after.contains("b.txt") && !after.contains("a.txt"),

        "only a.txt went in: {after}"

    );

    assert!(

        r[7]["error"]["message"]

            .as_str()

            .unwrap()

            .contains("no tool named undo"),

        "{}",

        r[7]

    );

    assert_eq!(r[8]["result"]["isError"], true);

    assert!(r[8]["result"]["content"][0]["text"]

        .as_str()

        .unwrap()

        .contains("--allow-destructive"));

    assert_eq!(r[9]["result"]["content"][0]["text"], "one\n");

}

#[test]

fn destructive_tools_come_with_the_flag_and_a_bad_directory_is_refused() {

    let tmp = tempfile::tempdir().unwrap();

    let home = tmp.path().join("home");

    std::fs::create_dir_all(&home).unwrap();

    let repo = tmp.path().join("repo");

    assert_eq!(oxy(tmp.path(), &home, &["init", repo.to_str().unwrap()]), 0);

    let r = session(

        &repo,

        &home,

        &["--allow-destructive"],

        &[json!({"jsonrpc": "2.0", "id": 1, "method": "tools/list"})],

    );

    let undo = r[0]["result"]["tools"]

        .as_array()

        .unwrap()

        .iter()

        .find(|t| t["name"] == "undo")

        .cloned();

    assert_eq!(

        undo.expect("undo is offered")["annotations"]["destructiveHint"],

        true

    );

    let out = Command::new(env!("CARGO_BIN_EXE_oxy"))

        .args(["mcp", tmp.path().to_str().unwrap()])

        .env("OXY_HOME", &home)

        .output()

        .unwrap();

    assert!(!out.status.success());

    assert!(String::from_utf8_lossy(&out.stderr).contains("not the root of an Oxygen repository"));

}