agent-cli 0.95.5__tar.gz → 0.95.7__tar.gz

{agent_cli-0.95.5 → agent_cli-0.95.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-cli
-Version: 0.95.5
+Version: 0.95.7
 Summary: A suite of AI-powered command-line tools for text correction, audio transcription, and voice assistance.
 Project-URL: Homepage, https://github.com/basnijholt/agent-cli
 Author-email: Bas Nijholt <bas@nijho.lt>

{agent_cli-0.95.5 → agent_cli-0.95.7}/agent_cli/install/service_config.py

@@ -152,6 +152,12 @@ def build_service_command(
 
 def find_uv(extra_paths: list[Path] | None = None) -> Path | None:
     """Find uv executable, preferring system paths over virtualenv."""
+    explicit_uv = os.environ.get("AGENTCLI_UV_PATH")
+    if explicit_uv:
+        explicit_uv_path = Path(explicit_uv).expanduser()
+        if explicit_uv_path.is_file() and os.access(explicit_uv_path, os.X_OK):
+            return explicit_uv_path
+
     bundled_uv = os.environ.get("AGENTCLI_BUNDLED_UV")
     if bundled_uv:
         bundled_uv_path = Path(bundled_uv).expanduser()
@@ -187,7 +193,6 @@ def install_uv() -> tuple[bool, str]:
             ["sh"],  # noqa: S607
             input=result.stdout,
             capture_output=True,
-            text=True,
             check=True,
         )
         return True, "uv installed successfully"

{agent_cli-0.95.5 → agent_cli-0.95.7}/macos/AgentCLI/Sources/AgentCLI/AgentCLIApp.swift

@@ -167,7 +167,7 @@ struct AgentCLIApp: App {
                 Label("Quit", systemImage: "power")
             }
         } label: {
-            AgentCLIMenuBarIcon(isRecording: runner.isRecording)
+            AgentCLIMenuBarIcon(state: runner.menuBarIconState)
         }
         .menuBarExtraStyle(.menu)
 

{agent_cli-0.95.5 → agent_cli-0.95.7}/macos/AgentCLI/Sources/AgentCLI/AgentCommand.swift

@@ -1,11 +1,5 @@
 import Foundation
 
-enum AgentBootstrapRequirement: Equatable {
-    case cliRuntime
-    case transcription
-    case transcriptionModel
-}
-
 struct AgentCommand {
     let identifier: String
     let title: String

{agent_cli-0.95.5 → agent_cli-0.95.7}/macos/AgentCLI/Sources/AgentCLI/AgentCommandRunner.swift

@@ -19,8 +19,6 @@ private enum HoldTranscriptionState {
     }
 }
 
