fix: batch fixes for issues #2008, 2019, 2020, 2021, 2022, 2025, 2026, 2027, 2033, 2038 [skip ci] (#380)

Fixes:
- #2008: HOME relative path now resolved to absolute to prevent unexpected config locations
- #2019: Added 'cortex agent copy/clone' subcommand to duplicate agents
- #2020: Added 'cortex agent export' subcommand to export agent definitions
- #2021: Added 'cortex mcp enable/disable' subcommands to toggle servers without removal
- #2022: Added 'cortex mcp rename' subcommand to rename MCP servers
- #2025: Added 'cortex whoami' command to show current authenticated user
- #2026: logout --all flag already exists (verified working)
- #2027: Added 'cortex servers refresh' subcommand for mDNS re-scan
- #2033: Added 'cortex history' command with search and clear subcommands
- #2038: Added security warning for sensitive system files in 'run -i'

Co-authored-by: Bounty Bot <bounty-bot@factory.ai>

Author: echobt

cortex-cli/src/agent_cmd.rs

@@ -39,6 +39,13 @@ pub enum AgentSubcommand {
 
     /// Install an agent from the registry.
     Install(InstallArgs),
+
+    /// Copy/clone an existing agent with a new name.
+    #[command(visible_alias = "clone")]
+    Copy(CopyArgs),
+
+    /// Export an agent definition to stdout or a file.
+    Export(ExportArgs),
 }
 
 /// Arguments for list command.
@@ -170,6 +177,35 @@ pub struct InstallArgs {
     pub registry: Option<String>,
 }
 
+/// Arguments for copy command.
+#[derive(Debug, Parser)]
+pub struct CopyArgs {
+    /// Name of the agent to copy.
+    pub source: String,
+
+    /// Name for the new agent copy.
+    pub destination: String,
+
+    /// Force overwrite if destination agent already exists.
+    #[arg(short, long)]
+    pub force: bool,
+}
+
+/// Arguments for export command.
+#[derive(Debug, Parser)]
+pub struct ExportArgs {
+    /// Name of the agent to export.
+    pub name: String,
+
+    /// Output file path (defaults to stdout).
+    #[arg(short, long)]
+    pub output: Option<PathBuf>,
+
+    /// Export as JSON instead of markdown.
+    #[arg(long)]
+    pub json: bool,
+}
+
 /// Agent operation mode.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
 #[serde(rename_all = "lowercase")]
@@ -341,6 +377,8 @@ impl AgentCli {
             AgentSubcommand::Edit(args) => run_edit(args).await,
             AgentSubcommand::Remove(args) => run_remove(args).await,
             AgentSubcommand::Install(args) => run_install(args).await,
+            AgentSubcommand::Copy(args) => run_copy(args).await,
+            AgentSubcommand::Export(args) => run_export(args).await,
         }
     }
 }
@@ -2078,6 +2116,226 @@ Provide architectural recommendations with:
 - Implementation roadmap
 "#;
 
