scriptoriumadmin/fabro
1
0
Fork 0
mirror of https://github.com/fabro-sh/fabro.git synced 2026-09-06 08:18:58 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Rename *config* variables/params that hold *Settings types

Browse source 
Local variables and function parameters named with "config" but holding
*Settings types (FabroSettings, TlsSettings, ApiSettings, LlmSettings)
are renamed to use "settings" for consistency with the type system.
Module paths (cli_config::) and struct fields are unchanged.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
Bryan Helmkamp 2026-03-28 15:15:15 -04:00
parent 52d0478a47
commit 2eb39d368c
40 changed files with 160 additions and 152 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
lib/crates/fabro-api/src/jwt_auth.rs
View file

@ -69,14 +69,14 @@ pub fn decode_pem_env(name: &str, value: &str) -> String {
///
/// Call this once at startup before serving requests. Panics if the
/// configuration is invalid (JWT strategy but no public key, or mTLS without TLS config).
pub fn resolve_auth_mode(api_config: &ApiSettings, allowed_usernames: &[String]) -> AuthMode {
pub fn resolve_auth_mode(api_settings: &ApiSettings, allowed_usernames: &[String]) -> AuthMode {
use fabro_config::server::ApiAuthStrategy;
if api_config.authentication_strategies.is_empty() {
if api_settings.authentication_strategies.is_empty() {
warn!("No authentication strategies configured; all requests will be rejected");
}
let strategies = api_config
let strategies = api_settings
.authentication_strategies
.iter()
.map(|s| match s {
@ -98,7 +98,7 @@ pub fn resolve_auth_mode(api_config: &ApiSettings, allowed_usernames: &[String])
}
ApiAuthStrategy::Mtls => {
assert!(
api_config.tls.is_some(),
api_settings.tls.is_some(),
"mTLS authentication strategy requires [api.tls] configuration with cert, key, and ca"
);
AuthStrategy::Mtls

36
lib/crates/fabro-api/src/serve.rs
View file

@ -93,17 +93,17 @@ pub async fn serve_command(args: ServeArgs, styles: &'static Styles) -> anyhow::
let data_dir = resolve_storage_dir(&server_settings);
// Shared config for live reloading
let shared_config = Arc::new(RwLock::new(server_settings));
let shared_settings = Arc::new(RwLock::new(server_settings));
// CLI overrides take precedence over config file values, even after reload
let cli_model = args.model;
let cli_provider = args.provider;
// Build registry factory that reads live config
let config_for_factory = Arc::clone(&shared_config);
let settings_for_factory = Arc::clone(&shared_settings);
let factory = move || {
let (model, provider_enum) = resolve_model_provider(
&config_for_factory,
&settings_for_factory,
cli_model.as_deref(),
cli_provider.as_deref(),
);
@ -120,7 +120,7 @@ pub async fn serve_command(args: ServeArgs, styles: &'static Styles) -> anyhow::
fabro_db::initialize_db(&db).await?;
let (auth_mode, client_auth, max_concurrent_runs) = {
let cfg = shared_config.read().expect("config lock poisoned");
let cfg = shared_settings.read().expect("config lock poisoned");
let api = cfg.api.clone().unwrap_or_default();
let allowed_usernames = cfg
.web
@ -137,7 +137,7 @@ pub async fn serve_command(args: ServeArgs, styles: &'static Styles) -> anyhow::
};
let git_author = {
let cfg = shared_config.read().expect("config lock poisoned");
let cfg = shared_settings.read().expect("config lock poisoned");
let author = cfg.git_author();
GitAuthor::from_options(
author.and_then(|a| a.name.clone()),
@ -145,7 +145,7 @@ pub async fn serve_command(args: ServeArgs, styles: &'static Styles) -> anyhow::
)
};
let hooks = {
let cfg = shared_config.read().expect("config lock poisoned");
let cfg = shared_settings.read().expect("config lock poisoned");
cfg.hooks.clone()
};
let state = create_app_state_with_options(
@ -177,7 +177,7 @@ pub async fn serve_command(args: ServeArgs, styles: &'static Styles) -> anyhow::
// Optionally start webhook listener
let webhook_app_id = {
let cfg = shared_config.read().expect("config lock poisoned");
let cfg = shared_settings.read().expect("config lock poisoned");
cfg.git
.as_ref()
.and_then(|g| g.webhooks.as_ref().and(g.app_id.as_ref()))
@ -206,7 +206,7 @@ pub async fn serve_command(args: ServeArgs, styles: &'static Styles) -> anyhow::
};
// Spawn config polling task
let config_for_poll = Arc::clone(&shared_config);
let settings_for_poll = Arc::clone(&shared_settings);
let config_path_for_poll = config_path.clone();
tokio::spawn(async move {
let mut interval = interval(Duration::from_secs(5));
@ -214,14 +214,14 @@ pub async fn serve_command(args: ServeArgs, styles: &'static Styles) -> anyhow::
loop {
interval.tick().await;
match load_server_settings(config_path_for_poll.as_deref()) {
Ok(new_config) => {
Ok(new_settings) => {
let changed = {
let cfg = config_for_poll.read().expect("config lock poisoned");
*cfg != new_config
let cfg = settings_for_poll.read().expect("config lock poisoned");
*cfg != new_settings
};
if changed {
let mut cfg = config_for_poll.write().expect("config lock poisoned");
*cfg = new_config;
let mut cfg = settings_for_poll.write().expect("config lock poisoned");
*cfg = new_settings;
info!("Server config reloaded");
}
}
@ -233,16 +233,16 @@ pub async fn serve_command(args: ServeArgs, styles: &'static Styles) -> anyhow::
});
// Branch: TLS or plain HTTP
let tls_config = shared_config
let tls_settings = shared_settings
.read()
.expect("config lock poisoned")
.api
.as_ref()
.and_then(|a| a.tls.clone());
if let Some(ref tls_config) = tls_config {
if let Some(ref tls_settings) = tls_settings {
let client_auth = client_auth.unwrap();
let rustls_config = build_rustls_config(tls_config, client_auth);
let rustls_config = build_rustls_config(tls_settings, client_auth);
let tls_acceptor = tokio_rustls::TlsAcceptor::from(rustls_config);
info!("TLS enabled");
@ -262,11 +262,11 @@ pub async fn serve_command(args: ServeArgs, styles: &'static Styles) -> anyhow::
/// Resolve model and provider from shared config, with CLI overrides taking precedence.
fn resolve_model_provider(
shared_config: &RwLock<FabroSettings>,
shared_settings: &RwLock<FabroSettings>,
cli_model: Option<&str>,
cli_provider: Option<&str>,
) -> (String, Provider) {
let cfg = shared_config.read().expect("config lock poisoned");
let cfg = shared_settings.read().expect("config lock poisoned");
let config_provider = cfg.llm.as_ref().and_then(|l| l.provider.as_deref());
let config_model = cfg.llm.as_ref().and_then(|l| l.model.as_deref());

11
lib/crates/fabro-api/src/tls.rs
View file

@ -23,9 +23,12 @@ pub enum ClientAuth {
}
/// Build a rustls `ServerConfig` from the `[api.tls]` configuration.
pub fn build_rustls_config(tls_config: &TlsSettings, client_auth: ClientAuth) -> Arc<ServerConfig> {
let certs = load_certs(&tls_config.cert);
let key = load_private_key(&tls_config.key);
pub fn build_rustls_config(
tls_settings: &TlsSettings,
client_auth: ClientAuth,
) -> Arc<ServerConfig> {
let certs = load_certs(&tls_settings.cert);
let key = load_private_key(&tls_settings.key);
let config = match client_auth {
ClientAuth::None => ServerConfig::builder()
@ -33,7 +36,7 @@ pub fn build_rustls_config(tls_config: &TlsSettings, client_auth: ClientAuth) ->
.with_single_cert(certs, key)
.expect("invalid server certificate or key"),
ClientAuth::Required | ClientAuth::Optional => {
let ca_certs = load_certs(&tls_config.ca);
let ca_certs = load_certs(&tls_settings.ca);
let mut root_store = rustls::RootCertStore::empty();
for cert in ca_certs {
root_store

20
lib/crates/fabro-api/tests/integration.rs
View file

@ -181,14 +181,14 @@ mod mtls_e2e {
/// Start a TLS server on a random port, returning the bound address.
async fn start_tls_server(
tls_config: &TlsSettings,
tls_settings: &TlsSettings,
client_auth: ClientAuth,
auth_mode: AuthMode,
) -> std::net::SocketAddr {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let rustls_config = build_rustls_config(tls_config, client_auth);
let rustls_config = build_rustls_config(tls_settings, client_auth);
let tls_acceptor = tokio_rustls::TlsAcceptor::from(rustls_config);
let state = create_app_state(test_db().await, test_llm_spec);
@ -236,14 +236,14 @@ mod mtls_e2e {
let dir = tempfile::tempdir().unwrap();
let pki = generate_pki(dir.path(), "TestCA", "localhost", "testuser");
let tls_config = TlsSettings {
let tls_settings = TlsSettings {
cert: pki.server_cert.clone(),
key: pki.server_key.clone(),
ca: pki.ca_cert.clone(),
};
let auth_mode = AuthMode::Strategies(vec![AuthStrategy::Mtls]);
let addr = start_tls_server(&tls_config, ClientAuth::Required, auth_mode).await;
let addr = start_tls_server(&tls_settings, ClientAuth::Required, auth_mode).await;
let client = build_client(&pki.ca_cert, Some(&pki.client_cert), Some(&pki.client_key));
@ -262,14 +262,14 @@ mod mtls_e2e {
let dir = tempfile::tempdir().unwrap();
let pki = generate_pki(dir.path(), "TestCA", "localhost", "testuser");
let tls_config = TlsSettings {
let tls_settings = TlsSettings {
cert: pki.server_cert.clone(),
key: pki.server_key.clone(),
ca: pki.ca_cert.clone(),
};
let auth_mode = AuthMode::Strategies(vec![AuthStrategy::Mtls]);
let addr = start_tls_server(&tls_config, ClientAuth::Required, auth_mode).await;
let addr = start_tls_server(&tls_settings, ClientAuth::Required, auth_mode).await;
// Generate a DIFFERENT CA and client cert signed by it
let wrong_dir = dir.path().join("wrong_ca");
@ -303,7 +303,7 @@ mod mtls_e2e {
let dir = tempfile::tempdir().unwrap();
let pki = generate_pki(dir.path(), "TestCA", "localhost", "testuser");
let tls_config = TlsSettings {
let tls_settings = TlsSettings {
cert: pki.server_cert.clone(),
key: pki.server_key.clone(),
ca: pki.ca_cert.clone(),
@ -311,7 +311,7 @@ mod mtls_e2e {
// mTLS is the ONLY strategy → client cert is required at TLS level
let auth_mode = AuthMode::Strategies(vec![AuthStrategy::Mtls]);
let addr = start_tls_server(&tls_config, ClientAuth::Required, auth_mode).await;
let addr = start_tls_server(&tls_settings, ClientAuth::Required, auth_mode).await;
// Client trusts the server CA but presents NO client cert
let client = build_client(&pki.ca_cert, None, None);
@ -378,7 +378,7 @@ mod mtls_e2e {
let dir = tempfile::tempdir().unwrap();
let pki = generate_pki(dir.path(), "TestCA", "localhost", "testuser");
let tls_config = TlsSettings {
let tls_settings = TlsSettings {
cert: pki.server_cert.clone(),
key: pki.server_key.clone(),
ca: pki.ca_cert.clone(),
@ -395,7 +395,7 @@ mod mtls_e2e {
allowed_usernames: vec!["brynary".to_string()],
},
]);
let addr = start_tls_server(&tls_config, ClientAuth::Optional, auth_mode).await;
let addr = start_tls_server(&tls_settings, ClientAuth::Optional, auth_mode).await;
// Client trusts the server CA but presents NO client cert
let client = build_client(&pki.ca_cert, None, None);

28
lib/crates/fabro-cli/src/cli_config.rs
View file

@ -28,11 +28,13 @@ const DEFAULT_SERVER_URL: &str = "http://localhost:3000";
pub fn resolve_mode(
cli_mode: Option<ExecutionMode>,
cli_server_url: Option<&str>,
config: &FabroSettings,
settings: &FabroSettings,
) -> ResolvedMode {
let mode = cli_mode.or_else(|| config.mode.clone()).unwrap_or_default();
let mode = cli_mode
.or_else(|| settings.mode.clone())
.unwrap_or_default();
let server_defaults = config.server.as_ref();
let server_defaults = settings.server.as_ref();
let server_base_url = cli_server_url
.map(String::from)
@ -90,8 +92,8 @@ mod tests {
#[test]
fn resolve_mode_defaults_to_standalone() {
let config = FabroSettings::default();
let resolved = resolve_mode(None, None, &config);
let settings = FabroSettings::default();
let resolved = resolve_mode(None, None, &settings);
assert_eq!(resolved.mode, ExecutionMode::Standalone);
assert_eq!(resolved.server_base_url, DEFAULT_SERVER_URL);
assert_eq!(resolved.tls, None);
@ -99,7 +101,7 @@ mod tests {
#[test]
fn resolve_mode_config_overrides_default() {
let config = FabroSettings {
let settings = FabroSettings {
mode: Some(ExecutionMode::Server),
server: Some(ServerSettings {
base_url: Some("https://config.example.com".to_string()),
@ -107,14 +109,14 @@ mod tests {
}),
..FabroSettings::default()
};
let resolved = resolve_mode(None, None, &config);
let resolved = resolve_mode(None, None, &settings);
assert_eq!(resolved.mode, ExecutionMode::Server);
assert_eq!(resolved.server_base_url, "https://config.example.com");
}
#[test]
fn resolve_mode_cli_overrides_config() {
let config = FabroSettings {
let settings = FabroSettings {
mode: Some(ExecutionMode::Standalone),
server: Some(ServerSettings {
base_url: Some("https://config.example.com".to_string()),
@ -125,7 +127,7 @@ mod tests {
let resolved = resolve_mode(
Some(ExecutionMode::Server),
Some("https://cli.example.com"),
&config,
&settings,
);
assert_eq!(resolved.mode, ExecutionMode::Server);
assert_eq!(resolved.server_base_url, "https://cli.example.com");
@ -133,14 +135,14 @@ mod tests {
#[test]
fn resolve_mode_cli_url_overrides_config_url() {
let config = FabroSettings {
let settings = FabroSettings {
server: Some(ServerSettings {
base_url: Some("https://config.example.com".to_string()),
tls: None,
}),
..FabroSettings::default()
};
let resolved = resolve_mode(None, Some("https://cli.example.com"), &config);
let resolved = resolve_mode(None, Some("https://cli.example.com"), &settings);
assert_eq!(resolved.server_base_url, "https://cli.example.com");
}
@ -151,14 +153,14 @@ mod tests {
key: PathBuf::from("key.pem"),
ca: PathBuf::from("ca.pem"),
};
let config = FabroSettings {
let settings = FabroSettings {
server: Some(ServerSettings {
base_url: None,
tls: Some(tls.clone()),
}),
..FabroSettings::default()
};
let resolved = resolve_mode(None, None, &config);
let resolved = resolve_mode(None, None, &settings);
assert_eq!(resolved.tls, Some(tls));
}
}

4
lib/crates/fabro-cli/src/commands/asset/cp.rs
View file

@ -11,8 +11,8 @@ use crate::cli_config::load_cli_settings;
use crate::shared::split_run_path;
pub(super) fn cp_command(args: &AssetCpArgs) -> Result<()> {
let cli_config = load_cli_settings(None)?;
let base = runs_base(&cli_config.storage_dir());
let cli_settings = load_cli_settings(None)?;
let base = runs_base(&cli_settings.storage_dir());
let (run_id, asset_path) = parse_source(&args.source);
let run = resolve_run(&base, run_id)?;
let runtime_state = RuntimeState::new(&run.path);

4
lib/crates/fabro-cli/src/commands/asset/list.rs
View file

@ -9,8 +9,8 @@ use crate::cli_config::load_cli_settings;
use crate::shared::format_size;
pub(super) fn list_command(args: &AssetListArgs) -> Result<()> {
let cli_config = load_cli_settings(None)?;
let base = runs_base(&cli_config.storage_dir());
let cli_settings = load_cli_settings(None)?;
let base = runs_base(&cli_settings.storage_dir());
let run = resolve_run(&base, &args.run_id)?;
let runtime_state = RuntimeState::new(&run.path);
let entries = scan_assets(&runtime_state.assets_dir(), args.node.as_deref())?;

18
lib/crates/fabro-cli/src/commands/doctor.rs
View file

@ -938,7 +938,7 @@ pub(crate) async fn run_doctor(verbose: bool, live: bool) -> i32 {
spinner.enable_steady_tick(std::time::Duration::from_millis(80));
// Gather state
let cli_config = load_cli_settings(None).unwrap_or_default();
let cli_settings = load_cli_settings(None).unwrap_or_default();
let config_path = dirs::home_dir().map(|h| h.join(".fabro").join("cli.toml"));
let config_exists = config_path.as_ref().is_some_and(|p| p.exists());
@ -953,11 +953,11 @@ pub(crate) async fn run_doctor(verbose: bool, live: bool) -> i32 {
let daytona_configured = std::env::var("DAYTONA_API_KEY").is_ok();
#[cfg(feature = "server")]
let server_config = fabro_config::server::load_server_settings(None).unwrap_or_default();
let server_settings = fabro_config::server::load_server_settings(None).unwrap_or_default();
#[cfg(feature = "server")]
let api_status = {
let api = server_config.api.clone().unwrap_or_default();
let api = server_settings.api.clone().unwrap_or_default();
ApiStatus {
base_url: api.base_url.clone(),
authentication_strategies: api.authentication_strategies.clone(),
@ -966,7 +966,7 @@ pub(crate) async fn run_doctor(verbose: bool, live: bool) -> i32 {
#[cfg(feature = "server")]
let web_status = {
let web = server_config.web.clone().unwrap_or_default();
let web = server_settings.web.clone().unwrap_or_default();
WebStatus {
url: web.url.clone(),
auth_provider: web.auth.provider.clone(),
@ -975,15 +975,15 @@ pub(crate) async fn run_doctor(verbose: bool, live: bool) -> i32 {
};
#[cfg(feature = "server")]
let server_git = server_config.git.clone().unwrap_or_default();
let server_git = server_settings.git.clone().unwrap_or_default();
#[cfg(feature = "server")]
let server_api = server_config.api.clone().unwrap_or_default();
let server_api = server_settings.api.clone().unwrap_or_default();
#[cfg(feature = "server")]
let server_web = server_config.web.clone().unwrap_or_default();
let server_web = server_settings.web.clone().unwrap_or_default();
let git_app_id = cli_config.app_id().map(str::to_owned);
let git_app_id = cli_settings.app_id().map(str::to_owned);
let private_key_raw = std::env::var("GITHUB_APP_PRIVATE_KEY").ok();
let sign_result = match (&git_app_id, &private_key_raw) {
(Some(app_id), Some(raw)) => {
@ -1011,7 +1011,7 @@ pub(crate) async fn run_doctor(verbose: bool, live: bool) -> i32 {
};
let github_status = GithubAppStatus {
app_id: git_app_id,
slug: cli_config.slug().map(str::to_owned),
slug: cli_settings.slug().map(str::to_owned),
private_key_set: private_key_raw.is_some(),
sign_result,
#[cfg(feature = "server")]

10
lib/crates/fabro-cli/src/commands/exec.rs
View file

@ -9,10 +9,10 @@ use crate::args::GlobalArgs;
use crate::cli_config;
pub(crate) async fn execute(mut args: AgentArgs, globals: &GlobalArgs) -> Result<()> {
let cli_config = cli_config::load_cli_settings(None)?;
let cli_settings = cli_config::load_cli_settings(None)?;
#[cfg(feature = "sleep_inhibitor")]
let _sleep_guard = crate::sleep_inhibitor::guard(cli_config.prevent_idle_sleep_enabled());
let exec_defaults = cli_config.exec.as_ref();
let _sleep_guard = crate::sleep_inhibitor::guard(cli_settings.prevent_idle_sleep_enabled());
let exec_defaults = cli_settings.exec.as_ref();
args.apply_cli_defaults(
exec_defaults.and_then(|a| a.provider.as_deref()),
exec_defaults.and_then(|a| a.model.as_deref()),
@ -23,9 +23,9 @@ pub(crate) async fn execute(mut args: AgentArgs, globals: &GlobalArgs) -> Result
let resolved = cli_config::resolve_mode(
globals.mode.clone(),
globals.server_url.as_deref(),
&cli_config,
&cli_settings,
);
let mcp_servers: Vec<McpServerConfig> = cli_config
let mcp_servers: Vec<McpServerConfig> = cli_settings
.mcp_servers
.into_iter()
.map(|(name, entry): (String, McpServerEntry)| entry.into_config(name))

15
lib/crates/fabro-cli/src/commands/install.rs
View file

@ -920,18 +920,21 @@ mod tests {
#[cfg(feature = "server")]
fn config_toml_roundtrips() {
let toml_str = format_config_toml("brynary");
let config: fabro_config::FabroSettings =
let settings: fabro_config::FabroSettings =
toml::from_str(&toml_str).expect("config should parse");
assert_eq!(config.web.unwrap().auth.allowed_usernames, vec!["brynary"]);
assert_eq!(
settings.web.unwrap().auth.allowed_usernames,
vec!["brynary"]
);
}
#[test]
#[cfg(feature = "server")]
fn config_toml_has_auth_strategies() {
let toml_str = format_config_toml("alice");
let config: fabro_config::FabroSettings = toml::from_str(&toml_str).unwrap();
let settings: fabro_config::FabroSettings = toml::from_str(&toml_str).unwrap();
assert_eq!(
config.api.unwrap().authentication_strategies,
settings.api.unwrap().authentication_strategies,
vec![
fabro_config::server::ApiAuthStrategy::Jwt,
fabro_config::server::ApiAuthStrategy::Mtls,
@ -944,8 +947,8 @@ mod tests {
fn config_toml_has_tls_paths() {
use std::path::PathBuf;
let toml_str = format_config_toml("bob");
let config: fabro_config::FabroSettings = toml::from_str(&toml_str).unwrap();
let tls = config.api.unwrap().tls.expect("tls should be set");
let settings: fabro_config::FabroSettings = toml::from_str(&toml_str).unwrap();
let tls = settings.api.unwrap().tls.expect("tls should be set");
assert_eq!(tls.cert, PathBuf::from("~/.fabro/certs/server.crt"));
assert_eq!(tls.key, PathBuf::from("~/.fabro/certs/server.key"));
assert_eq!(tls.ca, PathBuf::from("~/.fabro/certs/ca.crt"));

6
lib/crates/fabro-cli/src/commands/llm/chat.rs
View file

@ -8,10 +8,10 @@ use crate::args::GlobalArgs;
pub(super) async fn execute(
mut args: ChatArgs,
cli_config: &FabroSettings,
cli_settings: &FabroSettings,
globals: &GlobalArgs,
) -> Result<()> {
let llm_defaults = cli_config.llm.as_ref();
let llm_defaults = cli_settings.llm.as_ref();
if args.model.is_none() {
args.model = llm_defaults.and_then(|l| l.model.clone());
}
@ -21,7 +21,7 @@ pub(super) async fn execute(
let resolved = crate::cli_config::resolve_mode(
globals.mode.clone(),
globals.server_url.as_deref(),
cli_config,
cli_settings,
);
match resolved.mode {
crate::cli_config::ExecutionMode::Server => {

6
lib/crates/fabro-cli/src/commands/llm/mod.rs
View file

@ -7,10 +7,10 @@ use crate::args::{GlobalArgs, LlmCommand, LlmNamespace};
use crate::cli_config::load_cli_settings;
pub(crate) async fn dispatch(ns: LlmNamespace, globals: &GlobalArgs) -> Result<()> {
let cli_config = load_cli_settings(None)?;
let cli_settings = load_cli_settings(None)?;
match ns.command {
LlmCommand::Prompt(args) => prompt::execute(args, &cli_config, globals).await,
LlmCommand::Chat(args) => chat::execute(args, &cli_config, globals).await,
LlmCommand::Prompt(args) => prompt::execute(args, &cli_settings, globals).await,
LlmCommand::Chat(args) => chat::execute(args, &cli_settings, globals).await,
}
}

6
lib/crates/fabro-cli/src/commands/llm/prompt.rs
View file

@ -8,10 +8,10 @@ use crate::args::GlobalArgs;
pub(super) async fn execute(
mut args: PromptArgs,
cli_config: &FabroSettings,
cli_settings: &FabroSettings,
globals: &GlobalArgs,
) -> Result<()> {
let llm_defaults = cli_config.llm.as_ref();
let llm_defaults = cli_settings.llm.as_ref();
if args.model.is_none() {
args.model = llm_defaults.and_then(|l| l.model.clone());
}
@ -21,7 +21,7 @@ pub(super) async fn execute(
let resolved = crate::cli_config::resolve_mode(
globals.mode.clone(),
globals.server_url.as_deref(),
cli_config,
cli_settings,
);
match resolved.mode {
crate::cli_config::ExecutionMode::Server => {

4
lib/crates/fabro-cli/src/commands/model.rs
View file

@ -11,11 +11,11 @@ pub(crate) async fn execute(command: Option<ModelsCommand>, globals: &GlobalArgs
let server = {
#[cfg(feature = "server")]
{
let cli_config = cli_config::load_cli_settings(None)?;
let cli_settings = cli_config::load_cli_settings(None)?;
let resolved = cli_config::resolve_mode(
globals.mode.clone(),
globals.server_url.as_deref(),
&cli_config,
&cli_settings,
);
match resolved.mode {
cli_config::ExecutionMode::Server => {

4
lib/crates/fabro-cli/src/commands/pr/close.rs
View file

@ -12,8 +12,8 @@ pub(super) async fn close_command(
args: PrCloseArgs,
github_app: Option<fabro_github::GitHubAppCredentials>,
) -> Result<()> {
let cli_config = load_cli_settings(None)?;
let base = runs_base(&cli_config.storage_dir());
let cli_settings = load_cli_settings(None)?;
let base = runs_base(&cli_settings.storage_dir());
close_from(&base, args, github_app).await
}

4
lib/crates/fabro-cli/src/commands/pr/create.rs
View file

@ -19,8 +19,8 @@ pub(super) async fn create_command(
args: PrCreateArgs,
github_app: Option<fabro_github::GitHubAppCredentials>,
) -> Result<()> {
let cli_config = load_cli_settings(None)?;
let base = runs_base(&cli_config.storage_dir());
let cli_settings = load_cli_settings(None)?;
let base = runs_base(&cli_settings.storage_dir());
create_from(&base, args, github_app).await
}

4
lib/crates/fabro-cli/src/commands/pr/list.rs
View file

@ -14,8 +14,8 @@ pub(super) async fn list_command(
args: PrListArgs,
github_app: Option<fabro_github::GitHubAppCredentials>,
) -> Result<()> {
let cli_config = load_cli_settings(None)?;
let base = runs_base(&cli_config.storage_dir());
let cli_settings = load_cli_settings(None)?;
let base = runs_base(&cli_settings.storage_dir());
list_from(&base, args, github_app).await
}

4
lib/crates/fabro-cli/src/commands/pr/merge.rs
View file

@ -13,8 +13,8 @@ pub(super) async fn merge_command(
args: PrMergeArgs,
github_app: Option<fabro_github::GitHubAppCredentials>,
) -> Result<()> {
let cli_config = load_cli_settings(None)?;
let base = runs_base(&cli_config.storage_dir());
let cli_settings = load_cli_settings(None)?;
let base = runs_base(&cli_settings.storage_dir());
merge_from(&base, args, github_app).await
}

4
lib/crates/fabro-cli/src/commands/pr/mod.rs
View file

@ -16,8 +16,8 @@ use crate::cli_config::load_cli_settings;
use crate::shared::github::build_github_app_credentials;
pub(crate) async fn dispatch(ns: PrNamespace) -> Result<()> {
let cli_config = load_cli_settings(None)?;
let github_app = build_github_app_credentials(cli_config.app_id());
let cli_settings = load_cli_settings(None)?;
let github_app = build_github_app_credentials(cli_settings.app_id());
match ns.command {
PrCommand::Create(args) => create::create_command(args, github_app).await,

4
lib/crates/fabro-cli/src/commands/pr/view.rs
View file

@ -13,8 +13,8 @@ pub(super) async fn view_command(
args: PrViewArgs,
github_app: Option<fabro_github::GitHubAppCredentials>,
) -> Result<()> {
let cli_config = load_cli_settings(None)?;
let base = runs_base(&cli_config.storage_dir());
let cli_settings = load_cli_settings(None)?;
let base = runs_base(&cli_settings.storage_dir());
view_from(&base, args, github_app).await
}

6
lib/crates/fabro-cli/src/commands/preflight.rs
View file

@ -24,10 +24,10 @@ use crate::shared::github::build_github_app_credentials;
pub(crate) async fn execute(mut args: PreflightArgs) -> anyhow::Result<()> {
let styles: &'static Styles = Box::leak(Box::new(Styles::detect_stderr()));
let cli_defaults = load_cli_config(None)?;
let cli_config: FabroSettings = cli_defaults.clone().try_into()?;
args.verbose = args.verbose || cli_config.verbose_enabled();
let cli_settings: FabroSettings = cli_defaults.clone().try_into()?;
args.verbose = args.verbose || cli_settings.verbose_enabled();
let github_app = build_github_app_credentials(cli_config.app_id());
let github_app = build_github_app_credentials(cli_settings.app_id());
let cli_args_config = FabroConfig::try_from(&args)?;
let cwd = std::env::current_dir()?;
let settings = resolve_settings(ResolveSettingsInput {

6
lib/crates/fabro-cli/src/commands/repo/init.rs
View file

@ -153,11 +153,11 @@ async fn check_github_app_installation() {
};
// Load CLI config to get app_id and slug
let Ok(cli_config) = load_cli_settings(None) else {
let Ok(cli_settings) = load_cli_settings(None) else {
return;
};
let app_id = if let Some(id) = cli_config.app_id() {
let app_id = if let Some(id) = cli_settings.app_id() {
id.to_string()
} else {
eprintln!(
@ -170,7 +170,7 @@ async fn check_github_app_installation() {
return;
};
let slug = cli_config.slug().map(String::from);
let slug = cli_settings.slug().map(String::from);
// Build GitHub App credentials
let Some(creds) = build_github_app_credentials(Some(&app_id)) else {

6
lib/crates/fabro-cli/src/commands/run/command.rs
View file

@ -7,11 +7,11 @@ use crate::args::{GlobalArgs, RunArgs};
pub(crate) async fn execute(mut args: RunArgs, _globals: &GlobalArgs) -> Result<()> {
let styles: &'static Styles = Box::leak(Box::new(Styles::detect_stderr()));
let cli_defaults = load_cli_config(None)?;
let cli_config: fabro_config::FabroSettings = cli_defaults.clone().try_into()?;
args.verbose = args.verbose || cli_config.verbose_enabled();
let cli_settings: fabro_config::FabroSettings = cli_defaults.clone().try_into()?;
args.verbose = args.verbose || cli_settings.verbose_enabled();
let quiet = args.detach;
let prevent_idle_sleep = cli_config.prevent_idle_sleep_enabled();
let prevent_idle_sleep = cli_settings.prevent_idle_sleep_enabled();
let (run_id, run_dir) = super::create::create_run(&args, cli_defaults, styles, quiet)?;
#[cfg(feature = "sleep_inhibitor")]

4
lib/crates/fabro-cli/src/commands/run/cp.rs
View file

@ -28,8 +28,8 @@ enum CopyDirection {
pub(crate) async fn cp_command(args: CpArgs) -> Result<()> {
let direction = parse_direction(&args.src, &args.dst)?;
let cli_config = load_cli_settings(None)?;
let base = runs_base(&cli_config.storage_dir());
let cli_settings = load_cli_settings(None)?;
let base = runs_base(&cli_settings.storage_dir());
match direction {
CopyDirection::Download {

8
lib/crates/fabro-cli/src/commands/run/detached.rs
View file

@ -12,11 +12,11 @@ use crate::cli_config;
use crate::shared;
pub(crate) async fn execute(run_dir: PathBuf, launcher_path: PathBuf, resume: bool) -> Result<()> {
let cli_config = cli_config::load_cli_settings(None)?;
let github_app = shared::github::build_github_app_credentials(cli_config.app_id());
let cli_settings = cli_config::load_cli_settings(None)?;
let github_app = shared::github::build_github_app_credentials(cli_settings.app_id());
let git_author = GitAuthor::from_options(
cli_config.git_author().and_then(|a| a.name.clone()),
cli_config.git_author().and_then(|a| a.email.clone()),
cli_settings.git_author().and_then(|a| a.name.clone()),
cli_settings.git_author().and_then(|a| a.email.clone()),
);
let _launcher_guard = scopeguard::guard(launcher_path.clone(), |path| {

4
lib/crates/fabro-cli/src/commands/run/diff.rs
View file

@ -15,8 +15,8 @@ use crate::cli_config::load_cli_settings;
pub(crate) async fn run(args: DiffArgs) -> Result<()> {
info!(run_id = %args.run, "Showing diff");
let cli_config = load_cli_settings(None)?;
let base = runs_base(&cli_config.storage_dir());
let cli_settings = load_cli_settings(None)?;
let base = runs_base(&cli_settings.storage_dir());
let run_dir = resolve_run(&base, &args.run)?.path;
let patch = resolve_diff(&run_dir, &args).await?;

4
lib/crates/fabro-cli/src/commands/run/logs.rs
View file

@ -12,8 +12,8 @@ use crate::args::LogsArgs;
use crate::cli_config::load_cli_settings;
pub(crate) fn run(args: &LogsArgs, styles: &Styles) -> Result<()> {
let cli_config = load_cli_settings(None)?;
let base = runs_base(&cli_config.storage_dir());
let cli_settings = load_cli_settings(None)?;
let base = runs_base(&cli_settings.storage_dir());
let run = resolve_run(&base, &args.run)?;
info!(run_id = %run.run_id, "Showing logs");

12
lib/crates/fabro-cli/src/commands/run/mod.rs
View file

@ -37,8 +37,8 @@ pub(crate) async fn dispatch(cmd: RunCommands, globals: &GlobalArgs) -> Result<(
Ok(())
}
RunCommands::Start { run } => {
let cli_config = load_cli_settings(None)?;
let base = runs_base(&cli_config.storage_dir());
let cli_settings = load_cli_settings(None)?;
let base = runs_base(&cli_settings.storage_dir());
let run_info = resolve_run(&base, &run)?;
let child = start::start_run(&run_info.path, false)?;
eprintln!("Started engine process (PID {})", child.id());
@ -46,8 +46,8 @@ pub(crate) async fn dispatch(cmd: RunCommands, globals: &GlobalArgs) -> Result<(
}
RunCommands::Attach { run } => {
let styles: &'static Styles = Box::leak(Box::new(Styles::detect_stderr()));
let cli_config = load_cli_settings(None)?;
let base = runs_base(&cli_config.storage_dir());
let cli_settings = load_cli_settings(None)?;
let base = runs_base(&cli_settings.storage_dir());
let run_info = resolve_run(&base, &run)?;
let exit_code = attach::attach_run(&run_info.path, false, styles, None).await?;
if exit_code != std::process::ExitCode::SUCCESS {
@ -72,8 +72,8 @@ pub(crate) async fn dispatch(cmd: RunCommands, globals: &GlobalArgs) -> Result<(
let styles: &'static Styles = Box::leak(Box::new(Styles::detect_stderr()));
#[cfg(feature = "sleep_inhibitor")]
let _sleep_guard = {
let cli_config = load_cli_settings(None)?;
crate::sleep_inhibitor::guard(cli_config.prevent_idle_sleep_enabled())
let cli_settings = load_cli_settings(None)?;
crate::sleep_inhibitor::guard(cli_settings.prevent_idle_sleep_enabled())
};
resume::resume_command(args, styles).await
}

4
lib/crates/fabro-cli/src/commands/run/preview.rs
View file

@ -10,8 +10,8 @@ use crate::cli_config::load_cli_settings;
use crate::shared::validate_daytona_provider;
pub(crate) async fn run(args: PreviewArgs) -> Result<()> {
let cli_config = load_cli_settings(None)?;
let base = runs_base(&cli_config.storage_dir());
let cli_settings = load_cli_settings(None)?;
let base = runs_base(&cli_settings.storage_dir());
let run_dir = resolve_run(&base, &args.run)?.path;
let sandbox_json = run_dir.join("sandbox.json");
let record = fabro_sandbox::SandboxRecord::load(&sandbox_json).context(

4
lib/crates/fabro-cli/src/commands/run/resume.rs
View file

@ -16,8 +16,8 @@ pub(crate) async fn resume_command(
args: ResumeArgs,
styles: &'static Styles,
) -> anyhow::Result<()> {
let cli_config = load_cli_settings(None)?;
let base = runs_base(&cli_config.storage_dir());
let cli_settings = load_cli_settings(None)?;
let base = runs_base(&cli_settings.storage_dir());
let run_dir = find_run_by_prefix(&base, &args.run)?;
// find_run_by_prefix can match orphan directories (no run.json).

4
lib/crates/fabro-cli/src/commands/run/ssh.rs
View file

@ -10,8 +10,8 @@ use crate::cli_config::load_cli_settings;
use crate::shared::validate_daytona_provider;
pub(crate) async fn run(args: SshArgs) -> Result<()> {
let cli_config = load_cli_settings(None)?;
let base = runs_base(&cli_config.storage_dir());
let cli_settings = load_cli_settings(None)?;
let base = runs_base(&cli_settings.storage_dir());
let run_dir = resolve_run(&base, &args.run)?.path;
let sandbox_json = run_dir.join("sandbox.json");
let record = fabro_sandbox::SandboxRecord::load(&sandbox_json).context(

4
lib/crates/fabro-cli/src/commands/run/wait.rs
View file

@ -13,8 +13,8 @@ use crate::cli_config::load_cli_settings;
use crate::shared::format_duration_ms;
pub(crate) fn run(args: &WaitArgs, styles: &Styles) -> Result<()> {
let cli_config = load_cli_settings(None)?;
let base = runs_base(&cli_config.storage_dir());
let cli_settings = load_cli_settings(None)?;
let base = runs_base(&cli_settings.storage_dir());
let run_info = resolve_run(&base, &args.run)?;
info!(run_id = %run_info.run_id, "Waiting for run to complete");

4
lib/crates/fabro-cli/src/commands/runs/inspect.rs
View file

@ -26,8 +26,8 @@ pub(crate) struct InspectOutput {
}
pub(crate) fn run(args: &InspectArgs) -> Result<()> {
let cli_config = load_cli_settings(None)?;
let base = runs_base(&cli_config.storage_dir());
let cli_settings = load_cli_settings(None)?;
let base = runs_base(&cli_settings.storage_dir());
let run = resolve_run(&base, &args.run)?;
let output = inspect_run_dir(&run.run_id, &run.path, run.status);
let json = serde_json::to_string_pretty(&[output])?;

4
lib/crates/fabro-cli/src/commands/runs/list.rs
View file

@ -18,8 +18,8 @@ use crate::shared::{color_if, format_duration_ms, tilde_path};
use super::short_run_id;
pub(crate) fn list_command(args: &RunsListArgs, styles: &Styles) -> Result<()> {
let cli_config = load_cli_settings(None)?;
let base = runs_base(&cli_config.storage_dir());
let cli_settings = load_cli_settings(None)?;
let base = runs_base(&cli_settings.storage_dir());
let runs = scan_runs(&base)?;
let label_filters = parse_label_filters(&args.filter.label);
let filtered = filter_runs(

4
lib/crates/fabro-cli/src/commands/runs/rm.rs
View file

@ -15,8 +15,8 @@ use crate::cli_config::load_cli_settings;
use super::short_run_id;
pub(crate) async fn remove_command(args: &RunsRemoveArgs) -> Result<()> {
let cli_config = load_cli_settings(None)?;
let base = runs_base(&cli_config.storage_dir());
let cli_settings = load_cli_settings(None)?;
let base = runs_base(&cli_settings.storage_dir());
remove_from(args, &base).await
}

4
lib/crates/fabro-cli/src/commands/system/df.rs
View file

@ -14,8 +14,8 @@ use crate::cli_config::load_cli_settings;
use crate::shared::format_size;
pub(super) fn df_command(args: &DfArgs) -> Result<()> {
let cli_config = load_cli_settings(None)?;
let data_dir = cli_config.storage_dir();
let cli_settings = load_cli_settings(None)?;
let data_dir = cli_settings.storage_dir();
let runs_base_dir = runs_base(&data_dir);
let logs_base_dir = logs_base(&data_dir);
df_from(args, &data_dir, &runs_base_dir, &logs_base_dir)

4
lib/crates/fabro-cli/src/commands/system/prune.rs
View file

@ -12,8 +12,8 @@ use crate::cli_config::load_cli_settings;
use crate::shared::format_size;
pub(super) fn prune_command(args: &RunsPruneArgs) -> Result<()> {
let cli_config = load_cli_settings(None)?;
let base = runs_base(&cli_config.storage_dir());
let cli_settings = load_cli_settings(None)?;
let base = runs_base(&cli_settings.storage_dir());
prune_from(args, &base)
}

16
lib/crates/fabro-cli/src/main.rs
View file

@ -113,9 +113,9 @@ async fn main_inner() -> (String, Result<()>) {
}
} else {
match cli_config::load_cli_settings(None) {
Ok(cli_config) => (
cli_config.log.as_ref().and_then(|l| l.level.clone()),
cli_config.upgrade_check_enabled(),
Ok(cli_settings) => (
cli_settings.log.as_ref().and_then(|l| l.level.clone()),
cli_settings.upgrade_check_enabled(),
),
Err(err) => return (command_name, Err(err)),
}
@ -124,9 +124,9 @@ async fn main_inner() -> (String, Result<()>) {
#[cfg(not(feature = "server"))]
{
match cli_config::load_cli_settings(None) {
Ok(cli_config) => (
cli_config.log.as_ref().and_then(|l| l.level.clone()),
cli_config.upgrade_check_enabled(),
Ok(cli_settings) => (
cli_settings.log.as_ref().and_then(|l| l.level.clone()),
cli_settings.upgrade_check_enabled(),
),
Err(err) => return (command_name, Err(err)),
}
@ -184,8 +184,8 @@ async fn main_inner() -> (String, Result<()>) {
fabro_api::serve::serve_command(args, styles).await?;
}
Commands::Doctor { verbose, dry_run } => {
let cli_config = cli_config::load_cli_settings(None)?;
let verbose = verbose || cli_config.verbose_enabled();
let cli_settings = cli_config::load_cli_settings(None)?;
let verbose = verbose || cli_settings.verbose_enabled();
let exit_code = commands::doctor::run_doctor(verbose, !dry_run).await;
std::process::exit(exit_code);
}

4
lib/crates/fabro-config/src/server.rs
View file

@ -190,6 +190,6 @@ pub fn load_server_settings(path: Option<&Path>) -> anyhow::Result<FabroSettings
}
/// Resolve the storage directory: config value > default `~/.fabro`.
pub fn resolve_storage_dir(config: &FabroSettings) -> PathBuf {
config.storage_dir()
pub fn resolve_storage_dir(settings: &FabroSettings) -> PathBuf {
settings.storage_dir()
}

6
lib/crates/fabro-workflows/src/operations/create.rs
View file

@ -255,9 +255,9 @@ fn persist_validated(
}
pub(crate) fn resolve_run_settings(mut settings: FabroSettings, graph: &Graph) -> FabroSettings {
let llm_config = settings.llm.as_ref();
let configured_model = llm_config.and_then(|l| l.model.as_deref());
let configured_provider = llm_config.and_then(|l| l.provider.as_deref());
let llm_settings = settings.llm.as_ref();
let configured_model = llm_settings.and_then(|l| l.model.as_deref());
let configured_provider = llm_settings.and_then(|l| l.provider.as_deref());
let graph_provider = graph.attrs.get("default_provider").and_then(|v| v.as_str());
let graph_model = graph.attrs.get("default_model").and_then(|v| v.as_str());