refactor(proxy): single BuildInitCommand for every non-Windows launcher

The PowerShell init script that bootstraps PowerShell.MCP into a freshly
launched pwsh used to live in three near-identical inline copies. macOS
extracted it to PwshLauncherMacOS.BuildInitCommand back when issue #45
was fixed (see April 2026 work) but the Linux terminal path and the
Linux headless path each kept their own inline construction, drifted in
two ways:

- agentId went into the script unescaped — `IsValidAgentId` keeps the
  current ID format quote-free in practice, but the safety net the
  macOS path has (escapedAgentId) was missing on Linux, so a future ID
  format change would break only the Linux launches.
- The headless path skipped Set-Location and Remove-Module PSReadLine
  entirely. Set-Location was substituted with -WorkingDirectory, but
  the PSReadLine cleanup was just absent.

Move BuildInitCommand from PwshLauncherMacOS into PwshLauncherShared
so all three call sites (macOS tempFile, Linux Base64, Linux headless
ArgumentList) build the script body the same way. Each platform keeps
its own delivery mechanism for documented reasons:

  Windows  pwsh.exe -Command "<inline>"   (Win32, no shell layer)
  macOS    pwsh -File '/tmp/.../init.ps1' (AppleScript do script
                                           echoes the command line —
                                           Base64 would dump 1.2KB of
                                           noise into Terminal.app)
  Linux    pwsh -EncodedCommand <base64>  (setsid <terminal> -- <shell>
                                           -l -c '<pwsh>' multi-shell
                                           quoting through `sh -c` is
                                           the original reason for the
                                           encoding hop)
  Linux    pwsh -Command <init>           (headless / ArgumentList path,
                                           no shell layer at all)

Renamed the existing PwshLauncherMacOSTests file to
PwshLauncherSharedTests since the helper is no longer macOS-specific.
The 4 quoting / case-fix regression tests now cover every platform
that calls BuildInitCommand, and a single change to the script body
will cause exactly one test file to fail loudly instead of silently
diverging across launchers.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: yotsuda

PowerShell.MCP.Proxy/Services/PowerShellProcessManager.cs

@@ -174,6 +174,24 @@ internal static class PwshLauncherShared
     // may create the module directory as 'powershell.mcp'. Rename it so Import-Module can
     // locate the PascalCase name. No-op on case-insensitive file systems.
     internal const string ModuleCaseFix = "foreach ($p in ($env:PSModulePath -split [IO.Path]::PathSeparator)) { if ([string]::IsNullOrWhiteSpace($p)) { continue }; $lc = Join-Path $p 'powershell.mcp'; $uc = Join-Path $p 'PowerShell.MCP'; if ((Test-Path $lc) -and -not (Test-Path $uc)) { Rename-Item $lc $uc; break } }; ";
+
+    // Builds the PowerShell initialization command shared by every non-Windows launcher.
+    // The actual delivery to pwsh differs per platform — macOS writes this to /tmp and
+    // launches with `-File`, Linux Base64-encodes it for `-EncodedCommand` because of
+    // shell quoting through `sh -c` — but the script body is identical. Single quotes
+    // inside agentId / startLocation are escaped per PowerShell's '' convention so a
+    // future ID format change can't break the launch line.
+    // Kept internal so unit tests can lock in shell-safety without spawning a process.
+    internal static string BuildInitCommand(int proxyPid, string agentId, string? startupCommands, string? startLocation)
+    {
+        var setLocation = string.IsNullOrEmpty(startLocation)
+            ? "Set-Location ~; "
+            : $"Set-Location -LiteralPath '{startLocation.Replace("'", "''")}'; ";
+
+        var escapedAgentId = agentId.Replace("'", "''");
+        var core = $"{setLocation}$global:PowerShellMCPProxyPid = {proxyPid}; $global:PowerShellMCPAgentId = '{escapedAgentId}'; {ModuleCaseFix}Import-Module PowerShell.MCP -Force; Remove-Module PSReadLine -ErrorAction SilentlyContinue";
+        return string.IsNullOrEmpty(startupCommands) ? core : $"{core}; {startupCommands}";
+    }
 }
 
 /// <summary>
@@ -326,7 +344,7 @@ public static void LaunchPwsh(string agentId, string? startupCommands = null, st
         };
 
         var proxyPid = Process.GetCurrentProcess().Id;
-        var initCommand = BuildInitCommand(proxyPid, agentId, startupCommands, startLocation);
+        var initCommand = PwshLauncherShared.BuildInitCommand(proxyPid, agentId, startupCommands, startLocation);
 
         // Write the init to a temp .ps1 and launch with `-File`. AppleScript's `do script`
         // types its argument into the Terminal window verbatim — if we passed the PS source
