feat(cortex-cli): implement 10 open PR features (#186) (#189)

* feat(cortex-cli): implement 10 open PR features

This commit implements the following features from open PRs:

- PR #98: Improve stats command message for new users with tracking info
- PR #99: Implement --share flag to display share URL using cortex-share
- PR #100: Warn when showing hidden agent details in 'agent show'
- PR #101: Standardize session ID error message format to 'Invalid session ID format:'
- PR #102: Add --port and --host options to debug wait command for TCP port checks
- PR #103: Validate empty prompt before authentication in exec mode
- PR #104: Add --names-only flag for dynamic shell completion of agent names
- PR #105: Document sandbox modes in help text with examples
- PR #106: Improve PR checkout confirmation to show source branch info
- PR #107: Correct help message to use lowercase 'cortex' command

Changes include:
- stats_cmd.rs: Added informative output explaining what stats will track
- run_cmd.rs: Added cortex-share integration for session sharing
- agent_cmd.rs: Added hidden agent warning and --names-only flag
- debug_cmd.rs: Added TCP port wait functionality with --port/--host
- export_cmd.rs: Standardized session ID error message
- main.rs: Added empty prompt validation, sandbox docs, dynamic completion
- pr_cmd.rs: Enhanced checkout message with source branch info
- login.rs: Fixed command name in help text
- Cargo.toml: Added cortex-share dependency

* fix: resolve merge conflicts and fix API changes

- Fixed duplicate import of get_cortex_home in login.rs
- Updated fabric_home to cortex_home in debug_cmd.rs
- Fixed run_logout call to include skip_confirmation parameter
- Re-added yes flag to LogoutCommand struct

---------

Co-authored-by: Droid Agent <droid@factory.ai>

Author: echobt

Cargo.lock

@@ -34,6 +34,7 @@ cortex-process-hardening = { workspace = true }
 cortex-app-server = { workspace = true }
 cortex-update = { workspace = true }
 cortex-mcp-server = { workspace = true }
+cortex-share = { path = "../cortex-share" }
 
 clap = { workspace = true }
 clap_complete = { workspace = true }

cortex-cli/Cargo.toml

@@ -53,6 +53,10 @@ pub struct ListArgs {
     /// Show all agents including hidden ones.
     #[arg(long)]
     pub all: bool,
+
+    /// Output only agent names (one per line) for shell completion.
+    #[arg(long, hide = true)]
+    pub names_only: bool,
 }
 
 /// Arguments for show command.
@@ -700,6 +704,14 @@ async fn run_list(args: ListArgs) -> Result<()> {
         })
         .collect();
 
