Fix relative paths support for Python/Node.js executables

Flow.Launcher.Core/ExternalPlugins/Environments/AbstractPluginEnvironment.cs

@@ -40,6 +40,12 @@ internal AbstractPluginEnvironment(List<PluginMetadata> pluginMetadataList, Plug
             PluginSettings = pluginSettings;
         }
 
+        /// <summary>
+        /// Resolves the configured runtime executable path to an absolute path.
+        /// Supports both absolute paths and relative paths (relative to ProgramDirectory).
+        /// </summary>
+        private string ResolvedPluginsSettingsFilePath => FilesFolders.ResolveAbsolutePath(PluginsSettingsFilePath);
+
         internal IEnumerable<PluginPair> Setup()
         {
             // If no plugin is using the language, return empty list
@@ -48,13 +54,16 @@ internal IEnumerable<PluginPair> Setup()
                 return new List<PluginPair>();
             }
 
-            if (!string.IsNullOrEmpty(PluginsSettingsFilePath) && FilesFolders.FileExists(PluginsSettingsFilePath))
+            var resolvedPath = ResolvedPluginsSettingsFilePath;
+            if (!string.IsNullOrEmpty(resolvedPath) && FilesFolders.FileExists(resolvedPath))
             {
                 // Ensure latest only if user is using Flow's environment setup.
-                if (PluginsSettingsFilePath.StartsWith(EnvPath, StringComparison.OrdinalIgnoreCase))
-                    EnsureLatestInstalled(ExecutablePath, PluginsSettingsFilePath, EnvPath);
+                if (resolvedPath.StartsWith(EnvPath, StringComparison.OrdinalIgnoreCase))
+                    EnsureLatestInstalled(ExecutablePath, resolvedPath, EnvPath);
 
-                return SetPathForPluginPairs(PluginsSettingsFilePath, Language);
+                // Ensure the path is updated in settings in case environment was updated
+                resolvedPath = ResolvedPluginsSettingsFilePath;
+                return SetPathForPluginPairs(resolvedPath, Language);
             }
 
             var noRuntimeMessage = Localize.runtimePluginInstalledChooseRuntimePrompt(Language, EnvName, Environment.NewLine);
@@ -103,9 +112,11 @@ internal IEnumerable<PluginPair> Setup()
                 InstallEnvironment();
             }
 
-            if (FilesFolders.FileExists(PluginsSettingsFilePath))
+            // Ensure the path is updated when user has chosen to install or select environment executable
+            resolvedPath = ResolvedPluginsSettingsFilePath;
+            if (FilesFolders.FileExists(resolvedPath))
             {
-                return SetPathForPluginPairs(PluginsSettingsFilePath, Language);
+                return SetPathForPluginPairs(resolvedPath, Language);
             }
             else
             {

Flow.Launcher.Plugin/SharedCommands/FilesFolders.cs

@@ -2,6 +2,8 @@
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Reflection;
+
 #pragma warning disable IDE0005
 using System.Windows;
 #pragma warning restore IDE0005
@@ -17,7 +19,7 @@
 
         /// <summary>
         /// Copies the folder and all of its files and folders 
         /// including subfolders to the target location
         /// </summary>
         /// <param name="sourcePath"></param>
         /// <param name="targetPath"></param>
@@ -48,14 +50,14 @@
                 foreach (FileInfo file in files)
                 {
                     string temppath = Path.Combine(targetPath, file.Name);
                     file.CopyTo(temppath, false);
                 }
 
                 // Recursively copy subdirectories by calling itself on each subdirectory until there are no more to copy
                 foreach (DirectoryInfo subdir in dirs)
                 {
                     string temppath = Path.Combine(targetPath, subdir.Name);
                     CopyAll(subdir.FullName, temppath, messageBoxExShow);
                 }
             }
             catch (Exception)
@@ -487,5 +489,34 @@
                 }
             }
         }
+
+        /// <summary>
+        /// Resolves a path that may be relative to an absolute path.
+        /// If the path is already absolute, returns it as-is.
+        /// If the path is not rooted (as determined by <see cref="Path.IsPathRooted(string)"/>), resolves it relative to ProgramDirectory.
+        /// </summary>
+        /// <param name="path">The path to resolve</param>
+        /// <returns>An absolute path</returns>
+        public static string ResolveAbsolutePath(string path)
+        {
+            if (string.IsNullOrEmpty(path))
+                return path;
+
+            // If already absolute, return as-is
+            if (Path.IsPathFullyQualified(path))
+                return path;
+
+            // Resolve relative to ProgramDirectory, handling invalid path formats gracefully
+            try
+            {
+                return Path.GetFullPath(Path.Combine(Directory.GetParent(Assembly.GetExecutingAssembly().Location).ToString(), path));
+            }
+            catch (Exception)
+            {
+                // If the path cannot be resolved (invalid characters, format, or too long),
+                // return the original path to avoid crashing the application.
+                return path;
+            }
+        }
     }
 }