@@ -351,18 +369,6 @@ public static void LaunchPwsh(string agentId, string? startupCommands = null, st
         }
     }
 
-    // Builds the PowerShell initialization script written to a temp .ps1 and loaded via `pwsh -File`.
-    // Kept internal so unit tests can lock in shell-safety (no unescaped quotes) without spawning a process.
-    internal static string BuildInitCommand(int proxyPid, string agentId, string? startupCommands, string? startLocation)
-    {
-        var setLocation = string.IsNullOrEmpty(startLocation)
-            ? "Set-Location ~; "
-            : $"Set-Location -LiteralPath '{startLocation.Replace("'", "''")}'; ";
-
-        var escapedAgentId = agentId.Replace("'", "''");
-        var core = $"{setLocation}$global:PowerShellMCPProxyPid = {proxyPid}; $global:PowerShellMCPAgentId = '{escapedAgentId}'; {PwshLauncherShared.ModuleCaseFix}Import-Module PowerShell.MCP -Force; Remove-Module PSReadLine -ErrorAction SilentlyContinue";
-        return string.IsNullOrEmpty(startupCommands) ? core : $"{core}; {startupCommands}";
-    }
 }
 
 /// <summary>
@@ -437,27 +443,12 @@ private static bool TryLaunchTerminal(string terminal, string agentId, string? s
                 CreateNoWindow = true
             };
 
-            // Build initialization command and encode to Base64 to avoid shell quoting issues
-            // Set global variables with proxy PID and agent ID before importing module
+            // Build the PowerShell init script (shared with macOS) and encode to Base64.
+            // Linux delivers it via -EncodedCommand because the launch path goes through
+            // `setsid <terminal> ... <shell> -l -c '<pwshCommand>'` and quoting through
+            // multiple shell layers is fragile; -EncodedCommand sidesteps that entirely.
             var proxyPid = Process.GetCurrentProcess().Id;
-            var caseFix = PwshLauncherShared.ModuleCaseFix;
-
-            // Set working directory via Set-Location inside the command to avoid shell quoting issues
-            var setLocation = string.IsNullOrEmpty(startLocation)
-                ? "Set-Location ~; "
-                : $"Set-Location -LiteralPath '{startLocation.Replace("'", "''")}'; ";
-
-            string initCommand;
-            if (!string.IsNullOrEmpty(startupCommands))
-            {
-                initCommand = $"{setLocation}$global:PowerShellMCPProxyPid = {proxyPid}; $global:PowerShellMCPAgentId = '{agentId}'; {caseFix}Import-Module PowerShell.MCP -Force; Remove-Module PSReadLine -ErrorAction SilentlyContinue; {startupCommands}";
-            }
-            else
-            {
-                initCommand = $"{setLocation}$global:PowerShellMCPProxyPid = {proxyPid}; $global:PowerShellMCPAgentId = '{agentId}'; {caseFix}Import-Module PowerShell.MCP -Force; Remove-Module PSReadLine -ErrorAction SilentlyContinue";
-            }
-
-            // Encode command to Base64 (UTF-16LE) to bypass shell quoting/expansion issues
+            var initCommand = PwshLauncherShared.BuildInitCommand(proxyPid, agentId, startupCommands, startLocation);
             var encodedCommand = Convert.ToBase64String(System.Text.Encoding.Unicode.GetBytes(initCommand));
 
             // Command to launch pwsh with encoded initialization via login shell
