feat: adds apfs and noexec (#46)

* feat: adds apfs and noexec

* feat: adds better task handling and ejection

* fix: only use helper for tmpfs

* feat: mountpoint and add button on autocreate fixes #35

* feat: adds disk size validation fixes #36

* feat: tmpdisk cli

Author: imothee

Common/Constants.swift

@@ -18,4 +18,5 @@ enum TmpDiskError: Error {
     case failed
     case helperInvalidated
     case helperFailed
+    case inUse
 }

Common/DiskSizeManager.swift

@@ -0,0 +1,142 @@
+//
+//  DiskSizeManager.swift
+//  TmpDisk
+//
+//  Created on 06/04/25.
+//
+//  This file is part of TmpDisk.
+//
+//  TmpDisk is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  TmpDisk is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with TmpDisk.  If not, see <http://www.gnu.org/licenses/>.
+
+import Foundation
+import AppKit
+
+enum DiskSizeUnit: Int {
+    case mb = 0  // Megabytes
+    case gb = 1  // Gigabytes
+    
+    var displayName: String {
+        switch self {
+        case .mb:
+            return "MB"
+        case .gb:
+            return "GB"
+        }
+    }
+}
+
+class DiskSizeManager {
+    static let shared = DiskSizeManager()
+    
+    // MARK: - RAM Size Properties
+    
+    /// Total physical RAM in megabytes
+    var totalRamSizeMB: Double {
+        return Double(ProcessInfo.init().physicalMemory) / 1024 / 1024
+    }
+    
+    /// Maximum allowed size for TmpFS volumes (50% of RAM) in megabytes
+    var maxTmpFSSizeMB: Double {
+        return totalRamSizeMB * 0.5
+    }
+    
+    // MARK: - RAM Size Percentages
+    
+    /// Get RAM size for a specific percentage in MB
+    func ramSizeForPercentage(_ percentage: Double) -> Double {
+        return totalRamSizeMB * percentage
+    }
+    
+    /// Get the common RAM size percentages (10%, 25%, 50%, 75%)
+    func commonRamSizePercentages() -> [Double] {
+        return [0.1, 0.25, 0.5, 0.75]
+    }
+    
+    // MARK: - Unit Conversion
+    
+    /// Convert size from MB to GB
+    func convertMBtoGB(_ sizeMB: Double) -> Double {
+        return sizeMB / 1000.0
+    }
+    
+    /// Convert size from GB to MB
+    func convertGBtoMB(_ sizeGB: Double) -> Double {
+        return sizeGB * 1000.0
+    }
+    
+    /// Convert size between units
+    func convertSize(_ size: Double, from fromUnit: DiskSizeUnit, to toUnit: DiskSizeUnit) -> Double {
+        switch (fromUnit, toUnit) {
+        case (.mb, .gb):
+            return convertMBtoGB(size)
+        case (.gb, .mb):
+            return convertGBtoMB(size)
+        case (.mb, .mb):
+            return size
+        case (.gb, .gb):
+            return size
+        }
+    }
+    
+    // MARK: - String Formatting
+    
+    /// Format size in MB as a string in the given unit
+    func formatSize(_ sizeMB: Double, in unit: DiskSizeUnit) -> String {
+        switch unit {
+        case .mb:
+            return String(Int(sizeMB))
+        case .gb:
+            return String(format: "%.2f", convertMBtoGB(sizeMB))
+        }
+    }
+    
+    // MARK: - Validation
+    
+    /// Validates if the size is within the TmpFS limit
+    /// - Parameters:
+    ///   - size: The size to validate
+    ///   - unit: The unit of the provided size
+    /// - Returns: A tuple containing (isValid, correctedSize)
+    func validateDiskSize(_ size: Double, in unit: DiskSizeUnit, isTmpFS: Bool = false) -> (isValid: Bool, correctedSizeMB: Double) {
+        let sizeInMB = unit == .mb ? size : convertGBtoMB(size)
+        
+        if isTmpFS && sizeInMB > maxTmpFSSizeMB {
+            return (false, maxTmpFSSizeMB)
+        } else if sizeInMB < 0 {
+            return (false, 1)
+        } else if sizeInMB > ( totalRamSizeMB - 2048) {
+            // Hold back at least 2GB
+            return (false, totalRamSizeMB - 2048)
+        }
+        
+        return (true, sizeInMB)
+    }
+    
+    /// Shows a warning alert about the TmpFS size limitation
+    func showTmpFSSizeWarning() {
+        let alert = NSAlert()
+        alert.messageText = NSLocalizedString("TmpFS volumes are limited to 50% of RAM. Setting to maximum allowed value.", comment: "")
+        alert.alertStyle = .informational
+        alert.addButton(withTitle: "OK")
+        alert.runModal()
+    }
+    
+    func showInsufficientRamWarning() {
+        let alert = NSAlert()
+        alert.messageText = NSLocalizedString("Insufficient RAM to allocate to TmpDisk. Please reduce the size.", comment: "")
+        alert.alertStyle = .warning
+        alert.addButton(withTitle: "OK")
+        alert.runModal()
+    }
+}

Common/FileSystemManager.swift

@@ -0,0 +1,85 @@
+//
+//  FileSystemManager.swift
+//  TmpDisk
+//
+//  Created by Tim on 4/3/25.
+//
+//  This file is part of TmpDisk.
+//
+//  TmpDisk is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  TmpDisk is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with TmpDisk.  If not, see <http://www.gnu.org/licenses/>.
+
+import Foundation
+
+struct FileSystemType: Identifiable, Hashable {
+    let id = UUID()
+    let name: String
+    let description: String
+    
+    func hash(into hasher: inout Hasher) {
+        hasher.combine(name)
+    }
+    
+    static func == (lhs: FileSystemType, rhs: FileSystemType) -> Bool {
+        return lhs.name == rhs.name
+    }
+}
+
+class FileSystemManager {
+    // All filesystem types with descriptions
+    private static let allFileSystems: [FileSystemType] = [
+        FileSystemType(name: "APFS", description: "Apple File System - Suggested"),
+        FileSystemType(name: "APFSX", description: "Apple File System (Case Sensitive)"),
+        FileSystemType(name: "HFS+", description: "Mac OS Extended - Legacy"),
+        FileSystemType(name: "TMPFS", description: "TmpFS - Requires Admin or TmpDisk Helper"),
+        FileSystemType(name: "HFSX", description: "Mac OS Extended (Case-sensitive)"),
+        FileSystemType(name: "JHFS+", description: "Mac OS Extended (Journaled)"),
+        FileSystemType(name: "JHFSX", description: "Mac OS Extended (Case-sensitive, Journaled)"),
+    ]
+    
+    // Get filesystem types appropriate for the current OS version
+    static func availableFileSystems() -> [FileSystemType] {
+        var available = allFileSystems
+        
+        if #available(macOS 10.13, *) {
+            // Keep APFS for macOS 10.13+ (High Sierra and later)
+        } else {
+            // Remove APFS from available options for earlier macOS versions
+            available.removeAll { $0.name == "APFS" || $0.name == "APFSX" }
+        }
+        
+        return available
+    }
+    
+    // Get the default FS
+    static func defaultFileSystemName() -> String {
+        return self.availableFileSystems().first!.name
+    }
+    
+    // Get the descriptions of avaialable file systems
+    static func availableFileSystemDescriptions() -> [String] {
+        return availableFileSystems().map(\.self.description)
+    }
+    
+    static func isTmpFS(_ fileSystemName: String) -> Bool {
+        return fileSystemName == "TMPFS"
+    }
+    
+    static func isAPFS(_ fileSystemName: String) -> Bool {
+        return fileSystemName == "APFS" || fileSystemName == "APFSX"
+    }
+    
+    static func description(for fileSystemName: String) -> String? {
+        return availableFileSystems().first(where: { $0.name == fileSystemName })?.description
+    }
+}

