@sriinnu/runic 1.0.0

package/Tests/RunicTests/ClaudeUsageTests.swift

@@ -0,0 +1,370 @@
+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

@@ -0,0 +1,122 @@
+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

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,75 @@
+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")
+    }
+}