Add Ollama provider support

.gitignore

@@ -25,6 +25,7 @@ debug_*.swift
 
 # Misc
 .DS_Store
+.swiftpm-cache/
 
 # Debug/analysis docs
 docs/*-analysis.md

Sources/CodexBar/PreferencesDebugPane.swift

@@ -106,6 +106,7 @@ struct DebugPane: View {
                         Text("Cursor").tag(UsageProvider.cursor)
                         Text("Augment").tag(UsageProvider.augment)
                         Text("Amp").tag(UsageProvider.amp)
+                        Text("Ollama").tag(UsageProvider.ollama)
                     }
                     .pickerStyle(.segmented)
                     .frame(width: 460)
@@ -299,6 +300,7 @@ struct DebugPane: View {
                         Text("Antigravity").tag(UsageProvider.antigravity)
                         Text("Augment").tag(UsageProvider.augment)
                         Text("Amp").tag(UsageProvider.amp)
+                        Text("Ollama").tag(UsageProvider.ollama)
                     }
                     .pickerStyle(.segmented)
                     .frame(width: 360)

Sources/CodexBar/Providers/Ollama/OllamaProviderImplementation.swift

@@ -0,0 +1,81 @@
+import AppKit
+import CodexBarCore
+import CodexBarMacroSupport
+import Foundation
+import SwiftUI
+
+@ProviderImplementationRegistration
+struct OllamaProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .ollama
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.ollamaCookieSource
+        _ = settings.ollamaCookieHeader
+    }
+
+    @MainActor
+    func settingsSnapshot(context: ProviderSettingsSnapshotContext) -> ProviderSettingsSnapshotContribution? {
+        .ollama(context.settings.ollamaSettingsSnapshot(tokenOverride: context.tokenOverride))
+    }
+
+    @MainActor
+    func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        let cookieBinding = Binding(
+            get: { context.settings.ollamaCookieSource.rawValue },
+            set: { raw in
+                context.settings.ollamaCookieSource = ProviderCookieSource(rawValue: raw) ?? .auto
+            })
+        let cookieOptions = ProviderCookieSourceUI.options(
+            allowsOff: false,
+            keychainDisabled: context.settings.debugDisableKeychainAccess)
+
+        let cookieSubtitle: () -> String? = {
+            ProviderCookieSourceUI.subtitle(
+                source: context.settings.ollamaCookieSource,
+                keychainDisabled: context.settings.debugDisableKeychainAccess,
+                auto: "Automatic imports browser cookies.",
+                manual: "Paste a Cookie header or cURL capture from Ollama settings.",
+                off: "Ollama cookies are disabled.")
+        }
+
+        return [
+            ProviderSettingsPickerDescriptor(
+                id: "ollama-cookie-source",
+                title: "Cookie source",
+                subtitle: "Automatic imports browser cookies.",
+                dynamicSubtitle: cookieSubtitle,
+                binding: cookieBinding,
+                options: cookieOptions,
+                isVisible: nil,
+                onChange: nil),
+        ]
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "ollama-cookie",
+                title: "",
+                subtitle: "",
+                kind: .secure,
+                placeholder: "Cookie: …",
+                binding: context.stringBinding(\.ollamaCookieHeader),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "ollama-open-settings",
+                        title: "Open Ollama Settings",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            if let url = URL(string: "https://ollama.com/settings") {
+                                NSWorkspace.shared.open(url)
+                            }
+                        }),
+                ],
+                isVisible: { context.settings.ollamaCookieSource == .manual },
+                onActivate: { }),
+        ]
+    }
+}

Sources/CodexBar/Providers/Ollama/OllamaSettingsStore.swift

@@ -0,0 +1,60 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var ollamaCookieHeader: String {
+        get { self.configSnapshot.providerConfig(for: .ollama)?.sanitizedCookieHeader ?? "" }
+        set {
+            self.updateProviderConfig(provider: .ollama) { entry in
+                entry.cookieHeader = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .ollama, field: "cookieHeader", value: newValue)
+        }
+    }
+
+    var ollamaCookieSource: ProviderCookieSource {
+        get { self.resolvedCookieSource(provider: .ollama, fallback: .auto) }
+        set {
+            self.updateProviderConfig(provider: .ollama) { entry in
+                entry.cookieSource = newValue
+            }
+            self.logProviderModeChange(provider: .ollama, field: "cookieSource", value: newValue.rawValue)
+        }
+    }
+}
+
+extension SettingsStore {
+    func ollamaSettingsSnapshot(tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot.OllamaProviderSettings {
+        ProviderSettingsSnapshot.OllamaProviderSettings(
+            cookieSource: self.ollamaSnapshotCookieSource(tokenOverride: tokenOverride),
+            manualCookieHeader: self.ollamaSnapshotCookieHeader(tokenOverride: tokenOverride))
+    }
+
+    private func ollamaSnapshotCookieHeader(tokenOverride: TokenAccountOverride?) -> String {
+        let fallback = self.ollamaCookieHeader
+        guard let support = TokenAccountSupportCatalog.support(for: .ollama),
+              case .cookieHeader = support.injection
+        else {
+            return fallback
+        }
+        guard let account = ProviderTokenAccountSelection.selectedAccount(
+            provider: .ollama,
+            settings: self,
+            override: tokenOverride)
+        else {
+            return fallback
+        }
+        return TokenAccountSupportCatalog.normalizedCookieHeader(account.token, support: support)
+    }
+
+    private func ollamaSnapshotCookieSource(tokenOverride: TokenAccountOverride?) -> ProviderCookieSource {
+        let fallback = self.ollamaCookieSource
+        guard let support = TokenAccountSupportCatalog.support(for: .ollama),
+              support.requiresManualCookieSource
+        else {
+            return fallback
+        }
+        if self.tokenAccounts(for: .ollama).isEmpty { return fallback }
+        return .manual
+    }
+}

Sources/CodexBar/Providers/Shared/ProviderImplementationRegistry.swift

@@ -29,6 +29,7 @@ enum ProviderImplementationRegistry {
         case .jetbrains: JetBrainsProviderImplementation()
         case .kimik2: KimiK2ProviderImplementation()
         case .amp: AmpProviderImplementation()
+        case .ollama: OllamaProviderImplementation()
         case .synthetic: SyntheticProviderImplementation()
         }
     }

Sources/CodexBar/SettingsStore+MenuObservation.swift

@@ -36,6 +36,7 @@ extension SettingsStore {
         _ = self.kimiCookieSource
         _ = self.augmentCookieSource
         _ = self.ampCookieSource
+        _ = self.ollamaCookieSource
         _ = self.mergeIcons
         _ = self.switcherShowsIcons
         _ = self.zaiAPIToken
@@ -52,6 +53,7 @@ extension SettingsStore {
         _ = self.kimiK2APIToken
         _ = self.augmentCookieHeader
         _ = self.ampCookieHeader
+        _ = self.ollamaCookieHeader
         _ = self.copilotAPIToken
         _ = self.tokenAccountsByProvider
         _ = self.debugLoadingPattern

Sources/CodexBar/UsageStore+Logging.swift

@@ -14,6 +14,7 @@ extension UsageStore {
             "kimiCookieSource": self.settings.kimiCookieSource.rawValue,
             "augmentCookieSource": self.settings.augmentCookieSource.rawValue,
             "ampCookieSource": self.settings.ampCookieSource.rawValue,
+            "ollamaCookieSource": self.settings.ollamaCookieSource.rawValue,
             "openAIWebAccess": self.settings.openAIWebAccessEnabled ? "1" : "0",
             "claudeWebExtras": self.settings.claudeWebExtrasEnabled ? "1" : "0",
         ]

Sources/CodexBar/UsageStore.swift

@@ -1225,6 +1225,12 @@ extension UsageStore {
                     ampCookieHeader: self.settings.ampCookieHeader)
                 await MainActor.run { self.probeLogs[.amp] = text }
                 return text
+            case .ollama:
+                let text = await self.debugOllamaLog(
+                    ollamaCookieSource: self.settings.ollamaCookieSource,
+                    ollamaCookieHeader: self.settings.ollamaCookieHeader)
+                await MainActor.run { self.probeLogs[.ollama] = text }
+                return text
             case .jetbrains:
                 let text = "JetBrains AI debug log not yet implemented"
                 await MainActor.run { self.probeLogs[.jetbrains] = text }
@@ -1389,6 +1395,19 @@ extension UsageStore {
         }
     }
 
+    private func debugOllamaLog(
+        ollamaCookieSource: ProviderCookieSource,
+        ollamaCookieHeader: String) async -> String
+    {
+        await self.runWithTimeout(seconds: 15) {
+            let fetcher = OllamaUsageFetcher(browserDetection: self.browserDetection)
+            let manualHeader = ollamaCookieSource == .manual
+                ? CookieHeaderNormalizer.normalize(ollamaCookieHeader)
+                : nil
+            return await fetcher.debugRawProbe(cookieHeaderOverride: manualHeader)
+        }
+    }
+
     private func runWithTimeout(seconds: Double, operation: @escaping @Sendable () async -> String) async -> String {
         await withTaskGroup(of: String?.self) { group -> String in
             group.addTask { await operation() }

Sources/CodexBarCLI/TokenAccountCLI.swift

@@ -135,6 +135,11 @@ struct TokenAccountCLIContext {
                 amp: ProviderSettingsSnapshot.AmpProviderSettings(
                     cookieSource: cookieSource,
                     manualCookieHeader: cookieHeader))
+        case .ollama:
+            return self.makeSnapshot(
+                ollama: ProviderSettingsSnapshot.OllamaProviderSettings(
+                    cookieSource: cookieSource,
+                    manualCookieHeader: cookieHeader))
         case .kimi:
             return self.makeSnapshot(
                 kimi: ProviderSettingsSnapshot.KimiProviderSettings(
@@ -163,6 +168,7 @@ struct TokenAccountCLIContext {
         kimi: ProviderSettingsSnapshot.KimiProviderSettings? = nil,
         augment: ProviderSettingsSnapshot.AugmentProviderSettings? = nil,
         amp: ProviderSettingsSnapshot.AmpProviderSettings? = nil,
+        ollama: ProviderSettingsSnapshot.OllamaProviderSettings? = nil,
         jetbrains: ProviderSettingsSnapshot.JetBrainsProviderSettings? = nil) -> ProviderSettingsSnapshot
     {
         ProviderSettingsSnapshot.make(
@@ -176,6 +182,7 @@ struct TokenAccountCLIContext {
             kimi: kimi,
             augment: augment,
             amp: amp,
+            ollama: ollama,
             jetbrains: jetbrains)
     }
 

Sources/CodexBarCore/Logging/LogCategories.swift

@@ -40,6 +40,7 @@ public enum LogCategories {
     public static let notifications = "notifications"
     public static let openAIWeb = "openai-web"
     public static let openAIWebview = "openai-webview"
+    public static let ollama = "ollama"
     public static let opencodeUsage = "opencode-usage"
     public static let providerDetection = "provider-detection"
     public static let providers = "providers"