v1.0.3: finish audit backlog + new features

Fixes:
- Match Dock tiles by bundle id (AXURL) so two apps sharing a name no longer
  cross-wire badges; fall back to title.
- Don't walk the Dock for a monitored app that isn't running (a tile only
  exists for running apps) — kills the perpetual every-few-seconds walk.
- Robust badge parsing: handles "9+" and non-numeric labels; extracted a pure,
  unit-tested isNewMessage().
- Deterministic candidate-title order (ordered dedupe instead of Set).
- Pick the live (non-terminated) Dock process instead of an arbitrary one.
- AlertPresenter serializes alerts (no overwrite / no stale fade hiding a fresh
  panel) and reuses a single cached icon service (AppIcons); dropped duplicate
  icon loaders.

Features:
- Configurable poll interval (1 / 2 / 5 s) — re-arms the timer live.
- Per-app overrides (show count, floating alert) via the icon's right-click menu.
- Drag-to-reorder monitored apps; the menu bar follows the new order.
- "Check for Updates…" (GitHub Releases API) in the menus and Settings.
- Turkish/English localization (resource-free table, follows system language).
- Unit tests (Tests/) + GitHub Actions CI (.github/workflows/ci.yml).
- Shared signing-config.sh so build.sh / setup-signing.sh can't drift.

Bump to 1.0.3.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: ahmetrende

.github/workflows/ci.yml

@@ -0,0 +1,18 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  build-test:
+    runs-on: macos-14
+    steps:
+      - uses: actions/checkout@v4
+      - name: Swift version
+        run: swift --version
+      - name: Build
+        run: swift build
+      - name: Test
+        run: swift test

Info.plist

@@ -15,9 +15,9 @@
 	<key>CFBundlePackageType</key>
 	<string>APPL</string>
 	<key>CFBundleShortVersionString</key>
-	<string>1.0.2</string>
+	<string>1.0.3</string>
 	<key>CFBundleVersion</key>
-	<string>3</string>
+	<string>4</string>
 	<key>LSMinimumSystemVersion</key>
 	<string>14.0</string>
 	<key>LSUIElement</key>

Package.swift

@@ -8,6 +8,11 @@ let package = Package(
         .executableTarget(
             name: "BadgeBar",
             path: "Sources/BadgeBar"
+        ),
+        .testTarget(
+            name: "BadgeBarTests",
+            dependencies: ["BadgeBar"],
+            path: "Tests/BadgeBarTests"
         )
     ],
     swiftLanguageModes: [.v5]

README.md

@@ -90,7 +90,8 @@ icon appears there instead; click it to grant access.
 
 The configuration window has two tabs:
 
-- **Apps** — search installed apps and add/remove them from the menu bar.
+- **Apps** — search installed apps to add/remove them, and **drag the monitored
+  list to reorder** how icons appear in the menu bar.
 - **Settings**:
   - **Menu bar**
     - *Show unread count* — off shows a small red dot instead of the number.
@@ -99,12 +100,20 @@ The configuration window has two tabs:
     - *Dim the icon when there's no notification* — greys it out instead of
       hiding.
     - *Hide an app when it isn't running* — removes the icon while closed.
+    - *Always show a BadgeBar icon* — keep a permanent menu-bar entry.
   - **On-screen alert** — a floating alert that appears briefly on top of
     everything (including full-screen apps) when a new message arrives.
     Toggle on/off and choose how long it stays (2 / 4 / 6 s). Click it to open
     the app.
-  - **General** — *Launch at login* (via `SMAppService`).
+  - **General** — *Launch at login* (via `SMAppService`), a *Poll interval*
+    (1 / 2 / 5 s) to trade latency for fewer wakeups, and *Check for Updates…*.
   - **Permissions** — Accessibility status with a deep-link to System Settings.
+    If access is revoked while running, a warning icon appears in the menu bar.
+
+**Per-app overrides:** right-click an app's menu-bar icon → *This app* to
+override *Show unread count* or the floating alert just for that app.
+
+The UI is localized (English / Turkish, following your system language).
 
 ## Performance
 
@@ -181,7 +190,13 @@ Sources/BadgeBar/
 ## Contributing
 
 Issues and pull requests are welcome. To hack on it: clone, run `./run.sh`, and
-edit. No Xcode required (though `Package.swift` opens in Xcode too).
+edit. No Xcode required to build the app (though `Package.swift` opens in Xcode
+too).
+
+Unit tests cover the pure logic (badge-change detection, version comparison,
+model persistence). Run them with `swift test` — this needs XCTest, which ships
+with Xcode, so it runs in CI (GitHub Actions, `.github/workflows/ci.yml`) even
+if your local machine only has the Command Line Tools.
 
 ## License
 

Sources/BadgeBar/AlertPresenter.swift

