Replace DistributedNotificationCenter IPC with XPC (XPCListener/XPCSession)

CLI commands now communicate with the daemon over XPC (Mach service)
instead of file writes + distributed notification pings. This provides
reliable bidirectional communication, eliminates the duplicate mute
logic race condition, and prepares for future sandboxing.

Daemon: XPCListener with typed Codable handler (MicGuardRequest →
MicGuardResponse), no @objc protocol needed.
Client: XPCSession created as inactive, then activate() which throws
XPCRichError gracefully if the Mach service is unavailable (avoids
the _xpc_api_misuse trap on dealloc). cancel() before cleanup.
Login: SMAppService.agent with embedded LaunchAgent plist replaces
SMAppService.mainApp (provides Mach service registration via launchd).

DistributedNotificationCenter kept for outbound statusChanged/appTerminated
broadcasts to external consumers (SketchyBar). Zero integration impact.

Adds make dev/dev-stop targets for local XPC testing via launchctl.

Author: pszypowicz

Makefile

@@ -12,4 +12,26 @@ uninstall:
 zip: build
 	cd .build && zip -ry MicGuard.zip MicGuard.app bin/mic-guard
 
-.PHONY: build install uninstall zip
+# Development: build bundle, register LaunchAgent (Mach service), and launch daemon.
+# After this, `mic-guard` CLI commands work via XPC.
+dev: build
+	-killall MicGuard 2>/dev/null
+	-launchctl bootout gui/$$(id -u)/com.pszypowicz.MicGuard 2>/dev/null
+	@# Generate dev plist with absolute ProgramArguments (launchctl needs it, SMAppService doesn't)
+	/usr/libexec/PlistBuddy -c "Copy :. :" \
+		-c "Add :ProgramArguments array" \
+		-c "Add :ProgramArguments:0 string $$(pwd)/.build/MicGuard.app/Contents/MacOS/MicGuard" \
+		.build/MicGuard.app/Contents/Library/LaunchAgents/com.pszypowicz.MicGuard.agent.plist 2>/dev/null || \
+	/usr/libexec/PlistBuddy \
+		-c "Set :ProgramArguments:0 $$(pwd)/.build/MicGuard.app/Contents/MacOS/MicGuard" \
+		.build/MicGuard.app/Contents/Library/LaunchAgents/com.pszypowicz.MicGuard.agent.plist
+	launchctl bootstrap gui/$$(id -u) .build/MicGuard.app/Contents/Library/LaunchAgents/com.pszypowicz.MicGuard.agent.plist
+	@echo "Daemon running with XPC. Test with: .build/bin/mic-guard list"
+
+# Stop the dev daemon and unregister the LaunchAgent.
+dev-stop:
+	-killall MicGuard 2>/dev/null
+	-launchctl bootout gui/$$(id -u)/com.pszypowicz.MicGuard 2>/dev/null
+	@echo "Daemon stopped and LaunchAgent unregistered."
+
+.PHONY: build install uninstall zip dev dev-stop

README.md

@@ -34,7 +34,7 @@ On first launch the current input device becomes your preferred mic. You can cha
 
 - **Menubar daemon** — runs silently in the background with a shield+mic icon
 - **Auto-revert** — reverts unwanted input device switches caused by Bluetooth connections
-- **Mute / volume control** — toggle mute and set input volume via CLI or distributed notifications
+- **Mute / volume control** — toggle mute and set input volume via CLI
 - **CLI tool** — `mic-guard` binary for scripting (`list`, `set`, `enable`, `toggle`, `mute`, `volume`, etc.)
 - **SketchyBar integration** — reference plugin with shield + mic items, device picker popup, and mute on click
 - **Distributed notifications** — real-time status broadcasts for custom integrations

Resources/com.pszypowicz.MicGuard.agent.plist

