Add copyEnvironmentFrom for GUI app debugging via desktop process environment inheritance (#111)

* Add copyEnvironmentFrom feature for GUI app debugging support
- Added copyEnvironmentFrom property to SecureShellRemoteLaunchProfile.xaml
- Added QueryCopyEnvironmentFrom() to ConfigurationAggregator
- Added QueryProcessEnvironmentAsync() to ISecureShellRemoteOperationsService and implementation
- Modified AdapterLaunchConfiguration to fetch and merge environment variables from target process
- Environment variables explicitly set in profile take precedence over copied ones

* Add documentation for copyEnvironmentFrom feature
* Address code review feedback: security and performance improvements
* Add input validation to prevent command injection in process name
* Optimize environment variable override logic to avoid O(n²) complexity
* Use backward iteration with RemoveAt for efficient removal
- Add support for "processName|var1;var2;var3" syntax
- processName alone copies all variables (backward compatible)
- processName|var1;var2 copies only specified variables
- Update ConfigurationAggregator with TryParseCopyEnvironmentFrom method
- Update QueryProcessEnvironmentAsync to accept optional variable filter list
- Update documentation with new syntax and examples

---------

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: MichaelKoster70 <[email protected]>

Author: Copilot

docs/LaunchProfile.md

@@ -11,6 +11,7 @@ The following launch profile properties are independant of the application type:
       "environmentVariables": {
         "answer": "42"
       },
+      "copyEnvironmentFrom": "gnome-shell",
       "hostName": "192.168.1.106",
       "hostPort": "22",
       "userName": "pi",
@@ -39,6 +40,7 @@ The following launch profile properties are independant of the application type:
 | dotNetInstallFolderPath   | no | string | Linux path | The .NET install path |
 | debuggerInstallFolderPath | no | string | Linux path | The vsdbg install path |
 | appFolderPath | no | string | Linux path | The path where the app gets deployed to |
+| copyEnvironmentFrom | no | string | Process name | Name of a process to copy environment variables from (e.g., gnome-shell, plasmashell) |
 | additionalFiles | no | string | Multiple entries separated by ';'. Each entry: 'SourcePath|TargetPath' | Additional files to deploy |
 | additionalDirectories | no | string | Multiple entries separated by ';'. Each entry: 'SourcePath|TargetPath' | Additional directories to deploy |
 | publishMode | no | enum | SelfContained/FrameworkDependant | Publish mode |
@@ -76,3 +78,74 @@ The additional files and directories to deploy can be specified in the launch pr
 * All relative source paths for Windows are relative to the project folder.
 * All relative target paths (do not begin with /) for Linux are relative to the configured `appFolderPath`.
 * The entries in the additionalFiles are assumed to be files, the entries in additionalDirectories are assumed to be directories.
+
+## GUI Applications and Desktop Environment
+When debugging GUI applications that need to run inside a desktop environment, you typically need specific environment variables set. This is because an SSH session doesn't have access to the desktop environment's configuration.
+
+### Copy Environment From Process
+The `copyEnvironmentFrom` property allows you to copy environment variables from a running process that has the correct desktop environment setup. This is particularly useful for GUI applications that need variables like:
+- `DISPLAY`
+- `WAYLAND_DISPLAY`
+- `DBUS_SESSION_BUS_ADDRESS`
+- `XDG_RUNTIME_DIR`
+- `XDG_CURRENT_DESKTOP`
+- `XAUTHORITY`
+
+**Syntax:**
+The `copyEnvironmentFrom` property supports two formats:
+1. **Copy all variables**: `processName`
+   - Example: `"gnome-shell"` - copies all environment variables from the gnome-shell process
+2. **Copy specific variables**: `processName|var1;var2;var3`
+   - Example: `"gnome-shell|DISPLAY;XAUTHORITY;DBUS_SESSION_BUS_ADDRESS"` - copies only the specified variables
+
+**Usage:**
+1. Log into the target machine through a different connection having a desktop session (e.g., remote desktop via RDP/VNC or the virtual display of a VM)
+2. In your launch profile, set `copyEnvironmentFrom` to the name of a desktop process, such as:
+   - `gnome-shell` (GNOME desktop)
+   - `plasmashell` or `ksmserver` (KDE Plasma)
+   - `xfce4-session` (XFCE)
+   - `sway` (Sway compositor)
+   - `kwin_wayland` or `kwin_x11` (KWin window manager)
+   - `Xwayland` or `Xorg` (X server)
+
+**Examples:**
+
+Copy all environment variables:
+```json
+{
+  "profiles": {
+    "SSH Remote GUI": {
+      "commandName": "SshRemoteLaunch",
+      "hostName": "192.168.1.106",
+      "copyEnvironmentFrom": "gnome-shell",
+      "environmentVariables": {
+        "MY_CUSTOM_VAR": "value"
+      }
+    }
+  }
+}
+```
+
+Copy only specific environment variables:
+```json
+{
+  "profiles": {
+    "SSH Remote GUI": {
+      "commandName": "SshRemoteLaunch",
+      "hostName": "192.168.1.106",
+      "copyEnvironmentFrom": "gnome-shell|DISPLAY;WAYLAND_DISPLAY;XAUTHORITY;DBUS_SESSION_BUS_ADDRESS",
+      "environmentVariables": {
+        "MY_CUSTOM_VAR": "value"
+      }
+    }
+  }
+}
+```
+
+**Behavior:**
+- The extension finds a running process with the specified name that is owned by the same user as the SSH connection
+- It reads all environment variables from that process (via `/proc/{pid}/environ`)
+- These variables are added to the debugger launch configuration
+- Any environment variables explicitly specified in the `environmentVariables` property will override the copied ones
+
+**Note:** If the specified process is not found, the feature is silently skipped and debugging proceeds with only the explicitly configured environment variables.

src/Extension/RemoteDebuggerLauncher/ProjectSystem/Debugger/AdapterLaunchConfiguration.cs

@@ -7,6 +7,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.ProjectSystem;
 using Microsoft.VisualStudio.ProjectSystem.Debug;
@@ -141,7 +142,7 @@ public static async Task<string> CreateFrameworkDependantAsync(ConfigurationAggr
          config.Args.Add($"{assemblyFileDirectory}/{assemblyFileName}");
          config.CurrentWorkingDirectory = workingDirectory;
          config.AppendCommandLineArguments(configurationAggregator);
-         config.AppendEnvironmentVariables(configurationAggregator);
+         await config.AppendEnvironmentVariablesAsync(configurationAggregator, remoteOperations);
 
          var launchConfigurationJson = JsonConvert.SerializeObject(config);
 
@@ -194,7 +195,7 @@ public static async Task<string> CreateSelfContainedAsync(ConfigurationAggregato
          config.Args.Add($"./{assemblyFileName}");
          config.CurrentWorkingDirectory = workingDirectory;
          config.AppendCommandLineArguments(configurationAggregator);
-         config.AppendEnvironmentVariables(configurationAggregator);
+         await config.AppendEnvironmentVariablesAsync(configurationAggregator, remoteOperations);
 
          var launchConfigurationJson = JsonConvert.SerializeObject(config);
 
@@ -260,12 +261,43 @@ private static void AppendCommandLineArguments(this LaunchConfiguration config,
          }
       }
 
-      private static void AppendEnvironmentVariables(this LaunchConfiguration config, ConfigurationAggregator configurationAggregator)
+      private static async Task AppendEnvironmentVariablesAsync(this LaunchConfiguration config, ConfigurationAggregator configurationAggregator, ISecureShellRemoteOperationsService remoteOperations)
       {
-         var environment = configurationAggregator.QueryEnvironmentVariables();
-         foreach(var ev in environment)
+         // First, check if we need to copy environment from a process
+         var (processName, variablesToCopy) = configurationAggregator.QueryCopyEnvironmentFrom();
+         if (!string.IsNullOrEmpty(processName))
          {
-            config.Environment.Add(new EnvironmentEntry { Name = ev.Key, Value = ev.Value });
+            var processEnv = await remoteOperations.QueryProcessEnvironmentAsync(processName, variablesToCopy);
+            
+            // Add all environment variables from the process (filtered if specified)
+            foreach (var kvp in processEnv)
+            {
+               config.Environment.Add(new EnvironmentEntry { Name = kvp.Key, Value = kvp.Value });
+            }
+         }
+
+         // Then, add/override with explicitly configured environment variables
+         // These take precedence over copied variables
+         var explicitEnv = configurationAggregator.QueryEnvironmentVariables();
+         if (explicitEnv.Count > 0)
+         {
+            // Create a HashSet of explicit keys for efficient lookup
+            var explicitKeys = new HashSet<string>(explicitEnv.Keys);
+            
+            // Remove any existing entries that will be overridden
+            for (int i = config.Environment.Count - 1; i >= 0; i--)
+            {
+               if (explicitKeys.Contains(config.Environment[i].Name))
+               {
+                  config.Environment.RemoveAt(i);
+               }
+            }
+            
+            // Add the explicit environment variables
+            foreach (var ev in explicitEnv)
+            {
+               config.Environment.Add(new EnvironmentEntry { Name = ev.Key, Value = ev.Value });
+            }
          }
       }
    }

src/Extension/RemoteDebuggerLauncher/ProjectSystem/Debugger/ConfigurationAggregator.cs

@@ -6,7 +6,9 @@
 // ----------------------------------------------------------------------------
 
 using System;
+using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Linq;
 using System.Net;
 using Microsoft.VisualStudio.ProjectSystem.Debug;
 using RemoteDebuggerLauncher.Shared;
@@ -341,6 +343,46 @@ public string QueryCommandLineArguments()
       /// </remarks>
       public IImmutableDictionary<string, string> QueryEnvironmentVariables() => launchProfile.EnvironmentVariables;
 
+      /// <summary>
+      /// Queries and parses the copyEnvironmentFrom configuration value.
+      /// </summary>
+      /// <returns>A tuple containing the process name and list of specific variables to copy. Returns (string.Empty, empty list) if not configured.</returns>
+      /// <remarks>
+      /// The syntax is: "processName|var1;var2;var3"
+      /// - If no pipe character is present, all variables are copied (returns empty list)
+      /// - If pipe is present with variables, only those variables are copied
+      /// The following configuration providers are queried, first match wins:
+      /// - selected launch profile
+      /// </remarks>
+      public (string ProcessName, IReadOnlyList<string> VariablesToCopy) QueryCopyEnvironmentFrom()
+      {
+         var copyEnvFrom = GetOtherSetting<string>("copyEnvironmentFrom") ?? string.Empty;
+
+         if (!string.IsNullOrWhiteSpace(copyEnvFrom))
+         {
+            // Split the value into process name and variable list
+            var parts = copyEnvFrom.Split(new[] { '|' }, 2);
+            var processName = parts[0].Trim();
+
+            if (string.IsNullOrWhiteSpace(processName))
+            {
+               return (string.Empty, Array.Empty<string>());
+            }
+
+            IReadOnlyList<string> variablesToCopy = parts.Length == 2 && !string.IsNullOrWhiteSpace(parts[1]) ? 
+               parts[1].Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)
+                         .Select(v => v.Trim())
+                         .Where(v => !string.IsNullOrEmpty(v))
+                         .ToList() 
+               : (IReadOnlyList<string>)Array.Empty<string>();
+
+            return (processName, variablesToCopy);
+         }
+
+         // No args configured
+         return (string.Empty, Array.Empty<string>());
+      }
+
       /// <summary>
       /// Queries the flag whether to install the VS code debugger when start debugging.
       /// </summary>

