fix(macos): launch the detected Spotify bundle, not a hardcoded one

spawn_macos ran 'open -a /Applications/Spotify.app' and ignored the context
entirely, so on a ~/Applications install the whole apply succeeded and then
opened nothing, failing with 'Spotify did not start within 30 seconds'. It now
launches the bundle derived from the resolved executable. The version-detect
fallback had the same hardcoded path and now derives it too; its primary mdls
path already used the real bundle, which is why version detection worked while
the launch did not.

Author: afonsojramos

rust/crates/spicetify/src/hooks/version_detect.rs

@@ -1,4 +1,4 @@
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::sync::LazyLock;
 
@@ -46,13 +46,19 @@ fn detect_version(exec_path: &Path) -> Result<String> {
         }
     }
 
-    let output = Command::new("sh")
-        .args([
-            "-c",
-            "defaults read /Applications/Spotify.app/Contents/Info CFBundleShortVersionString",
-        ])
+    // Same bundle the caller resolved, not a hardcoded one: on an install in
+    // ~/Applications a fixed /Applications path reads nothing and the version
+    // comes back undetectable.
+    let info_plist = app_base
+        .map_or_else(|| PathBuf::from("/Applications/Spotify.app"), Path::to_path_buf)
+        .join("Contents")
+        .join("Info");
+    let output = Command::new("defaults")
+        .arg("read")
+        .arg(&info_plist)
+        .arg("CFBundleShortVersionString")
         .output()
-        .map_err(|e| anyhow::anyhow!("failed to read Info.plist: {e}"))?;
+        .map_err(|e| anyhow::anyhow!("failed to read {}: {e}", info_plist.display()))?;
 
     if output.status.success() {
         let version = String::from_utf8_lossy(&output.stdout).trim().to_string();

rust/crates/spicetify/src/process.rs

@@ -78,19 +78,39 @@ pub fn spawn_detached(ctx: &AppContext) -> Result<()> {
 }
 
 #[cfg(target_os = "macos")]
-fn spawn_macos(_ctx: &AppContext) -> Result<()> {
+fn spawn_macos(ctx: &AppContext) -> Result<()> {
+    // Launch the bundle that was actually resolved, not a hardcoded one:
+    // `open -a` on a path that does not exist starts nothing, and the caller
+    // then waits out its timeout with no idea why.
+    let bundle = macos_bundle(&ctx.spotify_exec);
     let child = Command::new("open")
-        .args(["-a", "/Applications/Spotify.app", "--args"])
+        .arg("-a")
+        .arg(&bundle)
+        .arg("--args")
         .stdin(Stdio::null())
         .stdout(Stdio::null())
         .stderr(Stdio::null())
         .spawn()
-        .map_err(|e| anyhow::anyhow!("failed to launch Spotify via open: {e}"))?;
+        .map_err(|e| {
+            anyhow::anyhow!("failed to launch Spotify via open -a {}: {e}", bundle.display())
+        })?;
     std::mem::forget(child);
-    tracing::info!("Spotify launched via open -a /Applications/Spotify.app");
+    tracing::info!("Spotify launched via open -a {}", bundle.display());
     Ok(())
 }
 
+/// `<bundle>/Contents/MacOS/Spotify` back up to `<bundle>`. Falls back to the
+/// executable itself, which `open -a` also accepts, when the path is not
+/// shaped like a bundle.
+#[cfg(target_os = "macos")]
+fn macos_bundle(exec: &std::path::Path) -> std::path::PathBuf {
+    exec.parent()
+        .and_then(std::path::Path::parent)
+        .and_then(std::path::Path::parent)
+        .filter(|p| p.extension().is_some_and(|ext| ext == "app"))
+        .map_or_else(|| exec.to_path_buf(), std::path::Path::to_path_buf)
+}
+
 #[cfg(windows)]
 fn spawn_windows(ctx: &AppContext) -> Result<()> {
     use std::path::PathBuf;
@@ -186,3 +206,30 @@ pub fn force_kill_spotify(ctx: &AppContext) {
     tracing::info!("force-killing Spotify processes");
     kill_image(image);
 }
+
+#[cfg(all(test, target_os = "macos"))]
+mod tests {
+    use super::macos_bundle;
+    use std::path::{Path, PathBuf};
+
+    #[test]
+    fn bundle_is_derived_from_the_resolved_executable() {
+        // The launch path must follow detection: a hardcoded /Applications
+        // "launches" nothing on a ~/Applications install and the caller then
+        // waits out its start timeout.
+        assert_eq!(
+            macos_bundle(Path::new("/Users/me/Applications/Spotify.app/Contents/MacOS/Spotify")),
+            PathBuf::from("/Users/me/Applications/Spotify.app")
+        );
+        assert_eq!(
+            macos_bundle(Path::new("/Applications/Spotify.app/Contents/MacOS/Spotify")),
+            PathBuf::from("/Applications/Spotify.app")
+        );
+    }
+
+    #[test]
+    fn a_non_bundle_executable_is_used_as_is() {
+        let exec = Path::new("/opt/spotify/spotify");
+        assert_eq!(macos_bundle(exec), exec.to_path_buf(), "open -a accepts the binary too");
+    }
+}