@sriinnu/runic 1.2.0 → 2.11.1

package/Tests/RunicTests/ClaudeUsageTests.swift

@@ -1,370 +0,0 @@
-import RunicCore
-import Foundation
-import Testing
-@testable import Runic
-
-@Suite
-struct ClaudeUsageTests {
-    @Test
-    func parsesUsageJSONWithSonnetLimit() {
-        let json = """
-        {
-          "ok": true,
-          "session_5h": { "pct_used": 1, "resets": "11am (Europe/Vienna)" },
-          "week_all_models": { "pct_used": 8, "resets": "Nov 21 at 5am (Europe/Vienna)" },
-          "week_sonnet": { "pct_used": 0, "resets": "Nov 21 at 5am (Europe/Vienna)" }
-        }
-        """
-        let data = Data(json.utf8)
-        let snap = ClaudeUsageFetcher.parse(json: data)
-        #expect(snap != nil)
-        #expect(snap?.primary.usedPercent == 1)
-        #expect(snap?.secondary?.usedPercent == 8)
-        #expect(snap?.primary.resetDescription == "11am (Europe/Vienna)")
-    }
-
-    @Test
-    func parsesUsageJSONWhenWeeklyMissing() {
-        let json = """
-        {
-          "ok": true,
-          "session_5h": { "pct_used": 4, "resets": "11am (Europe/Vienna)" }
-        }
-        """
-        let data = Data(json.utf8)
-        let snap = ClaudeUsageFetcher.parse(json: data)
-        #expect(snap != nil)
-        #expect(snap?.primary.usedPercent == 4)
-        #expect(snap?.secondary == nil)
-    }
-
-    @Test
-    func parsesLegacyOpusAndAccount() {
-        let json = """
-        {
-          "ok": true,
-          "session_5h": { "pct_used": 2, "resets": "10:59pm (Europe/Vienna)" },
-          "week_all_models": { "pct_used": 13, "resets": "Nov 21 at 4:59am (Europe/Vienna)" },
-          "week_opus": { "pct_used": 0, "resets": "" },
-          "account_email": " sriinnu@icloud.com ",
-          "account_org": ""
-        }
-        """
-        let data = Data(json.utf8)
-        let snap = ClaudeUsageFetcher.parse(json: data)
-        #expect(snap?.opus?.usedPercent == 0)
-        #expect(snap?.opus?.resetDescription?.isEmpty == true)
-        #expect(snap?.accountEmail == "sriinnu@icloud.com")
-        #expect(snap?.accountOrganization == nil)
-    }
-
-    @Test
-    func parsesUsageJSONWhenOnlySonnetLimitIsPresent() {
-        let json = """
-        {
-          "ok": true,
-          "session_5h": { "pct_used": 3, "resets": "11am (Europe/Vienna)" },
-          "week_all_models": { "pct_used": 9, "resets": "Nov 21 at 5am (Europe/Vienna)" },
-          "week_sonnet_only": { "pct_used": 12, "resets": "Nov 22 at 5am (Europe/Vienna)" }
-        }
-        """
-        let data = Data(json.utf8)
-        let snap = ClaudeUsageFetcher.parse(json: data)
-        #expect(snap?.secondary?.usedPercent == 9)
-        #expect(snap?.opus?.usedPercent == 12)
-        #expect(snap?.opus?.resetDescription == "Nov 22 at 5am (Europe/Vienna)")
-    }
-
-    @Test
-    func trimsAccountFields() throws {
-        let cases: [[String: String?]] = [
-            ["email": " sriinnu@icloud.com ", "org": "  Org  "],
-            ["email": "", "org": " Claude Max Account "],
-            ["email": nil, "org": " "],
-        ]
-
-        for entry in cases {
-            var payload = [
-                "ok": true,
-                "session_5h": ["pct_used": 0, "resets": ""],
-                "week_all_models": ["pct_used": 0, "resets": ""],
-            ] as [String: Any]
-            if let email = entry["email"] { payload["account_email"] = email }
-            if let org = entry["org"] { payload["account_org"] = org }
-            let data = try JSONSerialization.data(withJSONObject: payload)
-            let snap = ClaudeUsageFetcher.parse(json: data)
-            let emailRaw: String? = entry["email"] ?? Optional<String>.none
-            let expectedEmail = emailRaw?.trimmingCharacters(in: .whitespacesAndNewlines)
-            let normalizedEmail = (expectedEmail?.isEmpty ?? true) ? nil : expectedEmail
-            #expect(snap?.accountEmail == normalizedEmail)
-            let orgRaw: String? = entry["org"] ?? Optional<String>.none
-            let expectedOrg = orgRaw?.trimmingCharacters(in: .whitespacesAndNewlines)
-            let normalizedOrg = (expectedOrg?.isEmpty ?? true) ? nil : expectedOrg
-            #expect(snap?.accountOrganization == normalizedOrg)
-        }
-    }
-
-    @Test
-    func liveClaudeFetchPTY() async throws {
-        guard ProcessInfo.processInfo.environment["LIVE_CLAUDE_FETCH"] == "1" else {
-            return
-        }
-        let fetcher = ClaudeUsageFetcher(dataSource: .cli)
-        do {
-            let snap = try await fetcher.loadLatestUsage()
-            let opusUsed = snap.opus?.usedPercent ?? -1
-            let weeklyUsed = snap.secondary?.usedPercent ?? -1
-            let email = snap.accountEmail ?? "nil"
-            let org = snap.accountOrganization ?? "nil"
-            print(
-                """
-                Live Claude usage (PTY):
-                session used \(snap.primary.usedPercent)% 
-                week used \(weeklyUsed)% 
-                opus \(opusUsed)% 
-                email \(email) org \(org)
-                """)
-            #expect(snap.primary.usedPercent >= 0)
-        } catch {
-            // Dump raw CLI text captured via `script` to help debug.
-            let raw = try Self.captureClaudeUsageRaw(timeout: 15)
-            print("RAW CLAUDE OUTPUT BEGIN\n\(raw)\nRAW CLAUDE OUTPUT END")
-            throw error
-        }
-    }
-
-    private static func captureClaudeUsageRaw(timeout: TimeInterval) throws -> String {
-        let process = Process()
-        process.launchPath = "/usr/bin/script"
-        process.arguments = [
-            "-q",
-            "/dev/null",
-            "claude",
-            "/usage",
-            "--allowed-tools",
-            "",
-        ]
-        let pipe = Pipe()
-        process.standardOutput = pipe
-        process.standardError = Pipe()
-        process.standardInput = nil
-
-        try process.run()
-        DispatchQueue.global().asyncAfter(deadline: .now() + timeout) {
-            if process.isRunning { process.terminate() }
-        }
-        process.waitUntilExit()
-
-        let data = pipe.fileHandleForReading.readDataToEndOfFile()
-        return String(data: data, encoding: .utf8) ?? ""
-    }
-
-    // MARK: - Web API tests
-
-    @Test
-    func liveClaudeFetchWebAPI() async throws {
-        // Set LIVE_CLAUDE_WEB_FETCH=1 to run this test with real browser cookies
-        guard ProcessInfo.processInfo.environment["LIVE_CLAUDE_WEB_FETCH"] == "1" else {
-            return
-        }
-        let fetcher = ClaudeUsageFetcher(dataSource: .web)
-        let snap = try await fetcher.loadLatestUsage()
-        let weeklyUsed = snap.secondary?.usedPercent ?? -1
-        let opusUsed = snap.opus?.usedPercent ?? -1
-        print(
-            """
-            Live Claude usage (Web API):
-            session used \(snap.primary.usedPercent)%
-            week used \(weeklyUsed)%
-            opus \(opusUsed)%
-            login method: \(snap.loginMethod ?? "nil")
-            """)
-        #expect(snap.primary.usedPercent >= 0)
-    }
-
-    @Test
-    func claudeWebAPIHasSessionKeyCheck() {
-        // Quick check that hasSessionKey returns a boolean (doesn't crash)
-        let hasKey = ClaudeWebAPIFetcher.hasSessionKey()
-        // We can't assert the value since it depends on the test environment
-        #expect(hasKey == true || hasKey == false)
-    }
-
-    @Test
-    func parsesClaudeWebAPIUsageResponse() throws {
-        let json = """
-        {
-          "five_hour": { "utilization": 9, "resets_at": "2025-12-23T16:00:00.000Z" },
-          "seven_day": { "utilization": 4, "resets_at": "2025-12-29T23:00:00.000Z" },
-          "seven_day_opus": { "utilization": 1 }
-        }
-        """
-        let data = Data(json.utf8)
-        let parsed = try ClaudeWebAPIFetcher._parseUsageResponseForTesting(data)
-        #expect(parsed.sessionPercentUsed == 9)
-        #expect(parsed.weeklyPercentUsed == 4)
-        #expect(parsed.opusPercentUsed == 1)
-        #expect(parsed.sessionResetsAt != nil)
-        #expect(parsed.weeklyResetsAt != nil)
-    }
-
-    @Test
-    func parsesClaudeWebAPIUsageResponseWhenWeeklyMissing() throws {
-        let json = """
-        {
-          "five_hour": { "utilization": 9, "resets_at": "2025-12-23T16:00:00.000Z" }
-        }
-        """
-        let data = Data(json.utf8)
-        let parsed = try ClaudeWebAPIFetcher._parseUsageResponseForTesting(data)
-        #expect(parsed.sessionPercentUsed == 9)
-        #expect(parsed.weeklyPercentUsed == nil)
-    }
-
-    @Test
-    func parsesClaudeWebAPIOverageSpendLimit() {
-        let json = """
-        {
-          "monthly_credit_limit": 2000,
-          "currency": "EUR",
-          "used_credits": 0,
-          "is_enabled": true
-        }
-        """
-        let data = Data(json.utf8)
-        let cost = ClaudeWebAPIFetcher._parseOverageSpendLimitForTesting(data)
-        #expect(cost != nil)
-        #expect(cost?.currencyCode == "EUR")
-        #expect(cost?.limit == 20)
-        #expect(cost?.used == 0)
-        #expect(cost?.period == "Monthly")
-    }
-
-    @Test
-    func parsesClaudeWebAPIOverageSpendLimitCents() {
-        let json = """
-        {
-          "monthly_credit_limit": 12345,
-          "currency": "USD",
-          "used_credits": 6789,
-          "is_enabled": true
-        }
-        """
-        let data = Data(json.utf8)
-        let cost = ClaudeWebAPIFetcher._parseOverageSpendLimitForTesting(data)
-        #expect(cost?.currencyCode == "USD")
-        #expect(cost?.limit == 123.45)
-        #expect(cost?.used == 67.89)
-    }
-
-    @Test
-    func parsesClaudeWebAPIOrganizationsResponse() throws {
-        let json = """
-        [
-          { "uuid": "org-123", "name": "Example Org", "capabilities": [] }
-        ]
-        """
-        let data = Data(json.utf8)
-        let org = try ClaudeWebAPIFetcher._parseOrganizationsResponseForTesting(data)
-        #expect(org.id == "org-123")
-        #expect(org.name == "Example Org")
-    }
-
-    @Test
-    func parsesClaudeWebAPIAccountInfo() {
-        let json = """
-        {
-          "email_address": "sriinnu@icloud.com",
-          "memberships": [
-            {
-              "organization": {
-                "uuid": "org-123",
-                "name": "Example Org",
-                "rate_limit_tier": "default_claude_max_20x",
-                "billing_type": "stripe_subscription"
-              }
-            }
-          ]
-        }
-        """
-        let data = Data(json.utf8)
-        let info = ClaudeWebAPIFetcher._parseAccountInfoForTesting(data, orgId: "org-123")
-        #expect(info?.email == "sriinnu@icloud.com")
-        #expect(info?.loginMethod == "Claude Max")
-    }
-
-    @Test
-    func parsesClaudeWebAPIAccountInfoSelectsMatchingOrg() {
-        let json = """
-        {
-          "email_address": "sriinnu@icloud.com",
-          "memberships": [
-            {
-              "organization": {
-                "uuid": "org-other",
-                "name": "Other Org",
-                "rate_limit_tier": "claude_pro",
-                "billing_type": "stripe_subscription"
-              }
-            },
-            {
-              "organization": {
-                "uuid": "org-123",
-                "name": "Example Org",
-                "rate_limit_tier": "claude_team",
-                "billing_type": "stripe_subscription"
-              }
-            }
-          ]
-        }
-        """
-        let data = Data(json.utf8)
-        let info = ClaudeWebAPIFetcher._parseAccountInfoForTesting(data, orgId: "org-123")
-        #expect(info?.loginMethod == "Claude Team")
-    }
-
-    @Test
-    func parsesClaudeWebAPIAccountInfoFallsBackToFirstMembership() {
-        let json = """
-        {
-          "email_address": "sriinnu@icloud.com",
-          "memberships": [
-            {
-              "organization": {
-                "uuid": "org-first",
-                "name": "First Org",
-                "rate_limit_tier": "claude_enterprise",
-                "billing_type": "invoice"
-              }
-            },
-            {
-              "organization": {
-                "uuid": "org-second",
-                "name": "Second Org",
-                "rate_limit_tier": "claude_pro",
-                "billing_type": "stripe_subscription"
-              }
-            }
-          ]
-        }
-        """
-        let data = Data(json.utf8)
-        let info = ClaudeWebAPIFetcher._parseAccountInfoForTesting(data, orgId: nil)
-        #expect(info?.loginMethod == "Claude Enterprise")
-    }
-
-    @Test
-    func claudeUsageFetcherInitWithDataSources() {
-        // Verify we can create fetchers with both configurations
-        let defaultFetcher = ClaudeUsageFetcher()
-        let webFetcher = ClaudeUsageFetcher(dataSource: .web)
-        let cliFetcher = ClaudeUsageFetcher(dataSource: .cli)
-        // Both should be valid instances (no crashes)
-        let defaultVersion = defaultFetcher.detectVersion()
-        let webVersion = webFetcher.detectVersion()
-        let cliVersion = cliFetcher.detectVersion()
-        #expect(defaultVersion?.isEmpty != true)
-        #expect(webVersion?.isEmpty != true)
-        #expect(cliVersion?.isEmpty != true)
-    }
-}