src/Extension/RemoteDebuggerLauncher/ProjectSystem/Debugger/SecureShellRemoteLaunchProfile.xaml

@@ -73,6 +73,11 @@
     </StringProperty.ValueEditors>
   </StringProperty>
 
+  <StringProperty Name="copyEnvironmentFrom"
+                  DisplayName="Copy environment from"
+                  Description="Name of a process to copy environment variables from (e.g., gnome-shell, plasmashell, Xwayland). Environment variables explicitly set above will not be overwritten."
+                  Subcategory="Remote Devices" />
+
   <BoolProperty Name="launchBrowser"
                 DisplayName="LaunchBrowser"
                 Description="indicates that the web browser should automatically launch when debugging this project." />

src/Extension/RemoteDebuggerLauncher/RemoteOperations/ISecureShellRemoteOperationsService.cs

@@ -6,6 +6,7 @@
 // ----------------------------------------------------------------------------
 
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using RemoteDebuggerLauncher.Shared;
 
@@ -148,5 +149,13 @@ internal interface ISecureShellRemoteOperationsService
       /// </summary>
       /// <returns>The <see cref="string"/> holding the runtime ID.</returns>
       Task<string> GetRuntimeIdAsync();
+
+      /// <summary>
+      /// Queries environment variables from a running process owned by the current user.
+      /// </summary>
+      /// <param name="processName">The name of the process to query.</param>
+      /// <param name="variablesToCopy">Optional list of specific variables to copy. If null or empty, all variables are copied.</param>
+      /// <returns>A <see cref="Task{IDictionary}"/> representing the asynchronous operation: a dictionary of environment variables, or an empty dictionary if the process is not found.</returns>
+      Task<IDictionary<string, string>> QueryProcessEnvironmentAsync(string processName, IReadOnlyList<string> variablesToCopy = null);
    }
 }