-typealias AgentBootstrap = @Sendable (AgentBootstrapRequirement, Bool) -> CommandResult
-
 @MainActor
 final class AgentCommandRunner: ObservableObject {
     static let shared = AgentCommandRunner()
@@ -29,6 +27,7 @@ final class AgentCommandRunner: ObservableObject {
     @Published var lastOutput = ""
     @Published private(set) var hasLastError = false
     @Published private(set) var isRecording = false
+    @Published private(set) var bootstrapPhase: BootstrapPhase = .idle
     @Published private var activeCommandCount = 0
     private var recordingIndicator = RecordingIndicatorController()
     private let pasteController: TranscriptPasteController
@@ -47,6 +46,9 @@ final class AgentCommandRunner: ObservableObject {
         if isRecording {
             return "Recording"
         }
+        if bootstrapPhase.isPreparing {
+            return bootstrapPhase.statusMessage
+        }
         if holdTranscriptionState.isFinishing {
             return "Transcribing..."
         }
@@ -56,10 +58,20 @@ final class AgentCommandRunner: ObservableObject {
         return Self.compactMenuStatus(statusMessage)
     }
 
+    var menuBarIconState: MenuBarIconState {
+        if isRecording {
+            return .recording
+        }
+        if bootstrapPhase.isPreparing {
+            return .preparing
+        }
+        return .idle
+    }
+
     init(
         pasteController: TranscriptPasteController = TranscriptPasteController(),
-        bootstrap: @escaping AgentBootstrap = { requirement, force in
-            AgentRuntime.shared.ensureReady(for: requirement, force: force)
+        bootstrap: @escaping AgentBootstrap = { requirement, force, progress in
+            AgentRuntime.shared.ensureReady(for: requirement, force: force, progress: progress)
         }
     ) {
         self.pasteController = pasteController
@@ -82,13 +94,12 @@ final class AgentCommandRunner: ObservableObject {
         hasStartedTranscriptionWarmUp = true
 
         activeCommandCount += 1
-        if statusMessage == "Ready" {
-            statusMessage = "Preparing voice service..."
-        }
+        reportBootstrapPhase(.checkingRuntime)
 
         let bootstrap = self.bootstrap
+        let reportBootstrapPhase = makeBootstrapProgressReporter()
         DispatchQueue.global(qos: .utility).async {
-            let result = bootstrap(.transcriptionModel, false)
+            let result = bootstrap(.transcriptionModel, false, reportBootstrapPhase)
 
             Task { @MainActor in
                 self.activeCommandCount = max(0, self.activeCommandCount - 1)
@@ -97,12 +108,11 @@ final class AgentCommandRunner: ObservableObject {
                 }
 
                 if result.exitCode == 0 {
-                    if self.statusMessage == "Preparing voice service..." {
-                        self.statusMessage = "Ready"
-                    }
+                    self.reportBootstrapPhase(.idle)
                     return
                 }
 
+                self.reportBootstrapPhase(.failed)
                 self.recordFailure(title: "Startup Voice Service Warm-Up", result: result)
                 self.statusMessage = result.output.isEmpty
                     ? "Voice service warm-up failed with exit code \(result.exitCode)"
@@ -111,6 +121,18 @@ final class AgentCommandRunner: ObservableObject {
         }
     }
 
+    private func reportBootstrapPhase(_ phase: BootstrapPhase) {
+        bootstrapPhase = phase
+    }
+
+    private func makeBootstrapProgressReporter() -> AgentBootstrapProgress {
+        { [weak self] phase in
+            Task { @MainActor in
+                self?.reportBootstrapPhase(phase)
+            }
+        }
+    }
+
     @discardableResult
     func beginHoldToTranscribe() -> Bool {
         guard holdTranscriptionState == .idle else {
@@ -171,19 +193,23 @@ final class AgentCommandRunner: ObservableObject {
         }
 
         activeCommandCount += 1
-        statusMessage = isStopRequest
-            ? "Stopping \(command.title)..."
-            : "Running \(command.title)..."
+        if !self.bootstrapPhase.isPreparing {
+            statusMessage = isStopRequest
+                ? "Stopping \(command.title)..."
+                : "Running \(command.title)..."
+        }
 
         let bootstrap = self.bootstrap
+        let reportBootstrapPhase = makeBootstrapProgressReporter()
         let commandArguments = command.resolvedArguments(extraInstructions: TranscriptionSettings.extraInstructions)
         DispatchQueue.global(qos: .userInitiated).async {
-            let bootstrapResult = bootstrap(command.bootstrapRequirement, command.forceBootstrap)
+            let bootstrapResult = bootstrap(command.bootstrapRequirement, command.forceBootstrap, reportBootstrapPhase)
             guard bootstrapResult.exitCode == 0 else {
                 let message = Self.statusMessage(for: command, result: bootstrapResult)
                 let notificationTitle = Self.notificationTitle(for: command, result: bootstrapResult)
                 let notificationBody = Self.notificationBody(for: command, result: bootstrapResult, statusMessage: message)
                 Task { @MainActor in
+                    self.reportBootstrapPhase(.failed)
                     if isStopRequest {
                         self.clearStopRequested(for: command)
                     }
@@ -200,6 +226,10 @@ final class AgentCommandRunner: ObservableObject {
                 return
             }
 
+            Task { @MainActor in
+                self.reportBootstrapPhase(.idle)
+            }
+
             if shouldStartRecording {
                 Task { @MainActor in
                     if self.beginRecordingIndicator(for: command) {
@@ -261,14 +291,17 @@ final class AgentCommandRunner: ObservableObject {
         statusMessage = "Stopping Toggle Transcription..."
 
         let bootstrap = self.bootstrap
+        let reportBootstrapPhase = makeBootstrapProgressReporter()
         DispatchQueue.global(qos: .userInitiated).async {
             let bootstrapResult = bootstrap(
                 AgentCommand.stopTranscription.bootstrapRequirement,
-                AgentCommand.stopTranscription.forceBootstrap
+                AgentCommand.stopTranscription.forceBootstrap,
+                reportBootstrapPhase
             )
             guard bootstrapResult.exitCode == 0 else {
                 let message = Self.statusMessage(for: AgentCommand.stopTranscription, result: bootstrapResult)
                 Task { @MainActor in
+                    self.reportBootstrapPhase(.failed)
                     self.holdTranscriptionState = .idle
                     self.lastOutput = bootstrapResult.output
                     self.recordFailure(command: AgentCommand.stopTranscription, result: bootstrapResult)
@@ -281,6 +314,10 @@ final class AgentCommandRunner: ObservableObject {
                 return
             }
 
+            Task { @MainActor in
+                self.reportBootstrapPhase(.idle)
+            }
+
             let result = AgentRuntime.shared.runAgentCLI(arguments: AgentCommand.stopTranscription.arguments)
 
             Task { @MainActor in

{agent_cli-0.95.5 → agent_cli-0.95.7}/macos/AgentCLI/Sources/AgentCLI/AgentRuntime.swift

@@ -170,7 +170,10 @@ struct AgentRuntime {
         exit(0)
     }
 
-    func ensureInstalled(force: Bool = false) -> CommandResult {
+    func ensureInstalled(
+        force: Bool = false,
+        progress: AgentBootstrapProgress = { _ in }
+    ) -> CommandResult {
         let mode = runtimeMode
         do {
             try prepareDirectories(for: mode)
@@ -179,6 +182,7 @@ struct AgentRuntime {
         }
 
         if mode == .userInstalled {
+            progress(.checkingRuntime)
             return ensureUserInstalledCLIAvailable()
         }
 
@@ -188,6 +192,7 @@ struct AgentRuntime {
             return CommandResult(exitCode: 0, output: "")
         }
 
+        progress(.installingRuntime)
         guard fileManager.isExecutableFile(atPath: bundledUVURL.path) else {
             return CommandResult(
                 exitCode: 127,
@@ -243,36 +248,54 @@ struct AgentRuntime {
         "packageSource=\(agentCLIPackageSource)\ninstallRequirement=\(agentCLIInstallRequirement)\n"
     }
 
-    func ensureReady(for requirement: AgentBootstrapRequirement, force: Bool = false) -> CommandResult {
+    func ensureReady(
+        for requirement: AgentBootstrapRequirement,
+        force: Bool = false,
+        progress: AgentBootstrapProgress = { _ in }
+    ) -> CommandResult {
         Self.bootstrapQueue.sync {
-            ensureReadyUnsynchronized(for: requirement, force: force)
+            ensureReadyUnsynchronized(for: requirement, force: force, progress: progress)
         }
     }
 
-    private func ensureReadyUnsynchronized(for requirement: AgentBootstrapRequirement, force: Bool = false) -> CommandResult {
+    private func ensureReadyUnsynchronized(
+        for requirement: AgentBootstrapRequirement,
+        force: Bool = false,
+        progress: AgentBootstrapProgress
+    ) -> CommandResult {
         switch requirement {
         case .cliRuntime:
-            return ensureInstalled(force: force)
+            return ensureInstalled(force: force, progress: progress)
         case .transcription:
-            let installResult = ensureInstalled(force: force)
+            let installResult = ensureInstalled(force: force, progress: progress)
             guard installResult.exitCode == 0 else {
                 return installResult
             }
-            return ensureWhisperDaemon(force: force)
+            return ensureWhisperDaemon(force: force, progress: progress)
         case .transcriptionModel:
-            let daemonResult = ensureReadyUnsynchronized(for: .transcription, force: force)
+            let daemonResult = ensureReadyUnsynchronized(
+                for: .transcription,
+                force: force,
+                progress: progress
+            )
             guard daemonResult.exitCode == 0 else {
                 return daemonResult
             }
+            progress(.warmingWhisperModel)
             return warmUpWhisperModel()
         }
     }
 
-    private func ensureWhisperDaemon(force: Bool = false) -> CommandResult {
+    private func ensureWhisperDaemon(
+        force: Bool = false,
+        progress: AgentBootstrapProgress
+    ) -> CommandResult {
         if !force, (try? String(contentsOf: whisperDaemonMarkerURL)) == whisperDaemonMarkerContents {
+            progress(.waitingForVoiceService)
             return waitForWhisperDaemonReady()
         }
 
+        progress(.installingVoiceService)
         let result = runAgentCLI(arguments: ["daemon", "install", "whisper", "-y"])
         guard result.exitCode == 0 else {
             return result
@@ -283,6 +306,7 @@ struct AgentRuntime {
             atomically: true,
             encoding: .utf8
         )
+        progress(.waitingForVoiceService)
         return waitForWhisperDaemonReady()
     }
 
@@ -425,8 +449,12 @@ struct AgentRuntime {
         for key in Self.appPrivateEnvironmentKeys {
             environment.removeValue(forKey: key)
         }
+        // Preserve AGENTCLI_UV_PATH so GUI launches can point at a user-managed uv.
         let existingPATH = environment["PATH"] ?? "/usr/bin:/bin:/usr/sbin:/sbin"
-        environment["PATH"] = userInstalledCLIPath(existingPATH: existingPATH)
+        environment["PATH"] = userInstalledCLIPath(
+            existingPATH: existingPATH,
+            loginShellPATH: Self.loginShellPATH(environment: baseEnvironment)
+        )
         return environment
     }
 
@@ -460,15 +488,47 @@ struct AgentRuntime {
         return environment
     }
 
-    private func userInstalledCLIPath(existingPATH: String) -> String {
-        [
-            FileManager.default.homeDirectoryForCurrentUser
+    func userInstalledCLIPath(existingPATH: String, loginShellPATH: String? = nil) -> String {
+        let homeURL = FileManager.default.homeDirectoryForCurrentUser
+        var pathValues: [String] = []
+        if let loginShellPATH {
+            pathValues.append(loginShellPATH)
+        }
+        pathValues.append(contentsOf: [
+            homeURL
                 .appendingPathComponent(".local/bin", isDirectory: true)
                 .path,
+            homeURL
+                .appendingPathComponent(".cargo/bin", isDirectory: true)
+                .path,
             "/opt/homebrew/bin",
             "/usr/local/bin",
             existingPATH
-        ].joined(separator: ":")
+        ])
+
+        var seen = Set<String>()
+        return pathValues
+            .flatMap { $0.split(separator: ":").map(String.init) }
+            .filter { !$0.isEmpty }
+            .filter { seen.insert($0).inserted }
+            .joined(separator: ":")
+    }
+
+    private static func loginShellPATH(environment: [String: String]) -> String? {
+        let shellPath = environment["SHELL"].flatMap { $0.isEmpty ? nil : $0 } ?? "/bin/zsh"
+        guard FileManager.default.isExecutableFile(atPath: shellPath) else { return nil }
+
+        let result = runProcess(
+            executableURL: URL(fileURLWithPath: shellPath),
+            arguments: ["-lic", "printf '%s\\n' \"$PATH\""],
+            environment: environment
+        )
+        guard result.exitCode == 0 else { return nil }
+
+        return result.output
+            .split(separator: "\n")
+            .last
+            .map(String.init)
     }
 
     private func prepareDirectories(for mode: AgentCLIRuntimeMode = .bundled) throws {

agent_cli-0.95.7/macos/AgentCLI/Sources/AgentCLI/BootstrapState.swift

@@ -0,0 +1,48 @@
+import Foundation
+
+enum AgentBootstrapRequirement: Equatable {
+    case cliRuntime
+    case transcription
+    case transcriptionModel
+}
+
+enum BootstrapPhase: Equatable {
+    case idle
+    case checkingRuntime
+    case installingRuntime
+    case installingVoiceService
+    case waitingForVoiceService
+    case warmingWhisperModel
+    case failed
+
+    var isPreparing: Bool {
+        switch self {
+        case .idle, .failed:
+            return false
+        case .checkingRuntime, .installingRuntime, .installingVoiceService, .waitingForVoiceService, .warmingWhisperModel:
+            return true
+        }
+    }
+
+    var statusMessage: String {
+        switch self {
+        case .idle:
+            return "Ready"
+        case .checkingRuntime:
+            return "Checking CLI runtime..."
+        case .installingRuntime:
+            return "Installing CLI runtime..."
+        case .installingVoiceService:
+            return "Installing voice service..."
+        case .waitingForVoiceService:
+            return "Waiting for voice service..."
+        case .warmingWhisperModel:
+            return "Warming Whisper model..."
+        case .failed:
+            return "Voice service warm-up failed"
+        }
+    }
+}
+
+typealias AgentBootstrapProgress = (BootstrapPhase) -> Void
+typealias AgentBootstrap = (AgentBootstrapRequirement, Bool, @escaping AgentBootstrapProgress) -> CommandResult

{agent_cli-0.95.5 → agent_cli-0.95.7}/macos/AgentCLI/Sources/AgentCLI/ConfigurableHotkeyController.swift

@@ -22,18 +22,50 @@ final class ConfigurableHotkeyController {
         guard !registered else { return }
 
         self.runner = runner
+        registerStandardTranscriptionHotkeys(runner: runner)
         registerFunctionAwareTranscriptionHotkeys(runner: runner)
 
         KeyboardShortcuts.onKeyUp(for: .autocorrect) {
+            guard !ShortcutRecordingState.shared.isRecording else { return }
             Task { @MainActor in runner.run(.autocorrect) }
         }
         KeyboardShortcuts.onKeyUp(for: .voiceEdit) {
+            guard !ShortcutRecordingState.shared.isRecording else { return }
             Task { @MainActor in runner.run(.voiceEdit) }
         }
 
         registered = true
     }
 
+    private func registerStandardTranscriptionHotkeys(runner: AgentCommandRunner) {
+        KeyboardShortcuts.onKeyUp(for: .toggleTranscription) {
+            guard !ShortcutRecordingState.shared.isRecording,
+                  let shortcut = KeyboardShortcuts.getShortcut(for: .toggleTranscription),
+                  !self.usesFunctionShortcut(shortcut) else {
+                return
+            }
+            Task { @MainActor in runner.run(.toggleTranscription) }
+        }
+        KeyboardShortcuts.onKeyDown(for: .holdToTranscribe) {
+            guard !ShortcutRecordingState.shared.isRecording,
+                  let shortcut = KeyboardShortcuts.getShortcut(for: .holdToTranscribe),
+                  !self.usesFunctionShortcut(shortcut) else {
+                return
+            }
+            Task { @MainActor in
+                _ = runner.beginHoldToTranscribe()
+            }
+        }
+        KeyboardShortcuts.onKeyUp(for: .holdToTranscribe) {
+            guard !ShortcutRecordingState.shared.isRecording,
+                  let shortcut = KeyboardShortcuts.getShortcut(for: .holdToTranscribe),
+                  !self.usesFunctionShortcut(shortcut) else {
+                return
+            }
+            Task { @MainActor in runner.endHoldToTranscribe() }
+        }
+    }
+
     private func registerFunctionAwareTranscriptionHotkeys(runner: AgentCommandRunner) {
         let eventMask =
             CGEventMask(1 << CGEventType.keyDown.rawValue) |
@@ -84,6 +116,11 @@ final class ConfigurableHotkeyController {
             break
         }
 
+        if ShortcutRecordingState.shared.isRecording {
+            cancelPendingHoldToTranscribe()
+            return Unmanaged.passUnretained(event)
+        }
+
         if handleToggleTranscriptionShortcut(type: type, event: event) {
             return nil
         }
@@ -99,13 +136,14 @@ final class ConfigurableHotkeyController {
 
     private func handleToggleTranscriptionShortcut(type: CGEventType, event: CGEvent) -> Bool {
         guard let shortcut = KeyboardShortcuts.getShortcut(for: .toggleTranscription),
+              usesFunctionShortcut(shortcut),
               shortcutMatches(type: type, event: event, shortcut: shortcut) else {
             return false
         }
 
         if type == .keyDown {
             cancelPendingHoldToTranscribe()
-            suppressNextFunctionKeyRelease = usesFunctionModifier(shortcut)
+            suppressNextFunctionKeyRelease = usesFunctionShortcut(shortcut)
 
             if !isAutorepeat(event) && !holdToTranscribeIsRecording {
                 Task { @MainActor in
@@ -122,6 +160,7 @@ final class ConfigurableHotkeyController {
             return false
         }
         guard !isBareFunctionShortcut(shortcut),
+              usesFunctionShortcut(shortcut),
               shortcutMatches(type: type, event: event, shortcut: shortcut) else {
             return false
         }
@@ -237,8 +276,8 @@ final class ConfigurableHotkeyController {
         return carbonModifiers(from: event.flags) == shortcut.carbonModifiers
     }
 
-    private func usesFunctionModifier(_ shortcut: KeyboardShortcuts.Shortcut) -> Bool {
-        shortcut.carbonModifiers & kEventKeyModifierFnMask != 0
+    private func usesFunctionShortcut(_ shortcut: KeyboardShortcuts.Shortcut) -> Bool {
+        isBareFunctionShortcut(shortcut) || shortcut.carbonModifiers & kEventKeyModifierFnMask != 0
     }
 
     private func isBareFunctionShortcut(_ shortcut: KeyboardShortcuts.Shortcut) -> Bool {

agent_cli-0.95.7/macos/AgentCLI/Sources/AgentCLI/MenuBarIcon.swift

@@ -0,0 +1,111 @@
+import AppKit
+import Foundation
+import SwiftUI
+
+enum MenuBarIconState: Equatable {
+    case idle
+    case preparing
+    case recording
+}
+
+struct AgentCLIMenuBarIcon: View {
+    let state: MenuBarIconState
+
+    var body: some View {
+        if let image = Self.logoImage(state: state) {
+            Image(nsImage: image)
+                .resizable()
+                .aspectRatio(contentMode: .fit)
+                .frame(width: 22, height: 18)
+                .id(state)
+                .accessibilityLabel(accessibilityLabel)
+        } else {
+            Image(systemName: fallbackSystemImage)
+                .id(state)
+                .accessibilityLabel(accessibilityLabel)
+        }
+    }
+
+    private var accessibilityLabel: Text {
+        switch state {
+        case .idle:
+            return Text("Agent CLI")
+        case .preparing:
+            return Text("Agent CLI preparing")
+        case .recording:
+            return Text("Agent CLI recording")
+        }
+    }
+
+    private var fallbackSystemImage: String {
+        switch state {
+        case .idle:
+            return "person.crop.circle"
+        case .preparing:
+            return "arrow.triangle.2.circlepath.circle.fill"
+        case .recording:
+            return "record.circle.fill"
+        }
+    }
+
+    private static func logoImage(state: MenuBarIconState) -> NSImage? {
+        switch state {
+        case .idle:
+            return idleLogoImage
+        case .preparing:
+            return preparingLogoImage
+        case .recording:
+            return recordingLogoImage
+        }
+    }
+
+    private static let idleLogoImage: NSImage? = {
+        guard let url = Bundle.main.url(forResource: "logo-avatar", withExtension: "svg"),
+              let image = NSImage(contentsOf: url)
+        else {
+            return nil
+        }
+        image.isTemplate = true
+        image.size = NSSize(width: 18, height: 18)
+        return image
+    }()
+
+    private static let recordingLogoImage: NSImage? = makeRecordingLogoImage()
+    private static let preparingLogoImage: NSImage? = makePreparingLogoImage()
+
+    private static func makeRecordingLogoImage() -> NSImage? {
+        makeBadgedLogoImage(badgeColor: .systemRed, badgeDiameter: 7)
+    }
+
+    private static func makePreparingLogoImage() -> NSImage? {
+        makeBadgedLogoImage(badgeColor: .controlAccentColor, badgeDiameter: 7)
+    }
+
+    private static func makeBadgedLogoImage(badgeColor: NSColor, badgeDiameter: CGFloat) -> NSImage? {
+        guard let url = Bundle.main.url(forResource: "logo-avatar", withExtension: "svg"),
+              let avatar = NSImage(contentsOf: url)
+        else {
+            return nil
+        }
+
+        avatar.size = NSSize(width: 18, height: 18)
+
+        let image = NSImage(size: NSSize(width: 22, height: 18))
+        image.lockFocus()
+        avatar.draw(
+            in: NSRect(x: 0, y: 0, width: 18, height: 18),
+            from: .zero,
+            operation: .sourceOver,
+            fraction: 1
+        )
+
+        NSColor.white.setFill()
+        NSBezierPath(ovalIn: NSRect(x: 12.5, y: 0.5, width: 10, height: 10)).fill()
+        badgeColor.setFill()
+        NSBezierPath(ovalIn: NSRect(x: 14, y: 2, width: badgeDiameter, height: badgeDiameter)).fill()
+        image.unlockFocus()
+
+        image.isTemplate = false
+        return image
+    }
+}