Merge PR #261: fix: batch fixes for issues #2508-#2540

Author: factorydroid

cortex-cli/src/acp_cmd.rs

@@ -41,6 +41,16 @@ pub struct AcpCli {
     /// Agent to use.
     #[arg(long = "agent")]
     pub agent: Option<String>,
+
+    /// Tools to allow (whitelist). Can be specified multiple times.
+    /// Only these tools will be available to the agent.
+    #[arg(long = "allow-tool", action = clap::ArgAction::Append)]
+    pub allow_tools: Vec<String>,
+
+    /// Tools to deny (blacklist). Can be specified multiple times.
+    /// These tools will be blocked from use.
+    #[arg(long = "deny-tool", action = clap::ArgAction::Append)]
+    pub deny_tools: Vec<String>,
 }
 
 impl AcpCli {
@@ -58,6 +68,17 @@ impl AcpCli {
             config.model = resolve_model_alias(model).to_string();
         }
 
+        // Report tool restrictions (will be applied when server initializes session)
+        if !self.allow_tools.is_empty() {
+            eprintln!("Tool whitelist: {:?}", self.allow_tools);
+            // Note: Tool restrictions are passed via server configuration
+        }
+
+        if !self.deny_tools.is_empty() {
+            eprintln!("Tool blacklist: {:?}", self.deny_tools);
+            // Note: Tool restrictions are passed via server configuration
+        }
+
         // Decide transport mode
         if self.stdio || self.port == 0 {
             // Use stdio transport

cortex-cli/src/agent_cmd.rs

@@ -36,6 +36,9 @@ pub enum AgentSubcommand {
 
     /// Remove a user-defined agent.
     Remove(RemoveArgs),
+
+    /// Install an agent from the registry.
+    Install(InstallArgs),
 }
 
 /// Arguments for list command.
@@ -147,6 +150,21 @@ pub struct RemoveArgs {
     pub force: bool,
 }
 
+/// Arguments for install command.
+#[derive(Debug, Parser)]
+pub struct InstallArgs {
+    /// Name or URL of the agent to install from registry.
+    pub name: String,
+
+    /// Force overwrite if agent already exists.
+    #[arg(short, long)]
+    pub force: bool,
+
+    /// Registry URL to install from (defaults to official registry).
+    #[arg(long)]
+    pub registry: Option<String>,
+}
+
 /// Agent operation mode.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
 #[serde(rename_all = "lowercase")]
@@ -317,6 +335,7 @@ impl AgentCli {
             AgentSubcommand::Create(args) => run_create(args).await,
             AgentSubcommand::Edit(args) => run_edit(args).await,
             AgentSubcommand::Remove(args) => run_remove(args).await,
+            AgentSubcommand::Install(args) => run_install(args).await,
         }
     }
 }
@@ -1593,6 +1612,89 @@ async fn run_remove(args: RemoveArgs) -> Result<()> {
     Ok(())
 }
 