Common/Protocols.swift

@@ -9,5 +9,6 @@ import Foundation
 
 @objc protocol TmpDiskCreator {
     func createTmpDisk(_ command: String, onCreate: @escaping (Bool) -> Void)
+    func ejectTmpDisk(_ command: String, onEject: @escaping (Int32) -> Void)
     func uninstall()
 }

Common/TmpDiskVolume.swift

@@ -6,22 +6,89 @@
 //
 
 import Foundation
+import AppKit
 
 struct TmpDiskVolume: Hashable, Codable {
     var name: String = ""
     var size: Int = 16
     var autoCreate: Bool = false
+    var fileSystem: String
     var indexed: Bool = false
+    var noExec: Bool = false
     var hidden: Bool = false
-    var tmpFs: Bool = false
-    var caseSensitive: Bool = false
-    var journaled: Bool = false
     var warnOnEject: Bool = false
     var folders: [String] = []
     var icon: String?
+    var mountPoint: String?
+    
+    init() {
+        self.fileSystem = FileSystemManager.defaultFileSystemName()
+    }
+    
+    init(name: String, size: Int, fileSystem: String? = nil) {
+        self.name = name
+        self.size = size
+        self.fileSystem = fileSystem ?? FileSystemManager.defaultFileSystemName()
+    }
+
+    
+    init?(from dictionary: Dictionary<String, Any>) {
+        guard let name = dictionary["name"] as? String,
+              let size = dictionary["size"] as? Int,
+              let indexed = dictionary["indexed"] as? Bool,
+              let hidden = dictionary["hidden"] as? Bool
+        else { return nil }
+        
+        let warnOnEject = dictionary["warnOnEject"] as? Bool ?? false
+        let folders = dictionary["folders"] as? [String] ?? []
+        let icon = dictionary["icon"] as? String
+        let noExec = dictionary["noExec"] as? Bool ?? false
+        let mountPoint = dictionary["mountPoint"] as? String
+        
+        let fileSystem: String
+        
+        if let fs = dictionary["fileSystem"] as? String {
+            fileSystem = fs
+        } else {
+            let tmpFs = dictionary["tmpFs"] as? Bool
+            let caseSensitive = dictionary["caseSensitive"] as? Bool
+            let journaled = dictionary["journaled"] as? Bool
+            
+            // We're going to use HSF+ for legacy tmpdisks
+            if tmpFs ?? false {
+                fileSystem = "TMPFS"
+            } else if caseSensitive ?? false && journaled ?? false {
+                fileSystem = "JHFSX"
+            } else if caseSensitive ?? false {
+                fileSystem = "HFSX"
+            } else if journaled ?? false {
+                fileSystem = "JHFS+"
+            } else {
+                fileSystem = "HFS+"
+            }
+        }
+        
+        self.name = name
+        self.size = size
+        self.autoCreate = true
+        self.fileSystem = fileSystem
+        self.indexed = indexed
+        self.hidden = hidden
+        self.noExec = noExec
+        self.warnOnEject = warnOnEject
+        self.folders = folders
+        if let icon = icon, icon != "" {
+            self.icon = icon
+        }
+        if let mountPoint = mountPoint, mountPoint != "" {
+            self.mountPoint = mountPoint
+        }
+    }
 
     func path() -> String {
-        if tmpFs {
+        if let mountPoint = self.mountPoint {
+            return mountPoint
+        } else if FileSystemManager.isTmpFS(fileSystem) {
             return "\(TmpDiskManager.rootFolder)/\(name)"
         }
         return "/Volumes/\(name)"
@@ -37,12 +104,12 @@ struct TmpDiskVolume: Hashable, Codable {
             "size": size,
             "indexed": indexed,
             "hidden": hidden,
-            "tmpFs": tmpFs,
-            "caseSensitive": caseSensitive,
-            "journaled": journaled,
+            "filesystem": fileSystem,
+            "noExec": noExec,
             "warnOnEject": warnOnEject,
             "folders": folders,
             "icon": icon ?? "",
+            "mountPoint": mountPoint ?? ""
         ]
     }
 
@@ -56,4 +123,14 @@ struct TmpDiskVolume: Hashable, Codable {
         }
         return false
     }
+    
+    func isMounted() -> Bool {
+        let mountPoint = self.path()
+        if let mountedVolumes = FileManager.default.mountedVolumeURLs(includingResourceValuesForKeys: nil) {
+            let mountedPaths = mountedVolumes.map { $0.path }
+            return mountedPaths.contains { $0 == mountPoint }
+        }
+        
+        return false
+    }
 }