@sriinnu/runic 1.0.0

package/Tests/RunicTests/OTelGenAILedgerAdapterTests.swift

@@ -0,0 +1,112 @@
+import Foundation
+import Testing
+
+@testable import RunicCore
+
+@Suite
+struct OTelGenAILedgerAdapterTests {
+    @Test
+    func parsesFlatGenAIPayloadIntoLedgerEntry() throws {
+        let payload = """
+        {
+          "timestamp": "2026-02-23T12:00:00Z",
+          "attributes": {
+            "gen_ai.system": "anthropic",
+            "gen_ai.request.model": "claude-3-5-sonnet",
+            "gen_ai.usage.input_tokens": 120,
+            "gen_ai.usage.output_tokens": "80",
+            "project.id": "proj-alpha",
+            "project.name": "Alpha",
+            "gen_ai.conversation.id": "session-1",
+            "gen_ai.request.id": "request-1",
+            "gen_ai.usage.cost": 0.42
+          }
+        }
+        """
+        let options = OTelGenAIIngestionOptions(enabled: true)
+        let entries = try OTelGenAILedgerAdapter.parseData(Data(payload.utf8), options: options)
+
+        #expect(entries.count == 1)
+        let entry = try #require(entries.first)
+        #expect(entry.provider == .claude)
+        #expect(entry.model == "claude-3-5-sonnet")
+        #expect(entry.inputTokens == 120)
+        #expect(entry.outputTokens == 80)
+        #expect(entry.projectID == "proj-alpha")
+        #expect(entry.projectName == "Alpha")
+        #expect(entry.sessionID == "session-1")
+        #expect(entry.requestID == "request-1")
+        #expect(abs((entry.costUSD ?? 0) - 0.42) < 0.000_001)
+    }
+
+    @Test
+    func parsesOTLPResourceSpansPayload() throws {
+        let payload = """
+        {
+          "resourceSpans": [
+            {
+              "resource": {
+                "attributes": [
+                  { "key": "project.name", "value": { "stringValue": "Telemetry Project" } }
+                ]
+              },
+              "scopeSpans": [
+                {
+                  "spans": [
+                    {
+                      "name": "chat.completion",
+                      "endTimeUnixNano": "1771828800000000000",
+                      "attributes": [
+                        { "key": "gen_ai.system", "value": { "stringValue": "openai" } },
+                        { "key": "gen_ai.request.model", "value": { "stringValue": "gpt-5" } },
+                        { "key": "gen_ai.usage.input_tokens", "value": { "intValue": "200" } },
+                        { "key": "gen_ai.usage.output_tokens", "value": { "doubleValue": 50.0 } },
+                        { "key": "project.id", "value": { "stringValue": "proj-otlp" } }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }
+        """
+        let entries = try OTelGenAILedgerAdapter.parseData(
+            Data(payload.utf8),
+            options: OTelGenAIIngestionOptions(enabled: true))
+
+        #expect(entries.count == 1)
+        let entry = try #require(entries.first)
+        #expect(entry.provider == .codex)
+        #expect(entry.model == "gpt-5")
+        #expect(entry.inputTokens == 200)
+        #expect(entry.outputTokens == 50)
+        #expect(entry.projectID == "proj-otlp")
+        #expect(entry.projectName == "Telemetry Project")
+    }
+
+    @Test
+    func featureFlagDisablesIngestion() throws {
+        let payload = """
+        {"attributes":{"gen_ai.system":"openai","gen_ai.request.model":"gpt-5","gen_ai.usage.input_tokens":1}}
+        """
+        let entries = try OTelGenAILedgerAdapter.parseData(
+            Data(payload.utf8),
+            options: OTelGenAIIngestionOptions(enabled: false))
+        #expect(entries.isEmpty)
+    }
+
+    @Test
+    func defaultProviderBackfillsUnknownProvider() throws {
+        let payload = """
+        {"attributes":{"gen_ai.request.model":"custom-model-v1","gen_ai.usage.input_tokens":9}}
+        """
+        let entries = try OTelGenAILedgerAdapter.parseData(
+            Data(payload.utf8),
+            options: OTelGenAIIngestionOptions(enabled: true, defaultProvider: .openrouter))
+
+        #expect(entries.count == 1)
+        #expect(entries.first?.provider == .openrouter)
+        #expect(entries.first?.model == "custom-model-v1")
+    }
+}