@@ -10,23 +10,43 @@ final class AlertPresenter {
     private var hosting: NSHostingController<FloatingAlertView>?
     private var dismissTask: DispatchWorkItem?
 
+    /// Pending alerts shown one after another so a burst doesn't overwrite
+    /// itself. At most one entry per app (latest badge wins).
+    private var queue: [(app: MonitoredApp, badge: String)] = []
+    private var showing = false
+
+    /// Whether the alert is enabled is decided by the caller (global + per-app);
+    /// this just presents. Alerts are serialized so a new one never clobbers a
+    /// visible one, and a stale fade-out can never hide a fresh panel.
     func show(app: MonitoredApp, badge: String) {
-        guard Settings.floatingAlertEnabled else { return }
+        queue.removeAll { $0.app.bundleId == app.bundleId }
+        queue.append((app, badge))
+        if !showing { presentNext() }
+    }
+
+    private func presentNext() {
+        guard !queue.isEmpty else {
+            showing = false
+            return
+        }
+        showing = true
+        let (app, badge) = queue.removeFirst()
 
-        let icon = AppIconLoader.icon(forBundleId: app.bundleId)
-        let view = FloatingAlertView(icon: icon, appName: app.name, badge: badge) {
+        let view = FloatingAlertView(icon: AppIcons.icon(forBundleId: app.bundleId),
+                                     appName: app.name,
+                                     badge: badge) {
             AppLauncher.activate(bundleId: app.bundleId)
         }
 
         let panel = ensurePanel()
         hosting?.rootView = view
         position(panel)
-
-        panel.alphaValue = 0
         panel.orderFrontRegardless()
-        NSAnimationContext.runAnimationGroup { context in
-            context.duration = 0.18
-            panel.animator().alphaValue = 1
+        if panel.alphaValue < 1 {
+            NSAnimationContext.runAnimationGroup { context in
+                context.duration = 0.18
+                panel.animator().alphaValue = 1
+            }
         }
 
         scheduleDismiss()
@@ -81,12 +101,31 @@ final class AlertPresenter {
     }
 
     private func dismiss() {
-        guard let panel else { return }
+        guard let panel else {
+            showing = false
+            presentNext()
+            return
+        }
+        // If another alert is queued, hand the panel straight to it (no flicker);
+        // otherwise fade out and hide.
+        if !queue.isEmpty {
+            presentNext()
+            return
+        }
         NSAnimationContext.runAnimationGroup { context in
             context.duration = 0.3
             panel.animator().alphaValue = 0
-        } completionHandler: {
-            panel.orderOut(nil)
+        } completionHandler: { [weak self] in
+            // NSAnimationContext completions run on the main thread.
+            MainActor.assumeIsolated {
+                guard let self else { return }
+                if self.queue.isEmpty {
+                    panel.orderOut(nil)
+                    self.showing = false
+                } else {
+                    self.presentNext()
+                }
+            }
         }
     }
 }
@@ -107,7 +146,7 @@ private struct FloatingAlertView: View {
                 Text(appName.isEmpty ? " " : appName)
                     .font(.headline)
                     .lineLimit(1)
-                Text("New notification")
+                Text(L.t("New notification"))
                     .font(.subheadline)
                     .foregroundStyle(.secondary)
             }

Sources/BadgeBar/AppIcons.swift

@@ -0,0 +1,21 @@
+import AppKit
+
+/// Single cached source of app icons keyed by bundle id. NSCache evicts under
+/// memory pressure, so there's nothing to prune manually.
+enum AppIcons {
+    private static let cache = NSCache<NSString, NSImage>()
+
+    static func icon(forBundleId bundleId: String) -> NSImage {
+        if let hit = cache.object(forKey: bundleId as NSString) {
+            return hit
+        }
+        let image: NSImage
+        if let url = NSWorkspace.shared.urlForApplication(withBundleIdentifier: bundleId) {
+            image = NSWorkspace.shared.icon(forFile: url.path)
+        } else {
+            image = NSImage(systemSymbolName: "app.dashed", accessibilityDescription: nil) ?? NSImage()
+        }
+        cache.setObject(image, forKey: bundleId as NSString)
+        return image
+    }
+}

Sources/BadgeBar/BadgeMonitor.swift

@@ -6,11 +6,10 @@ import Foundation
 /// walk per second costs well under a millisecond.
 @MainActor
 final class BadgeMonitor {
-    private static let interval: TimeInterval = 1.0
-
     private let store: AppStore
     private let reader = BadgeReader()
     private var timer: Timer?
+    private var currentInterval: TimeInterval = 0
 
     /// Previous badge text per bundle id, for detecting new messages.
     private var previousText: [String: String] = [:]
@@ -30,10 +29,33 @@ final class BadgeMonitor {
     }
 
     func start() {
-        timer = Timer.scheduledTimer(withTimeInterval: Self.interval, repeats: true) { [weak self] _ in
+        scheduleTimer()
+        timer?.fire()
+    }
+
+    private func scheduleTimer() {
+        timer?.invalidate()
+        currentInterval = Settings.pollInterval
+        timer = Timer.scheduledTimer(withTimeInterval: currentInterval, repeats: true) { [weak self] _ in
             MainActor.assumeIsolated { self?.tick() }
         }
-        timer?.fire()
+    }
+
+    /// Decides whether a badge change should raise a "new message" alert.
+    /// Fires on first appearance, a numeric increase (handles "9+"), or any
+    /// change involving non-numeric text. Pure so it's unit-testable.
+    nonisolated static func isNewMessage(old: String, new: String) -> Bool {
+        guard !new.isEmpty, new != old else { return false }
+        if old.isEmpty { return true }
+        if let newN = leadingInt(new), let oldN = leadingInt(old) {
+            return newN > oldN
+        }
+        return true
+    }
+
+    nonisolated private static func leadingInt(_ text: String) -> Int? {
+        let digits = text.prefix { $0.isNumber }
+        return digits.isEmpty ? nil : Int(digits)
     }
 
     private func tick() {
@@ -74,15 +96,17 @@ final class BadgeMonitor {
                     continue
                 }
 
-                // Fire on a numeric increase, or an empty→non-empty transition.
-                let isNew = !newText.isEmpty
-                    && newText != oldText
-                    && ((Int(newText) ?? 0) > (Int(oldText) ?? 0) || oldText.isEmpty)
-                if isNew {
+                if Self.isNewMessage(old: oldText, new: newText),
+                   app.alerts(default: Settings.floatingAlertEnabled) {
                     onNewMessage?(app, newText)
                 }
             }
         }
         onTick?()
+
+        // Re-arm the timer if the user changed the poll interval.
+        if Settings.pollInterval != currentInterval {
+            scheduleTimer()
+        }
     }
 }