feat(desktop-ui): implement a desktop ui for appfaders

Package.swift

@@ -11,15 +11,21 @@ let package = Package(
     .executable(name: "AppFaders", targets: ["AppFaders"]),
     .executable(name: "AppFadersHelper", targets: ["AppFadersHelper"]),
     .library(name: "AppFadersDriver", type: .dynamic, targets: ["AppFadersDriver"]),
+    .library(name: "AppFadersCore", targets: ["AppFadersCore"]),
     .plugin(name: "BundleAssembler", targets: ["BundleAssembler"])
   ],
   dependencies: [
     .package(url: "https://github.com/sbooth/CAAudioHardware", from: "0.7.1")
   ],
   targets: [
+    .target(
+      name: "AppFadersCore",
+      dependencies: []
+    ),
     .executableTarget(
       name: "AppFaders",
       dependencies: [
+        "AppFadersCore",
         .product(name: "CAAudioHardware", package: "CAAudioHardware")
       ]
     ),
@@ -61,7 +67,7 @@ let package = Package(
     ),
     .testTarget(
       name: "AppFadersTests",
-      dependencies: ["AppFaders"]
+      dependencies: ["AppFaders", "AppFadersCore"]
     )
   ]
 )

Sources/AppFaders/AppDelegate.swift

@@ -0,0 +1,40 @@
+import AppFadersCore
+import AppKit
+import os.log
+
+private let log = OSLog(subsystem: "com.fbreidenbach.appfaders", category: "AppDelegate")
+
+@MainActor
+final class AppDelegate: NSObject, NSApplicationDelegate {
+  private var menuBarController: MenuBarController?
+  private let orchestrator = AudioOrchestrator()
+  private let deviceManager = DeviceManager()
+  private var appState: AppState?
+  private var orchestratorTask: Task<Void, Never>?
+
+  func applicationDidFinishLaunching(_ notification: Notification) {
+    os_log(.info, log: log, "AppFaders launching")
+
+    NSApp.setActivationPolicy(.accessory)
+
+    // Create AppState with dependencies
+    let state = AppState(orchestrator: orchestrator, deviceManager: deviceManager)
+    appState = state
+
+    // Create menu bar controller with state
+    menuBarController = MenuBarController(appState: state)
+
+    // Start orchestrator
+    orchestratorTask = Task {
+      await orchestrator.start()
+    }
+
+    os_log(.info, log: log, "AppFaders initialization complete")
+  }
+
+  func applicationWillTerminate(_ notification: Notification) {
+    os_log(.info, log: log, "AppFaders terminating")
+    orchestratorTask?.cancel()
+    orchestrator.stop()
+  }
+}

Sources/AppFaders/AppFadersApp.swift

@@ -0,0 +1,13 @@
+import AppKit
+
+@main
+struct AppFadersApp {
+  static func main() {
+    let app = NSApplication.shared
+    let delegate = AppDelegate()
+    app.delegate = delegate
+
+    // run() blocks until app terminates, keeping delegate alive
+    app.run()
+  }
+}

Sources/AppFaders/AppState.swift

