mod discovery;
mod dotenv;
mod home;
mod home_plugins;
mod plugin_cli;
mod tui;
use cpa_core::gostr::GoStr;
use std::io;
use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr};
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::time::Duration;
use anyhow::Context;
use clap::{ArgAction, CommandFactory, FromArgMatches, Parser};
use cpa_core::config::Config;
use cpa_exec::Executors;
use cpa_exec::claude::{ClaudeExecutor, DEFAULT_BASE_URL};
use cpa_server::Runtime;
use cpa_server::listener::bind;
const VERSION: &str = concat!("cliproxy-rs-", env!("CARGO_PKG_VERSION"));
const COMMIT: &str = match option_env!("CPA_COMMIT") {
Some(v) => v,
None => "none",
};
const BUILD_DATE: &str = match option_env!("CPA_BUILD_DATE") {
Some(v) => v,
None => "unknown",
};
fn banner() -> String {
format!("CLIProxyAPI Version: {VERSION}, Commit: {COMMIT}, BuiltAt: {BUILD_DATE}")
}
#[derive(Parser)]
#[command(version, about)]
struct Args {
#[arg(long, default_value = "")]
config: String,
#[arg(long)]
log_file: Option<PathBuf>,
#[arg(long)]
working_dir: Option<PathBuf>,
#[arg(long)]
claude_login: bool,
#[arg(long)]
codex_login: bool,
#[arg(long)]
codex_device_login: bool,
#[arg(long)]
no_browser: bool,
#[arg(long, default_value_t = 0)]
oauth_callback_port: u16,
#[arg(long)]
antigravity_login: bool,
#[arg(long)]
kimi_login: bool,
#[arg(long)]
kimi_ai_login: bool,
#[arg(long)]
xai_login: bool,
#[arg(long)]
devin_login: bool,
#[arg(long)]
meta_login: bool,
#[arg(long)]
discover: bool,
#[arg(long, default_value_t = 3, value_parser = go_int)]
discover_timeout: i64,
#[arg(long)]
discover_json: bool,
#[arg(long, default_value = "")]
discover_service_type: String,
#[arg(long, action = ArgAction::Append)]
discover_include: Vec<String>,
#[arg(long, action = ArgAction::Append)]
discover_exclude: Vec<String>,
#[arg(long, default_value = "")]
vertex_import: String,
#[arg(long, default_value = "")]
vertex_import_prefix: String,
#[arg(long, default_value = "")]
siwc_bind: String,
#[arg(long, hide = true, default_value = "")]
password: String,
#[arg(long, default_value = "")]
home_jwt: String,
#[arg(long)]
home_disable_cluster_discovery: bool,
#[arg(long)]
tui: bool,
#[arg(long)]
standalone: bool,
#[arg(long, default_value = "")]
management_base_url: String,
#[arg(long)]
local_model: bool,
}
#[derive(Parser)]
#[command(name = "discover")]
struct DiscoverArgs {
#[arg(long, default_value_t = 3, value_parser = go_int)]
timeout: i64,
#[arg(long)]
json: bool,
#[arg(long, default_value = "")]
service_type: String,
#[arg(long, default_value = "")]
config: String,
#[arg(long, action = ArgAction::Append)]
include: Vec<String>,
#[arg(long, action = ArgAction::Append)]
exclude: Vec<String>,
}
fn go_flags(
cmd: &clap::Command,
args: impl IntoIterator<Item = String>,
plugins: &dyn plugin_cli::PluginFlags,
) -> Result<Vec<String>, String> {
let mut args = args.into_iter();
let mut out: Vec<String> = args.next().into_iter().collect();
let args: Vec<String> = args.collect();
let mut bools: Vec<(String, bool)> = Vec::new();
let mut scalars: Vec<(String, String)> = Vec::new();
let mut appended: Vec<String> = Vec::new();
let mut tail = None;
let mut i = 0;
while i < args.len() {
let arg = &args[i];
i += 1;
if arg == "--" || arg.len() < 2 || !arg.starts_with('-') {
break;
}
let bare = arg.strip_prefix("--").unwrap_or(&arg[1..]);
let (name, value) = match bare.split_once('=') {
Some((n, v)) => (n, Some(v)),
None => (bare, None),
};
if let Some(is_bool) = plugins
.lookup(name)
.filter(|_| !name.is_empty() && !name.starts_with(['-', '=']))
{
let quote = cpa_common::gostr::quote;
if is_bool {
match value {
None => plugins
.set(name, "true")
.map_err(|e| format!("invalid boolean flag {name}: {e}"))?,
Some(v) => plugins
.set(name, v)
.map_err(|e| format!("invalid boolean value {} for -{name}: {e}", quote(v)))?,
}
continue;
}
let value = match value {
Some(v) => v.to_owned(),
None if i < args.len() => {
i += 1;
args[i - 1].clone()
}
None => return Err(format!("flag needs an argument: -{name}")),
};
plugins
.set(name, &value)
.map_err(|e| format!("invalid value {} for flag -{name}: {e}", quote(&value)))?;
continue;
}
let known = cmd.get_arguments().find(|a| a.get_long() == Some(name));
let Some(flag) = known.filter(|_| !name.is_empty() && !name.starts_with(['-', '='])) else {
tail = Some(if matches!(name, "h" | "help") {
"--help".to_owned()
} else {
format!("--{bare}")
});
break;
};
if !flag.get_action().takes_values() {
match value.map(go_parse_bool) {
None => upsert(&mut bools, name, true),
Some(Some(b)) => upsert(&mut bools, name, b),
Some(None) => {
tail = Some(format!("--{bare}"));
break;
}
}
continue;
}
let value = match value {
Some(v) => v.to_owned(),
None if i < args.len() => {
i += 1;
args[i - 1].clone()
}
None => {
tail = Some(format!("--{name}"));
break;
}
};
if matches!(flag.get_action(), ArgAction::Append) {
appended.push(format!("--{name}={value}"));
} else {
upsert(&mut scalars, name, value);
}
}
out.extend(bools.into_iter().filter(|(_, on)| *on).map(|(n, _)| format!("--{n}")));
out.extend(scalars.into_iter().map(|(n, v)| format!("--{n}={v}")));
out.extend(appended);
out.extend(tail);
Ok(out)
}
fn upsert<T>(list: &mut Vec<(String, T)>, name: &str, value: T) {
match list.iter_mut().find(|(n, _)| n == name) {
Some(slot) => slot.1 = value,
None => list.push((name.to_owned(), value)),
}
}
fn go_int(s: &str) -> Result<i64, String> {
let err = || format!("invalid value {s:?}: parse error");
let (neg, digits) = match s.as_bytes().first() {
Some(b'-') => (true, &s[1..]),
Some(b'+') => (false, &s[1..]),
_ => (false, s),
};
let lower = digits.to_ascii_lowercase();
let (radix, body, prefixed) = match lower.as_bytes() {
[b'0', b'x', ..] => (16, &lower[2..], true),
[b'0', b'o', ..] => (8, &lower[2..], true),
[b'0', b'b', ..] => (2, &lower[2..], true),
[b'0', _, ..] => (8, &lower[1..], true),
_ => (10, lower.as_str(), false),
};
if body.is_empty() || (body.starts_with('_') && !prefixed) || body.ends_with('_') || body.contains("__") {
return Err(err());
}
let magnitude = i128::from_str_radix(&body.replace('_', ""), radix).map_err(|_| err())?;
i64::try_from(if neg { -magnitude } else { magnitude }).map_err(|_| err())
}
fn go_parse_bool(v: &str) -> Option<bool> {
match v {
"1" | "t" | "T" | "TRUE" | "true" | "True" => Some(true),
"0" | "f" | "F" | "FALSE" | "false" | "False" => Some(false),
_ => None,
}
}
fn argv_enables_bool_flag(args: &[String], name: &str) -> bool {
const BOOL_FLAGS: [&str; 16] = [
"codex-login",
"codex-device-login",
"claude-login",
"no-browser",
"antigravity-login",
"kimi-login",
"kimi-ai-login",
"xai-login",
"devin-login",
"meta-login",
"discover",
"discover-json",
"home-disable-cluster-discovery",
"tui",
"standalone",
"local-model",
];
let mut enabled = false;
let mut i = 0;
while i < args.len() {
let arg = &args[i];
if arg == "--" || arg == "-" || !arg.starts_with('-') {
break;
}
let bare = arg.strip_prefix('-').unwrap_or(arg);
let bare = bare.strip_prefix('-').unwrap_or(bare);
let (flag, value) = match bare.split_once('=') {
Some((f, v)) => (f, Some(v)),
None => (bare, None),
};
if flag == name {
match value {
None => enabled = true,
Some(v) => enabled = go_parse_bool(v).unwrap_or(enabled),
}
}
if value.is_none()
&& !flag.is_empty()
&& !BOOL_FLAGS.contains(&flag)
&& args
.get(i + 1)
.is_some_and(|n| n != "--" && (builtin_flag(flag) || !is_discover_flag(n)))
{
i += 1;
}
i += 1;
}
enabled
}
fn prescan_value(args: &[String], wanted: &str) -> Option<String> {
let mut found = None;
let mut i = 0;
while i < args.len() {
let arg = &args[i];
i += 1;
if arg == "--" || arg.len() < 2 || !arg.starts_with('-') {
break;
}
let bare = arg.strip_prefix("--").unwrap_or(&arg[1..]);
let (name, value) = match bare.split_once('=') {
Some((n, v)) => (n, Some(v)),
None => (bare, None),
};
if value.is_some() {
if name == wanted {
found = value.map(str::to_owned);
}
continue;
}
let Some(next) = args.get(i) else { break };
let takes_value = match Args::command().get_arguments().find(|a| a.get_long() == Some(name)) {
Some(flag) => flag.get_action().takes_values(),
None => !next.starts_with('-'),
};
if takes_value {
if name == wanted {
found = Some(next.clone());
}
i += 1;
}
}
found
}
fn builtin_flag(name: &str) -> bool {
static NAMES: std::sync::LazyLock<Vec<String>> = std::sync::LazyLock::new(|| {
Args::command()
.get_arguments()
.filter_map(|a| a.get_long().map(str::to_owned))
.collect()
});
NAMES.iter().any(|n| n == name)
}
fn is_discover_flag(arg: &str) -> bool {
let Some(bare) = arg.strip_prefix('-') else {
return false;
};
let bare = bare.strip_prefix('-').unwrap_or(bare);
let flag = bare.split_once('=').map_or(bare, |(f, _)| f);
matches!(flag, "discover" | "discover-json")
}
struct PrescanBools(Vec<String>);
impl PrescanBools {
fn from_args(args: &[String]) -> Self {
let names = args
.iter()
.zip(args.iter().skip(1))
.take_while(|(arg, _)| *arg != "--")
.filter(|(_, next)| is_discover_flag(next))
.filter_map(|(arg, _)| {
let bare = arg.strip_prefix('-')?;
let bare = bare.strip_prefix('-').unwrap_or(bare);
(!bare.is_empty() && !bare.contains('=') && !builtin_flag(bare)).then(|| bare.to_owned())
})
.collect();
Self(names)
}
}
impl plugin_cli::PluginFlags for PrescanBools {
fn lookup(&self, name: &str) -> Option<bool> {
self.0.iter().any(|n| n == name).then_some(true)
}
fn set(&self, _: &str, _: &str) -> Result<(), String> {
Ok(())
}
}
fn csv_flags(values: &[String]) -> Vec<String> {
values
.iter()
.flat_map(|v| discovery::cli::parse_interface_list(std::slice::from_ref(v)))
.collect()
}
fn discover_options(
timeout: i64,
json: bool,
service_type: String,
config: &str,
cli: (Vec<String>, Vec<String>),
) -> discovery::cli::Options {
let file = if cli.0.is_empty() && cli.1.is_empty() {
discovery::cli::load_scan_filters(config).unwrap_or_else(|e| {
eprintln!("{e}");
std::process::exit(1)
})
} else {
Default::default()
};
let (include, exclude) = discovery::cli::resolve_filters(cli, file);
discovery::cli::Options {
timeout: Duration::from_secs(timeout.clamp(0, 3600) as u64),
json,
service_type,
include,
exclude,
}
}
fn runtime(config: Option<&Path>) -> io::Result<tokio::runtime::Runtime> {
tokio::runtime::Builder::new_multi_thread()
.worker_threads(worker_threads(config))
.enable_all()
.build()
}
fn configured_workers(path: &Path) -> Option<u64> {
let raw = std::fs::read_to_string(path).ok()?;
let doc = cpa_core::config::parse_yaml(&raw).ok()?;
doc.get("worker-threads")?.as_u64()
}
fn worker_threads(config: Option<&Path>) -> usize {
let positive = |n: u64| usize::try_from(n).ok().filter(|n| *n > 0);
if let Ok(raw) = std::env::var("TOKIO_WORKER_THREADS") {
match raw.trim().parse().ok().and_then(positive) {
Some(n) => return n,
None => tracing::warn!("ignoring TOKIO_WORKER_THREADS={raw:?}: not a positive number"),
}
}
let configured = config.and_then(configured_workers).and_then(positive);
configured.unwrap_or_else(|| std::thread::available_parallelism().map_or(1, |n| n.get().min(2)))
}
async fn shutdown_signal() {
#[cfg(unix)]
{
let mut term = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
.expect("SIGTERM handler installs");
tokio::select! {
_ = tokio::signal::ctrl_c() => {}
_ = term.recv() => {}
}
}
#[cfg(not(unix))]
let _ = tokio::signal::ctrl_c().await;
}
fn load_config(path: &Path, optional: bool) -> anyhow::Result<Config> {
let loaded = Config::load(path).with_context(|| format!("failed to load config {}", path.display()));
match loaded {
Err(e) if optional => {
let missing = std::fs::read(path).map_or(true, |b| String::from_utf8_lossy(&b).trim().is_empty());
if !missing {
tracing::error!("{e:#}");
}
Config::parse("")
}
other => other,
}
}
fn cloud_config_present(path: &Path, config: &Config) -> bool {
let (present, message) = match std::fs::metadata(path) {
Err(_) => (
false,
"Cloud deploy mode: No configuration file detected; standing by for configuration",
),
Ok(m) if m.is_dir() => (
false,
"Cloud deploy mode: Config path is a directory; standing by for configuration",
),
Ok(_) if config.port == 0 => (
false,
"Cloud deploy mode: Configuration file is empty or invalid; standing by for valid configuration",
),
Ok(_) => (true, "Cloud deploy mode: Configuration file detected; starting service"),
};
tracing::info!("{message}");
present
}
async fn wait_for_cloud_deploy() {
tracing::info!(
"Cloud deploy mode: No config found; standing by for configuration. API server is not started. Press Ctrl+C to exit."
);
shutdown_signal().await;
tracing::info!("Cloud deploy mode: Shutdown signal received; exiting");
}
fn flag_error(cmd: &mut clap::Command, message: &str) -> ! {
eprintln!("{message}");
eprint!("{}", cmd.render_help());
std::process::exit(2);
}
fn main() -> anyhow::Result<()> {
cpa_server::logging::init();
let raw: Vec<String> = std::env::args().collect();
let working_dir = prescan_value(&raw[1..], "working-dir");
if let Some(dir) = &working_dir {
std::env::set_current_dir(dir).with_context(|| format!("change to working directory {dir:?}"))?;
}
let log_file = prescan_value(&raw[1..], "log-file");
if let Some(path) = log_file.as_deref().filter(|p| !p.is_empty()) {
cpa_server::logging::set_log_file(path.into()).context("open process log")?;
}
if raw.get(1).map(String::as_str) == Some("discover") {
let flags = go_flags(&DiscoverArgs::command(), raw.into_iter().skip(1), &())
.unwrap_or_else(|e| flag_error(&mut DiscoverArgs::command(), &e));
let args = DiscoverArgs::parse_from(flags);
if !args.json {
eprintln!("{}", banner());
}
let cli = (csv_flags(&args.include), csv_flags(&args.exclude));
let opts = discover_options(args.timeout, args.json, args.service_type, &args.config, cli);
std::process::exit(runtime(None)?.block_on(discovery::cli::discover(&opts)));
}
if !argv_enables_bool_flag(&raw[1..], "discover-json") {
println!("{}", banner());
}
let discover_mode =
argv_enables_bool_flag(&raw[1..], "discover-json") || argv_enables_bool_flag(&raw[1..], "discover");
if !discover_mode {
dotenv::load_from_working_dir();
}
let runtime = runtime(Some(&plugin_cli::bootstrap_config_path(&raw[1..], "")))?;
let builtin_cmd = Args::command();
let plugins = (!discover_mode).then(|| {
let builtin = |name: &str| builtin_cmd.get_arguments().any(|a| a.get_long() == Some(name));
runtime.block_on(plugin_cli::bootstrap(&raw[1..], &builtin))
});
let mut cmd = match &plugins {
Some((_, flags)) => plugin_cli::with_flags(Args::command(), flags),
None => Args::command(),
};
let flags = match &plugins {
Some((host, _)) => go_flags(&cmd, raw, host),
None => {
let prescanned = PrescanBools::from_args(&raw[1..]);
go_flags(&cmd, raw, &prescanned)
}
}
.unwrap_or_else(|e| flag_error(&mut cmd, &e));
let matches = cmd.clone().get_matches_from(flags);
let args = Args::from_arg_matches(&matches).unwrap_or_else(|e| e.exit());
if args.working_dir.as_deref() != working_dir.as_deref().map(Path::new) {
flag_error(
&mut cmd,
"-working-dir must come before any plugin flag that takes a value",
);
}
if args.log_file.as_deref() != log_file.as_deref().map(Path::new) {
flag_error(
&mut cmd,
"-log-file must come before any plugin flag that takes a value",
);
}
if args.discover || args.discover_json {
let cli = (csv_flags(&args.discover_include), csv_flags(&args.discover_exclude));
let opts = discover_options(
args.discover_timeout,
args.discover_json,
args.discover_service_type.clone(),
&args.config,
cli,
);
std::process::exit(runtime.block_on(discovery::cli::discover(&opts)));
}
let builtin = plugin_cli::builtin_values(&cmd, &matches);
let host = plugins.map(|(host, _)| host).unwrap_or_default();
#[cfg(all(target_os = "linux", target_env = "gnu"))]
runtime.spawn(heap_trim::run());
let file_log = args.log_file.is_some();
let result = runtime.block_on(run(args, host, builtin));
if file_log && let Err(error) = &result {
tracing::error!("{error:#}");
}
result
}
#[cfg(all(target_os = "linux", target_env = "gnu"))]
mod heap_trim {
use std::pin::Pin;
use std::task::{Context, Poll};
use std::time::Duration;
use axum::body::{Body, Bytes, HttpBody};
const TICK: Duration = Duration::from_secs(5);
const QUIET: Duration = Duration::from_millis(50);
const MAX_GAP: u32 = 12;
fn cpu_time() -> Duration {
let mut usage: libc::rusage = unsafe { std::mem::zeroed() };
unsafe { libc::getrusage(libc::RUSAGE_SELF, &mut usage) };
let tv = |t: libc::timeval| Duration::new(t.tv_sec as u64, t.tv_usec as u32 * 1000);
tv(usage.ru_utime) + tv(usage.ru_stime)
}
pub async fn run() {
loop {
let (mut last, mut ticks) = (cpu_time(), 0);
loop {
tokio::time::sleep(TICK).await;
let now = cpu_time();
let quiet = now.saturating_sub(last) < QUIET;
last = now;
ticks += 1;
if quiet || ticks >= MAX_GAP {
let _ = tokio::task::spawn_blocking(|| unsafe { libc::malloc_trim(0) }).await;
ticks = 0;
}
if quiet {
break;
}
}
cpa_common::idle::park().await;
}
}
pub fn layer(app: axum::Router) -> axum::Router {
app.layer(tower::util::MapResponseLayer::new(|res: axum::response::Response| {
res.map(|body| Body::new(Done(body)))
}))
}
struct Done(Body);
impl HttpBody for Done {
type Data = Bytes;
type Error = axum::Error;
fn poll_frame(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
) -> Poll<Option<Result<http_body::Frame<Bytes>, axum::Error>>> {
Pin::new(&mut self.get_mut().0).poll_frame(cx)
}
fn is_end_stream(&self) -> bool {
self.0.is_end_stream()
}
fn size_hint(&self) -> http_body::SizeHint {
self.0.size_hint()
}
}
impl Drop for Done {
fn drop(&mut self) {
cpa_common::idle::activity();
}
}
}
async fn run(args: Args, plugins: cpa_plugin::Host, builtin: Vec<(String, String)>) -> anyhow::Result<()> {
if args.tui
&& !args.standalone
&& !args.management_base_url.trim().is_empty()
&& !command_mode(&args)
&& !plugins.has_triggered_command_line_flags()
{
remote_tui(args.management_base_url.trim().to_owned(), args.password).await;
return Ok(());
}
let wd = std::env::current_dir()?;
let home_jwt = [
args.home_jwt.clone(),
std::env::var("HOME_JWT").unwrap_or_default(),
std::env::var("home_jwt").unwrap_or_default(),
];
let home_jwt = home_jwt
.iter()
.map(|v| v.trim())
.find(|v| !v.is_empty())
.map(str::to_owned);
let home = home_jwt.is_some();
let env = |key: &str| std::env::var(key).ok();
let store = match cpa_store::select(&env, &wd, home) {
Some(selection) => match cpa_store::bootstrap(selection, &wd).await {
Ok(store) => Some(store),
Err(line) => {
tracing::error!("{line}");
return Ok(());
}
},
None => None,
};
let config_path = match &store {
Some(store) => store.config_path.clone(),
None if args.config.is_empty() => wd.join("config.yaml"),
None => PathBuf::from(&args.config),
};
let cloud = std::env::var("DEPLOY").is_ok_and(|v| v == "cloud");
let (mut config, home_config, home_plugins) = match &home_jwt {
Some(jwt) => match home::bootstrap(jwt, args.home_disable_cluster_discovery, &plugins).await {
Ok((home_config, config, home_plugins)) => (config, Some(home_config), Some(home_plugins)),
Err(line) => {
tracing::error!("{line}");
return Ok(());
}
},
None => (load_config(&config_path, cloud)?, None, None),
};
if let Some(store) = &store {
config.auth_dir = store.auth_dir.clone();
tracing::info!("{}", store.enabled);
}
if (store.is_some() || home_config.is_some())
&& std::env::var_os("TOKIO_WORKER_THREADS").is_none()
&& let Some(n) = config
.document
.get("worker-threads")
.and_then(serde_yaml_ng::Value::as_u64)
&& usize::try_from(n).ok() != Some(tokio::runtime::Handle::current().metrics().num_workers())
{
let source = match &home_config {
Some(_) => "the config Home supplies".to_owned(),
None => config_path.display().to_string(),
};
tracing::warn!(
"worker-threads in {source} is ignored: it is read only from -config/./config.yaml; set TOKIO_WORKER_THREADS"
);
}
let config_present = match &home_config {
Some(_) => !cloud || config.port != 0,
None => !cloud || cloud_config_present(&config_path, &config),
};
cpa_server::logging::configure(&config);
tracing::info!("{}", banner());
let before = store.as_ref().map(|store| auth_files(&store.auth_dir));
plugins.apply_config(Arc::new(config.clone())).await;
if let Some(home_plugins) = home_plugins
&& let Err(line) = home_plugins.finish(&plugins).await
{
tracing::error!("{line}");
return Ok(());
}
if let Some(code) = plugin_cli::execute(&plugins, &config_path, &builtin).await {
if let (Some(store), Some(before)) = (&store, &before) {
persist_login(store, before).await;
}
if code != 0 {
std::process::exit(code);
}
return Ok(());
}
let ran = command(&args, &config).await;
if !matches!(ran, Ok(Ran::Nothing)) {
if let (Some(store), Some(before)) = (&store, &before) {
persist_command(store, before, &ran).await;
}
return ran.map(|_| ());
}
if !config_present {
wait_for_cloud_deploy().await;
return Ok(());
}
if args.local_model && (!args.tui || args.standalone) {
tracing::info!("Local model mode: using embedded model catalogs, remote model updates disabled");
}
if args.tui {
if args.standalone {
standalone_tui(
config,
config_path,
args.password,
args.local_model,
store,
home_config,
plugins,
)
.await;
} else {
let base = resolve_management_base_url(&args.management_base_url, &config);
remote_tui(base, args.password).await;
}
return Ok(());
}
if args.log_file.is_some() {
free_console();
}
serve(
config,
config_path,
args.password,
args.local_model,
store,
home_config,
plugins,
shutdown_signal(),
None,
)
.await
}
fn free_console() {
#[cfg(windows)]
{
#[link(name = "kernel32")]
unsafe extern "system" {
fn FreeConsole() -> i32;
}
unsafe {
FreeConsole();
}
}
}
fn command_mode(args: &Args) -> bool {
!args.vertex_import.is_empty()
|| !args.siwc_bind.is_empty()
|| args.antigravity_login
|| args.codex_login
|| args.codex_device_login
|| args.claude_login
|| args.kimi_login
|| args.kimi_ai_login
|| args.xai_login
|| args.devin_login
|| args.meta_login
}
async fn remote_tui(base: String, password: String) {
let run = tokio::task::spawn_blocking(move || tui::run(&base, &password, None, io::stdout())).await;
if let Err(e) = run.map_err(io::Error::other).and_then(|r| r) {
eprintln!("TUI error: {e}");
}
}
fn resolve_management_base_url(flag: &str, config: &Config) -> String {
let configured = config
.document
.get("management")
.and_then(|m| m.get("base-url"))
.and_then(serde_yaml_ng::Value::as_str)
.unwrap_or_default();
management_base_url(flag, configured, i64::from(config.port))
}
fn management_base_url(flag: &str, configured: &str, port: i64) -> String {
for url in [flag, configured] {
if !url.trim().is_empty() {
return url.trim().to_owned();
}
}
format!("http://127.0.0.1:{}", if port > 0 { port } else { 8317 })
}
#[cfg(unix)]
struct QuietStdio {
out: libc::c_int,
err: libc::c_int,
}
#[cfg(unix)]
impl QuietStdio {
fn start() -> io::Result<(Self, std::fs::File)> {
use std::os::fd::{AsRawFd, FromRawFd};
io::Write::flush(&mut io::stdout())?;
let null = std::fs::OpenOptions::new().write(true).open("/dev/null")?;
unsafe {
let (out, err, tty) = (libc::dup(1), libc::dup(2), libc::dup(1));
if out < 0 || err < 0 || tty < 0 {
return Err(io::Error::last_os_error());
}
libc::dup2(null.as_raw_fd(), 1);
libc::dup2(null.as_raw_fd(), 2);
Ok((QuietStdio { out, err }, std::fs::File::from_raw_fd(tty)))
}
}
}
#[cfg(unix)]
impl Drop for QuietStdio {
fn drop(&mut self) {
unsafe {
libc::dup2(self.out, 1);
libc::dup2(self.err, 2);
libc::close(self.out);
libc::close(self.err);
}
}
}
#[cfg(not(unix))]
struct QuietStdio;
#[cfg(not(unix))]
impl QuietStdio {
fn start() -> io::Result<(Self, io::Stdout)> {
Ok((QuietStdio, io::stdout()))
}
}
async fn standalone_tui(
config: Config,
config_path: PathBuf,
password: String,
local_model: bool,
store: Option<cpa_store::Store>,
home_config: Option<cpa_home::HomeConfig>,
plugins: cpa_plugin::Host,
) {
let hook = cpa_server::logging::capture(2000);
let (quiet, out): (Option<QuietStdio>, Box<dyn io::Write + Send>) = match QuietStdio::start() {
Ok((guard, tty)) => (Some(guard), Box::new(tty)),
Err(_) => (None, Box::new(io::stdout())),
};
let password = if password.is_empty() {
let nanos = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map_or(0, |d| d.as_nanos());
format!("tui-{}-{nanos}", std::process::id())
} else {
password
};
let (stop, stopped) = tokio::sync::oneshot::channel::<()>();
let shutdown = async {
let _ = stopped.await;
};
let (listening, listener) = tokio::sync::oneshot::channel();
let server = tokio::spawn(serve(
config,
config_path,
password.clone(),
local_model,
store,
home_config,
plugins,
shutdown,
Some(listening),
));
let base = match listener.await {
Ok(listener) => standalone_base_url(listener),
Err(_) => Err("embedded server is not ready".to_owned()),
};
let result = match &base {
Ok(base) if tui::wait_ready(base, &password).await => {
let base = base.clone();
let run = tokio::task::spawn_blocking(move || tui::run(&base, &password, Some(hook), out)).await;
run.map_err(|e| e.to_string())
.and_then(|r| r.map_err(|e| e.to_string()))
}
Ok(_) => Err("embedded server is not ready".to_owned()),
Err(e) => Err(e.clone()),
};
#[cfg_attr(not(unix), allow(clippy::drop_non_drop))]
drop(quiet);
cpa_server::logging::release();
if let Err(e) = result {
eprintln!("TUI error: {e}");
}
let _ = stop.send(());
if let Ok(Err(e)) = server.await {
tracing::error!("{e:#}");
}
}
fn auth_files(dir: &Path) -> std::collections::BTreeMap<PathBuf, Vec<u8>> {
std::fs::read_dir(dir)
.into_iter()
.flatten()
.flatten()
.filter(|e| e.file_name().to_string_lossy().go_lower().ends_with(".json"))
.filter_map(|e| Some((e.path(), std::fs::read(e.path()).ok()?)))
.collect()
}
async fn persist_login(store: &cpa_store::Store, before: &std::collections::BTreeMap<PathBuf, Vec<u8>>) {
for (path, data) in auth_files(&store.auth_dir) {
if before.get(&path) == Some(&data) {
continue;
}
let name = path
.file_name()
.map(|n| n.to_string_lossy().into_owned())
.unwrap_or_default();
if let Err(error) = store
.persister
.persist_auth_files(format!("Update auth {name}"), vec![path])
.await
{
tracing::error!("failed to save auth {name} to the token store: {error:#}");
}
}
}
enum Ran {
Nothing,
Login,
Bound(Option<PathBuf>),
}
async fn persist_command(
store: &cpa_store::Store,
before: &std::collections::BTreeMap<PathBuf, Vec<u8>>,
ran: &anyhow::Result<Ran>,
) {
match ran {
Ok(Ran::Nothing | Ran::Bound(None)) => {}
Ok(Ran::Bound(Some(path))) => persist_bound(store, path).await,
Ok(Ran::Login) | Err(_) => persist_login(store, before).await,
}
}
async fn persist_bound(store: &cpa_store::Store, path: &Path) {
let path = std::fs::canonicalize(&store.auth_dir)
.ok()
.map(cpa_exec::codex_siwc_bind::plain_path)
.and_then(|dir| path.strip_prefix(dir).ok().map(|rel| store.auth_dir.join(rel)))
.unwrap_or_else(|| path.to_owned());
let name = path
.file_name()
.map(|n| n.to_string_lossy().into_owned())
.unwrap_or_default();
if let Err(error) = store
.persister
.persist_auth_files(format!("Update auth {name}"), vec![path])
.await
{
tracing::error!("failed to save auth {name} to the token store: {error:#}");
}
}
async fn command(args: &Args, config: &Config) -> anyhow::Result<Ran> {
if !args.vertex_import.is_empty() {
match cpa_exec::vertex_auth::import(&config.auth_dir, &args.vertex_import, &args.vertex_import_prefix) {
Ok(path) => println!("Vertex credentials imported: {}", path.display()),
Err(error) => tracing::error!("{error}"),
}
return Ok(Ran::Login);
}
if !args.siwc_bind.is_empty() {
let options = cpa_exec::codex_oauth::LoginOptions {
no_browser: args.no_browser,
callback_port: args.oauth_callback_port,
};
match cpa_exec::codex_siwc_bind::bind(config, &args.siwc_bind, &options).await {
Ok(path) => {
println!("SIWC credentials bound and saved to {}", path.display());
println!("Sign in with ChatGPT authentication successful!");
return Ok(Ran::Bound(Some(path)));
}
Err(cpa_exec::codex_siwc_bind::BindError::Log(line)) => tracing::error!("{line}"),
Err(cpa_exec::codex_siwc_bind::BindError::Print(line)) => println!("{line}"),
Err(cpa_exec::codex_siwc_bind::BindError::PortInUse) => {
tracing::error!(
"The required port is already in use. Please close any applications using port 3000 and try again."
);
std::process::exit(13);
}
}
return Ok(Ran::Bound(None));
}
if args.antigravity_login {
let options = cpa_exec::antigravity_auth::LoginOptions {
no_browser: args.no_browser,
callback_port: args.oauth_callback_port,
};
match cpa_exec::antigravity_auth::login(&config.auth_dir, config, &options).await {
Ok((path, label)) => {
println!("Authentication saved to {}", path.display());
if !label.is_empty() {
println!("Authenticated as {label}");
}
println!("Antigravity authentication successful!");
}
Err(error) => tracing::error!("Antigravity authentication failed: {error}"),
}
return Ok(Ran::Login);
}
if args.codex_login || args.codex_device_login {
let options = cpa_exec::codex_oauth::LoginOptions {
no_browser: args.no_browser,
callback_port: match args.oauth_callback_port {
0 => cpa_exec::codex_oauth::DEFAULT_CALLBACK_PORT,
port => port,
},
};
let path = if args.codex_login {
cpa_exec::codex_oauth::login(&config.auth_dir, &options).await?
} else {
cpa_exec::codex_oauth::device_login(&config.auth_dir, &options).await?
};
println!("Authentication saved to {}", path.display());
println!("Codex authentication successful!");
return Ok(Ran::Login);
}
if args.claude_login {
let options = cpa_exec::claude_login::LoginOptions {
no_browser: args.no_browser,
callback_port: match args.oauth_callback_port {
0 => cpa_exec::claude_login::DEFAULT_CALLBACK_PORT,
port => port,
},
};
if let Err(error) = cpa_exec::claude_login::login(&config.auth_dir, &options).await {
let message = String::from_utf8_lossy(&error.body).into_owned();
if message.starts_with(cpa_exec::claude_login::PORT_IN_USE) {
tracing::error!(
"The required port is already in use. Please close any applications using port 3000 and try again."
);
std::process::exit(13);
}
println!("Claude authentication failed: {message}");
}
return Ok(Ran::Login);
}
if args.kimi_login || args.kimi_ai_login {
let provider = if args.kimi_login { "kimi" } else { "kimi-ai" };
cpa_exec::kimi_auth::login(provider, config, args.no_browser).await?;
return Ok(Ran::Login);
}
if args.xai_login {
if let Err(error) = cpa_exec::xai_auth::login(config, args.no_browser).await {
tracing::error!("xAI authentication failed: {}", String::from_utf8_lossy(&error.body));
}
return Ok(Ran::Login);
}
if args.devin_login {
cpa_exec::devin_auth::login(config, args.no_browser, args.oauth_callback_port).await;
return Ok(Ran::Login);
}
if args.meta_login {
cpa_exec::meta_auth::login(config, args.no_browser).await?;
return Ok(Ran::Login);
}
Ok(Ran::Nothing)
}
fn standalone_base_url((addr, tls): (SocketAddr, bool)) -> Result<String, String> {
if tls {
return Err("the standalone TUI does not support server.tls; turn it off or run the TUI as a client".into());
}
let ip = match addr.ip() {
std::net::IpAddr::V4(ip) if ip.is_unspecified() => Ipv4Addr::LOCALHOST.into(),
std::net::IpAddr::V6(ip) if ip.is_unspecified() => Ipv6Addr::LOCALHOST.into(),
ip if ip.is_loopback() => ip,
ip => {
return Err(format!(
"the standalone TUI needs a loopback or wildcard host, not {ip}; run the TUI as a client"
));
}
};
Ok(format!("http://{}", SocketAddr::new(ip, addr.port())))
}
fn ensure_auth_dir(dir: &Path) -> anyhow::Result<()> {
match std::fs::metadata(dir) {
Ok(meta) if meta.is_dir() => Ok(()),
Ok(_) => anyhow::bail!("cliproxy: auth path exists but is not a directory: {}", dir.display()),
Err(e) if e.kind() == io::ErrorKind::NotFound => {
let mut builder = std::fs::DirBuilder::new();
builder.recursive(true);
#[cfg(unix)]
std::os::unix::fs::DirBuilderExt::mode(&mut builder, 0o755);
builder
.create(dir)
.with_context(|| format!("cliproxy: failed to create auth directory {}", dir.display()))?;
tracing::info!("created missing auth directory: {}", dir.display());
Ok(())
}
Err(e) => Err(e).with_context(|| format!("cliproxy: error checking auth directory {}", dir.display())),
}
}
fn app(rt: &Arc<Runtime>, management: &Arc<cpa_server::management::Management>, home: bool) -> axum::Router {
let app = if home {
cpa_server::router(rt.clone()).layer(axum::middleware::from_fn_with_state(
rt.clone(),
cpa_server::remote::gate,
))
} else {
let app = cpa_server::app(rt.clone(), cpa_server::management::router(management.clone()));
cpa_server::safe_mode::router(rt, app)
};
let app = app.layer(axum::middleware::from_fn(cpa_server::management::cors));
let app = cpa_server::request_logging::router(management, app);
let app = cpa_server::body_limit::layer(rt, app);
cpa_server::observability::router(rt, app)
}
#[allow(clippy::too_many_arguments)]
async fn serve(
config: Config,
config_path: PathBuf,
password: String,
local_model: bool,
store: Option<cpa_store::Store>,
home_config: Option<cpa_home::HomeConfig>,
plugins: cpa_plugin::Host,
shutdown: impl std::future::Future<Output = ()>,
listening: Option<tokio::sync::oneshot::Sender<(SocketAddr, bool)>>,
) -> anyhow::Result<()> {
if config.api_keys.is_empty() && home_config.is_none() {
tracing::warn!("access.api-keys is empty: the proxy API is open to anyone who can reach it");
}
if home_config.is_none() {
ensure_auth_dir(&config.auth_dir)?;
}
let (credentials, read) = match home_config {
Some(_) => Default::default(),
None => {
let scan = cpa_core::config::credentials::scan_auth_dir(&config);
let mut all = scan.credentials;
all.extend(cpa_core::config::credentials::from_config(&config));
(all, scan.read)
}
};
tracing::info!(credentials = credentials.len(), "credentials loaded");
let listener =
bind(&config.host, config.port).with_context(|| format!("binding {}:{}", config.host, config.port))?;
let listener = tokio::net::TcpListener::from_std(listener)?;
let tls = cpa_server::listener::tls_acceptor(&config)?;
tracing::info!(addr = %listener.local_addr()?, tls = tls.is_some(), "listening");
let standalone = listening.is_some();
if let Some(listening) = listening {
let _ = listening.send((listener.local_addr()?, tls.is_some()));
}
let executors = Executors {
claude: ClaudeExecutor::new(DEFAULT_BASE_URL)?,
codex: cpa_exec::codex::CodexExecutor::new()?,
devices: Default::default(),
openai: Default::default(),
google: Default::default(),
};
let rt = Arc::new(Runtime::new(config, credentials, executors).with_plugin_host(plugins));
rt.store().note_loaded(&read);
rt.set_local_model(local_model);
if let Some(cooldown) = store.as_ref().and_then(|store| store.cooldown.clone()) {
rt.set_cooldown_backend(cooldown);
}
cpa_server::model_updater::start(&rt, home_config.is_some());
let home = home_config.map(|home_config| {
let dispatcher = Arc::new(home::Dispatcher::new(&rt));
rt.set_remote_dispatch(Some(dispatcher.clone()));
let shutdown = tokio_util::sync::CancellationToken::new();
let task = home::spawn_subscriber(home_config, rt.clone(), dispatcher, shutdown.clone());
(shutdown, task)
});
cpa_server::install_registry(&rt);
rt.start_auto_refresh();
let options = cpa_server::management::Options {
local_password: password,
standalone,
store: store.map(|store| store.persister),
..Default::default()
};
let management = cpa_server::management::Management::with_options(rt.clone(), config_path, options);
if home.is_some() {
rt.usage_queue().configure(true, &rt.config());
}
cpa_server::plugins::start(&rt).await;
if home.is_none() {
cpa_server::plugins::reload_plugin_auth_files(&rt).await;
}
let pprof = cpa_server::pprof::Server::start(&rt);
let _watcher = home.is_none().then(|| cpa_server::watching::start(&management));
let advertiser = {
let rt = rt.clone();
let published = rt.subscribe_config();
discovery::advertise::Advertiser::spawn(move || rt.config(), published, tls.is_some())
};
let app = app(&rt, &management, home.is_some());
#[cfg(all(target_os = "linux", target_env = "gnu"))]
let app = heap_trim::layer(app);
let mut server = Box::pin(cpa_server::listener::serve_with_resp(
listener,
app,
tls,
Some(management),
));
let mut home = home;
let home_stopped = async {
match home.as_mut() {
Some((_, task)) => {
let _ = task.await;
}
None => std::future::pending::<()>().await,
}
};
let mut home_failed = false;
let mut server_done = false;
let served = tokio::select! {
r = &mut server => {
server_done = true;
r.map_err(anyhow::Error::from)
},
_ = shutdown => Ok(()),
_ = home_stopped => {
home_failed = true;
Err(anyhow::anyhow!("home subscriber stopped; shutting down"))
}
};
let cleanup = async {
if let Some((shutdown, task)) = home
&& !home_failed
{
shutdown.cancel();
let _ = task.await;
}
pprof.shutdown().await;
advertiser.shutdown().await;
rt.shutdown_codex_refreshes().await;
};
tokio::pin!(cleanup);
if server_done {
cleanup.await;
} else {
tokio::select! {
_ = &mut cleanup => {},
_ = &mut server => cleanup.await,
}
}
drop(server);
served
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn siwc_bind_saves_only_the_bound_file() {
struct Recorder(std::sync::Mutex<Vec<Vec<PathBuf>>>, PathBuf);
impl cpa_server::persist::StorePersister for Recorder {
fn persist_config(&self) -> futures_util::future::BoxFuture<'_, anyhow::Result<()>> {
Box::pin(async { Ok(()) })
}
fn persist_auth_files(
&self,
_: String,
paths: Vec<PathBuf>,
) -> futures_util::future::BoxFuture<'_, anyhow::Result<()>> {
self.0.lock().unwrap().push(paths);
Box::pin(async { Ok(()) })
}
fn delete_auth(&self, _: PathBuf) -> anyhow::Result<()> {
Ok(())
}
fn auth_dir(&self) -> PathBuf {
self.1.clone()
}
}
let root = std::env::temp_dir().join(format!(
"cliproxy-siwc-store-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
std::fs::create_dir_all(root.join("real")).unwrap();
#[cfg(unix)]
std::os::unix::fs::symlink(root.join("real"), root.join("auth")).unwrap();
#[cfg(not(unix))]
std::fs::create_dir_all(root.join("auth")).unwrap();
let auth = root.join("auth");
std::fs::write(auth.join("c.json"), "{}").unwrap();
let before = auth_files(&auth);
std::fs::write(auth.join("c.json"), r#"{"use_siwc":true}"#).unwrap();
std::fs::write(auth.join("other.json"), "{}").unwrap();
let recorder = Arc::new(Recorder(Default::default(), auth.clone()));
let store = cpa_store::Store {
config_path: root.join("config.yaml"),
auth_dir: auth.clone(),
persister: recorder.clone(),
cooldown: None,
enabled: String::new(),
};
let real = std::fs::canonicalize(auth.join("c.json")).unwrap();
persist_command(&store, &before, &Ok(Ran::Bound(Some(real)))).await;
assert_eq!(*recorder.0.lock().unwrap(), vec![vec![auth.join("c.json")]]);
recorder.0.lock().unwrap().clear();
persist_command(&store, &before, &Ok(Ran::Bound(None))).await;
assert!(recorder.0.lock().unwrap().is_empty());
persist_command(&store, &before, &Ok(Ran::Login)).await;
let mut saved: Vec<PathBuf> = recorder.0.lock().unwrap().concat();
saved.sort();
assert_eq!(saved, vec![auth.join("c.json"), auth.join("other.json")]);
let _ = std::fs::remove_dir_all(root);
}
#[test]
fn worker_threads_come_from_the_config_file() {
let dir = std::env::temp_dir().join(format!("cliproxy-workers-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("config.yaml");
let default = std::thread::available_parallelism().map_or(1, |n| n.get().min(2));
std::fs::write(&path, "port: 1\nworker-threads: 5\n").unwrap();
assert_eq!(worker_threads(Some(&path)), 5);
for text in [
"worker-threads: 0\n",
"worker-threads: -3\n",
"worker-threads: many\n",
": not yaml [",
] {
std::fs::write(&path, text).unwrap();
assert_eq!(worker_threads(Some(&path)), default, "{text:?}");
}
assert_eq!(worker_threads(Some(&dir.join("missing.yaml"))), default);
assert_eq!(worker_threads(None), default);
std::fs::remove_dir_all(dir).unwrap();
}
#[test]
fn management_base_url_follows_go() {
let fixture: serde_json::Value =
serde_json::from_str(include_str!("../tests/fixtures/discovery_main_go.json")).unwrap();
let cases = fixture["management_base_url"].as_array().unwrap();
assert!(cases.len() >= 6);
for case in cases {
let got = management_base_url(
case["flag"].as_str().unwrap(),
case["remote"].as_str().unwrap(),
case["port"].as_i64().unwrap(),
);
assert_eq!(got, case["out"].as_str().unwrap(), "{case}");
}
let config = Config::parse("config-version: 8\nmanagement:\n base-url: ' http://y '\n").unwrap();
assert_eq!(resolve_management_base_url("", &config), "http://y");
}
#[test]
fn argv_prescan_matches_go() {
let fixture: serde_json::Value =
serde_json::from_str(include_str!("../tests/fixtures/discovery_main_go.json")).unwrap();
for case in fixture["argv"].as_array().unwrap() {
let args: Vec<String> = serde_json::from_value(case["args"].clone()).unwrap();
assert_eq!(
argv_enables_bool_flag(&args, "discover-json"),
case["discover_json"],
"{args:?}"
);
assert_eq!(argv_enables_bool_flag(&args, "discover"), case["discover"], "{args:?}");
}
}
#[test]
fn a_plugin_flag_before_discover_keeps_discover_mode() {
let argv = |a: &[&str]| a.iter().map(|s| (*s).to_owned()).collect::<Vec<_>>();
assert!(argv_enables_bool_flag(
&argv(&["-plugin-verbose", "-discover"]),
"discover"
));
assert!(argv_enables_bool_flag(
&argv(&["--plugin-verbose", "--discover-json"]),
"discover-json"
));
assert!(argv_enables_bool_flag(
&argv(&["-plugin-verbose", "-discover=true"]),
"discover"
));
assert!(argv_enables_bool_flag(
&argv(&["-plugin-mode", "fast", "-discover"]),
"discover"
));
assert!(!argv_enables_bool_flag(
&argv(&["-plugin-mode", "x", "fast", "-discover"]),
"discover"
));
assert!(!argv_enables_bool_flag(&argv(&["-config", "-discover"]), "discover"));
assert!(!argv_enables_bool_flag(
&argv(&["-password", "--discover-json"]),
"discover-json"
));
}
#[test]
fn a_plugin_flag_before_discover_parses_in_discover_mode() {
let parse = |a: &[&str]| {
let raw: Vec<String> = std::iter::once("cliproxy")
.chain(a.iter().copied())
.map(str::to_owned)
.collect();
assert!(argv_enables_bool_flag(&raw[1..], "discover"), "{a:?}");
let flags = go_flags(&Args::command(), raw.clone(), &PrescanBools::from_args(&raw[1..]))?;
Args::try_parse_from(flags).map_err(|e| e.to_string())
};
assert!(parse(&["-plugin-verbose", "-discover"]).unwrap().discover);
assert!(
parse(&["--plugin-verbose", "--discover", "-discover-timeout", "5"])
.unwrap()
.discover
);
assert!(parse(&["-plugin-mode", "fast", "-discover"]).is_err());
}
#[test]
fn every_go_flag_parses_in_single_and_double_dash_form() {
let argv = |a: &[&str]| {
go_flags(
&Args::command(),
std::iter::once("cliproxy").chain(a.iter().copied()).map(String::from),
&(),
)
.unwrap()
};
let args = Args::try_parse_from(argv(&[
"-discover",
"-discover-timeout",
"-2",
"--discover-json",
"-discover-service-type=_x._tcp",
"-discover-include",
"eth0,en0",
"-discover-include=wl*",
"-discover-exclude",
"docker0",
"-vertex-import",
"k.json",
"-vertex-import-prefix",
"p",
"-siwc-bind",
"codex-a.json",
"-home-jwt",
"j",
"-home-disable-cluster-discovery",
"-tui",
"-standalone",
"-management-base-url",
"https://x",
"-local-model",
"-antigravity-login",
"-devin-login",
"-config",
"c.yaml",
"-password",
"pw",
]))
.unwrap();
assert!(args.discover && args.discover_json && args.tui && args.standalone && args.local_model);
assert!(args.antigravity_login && args.devin_login && args.home_disable_cluster_discovery);
assert_eq!(args.discover_timeout, -2);
assert_eq!(csv_flags(&args.discover_include), ["eth0", "en0", "wl*"]);
assert_eq!(args.management_base_url, "https://x");
assert_eq!(args.siwc_bind, "codex-a.json");
let sub = |a: &[&str]| {
DiscoverArgs::try_parse_from(
go_flags(
&DiscoverArgs::command(),
std::iter::once("discover").chain(a.iter().copied()).map(String::from),
&(),
)
.unwrap(),
)
};
let parsed = sub(&[
"-timeout", "5", "-json", "-include", "a,b", "-include", "a", "-config", "x.yaml",
])
.unwrap();
assert_eq!(
(parsed.timeout, parsed.json, csv_flags(&parsed.include)),
(5, true, vec!["a".into(), "b".into(), "a".into()])
);
let parsed = sub(&[
"--json=true",
"-timeout",
"2",
"-timeout",
"-10",
"-config",
"-local.yaml",
])
.unwrap();
assert_eq!(
(parsed.json, parsed.timeout, parsed.config.as_str()),
(true, -10, "-local.yaml")
);
assert!(!sub(&["--json=false"]).unwrap().json);
assert!(!sub(&["-json", "-json=0"]).unwrap().json);
assert_eq!(sub(&["-timeout=0x10"]).unwrap().timeout, 16);
let parsed = sub(&["-json", "extra", "-timeout", "9"]).unwrap();
assert_eq!((parsed.json, parsed.timeout), (true, 3));
assert!(sub(&["-json=maybe"]).is_err());
assert!(sub(&["-nope"]).is_err());
assert!(sub(&["-timeout"]).is_err());
assert!(sub(&["-timeout", "1.5"]).is_err());
assert!(sub(&["---x"]).is_err());
}
#[test]
fn prescan_reads_every_spelling() {
for flag in ["working-dir", "log-file"] {
let scan = |a: &[&str]| {
let args: Vec<String> = a.iter().map(|s| s.replace("working-dir", flag)).collect();
prescan_value(&args, flag)
};
for spelling in [
&["-working-dir", "d"][..],
&["--working-dir", "d"],
&["-working-dir=d"],
&["--working-dir=d"],
&["-tui", "-config", "c.yaml", "--working-dir", "d", "-local-model"],
&["-working-dir", "x", "-working-dir=d"],
&["-plugin-mode", "fast", "-working-dir", "d"],
&["-plugin-verbose", "-working-dir", "d"],
] {
assert_eq!(scan(spelling).as_deref(), Some("d"), "{flag}: {spelling:?}");
}
assert_eq!(scan(&["-working-dir", "-d"]).as_deref(), Some("-d"), "{flag}");
assert_eq!(scan(&["-working-dir="]).as_deref(), Some(""), "{flag}");
assert_eq!(scan(&["-config", "-working-dir", "x"]), None, "{flag}");
assert_eq!(scan(&["-password", "--working-dir=x"]), None, "{flag}");
assert_eq!(scan(&["run", "-working-dir", "x"]), None, "{flag}");
assert_eq!(scan(&["--", "-working-dir", "x"]), None, "{flag}");
assert_eq!(scan(&["-working-dir"]), None, "{flag}");
assert_eq!(scan(&["discover", "-working-dir", "x"]), None, "{flag}");
}
let args = ["-working-dir", "-log-file", "l"].map(str::to_owned);
assert_eq!(prescan_value(&args, "log-file"), None);
let raw = ["cliproxy", "-tui", "--working-dir=d", "-log-file", "l"].map(str::to_owned);
let cmd = Args::command();
let matches = cmd.clone().get_matches_from(go_flags(&cmd, raw.clone(), &()).unwrap());
let args = Args::from_arg_matches(&matches).unwrap();
assert_eq!(args.working_dir.as_deref(), Some(Path::new("d")));
assert_eq!(args.log_file.as_deref(), Some(Path::new("l")));
assert_eq!(prescan_value(&raw[1..], "working-dir").as_deref(), Some("d"));
assert_eq!(prescan_value(&raw[1..], "log-file").as_deref(), Some("l"));
let builtin = plugin_cli::builtin_values(&cmd, &matches);
assert!(builtin.iter().all(|(n, _)| n != "working-dir" && n != "log-file"));
assert!(builtin.iter().any(|(n, v)| n == "tui" && v == "true"));
}
#[test]
fn go_int_matches_strconv_base_zero() {
for (s, want) in [
("3", Some(3)),
("-10", Some(-10)),
("+7", Some(7)),
("0x1f", Some(31)),
("010", Some(8)),
] {
assert_eq!(go_int(s).ok(), want, "{s}");
}
for (s, want) in [
("0b101", Some(5)),
("0o17", Some(15)),
("1_000", Some(1000)),
("0_10", Some(8)),
("", None),
] {
assert_eq!(go_int(s).ok(), want, "{s}");
}
for bad in ["9223372036854775808", "_1", "1_", "1__0", "0x", "1.5", "0x_"] {
assert!(go_int(bad).is_err(), "{bad}");
}
assert_eq!(go_int("0x_1f").ok(), Some(31));
assert_eq!(go_int("-9223372036854775808").ok(), Some(i64::MIN));
}
#[test]
fn standalone_url_follows_the_listener() {
let url = |addr: &str, tls| standalone_base_url((addr.parse().unwrap(), tls));
assert_eq!(url("127.0.0.1:4100", false).unwrap(), "http://127.0.0.1:4100");
assert_eq!(url("0.0.0.0:4101", false).unwrap(), "http://127.0.0.1:4101");
assert_eq!(url("[::]:4102", false).unwrap(), "http://[::1]:4102");
assert_eq!(url("[::1]:4103", false).unwrap(), "http://[::1]:4103");
assert!(url("192.0.2.7:4104", false).unwrap_err().contains("192.0.2.7"));
assert!(url("127.0.0.1:4105", true).unwrap_err().contains("server.tls"));
}
#[tokio::test]
async fn standalone_server_starts_without_any_secret() {
let dir = std::env::temp_dir().join(format!("cpa-standalone-{}", std::process::id()));
let auth = dir.join("auth");
std::fs::create_dir_all(&auth).unwrap();
let path = dir.join("config.yaml");
std::fs::write(
&path,
format!("host: 127.0.0.1\nport: 0\nauth-dir: '{}'\n", auth.display()),
)
.unwrap();
let config = Config::load(&path).unwrap();
assert!(config.management.secret_key.is_empty());
let (stop, stopped) = tokio::sync::oneshot::channel::<()>();
let (listening, listener) = tokio::sync::oneshot::channel();
let server = tokio::spawn(serve(
config,
path,
"fake-tui-password".into(),
true,
None,
None,
cpa_plugin::Host::default(),
async {
let _ = stopped.await;
},
Some(listening),
));
let base = standalone_base_url(listener.await.unwrap()).unwrap();
assert_ne!(base, "http://127.0.0.1:0");
assert!(tui::wait_ready(&base, "fake-tui-password").await);
let _ = stop.send(());
server.await.unwrap().unwrap();
let _ = std::fs::remove_dir_all(&dir);
}
#[tokio::test]
async fn siwc_bind_route_follows_management_availability() {
use tower::ServiceExt as _;
let dir = std::env::temp_dir().join(format!("cpa-siwc-route-{}", std::process::id()));
std::fs::create_dir_all(dir.join("auth")).unwrap();
let path = dir.join("config.yaml");
std::fs::write(&path, format!("auth-dir: '{}'\n", dir.join("auth").display())).unwrap();
let config = Config::load(&path).unwrap();
for (name, enabled, home, authorized, want) in [
("authorized invalid target", true, false, true, 400),
("missing management key", true, false, false, 401),
("management disabled", false, false, true, 404),
("home disabled local API", true, true, true, 404),
] {
let executors = Executors {
claude: ClaudeExecutor::new("http://127.0.0.1:9").unwrap(),
codex: Default::default(),
devices: Default::default(),
openai: Default::default(),
google: Default::default(),
};
let rt = Arc::new(cpa_server::testing::runtime(config.clone(), Vec::new(), executors));
let options = cpa_server::management::Options {
management_password: Some(if enabled {
"fake-management-only".into()
} else {
String::new()
}),
log_dir: Some(dir.join("logs")),
..Default::default()
};
let management = cpa_server::management::Management::with_options(rt.clone(), path.clone(), options);
let mut request = axum::http::Request::post("/v8/management/oauth/siwc/bind")
.header("content-type", "application/json")
.extension(axum::extract::ConnectInfo(SocketAddr::from((
Ipv4Addr::LOCALHOST,
1234,
))));
if authorized {
request = request.header("authorization", "Bearer fake-management-only");
}
let response = app(&rt, &management, home)
.oneshot(request.body(axum::body::Body::from("{}")).unwrap())
.await
.unwrap();
let status = response.status().as_u16();
let body = axum::body::to_bytes(response.into_body(), usize::MAX).await.unwrap();
assert_eq!(status, want, "{name}: {}", String::from_utf8_lossy(&body));
match want {
400 => assert_eq!(&body[..], br#"{"error":"name is required"}"#, "{name}"),
404 => assert!(body.is_empty(), "{name}: {}", String::from_utf8_lossy(&body)),
_ => {}
}
}
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn cloud_mode_treats_missing_empty_and_broken_files_as_empty_config() {
let dir = std::env::temp_dir().join(format!("cpa-cloud-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let missing = dir.join("missing.yaml");
assert_eq!(load_config(&missing, true).unwrap().port, 0);
assert!(load_config(&missing, false).is_err());
assert_eq!(load_config(&dir, true).unwrap().port, 0, "a directory is standby too");
for text in ["port: [\n", "port: wrong\n", "- a\n- b\n"] {
let broken = dir.join("broken.yaml");
std::fs::write(&broken, text).unwrap();
assert_eq!(load_config(&broken, true).unwrap().port, 0, "{text}");
assert!(load_config(&broken, false).is_err(), "{text}");
}
let good = dir.join("good.yaml");
std::fs::write(&good, "port: 9\n").unwrap();
let cfg = load_config(&good, true).unwrap();
assert!(cloud_config_present(&good, &cfg));
assert!(!cloud_config_present(&missing, &Config::parse("").unwrap()));
assert!(!cloud_config_present(&dir, &Config::parse("").unwrap()));
let _ = std::fs::rename(
&dir,
std::env::temp_dir().join(format!("cpa-trash-cloud-{}", std::process::id())),
);
}
#[tokio::test]
async fn explicit_host_listener_is_nonblocking_for_tokio() {
let listener = bind("127.0.0.1", 0).unwrap();
let port = listener.local_addr().unwrap().port();
let listener = tokio::net::TcpListener::from_std(listener).unwrap();
let client = tokio::net::TcpStream::connect((Ipv4Addr::LOCALHOST, port));
let (client, accepted) = tokio::join!(client, listener.accept());
assert!(client.is_ok() && accepted.is_ok());
}
#[test]
fn empty_host_is_dual_stack_and_port_in_use_is_an_error() {
let listener = bind("", 0).unwrap();
let port = listener.local_addr().unwrap().port();
if listener.local_addr().unwrap().is_ipv6() {
std::net::TcpStream::connect((Ipv4Addr::LOCALHOST, port)).expect("IPv4 reaches the [::] listener");
std::net::TcpStream::connect((Ipv6Addr::LOCALHOST, port)).expect("IPv6 reaches the [::] listener");
}
let err = bind("", port).unwrap_err();
assert_eq!(
err.kind(),
io::ErrorKind::AddrInUse,
"must not silently fall back to IPv4"
);
}
}