fix(tailscale): detect CLI using fallback install paths

Author: Dimillian

memory/decisions.md

@@ -288,3 +288,10 @@ Type: decision
 Event: Smooth, delayed auto-scroll on streaming/appended messages caused visible upward jump then repin in the conversation view.
 Action: Updated `Messages` auto-scroll paths to immediate container-bottom pinning (`scrollTop = scrollHeight`) and removed delayed smooth auto-scroll behavior for automatic updates.
 Rule: Automatic message pinning should be immediate and non-animated; reserve smooth scrolling for explicit user-initiated navigation only.
+
+## 2026-02-07 21:16
+Context: Desktop Tailscale CLI detection in Tauri runtime
+Type: decision
+Event: Settings reported missing Tailscale CLI even when installed because GUI runtime PATH did not include shell-resolved aliases/paths.
+Action: Added Tailscale binary candidate resolution (`PATH` first, then standard install paths including macOS app bundle path) before status checks.
+Rule: Desktop CLI integrations must not rely on shell aliases or login-shell PATH alone; include deterministic install-path fallbacks.

memory/mistakes.md

@@ -131,3 +131,13 @@ Rule: Node-targeted unit tests must not assume browser globals exist; create and
 Root cause: The tests were authored assuming `navigator` is always available, but Vitest runs with `environment: node` in CI.
 Fix applied: Added a global-scope navigator shim path and descriptor-safe restore logic in `src/utils/platformPaths.test.ts`.
 Prevention rule: For tests that patch `navigator`, `window`, or `document`, guard setup with `typeof ... === \"undefined\"` and perform full teardown in `finally`.
+
+## 2026-02-07 21:16
+Context: Tailscale CLI detection from GUI app runtime
+Type: mistake
+Event: Tailscale detection relied on `PATH` only, which can differ from shell aliases and fail in Tauri GUI runtime.
+Action: Added binary resolution fallback candidates (including macOS app bundle path) before reporting CLI missing.
+Rule: For desktop-integrated CLIs, resolve from PATH plus standard install locations; do not assume shell alias/path propagation.
+Root cause: Implementation assumed the app process inherits the same shell PATH/aliases as user terminal sessions.
+Fix applied: Updated `src-tauri/src/tailscale/mod.rs` to probe candidate binaries and execute status/version via resolved path.
+Prevention rule: Any new CLI integration in Tauri should include explicit path fallback logic and a test for candidate list coverage.

src-tauri/src/tailscale/mod.rs

@@ -1,6 +1,8 @@
 mod core;
 
+use std::ffi::{OsStr, OsString};
 use std::io::ErrorKind;
+use std::process::Output;
 
 use tauri::State;
 
@@ -21,6 +23,70 @@ fn trim_to_non_empty(value: Option<&str>) -> Option<String> {
         .map(str::to_string)
 }
 
+fn tailscale_binary_candidates() -> Vec<OsString> {
+    let mut candidates = vec![OsString::from("tailscale")];
+
+    #[cfg(target_os = "macos")]
+    {
+        candidates.push(OsString::from(
+            "/Applications/Tailscale.app/Contents/MacOS/Tailscale",
+        ));
+        candidates.push(OsString::from("/opt/homebrew/bin/tailscale"));
+        candidates.push(OsString::from("/usr/local/bin/tailscale"));
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+        candidates.push(OsString::from("/usr/bin/tailscale"));
+        candidates.push(OsString::from("/usr/sbin/tailscale"));
+        candidates.push(OsString::from("/snap/bin/tailscale"));
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+        candidates.push(OsString::from(
+            "C:\\Program Files\\Tailscale\\tailscale.exe",
+        ));
+        candidates.push(OsString::from(
+            "C:\\Program Files (x86)\\Tailscale\\tailscale.exe",
+        ));
+    }
+
+    candidates
+}
+
+fn missing_tailscale_message() -> String {
+    #[cfg(target_os = "macos")]
+    {
+        return "Tailscale CLI not found on PATH or standard install paths (including /Applications/Tailscale.app/Contents/MacOS/Tailscale).".to_string();
+    }
+    #[cfg(not(target_os = "macos"))]
+    {
+        "Tailscale CLI not found on PATH or standard install paths.".to_string()
+    }
+}
+
+async fn resolve_tailscale_binary() -> Result<Option<(OsString, Output)>, String> {
+    let mut failures: Vec<String> = Vec::new();
+    for binary in tailscale_binary_candidates() {
+        let output = tokio_command(&binary).arg("version").output().await;
+        match output {
+            Ok(version_output) => return Ok(Some((binary, version_output))),
+            Err(err) if err.kind() == ErrorKind::NotFound => continue,
+            Err(err) => failures.push(format!("{}: {err}", OsStr::new(&binary).to_string_lossy())),
+        }
+    }
+
+    if failures.is_empty() {
+        Ok(None)
+    } else {
+        Err(format!(
+            "Failed to run tailscale version from candidate paths: {}",
+            failures.join(" | ")
+        ))
+    }
+}
+
 #[tauri::command]
 pub(crate) async fn tailscale_status() -> Result<TailscaleStatus, String> {
     #[cfg(any(target_os = "android", target_os = "ios"))]
@@ -31,24 +97,17 @@ pub(crate) async fn tailscale_status() -> Result<TailscaleStatus, String> {
         ));
     }
 
-    let version_output = tokio_command("tailscale").arg("version").output().await;
-    let version_output = match version_output {
-        Ok(output) => output,
-        Err(err) if err.kind() == ErrorKind::NotFound => {
-            return Ok(tailscale_core::unavailable_status(
-                None,
-                "Tailscale CLI not found on PATH.".to_string(),
-            ));
-        }
-        Err(err) => {
-            return Err(format!("Failed to run tailscale version: {err}"));
-        }
+    let Some((tailscale_binary, version_output)) = resolve_tailscale_binary().await? else {
+        return Ok(tailscale_core::unavailable_status(
+            None,
+            missing_tailscale_message(),
+        ));
     };
 
     let version = trim_to_non_empty(std::str::from_utf8(&version_output.stdout).ok())
         .and_then(|raw| raw.lines().next().map(str::trim).map(str::to_string));
 
-    let status_output = tokio_command("tailscale")
+    let status_output = tokio_command(&tailscale_binary)
         .arg("status")
         .arg("--json")
         .output()
@@ -77,6 +136,26 @@ pub(crate) async fn tailscale_status() -> Result<TailscaleStatus, String> {
     tailscale_core::status_from_json(version, payload)
 }
 
+#[cfg(test)]
+mod tests {
+    use super::tailscale_binary_candidates;
+
+    #[test]
+    fn includes_path_candidate() {
+        let candidates = tailscale_binary_candidates();
+        assert!(!candidates.is_empty());
+        assert_eq!(candidates[0].to_string_lossy(), "tailscale");
+
+        #[cfg(target_os = "macos")]
+        {
+            assert!(candidates.iter().any(|candidate| {
+                candidate.to_string_lossy()
+                    == "/Applications/Tailscale.app/Contents/MacOS/Tailscale"
+            }));
+        }
+    }
+}
+
 #[tauri::command]
 pub(crate) async fn tailscale_daemon_command_preview(
     state: State<'_, AppState>,