@@ -0,0 +1,181 @@
+import AppFadersCore
+import AppKit
+import Foundation
+import Observation
+import os.log
+
+private let log = OSLog(subsystem: "com.fbreidenbach.appfaders", category: "AppState")
+
+// MARK: - AppVolumeState
+
+/// Represents the volume state for a single application
+/// Note: @unchecked Sendable because NSImage isn't Sendable, but this struct
+/// is only used within @MainActor context (AppState)
+struct AppVolumeState: Identifiable, @unchecked Sendable {
+  let id: String // bundleID
+  let name: String
+  let icon: NSImage?
+  var volume: Float // 0.0-1.0
+  var isMuted: Bool
+  var previousVolume: Float // for restore on unmute
+
+  var displayPercentage: String {
+    isMuted ? "Muted" : "\(Int(volume * 100))%"
+  }
+
+  init(from trackedApp: TrackedApp, volume: Float, isMuted: Bool = false) {
+    id = trackedApp.bundleID
+    name = trackedApp.localizedName
+    icon = trackedApp.icon
+    self.volume = volume
+    self.isMuted = isMuted
+    previousVolume = volume
+  }
+
+  /// Memberwise initializer for previews and testing
+  init(
+    id: String,
+    name: String,
+    icon: NSImage?,
+    volume: Float,
+    isMuted: Bool,
+    previousVolume: Float
+  ) {
+    self.id = id
+    self.name = name
+    self.icon = icon
+    self.volume = volume
+    self.isMuted = isMuted
+    self.previousVolume = previousVolume
+  }
+}
+
+// MARK: - AppState
+
+/// Central state container driving SwiftUI updates
+@MainActor
+@Observable
+final class AppState {
+  private(set) var apps: [AppVolumeState] = []
+  var masterVolume: Float = 1.0
+  var masterMuted: Bool = false
+  var isPanelVisible: Bool = false
+  var connectionError: String?
+
+  private let orchestrator: AudioOrchestrator
+  private let deviceManager: DeviceManager
+
+  init(orchestrator: AudioOrchestrator, deviceManager: DeviceManager) {
+    self.orchestrator = orchestrator
+    self.deviceManager = deviceManager
+
+    // Initialize master volume from system
+    masterVolume = deviceManager.getSystemVolume()
+    masterMuted = deviceManager.getSystemMute()
+
+    os_log(.info, log: log, "AppState initialized")
+  }
+
+  // MARK: - Per-App Volume Control
+
+  /// Sets the volume for a specific application
+  func setVolume(for bundleID: String, volume: Float) async {
+    guard let index = apps.firstIndex(where: { $0.id == bundleID }) else { return }
+
+    let clamped = max(0.0, min(1.0, volume))
+    apps[index].volume = clamped
+
+    // If setting volume while muted, unmute
+    if apps[index].isMuted, clamped > 0 {
+      apps[index].isMuted = false
+    }
+
+    await orchestrator.setVolume(for: bundleID, volume: clamped)
+  }
+
+  /// Toggles mute state for a specific application
+  func toggleMute(for bundleID: String) async {
+    guard let index = apps.firstIndex(where: { $0.id == bundleID }) else { return }
+
+    if apps[index].isMuted {
+      // Unmute: restore previous volume
+      apps[index].isMuted = false
+      apps[index].volume = apps[index].previousVolume
+      await orchestrator.setVolume(for: bundleID, volume: apps[index].previousVolume)
+    } else {
+      // Mute: store current volume, set to 0
+      apps[index].previousVolume = apps[index].volume
+      apps[index].isMuted = true
+      apps[index].volume = 0
+      await orchestrator.setVolume(for: bundleID, volume: 0)
+    }
+  }
+
+  // MARK: - Master Volume Control
+
+  /// Sets the master (system) volume
+  func setMasterVolume(_ volume: Float) {
+    let clamped = max(0.0, min(1.0, volume))
+    masterVolume = clamped
+
+    // If setting volume while muted, unmute
+    if masterMuted, clamped > 0 {
+      masterMuted = false
+      deviceManager.setSystemMute(false)
+    }
+
+    deviceManager.setSystemVolume(clamped)
+  }
+
+  /// Toggles master (system) mute
+  func toggleMasterMute() {
+    masterMuted.toggle()
+    deviceManager.setSystemMute(masterMuted)
+  }
+
+  // MARK: - Sync from Orchestrator
+
+  /// Syncs app list from AudioOrchestrator's tracked apps and volumes
+  func syncFromOrchestrator() {
+    let trackedApps = orchestrator.trackedApps
+    let volumes = orchestrator.appVolumes
+
+    // Build new app states, preserving mute state for existing apps
+    var newApps: [AppVolumeState] = []
+    for trackedApp in trackedApps {
+      let volume = volumes[trackedApp.bundleID] ?? 1.0
+
+      // Check if we have existing state for this app (preserve mute)
+      if let existing = apps.first(where: { $0.id == trackedApp.bundleID }) {
+        var updated = AppVolumeState(from: trackedApp, volume: volume, isMuted: existing.isMuted)
+        updated.previousVolume = existing.previousVolume
+        // If muted, keep showing 0 volume
+        if existing.isMuted {
+          updated.volume = 0
+        }
+        newApps.append(updated)
+      } else {
+        newApps.append(AppVolumeState(from: trackedApp, volume: volume))
+      }
+    }
+
+    apps = newApps
+
+    // Update connection error status
+    connectionError = orchestrator.isDriverConnected ? nil : "Helper service not connected"
+  }
+
+  /// Refreshes master volume from system (call when panel opens)
+  func refreshMasterVolume() {
+    masterVolume = deviceManager.getSystemVolume()
+    masterMuted = deviceManager.getSystemMute()
+  }
+
+  // MARK: - App Lifecycle
+
+  /// Terminates the application
+  func quit() {
+    os_log(.info, log: log, "Quit requested via AppState")
+    NSApp.terminate(nil)
+  }
+}

