Add ability to temporarily disable swiftly

Adds two new commands, `swiftly unlink` and `swiftly link`, which
will disable and reenable swiftly's management of the active toolchain.

The `unlink` command removes the symlinks to toolchain binaries in the
swiftly bin directory that is in the user's path. This allows the rest
of the `$PATH` to be searched for available toolchain installations,
falling back to the system default. On macOS with Xcode installed this
has the effect of falling back to the toolchain in the user's installed
Xcode.

The `link` command reinstates the symlinks to the `inUse` toolchain,
which allows swiftly to resume management of the active toolchain.

Author: plemarquand

Sources/Swiftly/Install.swift

@@ -84,31 +84,8 @@ struct Install: SwiftlyCommand {
         try validateSwiftly(ctx)
 
         var config = try Config.load(ctx)
+        let toolchainVersion = try await Self.determineToolchainVersion(ctx, version: self.version, config: &config)
 
-        var selector: ToolchainSelector
-
-        if let version = self.version {
-            selector = try ToolchainSelector(parsing: version)
-        } else {
-            if case let (_, result) = try await selectToolchain(ctx, config: &config),
-               case let .swiftVersionFile(_, sel, error) = result
-            {
-                if let sel = sel {
-                    selector = sel
-                } else if let error = error {
-                    throw error
-                } else {
-                    throw SwiftlyError(message: "Internal error selecting toolchain to install.")
-                }
-            } else {
-                throw SwiftlyError(
-                    message:
-                    "Swiftly couldn't determine the toolchain version to install. Please set a version like this and try again: `swiftly install latest`"
-                )
-            }
-        }
-
-        let toolchainVersion = try await Self.resolve(ctx, config: config, selector: selector)
         let (postInstallScript, pathChanged) = try await Self.execute(
             ctx,
             version: toolchainVersion,
@@ -158,6 +135,101 @@ struct Install: SwiftlyCommand {
                 to: URL(fileURLWithPath: postInstallFile), options: .atomic
             )
         }
+    }    
+    
+    public static func setupProxies(
+        _ ctx: SwiftlyCoreContext,
+        version: ToolchainVersion,
+        verbose: Bool,
+        assumeYes: Bool
+    ) async throws -> Bool {
+        var pathChanged = false
+
+        // Create proxies if we have a location where we can point them
+        if let proxyTo = try? Swiftly.currentPlatform.findSwiftlyBin(ctx) {
+            // Ensure swiftly doesn't overwrite any existing executables without getting confirmation first.
+            let swiftlyBinDir = Swiftly.currentPlatform.swiftlyBinDir(ctx)
+            let swiftlyBinDirContents =
+                (try? FileManager.default.contentsOfDirectory(atPath: swiftlyBinDir.path)) ?? [String]()
+            let toolchainBinDir = Swiftly.currentPlatform.findToolchainBinDir(ctx, version)
+            let toolchainBinDirContents = try FileManager.default.contentsOfDirectory(
+                atPath: toolchainBinDir.path)
+
+            let existingProxies = swiftlyBinDirContents.filter { bin in
+                do {
+                    let linkTarget = try FileManager.default.destinationOfSymbolicLink(
+                        atPath: swiftlyBinDir.appendingPathComponent(bin).path)
+                    return linkTarget == proxyTo
+                } catch { return false }
+            }
+
+            let overwrite = Set(toolchainBinDirContents).subtracting(existingProxies).intersection(
+                swiftlyBinDirContents)
+            if !overwrite.isEmpty && !assumeYes {
+                await ctx.print("The following existing executables will be overwritten:")
+
+                for executable in overwrite {
+                    await ctx.print("  \(swiftlyBinDir.appendingPathComponent(executable).path)")
+                }
+
+                guard await ctx.promptForConfirmation(defaultBehavior: false) else {
+                    throw SwiftlyError(message: "Toolchain installation has been cancelled")
+                }
+            }
+
+            if verbose {
+                await ctx.print("Setting up toolchain proxies...")
+            }
+
+            let proxiesToCreate = Set(toolchainBinDirContents).subtracting(swiftlyBinDirContents).union(
+                overwrite)
+
+            for p in proxiesToCreate {
+                let proxy = Swiftly.currentPlatform.swiftlyBinDir(ctx).appendingPathComponent(p)
+
+                if proxy.fileExists() {
+                    try FileManager.default.removeItem(at: proxy)
+                }
+
+                try FileManager.default.createSymbolicLink(
+                    atPath: proxy.path,
+                    withDestinationPath: proxyTo
+                )
+
+                pathChanged = true
+            }
+        }
+        return pathChanged
+    }
+
+    static func determineToolchainVersion(
+        _ ctx: SwiftlyCoreContext,
+        version: String?,
+        config: inout Config
+    ) async throws -> ToolchainVersion {
+        let selector: ToolchainSelector
+
+        if let version = version {
+            selector = try ToolchainSelector(parsing: version)
+        } else {
+            if case let (_, result) = try await selectToolchain(ctx, config: &config),
+               case let .swiftVersionFile(_, sel, error) = result {
+                if let sel = sel {
+                    selector = sel
+                } else if let error = error {
+                    throw error
+                } else {
+                    throw SwiftlyError(message: "Internal error selecting toolchain to install.")
+                }
+            } else {
+                throw SwiftlyError(
+                    message:
+                    "Swiftly couldn't determine the toolchain version to install. Please set a version like this and try again: `swiftly install latest`"
+                )
+            }
+        }
+
+        return try await Self.resolve(ctx, config: config, selector: selector)
     }
 
     public static func execute(
@@ -274,62 +346,12 @@ struct Install: SwiftlyCommand {
 
         try await Swiftly.currentPlatform.install(ctx, from: tmpFile, version: version, verbose: verbose)
 
-        var pathChanged = false
-
-        // Create proxies if we have a location where we can point them
-        if let proxyTo = try? Swiftly.currentPlatform.findSwiftlyBin(ctx) {
-            // Ensure swiftly doesn't overwrite any existing executables without getting confirmation first.
-            let swiftlyBinDir = Swiftly.currentPlatform.swiftlyBinDir(ctx)
-            let swiftlyBinDirContents =
-                (try? FileManager.default.contentsOfDirectory(atPath: swiftlyBinDir.path)) ?? [String]()
-            let toolchainBinDir = Swiftly.currentPlatform.findToolchainBinDir(ctx, version)
-            let toolchainBinDirContents = try FileManager.default.contentsOfDirectory(
-                atPath: toolchainBinDir.path)
-
-            let existingProxies = swiftlyBinDirContents.filter { bin in
-                do {
-                    let linkTarget = try FileManager.default.destinationOfSymbolicLink(
-                        atPath: swiftlyBinDir.appendingPathComponent(bin).path)
-                    return linkTarget == proxyTo
-                } catch { return false }
-            }
-
-            let overwrite = Set(toolchainBinDirContents).subtracting(existingProxies).intersection(
-                swiftlyBinDirContents)
-            if !overwrite.isEmpty && !assumeYes {
-                await ctx.print("The following existing executables will be overwritten:")
-
-                for executable in overwrite {
-                    await ctx.print("  \(swiftlyBinDir.appendingPathComponent(executable).path)")
-                }
-
-                guard await ctx.promptForConfirmation(defaultBehavior: false) else {
-                    throw SwiftlyError(message: "Toolchain installation has been cancelled")
-                }
-            }
-
-            if verbose {
-                await ctx.print("Setting up toolchain proxies...")
-            }
-
-            let proxiesToCreate = Set(toolchainBinDirContents).subtracting(swiftlyBinDirContents).union(
-                overwrite)
-
-            for p in proxiesToCreate {
-                let proxy = Swiftly.currentPlatform.swiftlyBinDir(ctx).appendingPathComponent(p)
-
-                if proxy.fileExists() {
-                    try FileManager.default.removeItem(at: proxy)
-                }
-
-                try FileManager.default.createSymbolicLink(
-                    atPath: proxy.path,
-                    withDestinationPath: proxyTo
-                )
-
-                pathChanged = true
-            }
-        }
+        let pathChanged = try await Self.setupProxies(
+            ctx,
+            version: version,
+            verbose: verbose,
+            assumeYes: assumeYes
+        )
 
         config.installedToolchains.insert(version)
 

Sources/Swiftly/Link.swift

@@ -0,0 +1,42 @@
+import ArgumentParser
+import SwiftlyCore
+import Foundation
+
+struct Link: SwiftlyCommand {
+    public static let configuration = CommandConfiguration(
+        abstract: "Link swiftly so it resumes management of the active toolchain."
+    )
+
+    @Argument(help: ArgumentHelp(
+        "Links swiftly if it has been disabled.",
+        discussion: """
+
+        Links swiftly if it has been disabled.
+        """
+    ))
+    var toolchainSelector: String?
+
+    @OptionGroup var root: GlobalOptions
+
+    mutating func run() async throws {
+        try await self.run(Swiftly.createDefaultContext())
+    }
+
+    mutating func run(_ ctx: SwiftlyCoreContext) async throws {
+        try validateSwiftly(ctx)
+
+        var config = try Config.load(ctx)
+        let toolchainVersion = try await Install.determineToolchainVersion(
+            ctx,
+            version: nil,
+            config: &config
+        )
+
+        let _ = try await Install.setupProxies(
+            ctx,
+            version: toolchainVersion,
+            verbose: self.root.verbose,
+            assumeYes: self.root.assumeYes
+        )
+    }
+}

Sources/Swiftly/Swiftly.swift

@@ -33,6 +33,8 @@ public struct Swiftly: SwiftlyCommand {
             Init.self,
             SelfUpdate.self,
             Run.self,
+            Link.self,
+            Unlink.self
         ]
     )
 

Sources/Swiftly/Unlink.swift

@@ -0,0 +1,50 @@
+import ArgumentParser
+import SwiftlyCore
+import Foundation
+
+struct Unlink: SwiftlyCommand {
+    public static let configuration = CommandConfiguration(
+        abstract: "Unlinks swiftly so it no longer manages the active toolchain."
+    )
+
+    @Argument(help: ArgumentHelp(
+        "Unlinks swiftly, allowing the system default toolchain to be used.",
+        discussion: """
+
+        Unlinks swiftly until swiftly is linked again with:
+
+            $ swiftly link
+        """
+    ))
+    var toolchainSelector: String?
+
+    @OptionGroup var root: GlobalOptions
+
+    mutating func run() async throws {
+        try await self.run(Swiftly.createDefaultContext())
+    }
+
+    mutating func run(_ ctx: SwiftlyCoreContext) async throws {
+        try validateSwiftly(ctx)
+
+        if let proxyTo = try? Swiftly.currentPlatform.findSwiftlyBin(ctx) {
+            let swiftlyBinDir = Swiftly.currentPlatform.swiftlyBinDir(ctx)
+            let swiftlyBinDirContents = (try? FileManager.default.contentsOfDirectory(atPath: swiftlyBinDir.path)) ?? [String]()
+
+            let existingProxies = swiftlyBinDirContents.filter { bin in
+                do {
+                    let linkTarget = try FileManager.default.destinationOfSymbolicLink(atPath: swiftlyBinDir.appendingPathComponent(bin).path)
+                    return linkTarget == proxyTo
+                } catch { return false }
+            }
+
+            for p in existingProxies {
+                let proxy = Swiftly.currentPlatform.swiftlyBinDir(ctx).appendingPathComponent(p)
+
+                if proxy.fileExists() {
+                    try FileManager.default.removeItem(at: proxy)
+                }
+            }
+        }
+    }
+}

Tests/SwiftlyTests/LinkTests.swift

@@ -0,0 +1,41 @@
+import Foundation
+@testable import Swiftly
+@testable import SwiftlyCore
+import Testing
+
+@Suite struct LinkTests {
+    /// Tests that enabling swiftly results in swiftlyBinDir being populated with symlinks.
+    @Test func testLink() async throws {
+        try await SwiftlyTests.withTestHome {
+            let fm = FileManager.default
+            let swiftlyBinDir = Swiftly.currentPlatform.swiftlyBinDir(SwiftlyTests.ctx)
+            let swiftlyBinaryPath = swiftlyBinDir.appendingPathComponent("swiftly")
+            let swiftVersionFilename = SwiftlyTests.ctx.currentDirectory.appendingPathComponent(".swift-version")
+
+            // Configure a mock toolchain
+            let versionString = "6.0.3"
+            let toolchainVersion = try ToolchainVersion(parsing: versionString)
+            try versionString.write(to: swiftVersionFilename, atomically: true, encoding: .utf8)
+
+            // And start creating a mock folder structure for that toolchain.
+            try "swiftly binary".write(to: swiftlyBinaryPath, atomically: true, encoding: .utf8)
+
+            let toolchainDir = Swiftly.currentPlatform.findToolchainLocation(SwiftlyTests.ctx, toolchainVersion)
+                .appendingPathComponent("usr")
+                .appendingPathComponent("bin")
+            try fm.createDirectory(at: toolchainDir, withIntermediateDirectories: true)
+
+            let proxies = ["swift-build", "swift-test", "swift-run"]
+            for proxy in proxies {
+                let proxyPath = toolchainDir.appendingPathComponent(proxy)
+                try fm.createSymbolicLink(at: proxyPath, withDestinationURL: swiftlyBinaryPath)
+            }
+
+            _ = try await SwiftlyTests.runWithMockedIO(Link.self, ["link"])
+
+            let enabledSwiftlyBinDirContents = try fm.contentsOfDirectory(atPath: swiftlyBinDir.path).sorted()
+            let expectedProxies = (["swiftly"] + proxies).sorted()
+            #expect(enabledSwiftlyBinDirContents == expectedProxies)
+        }
+    }
+}

Tests/SwiftlyTests/UnlinkTests.swift

@@ -0,0 +1,27 @@
+import Foundation
+@testable import Swiftly
+@testable import SwiftlyCore
+import Testing
+
+@Suite struct UnlinkTests {
+    /// Tests that disabling swiftly results in swiftlyBinDir with no symlinks to toolchain binaries in it.
+    @Test func testUnlink() async throws {
+    try await SwiftlyTests.withTestHome {
+            let fm = FileManager.default
+            let swiftlyBinDir = Swiftly.currentPlatform.swiftlyBinDir(SwiftlyTests.ctx)
+            let swiftlyBinaryPath = swiftlyBinDir.appendingPathComponent("swiftly")
+            try "mockBinary".write(to: swiftlyBinaryPath, atomically: true, encoding: .utf8)
+
+            let proxies = ["swift-build", "swift-test", "swift-run"]
+            for proxy in proxies {
+                let proxyPath = swiftlyBinDir.appendingPathComponent(proxy)
+                try fm.createSymbolicLink(at: proxyPath, withDestinationURL: swiftlyBinaryPath)
+            }
+
+            _ = try await SwiftlyTests.runWithMockedIO(Unlink.self, ["unlink"])
+
+            let disabledSwiftlyBinDirContents = try fm.contentsOfDirectory(atPath: swiftlyBinDir.path)
+            #expect(disabledSwiftlyBinDirContents == ["swiftly"])
+        }
+    }
+}