package/Tests/RunicTests/CodexOAuthTests.swift

@@ -1,122 +0,0 @@
-import Foundation
-import Testing
-@testable import RunicCore
-
-@Suite
-struct CodexOAuthTests {
-    @Test
-    func parsesOAuthCredentials() throws {
-        let json = """
-        {
-          "OPENAI_API_KEY": null,
-          "tokens": {
-            "access_token": "access-token",
-            "refresh_token": "refresh-token",
-            "id_token": "id-token",
-            "account_id": "account-123"
-          },
-          "last_refresh": "2025-12-20T12:34:56Z"
-        }
-        """
-        let creds = try CodexOAuthCredentialsStore.parse(data: Data(json.utf8))
-        #expect(creds.accessToken == "access-token")
-        #expect(creds.refreshToken == "refresh-token")
-        #expect(creds.idToken == "id-token")
-        #expect(creds.accountId == "account-123")
-        #expect(creds.lastRefresh != nil)
-    }
-
-    @Test
-    func parsesAPIKeyCredentials() throws {
-        let json = """
-        {
-          "OPENAI_API_KEY": "sk-test"
-        }
-        """
-        let creds = try CodexOAuthCredentialsStore.parse(data: Data(json.utf8))
-        #expect(creds.accessToken == "sk-test")
-        #expect(creds.refreshToken.isEmpty)
-        #expect(creds.idToken == nil)
-        #expect(creds.accountId == nil)
-    }
-
-    @Test
-    func decodesCreditsBalanceString() throws {
-        let json = """
-        {
-          "plan_type": "pro",
-          "rate_limit": {
-            "primary_window": {
-              "used_percent": 12,
-              "reset_at": 1766948068,
-              "limit_window_seconds": 18000
-            }
-          },
-          "credits": {
-            "has_credits": false,
-            "unlimited": false,
-            "balance": "0"
-          }
-        }
-        """
-        let response = try CodexOAuthUsageFetcher._decodeUsageResponseForTesting(Data(json.utf8))
-        #expect(response.planType?.rawValue == "pro")
-        #expect(response.credits?.balance == 0)
-        #expect(response.credits?.hasCredits == false)
-        #expect(response.credits?.unlimited == false)
-    }
-
-    @Test
-    func mapsUsageWindowsFromOAuth() throws {
-        let json = """
-        {
-          "rate_limit": {
-            "primary_window": {
-              "used_percent": 22,
-              "reset_at": 1766948068,
-              "limit_window_seconds": 18000
-            },
-            "secondary_window": {
-              "used_percent": 43,
-              "reset_at": 1767407914,
-              "limit_window_seconds": 604800
-            }
-          }
-        }
-        """
-        let creds = CodexOAuthCredentials(
-            accessToken: "access",
-            refreshToken: "refresh",
-            idToken: nil,
-            accountId: nil,
-            lastRefresh: Date())
-        let snapshot = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
-        #expect(snapshot.primary.usedPercent == 22)
-        #expect(snapshot.primary.windowMinutes == 300)
-        #expect(snapshot.secondary?.usedPercent == 43)
-        #expect(snapshot.secondary?.windowMinutes == 10080)
-        #expect(snapshot.primary.resetsAt != nil)
-        #expect(snapshot.secondary?.resetsAt != nil)
-    }
-
-    @Test
-    func resolvesChatGPTUsageURLFromConfig() {
-        let config = "chatgpt_base_url = \"https://chatgpt.com/backend-api/\"\n"
-        let url = CodexOAuthUsageFetcher._resolveUsageURLForTesting(configContents: config)
-        #expect(url.absoluteString == "https://chatgpt.com/backend-api/wham/usage")
-    }
-
-    @Test
-    func resolvesCodexUsageURLFromConfig() {
-        let config = "chatgpt_base_url = \"https://api.openai.com\"\n"
-        let url = CodexOAuthUsageFetcher._resolveUsageURLForTesting(configContents: config)
-        #expect(url.absoluteString == "https://api.openai.com/api/codex/usage")
-    }
-
-    @Test
-    func normalizesChatGPTBaseURLWithoutBackendAPI() {
-        let config = "chatgpt_base_url = \"https://chat.openai.com\"\n"
-        let url = CodexOAuthUsageFetcher._resolveUsageURLForTesting(configContents: config)
-        #expect(url.absoluteString == "https://chat.openai.com/backend-api/wham/usage")
-    }
-}

