Output Redacted

Output Redacted

Output Redacted

Output Redacted

import Cocoa
import Combine
import CryptoKit
import Defaults

let emptyRoot = Group(key: "🚫", label: "Config error", actions: [])

class UserConfig: ObservableObject {
  @Published var root = emptyRoot {
    didSet {
      if !isLoading && root != emptyRoot && root != oldValue {
        saveConfigAsync()
      }
    }
  }
  @Published var validationErrors: [ValidationError] = []
  // O(1) lookup for row validation; keys are path strings like "1/0/3"
  @Published var validationErrorsByPath: [String: ValidationErrorType] = [:]

  let fileName = "config.json"
  private let alertHandler: AlertHandler
  private let fileManager: FileManager
  private var lastReadChecksum: String?
  private var isLoading = false
  private let configIOQueue = DispatchQueue(label: "ConfigIO", qos: .userInitiated)
  private var saveWorkItem: DispatchWorkItem?

  init(
    alertHandler: AlertHandler = DefaultAlertHandler(),
    fileManager: FileManager = .default
  ) {
    self.alertHandler = alertHandler
    self.fileManager = fileManager
  }

  // MARK: - Public Interface

  func ensureAndLoad() {
    ensureValidConfigDirectory()
    ensureConfigFileExists()
    loadConfig()
  }

  func reloadFromFile() {
    Events.send(.willReload)
    loadConfig(suppressAlerts: true)
    Events.send(.didReload)
  }

  func saveConfig() {
    // Check for file conflicts before saving
    if let lastChecksum = lastReadChecksum, exists {
      let currentChecksum = getCurrentFileChecksum()
      if currentChecksum != lastChecksum {
        let result = alertHandler.showAlert(
          style: .warning,
          message: "Configuration file changed on disk",
          informativeText:
            "The configuration file has been modified outside of the app. Choose 'Read from File' to load the external changes, or 'Overwrite' to save your current changes.",
          buttons: ["Overwrite", "Cancel", "Read from File"]
        )

        switch result {
        case .alertThirdButtonReturn:  // Read from File (rightmost, default)
          reloadFromFile()
          return
        case .alertFirstButtonReturn:  // Overwrite
          break  // Continue with save
        default:  // Cancel
          return
        }
      }
    }

    setValidationErrors(ConfigValidator.validate(group: root))

    do {
      let encoder = JSONEncoder()
      encoder.outputFormatting = [
        .prettyPrinted, .withoutEscapingSlashes, .sortedKeys,
      ]
      let jsonData = try encoder.encode(root)

      try writeFile(data: jsonData)

      // Update checksum after successful write using data directly
      lastReadChecksum = calculateChecksum(jsonData)
    } catch {
      handleError(error, critical: true)
    }
  }

  private func saveConfigAsync() {
    // Cancel any pending save
    saveWorkItem?.cancel()

    // Create a new debounced save work item
    let currentRoot = root
    let workItem = DispatchWorkItem { [weak self] in
      guard let self = self else { return }

      // Perform file I/O on background queue
      let encoder = JSONEncoder()
      encoder.outputFormatting = [.prettyPrinted, .withoutEscapingSlashes, .sortedKeys]

      do {
        let jsonData = try encoder.encode(currentRoot)

        // Check conflicts on background queue first, then switch to main for UI
        if let lastChecksum = self.lastReadChecksum, self.exists {
          let currentChecksum = self.getCurrentFileChecksum()
          if currentChecksum != lastChecksum {
            DispatchQueue.main.async {
              let result = self.alertHandler.showAlert(
                style: .warning,
                message: "Configuration file changed on disk",
                informativeText:
                  "The configuration file has been modified outside of the app. Choose 'Read from File' to load the external changes, or 'Overwrite' to save your current changes.",
                buttons: ["Overwrite", "Cancel", "Read from File"]
              )

              switch result {
              case .alertThirdButtonReturn:  // Read from File
                self.reloadFromFile()
                return
              case .alertFirstButtonReturn:  // Overwrite
                break  // Continue with save
              default:  // Cancel
                return
              }

              // Continue with save after conflict resolution
              self.performSaveWithData(jsonData, currentRoot: currentRoot)
            }
            return
          }
        }

        DispatchQueue.main.async {
          self.performSaveWithData(jsonData, currentRoot: currentRoot)
        }
      } catch {
        DispatchQueue.main.async {
          self.handleError(error, critical: true)
        }
      }
    }

    saveWorkItem = workItem

    // Execute with 300ms debounce
    configIOQueue.asyncAfter(deadline: .now() + .milliseconds(300), execute: workItem)
  }

  private func performSaveWithData(_ jsonData: Data, currentRoot: Group) {
    // Validation on main queue
    let validationErrors = ConfigValidator.validate(group: currentRoot)
    setValidationErrors(validationErrors)

    // Back to background for file write
    configIOQueue.async { [weak self] in
      guard let self = self else { return }

      do {
        try self.writeFile(data: jsonData)

        DispatchQueue.main.async {
          // Update checksum on main queue using data directly
          self.lastReadChecksum = self.calculateChecksum(jsonData)
        }
      } catch {
        DispatchQueue.main.async {
          self.handleError(error, critical: true)
        }
      }
    }
  }

  // MARK: - Directory Management

  static func defaultDirectory() -> String {
    let appSupportDir = FileManager.default.urls(
      for: .applicationSupportDirectory, in: .userDomainMask)[0]
    let path = (appSupportDir.path as NSString).appendingPathComponent(
      "Leader Key")
    do {
      try FileManager.default.createDirectory(
        atPath: path, withIntermediateDirectories: true)
    } catch {
      fatalError("Failed to create config directory")
    }
    return path
  }