package/Tests/RunicTests/OpenAIDashboardBrowserCookieImporterTests.swift

@@ -0,0 +1,17 @@
+import RunicCore
+import Testing
+
+@Suite
+struct OpenAIDashboardBrowserCookieImporterTests {
+    @Test
+    func mismatchErrorMentionsSourceLabel() {
+        let err = OpenAIDashboardBrowserCookieImporter.ImportError.noMatchingAccount(
+            found: [
+                .init(sourceLabel: "Safari", email: "a@example.com"),
+                .init(sourceLabel: "Chrome", email: "b@example.com"),
+            ])
+        let msg = err.localizedDescription
+        #expect(msg.contains("Safari=a@example.com"))
+        #expect(msg.contains("Chrome=b@example.com"))
+    }
+}

package/Tests/RunicTests/OpenAIDashboardFetcherCreditsWaitTests.swift

@@ -0,0 +1,75 @@
+import Foundation
+import Testing
+@testable import RunicCore
+
+@Suite
+struct OpenAIDashboardFetcherCreditsWaitTests {
+    @Test
+    func waitsAfterScrollRequest() {
+        let now = Date()
+        let shouldWait = OpenAIDashboardFetcher.shouldWaitForCreditsHistory(.init(
+            now: now,
+            anyDashboardSignalAt: now.addingTimeInterval(-10),
+            creditsHeaderVisibleAt: nil,
+            creditsHeaderPresent: false,
+            creditsHeaderInViewport: false,
+            didScrollToCredits: true))
+        #expect(shouldWait == true)
+    }
+
+    @Test
+    func waitsBrieflyWhenHeaderVisibleButTableEmpty() {
+        let now = Date()
+        let visibleAt = now.addingTimeInterval(-1.0)
+        let shouldWait = OpenAIDashboardFetcher.shouldWaitForCreditsHistory(.init(
+            now: now,
+            anyDashboardSignalAt: now.addingTimeInterval(-10),
+            creditsHeaderVisibleAt: visibleAt,
+            creditsHeaderPresent: true,
+            creditsHeaderInViewport: true,
+            didScrollToCredits: false))
+        #expect(shouldWait == true)
+    }
+
+    @Test
+    func stopsWaitingAfterHeaderHasBeenVisibleLongEnough() {
+        let now = Date()
+        let visibleAt = now.addingTimeInterval(-3.0)
+        let shouldWait = OpenAIDashboardFetcher.shouldWaitForCreditsHistory(.init(
+            now: now,
+            anyDashboardSignalAt: now.addingTimeInterval(-10),
+            creditsHeaderVisibleAt: visibleAt,
+            creditsHeaderPresent: true,
+            creditsHeaderInViewport: true,
+            didScrollToCredits: false))
+        #expect(shouldWait == false)
+    }
+
+    @Test
+    func waitsBrieflyAfterFirstDashboardSignalEvenWhenHeaderNotPresentYet() {
+        let now = Date()
+        let startedAt = now.addingTimeInterval(-2.0)
+        let shouldWait = OpenAIDashboardFetcher.shouldWaitForCreditsHistory(.init(
+            now: now,
+            anyDashboardSignalAt: startedAt,
+            creditsHeaderVisibleAt: nil,
+            creditsHeaderPresent: false,
+            creditsHeaderInViewport: false,
+            didScrollToCredits: false))
+        #expect(shouldWait == true)
+    }
+
+    @Test
+    func stopsWaitingEventuallyWhenHeaderNeverAppears() {
+        let now = Date()
+        let startedAt = now.addingTimeInterval(-7.0)
+        let shouldWait = OpenAIDashboardFetcher.shouldWaitForCreditsHistory(.init(
+            now: now,
+            anyDashboardSignalAt: startedAt,
+            creditsHeaderVisibleAt: nil,
+            creditsHeaderPresent: false,
+            creditsHeaderInViewport: false,
+            didScrollToCredits: false))
+        #expect(shouldWait == false)
+    }
+}

