@sriinnu/runic 2.0.0 → 2.11.2

package/Tests/RunicTests/MenuCardModelTests.swift

@@ -1,544 +0,0 @@
-import Foundation
-import RunicCore
-import SwiftUI
-import Testing
-@testable import Runic
-
-extension UsageMenuCardView.Model.Input {
-    fileprivate init(
-        provider: UsageProvider,
-        metadata: ProviderMetadata,
-        snapshot: UsageSnapshot?,
-        credits: CreditsSnapshot?,
-        creditsError: String?,
-        dashboard: OpenAIDashboardSnapshot?,
-        dashboardError: String?,
-        tokenSnapshot: CostUsageTokenSnapshot?,
-        tokenError: String?,
-        ledgerDaily: UsageLedgerDailySummary? = nil,
-        ledgerActiveBlock: UsageLedgerBlockSummary? = nil,
-        ledgerTopModel: UsageLedgerModelSummary? = nil,
-        ledgerTopProject: UsageLedgerProjectSummary? = nil,
-        ledgerSpendForecast: UsageLedgerSpendForecast? = nil,
-        ledgerTopProjectSpendForecast: UsageLedgerSpendForecast? = nil,
-        ledgerAnomaly: UsageLedgerAnomalySummary? = nil,
-        ledgerReliability: UsageLedgerReliabilityScore? = nil,
-        ledgerRouting: UsageLedgerRoutingRecommendation? = nil,
-        ledgerError: String? = nil,
-        ledgerUpdatedAt: Date? = nil,
-        account: AccountInfo,
-        isRefreshing: Bool,
-        lastError: String?,
-        usageBarsShowUsed: Bool,
-        menuMode: MenuMode = .operator,
-        tokenCostUsageEnabled: Bool,
-        showOptionalCreditsAndExtraUsage: Bool,
-        now: Date)
-    {
-        self.init(
-            provider: provider,
-            metadata: metadata,
-            snapshot: snapshot,
-            credits: credits,
-            creditsError: creditsError,
-            dashboard: dashboard,
-            dashboardError: dashboardError,
-            tokenSnapshot: tokenSnapshot,
-            tokenError: tokenError,
-            ledgerDaily: ledgerDaily,
-            ledgerActiveBlock: ledgerActiveBlock,
-            ledgerTopModel: ledgerTopModel,
-            ledgerTopProject: ledgerTopProject,
-            ledgerSpendForecast: ledgerSpendForecast,
-            ledgerTopProjectSpendForecast: ledgerTopProjectSpendForecast,
-            ledgerAnomaly: ledgerAnomaly,
-            ledgerReliability: ledgerReliability,
-            ledgerRouting: ledgerRouting,
-            ledgerError: ledgerError,
-            ledgerUpdatedAt: ledgerUpdatedAt,
-            account: account,
-            isRefreshing: isRefreshing,
-            lastError: lastError,
-            usageBarsShowUsed: usageBarsShowUsed,
-            usageMetricDisplayMode: .barsAndPercent,
-            menuMode: menuMode,
-            tokenCostUsageEnabled: tokenCostUsageEnabled,
-            showOptionalCreditsAndExtraUsage: showOptionalCreditsAndExtraUsage,
-            now: now)
-    }
-}
-
-struct MenuCardModelTests {
-    @Test
-    func `builds metrics using remaining percent`() throws {
-        let now = Date()
-        let identity = ProviderIdentitySnapshot(
-            providerID: .codex,
-            accountEmail: "codex@example.com",
-            accountOrganization: nil,
-            loginMethod: "Plus Plan")
-        let snapshot = UsageSnapshot(
-            primary: RateWindow(
-                usedPercent: 22,
-                windowMinutes: 300,
-                resetsAt: now.addingTimeInterval(3000),
-                resetDescription: nil),
-            secondary: RateWindow(
-                usedPercent: 40,
-                windowMinutes: 10080,
-                resetsAt: now.addingTimeInterval(6000),
-                resetDescription: nil),
-            updatedAt: now,
-            identity: identity)
-        let metadata = try #require(ProviderDefaults.metadata[.codex])
-        let updatedSnap = try UsageSnapshot(
-            primary: snapshot.primary,
-            secondary: RateWindow(
-                usedPercent: #require(snapshot.secondary?.usedPercent),
-                windowMinutes: #require(snapshot.secondary?.windowMinutes),
-                resetsAt: now.addingTimeInterval(3600),
-                resetDescription: nil),
-            tertiary: snapshot.tertiary,
-            updatedAt: now,
-            identity: identity)
-
-        let model = UsageMenuCardView.Model.make(.init(
-            provider: .codex,
-            metadata: metadata,
-            snapshot: updatedSnap,
-            credits: CreditsSnapshot(remaining: 12, events: [], updatedAt: now),
-            creditsError: nil,
-            dashboard: nil,
-            dashboardError: nil,
-            tokenSnapshot: nil,
-            tokenError: nil,
-            account: AccountInfo(email: "codex@example.com", plan: "Plus Plan"),
-            isRefreshing: false,
-            lastError: nil,
-            usageBarsShowUsed: false,
-            tokenCostUsageEnabled: false,
-            showOptionalCreditsAndExtraUsage: true,
-            now: now))
-
-        #expect(model.providerName == "Codex")
-        #expect(model.metrics.count == 2)
-        #expect(model.metrics.first?.percent == 78)
-        #expect(model.planText == "Plus")
-        #expect(model.subtitleText.hasPrefix("Updated"))
-        #expect(model.progressColor != Color.clear)
-        #expect(model.metrics[1].resetText?.isEmpty == false)
-    }
-
-    @Test
-    func `builds metrics using used percent when enabled`() throws {
-        let now = Date()
-        let identity = ProviderIdentitySnapshot(
-            providerID: .codex,
-            accountEmail: "codex@example.com",
-            accountOrganization: nil,
-            loginMethod: "Plus Plan")
-        let snapshot = UsageSnapshot(
-            primary: RateWindow(
-                usedPercent: 22,
-                windowMinutes: 300,
-                resetsAt: now.addingTimeInterval(3000),
-                resetDescription: nil),
-            secondary: RateWindow(
-                usedPercent: 40,
-                windowMinutes: 10080,
-                resetsAt: now.addingTimeInterval(6000),
-                resetDescription: nil),
-            updatedAt: now,
-            identity: identity)
-        let metadata = try #require(ProviderDefaults.metadata[.codex])
-
-        let dashboard = OpenAIDashboardSnapshot(
-            signedInEmail: "codex@example.com",
-            codeReviewRemainingPercent: 73,
-            creditEvents: [],
-            dailyBreakdown: [],
-            usageBreakdown: [],
-            creditsPurchaseURL: nil,
-            updatedAt: now)
-
-        let model = UsageMenuCardView.Model.make(.init(
-            provider: .codex,
-            metadata: metadata,
-            snapshot: snapshot,
-            credits: nil,
-            creditsError: nil,
-            dashboard: dashboard,
-            dashboardError: nil,
-            tokenSnapshot: nil,
-            tokenError: nil,
-            account: AccountInfo(email: "codex@example.com", plan: "Plus Plan"),
-            isRefreshing: false,
-            lastError: nil,
-            usageBarsShowUsed: true,
-            tokenCostUsageEnabled: false,
-            showOptionalCreditsAndExtraUsage: true,
-            now: now))
-
-        #expect(model.metrics.first?.title == "Session")
-        #expect(model.metrics.first?.percent == 22)
-        #expect(model.metrics.first?.percentLabel.contains("used") == true)
-        #expect(model.metrics.contains { $0.title == "Code review" && $0.percent == 27 })
-    }
-
-    @Test
-    func `shows code review metric when dashboard present`() throws {
-        let now = Date()
-        let identity = ProviderIdentitySnapshot(
-            providerID: .codex,
-            accountEmail: "codex@example.com",
-            accountOrganization: nil,
-            loginMethod: nil)
-        let snapshot = UsageSnapshot(
-            primary: RateWindow(usedPercent: 0, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
-            secondary: nil,
-            tertiary: nil,
-            updatedAt: now,
-            identity: identity)
-        let metadata = try #require(ProviderDefaults.metadata[.codex])
-
-        let dashboard = OpenAIDashboardSnapshot(
-            signedInEmail: "codex@example.com",
-            codeReviewRemainingPercent: 73,
-            creditEvents: [],
-            dailyBreakdown: [],
-            usageBreakdown: [],
-            creditsPurchaseURL: nil,
-            updatedAt: now)
-        let model = UsageMenuCardView.Model.make(.init(
-            provider: .codex,
-            metadata: metadata,
-            snapshot: snapshot,
-            credits: nil,
-            creditsError: nil,
-            dashboard: dashboard,
-            dashboardError: nil,
-            tokenSnapshot: nil,
-            tokenError: nil,
-            account: AccountInfo(email: "codex@example.com", plan: nil),
-            isRefreshing: false,
-            lastError: nil,
-            usageBarsShowUsed: false,
-            tokenCostUsageEnabled: false,
-            showOptionalCreditsAndExtraUsage: true,
-            now: now))
-
-        #expect(model.metrics.contains { $0.title == "Code review" && $0.percent == 73 })
-    }
-
-    @Test
-    func `claude model hides weekly when unavailable`() throws {
-        let now = Date()
-        let identity = ProviderIdentitySnapshot(
-            providerID: .claude,
-            accountEmail: nil,
-            accountOrganization: nil,
-            loginMethod: "Max")
-        let snapshot = UsageSnapshot(
-            primary: RateWindow(
-                usedPercent: 2,
-                windowMinutes: nil,
-                resetsAt: now.addingTimeInterval(3600),
-                resetDescription: nil),
-            secondary: nil,
-            tertiary: nil,
-            updatedAt: now,
-            identity: identity)
-        let metadata = try #require(ProviderDefaults.metadata[.claude])
-        let model = UsageMenuCardView.Model.make(.init(
-            provider: .claude,
-            metadata: metadata,
-            snapshot: snapshot,
-            credits: nil,
-            creditsError: nil,
-            dashboard: nil,
-            dashboardError: nil,
-            tokenSnapshot: nil,
-            tokenError: nil,
-            account: AccountInfo(email: "codex@example.com", plan: "plus"),
-            isRefreshing: false,
-            lastError: nil,
-            usageBarsShowUsed: false,
-            tokenCostUsageEnabled: false,
-            showOptionalCreditsAndExtraUsage: true,
-            now: now))
-
-        #expect(model.metrics.count == 1)
-        #expect(model.metrics.first?.title == "Session")
-        #expect(model.planText == "Max")
-    }
-
-    @Test
-    func `shows error subtitle when present`() throws {
-        let metadata = try #require(ProviderDefaults.metadata[.codex])
-        let model = UsageMenuCardView.Model.make(.init(
-            provider: .codex,
-            metadata: metadata,
-            snapshot: nil,
-            credits: nil,
-            creditsError: nil,
-            dashboard: nil,
-            dashboardError: nil,
-            tokenSnapshot: nil,
-            tokenError: nil,
-            account: AccountInfo(email: nil, plan: nil),
-            isRefreshing: false,
-            lastError: "Probe failed for Codex",
-            usageBarsShowUsed: false,
-            tokenCostUsageEnabled: false,
-            showOptionalCreditsAndExtraUsage: true,
-            now: Date()))
-
-        #expect(model.subtitleStyle == .error)
-        #expect(model.subtitleText.contains("Probe failed"))
-        #expect(model.placeholder == nil)
-    }
-
-    @Test
-    func `cost section includes last30 days tokens`() throws {
-        let now = Date()
-        let metadata = try #require(ProviderDefaults.metadata[.codex])
-        let snapshot = UsageSnapshot(
-            primary: RateWindow(usedPercent: 0, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
-            secondary: nil,
-            tertiary: nil,
-            updatedAt: now)
-        let tokenSnapshot = CostUsageTokenSnapshot(
-            sessionTokens: 123,
-            sessionCostUSD: 1.23,
-            last30DaysTokens: 456,
-            last30DaysCostUSD: 78.9,
-            daily: [],
-            updatedAt: now)
-        let model = UsageMenuCardView.Model.make(.init(
-            provider: .codex,
-            metadata: metadata,
-            snapshot: snapshot,
-            credits: nil,
-            creditsError: nil,
-            dashboard: nil,
-            dashboardError: nil,
-            tokenSnapshot: tokenSnapshot,
-            tokenError: nil,
-            account: AccountInfo(email: nil, plan: nil),
-            isRefreshing: false,
-            lastError: nil,
-            usageBarsShowUsed: false,
-            tokenCostUsageEnabled: true,
-            showOptionalCreditsAndExtraUsage: true,
-            now: now))
-
-        #expect(model.tokenUsage?.monthLine.contains("456") == true)
-        #expect(model.tokenUsage?.monthLine.contains("tokens") == true)
-    }
-
-    @Test
-    func `claude model does not leak codex plan`() throws {
-        let metadata = try #require(ProviderDefaults.metadata[.claude])
-        let model = UsageMenuCardView.Model.make(.init(
-            provider: .claude,
-            metadata: metadata,
-            snapshot: nil,
-            credits: nil,
-            creditsError: nil,
-            dashboard: nil,
-            dashboardError: nil,
-            tokenSnapshot: nil,
-            tokenError: nil,
-            account: AccountInfo(email: "codex@example.com", plan: "plus"),
-            isRefreshing: false,
-            lastError: nil,
-            usageBarsShowUsed: false,
-            tokenCostUsageEnabled: false,
-            showOptionalCreditsAndExtraUsage: true,
-            now: Date()))
-
-        #expect(model.planText == nil)
-        #expect(model.email.isEmpty)
-    }
-
-    @Test
-    func `hides codex credits when disabled`() throws {
-        let now = Date()
-        let identity = ProviderIdentitySnapshot(
-            providerID: .codex,
-            accountEmail: "codex@example.com",
-            accountOrganization: nil,
-            loginMethod: nil)
-        let snapshot = UsageSnapshot(
-            primary: RateWindow(usedPercent: 0, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
-            secondary: nil,
-            tertiary: nil,
-            updatedAt: now,
-            identity: identity)
-        let metadata = try #require(ProviderDefaults.metadata[.codex])
-
-        let model = UsageMenuCardView.Model.make(.init(
-            provider: .codex,
-            metadata: metadata,
-            snapshot: snapshot,
-            credits: CreditsSnapshot(remaining: 12, events: [], updatedAt: now),
-            creditsError: nil,
-            dashboard: nil,
-            dashboardError: nil,
-            tokenSnapshot: nil,
-            tokenError: nil,
-            account: AccountInfo(email: "codex@example.com", plan: nil),
-            isRefreshing: false,
-            lastError: nil,
-            usageBarsShowUsed: false,
-            tokenCostUsageEnabled: false,
-            showOptionalCreditsAndExtraUsage: false,
-            now: now))
-
-        #expect(model.creditsText == nil)
-    }
-
-    @Test
-    func `hides claude extra usage when disabled`() throws {
-        let now = Date()
-        let identity = ProviderIdentitySnapshot(
-            providerID: .claude,
-            accountEmail: "claude@example.com",
-            accountOrganization: nil,
-            loginMethod: nil)
-        let snapshot = UsageSnapshot(
-            primary: RateWindow(usedPercent: 0, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
-            secondary: nil,
-            tertiary: nil,
-            providerCost: ProviderCostSnapshot(used: 12, limit: 200, currencyCode: "USD", updatedAt: now),
-            updatedAt: now,
-            identity: identity)
-        let metadata = try #require(ProviderDefaults.metadata[.claude])
-
-        let model = UsageMenuCardView.Model.make(.init(
-            provider: .claude,
-            metadata: metadata,
-            snapshot: snapshot,
-            credits: nil,
-            creditsError: nil,
-            dashboard: nil,
-            dashboardError: nil,
-            tokenSnapshot: nil,
-            tokenError: nil,
-            account: AccountInfo(email: nil, plan: nil),
-            isRefreshing: false,
-            lastError: nil,
-            usageBarsShowUsed: false,
-            tokenCostUsageEnabled: false,
-            showOptionalCreditsAndExtraUsage: false,
-            now: now))
-
-        #expect(model.providerCost == nil)
-    }
-
-    @Test
-    func `insights show forecast and budget ETA for top project`() throws {
-        let now = Date()
-        let metadata = try #require(ProviderDefaults.metadata[.codex])
-        let topProject = UsageLedgerProjectSummary(
-            provider: .codex,
-            projectKey: "id:proj-runic",
-            projectID: "proj-runic",
-            projectName: "Runic",
-            entryCount: 5,
-            totals: UsageLedgerTotals(
-                inputTokens: 2000,
-                outputTokens: 1000,
-                cacheCreationTokens: 0,
-                cacheReadTokens: 0,
-                costUSD: 12.5),
-            modelsUsed: ["gpt-5"])
-        let providerForecast = UsageLedgerSpendForecast(
-            provider: .codex,
-            observedDays: 3,
-            observedCostUSD: 36,
-            averageDailyCostUSD: 12,
-            projected30DayCostUSD: 360,
-            projectedCostP50USD: 330,
-            projectedCostP80USD: 420,
-            projectedCostP95USD: 510)
-        let projectForecast = UsageLedgerSpendForecast(
-            provider: .codex,
-            projectKey: "id:proj-runic",
-            projectID: "proj-runic",
-            projectName: "Runic",
-            observedDays: 3,
-            observedCostUSD: 36,
-            averageDailyCostUSD: 12,
-            projected30DayCostUSD: 360)
-            .applyingBudget(monthlyLimitUSD: 60)
-
-        let model = UsageMenuCardView.Model.make(.init(
-            provider: .codex,
-            metadata: metadata,
-            snapshot: nil,
-            credits: nil,
-            creditsError: nil,
-            dashboard: nil,
-            dashboardError: nil,
-            tokenSnapshot: nil,
-            tokenError: nil,
-            ledgerTopProject: topProject,
-            ledgerSpendForecast: providerForecast,
-            ledgerTopProjectSpendForecast: projectForecast,
-            account: AccountInfo(email: nil, plan: nil),
-            isRefreshing: false,
-            lastError: nil,
-            usageBarsShowUsed: false,
-            tokenCostUsageEnabled: false,
-            showOptionalCreditsAndExtraUsage: true,
-            now: now))
-
-        #expect(model.insights?.forecastLine?.contains("Month-end forecast") == true)
-        #expect(model.insights?.forecastLine?.contains("p80") == true)
-        #expect(model.insights?.forecastLine?.contains("p95") == true)
-        #expect(model.insights?.projectDetail?.contains("Budget") == true)
-        #expect(model.insights?.projectDetail?.contains("Breach") == true)
-    }
-
-    @Test
-    func `insights surface anomaly severity line`() throws {
-        let metadata = try #require(ProviderDefaults.metadata[.codex])
-        let anomaly = UsageLedgerAnomalySummary(
-            provider: .codex,
-            baselineDays: 7,
-            tokenAnomaly: UsageLedgerAnomalySummary.MetricAnomaly(
-                metric: .tokens,
-                severity: .high,
-                todayValue: 4200,
-                baselineAverage: 1500,
-                percentIncrease: 1.8),
-            spendAnomaly: UsageLedgerAnomalySummary.MetricAnomaly(
-                metric: .spend,
-                severity: .elevated,
-                todayValue: 17.5,
-                baselineAverage: 9.0,
-                percentIncrease: 0.94))
-        let model = UsageMenuCardView.Model.make(.init(
-            provider: .codex,
-            metadata: metadata,
-            snapshot: nil,
-            credits: nil,
-            creditsError: nil,
-            dashboard: nil,
-            dashboardError: nil,
-            tokenSnapshot: nil,
-            tokenError: nil,
-            ledgerAnomaly: anomaly,
-            account: AccountInfo(email: nil, plan: nil),
-            isRefreshing: false,
-            lastError: nil,
-            usageBarsShowUsed: false,
-            tokenCostUsageEnabled: false,
-            showOptionalCreditsAndExtraUsage: true,
-            now: Date()))
-
-        #expect(model.insights?.anomalyLine == "Anomaly: High tokens spike")
-        #expect(model.insights?.anomalyDetail?.contains("+180%") == true)
-    }
-}

package/Tests/RunicTests/MiniMaxCookieHeaderStoreTestSupport.swift

@@ -1,11 +0,0 @@
-@testable import Runic
-
-struct NoopMiniMaxCookieHeaderStore: MiniMaxCookieHeaderStoring {
-    func loadHeader() throws -> String? {
-        nil
-    }
-
-    func storeHeader(_ header: String?) throws {
-        _ = header
-    }
-}

package/Tests/RunicTests/MiniMaxGroupIDStoreTestSupport.swift

@@ -1,11 +0,0 @@
-@testable import Runic
-
-struct NoopMiniMaxGroupIDStore: MiniMaxGroupIDStoring {
-    func loadGroupID() throws -> String? {
-        nil
-    }
-
-    func storeGroupID(_ groupID: String?) throws {
-        _ = groupID
-    }
-}

package/Tests/RunicTests/MiniMaxParsingTests.swift

@@ -1,67 +0,0 @@
-import Foundation
-import Testing
-@testable import RunicCore
-
-struct MiniMaxParsingTests {
-    @Test
-    func `parse manual input cookie header`() {
-        let input = "Cookie: foo=bar; baz=qux"
-        let parsed = MiniMaxWebParsing.parseManualInput(input)
-        #expect(parsed?.cookieHeader == "foo=bar; baz=qux")
-        #expect(parsed?.accessToken == nil)
-    }
-
-    @Test
-    func `parse manual input curl extracts bearer and group ID`() {
-        let curl = """
-        curl 'https://platform.minimax.io/v1/api/openplatform/coding_plan/remains?GroupId=group_123' \
-          -H 'Cookie: session=abc; foo=bar' \
-          -H 'Authorization: Bearer header.token.value'
-        """
-        let parsed = MiniMaxWebParsing.parseManualInput(curl)
-        #expect(parsed?.cookieHeader == "session=abc; foo=bar")
-        #expect(parsed?.accessToken == "header.token.value")
-        #expect(parsed?.groupID == "group_123")
-    }
-
-    @Test
-    func `parse HTML usage with percent and reset`() {
-        let html = """
-        <html>
-        <head><title>MiniMax Pro</title></head>
-        <body>
-        <div>Available usage: 40%</div>
-        <div>Resets in 2d 3h</div>
-        </body>
-        </html>
-        """
-        let now = Date(timeIntervalSince1970: 0)
-        let parsed = MiniMaxWebParsing.parseHTMLUsage(html, now: now)
-        #expect(parsed?.usedPercent == 60)
-        #expect(parsed?.planName == "MiniMax Pro")
-        #expect(parsed?.resetDescription == "Resets in 2d 3h")
-        #expect(parsed?.resetsAt == now.addingTimeInterval(TimeInterval((2 * 24 * 60 + 3 * 60) * 60)))
-    }
-
-    @Test
-    func `parse remains response uses model remains`() throws {
-        let json = """
-        {
-          "base_resp": { "retcode": 0, "msg": "ok", "success": true },
-          "data": {
-            "model_remains": { "used": 20, "total": 100 },
-            "start_time": 1700000000,
-            "end_time": 1700003600,
-            "remains_time": 600,
-            "plan_name": "MiniMax Pro"
-          }
-        }
-        """
-        let now = Date(timeIntervalSince1970: 0)
-        let parsed = try MiniMaxWebParsing.parseRemainsResponse(Data(json.utf8), now: now)
-        #expect(parsed.usedPercent == 20)
-        #expect(parsed.windowMinutes == 60)
-        #expect(parsed.resetsAt == now.addingTimeInterval(600))
-        #expect(parsed.planName == "MiniMax Pro")
-    }
-}

package/Tests/RunicTests/MiniMaxTokenStoreTestSupport.swift

@@ -1,11 +0,0 @@
-@testable import Runic
-
-struct NoopMiniMaxTokenStore: MiniMaxTokenStoring {
-    func loadToken() throws -> String? {
-        nil
-    }
-
-    func storeToken(_ token: String?) throws {
-        _ = token
-    }
-}