+/// Install agent from registry.
+async fn run_install(args: InstallArgs) -> Result<()> {
+    let registry_url = args
+        .registry
+        .as_deref()
+        .unwrap_or("https://registry.cortex.foundation");
+
+    println!("Installing agent '{}' from registry...", args.name);
+    println!("   Registry: {}", registry_url);
+
+    // Construct the agent download URL
+    let agent_url = format!("{}/agents/{}.md", registry_url, args.name);
+
+    // Download the agent file
+    println!("   Fetching: {}", agent_url);
+
+    let response = reqwest::get(&agent_url).await;
+
+    let content = match response {
+        Ok(resp) => {
+            if !resp.status().is_success() {
+                bail!(
+                    "Agent '{}' not found in registry (HTTP {}).\n\n\
+                    Available options:\n\
+                    1. Check the agent name is correct\n\
+                    2. Use --registry to specify a different registry URL\n\
+                    3. Create a custom agent with: cortex agent create {}",
+                    args.name,
+                    resp.status(),
+                    args.name
+                );
+            }
+            resp.text()
+                .await
+                .with_context(|| "Failed to read agent content")?
+        }
+        Err(e) => {
+            bail!(
+                "Failed to connect to registry: {}\n\n\
+                Check your network connection or try a different registry with --registry",
+                e
+            );
+        }
+    };
+
+    // Validate the content has proper frontmatter
+    if !content.trim().starts_with("---") {
+        bail!("Invalid agent file format. Expected markdown with YAML frontmatter.");
+    }
+
+    // Get target path
+    let agents_dir = get_agents_dir()?;
+    std::fs::create_dir_all(&agents_dir)?;
+
+    let agent_file = agents_dir.join(format!("{}.md", args.name));
+
+    // Check if already exists
+    if agent_file.exists() && !args.force {
+        bail!(
+            "Agent '{}' already exists at {}.\n\
+            Use --force to overwrite.",
+            args.name,
+            agent_file.display()
+        );
+    }
+
+    // Write the agent file
+    std::fs::write(&agent_file, &content)
+        .with_context(|| format!("Failed to write agent file: {}", agent_file.display()))?;
+
+    println!();
+    println!("Agent '{}' installed successfully!", args.name);
+    println!("   Location: {}", agent_file.display());
+    println!();
+    println!("   Use 'cortex agent show {}' to view details.", args.name);
+    println!(
+        "   Use 'cortex -a {}' to start a session with this agent.",
+        args.name
+    );
+
+    Ok(())
+}
+
 /// Generate agent using AI.
 async fn run_generate(args: CreateArgs) -> Result<()> {
     use cortex_engine::agent::{AgentGenerator, GeneratedAgent};

cortex-cli/src/github_cmd.rs

@@ -28,6 +28,12 @@ pub enum GitHubSubcommand {
 
     /// Check GitHub Actions installation status.
     Status(StatusArgs),
+
+    /// Uninstall/remove the Cortex GitHub workflow.
+    Uninstall(UninstallArgs),
+
+    /// Update the Cortex GitHub workflow to the latest version.
+    Update(UpdateArgs),
 }
 
 /// Arguments for install command.
@@ -100,13 +106,51 @@ pub struct StatusArgs {
     pub json: bool,
 }
 
+/// Arguments for uninstall command.
+#[derive(Debug, Parser)]
+pub struct UninstallArgs {
+    /// Path to the repository root (defaults to current directory).
+    #[arg(short, long)]
+    pub path: Option<PathBuf>,
+
+    /// Workflow name to remove (defaults to "cortex").
+    #[arg(long, default_value = "cortex")]
+    pub workflow_name: String,
+
+    /// Force removal without confirmation.
+    #[arg(short, long)]
+    pub force: bool,
+}
+
+/// Arguments for update command.
+#[derive(Debug, Parser)]
+pub struct UpdateArgs {
+    /// Path to the repository root (defaults to current directory).
+    #[arg(short, long)]
+    pub path: Option<PathBuf>,
+
+    /// Workflow name to update (defaults to "cortex").
+    #[arg(long, default_value = "cortex")]
+    pub workflow_name: String,
+
+    /// Include PR review automation.
+    #[arg(long, default_value_t = true)]
+    pub pr_review: bool,
+
+    /// Include issue automation.
+    #[arg(long, default_value_t = true)]
+    pub issue_automation: bool,
+}
+
 impl GitHubCli {
     /// Run the GitHub command.
     pub async fn run(self) -> Result<()> {
         match self.subcommand {
             GitHubSubcommand::Install(args) => run_install(args).await,
             GitHubSubcommand::Run(args) => run_github_agent(args).await,
             GitHubSubcommand::Status(args) => run_status(args).await,
+            GitHubSubcommand::Uninstall(args) => run_uninstall(args).await,
+            GitHubSubcommand::Update(args) => run_update(args).await,
         }
     }
 }
@@ -614,6 +658,154 @@ async fn run_status(args: StatusArgs) -> Result<()> {
     Ok(())
 }
 
+/// Uninstall/remove GitHub Actions workflow.
+async fn run_uninstall(args: UninstallArgs) -> Result<()> {
+    use std::io::{self, Write};
+
+    let repo_path = args.path.unwrap_or_else(|| PathBuf::from("."));
+
+    // Validate path exists
+    if !repo_path.exists() {
+        bail!("Path does not exist: {}", repo_path.display());
+    }
+
+    // Check for workflow files
+    let workflows_dir = repo_path.join(".github").join("workflows");
+
+    // Try multiple possible workflow file names
+    let possible_names = vec![
+        format!("{}.yml", args.workflow_name),
+        format!("{}.yaml", args.workflow_name),
+    ];
+
+    let mut found_workflow: Option<PathBuf> = None;
+    for name in &possible_names {
+        let path = workflows_dir.join(name);
+        if path.exists() {
+            // Verify it's a Cortex workflow
+            if let Ok(content) = std::fs::read_to_string(&path) {
+                if content.contains("Cortex") || content.contains("cortex") {
+                    found_workflow = Some(path);
+                    break;
+                }
+            }
+        }
+    }
+
+    let workflow_path = match found_workflow {
+        Some(p) => p,
+        None => {
+            bail!(
+                "Cortex workflow '{}' not found in {}.\n\
+                Use `cortex github status` to check installation status.",
+                args.workflow_name,
+                workflows_dir.display()
+            );
+        }
+    };
+
+    // Confirm removal unless --force
+    if !args.force {
+        print!(
+            "Remove Cortex workflow '{}'? [y/N]: ",
+            workflow_path.display()
+        );
+        io::stdout().flush()?;
+
+        let mut input = String::new();
+        io::stdin().read_line(&mut input)?;
+
+        if !input.trim().eq_ignore_ascii_case("y") {
+            println!("Cancelled.");
+            return Ok(());
+        }
+    }
+
+    // Remove the workflow file
+    std::fs::remove_file(&workflow_path)
+        .with_context(|| format!("Failed to remove workflow: {}", workflow_path.display()))?;
+
+    println!("Cortex workflow removed successfully!");
+    println!("   Removed: {}", workflow_path.display());
+    println!();
+    println!(
+        "Note: You may also want to remove the CORTEX_API_KEY secret from your repository settings."
+    );
+
+    Ok(())
+}
+
+/// Update GitHub Actions workflow to latest version.
+async fn run_update(args: UpdateArgs) -> Result<()> {
+    use cortex_engine::github::{WorkflowConfig, generate_workflow};
+
+    let repo_path = args.path.unwrap_or_else(|| PathBuf::from("."));
+
+    // Validate path exists
+    if !repo_path.exists() {
+        bail!("Path does not exist: {}", repo_path.display());
+    }
+
+    let workflows_dir = repo_path.join(".github").join("workflows");
+
+    // Try to find existing workflow
+    let possible_names = vec![
+        format!("{}.yml", args.workflow_name),
+        format!("{}.yaml", args.workflow_name),
+    ];
+
+    let mut existing_path: Option<PathBuf> = None;
+    for name in &possible_names {
+        let path = workflows_dir.join(name);
+        if path.exists() {
+            existing_path = Some(path);
+            break;
+        }
+    }
+
+    let workflow_file = match existing_path {
+        Some(p) => p,
+        None => {
+            bail!(
+                "Cortex workflow '{}' not found. Use `cortex github install` first.",
+                args.workflow_name
+            );
+        }
+    };
+
+    // Generate updated workflow
+    let config = WorkflowConfig {
+        name: args.workflow_name.clone(),
+        pr_review: args.pr_review,
+        issue_automation: args.issue_automation,
+    };
+
+    let workflow_content = generate_workflow(&config);
+
+    // Write updated workflow
+    std::fs::write(&workflow_file, &workflow_content)
+        .with_context(|| format!("Failed to write workflow file: {}", workflow_file.display()))?;
+
+    println!("Cortex workflow updated successfully!");
+    println!("   Path: {}", workflow_file.display());
+    println!();
+    println!("Features enabled:");
+    if args.pr_review {
+        println!("  • PR review automation");
+    }
+    if args.issue_automation {
+        println!("  • Issue automation");
+    }
+    println!();
+    println!("Next steps:");
+    println!("  1. Commit and push the updated workflow:");
+    println!("     git add {}", workflow_file.display());
+    println!("     git commit -m \"Update Cortex workflow\"");
+    println!("     git push");
+
+    Ok(())
+}
+
 /// Installation status information.
 #[derive(Debug, Default, serde::Serialize)]
 struct InstallationStatus {