@@ -537,15 +528,14 @@ private static bool TryLaunchTerminal(string terminal, string agentId, string? s
     /// </summary>
     private static void LaunchPwshDirectly(string agentId, string? startupCommands, string? startLocation)
     {
+        // Reuse the shared init builder so a single source of truth (with proper
+        // single-quote escaping) covers terminal / headless / macOS paths. ArgumentList
+        // delivers -Command as a separate argv entry, so no Base64 encoding is needed
+        // here even though the terminal-launched Linux path uses -EncodedCommand.
+        // BuildInitCommand prepends Set-Location, so the headless cwd is established
+        // by the script body itself; -WorkingDirectory is no longer needed.
         var proxyPid = Process.GetCurrentProcess().Id;
-        var caseFix = PwshLauncherShared.ModuleCaseFix;
-        var initCommand = string.IsNullOrEmpty(startupCommands)
-            ? $"$global:PowerShellMCPProxyPid = {proxyPid}; $global:PowerShellMCPAgentId = '{agentId}'; {caseFix}Import-Module PowerShell.MCP -Force"
-            : $"$global:PowerShellMCPProxyPid = {proxyPid}; $global:PowerShellMCPAgentId = '{agentId}'; {caseFix}Import-Module PowerShell.MCP -Force; {startupCommands}";
-
-        var workingDir = string.IsNullOrEmpty(startLocation)
-            ? Environment.GetFolderPath(Environment.SpecialFolder.UserProfile)
-            : startLocation;
+        var initCommand = PwshLauncherShared.BuildInitCommand(proxyPid, agentId, startupCommands, startLocation);
 
         var psi = new ProcessStartInfo
         {
@@ -557,8 +547,6 @@ private static void LaunchPwshDirectly(string agentId, string? startupCommands,
             RedirectStandardError = true,
         };
         psi.ArgumentList.Add("-NoExit");
-        psi.ArgumentList.Add("-WorkingDirectory");
-        psi.ArgumentList.Add(workingDir);
         psi.ArgumentList.Add("-Command");
         psi.ArgumentList.Add(initCommand);
 

Tests/Unit/Proxy/PwshLauncherMacOSTests.cs

@@ -0,0 +1,63 @@
+using PowerShell.MCP.Proxy.Services;
+using Xunit;
+
+namespace PowerShell.MCP.Tests.Unit.Proxy;
+
+// PwshLauncherShared.BuildInitCommand is the single source of truth for the
+// PowerShell init script that all non-Windows launchers run when starting a
+// fresh pwsh session. The original regression (GitHub issue #45) was a broken
+// '' quoting on macOS that produced `$global:PowerShellMCPAgentId = ''default''`,
+// which zsh collapsed to a bareword `default`. After the helper was extracted
+// from PwshLauncherMacOS into PwshLauncherShared so PwshLauncherLinux can use
+// it too, these tests guard the PowerShell-level quote escaping for every
+// platform that delivers the script via pwsh (whether through `-File` /
+// `-EncodedCommand` / `-Command`).
+public class PwshLauncherSharedTests
+{
+    private const string DefaultAgentId = "default";
+    private const int DefaultPid = 12345;
+
+    [Fact]
+    public void BuildInitCommand_DefaultAgent_ContainsNoDoubleSingleQuotes()
+    {
+        var cmd = PwshLauncherShared.BuildInitCommand(DefaultPid, DefaultAgentId, null, null);
+
+        Assert.DoesNotContain("''default''", cmd);
+        Assert.Contains("$global:PowerShellMCPAgentId = 'default'", cmd);
+    }
+
+    [Fact]
+    public void BuildInitCommand_StartLocationWithSingleQuote_IsEscapedForPowerShell()
+    {
+        // PowerShell single-quoted string escape is '' (doubling). This is a
+        // *PowerShell* concern — independent of how the script body reaches pwsh
+        // (temp .ps1 on macOS, Base64 on Linux, ArgumentList on the headless path).
+        var cmd = PwshLauncherShared.BuildInitCommand(DefaultPid, DefaultAgentId, null, "/Users/o'brien");
+
+        Assert.Contains("Set-Location -LiteralPath '/Users/o''brien';", cmd);
+    }
+
+    [Fact]
+    public void BuildInitCommand_AgentIdWithSingleQuote_IsEscapedForPowerShell()
+    {
+        var cmd = PwshLauncherShared.BuildInitCommand(DefaultPid, "te'st", null, null);
+
+        Assert.Contains("$global:PowerShellMCPAgentId = 'te''st'", cmd);
+    }
+
+    [Fact]
+    public void BuildInitCommand_IncludesModuleCaseFixBeforeImport()
+    {
+        // Case-sensitive file systems (Linux ext4/btrfs, case-sensitive APFS)
+        // can surface a lowercase 'powershell.mcp' directory that
+        // Install-PSResource creates. The case-fix script must run before
+        // Import-Module so the PascalCase name resolves.
+        var cmd = PwshLauncherShared.BuildInitCommand(DefaultPid, DefaultAgentId, null, null);
+
+        var caseFixIdx = cmd.IndexOf("Rename-Item $lc $uc", StringComparison.Ordinal);
+        var importIdx = cmd.IndexOf("Import-Module PowerShell.MCP -Force", StringComparison.Ordinal);
+
+        Assert.True(caseFixIdx >= 0, "case-fix snippet must be present");
+        Assert.True(caseFixIdx < importIdx, "case-fix must run before Import-Module");
+    }
+}