fix: resolve symlinked /bin/python3 as LinuxGlobal (Fixes #405) (#413)

When `/bin` is a symlink to `/usr/bin` (common on modern Linux distros),
`find_cached()` canonicalizes `/bin` → `/usr/bin` and only caches
entries under `/usr/bin`. A subsequent `try_from` call with
`/bin/python3` fails the direct cache lookup and returns `None`, causing
the environment to be reported as `Unknown`.

**Fix:** In `try_from`, after a cache miss, canonicalize the executable
path and retry the lookup. When found via the canonical path, add the
original path as a symlink and update both cache entries for
consistency.

- Canonicalize executable once, use for both path guard and cache
fallback
- Path guard accepts executables whose canonical path resolves to a
known bin dir
- Cache fallback adds the original path as a symlink for complete
metadata
- Both canonical and original cache entries updated to keep symlink
lists consistent

Fixes #405

Author: karthiknadig

crates/pet-linux-global-python/src/lib.rs

@@ -87,15 +87,48 @@ impl Locator for LinuxGlobalPython {
 
         self.find_cached(None);
 
-        // We only support python environments in /bin, /usr/bin, /usr/local/bin
-        if !executable.starts_with("/bin")
-            && !executable.starts_with("/usr/bin")
-            && !executable.starts_with("/usr/local/bin")
-        {
+        // Resolve the canonical path once — used for both the path guard and cache fallback.
+        let canonical = fs::canonicalize(&executable).ok();
+
+        // We only support python environments in /bin, /usr/bin, /usr/local/bin.
+        // Check both the original and canonical paths so that symlinks from other
+        // locations (e.g. /bin → /usr/bin) are still accepted.
+        let dominated = |p: &Path| {
+            p.starts_with("/bin") || p.starts_with("/usr/bin") || p.starts_with("/usr/local/bin")
+        };
+        if !dominated(&executable) && !canonical.as_ref().is_some_and(|c| dominated(c)) {
             return None;
         }
 
-        self.reported_executables.get(&executable)
+        // Try direct cache lookup first.
+        if let Some(env) = self.reported_executables.get(&executable) {
+            return Some(env);
+        }
+
+        // If the executable wasn't found directly, resolve symlinks and try the canonical path.
+        // This handles cases like /bin/python3 → /usr/bin/python3 on systems where /bin
+        // is a symlink to /usr/bin. The cache is populated using canonicalized bin directories,
+        // so /bin/python3 won't be in the cache but /usr/bin/python3 will be.
+        if let Some(canonical) = canonical {
+            if canonical != executable {
+                if let Some(mut env) = self.reported_executables.get(&canonical) {
+                    // Add the original path as a symlink so it's visible to consumers.
+                    let mut symlinks = env.symlinks.clone().unwrap_or_default();
+                    if !symlinks.contains(&executable) {
+                        symlinks.push(executable.clone());
+                        symlinks.sort();
+                        symlinks.dedup();
+                        env.symlinks = Some(symlinks);
+                    }
+                    // Update both the canonical and original entries for consistency.
+                    self.reported_executables.insert(canonical, env.clone());
+                    self.reported_executables.insert(executable, env.clone());
+                    return Some(env);
+                }
+            }
+        }
+
+        None
     }
 
     fn find(&self, reporter: &dyn Reporter) {