import Foundation package struct TemporaryDirectory: ~Copyable { private static let debugTmp = ProcessInfo.processInfo.environment["XTL_DEBUG_TMP"] != nil private var shouldDelete: Bool package let url: URL /// Prepares a fresh tmpdir root. /// /// Optional, but try calling this at launch to clean up old resources. package static func prepare() { _ = TemporaryDirectoryRoot.shared } /// Creates a temporary directory where `lastPathComponent` is exactly `name`. /// /// The directory is deleted on deinit or (if the object never deinits) on next launch. /// To save the contents, move them elsewhere with ``persist(at:)``. package init(name: String) throws { do { let basename = name.replacingOccurrences(of: ".", with: "_") self.url = try TemporaryDirectoryRoot.shared.url // ensures uniqueness .appendingPathComponent("tmp-\(basename)-\(UUID().uuidString)") .appendingPathComponent(name, isDirectory: true) self.shouldDelete = true } catch { // non-copyable types can't be partially initialized so we need a stub value self.url = URL(fileURLWithPath: "") self.shouldDelete = false throw error } try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true) if Self.debugTmp { stderrPrint("Created TemporaryDirectory: \(url.path)") } } private func _delete() { guard !Self.debugTmp else { return } try? FileManager.default.removeItem(at: url) } package consuming func persist(at location: URL) throws { try FileManager.default.moveItem(at: url, to: location) // we do this after moving, so that if the move fails we clean up shouldDelete = false } deinit { if shouldDelete { _delete() } } } private struct TemporaryDirectoryRoot { static let shared = TemporaryDirectoryRoot() private let _url: Result var url: URL { get throws(Errors) { try _url.get() } } private init() { let url: URL let env = ProcessInfo.processInfo.environment if let tmpdir = env["XTL_TMPDIR"] ?? env["TMPDIR"] { url = URL(fileURLWithPath: tmpdir).appendingPathComponent("sh.xtool") } else { #if os(Linux) // On Linux, /tmp is commonly a tmpfs mount while ~/.swiftpm lives on ext4. // Foundation's FileManager.copyItem uses sendfile(2) internally, which returns // EINVAL when copying between different filesystem types (e.g. tmpfs → ext4). // This causes `swift sdk install` to fail on distros like Linux Mint (#181). // Using a cache dir on the home filesystem avoids the cross-fs copy entirely. let xdgCache = env["XDG_CACHE_HOME"].map { URL(fileURLWithPath: $0) } ?? FileManager.default.homeDirectoryForCurrentUser.appendingPathComponent(".cache") url = xdgCache.appendingPathComponent("xtool") #else url = FileManager.default.temporaryDirectory.appendingPathComponent("sh.xtool") #endif } try? FileManager.default.removeItem(at: url) do { try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true) } catch { self._url = .failure(Errors.tmpdirCreationFailed(url, error)) return } self._url = .success(url) } enum Errors: Error, CustomStringConvertible { case tmpdirCreationFailed(URL, Error) var description: String { switch self { case let .tmpdirCreationFailed(url, error): "Could not create temporary directory at '\(url.path)': \(error)" } } } }