Build swiftly release cleanup (#335)

Remove the copies of bits of SwiftlyCore functionality in the build-swiftly-release script:

runProgramEnv|Output
SwiftlyRelease/SwiftlyPlatform (for JSON decoding from the REST endpoint)
curl
Remove the curl dependency from the release script using the AsyncHTTPClient instead
to download libarchive.

Migrate the release script from URLs and FileManager to the new FilePath and FileSystem
component for improved readability, and type safety.

Author: cmcgee1024

Sources/SwiftlyCore/Commands.swift

@@ -922,7 +922,7 @@ extension SystemCommand {
                 case arch(String)
                 case configuration(String)
                 case packagePath(FilePath)
-                case pkgConfigPath(String)
+                case pkgConfigPath(FilePath)
                 case product(String)
                 case swiftSdk(String)
                 case staticSwiftStdlib

Sources/SwiftlyCore/ModeledCommandLine.swift

@@ -15,6 +15,12 @@ public struct Configuration: Sendable {
     public var arguments: Arguments
     /// The environment to use when running the executable.
     public var environment: Environment
+
+    public init(executable: Executable, arguments: Arguments, environment: Environment) {
+        self.executable = executable
+        self.arguments = arguments
+        self.environment = environment
+    }
 }
 
 public struct Executable: Sendable, Hashable {

Sources/SwiftlyWebsiteAPI/openapi.yaml

@@ -284,6 +284,9 @@ components:
           items:
             $ref: '#/components/schemas/Architecture'
           description: List of supported architectures.
+        checksum:
+          type: string
+          description: SHA-256 Checksum of the static SDK, if this platform is the static SDK.
       required:
         - name
         - platform

Sources/TestSwiftly/TestSwiftly.swift

@@ -17,8 +17,60 @@ let currentPlatform: Platform = MacOS.currentPlatform
 #error("Unsupported platform")
 #endif
 
+typealias sys = SwiftlyCore.SystemCommand
 typealias fs = SwiftlyCore.FileSystem
 
+func sh(executable: Executable = ShCommand.defaultExecutable, _ options: ShCommand.Option...) -> ShCommand {
+    sh(executable: executable, options)
+}
+
+func sh(executable: Executable = ShCommand.defaultExecutable, _ options: [ShCommand.Option]) -> ShCommand {
+    ShCommand(executable: executable, options)
+}
+
+struct ShCommand {
+    static var defaultExecutable: Executable { .name("sh") }
+
+    var executable: Executable
+
+    var options: [Option]
+
+    enum Option {
+        case login
+        case command(String)
+
+        func args() -> [String] {
+            switch self {
+            case .login:
+                ["-l"]
+            case let .command(command):
+                ["-c", command]
+            }
+        }
+    }
+
+    init(executable: Executable, _ options: [Option]) {
+        self.executable = executable
+        self.options = options
+    }
+
+    func config() -> Configuration {
+        var args: [String] = []
+
+        for opt in self.options {
+            args.append(contentsOf: opt.args())
+        }
+
+        return Configuration(
+            executable: self.executable,
+            arguments: Arguments(args),
+            environment: .inherit
+        )
+    }
+}
+
+extension ShCommand: Runnable {}
+
 @main
 struct TestSwiftly: AsyncParsableCommand {
     @Flag(name: [.customShort("y"), .long], help: "Disable confirmation prompts by assuming 'yes'")
@@ -40,11 +92,13 @@ struct TestSwiftly: AsyncParsableCommand {
             Foundation.exit(2)
         }
 
+        guard case let swiftlyArchive = FilePath(swiftlyArchive) else { fatalError("") }
+
         print("Extracting swiftly release")
 #if os(Linux)
-        try currentPlatform.runProgram("tar", "-zxvf", swiftlyArchive, quiet: false)
+        try await sys.tar().extract(.verbose, .compressed, .archive(swiftlyArchive)).run(currentPlatform, quiet: false)
 #elseif os(macOS)
-        try currentPlatform.runProgram("installer", "-pkg", swiftlyArchive, "-target", "CurrentUserHomeDirectory", quiet: false)
+        try await sys.installer(.verbose, pkg: swiftlyArchive, target: "CurrentUserHomeDirectory").run(currentPlatform, quiet: false)
 #endif
 
 #if os(Linux)
@@ -54,7 +108,7 @@ struct TestSwiftly: AsyncParsableCommand {
 #endif
 
         var env = ProcessInfo.processInfo.environment
-        let shell = try await currentPlatform.getShell()
+        let shell = FilePath(try await currentPlatform.getShell())
         var customLoc: FilePath?
 
         if self.customLocation {
@@ -66,37 +120,39 @@ struct TestSwiftly: AsyncParsableCommand {
             env["SWIFTLY_TOOLCHAINS_DIR"] = (customLoc! / "toolchains").string
 
             try currentPlatform.runProgram(extractedSwiftly.string, "init", "--assume-yes", "--no-modify-profile", "--skip-install", quiet: false, env: env)
-            try currentPlatform.runProgram(shell, "-l", "-c", ". \"\(customLoc! / "env.sh")\" && swiftly install --assume-yes latest --post-install-file=./post-install.sh", quiet: false, env: env)
+            try await sh(executable: .path(shell), .login, .command(". \"\(customLoc! / "env.sh")\" && swiftly install --assume-yes latest --post-install-file=./post-install.sh")).run(currentPlatform, env: env, quiet: false)
         } else {
             print("Installing swiftly to the default location.")
             // Setting this environment helps to ensure that the profile gets sourced with bash, even if it is not in an interactive shell
-            if shell.hasSuffix("bash") {
+            if shell.ends(with: "bash") {
                 env["BASH_ENV"] = (fs.home / ".profile").string
-            } else if shell.hasSuffix("zsh") {
+            } else if shell.ends(with: "zsh") {
                 env["ZDOTDIR"] = fs.home.string
-            } else if shell.hasSuffix("fish") {
+            } else if shell.ends(with: "fish") {
                 env["XDG_CONFIG_HOME"] = (fs.home / ".config").string
             }
 
             try currentPlatform.runProgram(extractedSwiftly.string, "init", "--assume-yes", "--skip-install", quiet: false, env: env)
-            try currentPlatform.runProgram(shell, "-l", "-c", "swiftly install --assume-yes latest --post-install-file=./post-install.sh", quiet: false, env: env)
+            try await sh(executable: .path(shell), .login, .command("swiftly install --assume-yes latest --post-install-file=./post-install.sh")).run(currentPlatform, env: env, quiet: false)
         }
 
         var swiftReady = false
 
-        if NSUserName() == "root" && FileManager.default.fileExists(atPath: "./post-install.sh") {
-            try currentPlatform.runProgram(shell, "./post-install.sh", quiet: false)
+        if NSUserName() == "root" {
+            if try await fs.exists(atPath: "./post-install.sh") {
+                try currentPlatform.runProgram(shell.string, "./post-install.sh", quiet: false)
+            }
             swiftReady = true
-        } else if FileManager.default.fileExists(atPath: "./post-install.sh") {
+        } else if try await fs.exists(atPath: "./post-install.sh") {
             print("WARNING: not running as root, so skipping the post installation steps and final swift verification.")
         } else {
             swiftReady = true
         }
 
         if let customLoc = customLoc, swiftReady {
-            try currentPlatform.runProgram(shell, "-l", "-c", ". \"\(customLoc / "env.sh")\" && swift --version", quiet: false, env: env)
+            try await sh(executable: .path(shell), .login, .command(". \"\(customLoc / "env.sh")\" && swift --version")).run(currentPlatform, env: env, quiet: false)
         } else if swiftReady {
-            try currentPlatform.runProgram(shell, "-l", "-c", "swift --version", quiet: false, env: env)
+            try await sh(executable: .path(shell), .login, .command("swift --version")).run(currentPlatform, env: env, quiet: false)
         }
     }
 }