fix(bluetooth): avoid Pico self-selection as input (2026.6.23.0-CDDC)

Author: RealWhyKnot

bridge/src/cmd_home.rs

@@ -134,6 +134,15 @@ enum InputModeChoice {
     Family(&'static [protocol::Persona]),
 }
 
+impl InputModeChoice {
+    fn bluetooth_persona(self) -> Option<protocol::Persona> {
+        match self {
+            Self::Persona(persona) if persona.is_bluetooth() => Some(persona),
+            _ => None,
+        }
+    }
+}
+
 async fn scan_pico_inventory() -> Result<PicoInventory> {
     let mut inventory = PicoInventory::default();
     match cmd_run::discover_picos(Duration::from_secs(HOME_SCAN_SECONDS)).await {
@@ -473,7 +482,7 @@ fn missing_saved_card(pico: config::PicoIdentity) -> PicoCard {
 impl PicoAction {
     fn label(&self) -> String {
         match self {
-            Self::StartStreaming { .. } => "Start streaming with Controller 1".to_string(),
+            Self::StartStreaming { .. } => "Start streaming".to_string(),
             Self::ChooseRouting { .. } => "Choose controller and stream".to_string(),
             Self::CheckUsbAdapter { .. } => "Check console USB adapter".to_string(),
             Self::SwitchToUsbDebug { .. } => "Switch to USB debug mode".to_string(),
@@ -804,13 +813,22 @@ fn print_xinput_sources() {
 async fn route_one(picos: Vec<cmd_run::PicoTarget>) -> Result<()> {
     let pico_items: Vec<String> = picos.iter().map(|p| p.detail_label()).collect();
     let pico_index = select("Which Pico should receive the controller?", &pico_items, 0).await?;
+    let pico = picos[pico_index].clone();
+    let mode = choose_input_mode().await?;
+    if mode.bluetooth_persona().is_some() {
+        let routes = vec![cmd_run::StreamRoute {
+            source_slot: 0,
+            pico,
+        }];
+        let routes = prepare_routes_for_input_mode(routes, mode).await?;
+        let routes = choose_bluetooth_source_slots(routes).await?;
+        return start_stream(routes, true).await;
+    }
+
     let source_slot =
         choose_source_slot("Which Windows controller should feed that Pico?", None).await?;
-    let routes = vec![cmd_run::StreamRoute {
-        source_slot,
-        pico: picos[pico_index].clone(),
-    }];
-    stream(routes, true).await
+    let routes = vec![cmd_run::StreamRoute { source_slot, pico }];
+    stream_with_mode(routes, mode, true).await
 }
 
 async fn choose_source_slot(prompt: &str, default_slot: Option<u32>) -> Result<u32> {
@@ -829,7 +847,24 @@ fn slot_item(slot: u32) -> String {
 
 async fn stream(routes: Vec<cmd_run::StreamRoute>, save: bool) -> Result<()> {
     let mode = choose_input_mode().await?;
+    stream_with_mode(routes, mode, save).await
+}
+
+async fn stream_with_mode(
+    routes: Vec<cmd_run::StreamRoute>,
+    mode: InputModeChoice,
+    save: bool,
+) -> Result<()> {
     let routes = prepare_routes_for_input_mode(routes, mode).await?;
+    let routes = if mode.bluetooth_persona().is_some() {
+        choose_bluetooth_source_slots(routes).await?
+    } else {
+        routes
+    };
+    start_stream(routes, save).await
+}
+
+async fn start_stream(routes: Vec<cmd_run::StreamRoute>, save: bool) -> Result<()> {
     println!();
     println!("Ready to stream:");
     for route in &routes {
@@ -849,6 +884,35 @@ async fn stream(routes: Vec<cmd_run::StreamRoute>, save: bool) -> Result<()> {
     .await
 }
 
+async fn choose_bluetooth_source_slots(
+    mut routes: Vec<cmd_run::StreamRoute>,
+) -> Result<Vec<cmd_run::StreamRoute>> {
+    let targets: Vec<_> = routes.iter().map(|route| route.pico.clone()).collect();
+    cmd_persona::wait_for_bluetooth_xinput_release(&targets, false).await?;
+
+    print_xinput_sources();
+    if routes.len() == 1 {
+        routes[0].source_slot = choose_source_slot(
+            "Which Windows controller should feed that Bluetooth Pico?",
+            Some(routes[0].source_slot),
+        )
+        .await?;
+        return Ok(routes);
+    }
+
+    for route in &mut routes {
+        route.source_slot = choose_source_slot(
+            &format!(
+                "Which Windows controller should feed {}?",
+                route.pico.short_label()
+            ),
+            Some(route.source_slot),
+        )
+        .await?;
+    }
+    Ok(routes)
+}
+
 async fn choose_input_mode() -> Result<InputModeChoice> {
     let choices = vec![
         menu_item(

bridge/src/cmd_home/tests.rs

@@ -192,3 +192,20 @@ fn seed_saved_picos_migrates_legacy_last_pico_once() {
     assert!(!seed_saved_picos_from_legacy_last(&mut cfg));
     assert_eq!(cfg.picos.len(), 1);
 }
+
+#[test]
+fn input_mode_choice_identifies_bluetooth_personas() {
+    assert_eq!(
+        InputModeChoice::Persona(protocol::Persona::BluetoothHid).bluetooth_persona(),
+        Some(protocol::Persona::BluetoothHid)
+    );
+    assert_eq!(
+        InputModeChoice::Persona(protocol::Persona::BluetoothXbox).bluetooth_persona(),
+        Some(protocol::Persona::BluetoothXbox)
+    );
+    assert_eq!(
+        InputModeChoice::Persona(protocol::Persona::Xinput).bluetooth_persona(),
+        None
+    );
+    assert_eq!(InputModeChoice::Auto.bluetooth_persona(), None);
+}

bridge/src/cmd_lab.rs

@@ -129,6 +129,11 @@ pub async fn run(options: LabOptions) -> Result<()> {
     Ok(())
 }
 
+pub(crate) fn connected_xinput_instance_ids_for_uids(uids: &BTreeSet<u32>) -> Result<Vec<String>> {
+    let instances = pnp_instances_for_uids(uids, &[PnpPersona::Xinput])?;
+    Ok(pnp_instance_ids(&instances))
+}
+
 struct LabHarness {
     options: LabOptions,
     cfg: config::Config,

bridge/src/cmd_persona.rs

@@ -8,16 +8,18 @@
 //! the same Wi-Fi persona switch before the streaming loop opens the local
 //! USB diagnostic port.
 
-use std::collections::HashSet;
+use std::collections::{BTreeSet, HashSet};
 use std::time::{Duration, Instant};
 
 use anyhow::{bail, Result};
 
 use crate::protocol::Persona;
-use crate::{cmd_run, pico_cache, pico_mode, support};
+use crate::{cmd_lab, cmd_run, pico_cache, pico_mode, support};
 
 pub(crate) const DISCOVER: Duration = Duration::from_secs(5);
 pub(crate) const REBOOT_WAIT: Duration = Duration::from_secs(60);
+const XINPUT_RELEASE_WAIT: Duration = Duration::from_secs(8);
+const XINPUT_RELEASE_POLL: Duration = Duration::from_millis(500);
 
 pub async fn run(desired: Persona, selectors: Vec<String>, all: bool, stream: bool) -> Result<()> {
     tracing::info!(
@@ -128,10 +130,80 @@ pub async fn run(desired: Persona, selectors: Vec<String>, all: bool, stream: bo
             desired.label()
         );
     }
-    let routes = cmd_run::auto_routes(ready, Some((0..4).collect()))?;
+    if desired.is_bluetooth() {
+        wait_for_bluetooth_xinput_release(&ready, false).await?;
+    }
+    let routes = cmd_run::auto_routes(ready, preferred_source_slots_for_persona(desired))?;
     cmd_run::stream_routes(routes, cmd_run::StreamOptions::default()).await
 }
 
+fn preferred_source_slots_for_persona(desired: Persona) -> Option<Vec<u32>> {
+    if desired.is_bluetooth() {
+        None
+    } else {
+        Some((0..4).collect())
+    }
+}
+
+pub(crate) async fn wait_for_bluetooth_xinput_release(
+    targets: &[cmd_run::PicoTarget],
+    quiet: bool,
+) -> Result<()> {
+    let uids: BTreeSet<u32> = targets
+        .iter()
+        .map(|target| target.info.unique_id_short)
+        .collect();
+    if uids.is_empty() {
+        return Ok(());
+    }
+
+    let deadline = Instant::now() + XINPUT_RELEASE_WAIT;
+    let mut announced = false;
+    loop {
+        let instance_ids = match cmd_lab::connected_xinput_instance_ids_for_uids(&uids) {
+            Ok(instance_ids) if instance_ids.is_empty() => {
+                if announced && !quiet {
+                    println!("Selected Pico XInput endpoint is gone.");
+                }
+                return Ok(());
+            }
+            Ok(instance_ids) => instance_ids,
+            Err(e) => {
+                if !quiet {
+                    println!(
+                        "Note: could not verify whether the selected Pico is still exposed as a Windows XInput source: {e:#}"
+                    );
+                    println!(
+                        "Choose the Parsec or local controller source, not the selected Pico."
+                    );
+                }
+                return Ok(());
+            }
+        };
+
+        if Instant::now() >= deadline {
+            bail!("{}", selected_pico_xinput_release_error(&instance_ids));
+        }
+
+        if !announced && !quiet {
+            println!("Waiting for Windows to remove the selected Pico's old XInput source...");
+            announced = true;
+        }
+        tokio::time::sleep(XINPUT_RELEASE_POLL).await;
+    }
+}
+
+fn selected_pico_xinput_release_error(instance_ids: &[String]) -> String {
+    let details = if instance_ids.is_empty() {
+        "no instance ID captured".to_string()
+    } else {
+        instance_ids.join(", ")
+    };
+    format!(
+        "the selected Pico is still exposed as a local XInput device after switching to Bluetooth ({details}). Unplug/replug the Pico or wait for Windows to remove the old controller, then run the Bluetooth command again."
+    )
+}
+
 pub(crate) fn select_targets(
     picos: &[cmd_run::PicoTarget],
     selectors: &[String],
@@ -203,3 +275,6 @@ fn merge_targets(
     out.extend(reappeared);
     out
 }
+
+#[cfg(test)]
+mod tests;

bridge/src/cmd_persona/tests.rs

@@ -0,0 +1,29 @@
+use super::*;
+
+#[test]
+fn selected_pico_xinput_release_error_names_instance_ids() {
+    let message =
+        selected_pico_xinput_release_error(
+            &[r"USB\VID_045E&PID_028E\E6613852837C242C".to_string()],
+        );
+
+    assert!(message.contains("still exposed as a local XInput device"));
+    assert!(message.contains(r"USB\VID_045E&PID_028E\E6613852837C242C"));
+    assert!(message.contains("run the Bluetooth command again"));
+}
+
+#[test]
+fn bluetooth_persona_commands_reselect_live_source_slots() {
+    assert_eq!(
+        preferred_source_slots_for_persona(Persona::BluetoothHid),
+        None
+    );
+    assert_eq!(
+        preferred_source_slots_for_persona(Persona::BluetoothXbox),
+        None
+    );
+    assert_eq!(
+        preferred_source_slots_for_persona(Persona::Xinput),
+        Some(vec![0, 1, 2, 3])
+    );
+}