@@ -0,0 +1,25 @@
+<?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>Label</key>
+    <string>com.pszypowicz.MicGuard</string>
+    <key>BundleProgram</key>
+    <string>Contents/MacOS/MicGuard</string>
+    <key>MachServices</key>
+    <dict>
+        <key>com.pszypowicz.MicGuard.xpc</key>
+        <true/>
+    </dict>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>LimitLoadToSessionType</key>
+    <string>Aqua</string>
+    <key>AssociatedBundleIdentifiers</key>
+    <array>
+        <string>com.pszypowicz.MicGuard</string>
+    </array>
+</dict>
+</plist>

Sources/MicGuard/MicGuardApp.swift

@@ -54,31 +54,18 @@ struct MicGuardApp: App {
             exit(0)
         }
 
-        // Daemon mode — ensure single instance via fcntl lock file
+        // Daemon mode
         Config.ensureConfigDir()
-        let lockPath = Config.configDir.appending(component: "lock").path(percentEncoded: false)
-        let lockFD = open(lockPath, O_CREAT | O_WRONLY, 0o600)
-        guard lockFD != -1 else {
-            logger.error("Could not create lock file — exiting")
-            exit(1)
-        }
-        var lock = flock(
-            l_start: 0, l_len: 0, l_pid: getpid(),
-            l_type: Int16(F_WRLCK), l_whence: Int16(SEEK_SET)
-        )
-        if fcntl(lockFD, F_SETLK, &lock) == -1 {
-            // Query which process holds the lock
-            var info = lock
-            _ = fcntl(lockFD, F_GETLK, &info)
-            logger.info("Another instance is already running (PID \(info.l_pid, privacy: .public)) — exiting")
-            exit(0)
-        }
-        // lockFD intentionally kept open — kernel releases lock on exit/crash
-
         logger.info("MicGuard starting")
         installSignalHandlers()
 
         AudioMonitor.shared.start()
