@sriinnu/runic 1.0.0 → 1.2.0

package/Sources/RunicCore/Providers/Gemini/GeminiStatusProbe.swift

@@ -619,6 +619,7 @@ public struct GeminiStatusProbe: Sendable {
 
         let updatedData = try JSONSerialization.data(withJSONObject: json, options: [.prettyPrinted])
         try updatedData.write(to: credsURL, options: .atomic)
+        try? FileManager.default.setAttributes([.posixPermissions: 0o600], ofItemAtPath: credsURL.path)
     }
 
     private static func loadCredentials(homeDirectory: String) throws -> OAuthCredentials {

package/Sources/RunicCore/Providers/MiniMax/MiniMaxUsageFetcher.swift

@@ -119,10 +119,7 @@ public struct MiniMaxUsageFetcher: Sendable {
             throw MiniMaxUsageError.apiError("HTTP \(httpResponse.statusCode): \(errorMessage)")
         }
 
-        // Log raw response for debugging
-        if let jsonString = String(data: data, encoding: .utf8) {
-            Self.log.debug("MiniMax API response: \(jsonString)")
-        }
+        Self.log.debug("MiniMax API response: HTTP \(httpResponse.statusCode), \(data.count) bytes")
 
         let decoder = JSONDecoder()
         do {

package/Sources/RunicCore/Providers/OpenRouter/OpenRouterUsageFetcher.swift

@@ -91,9 +91,7 @@ struct OpenRouterUsageFetcher {
             throw OpenRouterAPIError.httpError(statusCode: httpResponse.statusCode)
         }
 
-        if let json = String(data: data, encoding: .utf8) {
-            Self.log.debug("OpenRouter credits response: \(json)")
-        }
+        Self.log.debug("OpenRouter credits response: HTTP \(httpResponse.statusCode), \(data.count) bytes")
 
         return try JSONDecoder().decode(OpenRouterCreditsResponse.self, from: data)
     }
@@ -122,9 +120,7 @@ struct OpenRouterUsageFetcher {
             throw OpenRouterAPIError.httpError(statusCode: httpResponse.statusCode)
         }
 
-        if let json = String(data: data, encoding: .utf8) {
-            Self.log.debug("OpenRouter key info response: \(json)")
-        }
+        Self.log.debug("OpenRouter key info response: HTTP \(httpResponse.statusCode), \(data.count) bytes")
 
         return try JSONDecoder().decode(OpenRouterKeyInfoResponse.self, from: data)
     }

package/Sources/RunicCore/Providers/Qwen/QwenUsageStats.swift

@@ -218,9 +218,7 @@ public struct QwenUsageFetcher: Sendable {
             throw QwenUsageError.apiError("HTTP \(httpResponse.statusCode): \(errorMessage)")
         }
 
