macOS Sandbox Wrapper

SandboxDirectoryAccess.swift

import Foundation
import AppKit.NSOpenPanel

class SandboxDirectoryAccess {
    static let shared: SandboxDirectoryAccess = SandboxDirectoryAccess()
    private var bookmarks = [URL: Data]()

    init() {}

    func openFolderSelection(then handler: @escaping (URL?) -> Void) {
        let openPanel = NSOpenPanel()
        openPanel.allowsMultipleSelection = false
        openPanel.canChooseDirectories = true
        openPanel.canCreateDirectories = true
        openPanel.canChooseFiles = false
        openPanel.begin { (result) -> Void in
            if result == .OK {
                if let url = openPanel.urls.first {
                    self.storeFolderInBookmark(url: url)
                }
                handler(openPanel.urls.first)
            }
        }
    }

    func saveBookmarksData() {
        let path = getBookmarkPath()
        do {
            let data = try NSKeyedArchiver.archivedData(withRootObject: bookmarks, requiringSecureCoding: false)
            try data.write(to: path)
        } catch {
            debugPrint("Could not save bookmark data")
        }
    }

    func loadBookmarks() {
        let path = getBookmarkPath()
        bookmarks = [:]
        if let data = try? Data(contentsOf: path) {
            if let unarchived = try? NSKeyedUnarchiver.unarchiveTopLevelObjectWithData(data) {
                bookmarks = unarchived as? [URL: Data] ?? [:]
            }
            for bookmark in bookmarks {
                restoreBookmark(bookmark)
            }
        }
    }

    private func storeFolderInBookmark(url: URL) {
        do {
            let data = try url.bookmarkData(options: .withSecurityScope, includingResourceValuesForKeys: nil, relativeTo: nil)
            bookmarks[url] = data
        } catch {
            debugPrint("Error storing bookmarks")
        }
    }

    private func getBookmarkPath() -> URL {
        let url = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0] as URL
        return url.appendingPathComponent("Bookmarks.dict")
    }

    private func restoreBookmark(_ bookmark: (key: URL, value: Data)) {
        let restoredUrl: URL?
        var isStale = false

        debugPrint("Restoring \(bookmark.key.absoluteString)")

        do {
            restoredUrl = try URL(resolvingBookmarkData: bookmark.value, options: .withSecurityScope, relativeTo: nil, bookmarkDataIsStale: &isStale)
        } catch {
            debugPrint("Error restoring bookmarks")
            restoredUrl = nil
        }

        if let url = restoredUrl {
            if isStale {
               debugPrint("URL is stale")
            } else {
                if !url.startAccessingSecurityScopedResource() {
                    debugPrint("Couldn't access: \(url.path)")
                }
            }
        }
    }
}

Thanks for this. Does this work as well for saving directory access or only file access?

Thats what saveBookmarksData and loadBookmarks are for, so yes saving directory access should be possible with this snippet.