Hide host selector menu if no default host is present. (#9523)

## Description
<!-- Please remember to add your design buddy onto the PR for review, if
it contains any UI changes! -->

Completes REMOTE-1535.

## Testing
<!--
How did you test this change? What automated tests did you add? If you
didn't add any new tests, what's your justification for not adding any?

If you're not sure whether you should add a test, check our testing
policy:
https://www.notion.so/warpdev/How-We-Code-at-Warp-257fe43d556e4b3c8dfd42f70004cc72#1f97825450504baa9c5fd87a737daa09
-->

https://www.loom.com/share/2df54624aa9846c3b2c9896df6d8caa6

## Agent Mode
- [x] Warp Agent Mode - This PR was created via Warp's AI Agent Mode

Author: abhishekp106

app/src/terminal/input.rs

@@ -221,7 +221,7 @@ use crate::{
         ForkedConversationDestination, InitContent, RestoreConversationLayout, ToastStack,
         WorkspaceAction,
     },
-    workspaces::user_workspaces::UserWorkspaces,
+    workspaces::user_workspaces::{UserWorkspaces, UserWorkspacesEvent},
     AgentModeEntrypoint, ServerApiProvider,
 };
 
@@ -2220,17 +2220,78 @@ impl Input {
                         let view = ctx.add_typed_action_view(|ctx| {
                             HostSelector::new(menu_positioning_provider.clone(), ctx)
                         });
-                        // Mirror the V2 model selector's `ModelSelectorClosed` -> refocus path:
-                        // when the host selector menu closes (item picked or dismissed via Esc /
-                        // click-outside), restore focus to the input editor so typing resumes
-                        // immediately. This is what powers the "input is focused after the host
-                        // selector closes" UX for the `/harness` slash command.
+                        // Env var takes priority over workspace setting for developer testing.
+                        let effective_host = std::env::var("WARP_CLOUD_MODE_DEFAULT_HOST")
+                            .ok()
+                            .filter(|s| !s.is_empty())
+                            .or_else(|| {
+                                UserWorkspaces::as_ref(ctx)
+                                    .default_host_slug()
+                                    .map(String::from)
+                            });
+                        if let Some(slug) = &effective_host {
+                            view.update(ctx, |selector, ctx| {
+                                selector.set_default_host(slug.clone(), ctx);
+                            });
+                        }
+                        if let Some(slug) = effective_host {
+                            view_model.update(ctx, |model, _ctx| {
+                                model.set_worker_host(Some(slug));
+                            });
+                        }
+                        // When the host selector menu closes (item picked or dismissed via
+                        // Esc / click-outside), restore focus to the input editor so typing
+                        // resumes immediately.
                         ctx.subscribe_to_view(&view, |me, _, event, ctx| {
-                            let HostSelectorEvent::MenuVisibilityChanged { open } = event;
-                            if !*open {
+                            if matches!(
+                                event,
+                                HostSelectorEvent::MenuVisibilityChanged { open: false }
+                            ) {
                                 me.focus_input_box(ctx);
                             }
                         });
+                        // Propagate host selection changes to the view model when a host is
+                        // explicitly selected, rather than on menu close, to avoid a race
+                        // where the menu closes before the selection updates.
+                        let vm_for_host = view_model.clone();
+                        ctx.subscribe_to_view(&view, move |_me, handle, event, ctx| {
+                            if matches!(event, HostSelectorEvent::HostSelected) {
+                                let selected = handle.as_ref(ctx).selected().clone();
+                                vm_for_host.update(ctx, |model, _ctx| {
+                                    model.set_worker_host(selected.worker_host_value());
+                                });
+                            }
+                        });
+                        // Keep the host selector and view model in sync when workspace
+                        // metadata refreshes (e.g. admin changes default_host_slug).
+                        let view_for_ws = view.clone();
+                        let vm_for_ws = view_model.clone();
+                        ctx.subscribe_to_model(
+                            &UserWorkspaces::handle(ctx),
+                            move |_me, _, event, ctx| {
+                                if !matches!(event, UserWorkspacesEvent::TeamsChanged) {
+                                    return;
+                                }
+                                let effective_host = std::env::var("WARP_CLOUD_MODE_DEFAULT_HOST")
+                                    .ok()
+                                    .filter(|s| !s.is_empty())
+                                    .or_else(|| {
+                                        UserWorkspaces::as_ref(ctx)
+                                            .default_host_slug()
+                                            .map(String::from)
+                                    });
+                                if let Some(slug) = &effective_host {
+                                    view_for_ws.update(ctx, |selector, ctx| {
+                                        selector.set_default_host(slug.clone(), ctx);
+                                    });
+                                }
+                                if let Some(slug) = effective_host {
+                                    vm_for_ws.update(ctx, |model, _ctx| {
+                                        model.set_worker_host(Some(slug));
+                                    });
+                                }
+                            },
+                        );
                         Some(view)
                     } else {
                         None

app/src/terminal/input/agent.rs

@@ -506,7 +506,7 @@ impl Input {
             .with_main_axis_size(MainAxisSize::Min)
             .with_spacing(CLOUD_MODE_V2_TOP_ROW_GAP);
 
-        column.add_child(self.render_cloud_mode_v2_top_row());
+        column.add_child(self.render_cloud_mode_v2_top_row(app));
         column.add_child(self.render_cloud_mode_v2_input_container(appearance, app));
         Align::new(
             ConstrainedBox::new(column.finish())
@@ -528,14 +528,17 @@ impl Input {
         Some(ChildView::new(view).finish())
     }
 
-    fn render_cloud_mode_v2_top_row(&self) -> Box<dyn Element> {
+    fn render_cloud_mode_v2_top_row(&self, app: &AppContext) -> Box<dyn Element> {
         let mut row = Flex::row()
             .with_main_axis_size(MainAxisSize::Min)
             .with_cross_axis_alignment(CrossAxisAlignment::Center)
             .with_spacing(CLOUD_MODE_V2_TOP_ROW_INNER_GAP);
 
+        // Only show the host selector when a default host is configured.
         if let Some(host) = self.host_selector() {
-            row.add_child(ChildView::new(host).finish());
+            if host.as_ref(app).has_default_host() {
+                row.add_child(ChildView::new(host).finish());
+            }
         }
         if let Some(harness_selector) = self.harness_selector() {
             row.add_child(ChildView::new(harness_selector).finish());

app/src/terminal/input/slash_commands/data_source/mod.rs

@@ -120,7 +120,11 @@ impl SlashCommandDataSource {
             }
         });
         ctx.subscribe_to_model(&UserWorkspaces::handle(ctx), |me, event, ctx| {
-            if matches!(event, UserWorkspacesEvent::CodebaseContextEnablementChanged) {
+            if matches!(
+                event,
+                UserWorkspacesEvent::CodebaseContextEnablementChanged
+                    | UserWorkspacesEvent::TeamsChanged
+            ) {
                 me.recompute_active_commands(ctx);
             }
         });
@@ -246,6 +250,13 @@ impl SlashCommandDataSource {
 
         let is_orchestration_enabled = AISettings::as_ref(ctx).is_orchestration_enabled(ctx);
 
+        // Hide /host when no default host is configured (env var or workspace setting).
+        let has_default_host = std::env::var("WARP_CLOUD_MODE_DEFAULT_HOST")
+            .ok()
+            .filter(|s| !s.is_empty())
+            .is_some()
+            || UserWorkspaces::as_ref(ctx).default_host_slug().is_some();
+
         #[cfg(not(target_family = "wasm"))]
         let active_conversation_is_cloud_oz = self.active_conversation_is_cloud_oz(ctx);
 
@@ -279,6 +290,8 @@ impl SlashCommandDataSource {
                         true
                     }
                 })
+                // /host is only useful when a default self-hosted host is configured.
+                .filter(|(_, command)| command.name != commands::HOST.name || has_default_host)
                 // When CLI agent input is open, restrict to the explicit allowlist.
                 .filter(|(_, command)| {
                     !is_cli_agent_input

app/src/terminal/input/slash_commands/mod.rs

@@ -711,8 +711,13 @@ impl Input {
             }
             host if command.name == commands::HOST.name => {
                 if !self.is_cloud_mode_input_v2_composing(ctx) {
-                    // Defensive: the command is registered only when the V2 flag is on and its
-                    // availability requires CLOUD_AGENT_V2, so this branch should be unreachable.
+                    return false;
+                }
+                // Only open the host selector when a default host is configured.
+                if self
+                    .host_selector()
+                    .is_none_or(|h| !h.as_ref(ctx).has_default_host())
+                {
                     return false;
                 }
                 self.suggestions_mode_model.update(ctx, |model, ctx| {

app/src/terminal/view/ambient_agent/host_selector.rs

@@ -37,15 +37,25 @@ const BUTTON_TOOLTIP: &str = "Execution host";
 
 const MENU_HEADER_LABEL: &str = "Execution host";
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Host {
     Warp,
+    SelfHosted { slug: String },
 }
 
 impl Host {
-    fn display_name(self) -> &'static str {
+    fn display_name(&self) -> &str {
         match self {
             Host::Warp => "Warp",
+            Host::SelfHosted { slug } => slug.as_str(),
+        }
+    }
+
+    /// Returns the value to send as `worker_host` in the config snapshot.
+    pub fn worker_host_value(&self) -> Option<String> {
+        match self {
+            Host::Warp => Some("warp".to_string()),
+            Host::SelfHosted { slug } => Some(slug.clone()),
         }
     }
 }
@@ -58,6 +68,7 @@ pub enum HostSelectorAction {
 
 pub enum HostSelectorEvent {
     MenuVisibilityChanged { open: bool },
+    HostSelected,
 }
 
 pub struct HostSelector {
@@ -66,6 +77,8 @@ pub struct HostSelector {
     is_menu_open: bool,
     menu_positioning_provider: Arc<dyn MenuPositioningProvider>,
     selected: Host,
+    /// The configured default self-hosted host, if any.
+    default_host: Option<Host>,
 }
 
 impl HostSelector {
@@ -78,9 +91,10 @@ impl HostSelector {
         // `SelectHost`), so it stays out of clippy's `field is never read`
         // warning while still serving as the source of truth for the label.
         let selected = Host::Warp;
+        let initial_label = selected.display_name().to_string();
 
         let button = ctx.add_typed_action_view(|_ctx| {
-            ActionButton::new(selected.display_name(), NakedHeaderButtonTheme)
+            ActionButton::new(initial_label, NakedHeaderButtonTheme)
                 .with_size(ButtonSize::AgentInputButton)
                 .with_menu(true)
                 .with_tooltip(BUTTON_TOOLTIP)
@@ -114,6 +128,7 @@ impl HostSelector {
             is_menu_open: false,
             menu_positioning_provider,
             selected,
+            default_host: None,
         };
         me.refresh_menu(ctx);
         me
@@ -123,6 +138,25 @@ impl HostSelector {
         self.is_menu_open
     }
 
+    pub fn has_default_host(&self) -> bool {
+        self.default_host.is_some()
+    }
+
+    pub fn selected(&self) -> &Host {
+        &self.selected
+    }
+
+    pub fn set_default_host(&mut self, slug: String, ctx: &mut ViewContext<Self>) {
+        let host = Host::SelfHosted { slug };
+        let label = host.display_name().to_string();
+        self.selected = host.clone();
+        self.button.update(ctx, |button, ctx| {
+            button.set_label(label.clone(), ctx);
+        });
+        self.default_host = Some(host);
+        self.refresh_menu(ctx);
+    }
+
     /// Programmatically opens the host selector popover. No-op if already open.
     pub fn open_menu(&mut self, ctx: &mut ViewContext<Self>) {
         self.set_menu_visibility(true, ctx);
@@ -132,7 +166,7 @@ impl HostSelector {
     /// from closed to open so the user has a clear starting point for arrow-key navigation
     /// instead of an unselected list.
     fn highlight_selected_host(&mut self, ctx: &mut ViewContext<Self>) {
-        let selected_action = HostSelectorAction::SelectHost(self.selected);
+        let selected_action = HostSelectorAction::SelectHost(self.selected.clone());
         self.menu.update(ctx, |menu, ctx| {
             menu.set_selected_by_action(&selected_action, ctx);
         });
@@ -157,7 +191,11 @@ impl HostSelector {
         let hover_background: Fill = internal_colors::neutral_4(theme).into();
         let header_text_color = theme.disabled_text_color(theme.surface_2()).into_solid();
         let border = Border::all(1.).with_border_fill(theme.outline());
-        let items = build_menu_items(hover_background, header_text_color);
+        let items = build_menu_items(
+            hover_background,
+            header_text_color,
+            self.default_host.as_ref(),
+        );
         self.menu.update(ctx, |menu, ctx| {
             menu.set_border(Some(border));
             menu.set_items(items, ctx);
@@ -185,6 +223,7 @@ impl HostSelector {
 fn build_menu_items(
     hover_background: Fill,
     header_text_color: ColorU,
+    default_host: Option<&Host>,
 ) -> Vec<MenuItem<HostSelectorAction>> {
     let header = MenuItem::Header {
         fields: MenuItemFields::new(MENU_HEADER_LABEL)
@@ -197,16 +236,22 @@ fn build_menu_items(
     };
 
     let item_for = |host: Host| {
+        let label = host.display_name().to_string();
         MenuItem::Item(
-            MenuItemFields::new(host.display_name())
+            MenuItemFields::new(label)
                 .with_font_size_override(ITEM_FONT_SIZE)
                 .with_padding_override(ITEM_VERTICAL_PADDING, MENU_HORIZONTAL_PADDING)
                 .with_override_hover_background_color(hover_background)
                 .with_on_select_action(HostSelectorAction::SelectHost(host)),
         )
     };
 
-    vec![header, item_for(Host::Warp)]
+    let mut items = vec![header];
+    if let Some(host) = default_host {
+        items.push(item_for(host.clone()));
+    }
+    items.push(item_for(Host::Warp));
+    items
 }
 
 impl Entity for HostSelector {
@@ -223,11 +268,12 @@ impl TypedActionView for HostSelector {
                 self.set_menu_visibility(new_state, ctx);
             }
             HostSelectorAction::SelectHost(host) => {
-                self.selected = *host;
-                let label = self.selected.display_name();
+                self.selected = host.clone();
+                let label = self.selected.display_name().to_string();
                 self.button.update(ctx, |button, ctx| {
-                    button.set_label(label, ctx);
+                    button.set_label(label.clone(), ctx);
                 });
+                ctx.emit(HostSelectorEvent::HostSelected);
                 self.set_menu_visibility(false, ctx);
             }
         }

app/src/terminal/view/ambient_agent/mod.rs

@@ -98,6 +98,7 @@ pub fn create_cloud_mode_view(
                 | AmbientAgentViewModelEvent::NeedsGithubAuth
                 | AmbientAgentViewModelEvent::Cancelled
                 | AmbientAgentViewModelEvent::HarnessSelected
+                | AmbientAgentViewModelEvent::HostSelected
                 | AmbientAgentViewModelEvent::HarnessCommandStarted
                 | AmbientAgentViewModelEvent::UpdatedSetupCommandVisibility => {}
             }