package/Tests/RunicTests/OpenAIDashboardOffscreenHostTests.swift

@@ -0,0 +1,27 @@
+import Foundation
+import Testing
+@testable import RunicCore
+
+@Suite
+struct OpenAIDashboardOffscreenHostTests {
+    @Test
+    func offscreenHostFrameOnlyIntersectsByASliver() {
+        let visibleFrame = CGRect(x: 0, y: 0, width: 1000, height: 800)
+        let frame = OpenAIDashboardFetcher.offscreenHostWindowFrame(for: visibleFrame)
+        let intersection = frame.intersection(visibleFrame)
+
+        #expect(frame.size.width == visibleFrame.size.width)
+        #expect(frame.size.height == visibleFrame.size.height)
+        #expect(intersection.size.width <= 1.0)
+        #expect(intersection.size.height <= 1.0)
+        #expect(intersection.minX >= visibleFrame.maxX - 1.0)
+        #expect(intersection.minY >= visibleFrame.maxY - 1.0)
+    }
+
+    @Test
+    func offscreenHostAlphaValueIsNonZeroButTiny() {
+        let alpha = OpenAIDashboardFetcher.offscreenHostAlphaValue()
+        #expect(alpha > 0)
+        #expect(alpha <= 0.001)
+    }
+}

package/Tests/RunicTests/OpenAIDashboardParserTests.swift