+/// Copy/clone an existing agent with a new name.
+async fn run_copy(args: CopyArgs) -> Result<()> {
+    let agents = load_all_agents()?;
+
+    // Find the source agent
+    let source_agent = agents
+        .iter()
+        .find(|a| a.name == args.source)
+        .ok_or_else(|| anyhow::anyhow!("Agent '{}' not found", args.source))?;
+
+    // Validate destination name
+    if args.destination.trim().is_empty() {
+        bail!("Destination agent name cannot be empty");
+    }
+
+    if !args
+        .destination
+        .chars()
+        .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_')
+    {
+        bail!("Agent name must contain only alphanumeric characters, hyphens, and underscores");
+    }
+
+    // Check if destination already exists
+    let dest_exists = agents.iter().any(|a| a.name == args.destination);
+    if dest_exists && !args.force {
+        bail!(
+            "Agent '{}' already exists. Use --force to overwrite.",
+            args.destination
+        );
+    }
+
+    // Get the agents directory
+    let agents_dir = get_agents_dir()?;
+    std::fs::create_dir_all(&agents_dir)?;
+
+    let dest_file = agents_dir.join(format!("{}.md", args.destination));
+
+    // Generate the agent content
+    let content = if source_agent.native {
+        // For built-in agents, create a new file from scratch
+        let mut frontmatter = format!(
+            r#"---
+name: {}
+description: "{}"
+mode: {}
+"#,
+            args.destination,
+            source_agent
+                .description
+                .as_ref()
+                .map(|d| format!("Copy of {}: {}", args.source, d))
+                .unwrap_or_else(|| format!("Copy of {} agent", args.source)),
+            source_agent.mode
+        );
+
+        if let Some(temp) = source_agent.temperature {
+            frontmatter.push_str(&format!("temperature: {}\n", temp));
+        }
+
+        if let Some(ref model) = source_agent.model {
+            frontmatter.push_str(&format!("model: {}\n", model));
+        }
+
+        if let Some(ref color) = source_agent.color {
+            frontmatter.push_str(&format!("color: \"{}\"\n", color));
+        }
+
+        if let Some(ref allowed) = source_agent.allowed_tools {
+            frontmatter.push_str("allowed_tools:\n");
+            for tool in allowed {
+                frontmatter.push_str(&format!("  - {}\n", tool));
+            }
+        }
+
+        if !source_agent.denied_tools.is_empty() {
+            frontmatter.push_str("denied_tools:\n");
+            for tool in &source_agent.denied_tools {
+                frontmatter.push_str(&format!("  - {}\n", tool));
+            }
+        }
+
+        frontmatter.push_str(&format!("can_delegate: {}\n", source_agent.can_delegate));
+        frontmatter.push_str("---\n\n");
+
+        if let Some(ref prompt) = source_agent.prompt {
+            frontmatter.push_str(prompt);
+            frontmatter.push('\n');
+        }
+
+        frontmatter
+    } else if let Some(ref path) = source_agent.path {
+        // For custom agents, read the file and update the name
+        let content = read_file_with_encoding(path)?;
+        let (mut fm, body) = parse_frontmatter(&content)?;
+        fm.name = args.destination.clone();
+
+        // Rebuild the file
+        let yaml = serde_yaml::to_string(&fm)?;
+        format!("---\n{}---\n\n{}\n", yaml, body)
+    } else {
+        bail!("Agent '{}' has no source file", args.source);
+    };
+
+    // Write the new agent file
+    std::fs::write(&dest_file, &content)
+        .with_context(|| format!("Failed to write agent file: {}", dest_file.display()))?;
+
+    println!("Agent '{}' copied to '{}'", args.source, args.destination);
+    println!("   Location: {}", dest_file.display());
+    println!();
+    println!(
+        "   Use 'cortex agent show {}' to view details.",
+        args.destination
+    );
+
+    Ok(())
+}
+
+/// Export an agent definition to stdout or a file.
+async fn run_export(args: ExportArgs) -> Result<()> {
+    let agents = load_all_agents()?;
+
+    let agent = agents
+        .iter()
+        .find(|a| a.name == args.name)
+        .ok_or_else(|| anyhow::anyhow!("Agent '{}' not found", args.name))?;
+
+    let output = if args.json {
+        // Export as JSON
+        serde_json::to_string_pretty(agent)?
+    } else {
+        // Export as markdown with YAML frontmatter
+        let mut frontmatter = format!(
+            r#"---
+name: {}
+"#,
+            agent.name
+        );
+
+        if let Some(ref desc) = agent.description {
+            frontmatter.push_str(&format!("description: \"{}\"\n", desc.replace('"', "\\\"")));
+        }
+
+        frontmatter.push_str(&format!("mode: {}\n", agent.mode));
+
+        if let Some(ref display_name) = agent.display_name {
+            frontmatter.push_str(&format!("display_name: \"{}\"\n", display_name));
+        }
+
+        if let Some(temp) = agent.temperature {
+            frontmatter.push_str(&format!("temperature: {}\n", temp));
+        }
+
+        if let Some(top_p) = agent.top_p {
+            frontmatter.push_str(&format!("top_p: {}\n", top_p));
+        }
+
+        if let Some(ref model) = agent.model {
+            frontmatter.push_str(&format!("model: {}\n", model));
+        }
+
+        if let Some(ref color) = agent.color {
+            frontmatter.push_str(&format!("color: \"{}\"\n", color));
+        }
+
+        if let Some(ref allowed) = agent.allowed_tools {
+            frontmatter.push_str("allowed_tools:\n");
+            for tool in allowed {
+                frontmatter.push_str(&format!("  - {}\n", tool));
+            }
+        }
+
+        if !agent.denied_tools.is_empty() {
+            frontmatter.push_str("denied_tools:\n");
+            for tool in &agent.denied_tools {
+                frontmatter.push_str(&format!("  - {}\n", tool));
+            }
+        }
+
+        if !agent.tags.is_empty() {
+            frontmatter.push_str("tags:\n");
+            for tag in &agent.tags {
+                frontmatter.push_str(&format!("  - {}\n", tag));
+            }
+        }
+
+        frontmatter.push_str(&format!("can_delegate: {}\n", agent.can_delegate));
+
+        if let Some(max_turns) = agent.max_turns {
+            frontmatter.push_str(&format!("max_turns: {}\n", max_turns));
+        }
+
+        frontmatter.push_str(&format!("hidden: {}\n", agent.hidden));
+        frontmatter.push_str("---\n\n");
+
+        if let Some(ref prompt) = agent.prompt {
+            frontmatter.push_str(prompt);
+            frontmatter.push('\n');
+        }
+
+        frontmatter
+    };
+
+    // Write to file or stdout
+    if let Some(ref output_path) = args.output {
+        std::fs::write(output_path, &output)
+            .with_context(|| format!("Failed to write to: {}", output_path.display()))?;
+        eprintln!(
+            "Agent '{}' exported to: {}",
+            args.name,
+            output_path.display()
+        );
+    } else {
+        print!("{}", output);
+    }
+
+    Ok(())
+}
+
 /// Format a hex color as an ANSI-colored preview block.
 ///
 /// Converts a hex color like "#FF5733" to an ANSI escape sequence that
@@ -2180,6 +2438,30 @@ mod tests {
         assert_eq!(result.unwrap(), content);
     }
 
+    #[test]
+    fn test_copy_args() {
+        // Test that CopyArgs parses correctly
+        let args = CopyArgs {
+            source: "build".to_string(),
+            destination: "my-build".to_string(),
+            force: false,
+        };
+        assert_eq!(args.source, "build");
+        assert_eq!(args.destination, "my-build");
+    }
+
+    #[test]
+    fn test_export_args() {
+        // Test that ExportArgs parses correctly
+        let args = ExportArgs {
+            name: "build".to_string(),
+            output: None,
+            json: false,
+        };
+        assert_eq!(args.name, "build");
+        assert!(!args.json);
+    }
+
     #[test]
     fn test_parse_frontmatter() {
         let content = r#"---