Auto reload config

Sources/AppBundle/command/impl/ReloadConfigCommand.swift

@@ -33,6 +33,7 @@ struct ReloadConfigCommand: Command {
                 configUrl = url
                 activateMode(activeMode)
                 syncStartAtLogin()
+                startConfigFileWatcher()
                 MessageModel.shared.message = nil
             }
             return true

Sources/AppBundle/config/Config.swift

@@ -40,6 +40,7 @@ struct Config: ConvenienceCopyable {
     var defaultRootContainerLayout: Layout = .tiles
     var defaultRootContainerOrientation: DefaultContainerOrientation = .auto
     var startAtLogin: Bool = false
+    var autoReloadConfig: Bool = false
     var automaticallyUnhideMacosHiddenApps: Bool = false
     var accordionPadding: Int = 30
     var enableNormalizationOppositeOrientationForNestedContainers: Bool = true

Sources/AppBundle/config/ConfigFileWatcher.swift

@@ -0,0 +1,159 @@
+import AppKit
+import Common
+import Foundation
+import CoreServices
+
+@MainActor
+class ConfigFileWatcher {
+    private var eventStream: FSEventStreamRef?
+    private var watchedFileUrl: URL?
+    private var lastModificationDate: Date?
+    private var debounceTask: Task<Void, Never>?
+
+    func startWatching(configUrl: URL) {
+        stopWatching()
+
+        guard config.autoReloadConfig else { return }
+
+        guard configUrl != defaultConfigUrl else { return }
+
+        watchedFileUrl = configUrl
+
+        if let attrs = try? FileManager.default.attributesOfItem(atPath: configUrl.path),
+           let modDate = attrs[.modificationDate] as? Date
+        {
+            lastModificationDate = modDate
+        }
+
+        let directoryPath = configUrl.deletingLastPathComponent().path
+
+        var context = FSEventStreamContext(
+            version: 0,
+            info: Unmanaged.passUnretained(self).toOpaque(),
+            retain: nil,
+            release: nil,
+            copyDescription: nil,
+        )
+
+        let pathsToWatch = [directoryPath] as CFArray
+        let callback: FSEventStreamCallback = { (
+            streamRef: ConstFSEventStreamRef,
+            clientCallBackInfo: UnsafeMutableRawPointer?,
+            numEvents: Int,
+            eventPaths: UnsafeMutableRawPointer,
+            eventFlags: UnsafePointer<FSEventStreamEventFlags>,
+            eventIds: UnsafePointer<FSEventStreamEventId>,
+        ) in
+            guard let info = clientCallBackInfo else { return }
+            let watcher = Unmanaged<ConfigFileWatcher>.fromOpaque(info).takeUnretainedValue()
+
+            // Filter events to only react to our specific file
+            let paths = unsafeBitCast(eventPaths, to: NSArray.self) as? [String] ?? []
+            guard let watchedPath = watcher.watchedFileUrl?.path else { return }
+
+            for i in 0 ..< numEvents {
+                let flags = eventFlags[i]
+                let isFile = (flags & FSEventStreamEventFlags(kFSEventStreamEventFlagItemIsFile)) != 0
+                let isRelevant = (flags & FSEventStreamEventFlags(
+                    kFSEventStreamEventFlagItemModified |
+                        kFSEventStreamEventFlagItemRenamed |
+                        kFSEventStreamEventFlagItemCreated |
+                        kFSEventStreamEventFlagItemChangeOwner,
+                )) != 0
+
+                if isFile && isRelevant && paths[i] == watchedPath {
+                    // Already on main queue
+                    watcher.handleFileChange()
+                    break
+                }
+            }
+        }
+
+        guard let stream = FSEventStreamCreate(
+            kCFAllocatorDefault,
+            callback,
+            &context,
+            pathsToWatch,
+            FSEventStreamEventId(kFSEventStreamEventIdSinceNow),
+            0.3, // latency in seconds, letting the system coalesce events
+            FSEventStreamCreateFlags(kFSEventStreamCreateFlagFileEvents),
+        ) else {
+            return
+        }
+
+        FSEventStreamSetDispatchQueue(stream, DispatchQueue.main)
+
+        if !FSEventStreamStart(stream) {
+            FSEventStreamInvalidate(stream)
+            FSEventStreamRelease(stream)
+            return
+        }
+
+        eventStream = stream
+    }
+
+    func stopWatching() {
+        debounceTask?.cancel()
+        debounceTask = nil
+
+        if let stream = eventStream {
+            FSEventStreamStop(stream)
+            FSEventStreamInvalidate(stream)
+            FSEventStreamRelease(stream)
+            eventStream = nil
+        }
+
+        watchedFileUrl = nil
+        lastModificationDate = nil
+    }
+
+    private func handleFileChange() {
+        guard let url = watchedFileUrl else {
+            return
+        }
+
+        guard FileManager.default.fileExists(atPath: url.path) else {
+            return
+        }
+
+        guard let attrs = try? FileManager.default.attributesOfItem(atPath: url.path),
+              let modDate = attrs[.modificationDate] as? Date
+        else {
+            return
+        }
+
+        guard modDate > (lastModificationDate ?? .distantPast) else {
+            return
+        }
+
+        lastModificationDate = modDate
+
+        debounceTask?.cancel()
+
+        // Debounce the reload to handle atomic save sequences (write → rename → swap)
+        debounceTask = Task { @MainActor in
+            try? await Task.sleep(for: .milliseconds(300))
+            guard !Task.isCancelled else { return }
+            // Reload config within a session to ensure layout refresh happens
+            guard let token: RunSessionGuard = .isServerEnabled else { return }
+            try? await runSession(.autoReloadConfig, token) {
+                _ = reloadConfig(forceConfigUrl: url)
+            }
+        }
+    }
+}
+
+@MainActor private var _configFileWatcher: ConfigFileWatcher?
+
+@MainActor
+func startConfigFileWatcher() {
+    if _configFileWatcher == nil {
+        _configFileWatcher = ConfigFileWatcher()
+    }
+    _configFileWatcher?.startWatching(configUrl: configUrl)
+}
+
+@MainActor
+func stopConfigFileWatcher() {
+    _configFileWatcher?.stopWatching()
+}

Sources/AppBundle/config/parseConfig.swift

@@ -102,6 +102,7 @@ private let configParser: [String: any ParserProtocol<Config>] = [
     "default-root-container-orientation": Parser(\.defaultRootContainerOrientation, parseDefaultContainerOrientation),
 
     "start-at-login": Parser(\.startAtLogin, parseBool),
+    "auto-reload-config": Parser(\.autoReloadConfig, parseBool),
     "automatically-unhide-macos-hidden-apps": Parser(\.automaticallyUnhideMacosHiddenApps, parseBool),
     "accordion-padding": Parser(\.accordionPadding, parseInt),
     "exec-on-workspace-change": Parser(\.execOnWorkspaceChange, parseExecOnWorkspaceChange),

Sources/AppBundle/initAppBundle.swift

@@ -14,6 +14,7 @@ import Foundation
     if !reloadConfig() {
         check(reloadConfig(forceConfigUrl: defaultConfigUrl))
     }
+    startConfigFileWatcher()
 
     checkAccessibilityPermissions()
     startUnixSocketServer()

Sources/Common/util/commonUtil.swift

@@ -77,6 +77,7 @@ public enum RefreshSessionEvent: Sendable, CustomStringConvertible {
     case ax(String)
     case onFocusedMonitorChanged
     case onFocusChanged
+    case autoReloadConfig
 
     public var isStartup: Bool {
         if case .startup = self { return true } else { return false }
@@ -94,6 +95,7 @@ public enum RefreshSessionEvent: Sendable, CustomStringConvertible {
             case .startup: "startup"
             case .onFocusedMonitorChanged: "onFocusedMonitorChanged"
             case .onFocusChanged: "onFocusChanged"
+            case .autoReloadConfig: "autoReloadConfig"
         }
     }
 }

docs/config-examples/default-config.toml

@@ -8,6 +8,9 @@ after-startup-command = []
 # Start AeroSpace at login
 start-at-login = false
 
+# Automatically reload the config when the config file is changed
+auto-reload-config = false
+
 # Normalizations. See: https://nikitabobko.github.io/AeroSpace/guide#normalization
 enable-normalization-flatten-containers = true
 enable-normalization-opposite-orientation-for-nested-containers = true