Add GitHub update checker and installer

2026-03-30 23:02:42 +08:00
parent 6b790c7a80
commit 63d1d0fe3f
15 changed files with 1663 additions and 2 deletions
@@ -0,0 +1,181 @@
+#if os(macOS)
+
+    import Foundation
+    import Security
+
+    public enum PKGInstaller {
+        private static let installerExitStatusMarker = "__PKG_INSTALLER_EXIT_STATUS__="
+
+        private typealias ExecuteWithPrivilegesFunc = @convention(c) (
+            AuthorizationRef,
+            UnsafePointer<CChar>,
+            AuthorizationFlags,
+            UnsafePointer<UnsafeMutablePointer<CChar>?>,
+            UnsafeMutablePointer<UnsafeMutablePointer<FILE>?>?
+        ) -> OSStatus
+
+        public static func authorize() throws -> AuthorizationRef {
+            var authRef: AuthorizationRef?
+            var status = AuthorizationCreate(nil, nil, [], &authRef)
+            guard status == errAuthorizationSuccess, let authRef else {
+                throw PKGInstallerError.authorizationFailed
+            }
+
+            let rightName = kAuthorizationRightExecute
+            var item = AuthorizationItem(name: rightName, valueLength: 0, value: nil, flags: 0)
+            withUnsafeMutablePointer(to: &item) { itemPtr in
+                var rights = AuthorizationRights(count: 1, items: itemPtr)
+                let flags: AuthorizationFlags = [.interactionAllowed, .extendRights, .preAuthorize]
+                status = AuthorizationCopyRights(authRef, &rights, nil, flags, nil)
+            }
+            guard status == errAuthorizationSuccess else {
+                if status == errAuthorizationCanceled {
+                    AuthorizationFree(authRef, [])
+                    throw PKGInstallerError.authorizationCancelled
+                }
+                AuthorizationFree(authRef, [])
+                throw PKGInstallerError.authorizationFailed
+            }
+
+            return authRef
+        }
+
+        public static func install(pkgPath: String, authorization authRef: AuthorizationRef) throws {
+            defer { AuthorizationFree(authRef, []) }
+
+            guard let sym = dlsym(UnsafeMutableRawPointer(bitPattern: -2), "AuthorizationExecuteWithPrivileges") else {
+                throw PKGInstallerError.authorizationFailed
+            }
+            let executeWithPrivileges = unsafeBitCast(sym, to: ExecuteWithPrivilegesFunc.self)
+
+            let escapedPkgPath = shellQuote(pkgPath)
+            let command = "/usr/sbin/installer -pkg \(escapedPkgPath) -target / 2>&1; status=$?; printf '\\n\(installerExitStatusMarker)%d\\n' \"$status\"; exit \"$status\""
+            let tool = "/bin/sh"
+            var cArgs: [UnsafeMutablePointer<CChar>?] = [
+                strdup("-c"), strdup(command), nil,
+            ]
+            defer { for i in 0 ..< cArgs.count - 1 {
+                free(cArgs[i])
+            } }
+
+            var pipe: UnsafeMutablePointer<FILE>?
+            let status = executeWithPrivileges(authRef, tool, [], &cArgs, &pipe)
+            guard status == errAuthorizationSuccess else {
+                throw PKGInstallerError.authorizationFailed
+            }
+
+            let output = pipe.map(readOutput(from:)) ?? ""
+            let (exitStatus, installerOutput) = parseInstallerOutput(output)
+            guard let exitStatus else {
+                throw PKGInstallerError.installationFailed(installerOutput.isEmpty ? "Installer exited without reporting a status" : installerOutput)
+            }
+            guard exitStatus == 0 else {
+                if installerOutput.isEmpty {
+                    throw PKGInstallerError.installationFailed("Installer failed with exit status \(exitStatus)")
+                }
+                throw PKGInstallerError.installationFailed(installerOutput)
+            }
+        }
+
+        public static func scheduleInstalledApplicationRelaunch() throws {
+            guard let appPath = findInstalledAppPath() else {
+                throw PKGInstallerError.relaunchFailed("Installed app not found in /Applications")
+            }
+
+            let escapedApp = appPath.replacingOccurrences(of: "'", with: "'\\''")
+            let processID = ProcessInfo.processInfo.processIdentifier
+            let command = "while kill -0 \(processID) 2>/dev/null; do sleep 1; done; open '\(escapedApp)' >/dev/null 2>&1"
+
+            let process = Process()
+            process.executableURL = URL(filePath: "/bin/sh")
+            process.arguments = ["-c", command]
+            if let nullHandle = FileHandle(forWritingAtPath: "/dev/null") {
+                process.standardOutput = nullHandle
+                process.standardError = nullHandle
+            }
+
+            do {
+                try process.run()
+            } catch {
+                throw PKGInstallerError.relaunchFailed(error.localizedDescription)
+            }
+        }
+
+        private static func findInstalledAppPath() -> String? {
+            if let bundleID = Bundle.main.bundleIdentifier,
+               let contents = try? FileManager.default.contentsOfDirectory(atPath: "/Applications")
+            {
+                for item in contents where item.hasSuffix(".app") {
+                    let path = "/Applications/\(item)"
+                    if let bundle = Bundle(path: path), bundle.bundleIdentifier == bundleID {
+                        return path
+                    }
+                }
+            }
+            let fallback = "/Applications/\(Bundle.main.bundleURL.lastPathComponent)"
+            if FileManager.default.fileExists(atPath: fallback) {
+                return fallback
+            }
+            return nil
+        }
+
+        private static func shellQuote(_ value: String) -> String {
+            "'\(value.replacingOccurrences(of: "'", with: "'\\''"))'"
+        }
+
+        private static func readOutput(from pipe: UnsafeMutablePointer<FILE>) -> String {
+            defer { fclose(pipe) }
+
+            var data = Data()
+            let bufferSize = 4096
+            let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: bufferSize)
+            defer { buffer.deallocate() }
+
+            while true {
+                let count = fread(buffer, 1, bufferSize, pipe)
+                if count > 0 {
+                    data.append(buffer, count: count)
+                }
+                if count < bufferSize {
+                    if feof(pipe) != 0 || ferror(pipe) != 0 {
+                        break
+                    }
+                }
+            }
+
+            return String(decoding: data, as: UTF8.self)
+        }
+
+        private static func parseInstallerOutput(_ output: String) -> (Int32?, String) {
+            let trimmedOutput = output.trimmingCharacters(in: .whitespacesAndNewlines)
+            guard let markerRange = output.range(of: installerExitStatusMarker, options: .backwards) else {
+                return (nil, trimmedOutput)
+            }
+
+            let statusText = output[markerRange.upperBound...].prefix { $0.isNumber || $0 == "-" }
+            let installerOutput = String(output[..<markerRange.lowerBound]).trimmingCharacters(in: .whitespacesAndNewlines)
+            return (Int32(String(statusText)), installerOutput)
+        }
+    }
+
+    public enum PKGInstallerError: LocalizedError {
+        case authorizationFailed
+        case authorizationCancelled
+        case installationFailed(String)
+        case relaunchFailed(String)
+
+        public var errorDescription: String? {
+            switch self {
+            case .authorizationFailed:
+                return "Authorization failed"
+            case .authorizationCancelled:
+                return "Authorization cancelled"
+            case let .installationFailed(message):
+                return message
+            case let .relaunchFailed(message):
+                return message
+            }
+        }
+    }
+
+#endif