Rename --host to --remote-host

Author: pRizz

packages/cli-rust/src/commands/cleanup.rs

@@ -3,7 +3,6 @@
 use anyhow::{Context, Result, bail};
 use opencode_cloud_core::config::{Config, get_config_path, load_config_or_default};
 use opencode_cloud_core::docker::ParsedMount;
-use opencode_cloud_core::load_hosts;
 use std::fs;
 use std::path::{Component, Path, PathBuf};
 
@@ -25,20 +24,8 @@ impl MountCleanupResult {
     }
 }
 
-pub fn resolve_target_host_name(maybe_host: Option<&str>) -> Option<String> {
-    if let Some(name) = maybe_host {
-        return Some(name.to_string());
-    }
-
-    let hosts = load_hosts().unwrap_or_default();
-    hosts.default_host.clone()
-}
-
 pub fn is_remote_host(maybe_host: Option<&str>) -> bool {
-    matches!(
-        resolve_target_host_name(maybe_host),
-        Some(name) if !name.is_empty() && name != "local"
-    )
+    matches!(maybe_host, Some(name) if !name.is_empty())
 }
 
 pub fn load_config_for_mounts(include_defaults_if_missing: bool) -> Result<(Config, bool)> {

packages/cli-rust/src/commands/host/default.rs

@@ -75,7 +75,7 @@ pub async fn cmd_host_default(args: &HostDefaultArgs, quiet: bool, _verbose: u8)
                     "  {} Commands will now target {} unless {} is specified.",
                     style("Note:").dim(),
                     style(name).cyan(),
-                    style("--host").yellow()
+                    style("--remote-host or --local").yellow()
                 );
             }
             Ok(())

packages/cli-rust/src/commands/mount/clean.rs