@@ -0,0 +1,134 @@
+import RunicCore
+import Foundation
+import Testing
+@testable import Runic
+
+@Suite
+struct OpenAIDashboardParserTests {
+    @Test
+    func parsesSignedInEmailFromClientBootstrapHTML() {
+        let html = """
+        <html>
+        <head></head>
+        <body>
+        <script type="application/json" id="client-bootstrap">
+        {"authStatus":"logged_in","session":{"user":{"email":"studpete@gmail.com"}}}
+        </script>
+        </body>
+        </html>
+        """
+        #expect(OpenAIDashboardParser.parseSignedInEmailFromClientBootstrap(html: html) == "studpete@gmail.com")
+        #expect(OpenAIDashboardParser.parseAuthStatusFromClientBootstrap(html: html) == "logged_in")
+    }
+
+    @Test
+    func parsesCodeReviewRemainingPercent_inline() {
+        let body = "Balance\nCode review 42% remaining\nCredits remaining 291"
+        #expect(OpenAIDashboardParser.parseCodeReviewRemainingPercent(bodyText: body) == 42)
+    }
+
+    @Test
+    func parsesCodeReviewRemainingPercent_multiline() {
+        let body = "Balance\nCode review\n100% remaining\nWeekly usage limit\n0% remaining"
+        #expect(OpenAIDashboardParser.parseCodeReviewRemainingPercent(bodyText: body) == 100)
+    }
+
+    @Test
+    func parsesCreditsRemaining() {
+        let body = "Balance\nCredits remaining 1,234.56\nUsage"
+        let value = OpenAIDashboardParser.parseCreditsRemaining(bodyText: body)
+        #expect(abs((value ?? 0) - 1234.56) < 0.001)
+    }
+
+    @Test
+    func parsesRateLimits() {
+        let body = """
+        Usage limits
+        5h limit
+        72% remaining
+        Resets today at 2:15 PM
+        Weekly limit
+        41% remaining
+        Resets Fri at 9:00 AM
+        """
+        let limits = OpenAIDashboardParser.parseRateLimits(bodyText: body)
+        #expect(abs((limits.primary?.usedPercent ?? 0) - 28) < 0.001)
+        #expect(limits.primary?.windowMinutes == 300)
+        #expect(limits.primary?.resetDescription?.lowercased().contains("resets") == true)
+        #expect(abs((limits.secondary?.usedPercent ?? 0) - 59) < 0.001)
+        #expect(limits.secondary?.windowMinutes == 10080)
+    }
+
+    @Test
+    func parsesPlanFromClientBootstrap() {
+        let html = """
+        <html>
+        <body>
+        <script type="application/json" id="client-bootstrap">
+        {"session":{"user":{"email":"user@example.com"}},"planType":"plus"}
+        </script>
+        </body>
+        </html>
+        """
+        #expect(OpenAIDashboardParser.parsePlanFromHTML(html: html) == "Plus")
+    }
+
+    @Test
+    func parsesCreditEventsFromTableRows() {
+        let rows: [[String]] = [
+            ["Dec 18, 2025", "CLI", "397.205 credits"],
+            ["Dec 17, 2025", "GitHub Code Review", "506.235 credits"],
+        ]
+        let events = OpenAIDashboardParser.parseCreditEvents(rows: rows)
+        #expect(events.count == 2)
+        #expect(events.first?.service == "CLI")
+        #expect(abs((events.first?.creditsUsed ?? 0) - 397.205) < 0.0001)
+        #expect(events.last?.service == "GitHub Code Review")
+        #expect(abs((events.last?.creditsUsed ?? 0) - 506.235) < 0.0001)
+    }
+
+    @Test
+    func buildsDailyBreakdownFromEvents() {
+        let calendar = Calendar(identifier: .gregorian)
+        var components = DateComponents()
+        components.calendar = calendar
+        components.timeZone = TimeZone(secondsFromGMT: 0)
+
+        components.year = 2025
+        components.month = 12
+        components.day = 18
+        let dec18 = components.date!
+
+        components.day = 17
+        let dec17 = components.date!
+
+        let events = [
+            CreditEvent(date: dec18, service: "CLI", creditsUsed: 10),
+            CreditEvent(date: dec18, service: "CLI", creditsUsed: 5),
+            CreditEvent(date: dec18, service: "GitHub Code Review", creditsUsed: 2),
+            CreditEvent(date: dec17, service: "CLI", creditsUsed: 1),
+        ]
+
+        let breakdown = OpenAIDashboardSnapshot.makeDailyBreakdown(from: events, maxDays: 30)
+        #expect(breakdown.count == 2)
+        #expect(breakdown.first?.services.first?.service == "CLI")
+        #expect(abs((breakdown.first?.services.first?.creditsUsed ?? 0) - 15) < 0.0001)
+    }
+
+    @Test
+    func decodesSnapshotWithoutUsageBreakdownField() throws {
+        let json = """
+        {
+          "signedInEmail": "user@example.com",
+          "codeReviewRemainingPercent": 42,
+          "creditEvents": [],
+          "dailyBreakdown": [],
+          "updatedAt": "2025-12-18T00:00:00Z"
+        }
+        """
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+        let snapshot = try decoder.decode(OpenAIDashboardSnapshot.self, from: Data(json.utf8))
+        #expect(snapshot.usageBreakdown.isEmpty)
+    }
+}

package/Tests/RunicTests/OpenAIWebAccountSwitchTests.swift

@@ -0,0 +1,53 @@
+import RunicCore
+import Foundation
+import Testing
+@testable import Runic
+
+@MainActor
+@Suite
+struct OpenAIWebAccountSwitchTests {
+    @Test
+    func clearsDashboardWhenCodexEmailChanges() {
+        let settings = SettingsStore(zaiTokenStore: NoopZaiTokenStore(), minimaxTokenStore: NoopMiniMaxTokenStore(), minimaxCookieHeaderStore: NoopMiniMaxCookieHeaderStore(), minimaxGroupIDStore: NoopMiniMaxGroupIDStore(), openRouterTokenStore: NoopOpenRouterTokenStore(), groqTokenStore: NoopGroqTokenStore())
+        settings.refreshFrequency = .manual
+
+        let store = UsageStore(fetcher: UsageFetcher(), settings: settings)
+
+        store.handleOpenAIWebTargetEmailChangeIfNeeded(targetEmail: "a@example.com")
+        store.openAIDashboard = OpenAIDashboardSnapshot(
+            signedInEmail: "a@example.com",
+            codeReviewRemainingPercent: 100,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            updatedAt: Date())
+
+        store.handleOpenAIWebTargetEmailChangeIfNeeded(targetEmail: "b@example.com")
+        #expect(store.openAIDashboard == nil)
+        #expect(store.openAIDashboardRequiresLogin == true)
+        #expect(store.openAIDashboardCookieImportStatus?.contains("Codex account changed") == true)
+    }
+
+    @Test
+    func keepsDashboardWhenCodexEmailStaysSame() {
+        let settings = SettingsStore(zaiTokenStore: NoopZaiTokenStore(), minimaxTokenStore: NoopMiniMaxTokenStore(), minimaxCookieHeaderStore: NoopMiniMaxCookieHeaderStore(), minimaxGroupIDStore: NoopMiniMaxGroupIDStore(), openRouterTokenStore: NoopOpenRouterTokenStore(), groqTokenStore: NoopGroqTokenStore())
+        settings.refreshFrequency = .manual
+
+        let store = UsageStore(fetcher: UsageFetcher(), settings: settings)
+
+        store.handleOpenAIWebTargetEmailChangeIfNeeded(targetEmail: "a@example.com")
+        let dash = OpenAIDashboardSnapshot(
+            signedInEmail: "a@example.com",
+            codeReviewRemainingPercent: 100,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            updatedAt: Date())
+        store.openAIDashboard = dash
+
+        store.handleOpenAIWebTargetEmailChangeIfNeeded(targetEmail: "a@example.com")
+        #expect(store.openAIDashboard == dash)
+    }
+}