+
+        // Try to start the XPC listener. This only succeeds when the process
+        // was launched by launchd with the Mach service registered (make dev).
+        // Ad-hoc signed Homebrew builds can't use SMAppService.agent() due to
+        // Launch Constraint Violations — see GitHub issue #1 for details.
+        AudioMonitor.shared.startXPCListener()
     }
 
     var body: some Scene {
@@ -252,24 +239,15 @@ struct MicGuardApp: App {
                 fputs("No input device found\n", stderr)
                 exit(1)
             }
-            // Determine current mute state from hardware.  The daemon tracks
-            // isMuted in software, but the CLI is short-lived so we read the
-            // hardware directly: volume == 0 OR hw-mute flag set → muted.
             let hwMuted = AudioDevices.isInputMuted(for: device.id) == true
             let hwVol = AudioDevices.inputVolume(for: device.id) ?? 0
             let currentlyMuted = hwMuted || hwVol == 0
-
             if currentlyMuted {
-                // Unmute: clear hw mute and set a fallback volume.  If the daemon
-                // is running, its mute listener will detect the hw flag change and
-                // restore the real pre-mute volume, overriding this fallback.
                 _ = AudioDevices.setInputMuted(for: device.id, muted: false)
                 if hwVol == 0 {
                     _ = AudioDevices.setInputVolume(for: device.id, volume: 50)
                 }
             } else {
-                // Mute: zero volume and set hw mute flag.  The daemon's volume
-                // listener will detect vol → 0 and save the pre-mute volume.
                 _ = AudioDevices.setInputVolume(for: device.id, volume: 0)
                 _ = AudioDevices.setInputMuted(for: device.id, muted: true)
             }

Sources/MicGuardCore/AudioMonitor.swift

@@ -2,6 +2,7 @@ import CoreAudio
 import Foundation
 import Observation
 import os
+@preconcurrency import XPC
 
 @Observable
 @MainActor
@@ -38,6 +39,8 @@ public final class AudioMonitor {
 
 
     private var statusDebounceWork: DispatchWorkItem?
+    @ObservationIgnored
+    private var xpcListener: XPCListener?
     var preMuteVolume: Int = 100
 
     let audio: any AudioDeviceProviding
@@ -528,6 +531,146 @@ public final class AudioMonitor {
         }
     }
 
+    // MARK: - XPC
+
+    /// Start the XPC listener. Returns true if the Mach service is available
+    /// (process was launched by launchd with the service registered).
+    @discardableResult
+    public func startXPCListener() -> Bool {
+        do {
+            xpcListener = try XPCListener(service: micGuardMachService, targetQueue: .main) { request in
+                request.accept { [weak self] (req: MicGuardRequest) -> MicGuardResponse in
+                    guard let self else { return .error(message: "Daemon shutting down") }
+                    return MainActor.assumeIsolated {
+                        self.handleRequest(req)
+                    }
+                }
+            }
+            logger.info("XPC listener started on '\(micGuardMachService, privacy: .public)'")
+            return true
+        } catch {
+            logger.error("Failed to start XPC listener: \(error, privacy: .public)")
+            return false
+        }
+    }
+
+    /// Handle an XPC request from the CLI and return a response.
+    public func handleRequest(_ request: MicGuardRequest) -> MicGuardResponse {
+        switch request {
+        case .ping:
+            postStatusChanged()
+            return .ok
+
+        case .enable:
+            isEnabled = true
+            return .ok
+
+        case .disable:
+            isEnabled = false
+            return .ok
+
+        case .toggle:
+            isEnabled = !isEnabled
+            return .statusInfo(enabled: isEnabled, mode: mode)
+
+        case .status:
+            return .statusInfo(enabled: isEnabled, mode: mode)
+
+        case .setDevice(let name):
+            guard inputDevices.contains(where: { $0.name == name }) else {
+                return .error(message: "Device '\(name)' not found")
+            }
+            setMode("manual")
+            setPreferredDevice(name: name)
+            return .ok
+
+        case .setVolume(let volume):
+            guard let device = audio.currentInputDevice() else {
+                return .error(message: "No input device found")
+            }
+            guard audio.setInputVolume(for: device.id, volume: volume) else {
+                return .error(message: "Failed to set volume")
+            }
+            inputVolume = volume
+            if volume > 0 && isMuted {
+                isMuted = false
+            } else if volume == 0 && !isMuted {
+                preMuteVolume = max(inputVolume, 1)
+                isMuted = true
+            }
+            debouncedPostStatusChanged()
+            return .ok
+
+        case .mute:
+            return toggleMute()
+
+        case .list:
+            return .deviceList(buildDeviceInfoList())
+
+        case .current:
+            return .device(name: currentDevice.isEmpty ? nil : currentDevice)
+        }
+    }
+
+    /// Toggle mute on the current input device using the daemon's mute state.
+    @discardableResult
+    public func toggleMute() -> MicGuardResponse {
+        guard let device = audio.currentInputDevice() else {
+            return .error(message: "No input device found")
+        }
+        if isMuted {
+            _ = audio.setInputMuted(for: device.id, muted: false)
+            _ = audio.setInputVolume(for: device.id, volume: preMuteVolume)
+            isMuted = false
+            inputVolume = preMuteVolume
+            logger.info("toggleMute: unmuted '\(device.name, privacy: .public)' vol=\(self.preMuteVolume, privacy: .public)")
+        } else {
+            preMuteVolume = max(inputVolume, 1)
+            _ = audio.setInputVolume(for: device.id, volume: 0)
+            _ = audio.setInputMuted(for: device.id, muted: true)
+            isMuted = true
+            inputVolume = 0
+            logger.info("toggleMute: muted '\(device.name, privacy: .public)' saved vol=\(self.preMuteVolume, privacy: .public)")
+        }
+        postStatusChanged()
+        return .ok
+    }
+
+    /// Build a sorted list of DeviceInfo for XPC and status broadcasting.
+    public func buildDeviceInfoList() -> [DeviceInfo] {
+        var devices: [DeviceInfo] = inputDevices
+            .sorted { $0.name.localizedCaseInsensitiveCompare($1.name) == .orderedAscending }
+            .map { device in
+                let isCurrent = device.name == currentDevice
+                let vol = (isCurrent && isMuted) ? 0 : (audio.inputVolume(for: device.id) ?? 0)
+                let muted = (isCurrent && isMuted) || (audio.isInputMuted(for: device.id) ?? false)
+                return DeviceInfo(
+                    name: device.name,
+                    current: isCurrent,
+                    volume: vol,
+                    muted: muted,
+                    available: true,
+                    preferred: device.name == preferredDevice
+                )
+            }
+
+        // If the preferred device is disconnected, append it as unavailable
+        if !preferredDevice.isEmpty,
+           !devices.contains(where: { $0.name == preferredDevice }) {
+            devices.append(DeviceInfo(
+                name: preferredDevice,
+                current: false,
+                volume: 0,
+                muted: false,
+                available: false,
+                preferred: true
+            ))
+            devices.sort { $0.name.localizedCaseInsensitiveCompare($1.name) == .orderedAscending }
+        }
+
+        return devices
+    }
+
     // MARK: - Status Notifications
 
     private func debouncedPostStatusChanged() {
@@ -545,39 +688,15 @@ public final class AudioMonitor {
         statusDebounceWork?.cancel()
         logger.debug("postStatusChanged: isMuted=\(self.isMuted, privacy: .public) inputVolume=\(self.inputVolume, privacy: .public) currentDevice='\(self.currentDevice, privacy: .public)'")
 
-        // Build per-device status, sorted alphabetically
-        var devices: [[String: Any]] = inputDevices
-            .sorted { $0.name.localizedCaseInsensitiveCompare($1.name) == .orderedAscending }
-            .map { device in
-                let isCurrent = device.name == currentDevice
-                let vol = (isCurrent && isMuted) ? 0 : (audio.inputVolume(for: device.id) ?? 0)
-                let muted = (isCurrent && isMuted) || (audio.isInputMuted(for: device.id) ?? false)
-                return [
-                    "name": device.name,
-                    "current": isCurrent,
-                    "volume": vol,
-                    "muted": muted,
-                    "available": true,
-                    "preferred": device.name == preferredDevice,
-                ]
-            }
-
-        // If the preferred device is disconnected, append it as unavailable
-        if !preferredDevice.isEmpty,
-           !devices.contains(where: { ($0["name"] as? String) == preferredDevice }) {
-            devices.append([
-                "name": preferredDevice,
-                "current": false,
-                "volume": 0,
-                "muted": false,
-                "available": false,
-                "preferred": true,
-            ])
-            devices.sort {
-                let a = ($0["name"] as? String) ?? ""
-                let b = ($1["name"] as? String) ?? ""
-                return a.localizedCaseInsensitiveCompare(b) == .orderedAscending
-            }
+        let devices: [[String: Any]] = buildDeviceInfoList().map { d in
+            [
+                "name": d.name,
+                "current": d.current,
+                "volume": d.volume,
+                "muted": d.muted,
+                "available": d.available,
+                "preferred": d.preferred,
+            ]
         }
 
         let payload: [String: Any] = [
@@ -602,3 +721,4 @@ public final class AudioMonitor {
         )
     }
 }
+

Sources/MicGuardCore/XPCClient.swift

@@ -0,0 +1,18 @@
+@preconcurrency import XPC
+
+/// Send a request to the MicGuard daemon over XPC and return the response.
+///
+/// Creates the session as inactive, then activates manually — `activate()` throws
+/// a `XPCRichError` (instead of trapping) if the Mach service is unavailable.
+/// Returns `nil` if the daemon is not running or the request fails.
+public func sendDaemonRequest(_ request: MicGuardRequest) -> MicGuardResponse? {
+    do {
+        let session = try XPCSession(machService: micGuardMachService, options: .inactive)
+        try session.activate()
+        defer { session.cancel(reason: "CLI request complete") }
+        let reply: MicGuardResponse = try session.sendSync(request)
+        return reply
+    } catch {
+        return nil
+    }
+}