package/Tests/RunicTests/CodexUsageLogSourceTests.swift

@@ -1,82 +0,0 @@
-import Foundation
-import Testing
-
-@testable import RunicCore
-
-@Suite
-struct CodexUsageLogSourceTests {
-    @Test
-    func codexUsageFallsBackToWorkspacePathFromTurnContext() async throws {
-        let fm = FileManager.default
-        let root = fm.temporaryDirectory
-            .appendingPathComponent("runic-codex-usage-tests", isDirectory: true)
-            .appendingPathComponent(UUID().uuidString, isDirectory: true)
-        try fm.createDirectory(at: root, withIntermediateDirectories: true)
-        defer { try? fm.removeItem(at: root) }
-
-        let now = Date(timeIntervalSince1970: 1_767_122_400) // 2026-01-01T00:00:00Z
-        var calendar = Calendar(identifier: .gregorian)
-        calendar.timeZone = TimeZone(secondsFromGMT: 0) ?? .current
-        let parts = calendar.dateComponents([.year, .month, .day], from: now)
-        let dayDir = root
-            .appendingPathComponent(String(format: "%04d", parts.year ?? 1970), isDirectory: true)
-            .appendingPathComponent(String(format: "%02d", parts.month ?? 1), isDirectory: true)
-            .appendingPathComponent(String(format: "%02d", parts.day ?? 1), isDirectory: true)
-        try fm.createDirectory(at: dayDir, withIntermediateDirectories: true)
-
-        let formatter = ISO8601DateFormatter()
-        formatter.formatOptions = [.withInternetDateTime]
-        let turnTimestamp = formatter.string(from: now)
-        let tokenTimestamp = formatter.string(from: now.addingTimeInterval(1))
-
-        let turnContext = try Self.jsonLine([
-            "type": "turn_context",
-            "timestamp": turnTimestamp,
-            "payload": [
-                "model": "openai/gpt-5.2-codex",
-                "workspace_path": "/Users/me/work/Runic-App",
-            ],
-        ])
-        let tokenCount = try Self.jsonLine([
-            "type": "event_msg",
-            "timestamp": tokenTimestamp,
-            "payload": [
-                "type": "token_count",
-                "info": [
-                    "model": "openai/gpt-5.2-codex",
-                    "total_token_usage": [
-                        "input_tokens": 120,
-                        "cached_input_tokens": 20,
-                        "output_tokens": 10,
-                    ],
-                ],
-            ],
-        ])
-
-        let fileURL = dayDir.appendingPathComponent("session.jsonl")
-        try "\(turnContext)\n\(tokenCount)\n".write(to: fileURL, atomically: true, encoding: .utf8)
-
-        let source = CodexUsageLogSource(
-            environment: [:],
-            fileManager: fm,
-            sessionsRoot: root,
-            maxAgeDays: nil,
-            now: now)
-        let entries = try await source.loadEntries()
-
-        #expect(entries.count == 1)
-        #expect(entries.first?.projectID == "/Users/me/work/Runic-App")
-        #expect(entries.first?.projectName == nil)
-
-        let summary = UsageLedgerAggregator.projectSummaries(entries: entries).first
-        #expect(summary?.displayProjectName == "Runic-App")
-    }
-
-    private static func jsonLine(_ object: [String: Any]) throws -> String {
-        let data = try JSONSerialization.data(withJSONObject: object, options: [.sortedKeys])
-        guard let text = String(data: data, encoding: .utf8) else {
-            throw NSError(domain: "CodexUsageLogSourceTests", code: 1)
-        }
-        return text
-    }
-}

