Add configurable Claude path setting with error handling

Author: StuartCameronCode

.gitignore

@@ -30,3 +30,8 @@ Package.resolved
 # Temporary files
 *.swp
 *~
+
+# Claude Code rules (local)
+CLAUDE.md
+*.zip
+generate_icon.swift

clive/CliveApp.swift

@@ -17,19 +17,30 @@ class AppDelegate: NSObject, NSApplicationDelegate {
     var usageManager: UsageManager?
     var settingsWindow: NSWindow?
     var currentUsage: UsageInfo?
+    var currentError: UsageError?
     var settingsCancellable: AnyCancellable?
 
     func applicationDidFinishLaunching(_ notification: Notification) {
         setupMenuBar()
-        usageManager = UsageManager { [weak self] usage in
-            self?.currentUsage = usage
-            self?.updateMenuBar(with: usage)
-        }
+        usageManager = UsageManager(
+            onUpdate: { [weak self] usage in
+                self?.currentUsage = usage
+                self?.updateMenuBar(with: usage)
+            },
+            onError: { [weak self] error in
+                self?.currentError = error
+                self?.updateMenuBarForError(error)
+            }
+        )
         usageManager?.startPolling()
 
         // Listen for settings changes
         settingsCancellable = SettingsManager.shared.$displayMode.sink { [weak self] _ in
-            self?.updateMenuBar(with: self?.currentUsage)
+            if self?.currentError != nil {
+                self?.updateMenuBarForError(self?.currentError)
+            } else {
+                self?.updateMenuBar(with: self?.currentUsage)
+            }
         }
     }
 
@@ -50,6 +61,12 @@ class AppDelegate: NSObject, NSApplicationDelegate {
     private func setupMenu() {
         let menu = NSMenu()
 
+        let errorItem = NSMenuItem(title: "", action: nil, keyEquivalent: "")
+        errorItem.isEnabled = false
+        errorItem.tag = 99
+        errorItem.isHidden = true
+        menu.addItem(errorItem)
+
         let sessionItem = NSMenuItem(title: "Session: --", action: nil, keyEquivalent: "")
         sessionItem.isEnabled = false
         sessionItem.tag = 100
@@ -129,11 +146,75 @@ class AppDelegate: NSObject, NSApplicationDelegate {
         return Double(numStr)
     }
 
+    private func updateMenuBarForError(_ error: UsageError?) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self, let button = self.statusItem?.button else { return }
+
+            // Update error menu item
+            if let menu = self.statusItem?.menu, let errorItem = menu.item(withTag: 99) {
+                if let error = error {
+                    errorItem.title = error.message
+                    errorItem.isHidden = false
+                } else {
+                    errorItem.title = ""
+                    errorItem.isHidden = true
+                }
+            }
+
+            if error != nil {
+                // Show error state with warning icon
+                let image = self.createErrorIcon()
+                image.isTemplate = false
+                button.image = image
+                button.title = "CC:"
+                button.imagePosition = .imageRight
+
+                // Also clear the usage display items
+                if let menu = self.statusItem?.menu,
+                   let sessionItem = menu.item(withTag: 100),
+                   let weeklyItem = menu.item(withTag: 101) {
+                    sessionItem.title = "Session: --"
+                    weeklyItem.title = "Weekly: --"
+                }
+            } else {
+                // Error cleared, restore normal display
+                self.currentError = nil
+                self.updateMenuBar(with: self.currentUsage)
+            }
+        }
+    }
+
+    private func createErrorIcon() -> NSImage {
+        let size = NSSize(width: 18, height: 18)
+        let image = NSImage(size: size, flipped: false) { rect in
+            // Draw warning triangle with exclamation mark
+            let warningColor = NSColor(red: 1.0, green: 0.3, blue: 0.3, alpha: 1.0)
+
+            // Use SF Symbol if available
+            if let symbolImage = NSImage(systemSymbolName: "exclamationmark.triangle.fill", accessibilityDescription: "Error") {
+                let config = NSImage.SymbolConfiguration(pointSize: 14, weight: .medium)
+                let configuredImage = symbolImage.withSymbolConfiguration(config)
+
+                // Draw with tint color
+                warningColor.set()
+                let imageRect = NSRect(x: (rect.width - 16) / 2, y: (rect.height - 16) / 2, width: 16, height: 16)
+                configuredImage?.draw(in: imageRect, from: .zero, operation: .sourceOver, fraction: 1.0)
+
+                // Apply color tint by drawing over
+                NSGraphicsContext.current?.cgContext.setBlendMode(.sourceAtop)
+                warningColor.setFill()
+                imageRect.fill()
+            }
+            return true
+        }
+        return image
+    }
+
     @objc func openSettings() {
         if settingsWindow == nil {
             let view = SettingsView()
             settingsWindow = NSWindow(
-                contentRect: NSRect(x: 0, y: 0, width: 280, height: 140),
+                contentRect: NSRect(x: 0, y: 0, width: 400, height: 280),
                 styleMask: [.titled, .closable],
                 backing: .buffered,
                 defer: false

clive/SettingsManager.swift

@@ -31,6 +31,9 @@ class SettingsManager: ObservableObject {
 
     private let displayModeKey = "displayMode"
     private let refreshIntervalKey = "refreshInterval"
+    private let claudePathKey = "claudePath"
+
+    static let defaultClaudePath = "/opt/homebrew/bin/claude"
 
     @Published var displayMode: DisplayMode {
         didSet {
@@ -44,6 +47,12 @@ class SettingsManager: ObservableObject {
         }
     }
 
+    @Published var claudePath: String {
+        didSet {
+            UserDefaults.standard.set(claudePath, forKey: claudePathKey)
+        }
+    }
+
     init() {
         if let saved = UserDefaults.standard.string(forKey: displayModeKey),
            let mode = DisplayMode(rawValue: saved) {
@@ -58,5 +67,11 @@ class SettingsManager: ObservableObject {
         } else {
             self.refreshInterval = .fiveMinutes
         }
+
+        if let savedPath = UserDefaults.standard.string(forKey: claudePathKey), !savedPath.isEmpty {
+            self.claudePath = savedPath
+        } else {
+            self.claudePath = SettingsManager.defaultClaudePath
+        }
     }
 }

clive/SettingsView.swift

@@ -1,7 +1,9 @@
 import SwiftUI
+import AppKit
 
 struct SettingsView: View {
     @ObservedObject var settings = SettingsManager.shared
+    @State private var isPathValid: Bool = true
 
     var body: some View {
         Form {
@@ -18,8 +20,58 @@ struct SettingsView: View {
                 }
             }
             .pickerStyle(.menu)
+
+            Divider()
+                .padding(.vertical, 8)
+
+            VStack(alignment: .leading, spacing: 6) {
+                Text("Claude Executable Path")
+                    .font(.headline)
+
+                HStack {
+                    TextField("Path to claude", text: $settings.claudePath)
+                        .textFieldStyle(.roundedBorder)
+                        .onChange(of: settings.claudePath) { newValue in
+                            isPathValid = FileManager.default.isExecutableFile(atPath: newValue)
+                        }
+
+                    Button("Browse...") {
+                        selectClaudePath()
+                    }
+                }
+
+                if !isPathValid && !settings.claudePath.isEmpty {
+                    Text("Executable not found at this path")
+                        .font(.caption)
+                        .foregroundColor(.red)
+                }
+
+                Button("Reset to Default") {
+                    settings.claudePath = SettingsManager.defaultClaudePath
+                    isPathValid = FileManager.default.isExecutableFile(atPath: settings.claudePath)
+                }
+                .buttonStyle(.link)
+                .font(.caption)
+            }
         }
         .padding(20)
-        .frame(width: 280, height: 140)
+        .frame(width: 400, height: 280)
+        .onAppear {
+            isPathValid = FileManager.default.isExecutableFile(atPath: settings.claudePath)
+        }
+    }
+
+    private func selectClaudePath() {
+        let panel = NSOpenPanel()
+        panel.title = "Select Claude Executable"
+        panel.canChooseFiles = true
+        panel.canChooseDirectories = false
+        panel.allowsMultipleSelection = false
+        panel.directoryURL = URL(fileURLWithPath: "/opt/homebrew/bin")
+
+        if panel.runModal() == .OK, let url = panel.url {
+            settings.claudePath = url.path
+            isPathValid = FileManager.default.isExecutableFile(atPath: settings.claudePath)
+        }
     }
 }

clive/UsageManager.swift

@@ -13,24 +13,50 @@ struct UsageInfo {
     }
 }
 
+enum UsageError {
+    case executableNotFound(path: String)
+    case launchFailed(error: String)
+
+    var message: String {
+        switch self {
+        case .executableNotFound(let path):
+            return "Claude not found at: \(path)"
+        case .launchFailed(let error):
+            return "Failed to launch Claude: \(error)"
+        }
+    }
+}
+
 class UsageManager {
     private var refreshTimer: Timer?
     private let onUpdate: (UsageInfo?) -> Void
+    private let onError: (UsageError?) -> Void
     private var process: Process?
     private var outputPipe: Pipe?
     private var timeoutTimer: Timer?
     private var isRefreshing = false
-    private var settingsCancellable: AnyCancellable?
+    private var settingsCancellables = Set<AnyCancellable>()
 
     private let timeout: TimeInterval = 30
 
-    init(onUpdate: @escaping (UsageInfo?) -> Void) {
+    init(onUpdate: @escaping (UsageInfo?) -> Void, onError: @escaping (UsageError?) -> Void) {
         self.onUpdate = onUpdate
+        self.onError = onError
 
         // Listen for refresh interval changes
-        settingsCancellable = SettingsManager.shared.$refreshInterval.sink { [weak self] _ in
+        SettingsManager.shared.$refreshInterval.sink { [weak self] _ in
             self?.restartTimer()
-        }
+        }.store(in: &settingsCancellables)
+
+        // Listen for claude path changes and refresh when changed
+        SettingsManager.shared.$claudePath.sink { [weak self] _ in
+            self?.refreshNow()
+        }.store(in: &settingsCancellables)
+    }
+
+    private func checkExecutableExists() -> Bool {
+        let path = SettingsManager.shared.claudePath
+        return FileManager.default.isExecutableFile(atPath: path)
     }
 
     func startPolling() {
@@ -68,6 +94,18 @@ class UsageManager {
     private func performRefresh() {
         isRefreshing = true
 
+        let claudePath = SettingsManager.shared.claudePath
+
+        // Check if executable exists
+        guard checkExecutableExists() else {
+            isRefreshing = false
+            onError(.executableNotFound(path: claudePath))
+            return
+        }
+
+        // Clear any previous error on successful check
+        onError(nil)
+
         let proc = Process()
         let pipe = Pipe()
 
@@ -76,12 +114,15 @@ class UsageManager {
         try? FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
         proc.currentDirectoryURL = tempDir
 
+        // Get directory containing claude for PATH
+        let claudeDir = (claudePath as NSString).deletingLastPathComponent
+
         // Write expect script to temp directory
         let expectScript = """
             #!/usr/bin/expect -f
             log_user 1
             set timeout 25
-            spawn /opt/homebrew/bin/claude /usage
+            spawn \(claudePath) /usage
 
             # Handle trust dialog if it appears, then read output
             expect {
@@ -112,9 +153,9 @@ class UsageManager {
         proc.standardOutput = pipe
         proc.standardError = pipe
 
-        // Minimal environment
+        // Minimal environment - include claude's directory in PATH
         var env: [String: String] = [:]
-        env["PATH"] = "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin"
+        env["PATH"] = "\(claudeDir):/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin"
         env["HOME"] = ProcessInfo.processInfo.environment["HOME"] ?? ""
         env["USER"] = ProcessInfo.processInfo.environment["USER"] ?? ""
         env["TERM"] = "dumb"
@@ -172,7 +213,7 @@ class UsageManager {
             try proc.run()
         } catch {
             isRefreshing = false
-            onUpdate(nil)
+            onError(.launchFailed(error: error.localizedDescription))
         }
     }