@@ -30,7 +30,7 @@ pub async fn cmd_mount_clean(
     if is_remote_host(maybe_host) {
         return Err(anyhow!(
             "Mount cleanup is only supported for local hosts.\n\
-             Run without --host or use --host local on the machine where the mounts exist."
+             Run without --remote-host or use --local on the machine where the mounts exist."
         ));
     }
 

packages/cli-rust/src/commands/reset/mod.rs

@@ -103,7 +103,7 @@ async fn cmd_reset_container(
     if (args.clean_mounts || args.purge_mounts) && is_remote_host(maybe_host) {
         bail!(
             "Mount cleanup is only supported for local hosts.\n\
-             Run without --host or use --host local on the machine where the mounts exist."
+             Run without --remote-host or use --local on the machine where the mounts exist."
         );
     }
 
@@ -263,7 +263,7 @@ async fn cmd_reset_host(
     if is_remote_host(maybe_host) {
         bail!(
             "Host reset is only supported on the local machine.\n\
-             Run without --host or use --host local."
+             Run without --remote-host or use --local."
         );
     }
 

packages/cli-rust/src/commands/setup.rs

@@ -25,17 +25,22 @@ pub struct SetupArgs {
     pub bootstrap: bool,
 
     /// Run setup for a remote host instead of local Docker
-    #[arg(long)]
-    pub host: Option<String>,
+    #[arg(long, conflicts_with = "local")]
+    pub remote_host: Option<String>,
+
+    /// Force local Docker (ignores default_host)
+    #[arg(long, conflicts_with = "remote_host")]
+    pub local: bool,
 }
 
 /// Run the setup command
 pub async fn cmd_setup(args: &SetupArgs, quiet: bool) -> Result<()> {
     // Load existing config (or create default)
     let existing_config = load_config_or_default().ok();
+    let target_host = crate::resolve_target_host(args.remote_host.as_deref(), args.local);
 
     if args.bootstrap {
-        return run_bootstrap_setup(existing_config, args.host.as_deref(), quiet).await;
+        return run_bootstrap_setup(existing_config, target_host.as_deref(), quiet).await;
     }
 
     // Handle --yes flag for non-interactive mode
@@ -75,7 +80,7 @@ pub async fn cmd_setup(args: &SetupArgs, quiet: bool) -> Result<()> {
     println!();
 
     // Check if container is already running
-    let (client, host_name) = crate::resolve_docker_client(args.host.as_deref()).await?;
+    let (client, host_name) = crate::resolve_docker_client(target_host.as_deref()).await?;
     let is_running = container_is_running(&client, CONTAINER_NAME)
         .await
         .unwrap_or(false);
@@ -117,7 +122,7 @@ pub async fn cmd_setup(args: &SetupArgs, quiet: bool) -> Result<()> {
             timeout: 60,
             remove: false,
         };
-        cmd_stop(&stop_args, args.host.as_deref(), quiet).await?;
+        cmd_stop(&stop_args, target_host.as_deref(), quiet).await?;
         println!();
     }
 
@@ -126,14 +131,14 @@ pub async fn cmd_setup(args: &SetupArgs, quiet: bool) -> Result<()> {
         port: Some(new_config.opencode_web_port),
         ..Default::default()
     };
-    cmd_start(&start_args, args.host.as_deref(), quiet, 0).await?;
+    cmd_start(&start_args, target_host.as_deref(), quiet, 0).await?;
 
     Ok(())
 }
 
 async fn run_bootstrap_setup(
     existing_config: Option<Config>,
-    host: Option<&str>,
+    target_host: Option<&str>,
     quiet: bool,
 ) -> Result<()> {
     let new_config = build_bootstrap_config(existing_config.clone());
@@ -143,7 +148,7 @@ async fn run_bootstrap_setup(
         return start_or_restart_after_setup(
             existing_config.as_ref(),
             &new_config,
-            host,
+            target_host,
             quiet,
             true,
         )
@@ -161,7 +166,14 @@ async fn run_bootstrap_setup(
     );
     println!();
 
-    start_or_restart_after_setup(existing_config.as_ref(), &new_config, host, quiet, true).await
+    start_or_restart_after_setup(
+        existing_config.as_ref(),
+        &new_config,
+        target_host,
+        quiet,
+        true,
+    )
+    .await
 }
 
 fn build_bootstrap_config(existing_config: Option<Config>) -> Config {
@@ -176,11 +188,11 @@ fn build_bootstrap_config(existing_config: Option<Config>) -> Config {
 async fn start_or_restart_after_setup(
     existing_config: Option<&Config>,
     new_config: &Config,
-    host: Option<&str>,
+    target_host: Option<&str>,
     quiet: bool,
     non_interactive: bool,
 ) -> Result<()> {
-    let (client, host_name) = crate::resolve_docker_client(host).await?;
+    let (client, host_name) = crate::resolve_docker_client(target_host).await?;
     let is_running = container_is_running(&client, CONTAINER_NAME)
         .await
         .unwrap_or(false);
@@ -199,14 +211,14 @@ async fn start_or_restart_after_setup(
             timeout: 60,
             remove: false,
         };
-        cmd_stop(&stop_args, host, quiet || non_interactive).await?;
+        cmd_stop(&stop_args, target_host, quiet || non_interactive).await?;
     }
 
     let start_args = crate::commands::StartArgs {
         port: Some(new_config.opencode_web_port),
         ..Default::default()
     };
-    cmd_start(&start_args, host, quiet || non_interactive, 0).await?;
+    cmd_start(&start_args, target_host, quiet || non_interactive, 0).await?;
     Ok(())
 }
 

packages/cli-rust/src/commands/start.rs

@@ -1094,7 +1094,7 @@ fn show_start_result(
     quiet: bool,
     host_name: Option<&str>,
 ) {
-    // Get remote host address if using --host
+    // Get remote host address if using --remote-host
     let maybe_remote_addr = resolve_remote_addr(host_name);
 
     if quiet {

packages/cli-rust/src/commands/status.rs

@@ -156,7 +156,7 @@ pub async fn cmd_status(
         .map(|cfg| cfg.bind_address.as_str())
         .unwrap_or("127.0.0.1");
 
-    // Get remote host address if using --host
+    // Get remote host address if using --remote-host
     let maybe_remote_addr = resolve_remote_addr(host_name.as_deref());
 
     // Normal mode: print formatted status
@@ -579,7 +579,7 @@ fn print_cockpit(
         )
     );
     let user_cmd = if let Some(name) = maybe_host_name {
-        format!("occ user add <username> --host {name}")
+        format!("occ user add <username> --remote-host {name}")
     } else {
         "occ user add <username>".to_string()
     };

packages/cli-rust/src/commands/user/mod.rs

@@ -57,7 +57,9 @@ pub async fn cmd_user(
     // Check container is running first
     if !container_is_running(&client, CONTAINER_NAME).await? {
         let msg = if let Some(name) = &host_name {
-            format!("Container not running on {name}. Start with `occ start --host {name}`.")
+            format!(
+                "Container not running on {name}. Start with `occ start --remote-host {name}`."
+            )
         } else {
             "Container not running. Start with `occ start` first.".to_string()
         };

packages/cli-rust/src/lib.rs

@@ -40,8 +40,12 @@ struct Cli {
     no_color: bool,
 
     /// Target remote host (overrides default_host)
-    #[arg(long, global = true)]
-    host: Option<String>,
+    #[arg(long, global = true, conflicts_with = "local")]
+    remote_host: Option<String>,
+
+    /// Force local Docker (ignores default_host)
+    #[arg(long, global = true, conflicts_with = "remote_host")]
+    local: bool,
 }
 
 #[derive(Subcommand)]
@@ -90,26 +94,39 @@ fn get_banner() -> &'static str {
 "#
 }
 
-/// Resolve which Docker client to use based on --host flag and default_host config
-///
-/// Returns (DockerClient, Option<host_name>) where host_name is Some for remote connections.
+/// Resolve the target host name based on flags and hosts.json
 ///
 /// Resolution order:
-/// 1. --host flag (explicit)
-/// 2. default_host from hosts.json
-/// 3. Local Docker (no host_name)
+/// 1. --local (force local Docker)
+/// 2. --remote-host flag (explicit)
+/// 3. default_host from hosts.json
+/// 4. Local Docker (no host_name)
+pub fn resolve_target_host(remote_host: Option<&str>, force_local: bool) -> Option<String> {
+    if force_local {
+        return None;
+    }
+
+    if let Some(name) = remote_host {
+        return Some(name.to_string());
+    }
+
+    let hosts = load_hosts().unwrap_or_default();
+    hosts.default_host.clone()
+}
+
+/// Resolve which Docker client to use based on an explicit target host name
+///
+/// Returns (DockerClient, Option<host_name>) where host_name is Some for remote connections.
 pub async fn resolve_docker_client(
     maybe_host: Option<&str>,
 ) -> anyhow::Result<(DockerClient, Option<String>)> {
     let hosts = load_hosts().unwrap_or_default();
 
     // Determine target host
-    let target_host = maybe_host
-        .map(String::from)
-        .or_else(|| hosts.default_host.clone());
+    let target_host = maybe_host.map(String::from);
 
     match target_host {
-        Some(name) if name != "local" && !name.is_empty() => {
+        Some(name) => {
             // Remote host requested
             let host_config = hosts.get_host(&name).ok_or_else(|| {
                 anyhow::anyhow!(
@@ -120,7 +137,7 @@ pub async fn resolve_docker_client(
             let client = DockerClient::connect_remote(host_config, &name).await?;
             Ok((client, Some(name)))
         }
-        _ => {
+        None => {
             // Local Docker
             let client = DockerClient::new()?;
             Ok((client, None))
@@ -228,8 +245,8 @@ pub fn run() -> Result<()> {
         eprintln!("{} Data: {}", style("[info]").cyan(), data_dir);
     }
 
-    // Store host flag for command handlers
-    let target_host = cli.host.clone();
+    // Store target host for command handlers
+    let target_host = resolve_target_host(cli.remote_host.as_deref(), cli.local);
 
     match cli.command {
         Some(Commands::Start(args)) => {