-        if let jsonString = String(data: data, encoding: .utf8) {
-            Self.log.debug("DashScope usage response: \(jsonString)")
-        }
+        Self.log.debug("DashScope usage response: HTTP \(httpResponse.statusCode), \(data.count) bytes")
 
         let apiResponse = try JSONDecoder().decode(QwenUsageResponse.self, from: data)
         guard apiResponse.isSuccess else {

package/Sources/RunicCore/Providers/Zai/ZaiUsageStats.swift

@@ -520,9 +520,7 @@ public struct ZaiUsageFetcher: Sendable {
             throw ZaiUsageError.apiError("HTTP \(httpResponse.statusCode): \(errorMessage)")
         }
 
-        if let jsonString = String(data: data, encoding: .utf8) {
-            Self.log.debug("z.ai quota response: \(jsonString)")
-        }
+        Self.log.debug("z.ai quota response: HTTP \(httpResponse.statusCode), \(data.count) bytes")
 
         let apiResponse: ZaiQuotaLimitResponse
         do {
@@ -573,9 +571,7 @@ public struct ZaiUsageFetcher: Sendable {
             throw ZaiUsageError.apiError("model-usage endpoint returned non-200")
         }
 
-        if let jsonString = String(data: data, encoding: .utf8) {
-            Self.log.debug("z.ai model-usage response: \(jsonString)")
-        }
+        Self.log.debug("z.ai model-usage response: HTTP \(httpResponse.statusCode), \(data.count) bytes")
 
         let raw = try JSONDecoder().decode(ZaiModelUsageResponse.self, from: data)
         let models = raw.data?.models ?? []
@@ -635,9 +631,7 @@ public struct ZaiUsageFetcher: Sendable {
             throw ZaiUsageError.apiError("tool-usage endpoint returned non-200")
         }
 
-        if let jsonString = String(data: data, encoding: .utf8) {
-            Self.log.debug("z.ai tool-usage response: \(jsonString)")
-        }
+        Self.log.debug("z.ai tool-usage response: HTTP \(httpResponse.statusCode), \(data.count) bytes")
 
         let raw = try JSONDecoder().decode(ZaiToolUsageResponse.self, from: data)
         let tools = raw.data?.tools ?? []

package/Sources/RunicCore/UsageLedger/ClaudeUsageLogSource.swift

@@ -44,33 +44,131 @@ public struct ClaudeUsageLogSource: UsageLedgerSource, @unchecked Sendable {
             throw ClaudeUsageLogError.noProjectsDirectory
         }
 
+        // Only scan files modified since our last scan (incremental).
+        // On first run, scans the last `maxAgeDays` worth of files.
+        let cache = LedgerCache.shared
+        let lastScan = await cache.lastScanDate(provider: "claude")
+        let incrementalCutoff = lastScan ?? self.minDate() ?? self.now.addingTimeInterval(-86400)
         let minDate = self.minDate()
-        let files = self.findUsageFiles(in: projectsDirs, minDate: minDate)
-        if files.isEmpty {
-            return []
+
+        let allFiles = self.findUsageFiles(in: projectsDirs, minDate: minDate)
+
+        // Filter to only files modified since last scan (plus today's files which may have grown).
+        let todayStart = Calendar.current.startOfDay(for: self.now)
+        let filesToScan = allFiles.filter { file in
+            guard let modDate = (try? self.fileManager.attributesOfItem(atPath: file.url.path))?[.modificationDate] as? Date else {
+                return true
+            }
+            return modDate >= incrementalCutoff || modDate >= todayStart
         }
 
-        var entries: [UsageLedgerEntry] = []
-        var seenKeys = Set<String>()
+        if filesToScan.isEmpty {
+            return []
+        }
 
-        for file in files {
-            do {
-                let data = try Data(contentsOf: file.url)
-                guard let content = String(data: data, encoding: .utf8) else { continue }
-                let lines = content.split(whereSeparator: \.isNewline)
-                for line in lines {
-                    if let entry = self.parseLine(line, file: file, minDate: minDate, seenKeys: &seenKeys) {
-                        entries.append(entry)
+        self.log.info("Scanning \(filesToScan.count) of \(allFiles.count) JSONL files (incremental since \(incrementalCutoff))")
+
+        // Parse files concurrently (max 16 at a time).
+        let maxConcurrency = 16
+        let fileEntries = await withTaskGroup(
+            of: [UsageLedgerEntry].self,
+            returning: [UsageLedgerEntry].self)
+        { group in
+            var all: [UsageLedgerEntry] = []
+            var inflight = 0
+            for file in filesToScan {
+                if inflight >= maxConcurrency {
+                    if let batch = await group.next() {
+                        all.append(contentsOf: batch)
+                        inflight -= 1
                     }
                 }
-            } catch {
-                self.log.warning("Claude usage log read failed", metadata: [
-                    "file": file.url.path,
-                    "error": error.localizedDescription,
-                ])
+                group.addTask {
+                    self.parseFile(file, minDate: minDate)
+                }
+                inflight += 1
+            }
+            for await batch in group {
+                all.append(contentsOf: batch)
+            }
+            return all
+        }
+
+        // Deduplicate across files using the same composite key as per-file dedup.
+        var seenKeys = Set<String>()
+        var entries: [UsageLedgerEntry] = []
+        entries.reserveCapacity(fileEntries.count)
+        for entry in fileEntries {
+            let key = self.dedupeKey(
+                requestID: entry.requestID,
+                messageID: entry.messageID,
+                sessionID: entry.sessionID,
+                timestamp: entry.timestamp,
+                inputTokens: entry.inputTokens,
+                outputTokens: entry.outputTokens,
+                cacheCreationTokens: entry.cacheCreationTokens,
+                cacheReadTokens: entry.cacheReadTokens)
+            if seenKeys.insert(key).inserted {
+                entries.append(entry)
             }
         }
 
+        // Aggregate into daily summaries and persist to cache.
+        let dailyFormatter = DateFormatter()
+        dailyFormatter.dateFormat = "yyyy-MM-dd"
+        dailyFormatter.timeZone = .current
+
+        var dailyBuckets: [String: (input: Int, output: Int, cacheCreate: Int, cacheRead: Int, cost: Double, requests: Int, models: Set<String>)] = [:]
+        for entry in entries {
+            let key = dailyFormatter.string(from: entry.timestamp)
+            var bucket = dailyBuckets[key] ?? (0, 0, 0, 0, 0, 0, [])
+            bucket.input += entry.inputTokens
+            bucket.output += entry.outputTokens
+            bucket.cacheCreate += entry.cacheCreationTokens
+            bucket.cacheRead += entry.cacheReadTokens
+            bucket.cost += entry.costUSD ?? 0
+            bucket.requests += 1
+            if let model = entry.model { bucket.models.insert(model) }
+            dailyBuckets[key] = bucket
+        }
+
+        let cachedDailies = dailyBuckets.map { key, bucket in
+            CachedDaily(
+                dayKey: key,
+                inputTokens: bucket.input,
+                outputTokens: bucket.output,
+                cacheCreationTokens: bucket.cacheCreate,
+                cacheReadTokens: bucket.cacheRead,
+                costUSD: bucket.cost > 0 ? bucket.cost : nil,
+                requestCount: bucket.requests,
+                modelsUsed: Array(bucket.models))
+        }
+
+        let todayKey = await LedgerCache.dayKey(for: self.now)
+        await cache.mergeDailies(provider: "claude", newDailies: cachedDailies, scanDate: self.now, todayKey: todayKey)
+
+        return entries
+    }
+
+    /// Parse a single JSONL file, returning usage entries.
+    private func parseFile(_ file: UsageFile, minDate: Date?) -> [UsageLedgerEntry] {
+        var entries: [UsageLedgerEntry] = []
+        do {
+            let data = try Data(contentsOf: file.url)
+            guard let content = String(data: data, encoding: .utf8) else { return [] }
+            var seenKeys = Set<String>()
+            let lines = content.split(whereSeparator: \.isNewline)
+            for line in lines {
+                if let entry = self.parseLine(line, file: file, minDate: minDate, seenKeys: &seenKeys) {
+                    entries.append(entry)
+                }
+            }
+        } catch {
+            self.log.warning("Claude usage log read failed", metadata: [
+                "file": file.url.path,
+                "error": error.localizedDescription,
+            ])
+        }
         return entries
     }
 
@@ -123,7 +221,7 @@ public struct ClaudeUsageLogSource: UsageLedgerSource, @unchecked Sendable {
                 options: [.skipsHiddenFiles])
 
             while let fileURL = enumerator?.nextObject() as? URL {
-                guard fileURL.lastPathComponent == "usage.jsonl" else { continue }
+                guard fileURL.pathExtension == "jsonl" else { continue }
                 if let minDate {
                     let values = try? fileURL.resourceValues(forKeys: [.contentModificationDateKey])
                     if let modifiedAt = values?.contentModificationDate, modifiedAt < minDate { continue }

package/Sources/RunicCore/UsageLedger/CodexUsageLogSource.swift

@@ -87,15 +87,27 @@ public struct CodexUsageLogSource: UsageLedgerSource, @unchecked Sendable {
     public func loadEntries() async throws -> [UsageLedgerEntry] {
         let root = try self.resolveSessionsRoot()
         let minDate = self.minDate()
-        let files = self.listSessionFiles(root: root, minDate: minDate)
-        if files.isEmpty {
+
+        // Incremental scan: only parse files modified since our last scan.
+        let cache = LedgerCache.shared
+        let lastScan = await cache.lastScanDate(provider: "codex")
+        let incrementalCutoff = lastScan ?? minDate ?? self.now.addingTimeInterval(-86400)
+        let todayStart = Calendar.current.startOfDay(for: self.now)
+
+        let allFiles = self.listSessionFiles(root: root, minDate: minDate)
+        let filesToScan = allFiles.filter { file in
+            guard let modDate = file.modifiedAt else { return true }
+            return modDate >= incrementalCutoff || modDate >= todayStart
+        }
+
+        if filesToScan.isEmpty {
             return []
         }
 
         var entries: [UsageLedgerEntry] = []
         var seenKeys = Set<String>()
 
-        for file in files {
+        for file in filesToScan {
             do {
                 try self.parseFile(file, minDate: minDate, seenKeys: &seenKeys, entries: &entries)
             } catch {
@@ -106,6 +118,40 @@ public struct CodexUsageLogSource: UsageLedgerSource, @unchecked Sendable {
             }
         }
 
+        // Aggregate into daily summaries and persist to cache.
+        let dailyFormatter = DateFormatter()
+        dailyFormatter.dateFormat = "yyyy-MM-dd"
+        dailyFormatter.timeZone = .current
+
+        var dailyBuckets: [String: (input: Int, output: Int, cacheCreate: Int, cacheRead: Int, cost: Double, requests: Int, models: Set<String>)] = [:]
+        for entry in entries {
+            let key = dailyFormatter.string(from: entry.timestamp)
+            var bucket = dailyBuckets[key] ?? (0, 0, 0, 0, 0, 0, [])
+            bucket.input += entry.inputTokens
+            bucket.output += entry.outputTokens
+            bucket.cacheCreate += entry.cacheCreationTokens
+            bucket.cacheRead += entry.cacheReadTokens
+            bucket.cost += entry.costUSD ?? 0
+            bucket.requests += 1
+            if let model = entry.model { bucket.models.insert(model) }
+            dailyBuckets[key] = bucket
+        }
+
+        let cachedDailies = dailyBuckets.map { key, bucket in
+            CachedDaily(
+                dayKey: key,
+                inputTokens: bucket.input,
+                outputTokens: bucket.output,
+                cacheCreationTokens: bucket.cacheCreate,
+                cacheReadTokens: bucket.cacheRead,
+                costUSD: bucket.cost > 0 ? bucket.cost : nil,
+                requestCount: bucket.requests,
+                modelsUsed: Array(bucket.models))
+        }
+
+        let todayKey = await LedgerCache.dayKey(for: self.now)
+        await cache.mergeDailies(provider: "codex", newDailies: cachedDailies, scanDate: self.now, todayKey: todayKey)
+
         return entries
     }
 

package/Sources/RunicCore/UsageLedger/LedgerCache.swift

@@ -0,0 +1,158 @@
+import Foundation
+import OSLog
+
+/// Persistent cache for aggregated ledger data. Stores daily summaries per provider
+/// so the app never re-scans old JSONL files. Works like a deque — new days are
+/// appended, historical days are immutable.
+///
+/// Storage: `~/Library/Application Support/Runic/ledger-cache/`
+///   - `claude-daily.json`, `codex-daily.json`, etc.
+///   - Each file: `{ "lastScanDate": "...", "dailies": [...] }`
+public actor LedgerCache {
+    public static let shared = LedgerCache()
+
+    private static let log = Logger(subsystem: "com.sriinnu.athena.Runic", category: "ledger-cache")
+    private let cacheDir: URL
+
+    private static let dayKeyFormatter: DateFormatter = {
+        let f = DateFormatter()
+        f.dateFormat = "yyyy-MM-dd"
+        f.timeZone = .current
+        return f
+    }()
+
+    public init() {
+        let appSupport = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first!
+        self.cacheDir = appSupport.appendingPathComponent("Runic/ledger-cache", isDirectory: true)
+        try? FileManager.default.createDirectory(at: self.cacheDir, withIntermediateDirectories: true)
+    }
+
+    // MARK: - Public API
+
+    /// Load cached daily summaries for a provider. Returns instantly.
+    public func loadCachedDailies(provider: String) -> CachedLedger? {
+        let url = self.fileURL(provider: provider)
+        guard let data = try? Data(contentsOf: url) else { return nil }
+        return try? JSONDecoder().decode(CachedLedger.self, from: data)
+    }
+
+    /// Save aggregated daily summaries for a provider.
+    public func saveDailies(provider: String, ledger: CachedLedger) {
+        let url = self.fileURL(provider: provider)
+        guard let data = try? JSONEncoder().encode(ledger) else { return }
+        try? data.write(to: url, options: .atomic)
+        Self.log.debug("Saved \(ledger.dailies.count) days for \(provider)")
+    }
+
+    /// Merge new daily entries into existing cache. Deque behavior:
+    /// - Existing days are NOT overwritten (immutable history)
+    /// - Today's entry is ACCUMULATED (adds to existing totals for partial scans)
+    /// - New days are appended
+    public func mergeDailies(provider: String, newDailies: [CachedDaily], scanDate: Date, todayKey: String? = nil) {
+        var ledger = self.loadCachedDailies(provider: provider) ?? CachedLedger(lastScanDate: scanDate, lastFullScanDate: nil, dailies: [])
+
+        let resolvedTodayKey = todayKey ?? Self.dayKey(for: Date())
+        var existingByKey: [String: CachedDaily] = [:]
+        for daily in ledger.dailies {
+            existingByKey[daily.dayKey] = daily
+        }
+
+        for newDaily in newDailies {
+            if newDaily.dayKey == resolvedTodayKey, let existing = existingByKey[newDaily.dayKey] {
+                // Accumulate today's partial scan results onto existing totals.
+                var mergedModels = Set(existing.modelsUsed)
+                mergedModels.formUnion(newDaily.modelsUsed)
+                existingByKey[newDaily.dayKey] = CachedDaily(
+                    dayKey: newDaily.dayKey,
+                    inputTokens: existing.inputTokens + newDaily.inputTokens,
+                    outputTokens: existing.outputTokens + newDaily.outputTokens,
+                    cacheCreationTokens: existing.cacheCreationTokens + newDaily.cacheCreationTokens,
+                    cacheReadTokens: existing.cacheReadTokens + newDaily.cacheReadTokens,
+                    costUSD: (existing.costUSD ?? 0) + (newDaily.costUSD ?? 0) > 0
+                        ? (existing.costUSD ?? 0) + (newDaily.costUSD ?? 0) : nil,
+                    requestCount: existing.requestCount + newDaily.requestCount,
+                    modelsUsed: Array(mergedModels))
+            } else if existingByKey[newDaily.dayKey] == nil {
+                existingByKey[newDaily.dayKey] = newDaily
+            }
+        }
+
+        ledger.dailies = existingByKey.values.sorted { $0.dayKey < $1.dayKey }
+        ledger.lastScanDate = scanDate
+        self.saveDailies(provider: provider, ledger: ledger)
+    }
+
+    /// Mark that a full historical scan has been completed.
+    public func markFullScanComplete(provider: String) {
+        guard var ledger = self.loadCachedDailies(provider: provider) else { return }
+        ledger.lastFullScanDate = Date()
+        self.saveDailies(provider: provider, ledger: ledger)
+    }
+
+    /// Whether a full historical scan has been done for this provider.
+    public func hasFullScan(provider: String) -> Bool {
+        self.loadCachedDailies(provider: provider)?.lastFullScanDate != nil
+    }
+
+    /// Date of last incremental scan (to know which files to scan next).
+    public func lastScanDate(provider: String) -> Date? {
+        self.loadCachedDailies(provider: provider)?.lastScanDate
+    }
+
+    // MARK: - Internal
+
+    private func fileURL(provider: String) -> URL {
+        self.cacheDir.appendingPathComponent("\(provider)-daily.json")
+    }
+
+    static func dayKey(for date: Date) -> String {
+        self.dayKeyFormatter.string(from: date)
+    }
+}
+
+// MARK: - Models
+
+public struct CachedLedger: Codable, Sendable {
+    public var lastScanDate: Date
+    public var lastFullScanDate: Date?
+    public var dailies: [CachedDaily]
+}
+
+public struct CachedDaily: Codable, Sendable {
+    public let dayKey: String          // "2026-03-23"
+    public let inputTokens: Int
+    public let outputTokens: Int
+    public let cacheCreationTokens: Int
+    public let cacheReadTokens: Int
+    public let costUSD: Double?
+    public let requestCount: Int
+    public let modelsUsed: [String]
+
+    private static let dayKeyParser: DateFormatter = {
+        let f = DateFormatter()
+        f.dateFormat = "yyyy-MM-dd"
+        f.timeZone = .current
+        return f
+    }()
+
+    public var totalTokens: Int {
+        self.inputTokens + self.outputTokens + self.cacheCreationTokens + self.cacheReadTokens
+    }
+
+    /// Convert to a UsageLedgerDailySummary for immediate display from cache.
+    public func toLedgerDailySummary(provider: UsageProvider) -> UsageLedgerDailySummary? {
+        guard let dayStart = Self.dayKeyParser.date(from: self.dayKey) else { return nil }
+        return UsageLedgerDailySummary(
+            provider: provider,
+            projectID: nil,
+            dayStart: dayStart,
+            dayKey: self.dayKey,
+            totals: UsageLedgerTotals(
+                inputTokens: self.inputTokens,
+                outputTokens: self.outputTokens,
+                cacheCreationTokens: self.cacheCreationTokens,
+                cacheReadTokens: self.cacheReadTokens,
+                costUSD: self.costUSD),
+            modelsUsed: self.modelsUsed)
+    }
+}

package/appcast.xml

@@ -2,6 +2,45 @@
 <rss xmlns:sparkle="http://www.andymatuschak.org/xml-namespaces/sparkle" version="2.0">
     <channel>
         <title>Runic</title>
+        <item>
+            <title>1.1.0</title>
+            <pubDate>Sun, 23 Mar 2026 00:00:00 +0100</pubDate>
+            <link>https://raw.githubusercontent.com/sriinnu/Runic/main/appcast.xml</link>
+            <sparkle:version>49</sparkle:version>
+            <sparkle:shortVersionString>1.1.0</sparkle:shortVersionString>
+            <sparkle:minimumSystemVersion>14.0</sparkle:minimumSystemVersion>
+            <description><![CDATA[<h2>Runic 1.1.0</h2>
+<ul>
+<li>Overview dashboard with activity ring, context windows, reset countdowns</li>
+<li>Context windows from config file (no recompile needed)</li>
+<li>Parallel provider refresh (concurrent instead of sequential)</li>
+<li>Keychain ACL fix (no more password prompts on relaunch)</li>
+</ul>
+]]></description>
+            <enclosure url="https://github.com/sriinnu/Runic/releases/download/v1.1.0/Runic-1.1.0.zip" length="30807384" type="application/octet-stream" sparkle:edSignature="hXMeE/CLrSDV+kbFythUA6w84WQ7u0YpvXK6uI58QHfBAn2FpH98xWERNfyL55gxBULdMASXzpv1UxmjtRFjCg=="/>
+        </item>
+        <item>
+            <title>1.0.0</title>
+            <pubDate>Sat, 22 Mar 2026 18:00:00 +0100</pubDate>
+            <link>https://raw.githubusercontent.com/sriinnu/Runic/main/appcast.xml</link>
+            <sparkle:version>48</sparkle:version>
+            <sparkle:shortVersionString>1.0.0</sparkle:shortVersionString>
+            <sparkle:minimumSystemVersion>14.0</sparkle:minimumSystemVersion>
+            <description><![CDATA[<h2>Runic 1.0.0</h2>
+<ul>
+<li>26 AI providers including Vertex AI and Qwen/DashScope</li>
+<li>Inline line charts (1h/6h/1d/7d/30d), hourly/weekly bar charts</li>
+<li>Provider tab bar with brand icons and Overview tab</li>
+<li>Hero stat, glassmorphism cards with sparklines</li>
+<li>Subscription utilization and usage window comparison charts</li>
+<li>Export usage as CSV or JSON</li>
+<li>Budget breach notifications</li>
+<li>Dark/Light/System theme</li>
+<li>Liquid UI animations</li>
+</ul>
+]]></description>
+            <enclosure url="https://github.com/sriinnu/Runic/releases/download/v1.0.0/Runic-1.0.0.zip" length="30772430" type="application/octet-stream" sparkle:edSignature="a065lJa+Gwv2mH8DcniAxFW4tHB2JD4ZnT39+tXWs0k4p+Zq61WKi699aowEf8HakfgnSU7OQ3YdL5X0XYn7CQ=="/>
+        </item>
         <item>
             <title>0.16.0</title>
             <pubDate>Mon, 29 Dec 2025 19:03:57 +0100</pubDate>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sriinnu/runic",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "AI usage monitoring for your Mac menubar. Track usage, costs, and quotas across 26 AI providers.",
   "author": "Srinivas Pendela <sriinnu@users.noreply.github.com>",
   "license": "MIT",

package/version.env

@@ -1,2 +1,2 @@
-MARKETING_VERSION=0.16.1
-BUILD_NUMBER=47
+MARKETING_VERSION=1.1.0
+BUILD_NUMBER=49