490 lines
17 KiB
Rust
490 lines
17 KiB
Rust
#![allow(clippy::collapsible_if)] // TODO: Remove once Rust 2024 let-chains are available
|
|
|
|
//! OWLEN CLI - Chat TUI client
|
|
|
|
mod bootstrap;
|
|
mod commands;
|
|
mod mcp;
|
|
|
|
use anyhow::{Result, anyhow};
|
|
use clap::{Parser, Subcommand};
|
|
use commands::{
|
|
cloud::{CloudCommand, run_cloud_command},
|
|
providers::{ModelsArgs, ProvidersCommand, run_models_command, run_providers_command},
|
|
security::{SecurityCommand, run_security_command},
|
|
tools::{ToolsCommand, run_tools_command},
|
|
};
|
|
use mcp::{McpCommand, run_mcp_command};
|
|
use owlen_core::config::{
|
|
self as core_config, Config, DEFAULT_OLLAMA_CLOUD_HOURLY_QUOTA,
|
|
DEFAULT_OLLAMA_CLOUD_WEEKLY_QUOTA, DEFAULT_PROVIDER_CONTEXT_WINDOW_TOKENS,
|
|
DEFAULT_PROVIDER_LIST_TTL_SECS, LEGACY_OLLAMA_CLOUD_API_KEY_ENV, LEGACY_OLLAMA_CLOUD_BASE_URL,
|
|
LEGACY_OWLEN_OLLAMA_CLOUD_API_KEY_ENV, McpMode, OLLAMA_API_KEY_ENV, OLLAMA_CLOUD_BASE_URL,
|
|
OLLAMA_CLOUD_ENDPOINT_KEY,
|
|
};
|
|
use owlen_core::mode::Mode;
|
|
use owlen_tui::config;
|
|
use serde_json::{Number as JsonNumber, Value as JsonValue};
|
|
use std::env;
|
|
|
|
/// Owlen - Terminal UI for LLM chat
|
|
#[derive(Parser, Debug)]
|
|
#[command(name = "owlen")]
|
|
#[command(about = "Terminal UI for LLM chat via MCP", long_about = None)]
|
|
struct Args {
|
|
/// Start in code mode (enables all tools)
|
|
#[arg(long, short = 'c')]
|
|
code: bool,
|
|
/// Disable automatic transcript compression for this session
|
|
#[arg(long)]
|
|
no_auto_compress: bool,
|
|
#[command(subcommand)]
|
|
command: Option<OwlenCommand>,
|
|
}
|
|
|
|
#[derive(Debug, Subcommand)]
|
|
enum OwlenCommand {
|
|
/// Inspect or upgrade configuration files
|
|
#[command(subcommand)]
|
|
Config(ConfigCommand),
|
|
/// Manage Ollama Cloud credentials
|
|
#[command(subcommand)]
|
|
Cloud(CloudCommand),
|
|
/// Manage model providers
|
|
#[command(subcommand)]
|
|
Providers(ProvidersCommand),
|
|
/// List models exposed by configured providers
|
|
Models(ModelsArgs),
|
|
/// Manage MCP server registrations
|
|
#[command(subcommand)]
|
|
Mcp(McpCommand),
|
|
/// Manage MCP tool presets
|
|
#[command(subcommand)]
|
|
Tools(ToolsCommand),
|
|
/// Configure security and approval policies
|
|
#[command(subcommand)]
|
|
Security(SecurityCommand),
|
|
/// Show manual steps for updating Owlen to the latest revision
|
|
Upgrade,
|
|
}
|
|
|
|
#[derive(Debug, Subcommand)]
|
|
enum ConfigCommand {
|
|
/// Automatically upgrade legacy configuration values and ensure validity
|
|
Doctor,
|
|
/// Print the resolved configuration file path
|
|
Path,
|
|
/// Create a fresh configuration file using the latest defaults
|
|
Init {
|
|
/// Overwrite the existing configuration if present.
|
|
#[arg(long)]
|
|
force: bool,
|
|
},
|
|
}
|
|
|
|
async fn run_command(command: OwlenCommand) -> Result<()> {
|
|
match command {
|
|
OwlenCommand::Config(config_cmd) => run_config_command(config_cmd),
|
|
OwlenCommand::Cloud(cloud_cmd) => run_cloud_command(cloud_cmd).await,
|
|
OwlenCommand::Providers(provider_cmd) => run_providers_command(provider_cmd).await,
|
|
OwlenCommand::Models(args) => run_models_command(args).await,
|
|
OwlenCommand::Mcp(mcp_cmd) => run_mcp_command(mcp_cmd),
|
|
OwlenCommand::Tools(tools_cmd) => run_tools_command(tools_cmd),
|
|
OwlenCommand::Security(sec_cmd) => run_security_command(sec_cmd),
|
|
OwlenCommand::Upgrade => {
|
|
println!(
|
|
"To update Owlen from source:\n git pull\n cargo install --path crates/owlen-cli --force"
|
|
);
|
|
println!(
|
|
"If you installed from the AUR, use your package manager (e.g., yay -S owlen-git)."
|
|
);
|
|
Ok(())
|
|
}
|
|
}
|
|
}
|
|
|
|
fn run_config_command(command: ConfigCommand) -> Result<()> {
|
|
match command {
|
|
ConfigCommand::Doctor => run_config_doctor(),
|
|
ConfigCommand::Path => {
|
|
let path = core_config::default_config_path();
|
|
println!("{}", path.display());
|
|
Ok(())
|
|
}
|
|
ConfigCommand::Init { force } => run_config_init(force),
|
|
}
|
|
}
|
|
|
|
fn run_config_init(force: bool) -> Result<()> {
|
|
let config_path = core_config::default_config_path();
|
|
if config_path.exists() && !force {
|
|
return Err(anyhow!(
|
|
"Configuration already exists at {}. Re-run with --force to overwrite.",
|
|
config_path.display()
|
|
));
|
|
}
|
|
|
|
let mut config = Config::default();
|
|
let _ = config.refresh_mcp_servers(None);
|
|
config.validate()?;
|
|
|
|
config::save_config(&config)?;
|
|
println!("Wrote default configuration to {}.", config_path.display());
|
|
Ok(())
|
|
}
|
|
|
|
fn run_config_doctor() -> Result<()> {
|
|
let config_path = core_config::default_config_path();
|
|
let existed = config_path.exists();
|
|
let mut config = config::try_load_config().unwrap_or_default();
|
|
let _ = config.refresh_mcp_servers(None);
|
|
let mut changes = Vec::new();
|
|
let mut warnings = Vec::new();
|
|
|
|
if !existed {
|
|
changes.push("created configuration file from defaults".to_string());
|
|
}
|
|
|
|
if config.provider(&config.general.default_provider).is_none() {
|
|
config.general.default_provider = "ollama_local".to_string();
|
|
changes.push("default provider missing; reset to 'ollama_local'".to_string());
|
|
}
|
|
|
|
for key in ["ollama_local", "ollama_cloud", "openai", "anthropic"] {
|
|
if !config.providers.contains_key(key) {
|
|
core_config::ensure_provider_config_mut(&mut config, key);
|
|
changes.push(format!("added default configuration for provider '{key}'"));
|
|
}
|
|
}
|
|
|
|
if let Some(local) = config.providers.get_mut("ollama_local") {
|
|
if ensure_numeric_extra_with_change(
|
|
&mut local.extra,
|
|
"list_ttl_secs",
|
|
DEFAULT_PROVIDER_LIST_TTL_SECS,
|
|
) {
|
|
changes.push("added providers.ollama_local.list_ttl_secs (default 60)".to_string());
|
|
}
|
|
if ensure_numeric_extra_with_change(
|
|
&mut local.extra,
|
|
"default_context_window",
|
|
u64::from(DEFAULT_PROVIDER_CONTEXT_WINDOW_TOKENS),
|
|
) {
|
|
changes.push(format!(
|
|
"added providers.ollama_local.default_context_window (default {})",
|
|
DEFAULT_PROVIDER_CONTEXT_WINDOW_TOKENS
|
|
));
|
|
}
|
|
if local.provider_type.trim().is_empty() || local.provider_type != "ollama" {
|
|
local.provider_type = "ollama".to_string();
|
|
changes.push("normalised providers.ollama_local.provider_type to 'ollama'".to_string());
|
|
}
|
|
}
|
|
|
|
if let Some(cloud) = config.providers.get_mut("ollama_cloud") {
|
|
if cloud.provider_type.trim().is_empty()
|
|
|| !cloud.provider_type.eq_ignore_ascii_case("ollama_cloud")
|
|
{
|
|
cloud.provider_type = "ollama_cloud".to_string();
|
|
changes.push(
|
|
"normalised providers.ollama_cloud.provider_type to 'ollama_cloud'".to_string(),
|
|
);
|
|
}
|
|
|
|
let previous_base_url = cloud.base_url.clone();
|
|
match cloud
|
|
.base_url
|
|
.as_ref()
|
|
.map(|value| value.trim_end_matches('/'))
|
|
{
|
|
None => {
|
|
cloud.base_url = Some(OLLAMA_CLOUD_BASE_URL.to_string());
|
|
}
|
|
Some(current) if current.eq_ignore_ascii_case(LEGACY_OLLAMA_CLOUD_BASE_URL) => {
|
|
cloud.base_url = Some(OLLAMA_CLOUD_BASE_URL.to_string());
|
|
}
|
|
_ => {}
|
|
}
|
|
if cloud.base_url != previous_base_url {
|
|
changes.push(
|
|
"normalised providers.ollama_cloud.base_url to https://ollama.com".to_string(),
|
|
);
|
|
}
|
|
|
|
let original_api_key_env = cloud.api_key_env.clone();
|
|
let needs_env_update = cloud
|
|
.api_key_env
|
|
.as_ref()
|
|
.map(|value| value.trim().is_empty())
|
|
.unwrap_or(true);
|
|
if needs_env_update {
|
|
cloud.api_key_env = Some(OLLAMA_API_KEY_ENV.to_string());
|
|
}
|
|
if let Some(ref value) = original_api_key_env {
|
|
if value.eq_ignore_ascii_case(LEGACY_OLLAMA_CLOUD_API_KEY_ENV)
|
|
|| value.eq_ignore_ascii_case(LEGACY_OWLEN_OLLAMA_CLOUD_API_KEY_ENV)
|
|
{
|
|
cloud.api_key_env = Some(OLLAMA_API_KEY_ENV.to_string());
|
|
}
|
|
}
|
|
if cloud.api_key_env != original_api_key_env {
|
|
changes
|
|
.push("updated providers.ollama_cloud.api_key_env to 'OLLAMA_API_KEY'".to_string());
|
|
}
|
|
|
|
if ensure_string_extra_with_change(
|
|
&mut cloud.extra,
|
|
OLLAMA_CLOUD_ENDPOINT_KEY,
|
|
OLLAMA_CLOUD_BASE_URL,
|
|
) {
|
|
changes.push(
|
|
"added providers.ollama_cloud.extra.cloud_endpoint (default https://ollama.com)"
|
|
.to_string(),
|
|
);
|
|
}
|
|
if ensure_numeric_extra_with_change(
|
|
&mut cloud.extra,
|
|
"hourly_quota_tokens",
|
|
DEFAULT_OLLAMA_CLOUD_HOURLY_QUOTA,
|
|
) {
|
|
changes.push(format!(
|
|
"added providers.ollama_cloud.hourly_quota_tokens (default {})",
|
|
DEFAULT_OLLAMA_CLOUD_HOURLY_QUOTA
|
|
));
|
|
}
|
|
if ensure_numeric_extra_with_change(
|
|
&mut cloud.extra,
|
|
"weekly_quota_tokens",
|
|
DEFAULT_OLLAMA_CLOUD_WEEKLY_QUOTA,
|
|
) {
|
|
changes.push(format!(
|
|
"added providers.ollama_cloud.weekly_quota_tokens (default {})",
|
|
DEFAULT_OLLAMA_CLOUD_WEEKLY_QUOTA
|
|
));
|
|
}
|
|
if ensure_numeric_extra_with_change(
|
|
&mut cloud.extra,
|
|
"list_ttl_secs",
|
|
DEFAULT_PROVIDER_LIST_TTL_SECS,
|
|
) {
|
|
changes.push("added providers.ollama_cloud.list_ttl_secs (default 60)".to_string());
|
|
}
|
|
if ensure_numeric_extra_with_change(
|
|
&mut cloud.extra,
|
|
"default_context_window",
|
|
u64::from(DEFAULT_PROVIDER_CONTEXT_WINDOW_TOKENS),
|
|
) {
|
|
changes.push(format!(
|
|
"added providers.ollama_cloud.default_context_window (default {})",
|
|
DEFAULT_PROVIDER_CONTEXT_WINDOW_TOKENS
|
|
));
|
|
}
|
|
}
|
|
|
|
let canonical_env = env::var(OLLAMA_API_KEY_ENV)
|
|
.ok()
|
|
.filter(|value| !value.trim().is_empty());
|
|
let legacy_env = env::var(LEGACY_OLLAMA_CLOUD_API_KEY_ENV)
|
|
.ok()
|
|
.filter(|value| !value.trim().is_empty());
|
|
let legacy_alt_env = env::var(LEGACY_OWLEN_OLLAMA_CLOUD_API_KEY_ENV)
|
|
.ok()
|
|
.filter(|value| !value.trim().is_empty());
|
|
|
|
if canonical_env.is_some() {
|
|
if legacy_env.is_some() {
|
|
warnings.push(format!(
|
|
"Both {OLLAMA_API_KEY_ENV} and {LEGACY_OLLAMA_CLOUD_API_KEY_ENV} are set; Owlen will prefer {OLLAMA_API_KEY_ENV}."
|
|
));
|
|
}
|
|
if legacy_alt_env.is_some() {
|
|
warnings.push(format!(
|
|
"Both {OLLAMA_API_KEY_ENV} and {LEGACY_OWLEN_OLLAMA_CLOUD_API_KEY_ENV} are set; Owlen will prefer {OLLAMA_API_KEY_ENV}."
|
|
));
|
|
}
|
|
} else {
|
|
if legacy_env.is_some() {
|
|
warnings.push(format!(
|
|
"Legacy environment variable {LEGACY_OLLAMA_CLOUD_API_KEY_ENV} is set. Rename it to {OLLAMA_API_KEY_ENV} to match the latest configuration schema."
|
|
));
|
|
}
|
|
if legacy_alt_env.is_some() {
|
|
warnings.push(format!(
|
|
"Legacy environment variable {LEGACY_OWLEN_OLLAMA_CLOUD_API_KEY_ENV} is set. Rename it to {OLLAMA_API_KEY_ENV} to match the latest configuration schema."
|
|
));
|
|
}
|
|
}
|
|
|
|
let mut ensure_default_enabled = true;
|
|
|
|
if !config.providers.values().any(|cfg| cfg.enabled) {
|
|
let entry = core_config::ensure_provider_config_mut(&mut config, "ollama_local");
|
|
if !entry.enabled {
|
|
entry.enabled = true;
|
|
changes.push("no providers were enabled; enabled 'ollama_local'".to_string());
|
|
}
|
|
if config.general.default_provider != "ollama_local" {
|
|
config.general.default_provider = "ollama_local".to_string();
|
|
changes.push(
|
|
"default provider reset to 'ollama_local' because no providers were enabled"
|
|
.to_string(),
|
|
);
|
|
}
|
|
ensure_default_enabled = false;
|
|
}
|
|
|
|
if ensure_default_enabled {
|
|
let default_id = config.general.default_provider.clone();
|
|
if let Some(default_cfg) = config.providers.get(&default_id) {
|
|
if !default_cfg.enabled {
|
|
if let Some(new_default) = config
|
|
.providers
|
|
.iter()
|
|
.filter(|(id, cfg)| cfg.enabled && *id != &default_id)
|
|
.map(|(id, _)| id.clone())
|
|
.min()
|
|
{
|
|
config.general.default_provider = new_default.clone();
|
|
changes.push(format!(
|
|
"default provider '{default_id}' was disabled; switched default to '{new_default}'"
|
|
));
|
|
} else {
|
|
let entry =
|
|
core_config::ensure_provider_config_mut(&mut config, "ollama_local");
|
|
if !entry.enabled {
|
|
entry.enabled = true;
|
|
changes.push(
|
|
"enabled 'ollama_local' because default provider was disabled"
|
|
.to_string(),
|
|
);
|
|
}
|
|
if config.general.default_provider != "ollama_local" {
|
|
config.general.default_provider = "ollama_local".to_string();
|
|
changes.push(
|
|
"default provider reset to 'ollama_local' because previous default was disabled"
|
|
.to_string(),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
match config.mcp.mode {
|
|
McpMode::Legacy => {
|
|
config.mcp.mode = McpMode::LocalOnly;
|
|
config.mcp.warn_on_legacy = true;
|
|
changes.push("converted [mcp].mode = 'legacy' to 'local_only'".to_string());
|
|
}
|
|
McpMode::RemoteOnly if config.effective_mcp_servers().is_empty() => {
|
|
config.mcp.mode = McpMode::RemotePreferred;
|
|
config.mcp.allow_fallback = true;
|
|
changes.push(
|
|
"downgraded remote-only configuration to remote_preferred because no servers are defined"
|
|
.to_string(),
|
|
);
|
|
}
|
|
McpMode::RemotePreferred
|
|
if !config.mcp.allow_fallback && config.effective_mcp_servers().is_empty() =>
|
|
{
|
|
config.mcp.allow_fallback = true;
|
|
changes.push(
|
|
"enabled [mcp].allow_fallback because no remote servers are configured".to_string(),
|
|
);
|
|
}
|
|
_ => {}
|
|
}
|
|
|
|
config.validate()?;
|
|
config::save_config(&config)?;
|
|
|
|
if changes.is_empty() {
|
|
println!(
|
|
"Configuration already up to date: {}",
|
|
config_path.display()
|
|
);
|
|
} else {
|
|
println!("Updated {}:", config_path.display());
|
|
for change in changes {
|
|
println!(" - {change}");
|
|
}
|
|
}
|
|
|
|
if !warnings.is_empty() {
|
|
println!("Warnings:");
|
|
for warning in warnings {
|
|
println!(" - {warning}");
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn ensure_numeric_extra_with_change(
|
|
extra: &mut std::collections::HashMap<String, JsonValue>,
|
|
key: &str,
|
|
default_value: u64,
|
|
) -> bool {
|
|
match extra.get_mut(key) {
|
|
Some(existing) => {
|
|
if existing.as_u64().is_some() {
|
|
false
|
|
} else {
|
|
*existing = JsonValue::Number(JsonNumber::from(default_value));
|
|
true
|
|
}
|
|
}
|
|
None => {
|
|
extra.insert(
|
|
key.to_string(),
|
|
JsonValue::Number(JsonNumber::from(default_value)),
|
|
);
|
|
true
|
|
}
|
|
}
|
|
}
|
|
|
|
fn ensure_string_extra_with_change(
|
|
extra: &mut std::collections::HashMap<String, JsonValue>,
|
|
key: &str,
|
|
default_value: &str,
|
|
) -> bool {
|
|
match extra.get_mut(key) {
|
|
Some(existing) => match existing.as_str() {
|
|
Some(value) if !value.trim().is_empty() => false,
|
|
_ => {
|
|
*existing = JsonValue::String(default_value.to_string());
|
|
true
|
|
}
|
|
},
|
|
None => {
|
|
extra.insert(
|
|
key.to_string(),
|
|
JsonValue::String(default_value.to_string()),
|
|
);
|
|
true
|
|
}
|
|
}
|
|
}
|
|
|
|
#[tokio::main(flavor = "multi_thread")]
|
|
async fn main() -> Result<()> {
|
|
// Parse command-line arguments
|
|
let Args {
|
|
code,
|
|
command,
|
|
no_auto_compress,
|
|
} = Args::parse();
|
|
if let Some(command) = command {
|
|
return run_command(command).await;
|
|
}
|
|
let initial_mode = if code { Mode::Code } else { Mode::Chat };
|
|
bootstrap::launch(
|
|
initial_mode,
|
|
bootstrap::LaunchOptions {
|
|
disable_auto_compress: no_auto_compress,
|
|
},
|
|
)
|
|
.await
|
|
}
|