src/Extension/RemoteDebuggerLauncher/RemoteOperations/SecureShellKeySetupService.cs

@@ -188,8 +188,12 @@ private async Task<bool> RegisterServerFingerprintWithConnectionAsync(SecureShel
 
          var outputPaneWriter = OutputPaneWriterServiceAsync.Create(OutputPaneWriter);
 
-         outputPaneWriter.WriteLineAsync(Resources.RemoteCommandSetupSshScanProgressFingerprintSsh1, settings.UserName, settings.HostName, settings.HostPort);
-         outputPaneWriter.WriteLineAsync(Resources.RemoteCommandSetupSshScanProgressFingerprintSsh2, arguments);
+         await outputPaneWriter.WriteLineAsync(Resources.RemoteCommandSetupSshScanProgressFingerprintSsh1, settings.UserName, settings.HostName, settings.HostPort);
+         await 
+            
+            
+            
+            outputPaneWriter.WriteLineAsync(Resources.RemoteCommandSetupSshScanProgressFingerprintSsh2, arguments);
 
          using (var process = PseudoConsoleProcess.Start(startInfo))
          {

src/Extension/RemoteDebuggerLauncher/RemoteOperations/SecureShellRemoteOperationsService.cs

@@ -6,11 +6,13 @@
 // ----------------------------------------------------------------------------
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Management.Automation;
 using System.Management.Automation.Runspaces;
 using System.Net.Http;
+using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using Microsoft.Build.Tasks;
 using Microsoft.Extensions.Logging;
@@ -809,6 +811,86 @@ private async Task InstallDotnetAsync(string filePath)
             outputPaneWriter.WriteLine(Resources.RemoteCommandCommonSuccess);
          }
       }
