use crate::stdio_agent_server::{StdioAgentServer, find_bin_in_path};use crate::{AgentServerCommand, AgentServerVersion};use anyhow::{Context as _, Result};use gpui::{AsyncApp, Entity};use project::Project;use settings::SettingsStore; use crate::AllAgentServersSettings; #[derive(Clone)]pub struct Codex; const ACP_ARG: &str = "acp"; impl StdioAgentServer for Codex {    fn name(&self) -> &'static str {        "Codex"    }     fn empty_state_headline(&self) -> &'static str {        "Welcome to Codex"    }     fn empty_state_message(&self) -> &'static str {        "Ask questions, edit files, run commands.\nBe specific for the best results."    }     fn logo(&self) -> ui::IconName {        ui::IconName::AiOpenAi    }     async fn command(        &self,        project: &Entity<Project>,        cx: &mut AsyncApp,    ) -> Result<AgentServerCommand> {        let custom_command = cx.read_global(|settings: &SettingsStore, _| {            let settings = settings.get::<AllAgentServersSettings>(None);            settings                .codex                .as_ref()                .map(|codex_settings| AgentServerCommand {                    path: codex_settings.command.path.clone(),                    args: codex_settings                        .command                        .args                        .iter()                        .cloned()                        .chain(std::iter::once(ACP_ARG.into()))                        .collect(),                    env: codex_settings.command.env.clone(),                })        })?;         if let Some(custom_command) = custom_command {            return Ok(custom_command);        }         if let Some(path) = find_bin_in_path("codex", project, cx).await {            return Ok(AgentServerCommand {                path,                args: vec![ACP_ARG.into()],                env: None,            });        }         todo!()        // let (fs, node_runtime) = project.update(cx, |project, _| {        //     (project.fs().clone(), project.node_runtime().cloned())        // })?;        // let node_runtime = node_runtime.context("codex not found on path")?;         // let directory = ::paths::agent_servers_dir().join("codex");        // fs.create_dir(&directory).await?;        // node_runtime        //     .npm_install_packages(&directory, &[("@google/gemini-cli", "latest")])        //     .await?;        // let path = directory.join("node_modules/.bin/gemini");         // Ok(AgentServerCommand {        //     path,        //     args: vec![ACP_ARG.into()],        //     env: None,        // })    }     async fn version(&self, command: &AgentServerCommand) -> Result<AgentServerVersion> {        let version_fut = util::command::new_smol_command(&command.path)            .args(command.args.iter())            .arg("--version")            .kill_on_drop(true)            .output();         let help_fut = util::command::new_smol_command(&command.path)            .args(command.args.iter())            .arg("--help")            .kill_on_drop(true)            .output();         let (version_output, help_output) = futures::future::join(version_fut, help_fut).await;         let current_version = String::from_utf8(version_output?.stdout)?;        let supported = String::from_utf8(help_output?.stdout)?.contains(ACP_ARG);         if supported {            Ok(AgentServerVersion::Supported)        } else {            Ok(AgentServerVersion::Unsupported {                error_message: format!(                    "Your installed version of Codex {} doesn't support the Agentic Coding Protocol (ACP).",                    current_version                ).into(),                upgrade_message: "Upgrade Codex to Latest".into(),                upgrade_command: "npm install -g @openai/codex@latest".into(),            })        }    }}