Sources/AppFaders/AudioOrchestrator.swift

@@ -1,3 +1,4 @@
+import AppFadersCore
 import CAAudioHardware
 import Foundation
 import Observation
@@ -21,7 +22,15 @@ final class AudioOrchestrator {
     deviceManager = DeviceManager()
     appAudioMonitor = AppAudioMonitor()
     driverBridge = DriverBridge()
-    os_log(.info, log: log, "AudioOrchestrator initialized")
+
+    // Populate apps immediately so they're available before start() runs
+    appAudioMonitor.start()
+    for app in appAudioMonitor.runningApps {
+      trackedApps.append(app)
+      appVolumes[app.bundleID] = 1.0
+    }
+
+    os_log(.info, log: log, "AudioOrchestrator initialized with %d apps", trackedApps.count)
   }
 
   // MARK: - Lifecycle
@@ -36,12 +45,7 @@ final class AudioOrchestrator {
     let deviceUpdates = deviceManager.deviceListUpdates
     let appEvents = appAudioMonitor.events
 
-    appAudioMonitor.start()
-
-    for app in appAudioMonitor.runningApps {
-      trackApp(app)
-    }
-
+    // Apps already populated in init(), just connect to helper
     await connectToHelper()
 
     await withTaskGroup(of: Void.self) { group in

Sources/AppFaders/Components/MuteButton.swift

@@ -0,0 +1,47 @@
+import SwiftUI
+
+/// Clickable speaker/muted icon toggle matching Pencil design (tLYj9, u847K)
+struct MuteButton: View {
+  let isMuted: Bool
+  let onToggle: () -> Void
+
+  private let speakerColor = AppColors.sliderThumb
+  private let mutedColor = AppColors.accent
+
+  var body: some View {
+    Button(action: onToggle) {
+      Image(systemName: isMuted ? "speaker.slash.fill" : "speaker.wave.2.fill")
+        .font(.system(size: 18))
+        .foregroundStyle(isMuted ? mutedColor : speakerColor)
+        .frame(width: 23, height: 18)
+        .contentShape(Rectangle())
+    }
+    .buttonStyle(.plain)
+  }
+}
+
+// MARK: - Previews
+
+#Preview("Unmuted - Light") {
+  MuteButton(isMuted: false, onToggle: {})
+    .padding()
+    .preferredColorScheme(.light)
+}
+
+#Preview("Muted - Light") {
+  MuteButton(isMuted: true, onToggle: {})
+    .padding()
+    .preferredColorScheme(.light)
+}
+
+#Preview("Unmuted - Dark") {
+  MuteButton(isMuted: false, onToggle: {})
+    .padding()
+    .preferredColorScheme(.dark)
+}
+
+#Preview("Muted - Dark") {
+  MuteButton(isMuted: true, onToggle: {})
+    .padding()
+    .preferredColorScheme(.dark)
+}