1use std::rc::Rc;
  2use std::sync::Arc;
  3use std::{any::Any, path::Path};
  4
  5use acp_thread::AgentConnection;
  6use agent_client_protocol as acp;
  7use anyhow::{Context as _, Result};
  8use fs::Fs;
  9use gpui::{App, AppContext as _, SharedString, Task};
 10use project::agent_server_store::{AllAgentServersSettings, CODEX_NAME};
 11use settings::{SettingsStore, update_settings_file};
 12
 13use crate::{AgentServer, AgentServerDelegate, load_proxy_env};
 14
 15#[derive(Clone)]
 16pub struct Codex;
 17
 18#[cfg(test)]
 19pub(crate) mod tests {
 20    use super::*;
 21
 22    crate::common_e2e_tests!(async |_, _, _| Codex, allow_option_id = "proceed_once");
 23}
 24
 25impl AgentServer for Codex {
 26    fn telemetry_id(&self) -> &'static str {
 27        "codex"
 28    }
 29
 30    fn name(&self) -> SharedString {
 31        "Codex".into()
 32    }
 33
 34    fn logo(&self) -> ui::IconName {
 35        ui::IconName::AiOpenAi
 36    }
 37
 38    fn default_mode(&self, cx: &mut App) -> Option<acp::SessionModeId> {
 39        let settings = cx.read_global(|settings: &SettingsStore, _| {
 40            settings.get::<AllAgentServersSettings>(None).codex.clone()
 41        });
 42
 43        settings
 44            .as_ref()
 45            .and_then(|s| s.default_mode.clone().map(|m| acp::SessionModeId(m.into())))
 46    }
 47
 48    fn set_default_mode(&self, mode_id: Option<acp::SessionModeId>, fs: Arc<dyn Fs>, cx: &mut App) {
 49        update_settings_file(fs, cx, |settings, _| {
 50            settings
 51                .agent_servers
 52                .get_or_insert_default()
 53                .codex
 54                .get_or_insert_default()
 55                .default_mode = mode_id.map(|m| m.to_string())
 56        });
 57    }
 58
 59    fn connect(
 60        &self,
 61        root_dir: Option<&Path>,
 62        delegate: AgentServerDelegate,
 63        cx: &mut App,
 64    ) -> Task<Result<(Rc<dyn AgentConnection>, Option<task::SpawnInTerminal>)>> {
 65        let name = self.name();
 66        let root_dir = root_dir.map(|root_dir| root_dir.to_string_lossy().into_owned());
 67        let is_remote = delegate.project.read(cx).is_via_remote_server();
 68        let store = delegate.store.downgrade();
 69        let extra_env = load_proxy_env(cx);
 70        let default_mode = self.default_mode(cx);
 71
 72        cx.spawn(async move |cx| {
 73            let (command, root_dir, login) = store
 74                .update(cx, |store, cx| {
 75                    let agent = store
 76                        .get_external_agent(&CODEX_NAME.into())
 77                        .context("Codex is not registered")?;
 78                    anyhow::Ok(agent.get_command(
 79                        root_dir.as_deref(),
 80                        extra_env,
 81                        delegate.status_tx,
 82                        delegate.new_version_available,
 83                        &mut cx.to_async(),
 84                    ))
 85                })??
 86                .await?;
 87
 88            let connection = crate::acp::connect(
 89                name,
 90                command,
 91                root_dir.as_ref(),
 92                default_mode,
 93                is_remote,
 94                cx,
 95            )
 96            .await?;
 97            Ok((connection, login))
 98        })
 99    }
100
101    fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
102        self
103    }
104}