use serde::Deserialize;
use std::collections::HashMap;
use std::fs;
use std::path::{Path, PathBuf};
use crate::paths;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AliasProvider {
Anthropic,
Codex,
Kimi,
}
impl AliasProvider {
pub fn as_str(&self) -> &str {
match self {
AliasProvider::Anthropic => "anthropic",
AliasProvider::Codex => "codex",
AliasProvider::Kimi => "kimi",
}
}
}
#[derive(Debug, Clone)]
pub struct LoadedConfig {
pub port: u16,
pub alias_provider: AliasProvider,
pub log_verbose: bool,
pub log_stderr: bool,
pub config_dir: PathBuf,
}
#[derive(Deserialize)]
struct FileConfig {
pub port: Option<u16>,
#[serde(rename = "aliasProvider")]
pub alias_provider: Option<String>,
pub log: Option<FileLog>,
pub kimi: Option<KimiConfig>,
pub codex: Option<CodexConfig>,
pub cursor: Option<CursorConfig>,
pub grok: Option<GrokConfig>,
}
#[derive(Deserialize, Clone)]
struct CodexConfig {
#[serde(rename = "baseUrl")]
pub base_url: Option<String>,
#[serde(rename = "originator")]
pub originator: Option<String>,
#[serde(rename = "userAgent")]
pub user_agent: Option<String>,
#[serde(rename = "previousResponseId")]
pub previous_response_id: Option<bool>,
#[serde(rename = "serviceTier")]
pub service_tier: Option<String>,
#[serde(rename = "reasoningSummary")]
pub reasoning_summary: Option<String>,
#[serde(rename = "effort")]
pub effort: Option<String>,
#[serde(rename = "model")]
pub model: Option<String>,
pub transport: Option<String>,
}
#[derive(Deserialize, Clone)]
struct CursorConfig {
#[serde(rename = "baseUrl")]
pub base_url: Option<String>,
#[serde(rename = "clientVersion")]
pub client_version: Option<String>,
#[serde(rename = "agentBundle")]
pub agent_bundle: Option<String>,
}
#[derive(Deserialize, Clone)]
struct KimiConfig {
#[serde(rename = "userAgent")]
pub user_agent: Option<String>,
#[serde(rename = "oauthHost")]
pub oauth_host: Option<String>,
#[serde(rename = "baseUrl")]
pub base_url: Option<String>,
}
#[derive(Deserialize, Clone)]
struct GrokConfig {
#[serde(rename = "baseUrl")]
pub base_url: Option<String>,
#[serde(rename = "clientVersion")]
pub client_version: Option<String>,
}
#[derive(Deserialize)]
struct FileLog {
pub verbose: Option<bool>,
pub stderr: Option<bool>,
}
fn parse_alias(raw: &str) -> Option<AliasProvider> {
match raw {
"anthropic" => Some(AliasProvider::Anthropic),
"codex" => Some(AliasProvider::Codex),
"kimi" => Some(AliasProvider::Kimi),
_ => None,
}
}
fn read_file_config(config_dir: &Path) -> Option<FileConfig> {
let path = config_dir.join("config.json");
let raw = fs::read_to_string(path).ok()?;
serde_json::from_str(&raw).ok()
}
pub fn load_config() -> LoadedConfig {
let config_dir = paths::config_dir();
let file = read_file_config(&config_dir);
let env: HashMap<_, _> = std::env::vars().collect();
let mut out = LoadedConfig {
port: 18765,
alias_provider: AliasProvider::Anthropic,
log_verbose: false,
log_stderr: false,
config_dir: config_dir.clone(),
};
if let Some(raw) = env.get("CCP_ALIAS_PROVIDER") {
if let Some(alias) = parse_alias(raw) {
out.alias_provider = alias;
}
} else if let Some(alias_provider) = file
.as_ref()
.and_then(|f| f.alias_provider.as_deref())
.and_then(parse_alias)
{
out.alias_provider = alias_provider;
}
if let Some(raw) = env.get("PORT") {
if let Ok(port) = raw.parse::<u16>() {
out.port = port;
}
} else if let Some(port) = file.as_ref().and_then(|f| f.port) {
out.port = port;
}
if env.contains_key("CCP_LOG_VERBOSE") {
out.log_verbose = true;
} else if let Some(value) = file
.as_ref()
.and_then(|f| f.log.as_ref().and_then(|v| v.verbose))
{
out.log_verbose = value;
}
if env.contains_key("CCP_LOG_STDERR") {
out.log_stderr = true;
} else if let Some(value) = file
.as_ref()
.and_then(|f| f.log.as_ref().and_then(|v| v.stderr))
{
out.log_stderr = value;
}
out
}
pub fn config_path() -> PathBuf {
paths::config_dir().join("config.json")
}
pub fn port() -> u16 {
load_config().port
}
pub fn alias_provider() -> AliasProvider {
load_config().alias_provider
}
pub fn log_verbose() -> bool {
load_config().log_verbose
}
pub fn log_stderr() -> bool {
load_config().log_stderr
}
pub fn config_override_summary_lines(cfg: &LoadedConfig) -> Vec<String> {
let file = read_file_config(&cfg.config_dir);
let env: HashMap<_, _> = std::env::vars().collect();
let mut out = Vec::new();
if env.contains_key("PORT") {
out.push("port (env)".to_string());
}
if env.contains_key("CCP_ALIAS_PROVIDER") {
out.push("aliasProvider (env)".to_string());
}
if env.contains_key("CCP_LOG_VERBOSE") {
out.push("log.verbose (env)".to_string());
}
if env.contains_key("CCP_LOG_STDERR") {
out.push("log.stderr (env)".to_string());
}
if env.contains_key("CCP_KIMI_OAUTH_HOST") {
out.push("kimi.oauthHost (env)".to_string());
}
if env.contains_key("CCP_KIMI_BASE_URL") {
out.push("kimi.baseUrl (env)".to_string());
}
if env.contains_key("CCP_CURSOR_BASE_URL") {
out.push("cursor.baseUrl (env)".to_string());
}
if env.contains_key("CCP_CURSOR_CLIENT_VERSION") {
out.push("cursor.clientVersion (env)".to_string());
}
if env.contains_key("CCP_KIMI_USER_AGENT") {
out.push("kimi.userAgent (env)".to_string());
}
if env.contains_key("CCP_GROK_BASE_URL") {
out.push("grok.baseUrl (env)".to_string());
}
if env.contains_key("CCP_GROK_CLIENT_VERSION") {
out.push("grok.clientVersion (env)".to_string());
}
if env
.get("CCP_CODEX_REASONING_SUMMARY")
.is_some_and(|raw| !raw.is_empty())
{
out.push("CCP_CODEX_REASONING_SUMMARY (env)".to_string());
}
if let Some(file_cfg) = file {
if let Some(p) = file_cfg.port {
out.push(format!("port: {p}"));
}
if let Some(alias) = file_cfg.alias_provider {
out.push(format!("aliasProvider: {alias}"));
}
if let Some(log) = file_cfg.log {
if let Some(v) = log.verbose {
out.push(format!("log.verbose: {v}"));
}
if let Some(v) = log.stderr {
out.push(format!("log.stderr: {v}"));
}
}
if let Some(codex) = file_cfg.codex
&& let Some(summary) = codex.reasoning_summary
&& !summary.is_empty()
{
out.push("codex.reasoningSummary (config)".to_string());
}
}
out
}
pub fn grok_base_url() -> String {
let env: HashMap<_, _> = std::env::vars().collect();
if let Some(raw) = env.get("CCP_GROK_BASE_URL") {
return raw.clone();
}
if let Some(grok) = read_file_config(&paths::config_dir()).and_then(|f| f.grok)
&& let Some(url) = grok.base_url
{
return url;
}
"https://cli-chat-proxy.grok.com/v1".to_string()
}
pub fn grok_client_version() -> String {
let env: HashMap<_, _> = std::env::vars().collect();
if let Some(raw) = env.get("CCP_GROK_CLIENT_VERSION") {
return raw.clone();
}
if let Some(grok) = read_file_config(&paths::config_dir()).and_then(|f| f.grok)
&& let Some(version) = grok.client_version
{
return version;
}
"0.2.93".to_string()
}
pub fn is_verbose() -> bool {
log_verbose()
}
pub fn anthropic_base_url() -> String {
let env: HashMap<_, _> = std::env::vars().collect();
if let Some(raw) = env.get("CCP_ANTHROPIC_BASE_URL") {
return raw.clone();
}
"https://api.anthropic.com".to_string()
}
pub fn kimi_oauth_host() -> String {
let env: HashMap<_, _> = std::env::vars().collect();
if let Some(raw) = env.get("CCP_KIMI_OAUTH_HOST") {
return raw.clone();
}
let config_dir = paths::config_dir();
if let Some(file) = read_file_config(&config_dir)
&& let Some(kimi) = file.kimi
&& let Some(host) = kimi.oauth_host
{
return host;
}
"https://auth.kimi.com".to_string()
}
pub fn kimi_base_url() -> String {
let env: HashMap<_, _> = std::env::vars().collect();
if let Some(raw) = env.get("CCP_KIMI_BASE_URL") {
return raw.clone();
}
let config_dir = paths::config_dir();
if let Some(file) = read_file_config(&config_dir)
&& let Some(kimi) = file.kimi
&& let Some(url) = kimi.base_url
{
return url;
}
"https://api.kimi.com/coding/v1".to_string()
}
pub fn kimi_user_agent(default: &str) -> String {
let env: HashMap<_, _> = std::env::vars().collect();
if let Some(raw) = env.get("CCP_KIMI_USER_AGENT") {
return raw.clone();
}
if let Some(raw) = env.get("CCP_USER_AGENT") {
return raw.clone();
}
let config_dir = paths::config_dir();
if let Some(file) = read_file_config(&config_dir)
&& let Some(kimi) = file.kimi
&& let Some(ua) = kimi.user_agent
{
return ua;
}
default.to_string()
}
pub fn codex_base_url(default: &str) -> String {
let env: HashMap<_, _> = std::env::vars().collect();
if let Some(raw) = env.get("CCP_CODEX_BASE_URL") {
return raw.clone();
}
if let Some(raw) = env.get("CLAUDE_CODE_PROXY_CODEX_BASE_URL") {
return raw.clone();
}
let config_dir = paths::config_dir();
if let Some(file) = read_file_config(&config_dir)
&& let Some(codex) = file.codex
&& let Some(url) = codex.base_url
{
return url;
}
default.to_string()
}
pub fn codex_originator(default: &str) -> String {
let env: HashMap<_, _> = std::env::vars().collect();
if let Some(raw) = env.get("CCP_CODEX_ORIGINATOR") {
return raw.clone();
}
let config_dir = paths::config_dir();
if let Some(file) = read_file_config(&config_dir)
&& let Some(codex) = file.codex
&& let Some(val) = codex.originator
{
return val;
}
default.to_string()
}
pub fn codex_user_agent(default: &str) -> String {
let env: HashMap<_, _> = std::env::vars().collect();
if let Some(raw) = env.get("CCP_CODEX_USER_AGENT") {
return raw.clone();
}
if let Some(raw) = env.get("CCP_USER_AGENT") {
return raw.clone();
}
let config_dir = paths::config_dir();
if let Some(file) = read_file_config(&config_dir)
&& let Some(codex) = file.codex
&& let Some(ua) = codex.user_agent
{
return ua;
}
default.to_string()
}
pub fn codex_previous_response_id() -> bool {
let env: HashMap<_, _> = std::env::vars().collect();
if let Some(raw) = env.get("CCP_CODEX_PREVIOUS_RESPONSE_ID") {
return matches!(raw.to_ascii_lowercase().as_str(), "1" | "true" | "yes");
}
let config_dir = paths::config_dir();
if let Some(file) = read_file_config(&config_dir)
&& let Some(codex) = file.codex
&& let Some(val) = codex.previous_response_id
{
return val;
}
false
}
pub fn codex_service_tier() -> Option<String> {
let env: HashMap<_, _> = std::env::vars().collect();
if let Some(raw) = env.get("CCP_CODEX_SERVICE_TIER") {
return Some(raw.clone());
}
let config_dir = paths::config_dir();
if let Some(file) = read_file_config(&config_dir)
&& let Some(codex) = file.codex
{
return codex.service_tier;
}
None
}
pub fn codex_effort() -> Option<String> {
let env: HashMap<_, _> = std::env::vars().collect();
if let Some(raw) = env.get("CCP_CODEX_EFFORT") {
return Some(raw.clone());
}
let config_dir = paths::config_dir();
if let Some(file) = read_file_config(&config_dir)
&& let Some(codex) = file.codex
{
return codex.effort;
}
None
}
pub fn codex_reasoning_summary() -> Option<String> {
let env: HashMap<_, _> = std::env::vars().collect();
if let Some(raw) = env
.get("CCP_CODEX_REASONING_SUMMARY")
.filter(|raw| !raw.is_empty())
{
return Some(raw.clone());
}
let config_dir = paths::config_dir();
if let Some(file) = read_file_config(&config_dir)
&& let Some(codex) = file.codex
&& let Some(summary) = codex.reasoning_summary.filter(|raw| !raw.is_empty())
{
return Some(summary);
}
None
}
pub fn codex_model() -> Option<String> {
let env: HashMap<_, _> = std::env::vars().collect();
if let Some(raw) = env.get("CCP_CODEX_MODEL") {
return Some(raw.clone());
}
let config_dir = paths::config_dir();
if let Some(file) = read_file_config(&config_dir)
&& let Some(codex) = file.codex
{
return codex.model;
}
None
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CodexTransport {
Http,
WebSocket,
Auto,
}
impl CodexTransport {
pub fn as_str(self) -> &'static str {
match self {
CodexTransport::Http => "http",
CodexTransport::WebSocket => "websocket",
CodexTransport::Auto => "auto",
}
}
}
fn parse_codex_transport(raw: &str) -> Option<CodexTransport> {
match raw {
"http" => Some(CodexTransport::Http),
"websocket" => Some(CodexTransport::WebSocket),
"auto" => Some(CodexTransport::Auto),
_ => None,
}
}
pub fn codex_transport() -> CodexTransport {
let env: HashMap<_, _> = std::env::vars().collect();
if let Some(raw) = env.get("CCP_CODEX_TRANSPORT")
&& let Some(transport) = parse_codex_transport(raw)
{
return transport;
}
let config_dir = paths::config_dir();
if let Some(file) = read_file_config(&config_dir)
&& let Some(codex) = file.codex
&& let Some(transport) = codex.transport.as_deref().and_then(parse_codex_transport)
{
return transport;
}
CodexTransport::WebSocket
}
pub fn cursor_base_url() -> String {
let env: HashMap<_, _> = std::env::vars().collect();
if let Some(raw) = env.get("CCP_CURSOR_BASE_URL") {
return raw.clone();
}
let config_dir = paths::config_dir();
if let Some(file) = read_file_config(&config_dir)
&& let Some(cursor) = file.cursor
&& let Some(url) = cursor.base_url
{
return url;
}
"https://api2.cursor.sh".to_string()
}
pub fn cursor_client_version() -> String {
let env: HashMap<_, _> = std::env::vars().collect();
if let Some(raw) = env.get("CCP_CURSOR_CLIENT_VERSION") {
return raw.clone();
}
let config_dir = paths::config_dir();
if let Some(file) = read_file_config(&config_dir)
&& let Some(cursor) = file.cursor
&& let Some(version) = cursor.client_version
{
return version;
}
"0.48.5".to_string()
}
pub fn cursor_agent_bundle() -> Option<String> {
let env: HashMap<_, _> = std::env::vars().collect();
if let Some(raw) = env.get("CCP_CURSOR_AGENT_BUNDLE") {
return Some(raw.clone());
}
let config_dir = paths::config_dir();
if let Some(file) = read_file_config(&config_dir)
&& let Some(cursor) = file.cursor
&& let Some(bundle) = cursor.agent_bundle
{
return Some(bundle);
}
None
}
#[cfg(test)]
mod tests {
use super::*;
use once_cell::sync::Lazy;
use std::sync::Mutex;
static ENV_LOCK: Lazy<Mutex<()>> = Lazy::new(|| Mutex::new(()));
fn clear_env() {
unsafe {
std::env::remove_var("CCP_CODEX_TRANSPORT");
std::env::remove_var("CCP_CONFIG_DIR");
std::env::remove_var("CCP_LOG_VERBOSE");
std::env::remove_var("CCP_LOG_STDERR");
std::env::remove_var("CCP_CODEX_REASONING_SUMMARY");
}
}
struct EnvGuard {
key: &'static str,
previous: Option<std::ffi::OsString>,
}
impl EnvGuard {
fn set(key: &'static str, value: impl AsRef<std::ffi::OsStr>) -> Self {
let previous = std::env::var_os(key);
unsafe {
std::env::set_var(key, value);
}
Self { key, previous }
}
}
impl Drop for EnvGuard {
fn drop(&mut self) {
unsafe {
match self.previous.take() {
Some(value) => std::env::set_var(self.key, value),
None => std::env::remove_var(self.key),
}
}
}
}
#[test]
fn codex_transport_defaults_to_websocket() {
let _guard = ENV_LOCK.lock().unwrap();
clear_env();
let result = codex_transport();
assert_eq!(result, CodexTransport::WebSocket);
}
#[test]
fn codex_transport_reads_env() {
let _guard = ENV_LOCK.lock().unwrap();
clear_env();
unsafe {
std::env::set_var("CCP_CODEX_TRANSPORT", "auto");
}
assert_eq!(codex_transport(), CodexTransport::Auto);
}
#[test]
fn codex_transport_env_websocket() {
let _guard = ENV_LOCK.lock().unwrap();
clear_env();
unsafe {
std::env::set_var("CCP_CODEX_TRANSPORT", "websocket");
}
assert_eq!(codex_transport(), CodexTransport::WebSocket);
}
#[test]
fn codex_transport_invalid_env_falls_back_to_websocket() {
let _guard = ENV_LOCK.lock().unwrap();
clear_env();
unsafe {
std::env::set_var("CCP_CODEX_TRANSPORT", "invalid");
}
assert_eq!(codex_transport(), CodexTransport::WebSocket);
}
#[test]
fn codex_transport_empty_env_falls_back_to_websocket() {
let _guard = ENV_LOCK.lock().unwrap();
clear_env();
unsafe {
std::env::set_var("CCP_CODEX_TRANSPORT", "");
}
assert_eq!(codex_transport(), CodexTransport::WebSocket);
}
#[test]
fn parse_codex_transport_variants() {
assert_eq!(parse_codex_transport("http"), Some(CodexTransport::Http));
assert_eq!(
parse_codex_transport("websocket"),
Some(CodexTransport::WebSocket)
);
assert_eq!(parse_codex_transport("auto"), Some(CodexTransport::Auto));
assert_eq!(parse_codex_transport(""), None);
assert_eq!(parse_codex_transport("HTTP"), None);
assert_eq!(parse_codex_transport("ws"), None);
}
#[test]
fn codex_transport_as_str() {
assert_eq!(CodexTransport::Http.as_str(), "http");
assert_eq!(CodexTransport::WebSocket.as_str(), "websocket");
assert_eq!(CodexTransport::Auto.as_str(), "auto");
}
#[test]
fn log_env_presence_enables_legacy_verbose_and_stderr() {
let _guard = ENV_LOCK.lock().unwrap();
clear_env();
let config = tempfile::TempDir::new().unwrap();
let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());
let _verbose_env = EnvGuard::set("CCP_LOG_VERBOSE", "0");
let _stderr_env = EnvGuard::set("CCP_LOG_STDERR", "");
let loaded = load_config();
assert!(loaded.log_verbose);
assert!(loaded.log_stderr);
}
#[test]
fn log_config_values_apply_without_env() {
let _guard = ENV_LOCK.lock().unwrap();
clear_env();
let config = tempfile::TempDir::new().unwrap();
std::fs::write(
config.path().join("config.json"),
r#"{"log":{"verbose":true,"stderr":true}}"#,
)
.unwrap();
let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());
let loaded = load_config();
assert!(loaded.log_verbose);
assert!(loaded.log_stderr);
}
#[test]
fn codex_reasoning_summary_reads_config() {
let _guard = ENV_LOCK.lock().unwrap();
clear_env();
let config = tempfile::TempDir::new().unwrap();
std::fs::write(
config.path().join("config.json"),
r#"{"codex":{"reasoningSummary":"off"}}"#,
)
.unwrap();
let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());
assert_eq!(codex_reasoning_summary().as_deref(), Some("off"));
}
#[test]
fn codex_reasoning_summary_env_overrides_config_and_empty_falls_through() {
let _guard = ENV_LOCK.lock().unwrap();
clear_env();
let config = tempfile::TempDir::new().unwrap();
std::fs::write(
config.path().join("config.json"),
r#"{"codex":{"reasoningSummary":"off"}}"#,
)
.unwrap();
let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());
{
let _summary_env = EnvGuard::set("CCP_CODEX_REASONING_SUMMARY", "auto");
assert_eq!(codex_reasoning_summary().as_deref(), Some("auto"));
}
{
let _summary_env = EnvGuard::set("CCP_CODEX_REASONING_SUMMARY", "");
assert_eq!(codex_reasoning_summary().as_deref(), Some("off"));
}
}
}