package/Tests/RunicTests/CopilotTokenResolverTests.swift

@@ -1,75 +0,0 @@
-import Foundation
-import Testing
-@testable import RunicCore
-
-@Suite
-struct CopilotTokenResolverTests {
-    @Test
-    func copilotTokenPrefersCopilotApiEnvironmentVariable() {
-        let env = [
-            "COPILOT_API_TOKEN": "copilot-env-token",
-            "GITHUB_TOKEN": "github-token",
-            "GH_TOKEN": "gh-fallback-token",
-        ]
-        let resolution = ProviderTokenResolver.copilotResolution(environment: env)
-        #expect(resolution?.token == "copilot-env-token")
-        #expect(resolution?.source == .environment)
-        #expect(resolution?.sourceKey == "COPILOT_API_TOKEN")
-    }
-
-    @Test
-    func copilotTokenFallsBackToGithubToken() {
-        let env = [
-            "GITHUB_TOKEN": "github-token",
-            "GH_TOKEN": "gh-fallback-token",
-        ]
-        let resolution = ProviderTokenResolver.copilotResolution(environment: env)
-        #expect(resolution?.token == "github-token")
-        #expect(resolution?.sourceKey == "GITHUB_TOKEN")
-    }
-
-    @Test
-    func copilotTokenFallsBackToGhToken() {
-        let env = [
-            "GH_TOKEN": "gh-fallback-token",
-            "GITHUB_TOKEN": "",
-        ]
-        let resolution = ProviderTokenResolver.copilotResolution(environment: env)
-        #expect(resolution?.token == "gh-fallback-token")
-        #expect(resolution?.sourceKey == "GH_TOKEN")
-    }
-
-    @Test
-    func copilotTokenFallsBackToGithubCLIToken() throws {
-        let token = "gho_abcdefghijklmnopqrstuvwxyz1234"
-        let tempDir = FileManager.default.temporaryDirectory
-            .appendingPathComponent("runic-copilot-gh-cli-\(UUID().uuidString)", isDirectory: true)
-        try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
-        defer { try? FileManager.default.removeItem(at: tempDir) }
-
-        let hostsFile = tempDir.appendingPathComponent("hosts.yml")
-        let hostsContent = """
-        github.com:
-          oauth_token: \(token)
-        """
-        try hostsContent.write(to: hostsFile, atomically: true, encoding: .utf8)
-
-        let env = [
-            "GH_CONFIG_DIR": tempDir.path,
-            "GH_TOKEN": "",
-        ]
-        let resolution = ProviderTokenResolver.copilotResolution(environment: env)
-        #expect(resolution?.token == token)
-        #expect(resolution?.source == .environment)
-        #expect(resolution?.sourceKey == "gh-cli")
-    }
-
-    @Test
-    func copilotTokenStripsQuotedValues() {
-        let env = [
-            "COPILOT_API_TOKEN": "\"quoted-token\"",
-        ]
-        let token = ProviderTokenResolver.copilotToken(environment: env)
-        #expect(token == "quoted-token")
-    }
-}