Remove swiftly from the path during proxying (#311)

Retaining swiftly in the path increases the probability that
a tool might run the proxy again, resulting in circularities.
Also, tools will locate programs in the path to try and find
adjacent toolchain files that cannot be discovered in the swiftly
bin directory.

Remove the swiftly bin directory from the path when proxying
to help improve the experience with other tools.

Author: cmcgee1024

Sources/Swiftly/Run.swift

@@ -105,6 +105,9 @@ struct Run: SwiftlyCommand {
 
             try await Swiftly.currentPlatform.proxy(ctx, toolchain, command[0], [String](command[1...]))
         } catch let terminated as RunProgramError {
+            if ctx.mockedHomeDir != nil {
+                throw terminated
+            }
             Foundation.exit(terminated.exitCode)
         } catch {
             throw error

Sources/SwiftlyCore/Platform.swift

@@ -164,25 +164,28 @@ extension Platform {
     }
 
 #if os(macOS) || os(Linux)
-    func proxyEnv(_ ctx: SwiftlyCoreContext, _ toolchain: ToolchainVersion) throws -> [
-        String:
-            String
-    ] {
+    func proxyEnv(_ ctx: SwiftlyCoreContext, env: [String: String], toolchain: ToolchainVersion) throws -> [String: String] {
+        var newEnv = env
+
         let tcPath = self.findToolchainLocation(ctx, toolchain).appendingPathComponent("usr/bin")
         guard tcPath.fileExists() else {
             throw SwiftlyError(
                 message:
                 "Toolchain \(toolchain) could not be located. You can try `swiftly uninstall \(toolchain)` to uninstall it and then `swiftly install \(toolchain)` to install it again."
             )
         }
-        var newEnv = ProcessInfo.processInfo.environment
+
+        var pathComponents = (newEnv["PATH"] ?? "").split(separator: ":").map { String($0) }
 
         // The toolchain goes to the beginning of the PATH
-        var newPath = newEnv["PATH"] ?? ""
-        if !newPath.hasPrefix(tcPath.path + ":") {
-            newPath = "\(tcPath.path):\(newPath)"
-        }
-        newEnv["PATH"] = newPath
+        pathComponents.removeAll(where: { $0 == tcPath.path })
+        pathComponents = [tcPath.path] + pathComponents
+
+        // Remove swiftly bin directory from the PATH entirely
+        let swiftlyBinDir = self.swiftlyBinDir(ctx)
+        pathComponents.removeAll(where: { $0 == swiftlyBinDir.path })
+
+        newEnv["PATH"] = String(pathComponents.joined(by: ":"))
 
         return newEnv
     }
@@ -192,27 +195,40 @@ extension Platform {
     /// In the case where the command exit with a non-zero exit code a RunProgramError is thrown with
     /// the exit code and program information.
     ///
-    public func proxy(
-        _ ctx: SwiftlyCoreContext, _ toolchain: ToolchainVersion, _ command: String,
-        _ arguments: [String], _ env: [String: String] = [:]
-    ) async throws {
-        var newEnv = try self.proxyEnv(ctx, toolchain)
+    public func proxy(_ ctx: SwiftlyCoreContext, _ toolchain: ToolchainVersion, _ command: String, _ arguments: [String], _ env: [String: String] = [:]) async throws {
+        let tcPath = self.findToolchainLocation(ctx, toolchain).appendingPathComponent("usr/bin")
+
+        let commandTcPath = tcPath.appendingPathComponent(command)
+        let commandToRun = if FileManager.default.fileExists(atPath: commandTcPath.path) {
+            commandTcPath.path
+        } else {
+            command
+        }
+
+        var newEnv = try self.proxyEnv(ctx, env: ProcessInfo.processInfo.environment, toolchain: toolchain)
         for (key, value) in env {
             newEnv[key] = value
         }
-        try self.runProgram([command] + arguments, env: newEnv)
+
+        try self.runProgram([commandToRun] + arguments, env: newEnv)
     }
 
     /// Proxy the invocation of the provided command to the chosen toolchain and capture the output.
     ///
     /// In the case where the command exit with a non-zero exit code a RunProgramError is thrown with
     /// the exit code and program information.
     ///
-    public func proxyOutput(
-        _ ctx: SwiftlyCoreContext, _ toolchain: ToolchainVersion, _ command: String,
-        _ arguments: [String]
-    ) async throws -> String? {
-        try await self.runProgramOutput(command, arguments, env: self.proxyEnv(ctx, toolchain))
+    public func proxyOutput(_ ctx: SwiftlyCoreContext, _ toolchain: ToolchainVersion, _ command: String, _ arguments: [String]) async throws -> String? {
+        let tcPath = self.findToolchainLocation(ctx, toolchain).appendingPathComponent("usr/bin")
+
+        let commandTcPath = tcPath.appendingPathComponent(command)
+        let commandToRun = if FileManager.default.fileExists(atPath: commandTcPath.path) {
+            commandTcPath.path
+        } else {
+            command
+        }
+
+        return try await self.runProgramOutput(commandToRun, arguments, env: self.proxyEnv(ctx, env: ProcessInfo.processInfo.environment, toolchain: toolchain))
     }
 
     /// Run a program.

Tests/SwiftlyTests/PlatformTests.swift

@@ -85,4 +85,30 @@ import Testing
         toolchains = try FileManager.default.contentsOfDirectory(at: Swiftly.currentPlatform.swiftlyToolchainsDir(SwiftlyTests.ctx), includingPropertiesForKeys: nil)
         #expect(0 == toolchains.count)
     }
+
+#if os(macOS) || os(Linux)
+    @Test(
+        .mockHomeToolchains(),
+        arguments: [
+            "/a/b/c:SWIFTLY_BIN_DIR:/d/e/f",
+            "SWIFTLY_BIN_DIR:/abcde",
+            "/defgh:SWIFTLY_BIN_DIR",
+            "/xyzabc:/1/3/4",
+            "",
+        ]
+    ) func proxyEnv(_ path: String) async throws {
+        // GIVEN: a PATH that may contain the swiftly bin directory
+        let env = ["PATH": path.replacing("SWIFTLY_BIN_DIR", with: Swiftly.currentPlatform.swiftlyBinDir(SwiftlyTests.ctx).path)]
+
+        // WHEN: proxying to an installed toolchain
+        let newEnv = try Swiftly.currentPlatform.proxyEnv(SwiftlyTests.ctx, env: env, toolchain: .newStable)
+
+        // THEN: the toolchain's bin directory is added to the beginning of the PATH
+        #expect(newEnv["PATH"]!.hasPrefix(Swiftly.currentPlatform.findToolchainLocation(SwiftlyTests.ctx, .newStable).appendingPathComponent("usr/bin").path))
+
+        // AND: the swiftly bin directory is removed from the PATH
+        #expect(!newEnv["PATH"]!.contains(Swiftly.currentPlatform.swiftlyBinDir(SwiftlyTests.ctx).path))
+        #expect(!newEnv["PATH"]!.contains(Swiftly.currentPlatform.swiftlyBinDir(SwiftlyTests.ctx).path))
+    }
+#endif
 }