package/Tests/RunicTests/OpenRouterTokenStoreTestSupport.swift

@@ -0,0 +1,92 @@
+@testable import Runic
+
+struct NoopOpenRouterTokenStore: OpenRouterTokenStoring {
+    func loadToken() throws -> String? { nil }
+    func storeToken(_ token: String?) throws {
+        _ = token
+    }
+}
+
+struct NoopGroqTokenStore: GroqTokenStoring {
+    func loadToken() throws -> String? { nil }
+    func storeToken(_ token: String?) throws {
+        _ = token
+    }
+}
+
+struct NoopDeepSeekTokenStore: DeepSeekTokenStoring {
+    func loadToken() throws -> String? { nil }
+    func storeToken(_ token: String?) throws {
+        _ = token
+    }
+}
+
+struct NoopFireworksTokenStore: FireworksTokenStoring {
+    func loadToken() throws -> String? { nil }
+    func storeToken(_ token: String?) throws {
+        _ = token
+    }
+}
+
+struct NoopMistralTokenStore: MistralTokenStoring {
+    func loadToken() throws -> String? { nil }
+    func storeToken(_ token: String?) throws {
+        _ = token
+    }
+}
+
+struct NoopPerplexityTokenStore: PerplexityTokenStoring {
+    func loadToken() throws -> String? { nil }
+    func storeToken(_ token: String?) throws {
+        _ = token
+    }
+}
+
+struct NoopKimiTokenStore: KimiTokenStoring {
+    func loadToken() throws -> String? { nil }
+    func storeToken(_ token: String?) throws {
+        _ = token
+    }
+}
+
+struct NoopAuggieTokenStore: AuggieTokenStoring {
+    func loadToken() throws -> String? { nil }
+    func storeToken(_ token: String?) throws {
+        _ = token
+    }
+}
+
+struct NoopTogetherTokenStore: TogetherTokenStoring {
+    func loadToken() throws -> String? { nil }
+    func storeToken(_ token: String?) throws {
+        _ = token
+    }
+}
+
+struct NoopCohereTokenStore: CohereTokenStoring {
+    func loadToken() throws -> String? { nil }
+    func storeToken(_ token: String?) throws {
+        _ = token
+    }
+}
+
+struct NoopXAITokenStore: XAITokenStoring {
+    func loadToken() throws -> String? { nil }
+    func storeToken(_ token: String?) throws {
+        _ = token
+    }
+}
+
+struct NoopCerebrasTokenStore: CerebrasTokenStoring {
+    func loadToken() throws -> String? { nil }
+    func storeToken(_ token: String?) throws {
+        _ = token
+    }
+}
+
+struct NoopSambaNovaTokenStore: SambaNovaTokenStoring {
+    func loadToken() throws -> String? { nil }
+    func storeToken(_ token: String?) throws {
+        _ = token
+    }
+}