mod completer; use crate::cli::completer::{ ShellCompletion, agent_completer, macro_completer, mcp_server_completer, model_completer, rag_completer, role_completer, secrets_completer, session_completer, }; use crate::config::{AssetCategory, InstallFilter, MemoryScope}; use anyhow::{Context, Result}; use clap::{ArgGroup, ValueHint}; use clap::{Parser, crate_authors, crate_description, crate_version}; use clap_complete::ArgValueCompleter; use is_terminal::IsTerminal; use std::collections::HashSet; use std::io::{Read, stdin}; #[derive(clap::ValueEnum, Debug, Clone, Copy, PartialEq, Eq)] pub enum McpTransportArg { Stdio, Http, Sse, } #[derive(clap::ValueEnum, Debug, Clone, Copy, PartialEq, Eq, Default)] pub enum McpScopeArg { #[default] User, Workspace, } #[derive(Parser, Debug)] #[command(author, version, about, long_about = None)] #[command( name = "coyote", author = crate_authors!(), version = crate_version!(), about = crate_description!(), help_template = "\ {before-help}{name} {version} {author-with-newline} {about-with-newline} {usage-heading} {usage} {all-args}{after-help} ", group( ArgGroup::new("sbx-mode") .args(["sandbox", "fresh"]) .multiple(true) .conflicts_with_all([ "model", "prompt", "role", "session", "agent", "rag", "rebuild_rag", "macro_name", "execute", "code", "file", "no_stream", "no_memory", "init_memory", "dry_run", "info", "build_tools", "install", "install_from", "sync_models", "list_models", "list_roles", "list_sessions", "list_agents", "list_rags", "list_macros", "list_skills", "skill", "tail_logs", "completions", "update", ]) ), group( ArgGroup::new("mcp-action") .args(["mcp_add", "mcp_remove", "mcp_list", "mcp_get"]) .multiple(false) ), )] pub struct Cli { /// Input text #[arg(allow_hyphen_values = true)] text: Vec, /// Select a LLM model #[arg(short, long, add = ArgValueCompleter::new(model_completer))] pub model: Option, /// Use the system prompt #[arg(long)] pub prompt: Option, /// Select a role #[arg(short, long, add = ArgValueCompleter::new(role_completer))] pub role: Option, /// Execute commands in natural language #[arg(short = 'e', long)] pub execute: bool, /// Output code only #[arg(short = 'c', long)] pub code: bool, /// Include files, directories, or URLs #[arg(short = 'f', long, value_name = "FILE|URL", value_hint = ValueHint::AnyPath)] pub file: Vec, /// Turn off stream mode #[arg(short = 'S', long)] pub no_stream: bool, /// Render markdown as raw text with syntax highlighting only (skip the rich markdown renderer) #[arg(long)] pub raw_markdown: bool, /// Display the message without sending it #[arg(long)] pub dry_run: bool, /// Disable loading workspace MCP servers from .coyote/mcp.json, .coyote/.mcp.json, or .mcp.json #[arg(long)] pub no_workspace_mcp: bool, /// Disable memory for this invocation #[arg(long)] pub no_memory: bool, /// Disable loading workspace instructions (COYOTE.md/AGENTS.md/CLAUDE.md/etc.) for this invocation #[arg(long)] pub no_workspace_instructions: bool, /// Override the workspace instructions file chain for this invocation (repeatable, priority order) #[arg(long, value_name = "NAME")] pub workspace_instructions_file: Vec, /// Skip permission prompts by setting AUTO_CONFIRM for all tools (dangerous!) #[arg(long)] pub dangerously_skip_permissions: bool, /// Start or join a session #[arg(short = 's', long, help_heading = "Session & Memory", add = ArgValueCompleter::new(session_completer))] pub session: Option>, /// Ensure the session is empty #[arg(long, help_heading = "Session & Memory")] pub empty_session: bool, /// Ensure the new conversation is saved to the session #[arg(long, help_heading = "Session & Memory")] pub save_session: bool, /// Bootstrap a memory marker so coyote begins loading memory next run #[arg( long, value_name = "SCOPE", value_enum, help_heading = "Session & Memory" )] pub init_memory: Option, /// Scaffold a COYOTE.md workspace instructions file in the current directory #[arg(long, help_heading = "Session & Memory")] pub init_instructions: bool, /// Pre-load an existing skill into the session (repeatable). If a single /// `--skill ` is given and the skill doesn't exist, opens $EDITOR /// with a scaffold to create it. #[arg(long, value_name = "NAME", help_heading = "Session & Memory")] pub skill: Vec, /// Start an agent #[arg(short = 'a', long, help_heading = "Agents, RAG & Macros", add = ArgValueCompleter::new(agent_completer))] pub agent: Option, /// Set agent variables #[arg(long, value_names = ["NAME", "VALUE"], num_args = 2, help_heading = "Agents, RAG & Macros")] pub agent_variable: Vec, /// Start a RAG #[arg(long, help_heading = "Agents, RAG & Macros", add = ArgValueCompleter::new(rag_completer))] pub rag: Option, /// Rebuild the RAG to sync document changes #[arg(long, help_heading = "Agents, RAG & Macros")] pub rebuild_rag: bool, /// Execute a macro #[arg(long = "macro", value_name = "MACRO", help_heading = "Agents, RAG & Macros", add = ArgValueCompleter::new(macro_completer))] pub macro_name: Option, /// List all available chat models #[arg(long, help_heading = "List & Discovery")] pub list_models: bool, /// List all roles #[arg(long, help_heading = "List & Discovery")] pub list_roles: bool, /// List all sessions #[arg(long, help_heading = "List & Discovery")] pub list_sessions: bool, /// List all agents #[arg(long, help_heading = "List & Discovery")] pub list_agents: bool, /// List all RAGs #[arg(long, help_heading = "List & Discovery")] pub list_rags: bool, /// List all macros #[arg(long, help_heading = "List & Discovery")] pub list_macros: bool, /// List all installed skills #[arg(long, help_heading = "List & Discovery")] pub list_skills: bool, /// Reinstall bundled assets, overwriting any local changes #[arg( long, value_name = "CATEGORY", value_enum, help_heading = "Installation & Updates" )] pub install: Option, /// Install assets from a remote git repository (URL may be suffixed with #) #[arg(long, value_name = "GIT_URL", help_heading = "Installation & Updates")] pub install_from: Option, /// Restrict --install-from to a single asset category #[arg( long, value_name = "CATEGORY", value_enum, requires = "install_from", help_heading = "Installation & Updates" )] pub filter: Option, /// Overwrite all conflicts without prompting (used with --install-from) #[arg( long, requires = "install_from", help_heading = "Installation & Updates" )] pub install_force: bool, /// Sync models updates #[arg(long, help_heading = "Installation & Updates")] pub sync_models: bool, /// Update Coyote to the latest release, or to a specific version #[arg(long, value_name = "VERSION", help_heading = "Installation & Updates")] pub update: Option>, /// With --update, update even if Coyote was installed via a package manager #[arg(long, requires = "update", help_heading = "Installation & Updates")] pub force: bool, /// Add a secret to the Coyote vault #[arg( long, value_name = "SECRET_NAME", exclusive = true, help_heading = "Vault & Secrets" )] pub add_secret: Option, /// Decrypt a secret from the Coyote vault and print the plaintext #[arg(long, value_name = "SECRET_NAME", exclusive = true, help_heading = "Vault & Secrets", add = ArgValueCompleter::new(secrets_completer))] pub get_secret: Option, /// Update an existing secret in the Coyote vault #[arg(long, value_name = "SECRET_NAME", exclusive = true, help_heading = "Vault & Secrets", add = ArgValueCompleter::new(secrets_completer))] pub update_secret: Option, /// Delete a secret from the Coyote vault #[arg(long, value_name = "SECRET_NAME", exclusive = true, help_heading = "Vault & Secrets", add = ArgValueCompleter::new(secrets_completer))] pub delete_secret: Option, /// List all secrets stored in the Coyote vault #[arg(long, exclusive = true, help_heading = "Vault & Secrets")] pub list_secrets: bool, /// Authenticate with an LLM provider using OAuth (e.g., --authenticate client_name) #[arg( long, exclusive = true, value_name = "CLIENT_NAME", help_heading = "Authentication" )] pub authenticate: Option>, /// Authenticate with an OAuth-protected remote MCP server (e.g., --auth-mcp server_name) #[arg(long, exclusive = true, value_name = "SERVER_NAME", help_heading = "Authentication", add = ArgValueCompleter::new(mcp_server_completer))] pub auth_mcp: Option, /// Add an MCP server. Use `-- [args...]` for stdio, or `--url ` for http/sse. #[arg(long, value_name = "NAME", help_heading = "MCP Servers")] pub mcp_add: Option, /// Remove an MCP server by name #[arg(long, value_name = "NAME", help_heading = "MCP Servers", add = ArgValueCompleter::new(mcp_server_completer))] pub mcp_remove: Option, /// List all configured MCP servers (user + workspace scopes) #[arg(long, help_heading = "MCP Servers")] pub mcp_list: bool, /// Show the JSON config for one MCP server #[arg(long, value_name = "NAME", help_heading = "MCP Servers", add = ArgValueCompleter::new(mcp_server_completer))] pub mcp_get: Option, /// Transport for --mcp-add: stdio (default when `--` present), http, or sse #[arg( long, value_enum, value_name = "TRANSPORT", help_heading = "MCP Servers" )] pub transport: Option, /// URL for http/sse MCP server (used with --mcp-add) #[arg(long, value_name = "URL", help_heading = "MCP Servers")] pub url: Option, /// Scope for MCP config: user (~/.config/coyote/functions/mcp.json) or workspace (./.coyote/mcp.json). Default: user #[arg(long, value_enum, value_name = "SCOPE", help_heading = "MCP Servers")] pub scope: Option, /// Environment variable for stdio MCP server (repeatable): --env KEY=VALUE #[arg(long, value_name = "KEY=VALUE", help_heading = "MCP Servers")] pub env: Vec, /// HTTP header for http/sse MCP server (repeatable): --header "Name: Value" #[arg(long, value_name = "HEADER", help_heading = "MCP Servers")] pub header: Vec, /// Working directory for stdio MCP server #[arg(long, value_name = "PATH", value_hint = ValueHint::AnyPath, help_heading = "MCP Servers")] pub cwd: Option, /// OAuth client ID for http/sse MCP server #[arg(long, value_name = "ID", help_heading = "MCP Servers")] pub client_id: Option, /// OAuth client secret for http/sse MCP server (use {{NAME}} to reference a vault secret) #[arg(long, value_name = "SECRET", help_heading = "MCP Servers")] pub client_secret: Option, /// OAuth callback port for http/sse MCP server #[arg(long, value_name = "PORT", help_heading = "MCP Servers")] pub callback_port: Option, /// OAuth redirect host for http/sse MCP server #[arg(long, value_name = "HOST", help_heading = "MCP Servers")] pub redirect_host: Option, /// Overwrite an existing MCP server (with --mcp-add) or skip confirmation (with --mcp-remove) #[arg(long, help_heading = "MCP Servers")] pub mcp_force: bool, /// Launch Coyote inside a Docker sandbox (via `sbx`); name defaults to current directory basename #[arg(long, value_name = "NAME", help_heading = "Sandbox")] pub sandbox: Option>, /// Start the sandbox with a clean slate. No copied config or tokens; LLM credentials injected via sbx proxy #[arg(long, requires = "sandbox", help_heading = "Sandbox")] pub fresh: bool, /// Declare that no human is present. All user-interaction tools return structured JSON instead of /// prompting. Implies --dangerously-skip-permissions. Incompatible with REPL mode (requires a prompt). #[arg(long, help_heading = "Sandbox")] pub headless: bool, /// Run as an ACP agent server over stdio (JSON-RPC 2.0). Every stdout byte must be valid JSON-RPC. /// Implies --headless. Single session per process. #[arg(long, help_heading = "Sandbox")] pub acp_server: bool, /// Display information #[arg(long, help_heading = "Diagnostics & Tools")] pub info: bool, /// Build all configured Bash tool scripts #[arg(long, help_heading = "Diagnostics & Tools")] pub build_tools: bool, /// Tail logs #[arg(long, help_heading = "Diagnostics & Tools")] pub tail_logs: bool, /// Disable colored log output #[arg(long, requires = "tail_logs", help_heading = "Diagnostics & Tools")] pub disable_log_colors: bool, /// Generate static shell completion scripts #[arg(long, value_name = "SHELL", value_enum, help_heading = "Shell")] pub completions: Option, /// Stdio command for --mcp-add: everything after `--` is passed to the server verbatim #[arg( last = true, allow_hyphen_values = true, value_name = "CMD", help_heading = "MCP Servers" )] pub mcp_command: Vec, } impl Cli { pub fn skills(&self) -> Vec { let mut seen = HashSet::new(); let mut out = Vec::with_capacity(self.skill.len()); for name in &self.skill { if seen.insert(name.clone()) { out.push(name.clone()); } } out } pub fn text(&self) -> Result> { let mut stdin_text = String::new(); if !stdin().is_terminal() { let _ = stdin() .read_to_string(&mut stdin_text) .context("Invalid stdin pipe")?; }; match self.text.is_empty() { true => { if stdin_text.is_empty() { Ok(None) } else { Ok(Some(stdin_text)) } } false => { if self.macro_name.is_some() { let text = self .text .iter() .map(|v| shell_words::quote(v)) .collect::>() .join(" "); if stdin_text.is_empty() { Ok(Some(text)) } else { Ok(Some(format!("{text} -- {stdin_text}"))) } } else { let text = self.text.join(" "); if stdin_text.is_empty() { Ok(Some(text)) } else { Ok(Some(format!("{text}\n{stdin_text}"))) } } } } } } #[cfg(test)] mod tests { use super::*; use clap::Parser; fn parse(args: &[&str]) -> Cli { let mut full_args = vec!["coyote"]; full_args.extend_from_slice(args); Cli::try_parse_from(full_args).unwrap() } #[test] fn parse_no_args_defaults() { let cli = parse(&[]); assert!(cli.model.is_none()); assert!(cli.role.is_none()); assert!(cli.session.is_none()); assert!(cli.agent.is_none()); assert!(!cli.execute); assert!(!cli.code); assert!(!cli.no_stream); assert!(!cli.dry_run); assert!(!cli.info); assert!(!cli.build_tools); assert!(cli.file.is_empty()); assert!(cli.text.is_empty()); } #[test] fn parse_model_flag() { let cli = parse(&["--model", "gpt-4o"]); assert_eq!(cli.model, Some("gpt-4o".to_string())); } #[test] fn parse_model_short_flag() { let cli = parse(&["-m", "gpt-4o"]); assert_eq!(cli.model, Some("gpt-4o".to_string())); } #[test] fn parse_role_flag() { let cli = parse(&["--role", "coder"]); assert_eq!(cli.role, Some("coder".to_string())); } #[test] fn parse_session_with_name() { let cli = parse(&["--session", "my-session"]); assert_eq!(cli.session, Some(Some("my-session".to_string()))); } #[test] fn parse_agent_flag() { let cli = parse(&["--agent", "sisyphus"]); assert_eq!(cli.agent, Some("sisyphus".to_string())); } #[test] fn parse_agent_short_flag() { let cli = parse(&["-a", "sisyphus"]); assert_eq!(cli.agent, Some("sisyphus".to_string())); } #[test] fn parse_execute_flag() { let cli = parse(&["-e", "list files"]); assert!(cli.execute); } #[test] fn parse_code_flag() { let cli = parse(&["-c", "hello world"]); assert!(cli.code); } #[test] fn parse_no_stream_flag() { let cli = parse(&["-S", "test"]); assert!(cli.no_stream); } #[test] fn parse_dry_run_flag() { let cli = parse(&["--dry-run", "test"]); assert!(cli.dry_run); } #[test] fn parse_info_flag() { let cli = parse(&["--info"]); assert!(cli.info); } #[test] fn parse_list_flags() { assert!(parse(&["--list-models"]).list_models); assert!(parse(&["--list-roles"]).list_roles); assert!(parse(&["--list-sessions"]).list_sessions); assert!(parse(&["--list-agents"]).list_agents); assert!(parse(&["--list-rags"]).list_rags); assert!(parse(&["--list-macros"]).list_macros); assert!(parse(&["--list-skills"]).list_skills); } #[test] fn parse_skill_flag_takes_name() { assert_eq!(parse(&["--skill", "git-master"]).skill, vec!["git-master"]); assert!(parse(&[]).skill.is_empty()); } #[test] fn parse_multiple_skill_flags_preserves_order() { assert_eq!( parse(&["--skill", "alpha", "--skill", "beta", "--skill", "gamma"]).skill, vec!["alpha", "beta", "gamma"] ); } #[test] fn skills_method_dedupes_preserving_first_occurrence() { let cli = parse(&[ "--skill", "alpha", "--skill", "beta", "--skill", "alpha", "--skill", "gamma", "--skill", "beta", ]); assert_eq!(cli.skills(), vec!["alpha", "beta", "gamma"]); } #[test] fn skills_method_returns_empty_when_no_flags() { assert!(parse(&[]).skills().is_empty()); } #[test] fn parse_file_flag_single() { let cli = parse(&["-f", "file.txt", "question"]); assert_eq!(cli.file, vec!["file.txt"]); } #[test] fn parse_file_flag_multiple() { let cli = parse(&["-f", "a.txt", "-f", "b.txt", "question"]); assert_eq!(cli.file, vec!["a.txt", "b.txt"]); } #[test] fn parse_trailing_text() { let cli = parse(&["hello", "world"]); assert_eq!(cli.text, vec!["hello", "world"]); } #[test] fn parse_prompt_flag() { let cli = parse(&["--prompt", "be a pirate"]); assert_eq!(cli.prompt, Some("be a pirate".to_string())); } #[test] fn parse_empty_session_flag() { let cli = parse(&["--session", "s", "--empty-session"]); assert!(cli.empty_session); } #[test] fn parse_save_session_flag() { let cli = parse(&["--session", "s", "--save-session"]); assert!(cli.save_session); } #[test] fn parse_build_tools_flag() { let cli = parse(&["--build-tools"]); assert!(cli.build_tools); } #[test] fn parse_dangerously_skip_permissions_flag() { let cli = parse(&["--dangerously-skip-permissions"]); assert!(cli.dangerously_skip_permissions); } #[test] fn parse_dangerously_skip_permissions_default_off() { let cli = parse(&[]); assert!(!cli.dangerously_skip_permissions); } #[test] fn parse_headless_flag() { let cli = parse(&["--headless", "do something"]); assert!(cli.headless); } #[test] fn parse_headless_default_off() { assert!(!parse(&[]).headless); } #[test] fn parse_acp_server_flag() { let cli = parse(&["--acp-server"]); assert!(cli.acp_server); } #[test] fn parse_acp_server_default_off() { assert!(!parse(&[]).acp_server); } #[test] fn parse_sync_models_flag() { let cli = parse(&["--sync-models"]); assert!(cli.sync_models); } #[test] fn parse_model_with_role() { let cli = parse(&["-m", "gpt-4o", "-r", "coder"]); assert_eq!(cli.model, Some("gpt-4o".to_string())); assert_eq!(cli.role, Some("coder".to_string())); } #[test] fn parse_agent_with_file_and_text() { let cli = parse(&["-a", "sisyphus", "-f", "code.rs", "explain", "this"]); assert_eq!(cli.agent, Some("sisyphus".to_string())); assert_eq!(cli.file, vec!["code.rs"]); assert_eq!(cli.text, vec!["explain", "this"]); } #[test] fn parse_role_with_session() { let cli = parse(&["-r", "coder", "-s", "dev-session"]); assert_eq!(cli.role, Some("coder".to_string())); assert_eq!(cli.session, Some(Some("dev-session".to_string()))); } #[test] fn cli_text_returns_none_when_no_text_no_stdin() { let cli = parse(&[]); assert!(cli.text().unwrap().is_none()); } #[test] fn cli_text_joins_trailing_args() { let cli = parse(&["hello", "world"]); assert_eq!(cli.text().unwrap(), Some("hello world".to_string())); } #[test] fn parse_add_secret_flag() { let cli = parse(&["--add-secret", "MY_KEY"]); assert_eq!(cli.add_secret, Some("MY_KEY".to_string())); } #[test] fn parse_get_secret_flag() { let cli = parse(&["--get-secret", "MY_KEY"]); assert_eq!(cli.get_secret, Some("MY_KEY".to_string())); } #[test] fn parse_list_secrets_flag() { let cli = parse(&["--list-secrets"]); assert!(cli.list_secrets); } #[test] fn parse_rag_flag() { let cli = parse(&["--rag", "my-rag"]); assert_eq!(cli.rag, Some("my-rag".to_string())); } #[test] fn parse_macro_flag() { let cli = parse(&["--macro", "my-macro"]); assert_eq!(cli.macro_name, Some("my-macro".to_string())); } #[test] fn parse_update_flag_no_value() { let cli = parse(&["--update"]); assert_eq!(cli.update, Some(None)); } #[test] fn parse_update_flag_with_version() { let cli = parse(&["--update", "v0.4.0"]); assert_eq!(cli.update, Some(Some("v0.4.0".to_string()))); } #[test] fn parse_update_with_force() { let cli = parse(&["--update", "--force"]); assert_eq!(cli.update, Some(None)); assert!(cli.force); } #[test] fn parse_force_without_update_fails() { assert!(Cli::try_parse_from(["coyote", "--force"]).is_err()); } #[test] fn parse_sandbox_flag_no_value() { let cli = parse(&["--sandbox"]); assert_eq!(cli.sandbox, Some(None)); } #[test] fn parse_sandbox_flag_with_name() { let cli = parse(&["--sandbox", "my-box"]); assert_eq!(cli.sandbox, Some(Some("my-box".to_string()))); } #[test] fn parse_sandbox_is_exclusive() { assert!(Cli::try_parse_from(["coyote", "--sandbox", "--agent", "foo"]).is_err()); } #[test] fn parse_mcp_add_stdio_with_trailing_command() { let cli = parse(&[ "--mcp-add", "myserver", "--", "npx", "some-server", "--flag", "arg1", ]); assert_eq!(cli.mcp_add, Some("myserver".to_string())); assert_eq!( cli.mcp_command, vec!["npx", "some-server", "--flag", "arg1"] ); assert!(cli.text.is_empty()); } #[test] fn parse_mcp_add_stdio_with_env_and_command() { let cli = parse(&[ "--mcp-add", "s", "--env", "API_KEY={{API_KEY}}", "--env", "MODE=dev", "--", "npx", "srv", ]); assert_eq!(cli.mcp_add, Some("s".to_string())); assert_eq!(cli.env, vec!["API_KEY={{API_KEY}}", "MODE=dev"]); assert_eq!(cli.mcp_command, vec!["npx", "srv"]); } #[test] fn parse_mcp_add_http_with_header() { let cli = parse(&[ "--mcp-add", "notion", "--transport", "http", "--url", "https://mcp.notion.com/mcp", "--header", "Authorization: Bearer {{NOTION_TOKEN}}", ]); assert_eq!(cli.mcp_add, Some("notion".to_string())); assert!(matches!(cli.transport, Some(McpTransportArg::Http))); assert_eq!(cli.url, Some("https://mcp.notion.com/mcp".to_string())); assert_eq!(cli.header, vec!["Authorization: Bearer {{NOTION_TOKEN}}"]); assert!(cli.mcp_command.is_empty()); } #[test] fn parse_mcp_list_flag() { let cli = parse(&["--mcp-list"]); assert!(cli.mcp_list); } #[test] fn parse_mcp_scope_workspace() { let cli = parse(&["--mcp-list", "--scope", "workspace"]); assert!(cli.mcp_list); assert!(matches!(cli.scope, Some(McpScopeArg::Workspace))); } #[test] fn parse_mcp_action_group_is_exclusive() { assert!(Cli::try_parse_from(["coyote", "--mcp-list", "--mcp-get", "foo"]).is_err()); } #[test] fn parse_trailing_text_unchanged_without_dash_dash() { let cli = parse(&["hello", "world"]); assert_eq!(cli.text, vec!["hello", "world"]); assert!(cli.mcp_command.is_empty()); } }