Model pkgutil

Author: cmcgee1024

Sources/MacOSPlatform/MacOS.swift

@@ -86,7 +86,7 @@ public struct MacOS: Platform {
 
             await ctx.print("Checking package signature...")
             do {
-                try runProgram("pkgutil", "--check-signature", "\(tmpFile)", quiet: !verbose)
+                try await sys.pkgutil().checkSignature(pkgPath: tmpFile).run(self, quiet: !verbose)
             } catch {
                 // If this is not a test that uses mocked toolchains then we must throw this error and abort installation
                 guard ctx.mockedHomeDir != nil else {
@@ -96,7 +96,7 @@ public struct MacOS: Platform {
                 // We permit the signature verification to fail during testing
                 await ctx.print("Signature verification failed, which is allowable during testing with mocked toolchains")
             }
-            try runProgram("pkgutil", "--verbose", "--expand", "\(tmpFile)", "\(tmpDir)", quiet: !verbose)
+            try await sys.pkgutil(.verbose).expand(pkgPath: tmpFile, dirPath: tmpDir).run(self, quiet: !verbose)
 
             // There's a slight difference in the location of the special Payload file between official swift packages
             // and the ones that are mocked here in the test framework.
@@ -120,15 +120,15 @@ public struct MacOS: Platform {
         if ctx.mockedHomeDir == nil {
             await ctx.print("Extracting the swiftly package...")
             try runProgram("installer", "-pkg", "\(archive)", "-target", "CurrentUserHomeDirectory")
-            try? runProgram("pkgutil", "--volume", "\(userHomeDir)", "--forget", "org.swift.swiftly")
+            try? await sys.pkgutil(.volume(userHomeDir)).forget(packageId: "org.swift.swiftly").run(self)
         } else {
             let installDir = userHomeDir / ".swiftly"
             try await fs.mkdir(.parents, atPath: installDir)
 
             // In the case of a mock for testing purposes we won't use the installer, perferring a manual process because
             //  the installer will not install to an arbitrary path, only a volume or user home directory.
             let tmpDir = fs.mktemp()
-            try runProgram("pkgutil", "--expand", "\(archive)", "\(tmpDir)")
+            try await sys.pkgutil().expand(pkgPath: archive, dirPath: tmpDir).run(self)
 
             // There's a slight difference in the location of the special Payload file between official swift packages
             // and the ones that are mocked here in the test framework.
@@ -161,9 +161,7 @@ public struct MacOS: Platform {
 
         try await fs.remove(atPath: toolchainDir)
 
-        try? runProgram(
-            "pkgutil", "--volume", "\(fs.home)", "--forget", pkgInfo.CFBundleIdentifier, quiet: !verbose
-        )
+        try? await sys.pkgutil(.volume(fs.home)).forget(packageId: pkgInfo.CFBundleIdentifier).run(self, quiet: !verbose)
     }
 
     public func getExecutableName() -> String {

Sources/SwiftlyCore/Commands.swift

@@ -1218,6 +1218,8 @@ extension SystemCommand.ProductBuildCommand.SynthesizeCommand: Runnable {}
 extension SystemCommand.ProductBuildCommand.DistributionCommand: Runnable {}
 
 extension SystemCommand {
+    // OpenPGP encryption and signing tool
+    // See gpg(1) for more information.
     public static func gpg(executable: Executable = GpgCommand.defaultExecutable) -> GpgCommand {
         GpgCommand(executable: executable)
     }
@@ -1313,3 +1315,154 @@ extension SystemCommand {
 
 extension SystemCommand.GpgCommand.ImportCommand: Runnable {}
 extension SystemCommand.GpgCommand.VerifyCommand: Runnable {}
+
+extension SystemCommand {
+    // Query and manipulate macOS Installer packages and receipts.
+    // See pkgutil(1) for more information.
+    public static func pkgutil(executable: Executable = PkgutilCommand.defaultExecutable, _ options: PkgutilCommand.Option...) -> PkgutilCommand {
+        Self.pkgutil(executable: executable, options)
+    }
+
+    // Query and manipulate macOS Installer packages and receipts.
+    // See pkgutil(1) for more information.
+    public static func pkgutil(executable: Executable = PkgutilCommand.defaultExecutable, _ options: [PkgutilCommand.Option]) -> PkgutilCommand {
+        PkgutilCommand(executable: executable, options)
+    }
+
+    public struct PkgutilCommand {
+        public static var defaultExecutable: Executable { .name("pkgutil") }
+
+        public var executable: Executable
+
+        public var options: [Option]
+
+        public enum Option {
+            case verbose
+            case volume(FilePath)
+
+            public func args() -> [String] {
+                switch self {
+                case .verbose:
+                    ["--verbose"]
+                case let .volume(volume):
+                    ["--volume", "\(volume)"]
+                }
+            }
+        }
+
+        public init(executable: Executable, _ options: [Option]) {
+            self.executable = executable
+            self.options = options
+        }
+
+        public 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
+            )
+        }
+
+        public func checkSignature(pkgPath: FilePath) -> CheckSignatureCommand {
+            CheckSignatureCommand(self, pkgPath: pkgPath)
+        }
+
+        public struct CheckSignatureCommand {
+            public var pkgutil: PkgutilCommand
+
+            public var pkgPath: FilePath
+
+            public init(_ pkgutil: PkgutilCommand, pkgPath: FilePath) {
+                self.pkgutil = pkgutil
+                self.pkgPath = pkgPath
+            }
+
+            public func config() -> Configuration {
+                var c: Configuration = self.pkgutil.config()
+
+                var args = c.arguments.storage.map(\.description)
+
+                args.append("--check-signature")
+
+                args.append("\(self.pkgPath)")
+
+                c.arguments = .init(args)
+
+                return c
+            }
+        }
+
+        public func expand(pkgPath: FilePath, dirPath: FilePath) -> ExpandCommand {
+            ExpandCommand(self, pkgPath: pkgPath, dirPath: dirPath)
+        }
+
+        public struct ExpandCommand {
+            public var pkgutil: PkgutilCommand
+
+            public var pkgPath: FilePath
+
+            public var dirPath: FilePath
+
+            public init(_ pkgutil: PkgutilCommand, pkgPath: FilePath, dirPath: FilePath) {
+                self.pkgutil = pkgutil
+                self.pkgPath = pkgPath
+                self.dirPath = dirPath
+            }
+
+            public func config() -> Configuration {
+                var c: Configuration = self.pkgutil.config()
+
+                var args = c.arguments.storage.map(\.description)
+
+                args.append("--expand")
+
+                args.append("\(self.pkgPath)")
+
+                args.append("\(self.dirPath)")
+
+                c.arguments = .init(args)
+
+                return c
+            }
+        }
+
+        public func forget(packageId: String) -> ForgetCommand {
+            ForgetCommand(self, packageId: packageId)
+        }
+
+        public struct ForgetCommand {
+            public var pkgutil: PkgutilCommand
+
+            public var packageId: String
+
+            public init(_ pkgutil: PkgutilCommand, packageId: String) {
+                self.pkgutil = pkgutil
+                self.packageId = packageId
+            }
+
+            public func config() -> Configuration {
+                var c: Configuration = self.pkgutil.config()
+
+                var args = c.arguments.storage.map(\.description)
+
+                args.append("--forget")
+
+                args.append("\(self.packageId)")
+
+                c.arguments = .init(args)
+
+                return c
+            }
+        }
+    }
+}
+
+extension SystemCommand.PkgutilCommand.CheckSignatureCommand: Runnable {}
+extension SystemCommand.PkgutilCommand.ExpandCommand: Runnable {}
+extension SystemCommand.PkgutilCommand.ForgetCommand: Runnable {}

Tests/SwiftlyTests/CommandLineTests.swift

@@ -228,4 +228,15 @@ public struct CommandLineTests {
         config = sys.gpg().verify(detachedSignature: FilePath("file.sig"), signedData: FilePath("file")).config()
         #expect(String(describing: config) == "gpg --verify file.sig file")
     }
+
+    @Test func testPkgutil() async throws {
+        var config = sys.pkgutil(.verbose).checkSignature(pkgPath: FilePath("path/to/my.pkg")).config()
+        #expect(String(describing: config) == "pkgutil --verbose --check-signature path/to/my.pkg")
+
+        config = sys.pkgutil(.verbose).expand(pkgPath: FilePath("path/to/my.pkg"), dirPath: FilePath("expand/to/here")).config()
+        #expect(String(describing: config) == "pkgutil --verbose --expand path/to/my.pkg expand/to/here")
+
+        config = sys.pkgutil(.volume("CurrentUserHomeDirectory")).forget(packageId: "com.example.pkg").config()
+        #expect(String(describing: config) == "pkgutil --volume CurrentUserHomeDirectory --forget com.example.pkg")
+    }
 }