Support exporting custom commands

Author: intitni

Core/Sources/HostApp/CustomCommandSettings/CustomCommand.swift

@@ -17,6 +17,9 @@ struct CustomCommandFeature: ReducerProtocol {
         case editCommand(CustomCommand)
         case editCustomCommand(EditCustomCommand.Action)
         case deleteCommand(CustomCommand)
+        case exportCommand(CustomCommand)
+        case importCommand(at: URL)
+        case importCommandClicked
     }
 
     @Dependency(\.toast) var toast
@@ -49,6 +52,68 @@ struct CustomCommandFeature: ReducerProtocol {
                 return .none
             case .editCustomCommand:
                 return .none
+            case let .exportCommand(command):
+                return .run { _ in
+                    do {
+                        let data = try JSONEncoder().encode(command)
+                        let filename = "CustomCommand-\(command.name).json"
+
+                        let url = await withCheckedContinuation { continuation in
+                            Task { @MainActor in
+                                let panel = NSSavePanel()
+                                panel.canCreateDirectories = true
+                                panel.nameFieldStringValue = filename
+                                let result = await panel.begin()
+                                switch result {
+                                case .OK:
+                                    continuation.resume(returning: panel.url)
+                                default:
+                                    continuation.resume(returning: nil)
+                                }
+                            }
+                        }
+
+                        if let url {
+                            try data.write(to: url)
+                            toast("Saved!", .info)
+                        }
+
+                    } catch {
+                        toast(error.localizedDescription, .error)
+                    }
+                }
+
+            case let .importCommand(url):
+                do {
+                    let data = try Data(contentsOf: url)
+                    var command = try JSONDecoder().decode(CustomCommand.self, from: data)
+                    command.commandId = UUID().uuidString
+                    settings.customCommands.append(command)
+                    toast("Imported custom command \(command.name)!", .info)
+                } catch {
+                    toast("Failed to import command: \(error.localizedDescription)", .error)
+                }
+                return .none
+
+            case .importCommandClicked:
+                return .run { send in
+                    let url = await withCheckedContinuation { continuation in
+                        Task { @MainActor in
+                            let panel = NSOpenPanel()
+                            panel.allowedContentTypes = [.json]
+                            let result = await panel.begin()
+                            if result == .OK {
+                                continuation.resume(returning: panel.url)
+                            } else {
+                                continuation.resume(returning: nil)
+                            }
+                        }
+                    }
+                    
+                    if let url {
+                        await send(.importCommand(at: url))
+                    }
+                }
             }
         }.ifLet(\.editCustomCommand, action: /Action.editCustomCommand) {
             EditCustomCommand(settings: settings)

Core/Sources/HostApp/CustomCommandSettings/CustomCommandView.swift

@@ -4,6 +4,7 @@ import PlusFeatureFlag
 import Preferences
 import SharedUIComponents
 import SwiftUI
+import Toast
 
 extension List {
     @ViewBuilder
@@ -51,7 +52,7 @@ struct CustomCommandView: View {
     @ViewBuilder
     var leftPane: some View {
         List {
-            ForEach(settings.customCommands, id: \.name) { command in
+            ForEach(settings.customCommands, id: \.commandId) { command in
                 CommandButton(store: store, command: command)
             }
             .onMove(perform: { indices, newOffset in
@@ -92,6 +93,34 @@ struct CustomCommandView: View {
             }
             .buttonStyle(.plain)
             .padding()
+            .contextMenu {
+                Button("Import") {
+                    store.send(.importCommandClicked)
+                }
+            }
+        }
+        .onDrop(of: [.json], delegate: FileDropDelegate(store: store, toast: toast))
+    }
+
+    struct FileDropDelegate: DropDelegate {
+        let store: StoreOf<CustomCommandFeature>
+        let toast: (String, ToastType) -> Void
+        func performDrop(info: DropInfo) -> Bool {
+            let jsonFiles = info.itemProviders(for: [.json])
+            for file in jsonFiles {
+                file.loadInPlaceFileRepresentation(forTypeIdentifier: "public.json") { url, _, error in
+                    Task { @MainActor in
+                        if let url {
+                            print(url)
+                            store.send(.importCommand(at: url))
+                        } else if let error {
+                            toast(error.localizedDescription, .error)
+                        }
+                    }
+                }
+            }
+
+            return !jsonFiles.isEmpty
         }
     }
 
@@ -143,6 +172,10 @@ struct CustomCommandView: View {
                 Button("Remove") {
                     store.send(.deleteCommand(command))
                 }
+
+                Button("Export") {
+                    store.send(.exportCommand(command))
+                }
             }
         }
     }