+
+      /// <inheritdoc />
+      public async Task<IDictionary<string, string>> QueryProcessEnvironmentAsync(string processName, IReadOnlyList<string> variablesToCopy = null)
+      {
+         var result = new Dictionary<string, string>();
+
+         if (string.IsNullOrWhiteSpace(processName))
+         {
+            logger.LogDebug("QueryProcessEnvironmentAsync: No processName specified, exiting");
+            return result;
+         }
+
+         try
+         {
+            logger.LogDebug("QueryProcessEnvironmentAsync: Querying environment from process '{ProcessName}'", processName);
+
+            // Escape the process name to prevent command injection
+            // Only allow alphanumeric characters, hyphens, and underscores
+            if (!Regex.IsMatch(processName, @"^[a-zA-Z0-9_-]+$"))
+            {
+               logger.LogWarning("QueryProcessEnvironmentAsync: Invalid process name '{ProcessName}' - only alphanumeric, hyphens, and underscores are allowed", processName);
+               return result;
+            }
+
+            // Find the process ID of a process with the given name owned by the current user
+            var userName = session.Settings.UserName;
+            var findPidCommand = $"pgrep -u {userName} -x \"{processName}\" | head -n 1";
+            
+            var pidResult = await session.ExecuteSingleCommandAsync(findPidCommand);
+            var pid = pidResult.Trim();
+
+            if (string.IsNullOrWhiteSpace(pid) || !int.TryParse(pid, out _))
+            {
+               logger.LogDebug("QueryProcessEnvironmentAsync: Process '{ProcessName}' not found or not owned by user '{UserName}'", processName, userName);
+               return result;
+            }
+
+            logger.LogDebug("QueryProcessEnvironmentAsync: Found process '{ProcessName}' with PID {Pid}", processName, pid);
+
+            // Read the environment variables from /proc/{pid}/environ
+            var environCommand = $"cat /proc/{pid}/environ";
+            var environResult = await session.ExecuteSingleCommandAsync(environCommand);
+
+            // The environ file contains null-terminated strings
+            var envVars = environResult.Split(new char[] { '\0' }, StringSplitOptions.RemoveEmptyEntries);
+            
+            // Create a HashSet for efficient lookup if filtering is needed
+            HashSet<string> filterSet = null;
+            if (variablesToCopy != null && variablesToCopy.Count > 0)
+            {
+               filterSet = new HashSet<string>(variablesToCopy, StringComparer.Ordinal);
+               logger.LogDebug("QueryProcessEnvironmentAsync: Filtering to {Count} specific variables", filterSet.Count);
+            }
+            
+            foreach (var envVar in envVars)
+            {
+               var separatorIndex = envVar.IndexOf('=');
+               if (separatorIndex > 0)
+               {
+                  var key = envVar.Substring(0, separatorIndex);
+                  var value = envVar.Substring(separatorIndex + 1);
+                  
+                  // Only add if no filter, or if the key is in the filter set
+                  if (filterSet == null || filterSet.Contains(key))
+                  {
+                     result[key] = value;
+                  }
+               }
+            }
+
+            logger.LogDebug("QueryProcessEnvironmentAsync: Successfully retrieved {Count} environment variables from process '{ProcessName}'", result.Count, processName);
+         }
+         catch (Exception ex)
+         {
+            logger.LogWarning(ex, "QueryProcessEnvironmentAsync: Failed to query environment from process '{ProcessName}'", processName);
+            // Return empty dictionary on error - this is not a critical failure
+         }
+
+         return result;
+      }
       #endregion
    }
 }