Make TUI voice input optional on Linux (#14611)

Author: kevinyang372

app/Cargo.toml

@@ -467,7 +467,7 @@ embed-resource = "3.0"
 
 # Note that we support channel-specific enables for these features
 [features]
-tui = ["warpui_core/tui", "voice_input"]
+tui = ["warpui_core/tui"]
 ai_resume_button = []
 autoupdate = []
 figma_detection = []

crates/warp_tui/Cargo.toml

@@ -75,7 +75,6 @@ warp = { workspace = true, features = [
   "nld_classifier_v3",
   "nld_heuristic_v2",
   "tui",
-  "voice_input",
 ] }
 warp_channel_config.workspace = true
 warp_completer.workspace = true
@@ -129,6 +128,9 @@ harness = false
 required-features = ["test-util"]
 
 [features]
+# Enables native microphone capture and transcription support. Keep this
+# opt-in so portable Linux builds do not require the host ALSA runtime.
+voice_input = ["warp/voice_input"]
 # Exposes deterministic, production-shaped transcript fixtures to benchmarks.
 test-util = ["warp/test-util", "warp_core/test-util"]
 # Declared so the `warp_channel_config::load_config!` macro's

crates/warp_tui/src/input/view.rs

@@ -34,11 +34,14 @@ use warp::tui_export::{
 use warp_editor::model::CoreEditorModel;
 use warpui::SingletonEntity as _;
 use warpui_core::elements::MouseStateHandle;
+#[cfg(feature = "voice_input")]
 use warpui_core::elements::animation::AnimationClock;
 use warpui_core::elements::tui::{TuiContainer, TuiElement, TuiFlex, TuiHoverable, TuiText};
+#[cfg(feature = "voice_input")]
 use warpui_core::event::KeyState;
 use warpui_core::keymap::macros::*;
 use warpui_core::keymap::{self, EditableBinding, FixedBinding, Keystroke};
+#[cfg(feature = "voice_input")]
 use warpui_core::platform::keyboard::KeyCode;
 use warpui_core::text::{byte_offset_for_char_offset, count_chars_up_to_byte};
 use warpui_core::{
@@ -64,6 +67,7 @@ use crate::mcp_install_flow::TuiMcpInstallFlowAction;
 use crate::read_only_menu::TuiReadOnlyMenuKind;
 use crate::terminal_session_view::state::TuiTerminalSessionStateModel;
 use crate::tui_builder::TuiUiBuilder;
+#[cfg(feature = "voice_input")]
 use crate::voice_input::{
     TuiVoiceInputEvent, TuiVoiceInputModel, TuiVoiceInputState, VoiceInputStartSource,
 };
@@ -248,6 +252,7 @@ pub struct TuiInputView {
     /// Consults the owner live before an inline-menu Enter can accept an item.
     can_accept_inline_menu: Rc<dyn Fn(&AppContext) -> bool>,
     /// TUI voice state used for Escape routing and shell-gutter suppression.
+    #[cfg(feature = "voice_input")]
     voice_input: ModelHandle<TuiVoiceInputModel>,
     /// Vim model (shared FSA + event dispatch layer). Always present but only
     /// active when `AppEditorSettings::vim_mode_enabled()` returns `true`.
@@ -332,6 +337,7 @@ impl TuiInputView {
         session_state: ModelHandle<TuiTerminalSessionStateModel>,
         ctx: &mut ViewContext<Self>,
     ) -> Self {
+        #[cfg(feature = "voice_input")]
         let voice_input = ctx.add_model(|ctx| TuiVoiceInputModel::new(input_mode.clone(), ctx));
         let vim_model = ctx.add_model(|_| VimModel::new());
         // Subscribe to vim events: VimSubscriber blanket impl (TuiInputView: VimHandler)
@@ -346,15 +352,18 @@ impl TuiInputView {
         // on the config (shell-mode gutter/border), so every event re-renders.
         ctx.subscribe_to_model(&input_mode, |_, _, _, ctx| ctx.notify());
         ctx.subscribe_to_model(&suggestions_mode, |_, _, _, ctx| ctx.notify());
-        // Only the voice lifecycle state reaches this view's render (the
-        // suppressed shell gutter and the Escape keymap flag). Transcribed text
-        // arrives through `insert_text`, and failure or cancellation notices
-        // render in the session footer, so neither repaints the input.
-        ctx.subscribe_to_model(&voice_input, |_, _, event, ctx| {
-            if matches!(event, TuiVoiceInputEvent::StateChanged(_)) {
-                ctx.notify();
-            }
-        });
+        #[cfg(feature = "voice_input")]
+        {
+            // Only the voice lifecycle state reaches this view's render (the
+            // suppressed shell gutter and the Escape keymap flag). Transcribed text
+            // arrives through `insert_text`, and failure or cancellation notices
+            // render in the session footer, so neither repaints the input.
+            ctx.subscribe_to_model(&voice_input, |_, _, event, ctx| {
+                if matches!(event, TuiVoiceInputEvent::StateChanged(_)) {
+                    ctx.notify();
+                }
+            });
+        }
 
         Self {
             model,
@@ -368,6 +377,7 @@ impl TuiInputView {
             session_state,
             keyboard_enhancement_supported: false,
             can_accept_inline_menu: Rc::new(|_| true),
+            #[cfg(feature = "voice_input")]
             voice_input,
             vim_model,
             yank_buffer: String::new(),
@@ -397,6 +407,7 @@ impl TuiInputView {
             .resolve(ctx)
             .is_ok_and(|state| state.plan_available())
     }
+
     /// Whether vim mode is enabled in settings.
     ///
     /// Returns `false` when [`AppEditorSettings`] has not been registered in
@@ -432,28 +443,32 @@ impl TuiInputView {
         input_mode_policy::is_shell_mode(self.input_mode.as_ref(ctx))
     }
 
+    #[cfg(feature = "voice_input")]
     pub(crate) fn voice_is_active(&self, ctx: &AppContext) -> bool {
         self.voice_input.as_ref(ctx).is_active()
     }
-
+    #[cfg(feature = "voice_input")]
     pub(crate) fn voice_input_model(&self) -> &ModelHandle<TuiVoiceInputModel> {
         &self.voice_input
     }
-
+    #[cfg(feature = "voice_input")]
     pub(crate) fn voice_state(&self, ctx: &AppContext) -> TuiVoiceInputState {
         self.voice_input.as_ref(ctx).state()
     }
 
+    #[cfg(feature = "voice_input")]
     pub(crate) fn voice_animation_clock(&self, ctx: &AppContext) -> AnimationClock {
         self.voice_input.as_ref(ctx).animation_clock()
     }
 
     /// The physical modifier holding the current recording open, set only while
     /// a hold-to-talk press started it.
+    #[cfg(feature = "voice_input")]
     pub(crate) fn voice_hold_key(&self, ctx: &AppContext) -> Option<KeyCode> {
         self.voice_input.as_ref(ctx).hold_key()
     }
 
+    #[cfg(feature = "voice_input")]
     pub(crate) fn start_voice_input(
         &mut self,
         available: bool,
@@ -465,16 +480,19 @@ impl TuiInputView {
         })
     }
 
+    #[cfg(feature = "voice_input")]
     pub(crate) fn stop_voice_input(&mut self, ctx: &mut ViewContext<Self>) {
         self.voice_input
             .update(ctx, |voice_input, ctx| voice_input.stop(ctx));
     }
 
+    #[cfg(feature = "voice_input")]
     pub(crate) fn stop_active_voice_hold(&mut self, ctx: &mut ViewContext<Self>) {
         self.voice_input
             .update(ctx, |voice_input, ctx| voice_input.stop_hold(ctx));
     }
 
+    #[cfg(feature = "voice_input")]
     pub(crate) fn handle_voice_hold_key(
         &mut self,
         key: KeyCode,
@@ -512,6 +530,7 @@ impl TuiInputView {
     }
 
     /// Inserts normalized text at the current cursor without submitting it.
+    #[cfg(feature = "voice_input")]
     pub(crate) fn insert_text(&mut self, text: &str, ctx: &mut ViewContext<Self>) {
         let text = self.editor_behavior.normalize_text(text);
         if !text.is_empty() {
@@ -651,6 +670,7 @@ impl TuiView for TuiInputView {
         let inline_menu_owns_input = self
             .active_inline_menu_input_ownership(ctx)
             .inline_menu_owns_input();
+        #[cfg(feature = "voice_input")]
         if self.voice_is_active(ctx) && !inline_menu_owns_input {
             return self.render_input(ctx);
         }
@@ -693,7 +713,16 @@ impl TuiView for TuiInputView {
             input_handles_escape: self.active_inline_menu(ctx).is_some()
                 || suggestions_mode.read_only_menu().is_some()
                 || self.is_shell_mode(ctx)
-                || self.voice_is_active(ctx)
+                || {
+                    #[cfg(feature = "voice_input")]
+                    {
+                        self.voice_is_active(ctx)
+                    }
+                    #[cfg(not(feature = "voice_input"))]
+                    {
+                        false
+                    }
+                }
                 || (vim_mode_enabled
                     && (!matches!(vim_state.mode, VimMode::Normal)
                         || !vim_state.showcmd.is_empty())),
@@ -833,7 +862,11 @@ impl TypedActionView for TuiInputView {
                 self.close_read_only_menu(ctx);
                 // In vim normal/visual/replace mode, Enter still submits so the
                 // prompt behaves like a command line (same as bash/zsh vi-mode).
-                if !self.handle_voice_submit(ctx) {
+                #[cfg(feature = "voice_input")]
+                if self.handle_voice_submit(ctx) {
+                    return;
+                }
+                {
                     self.submit(ctx);
                 }
                 TuiEditorInteractionOutcome::FollowCursor
@@ -1292,6 +1325,7 @@ impl TuiInputView {
         ctx.emit(TuiInputViewEvent::Submitted(text));
     }
 
+    #[cfg(feature = "voice_input")]
     fn handle_voice_submit(&mut self, ctx: &mut ViewContext<Self>) -> bool {
         match self.voice_input.as_ref(ctx).state() {
             TuiVoiceInputState::Listening => {
@@ -1406,18 +1440,21 @@ impl TuiInputView {
             return true;
         }
 
-        match self.voice_input.as_ref(ctx).state() {
-            TuiVoiceInputState::Listening => {
-                self.voice_input
-                    .update(ctx, |voice_input, ctx| voice_input.stop(ctx));
-                return true;
-            }
-            TuiVoiceInputState::Transcribing => {
-                self.voice_input
-                    .update(ctx, |voice_input, ctx| voice_input.cancel(ctx));
-                return true;
+        #[cfg(feature = "voice_input")]
+        {
+            match self.voice_input.as_ref(ctx).state() {
+                TuiVoiceInputState::Listening => {
+                    self.voice_input
+                        .update(ctx, |voice_input, ctx| voice_input.stop(ctx));
+                    return true;
+                }
+                TuiVoiceInputState::Transcribing => {
+                    self.voice_input
+                        .update(ctx, |voice_input, ctx| voice_input.cancel(ctx));
+                    return true;
+                }
+                TuiVoiceInputState::Idle => {}
             }
-            TuiVoiceInputState::Idle => {}
         }
 
         // In vim mode, Escape transitions between modes (Insert→Normal,

crates/warp_tui/src/input/view_tests.rs

@@ -13,11 +13,13 @@ use vim::vim::VimMode;
 use warp::appearance::Appearance;
 use warp::editor::CodeEditorModel;
 use warp::settings::AISettingsChangedEvent;
+#[cfg(feature = "voice_input")]
+use warp::tui_export::VoiceInput;
 use warp::tui_export::{
     AcceptSlashCommandOrSavedPrompt, BlocklistAIHistoryModel, BlocklistAIInputModel,
     ConversationSelectionEvent, InputConfig, InputModePolicy, InputType, LLMId, PolicyConfigUpdate,
     SlashCommandId, SlashCommandMixer, TuiMcpAction, TuiMcpServerId, TuiUpArrowHistoryItemKind,
-    VoiceInput, add_tui_history_test_models, blocklist_ai_history_model_with_queries,
+    add_tui_history_test_models, blocklist_ai_history_model_with_queries,
     register_tui_input_mode_test_settings, register_tui_session_view_test_singletons,
 };
 use warp_core::features::FeatureFlag;
@@ -57,6 +59,7 @@ use crate::read_only_menu::TuiReadOnlyMenuKind;
 use crate::slash_commands::{TuiSlashCommandModel, TuiSlashCommandRow};
 use crate::test_fixtures::{add_test_conversation_selection, add_test_semantic_selection};
 use crate::tui_builder::TuiUiBuilder;
+#[cfg(feature = "voice_input")]
 use crate::voice_input::{TuiVoiceInputModel, TuiVoiceInputState};
 
 const W: u16 = 80;
@@ -1331,6 +1334,7 @@ fn slash_command_argument_hint_renders_after_menu_closes() {
 }
 
 #[test]
+#[cfg(feature = "voice_input")]
 fn enter_and_escape_stop_listening_while_escape_cancels_transcribing() {
     App::test((), |mut app| async move {
         let (view, voice_input, submissions) = app.update(|ctx| {
@@ -1822,6 +1826,7 @@ fn typeahead_overwrites_incremental_prefix_and_moves_cursor_to_end() {
         });
     });
 }
+#[cfg(feature = "voice_input")]
 fn build_view_with_voice(
     ctx: &mut AppContext,
 ) -> (ViewHandle<TuiInputView>, ModelHandle<TuiVoiceInputModel>) {
@@ -1852,6 +1857,7 @@ fn build_view_with_voice(
 }
 
 #[test]
+#[cfg(feature = "voice_input")]
 fn listening_voice_input_suppresses_shell_gutter() {
     App::test((), |mut app| async move {
         app.update(|ctx| {

crates/warp_tui/src/lib.rs

@@ -84,6 +84,7 @@ mod tui_plan_view;
 mod tui_review_comments;
 mod tui_shell_command_view;
 mod usage;
+#[cfg(feature = "voice_input")]
 mod voice_input;
 mod warping_indicator;
 mod zero_state;

crates/warp_tui/src/session.rs

@@ -13,7 +13,9 @@ use anyhow::{Context, Result, anyhow};
 use clap::Parser;
 use clap::error::ErrorKind;
 use inquire::{InquireError, Password, PasswordDisplayMode};
-use warp::settings::{TuiThemeSettings, TuiVoiceSettings, TuiVoiceSettingsChangedEvent};
+use warp::settings::TuiThemeSettings;
+#[cfg(feature = "voice_input")]
+use warp::settings::{TuiVoiceSettings, TuiVoiceSettingsChangedEvent};
 use warp::tui_export::{AIConversationAutoexecuteMode, Appearance, ServerConversationToken};
 use warp::{TuiLoginEvent, TuiLoginModel, TuiLoginPhase};
 use warp_core::channel::ChannelState;
@@ -34,6 +36,7 @@ use crate::terminal_background::TuiHostTerminalBackground;
 use crate::terminal_session_view::{
     TuiConversationRestoreOrigin, TuiConversationRestoreTarget, tui_resume_shell_command,
 };
+#[cfg(feature = "voice_input")]
 use crate::voice_input::requires_modifier_key_reporting;
 
 /// Version string printed by `--version`. Release builds get `GIT_RELEASE_TAG`;
@@ -250,18 +253,24 @@ fn init(
         },
         |_| RootTuiView::new(),
     );
+    #[cfg(feature = "voice_input")]
+    let modifier_key_lifecycle_enabled = requires_modifier_key_reporting(ctx);
+    #[cfg(not(feature = "voice_input"))]
+    let modifier_key_lifecycle_enabled = false;
     match spawn_tui_driver(
         ctx,
         window_id,
         root.clone(),
-        requires_modifier_key_reporting(ctx),
+        modifier_key_lifecycle_enabled,
         Some(probe),
     ) {
         Ok(driver) => {
             let sessions = ctx.add_singleton_model(|_| {
                 TuiSessions::new(driver, exit_summary, resume_token, default_autoexecute_mode)
             });
+            #[cfg(feature = "voice_input")]
             let sessions_for_voice_settings = sessions.clone();
+            #[cfg(feature = "voice_input")]
             ctx.subscribe_to_model(&TuiVoiceSettings::handle(ctx), move |_, event, ctx| {
                 let TuiVoiceSettingsChangedEvent::TuiVoiceInputHoldKeySetting { .. } = event;
                 let enabled = requires_modifier_key_reporting(ctx);

crates/warp_tui/src/session_registry.rs

@@ -130,6 +130,7 @@ pub(crate) enum TuiSessionsEvent {
 pub(crate) struct TuiSessions {
     /// TUI-specific process driver. Its handle restores terminal mode on
     /// drop, so the app-lifetime session singleton must retain it.
+    #[cfg_attr(not(feature = "voice_input"), allow(dead_code))]
     driver: Option<TuiDriverHandle>,
     keyboard_enhancement_supported: bool,
     exit_summary: TuiExitSummaryHandle,
@@ -602,6 +603,7 @@ impl TuiSessions {
         }
     }
 
+    #[cfg(feature = "voice_input")]
     pub(crate) fn set_modifier_key_lifecycle_enabled(
         &mut self,
         enabled: bool,