+    // Output names only for shell completion
+    if args.names_only {
+        for agent in &filtered {
+            println!("{}", agent.name);
+        }
+        return Ok(());
+    }
+
     if args.json {
         let json = serde_json::to_string_pretty(&filtered)?;
         println!("{json}");
@@ -791,6 +803,15 @@ async fn run_show(args: ShowArgs) -> Result<()> {
         .find(|a| a.name == args.name)
         .ok_or_else(|| anyhow::anyhow!("Agent '{}' not found", args.name))?;
 
+    // Warn if the agent is hidden
+    if agent.hidden {
+        eprintln!(
+            "Note: '{}' is a hidden agent (not shown in default listings).",
+            agent.name
+        );
+        eprintln!();
+    }
+
     if args.json {
         let json = serde_json::to_string_pretty(&agent)?;
         println!("{json}");

cortex-cli/src/agent_cmd.rs

@@ -227,7 +227,7 @@ async fn run_config(args: ConfigArgs) -> Result<()> {
         println!("Config Diff (Global vs Local)");
         println!("{}", "=".repeat(50));
 
-        let global_path = config.fabric_home.join("config.toml");
+        let global_path = config.cortex_home.join("config.toml");
         let local_path = std::env::current_dir()
             .ok()
             .map(|d| d.join(".cortex/config.toml"));
@@ -1607,6 +1607,14 @@ pub struct WaitArgs {
     #[arg(long, default_value = "http://127.0.0.1:3000")]
     pub server_url: String,
 
+    /// Wait for a TCP port to be available.
+    #[arg(long)]
+    pub port: Option<u16>,
+
+    /// Host to check when using --port (default: 127.0.0.1).
+    #[arg(long, default_value = "127.0.0.1")]
+    pub host: String,
+
     /// Timeout in seconds.
     #[arg(long, default_value = "30")]
     pub timeout: u64,
@@ -1692,9 +1700,38 @@ async fn run_wait(args: WaitArgs) -> Result<()> {
             error = Some(format!("Timeout waiting for server at {}", args.server_url));
         }
 
+        (condition, success, error)
+    } else if let Some(port) = args.port {
+        // Wait for TCP port to be available
+        let condition = format!("port_ready ({}:{})", args.host, port);
+        let mut success = false;
+        let mut error = None;
+
+        let addr = format!("{}:{}", args.host, port);
+
+        while start.elapsed() < timeout {
+            match tokio::net::TcpStream::connect(&addr).await {
+                Ok(_) => {
+                    // Port is open and accepting connections
+                    success = true;
+                    break;
+                }
+                Err(_) => {
+                    tokio::time::sleep(interval).await;
+                }
+            }
+        }
+
+        if !success {
+            error = Some(format!(
+                "Timeout waiting for port {} on {}",
+                port, args.host
+            ));
+        }
+
         (condition, success, error)
     } else {
-        bail!("No condition specified. Use --lsp-ready or --server-ready");
+        bail!("No condition specified. Use --lsp-ready, --server-ready, or --port");
     };
 
     let waited_ms = start.elapsed().as_millis() as u64;

cortex-cli/src/debug_cmd.rs

@@ -130,7 +130,7 @@ impl ExportCommand {
                     }
                 } else {
                     bail!(
-                        "Invalid session ID: {session_id}. Expected full UUID or 8-character prefix."
+                        "Invalid session ID format: {session_id}. Expected full UUID or 8-character prefix."
                     );
                 }
             }

cortex-cli/src/export_cmd.rs

@@ -1,12 +1,12 @@
 //! Login command handlers.
 
-use cortex_common::{CliConfigOverrides, get_cortex_home};
+use cortex_common::CliConfigOverrides;
 use cortex_login::{
     AuthMode, CredentialsStoreMode, SecureAuthData, load_auth_with_fallback, logout,
     safe_format_key, save_auth_with_fallback,
 };
 use std::collections::HashSet;
-use std::io::{BufRead, IsTerminal, Read};
+use std::io::{IsTerminal, Read};
 use std::path::PathBuf;
 
 /// Check for duplicate config override keys and warn the user.
@@ -33,7 +33,7 @@ fn check_duplicate_config_overrides(config_overrides: &CliConfigOverrides) {
 
 /// Get the cortex home directory using unified directory management.
 fn get_cortex_home() -> PathBuf {
-    get_cortex_home().unwrap_or_else(|| {
+    cortex_common::get_cortex_home().unwrap_or_else(|| {
         dirs::home_dir()
             .map(|h| h.join(".cortex"))
             .unwrap_or_else(|| PathBuf::from(".cortex"))

cortex-cli/src/login.rs

@@ -347,6 +347,11 @@ enum LoginSubcommand {
 struct LogoutCommand {
     #[clap(skip)]
     config_overrides: CliConfigOverrides,
+
+    /// Skip confirmation prompt and log out immediately.
+    /// Useful for scripting and automation.
+    #[arg(short = 'y', long = "yes")]
+    yes: bool,
 }
 
 /// Completion command.
@@ -409,6 +414,17 @@ struct ConfigCommand {
 }
 
 /// Sandbox debug commands.
+///
+/// Run shell commands in a sandboxed environment with restricted permissions.
+///
+/// Available sandbox modes (via CORTEX_SANDBOX_MODE or --sandbox flag):
+///   read-only         - Read-only filesystem access, no write permissions anywhere
+///   workspace-write   - Read access everywhere + write access limited to workspace directory
+///   danger-full-access - Full filesystem access with no restrictions (use with caution)
+///
+/// Examples:
+///   cortex sandbox linux -- ls -la /tmp
+///   cortex sandbox macos -- cat /etc/passwd
 #[derive(Args)]
 struct SandboxArgs {
     #[command(subcommand)]
@@ -564,7 +580,7 @@ async fn main() -> Result<()> {
             Ok(())
         }
         Some(Commands::Logout(logout_cli)) => {
-            run_logout(logout_cli.config_overrides).await;
+            run_logout(logout_cli.config_overrides, logout_cli.yes).await;
             Ok(())
         }
         Some(Commands::Mcp(mcp_cli)) => mcp_cli.run().await,
@@ -673,6 +689,11 @@ async fn run_exec(exec_cli: ExecCommand) -> Result<()> {
     use cortex_protocol::{EventMsg, Op, Submission, UserInput};
     use std::io::Write;
 
+    // Validate prompt is not empty before any other processing (including authentication)
+    if exec_cli.prompt.trim().is_empty() {
+        bail!("Prompt cannot be empty");
+    }
+
     let is_json = exec_cli.format == "json" || exec_cli.format == "jsonl";
 
     let mut config = cortex_engine::Config::default();
@@ -855,6 +876,57 @@ fn generate_completions(shell: Shell) {
     let stdout = io::stdout();
     let mut writer = BrokenPipeIgnorer { inner: stdout };
     generate(shell, &mut cmd, "cortex", &mut writer);
+
+    // Print dynamic completion helper for agent names
+    // Users can regenerate completions to get this functionality
+    let agent_completion_note = match shell {
+        Shell::Bash => {
+            r#"
+# Dynamic agent completion for --agent flag
+# Add this to your .bashrc after sourcing completions:
+_cortex_agent_completion() {
+    local agents
+    agents=$(cortex agent list --names-only 2>/dev/null)
+    COMPREPLY=($(compgen -W "$agents" -- "${COMP_WORDS[COMP_CWORD]}"))
+}
+complete -F _cortex_agent_completion cortex run --agent
+"#
+        }
+        Shell::Zsh => {
+            r#"
+# Dynamic agent completion for --agent flag
+# Add this to your .zshrc after sourcing completions:
+_cortex_agents() {
+    local agents
+    agents=(${(f)"$(cortex agent list --names-only 2>/dev/null)"})
+    _describe 'agent' agents
+}
+compdef _cortex_agents cortex run -a --agent
+"#
+        }
+        Shell::Fish => {
+            r#"
+# Dynamic agent completion for --agent flag
+complete -c cortex -n "__fish_seen_subcommand_from run" -l agent -xa "(cortex agent list --names-only 2>/dev/null)"
+"#
+        }
+        Shell::PowerShell => {
+            r#"
+# Dynamic agent completion for --agent flag
+# Add this to your PowerShell profile:
+Register-ArgumentCompleter -CommandName cortex -ParameterName agent -ScriptBlock {
+    param($commandName, $parameterName, $wordToComplete)
+    cortex agent list --names-only 2>$null | Where-Object { $_ -like "$wordToComplete*" }
+}
+"#
+        }
+        _ => "",
+    };
+
+    // Write the agent completion note as a comment
+    if !agent_completion_note.is_empty() {
+        let _ = writer.write_all(agent_completion_note.as_bytes());
+    }
 }
 
 async fn run_resume(resume_cli: ResumeCommand) -> Result<()> {
@@ -901,7 +973,7 @@ async fn run_resume(resume_cli: ResumeCommand) -> Result<()> {
                 }
             } else {
                 anyhow::bail!(
-                    "Invalid session ID: {id_str}. Expected full UUID or 8-character prefix."
+                    "Invalid session ID format: {id_str}. Expected full UUID or 8-character prefix."
                 );
             }
         }

cortex-cli/src/main.rs

@@ -243,8 +243,10 @@ async fn run_pr_checkout(args: PrCli) -> Result<()> {
     }
 
     println!();
-    println!("✅ Successfully checked out PR #{}", pr_number);
-    println!("   Branch: {}", branch_name);
+    println!(
+        "✅ Checked out PR #{} to branch '{}' from '{}:{}'",
+        pr_number, branch_name, pr_info.author, pr_info.head_branch
+    );
     println!();
     println!("Commands:");
     // SECURITY: Validate base_branch before displaying in commands

cortex-cli/src/pr_cmd.rs

@@ -796,9 +796,15 @@ impl RunCli {
 
         // Share session if requested
         if self.share {
-            // TODO: Implement session sharing when API is available
-            if self.verbose {
-                eprintln!("Session sharing requested but not yet implemented");
+            use cortex_share::ShareManager;
+            let share_manager = ShareManager::new();
+            match share_manager.share(&session_id).await {
+                Ok(shared) => {
+                    eprintln!("✓ Session shared: {}", shared.url);
+                }
+                Err(e) => {
+                    eprintln!("Warning: Failed to share session: {}", e);
+                }
             }
         }
 

cortex-cli/src/run_cmd.rs

@@ -131,6 +131,12 @@ impl StatsCli {
                 println!("{json_output}");
             } else {
                 println!("No sessions found. Start using Cortex to generate statistics!");
+                println!();
+                println!("The stats command will track:");
+                println!("  - Session counts and message totals");
+                println!("  - Token usage (input and output tokens)");
+                println!("  - Estimated costs by provider and model");
+                println!("  - Tool call frequency");
             }
             return Ok(());
         }