  private func ensureValidConfigDirectory() {
    let dir = Defaults[.configDir]
    let defaultDir = Self.defaultDirectory()

    if !fileManager.fileExists(atPath: dir) {
      alertHandler.showAlert(
        style: .warning,
        message:
          "Config directory does not exist: \(dir)\nResetting to default location."
      )
      Defaults[.configDir] = defaultDir
    }
  }

  // MARK: - File Operations

  var path: String {
    (Defaults[.configDir] as NSString).appendingPathComponent(fileName)
  }

  var url: URL {
    URL(fileURLWithPath: path)
  }

  var exists: Bool {
    fileManager.fileExists(atPath: path)

import Cocoa
import Defaults
import KeyboardShortcuts
import Settings
import Sparkle
import SwiftUI
import UserNotifications

let updateLocationIdentifier = "UpdateCheck"

@NSApplicationMain
class AppDelegate: NSObject, NSApplicationDelegate,
  SPUStandardUserDriverDelegate,
  UNUserNotificationCenterDelegate,
  NSWindowDelegate
{
  var controller: Controller!

  let statusItem = StatusItem()
  let config = UserConfig()

  var state: UserState!
  @IBOutlet var updaterController: SPUStandardUpdaterController!

  lazy var settingsWindowController = SettingsWindowController(
    panes: [
      Settings.Pane(
        identifier: .general, title: "General",
        toolbarIcon: NSImage(named: NSImage.preferencesGeneralName)!,
        contentView: { GeneralPane().environmentObject(self.config) }
      ),
      Settings.Pane(
        identifier: .advanced, title: "Advanced",
        toolbarIcon: NSImage(named: NSImage.advancedName)!,
        contentView: {
          AdvancedPane().environmentObject(self.config)
        }),
    ],
    style: .segmentedControl,
  )

  func applicationDidFinishLaunching(_: Notification) {

    guard
      ProcessInfo.processInfo.environment["XCODE_RUNNING_FOR_PREVIEWS"] != "1"
    else { return }
    guard !isRunningTests() else { return }

    UNUserNotificationCenter.current().delegate = self

    NSApp.mainMenu = MainMenu()

    config.ensureAndLoad()
    state = UserState(userConfig: config)
    controller = Controller(userState: state, userConfig: config)

    statusItem.handlePreferences = {
      self.showSettings()
    }
    statusItem.handleAbout = {
      NSApp.orderFrontStandardAboutPanel(nil)
    }
    statusItem.handleReloadConfig = {
      self.config.reloadFromFile()
    }
    statusItem.handleRevealConfig = {
      NSWorkspace.shared.activateFileViewerSelecting([self.config.url])
    }
    statusItem.handleCheckForUpdates = {
      self.updaterController.checkForUpdates(nil)
    }

    Task {
      for await value in Defaults.updates(.showMenuBarIcon) {
        if value {
          self.statusItem.enable()
        } else {
          self.statusItem.disable()
        }
      }
    }

    // Initialize status item according to current preference
    if Defaults[.showMenuBarIcon] {
      statusItem.enable()
    } else {
      statusItem.disable()
    }

    // Activation policy is managed solely by the Settings window

    registerGlobalShortcuts()
  }

  func activate() {
    if self.controller.window.isKeyWindow {
      switch Defaults[.reactivateBehavior] {
      case .hide:
        self.hide()
      case .reset:
        self.controller.userState.clear()
      case .nothing:
        return
      }
    } else if self.controller.window.isVisible {
      // should never happen as the window will self-hide when not key
      self.controller.window.makeKeyAndOrderFront(nil)
    } else {
      self.show()
    }
  }

  public func registerGlobalShortcuts() {
    KeyboardShortcuts.removeAllHandlers()

    KeyboardShortcuts.onKeyDown(for: .activate) {
      self.activate()
    }

    for groupKey in Defaults[.groupShortcuts] {
      print("Registering shortcut for \(groupKey)")
      KeyboardShortcuts.onKeyDown(for: KeyboardShortcuts.Name("group-\(groupKey)")) {
        if !self.controller.window.isVisible {
          self.activate()
        }
        self.processKeys([groupKey])
      }
    }
  }

  func applicationWillTerminate(_ notification: Notification) {
    // Config saves automatically on changes
  }

  @IBAction
  func settingsMenuItemActionHandler(_: NSMenuItem) {
    showSettings()
  }

  func show() {
    controller.show()
  }

  func hide() {
    controller.hide()
  }

  // MARK: - Sparkle Gentle Reminders

  @objc var supportsGentleScheduledUpdateReminders: Bool {
    return true
  }

  func standardUserDriverWillHandleShowingUpdate(
    _ handleShowingUpdate: Bool, forUpdate update: SUAppcastItem,
    state: SPUUserUpdateState
  ) {
    // Do not change activation policy here; Settings drives visibility

    if !state.userInitiated {
      NSApp.dockTile.badgeLabel = "1"

      requestNotificationsAuthorizationIfNeeded { granted in
        guard granted else { return }
        let content = UNMutableNotificationContent()
        content.title = "Leader Key Update Available"
        content.body = "Version \(update.displayVersionString) is now available"

        let request = UNNotificationRequest(
          identifier: updateLocationIdentifier, content: content,
          trigger: nil)
        UNUserNotificationCenter.current().add(request)
      }
    }
  }

  func standardUserDriverDidReceiveUserAttention(
    forUpdate update: SUAppcastItem
  ) {
    NSApp.dockTile.badgeLabel = ""

    UNUserNotificationCenter.current().removeDeliveredNotifications(
      withIdentifiers: [
        updateLocationIdentifier
      ])
  }

  func standardUserDriverWillFinishUpdateSession() {}

  // MARK: - UNUserNotificationCenter Delegate

  func userNotificationCenter(
    _ center: UNUserNotificationCenter,
    didReceive response: UNNotificationResponse,
    withCompletionHandler completionHandler: @escaping () -> Void
  ) {
    if response.notification.request.identifier
      == updateLocationIdentifier
      && response.actionIdentifier == UNNotificationDefaultActionIdentifier
    {
      updaterController.checkForUpdates(nil)
    }
    completionHandler()
  }

  func isRunningTests() -> Bool {
    let environment = ProcessInfo.processInfo.environment
    guard environment["XCTestSessionIdentifier"] != nil else { return false }
    return true
  }

  // MARK: - URL Scheme Handling

  func application(_ application: NSApplication, open urls: [URL]) {
    for url in urls {
      handleURL(url)
    }
  }

  private func handleURL(_ url: URL) {
    guard url.scheme == "leaderkey" else { return }

    if url.host == "settings" {
      showSettings()
      return
    }
    if url.host == "about" {
      NSApp.orderFrontStandardAboutPanel(nil)
      return
    }

    show()

    if url.host == "navigate",
      let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
      let queryItems = components.queryItems,
      let keysParam = queryItems.first(where: { $0.name == "keys" })?.value
    {
      let keys = keysParam.split(separator: ",").map(String.init)
      processKeys(keys)
    }
  }

  private func processKeys(_ keys: [String]) {
    guard !keys.isEmpty else { return }

    controller.handleKey(keys[0])

    if keys.count > 1 {
      let remainingKeys = Array(keys.dropFirst())

      var delayMs = 100
      for key in remainingKeys {
        delay(delayMs) { [weak self] in
          self?.controller.handleKey(key)
        }
        delayMs += 100
      }
    }
  }

import Settings

extension Settings.PaneIdentifier {
  static let general = Self("general")
  static let advanced = Self("advanced")
}

import Cocoa
import Combine
import Sparkle

class StatusItem {
  enum Appearance {
    case normal
    case active
  }

  var appearance: Appearance = .normal {
    didSet {
      updateStatusItemAppearance()
    }
  }

  var statusItem: NSStatusItem?
  private var cancellables = Set<AnyCancellable>()

  var handlePreferences: (() -> Void)?
  var handleAbout: (() -> Void)?
  var handleReloadConfig: (() -> Void)?
  var handleRevealConfig: (() -> Void)?
  var handleCheckForUpdates: (() -> Void)?

  func enable() {
    statusItem = NSStatusBar.system.statusItem(
      withLength: NSStatusItem.squareLength)

    guard let item = statusItem else {
      print("No status item")
      return
    }

    if let menubarButton = item.button {
      menubarButton.image = NSImage(named: NSImage.Name("StatusItem"))
    }

    let menu = NSMenu()

    // About
    let aboutItem = NSMenuItem(
      title: "About Leader Key", action: #selector(showAbout),
      keyEquivalent: ""
    )
    aboutItem.target = self
    menu.addItem(aboutItem)

    menu.addItem(NSMenuItem.separator())

    // Settings
    let preferencesItem = NSMenuItem(
      title: "Settings…", action: #selector(showPreferences), keyEquivalent: ",")
    preferencesItem.target = self
    menu.addItem(preferencesItem)

    menu.addItem(NSMenuItem.separator())

    let checkForUpdatesItem = NSMenuItem(
      title: "Check for Updates...", action: #selector(checkForUpdates),
      keyEquivalent: ""
    )
    checkForUpdatesItem.target = self
    menu.addItem(checkForUpdatesItem)

    menu.addItem(NSMenuItem.separator())

    let revealConfigItem = NSMenuItem(
      title: "Show config in Finder", action: #selector(revealConfigFile),
      keyEquivalent: ""
    )
    revealConfigItem.target = self
    menu.addItem(revealConfigItem)

    let reloadConfigItem = NSMenuItem(
      title: "Reload config", action: #selector(reloadConfig), keyEquivalent: ""
    )
    reloadConfigItem.target = self
    menu.addItem(reloadConfigItem)

    menu.addItem(NSMenuItem.separator())

    menu.addItem(
      NSMenuItem(
        title: "Quit Leader Key",
        action: #selector(NSApplication.terminate(_:)), keyEquivalent: "q"
      ))

    item.menu = menu

    updateStatusItemAppearance()

    Events.sink { event in
      switch event {
      case .willActivate:
        self.appearance = .active
        break
      case .willDeactivate:
        self.appearance = .normal
        break
      default:
        break
      }
    }.store(in: &cancellables)

  }

  func disable() {
    guard let item = statusItem else { return }

    cancellables.removeAll()
    NSStatusBar.system.removeStatusItem(item)
    statusItem = nil
  }

  @objc func showPreferences() {
    handlePreferences?()
  }

  @objc func showAbout() {
    handleAbout?()
  }

  @objc func reloadConfig() {
    handleReloadConfig?()
  }

  @objc func revealConfigFile() {
    handleRevealConfig?()
  }

  @objc func checkForUpdates() {
    handleCheckForUpdates?()
  }

  private func updateStatusItemAppearance() {
    guard let button = statusItem?.button else { return }

    switch appearance {
    case .normal:
      button.image = NSImage(named: NSImage.Name("StatusItem"))
    case .active:
      button.image = NSImage(named: NSImage.Name("StatusItem-filled"))
    }
  }
}

../Leader Key/Leader Key/UserConfig.swift:196:    let dir = Defaults[.configDir]
../Leader Key/Leader Key/UserConfig.swift:205:      Defaults[.configDir] = defaultDir
../Leader Key/Leader Key/UserConfig.swift:212:    (Defaults[.configDir] as NSString).appendingPathComponent(fileName)
../Leader Key/Leader Key/AppDelegate.swift:74:      for await value in Defaults.updates(.showMenuBarIcon) {
../Leader Key/Leader Key/AppDelegate.swift:84:    if Defaults[.showMenuBarIcon] {
../Leader Key/Leader Key/Defaults.swift:9:extension Defaults.Keys {
../Leader Key/Leader Key/Defaults.swift:10:  static let configDir = Key<String>(
../Leader Key/Leader Key/Defaults.swift:11:    "configDir", default: UserConfig.defaultDirectory(), suite: defaultsSuite)
../Leader Key/Leader Key/Defaults.swift:12:  static let showMenuBarIcon = Key<Bool>(
../Leader Key/Leader Key/Settings/GeneralPane.swift:10:  @Default(.configDir) var configDir
../Leader Key/Leader Key/Settings/AdvancedPane.swift:12:  @Default(.configDir) var configDir
../Leader Key/Leader Key/Settings/AdvancedPane.swift:27:          Text(configDir).lineLimit(1).truncationMode(.middle)
../Leader Key/Leader Key/Settings/AdvancedPane.swift:37:            configDir = selectedPath.path
../Leader Key/Leader Key/Settings/AdvancedPane.swift:46:            configDir = UserConfig.defaultDirectory()
../Leader Key/Leader Key/Settings/AdvancedPane.swift:148:        Defaults.Toggle("Show Leader Key in menubar", key: .showMenuBarIcon)

import Defaults
import KeyboardShortcuts
import LaunchAtLogin
import Settings
import SwiftUI

struct AdvancedPane: View {
  private let contentWidth = 640.0

  @EnvironmentObject private var config: UserConfig

  @Default(.configDir) var configDir
  @Default(.modifierKeyConfiguration) var modifierKeyConfiguration
  @Default(.autoOpenCheatsheet) var autoOpenCheatsheet
  @Default(.cheatsheetDelayMS) var cheatsheetDelayMS
  @Default(.reactivateBehavior) var reactivateBehavior
  @Default(.showAppIconsInCheatsheet) var showAppIconsInCheatsheet
  @Default(.screen) var screen

  var body: some View {
    Settings.Container(contentWidth: contentWidth) {
      Settings.Section(
        title: "Config directory",
        bottomDivider: true
      ) {
        HStack {
          Text(configDir).lineLimit(1).truncationMode(.middle)
        }
        HStack {
          Button("Choose…") {
            let panel = NSOpenPanel()
            panel.allowsMultipleSelection = false
            panel.canChooseDirectories = true
            panel.canChooseFiles = false
            if panel.runModal() != .OK { return }
            guard let selectedPath = panel.url else { return }
            configDir = selectedPath.path
          }
          Button("Reveal") {
            NSWorkspace.shared.activateFileViewerSelecting([
              config.url
            ])
          }

          Button("Reset") {
            configDir = UserConfig.defaultDirectory()
          }
        }
      }

      Settings.Section(
        title: "Modifier Keys", bottomDivider: true
      ) {
        VStack(alignment: .leading, spacing: 16) {
          HStack {
            Picker("", selection: $modifierKeyConfiguration) {
              ForEach(ModifierKeyConfig.allCases) { config in
                Text(config.description).tag(config)
              }
            }
            .frame(width: 280)
            .labelsHidden()
          }

          VStack(alignment: .leading, spacing: 8) {
            Text(
              "Group Actions: When the modifier key is held while pressing a group key, it runs all actions in that group and its sub-groups."
            )
            .font(.callout)
            .foregroundColor(.secondary)
          }

          VStack(alignment: .leading, spacing: 8) {
            Text(
              "Sticky Mode: When the modifier key is held while triggering an action, Leader Key stays open after the action completes."
            )
            .font(.callout)
            .foregroundColor(.secondary)
          }
        }
        .padding(.top, 2)
      }

      Settings.Section(title: "Cheatsheet", bottomDivider: true) {
        HStack(alignment: .firstTextBaseline) {
          Picker("Show", selection: $autoOpenCheatsheet) {
            Text("Always").tag(AutoOpenCheatsheetSetting.always)
            Text("After …").tag(AutoOpenCheatsheetSetting.delay)
            Text("Never").tag(AutoOpenCheatsheetSetting.never)
          }.frame(width: 120)

          if autoOpenCheatsheet == .delay {
            TextField(
              "", value: $cheatsheetDelayMS, formatter: NumberFormatter()
            )
            .frame(width: 50)
            Text("milliseconds")
          }

          Spacer()
        }

        Text(
          "The cheatsheet can always be manually shown by \"?\" when Leader Key is activated."
        )
        .padding(.vertical, 2)

        Defaults.Toggle(
          "Show expanded groups in cheatsheet", key: .expandGroupsInCheatsheet)
        Defaults.Toggle(
          "Show icons", key: .showAppIconsInCheatsheet)
        Defaults.Toggle(
          "Use favicons for URLs", key: .showFaviconsInCheatsheet
        ).padding(.leading, 20).disabled(!showAppIconsInCheatsheet)
        Defaults.Toggle(
          "Show item details in cheatsheet", key: .showDetailsInCheatsheet)

      }

      Settings.Section(title: "Activation", bottomDivider: true) {
        VStack(alignment: .leading) {
          Text(
            "Pressing the global shortcut key while Leader Key is active should …"
          )

          Picker(
            "Reactivation behavior", selection: $reactivateBehavior
          ) {
            Text("Hide Leader Key").tag(ReactivateBehavior.hide)
            Text("Reset group selection").tag(ReactivateBehavior.reset)
            Text("Do nothing").tag(ReactivateBehavior.nothing)
          }
          .labelsHidden()
          .frame(width: 220)
        }
      }

      Settings.Section(title: "Show Leader Key on", bottomDivider: true) {
        Picker("", selection: $screen) {
          Text("Screen containing mouse").tag(Screen.mouse)
          Text("Primary screen").tag(Screen.primary)
          Text("Screen with active window").tag(Screen.activeWindow)
        }
        .labelsHidden()
        .frame(width: 220)
      }
      Settings.Section(title: "Other") {
        Defaults.Toggle("Show Leader Key in menubar", key: .showMenuBarIcon)
        VStack(alignment: .leading, spacing: 4) {
          Defaults.Toggle(
            "Force English keyboard layout", key: .forceEnglishKeyboardLayout)
          Text(
            "When enabled, letter keys are interpreted in US-English (QWERTY) regardless of your current keyboard layout."
          )
          .font(.caption)
          .foregroundColor(.secondary)
          .fixedSize(horizontal: false, vertical: true)
        }
      }
    }
  }
}

struct AdvancedPane_Previews: PreviewProvider {
  static var previews: some View {
    return AdvancedPane()
    //      .environmentObject(UserConfig())
  }
}

import AXSwift
import Cocoa
import Defaults
import Settings
import Sparkle

extension Settings.PaneIdentifier {
  static let general = Self("general")
  static let excludes = Self("excludes")
}

class AppDelegate: NSObject, NSApplicationDelegate, NSWindowDelegate {
  let sparkle = SPUStandardUpdaterController(
    startingUpdater: true,
    updaterDelegate: nil,
    userDriverDelegate: nil
  )

  let statusItem = StatusItem()
  let windowHandler = WindowHandler()

  lazy var settingsWindowController = SettingsWindowController(
    panes: [
      Settings.Pane(
        identifier: .general,
        title: "General",
        toolbarIcon: settingsIcon(named: "gearshape")
      ) {
        GeneralSettingsPane()
      },
      Settings.Pane(
        identifier: .excludes,
        title: "Excludes",
        toolbarIcon: settingsIcon(named: "nosign")
      ) {
        ExcludesSettingsPane()
      },
    ],
    style: .segmentedControl
  )

  func applicationDidFinishLaunching(_ aNotification: Notification) {
    setupMainMenu()
    setSettingsActivation(active: false)

    Task {
      for await value in Defaults.updates(.showInMenubar) {
        if value {
          self.statusItem.enable()
        } else {
          self.statusItem.disable()
        }
      }
    }

    statusItem.handleCheckForUpdates = { self.sparkle.checkForUpdates(nil) }
    statusItem.handleSettings = { self.showSettingsWindow() }

    let modifiers = Modifiers { self.windowHandler.intention = $0 }

    Task {
      for await value in Defaults.updates(.accessibilityEnabled) {
        if value {
          modifiers.observe()
        } else {
          modifiers.remove()
        }
      }
    }

    DistributedNotificationCenter.default.addObserver(
      forName: NSNotification.Name("com.apple.accessibility.api"), object: nil, queue: nil
    ) { _ in
      DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
        Defaults[.accessibilityEnabled] = AXSwift.checkIsProcessTrusted()
      }
    }

    Defaults[.accessibilityEnabled] = AXSwift.checkIsProcessTrusted(prompt: true)

    if Defaults[.showSettingsOnLaunch] {
      showSettingsWindow()
    }
  }

  func applicationWillTerminate(_ aNotification: Notification) {
  }

  func applicationDidBecomeActive(_ notification: Notification) {
    showSettingsWindow()
  }

  func windowWillClose(_ notification: Notification) {
    guard let window = notification.object as? NSWindow else { return }
    if window == settingsWindowController.window {
      setSettingsActivation(active: false)
    }
  }

  private func showSettingsWindow() {
    guard !isRunningForPreviews else { return }
    setSettingsActivation(active: true)
    NSApp.activate(ignoringOtherApps: true)
    settingsWindowController.window?.delegate = self
    sanitizeSettingsWindowAutosave()
    settingsWindowController.show()
  }

  private func setSettingsActivation(active: Bool) {
    _ = NSApp.setActivationPolicy(active ? .regular : .accessory)
  }

  private var isRunningForPreviews: Bool {
    ProcessInfo.processInfo.environment["XCODE_RUNNING_FOR_PREVIEWS"] == "1"
  }

  private func sanitizeSettingsWindowAutosave() {
    let key = "NSWindow Frame com.sindresorhus.Settings.FrameAutosaveName"
    guard let stored = UserDefaults.standard.string(forKey: key) else { return }
    guard !stored.contains("{") else { return }
    UserDefaults.standard.removeObject(forKey: key)
  }

  private func settingsIcon(named systemName: String) -> NSImage {
    NSImage(systemSymbolName: systemName, accessibilityDescription: nil) ?? NSImage()
  }

  // MARK: - Main Menu

  private func setupMainMenu() {
    let mainMenu = NSMenu()

    let appMenuItem = NSMenuItem()
    mainMenu.addItem(appMenuItem)

    let appMenu = NSMenu()
    appMenuItem.submenu = appMenu

    let appName = ProcessInfo.processInfo.processName

    appMenu.addItem(
      withTitle: "About \(appName)",
      action: #selector(NSApplication.orderFrontStandardAboutPanel(_:)),
      keyEquivalent: "")

    appMenu.addItem(.separator())

    let settingsItem = NSMenuItem(
      title: "Settings…",
      action: #selector(openSettingsFromMenu),
      keyEquivalent: ",")
    settingsItem.target = self
    appMenu.addItem(settingsItem)

    appMenu.addItem(.separator())

    appMenu.addItem(
      withTitle: "Hide \(appName)",
      action: #selector(NSApplication.hide(_:)),
      keyEquivalent: "h")

    let hideOthers = NSMenuItem(
      title: "Hide Others",
      action: #selector(NSApplication.hideOtherApplications(_:)),
      keyEquivalent: "h")
    hideOthers.keyEquivalentModifierMask = [.command, .option]
    appMenu.addItem(hideOthers)

    appMenu.addItem(
      withTitle: "Show All",
      action: #selector(NSApplication.unhideAllApplications(_:)),
      keyEquivalent: "")

    appMenu.addItem(.separator())

    appMenu.addItem(
      withTitle: "Quit \(appName)",
      action: #selector(NSApplication.terminate(_:)),
      keyEquivalent: "q")

    NSApp.mainMenu = mainMenu
  }

  @objc private func openSettingsFromMenu() {
    showSettingsWindow()
  }

  // MARK: - URLs

  func application(_ application: NSApplication, open urls: [URL]) {
    for url in urls {
      handleURL(url)
    }
  }

  private func handleURL(_ url: URL) {
    guard url.scheme == "moves" else { return }

    guard let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
      let host = url.host
    else { return }

    let queryItems = components.queryItems ?? []

    switch host {
    case "template":
      let templateName = url.path.trimmingCharacters(in: CharacterSet(charactersIn: "/"))
      guard !templateName.isEmpty else { return }

      guard let templateType = TemplateType(rawValue: templateName) else { return }
      ActiveWindow.applyTemplate(templateType)

    case "custom":
      let positionString: String
      let command = url.path.trimmingCharacters(in: CharacterSet(charactersIn: "/"))

      if let positionParam = queryItems.first(where: { $0.name == "position" })?.value,
        !positionParam.isEmpty
      {
        positionString = positionParam
---
import Cocoa

class StatusItem {
  var statusItem: NSStatusItem?

  var handleSettings: (() -> Void)?
  var handleCheckForUpdates: (() -> Void)?

  func enable() {
    statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.squareLength)

    guard let item = statusItem else {
      print("No status item")
      return
    }

    if let menubarButton = item.button {
      menubarButton.image = NSImage(named: NSImage.Name("Menubar Icon"))
    }

    let menu = NSMenu()

    let settingsItem = NSMenuItem(
      title: "Settings…", action: #selector(showSettings), keyEquivalent: ",")
    settingsItem.target = self
    menu.addItem(settingsItem)

    let updatesItem = NSMenuItem(
      title: "Check for updates…", action: #selector(checkForUpdates), keyEquivalent: "")
    updatesItem.target = self
    menu.addItem(updatesItem)

    menu.addItem(NSMenuItem.separator())
    menu.addItem(
      NSMenuItem(
        title: "Quit Moves", action: #selector(NSApplication.terminate(_:)), keyEquivalent: "q"))

    item.menu = menu
  }

  func disable() {
    guard let item = statusItem else { return }
    NSStatusBar.system.removeStatusItem(item)
  }

  @objc func showSettings() {
    handleSettings?()
  }

  @objc func checkForUpdates() {
    handleCheckForUpdates?()
  }
}
---
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>CFBundleDevelopmentRegion</key>
	<string>$(DEVELOPMENT_LANGUAGE)</string>
	<key>CFBundleExecutable</key>
	<string>$(EXECUTABLE_NAME)</string>
	<key>CFBundleIconFile</key>
	<string>AppIcon</string>
	<key>CFBundleIdentifier</key>
	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
	<key>CFBundleInfoDictionaryVersion</key>
	<string>6.0</string>
	<key>CFBundleName</key>
	<string>$(PRODUCT_NAME)</string>
	<key>CFBundlePackageType</key>
	<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
	<key>CFBundleShortVersionString</key>
	<string>$(MARKETING_VERSION)</string>
	<key>CFBundleURLTypes</key>
	<array>
		<dict>
			<key>CFBundleTypeRole</key>
			<string>Editor</string>
			<key>CFBundleURLName</key>
			<string>com.brnbw.moves</string>
			<key>CFBundleURLSchemes</key>
			<array>
				<string>moves</string>
			</array>
		</dict>
	</array>
	<key>CFBundleVersion</key>
	<string>122</string>
	<key>LSApplicationCategoryType</key>
	<string>public.app-category.utilities</string>
	<key>LSUIElement</key>
	<true/>
	<key>LSMinimumSystemVersion</key>
	<string>$(MACOSX_DEPLOYMENT_TARGET)</string>
	<key>NSHumanReadableCopyright</key>
	<string>Copyright © 2020 Brainbow. All rights reserved.</string>
	<key>NSPrincipalClass</key>
	<string>NSApplication</string>
	<key>NSSupportsAutomaticTermination</key>
	<false/>
	<key>NSSupportsSuddenTermination</key>
	<true/>
	<key>SUFeedURL</key>
	<string>https://mikker.github.io/Moves.app/appcast.xml</string>
	<key>SUPublicEDKey</key>
	<string>4ZfPYKvzE7b/uYW4B8f2v++7Bry/OmvYHCzl3g936KE=</string>
</dict>
</plist>

import Cocoa

class StatusItem: NSObject {
  var statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.squareLength)

  override func awakeFromNib() {
    statusItem.button?.image = NSImage(named: NSImage.Name("ToolbarItemIcon"))
    statusItem.menu = buildMenu()
  }

  private func buildMenu() -> NSMenu {
    let menu = NSMenu()

    let preferencesItem = NSMenuItem(
      title: "Preferences…", action: #selector(showPreferences), keyEquivalent: ",")
    preferencesItem.target = self
    menu.addItem(preferencesItem)

    let onboardingItem = NSMenuItem(
      title: "Onboarding…", action: #selector(showOnboarding), keyEquivalent: ",")
    onboardingItem.target = self
    onboardingItem.isAlternate = true
    onboardingItem.keyEquivalentModifierMask = .option
    menu.addItem(onboardingItem)

    let directoryItem = NSMenuItem(
      title: "Open directory…", action: #selector(openDirectory), keyEquivalent: "o")
    directoryItem.target = self
    menu.addItem(directoryItem)

    menu.addItem(NSMenuItem.separator())
    menu.addItem(
      NSMenuItem(
        title: "Quit Sprinkles", action: #selector(NSApplication.terminate(_:)), keyEquivalent: "q")
    )

    return menu
  }

  @objc func openDirectory() {
    if let directory = store.state.directory {
      NSWorkspace.shared.open(directory)
    } else {
      showPreferences()
    }
  }

  @objc func showPreferences() {
    guard let delegate = NSApplication.shared.delegate as? AppDelegate else { return }
    delegate.showPreferences()
  }

  @objc func showOnboarding() {
    guard let delegate = NSApplication.shared.delegate as? AppDelegate else { return }
    delegate.showOnboarding()
  }
}
---
import Cocoa
import Defaults
import LaunchAtLogin
import SafariServices
import Settings

class GeneralPreferencesController: NSViewController, SettingsPane {
  var paneIdentifier = Settings.PaneIdentifier.general
  var paneTitle: String = "General"

  override var nibName: NSNib.Name? { "General" }

  @IBOutlet var statusLight: NSButton!
  @IBOutlet var directoryPathControl: NSPathControl!
  @IBOutlet var pickLocationButton: NSButton!
  @IBOutlet var revealButton: NSButton!
  @IBOutlet var showPreferencesOnLaunchCheckbox: NSButton!
  @IBOutlet var launchAtLoginCheckbox: NSButton!
  @IBOutlet var diagnosticsCheckbox: NSButton!
  @IBOutlet var safariButton: NSButton!
  @IBOutlet var firefoxButton: NSButton!
  @IBOutlet var chromeButton: NSButton!

  var unsubscribe: UnsubscribeFn?
  var dockTimer: Timer?

  deinit {
    unsubscribe?()
  }

  override func viewDidLoad() {
    super.viewDidLoad()

    self.preferredContentSize = NSSize(width: 480, height: 403)

    unsubscribe = store.subscribe { state in
      self.directoryPathControl.url = state.directory
      self.revealButton.isEnabled = state.directory != nil

      switch state.serverState {
      case .booting:
        self.statusLight.image = NSImage(named: NSImage.statusPartiallyAvailableName)
        self.statusLight.title = "Booting…"
      case .stopped:
        self.statusLight.image = NSImage(named: NSImage.statusUnavailableName)
        self.statusLight.title = "Stopped"
      case .running:
        self.statusLight.image = NSImage(named: NSImage.statusAvailableName)
        self.statusLight.title = "Running on localhost:3133"
      }
    }

    launchAtLoginCheckbox.state = LaunchAtLogin.isEnabled ? .on : .off
  }

  @IBAction func chooseLocationPressed(_ sender: Any?) {
    OpenPanel.pick { result in
      guard let url = result else { return }

      Bookmark.url = url
      store.dispatch(.setDirectory(url))
    }
  }

  @IBAction func revealButtonPressed(_ sender: Any?) {
    guard let dir = store.state.directory else { return }
    NSWorkspace.shared.open(dir)
  }

  @IBAction func showPreferencesOnLaunchPressed(_ sender: Any?) {
    Defaults[.showPreferencesOnLaunch] = showPreferencesOnLaunchCheckbox.state == .on
  }

  @IBAction func launchAtStartupPressed(_ sender: Any?) {
    LaunchAtLogin.isEnabled = launchAtLoginCheckbox.state == .on
  }

  @IBAction func supportPressed(_ sender: Any?) {
    NSWorkspace.shared.open(URL(string: "https://getsprinkles.app/")!)
  }

  @IBAction func safariPressed(_ sender: Any?) {
    ExtensionLinks.safari()
  }

  @IBAction func firefoxPressed(_ sender: Any?) {
    ExtensionLinks.firefox()
  }

  @IBAction func chromePressed(_ sender: Any?) {
    ExtensionLinks.chrome()
  }

  @IBAction func resetCertsPressed(_ sender: Any?) {
    SprinklesCertificate.destroy()
    Defaults[.hasOnboarded] = false
    NSApp.relaunch()
  }
}
---
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>CFBundleDevelopmentRegion</key>
	<string>$(DEVELOPMENT_LANGUAGE)</string>
	<key>CFBundleExecutable</key>
	<string>$(EXECUTABLE_NAME)</string>
	<key>CFBundleIdentifier</key>
	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
	<key>CFBundleInfoDictionaryVersion</key>
	<string>6.0</string>
	<key>CFBundleName</key>
	<string>$(PRODUCT_NAME)</string>
	<key>CFBundlePackageType</key>
	<string>APPL</string>
	<key>CFBundleShortVersionString</key>
	<string>$(MARKETING_VERSION)</string>
	<key>CFBundleVersion</key>
	<string>$(CURRENT_PROJECT_VERSION)</string>
	<key>LSApplicationCategoryType</key>
	<string>public.app-category.utilities</string>
	<key>LSMinimumSystemVersion</key>
	<string>$(MACOSX_DEPLOYMENT_TARGET)</string>
	<key>LSUIElement</key>
	<true/>
	<key>NSHumanReadableCopyright</key>
	<string>Copyright © 2019 Brainbow. All rights reserved.</string>
	<key>NSMainStoryboardFile</key>
	<string>Main</string>
	<key>NSPrincipalClass</key>
	<string>NSApplication</string>
</dict>
</plist>

import Cocoa
import Defaults
import Settings
import Sparkle
import SwiftUI

@main
class AppDelegate: NSObject, NSApplicationDelegate, SPUStandardUserDriverDelegate {
  @IBOutlet var updateController: SPUStandardUpdaterController!

  var statusItem: StatusItem!
  var controller: Controller!
  var userState: UserState!

  lazy var settingsWindowController = SettingsWindowController(
    panes: [
      Settings.Pane(
        identifier: .general, title: "General",
        toolbarIcon: NSImage(named: NSImage.preferencesGeneralName)!,
        contentView: { GeneralPane() }
      )
    ]
  )

  func applicationDidFinishLaunching(_ aNotification: Notification) {
    // Check if running in preview mode
    #if DEBUG
      if ProcessInfo.processInfo.environment["XCODE_RUNNING_FOR_PREVIEWS"] == "1" {
        return  // Exit early if running in preview
      }
    #endif

    userState = UserState()
    controller = Controller(userState: userState)
    statusItem = StatusItem()

    statusItem.handlePreferences = {
      self.settingsWindowController.show()
    }
    statusItem.handleUpdates = {
      self.updateController.checkForUpdates(nil)
    }

    statusItem.enable()

    if AXIsProcessTrusted() {
      startListeningForMouseEvents()
    } else {
      requestAccessibilityPermission()
    }

    if Defaults[.showPreferencesOnLaunch] {
      settingsWindowController.show()
    }

    NotificationCenter.default.addObserver(
      self,
      selector: #selector(handleConfigurationStateChange),
      name: .configurationStateChanged,
      object: nil
    )
  }

  func startListeningForMouseEvents() {
    controller.startListeningForMouseEvents()
  }

  func requestAccessibilityPermission() {
    let promptKey = kAXTrustedCheckOptionPrompt.takeUnretainedValue() as String
    let opts = [promptKey: true] as CFDictionary
    let accessibilityEnabled = AXIsProcessTrustedWithOptions(opts)

    if accessibilityEnabled {
      startListeningForMouseEvents()
    } else {
      showAlertForAccessibilityPermission()
    }
  }

  func showAlertForAccessibilityPermission() {
    let alert = NSAlert()
    alert.messageText = "Accessibility Permission Required"
    alert.informativeText = "Please enable accessibility permissions in System Preferences."
    alert.alertStyle = .warning
    alert.addButton(withTitle: "OK")
    alert.addButton(withTitle: "Open System Preferences")

    let response = alert.runModal()
    if response == .alertSecondButtonReturn {
      openSystemPreferences()
    }
  }

  func openSystemPreferences() {
    if let url = URL(
      string: "x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility")
    {
      NSWorkspace.shared.open(url)
    }
  }

  @IBAction
  func settingsMenuItemActionHandler(_: NSMenuItem) {
    settingsWindowController.show()
  }

  @objc func handleConfigurationStateChange(_ notification: Notification) {
    if let isConfiguring = notification.object as? Bool {
      controller.setConfiguring(isConfiguring)
    }
  }

  // MARK: SPUStandardUserDriverDelegate

  var supportsGentleScheduledUpdateReminders: Bool = true
}

extension Notification.Name {
  static let mouseButtonSelected = Notification.Name("mouseButtonSelected")
  static let configurationStateChanged = Notification.Name("configurationStateChanged")
}
---
import Cocoa

class StatusItem {
  var statusItem: NSStatusItem?

  var handlePreferences: (() -> Void)?
  var handleUpdates: (() -> Void)?

  func enable() {
    statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.squareLength)

    guard let item = statusItem else {
      print("No status item")
      return
    }

    if let menubarButton = item.button {
      menubarButton.image = NSImage(named: NSImage.Name("StatusItem"))
    }

    let menu = NSMenu()

    let preferencesItem = NSMenuItem(
      title: "Preferences…", action: #selector(showPreferences), keyEquivalent: ","
    )
    preferencesItem.target = self
    menu.addItem(preferencesItem)

    let updatesItem = NSMenuItem(
      title: "Check for updates", action: #selector(checkForUpdates), keyEquivalent: ""
    )
    updatesItem.target = self
    menu.addItem(updatesItem)

    menu.addItem(NSMenuItem.separator())

    menu.addItem(
      NSMenuItem(
        title: "Quit Flick Ring", action: #selector(NSApplication.terminate(_:)), keyEquivalent: "q"
      ))

    item.menu = menu
  }

  @objc func showPreferences() {
    handlePreferences?()
  }

  @objc func checkForUpdates() {
    handleUpdates?()
  }
}
---
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>SUFeedURL</key>
	<string>https://flick-ring-updates.s3.amazonaws.com/appcast.xml</string>
	<key>SUPublicEDKey</key>
	<string>4ZfPYKvzE7b/uYW4B8f2v++7Bry/OmvYHCzl3g936KE=</string>
</dict>
</plist>