@sriinnu/runic 1.0.0

package/Sources/RunicCore/Providers/Claude/ClaudeUsageFetcher.swift

@@ -0,0 +1,480 @@
+import Foundation
+
+public protocol ClaudeUsageFetching: Sendable {
+    func loadLatestUsage(model: String) async throws -> ClaudeUsageSnapshot
+    func debugRawProbe(model: String) async -> String
+    func detectVersion() -> String?
+}
+
+public struct ClaudeUsageSnapshot: Sendable {
+    public let primary: RateWindow
+    public let secondary: RateWindow?
+    public let opus: RateWindow?
+    public let providerCost: ProviderCostSnapshot?
+    public let updatedAt: Date
+    public let accountEmail: String?
+    public let accountOrganization: String?
+    public let loginMethod: String?
+    public let rawText: String?
+
+    public init(
+        primary: RateWindow,
+        secondary: RateWindow?,
+        opus: RateWindow?,
+        providerCost: ProviderCostSnapshot? = nil,
+        updatedAt: Date,
+        accountEmail: String?,
+        accountOrganization: String?,
+        loginMethod: String?,
+        rawText: String?)
+    {
+        self.primary = primary
+        self.secondary = secondary
+        self.opus = opus
+        self.providerCost = providerCost
+        self.updatedAt = updatedAt
+        self.accountEmail = accountEmail
+        self.accountOrganization = accountOrganization
+        self.loginMethod = loginMethod
+        self.rawText = rawText
+    }
+}
+
+public enum ClaudeUsageError: LocalizedError, Sendable {
+    case claudeNotInstalled
+    case parseFailed(String)
+    case oauthFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .claudeNotInstalled:
+            "Claude CLI is not installed. Install it from https://docs.claude.ai/claude-code."
+        case let .parseFailed(details):
+            "Could not parse Claude usage: \(details)"
+        case let .oauthFailed(details):
+            details
+        }
+    }
+}
+
+public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
+    private let environment: [String: String]
+    private let dataSource: ClaudeUsageDataSource
+    private let useWebExtras: Bool
+    private static let log = RunicLog.logger("claude-usage")
+
+    /// Creates a new ClaudeUsageFetcher.
+    /// - Parameters:
+    ///   - environment: Process environment (default: current process environment)
+    ///   - dataSource: Usage data source (default: OAuth API).
+    ///   - useWebExtras: If true, attempts to enrich usage with Claude web data (cookies).
+    public init(
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        dataSource: ClaudeUsageDataSource = .oauth,
+        useWebExtras: Bool = false)
+    {
+        self.environment = environment
+        self.dataSource = dataSource
+        self.useWebExtras = useWebExtras
+    }
+
+    // MARK: - Parsing helpers
+
+    public static func parse(json: Data) -> ClaudeUsageSnapshot? {
+        guard let output = String(data: json, encoding: .utf8) else { return nil }
+        return try? Self.parse(output: output)
+    }
+
+    private static func parse(output: String) throws -> ClaudeUsageSnapshot {
+        guard
+            let data = output.data(using: .utf8),
+            let obj = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+            throw ClaudeUsageError.parseFailed(output.prefix(500).description)
+        }
+
+        if let ok = obj["ok"] as? Bool, !ok {
+            let hint = obj["hint"] as? String ?? (obj["pane_preview"] as? String ?? "")
+            throw ClaudeUsageError.parseFailed(hint)
+        }
+
+        func firstWindowDict(_ keys: [String]) -> [String: Any]? {
+            for key in keys {
+                if let dict = obj[key] as? [String: Any] { return dict }
+            }
+            return nil
+        }
+
+        func makeWindow(_ dict: [String: Any]?) -> RateWindow? {
+            guard let dict else { return nil }
+            let pct = (dict["pct_used"] as? NSNumber)?.doubleValue ?? 0
+            let resetText = dict["resets"] as? String
+            return RateWindow(
+                usedPercent: pct,
+                windowMinutes: nil,
+                resetsAt: Self.parseReset(text: resetText),
+                resetDescription: resetText)
+        }
+
+        guard let session = makeWindow(firstWindowDict(["session_5h"])) else {
+            throw ClaudeUsageError.parseFailed("missing session data")
+        }
+        let weekAll = makeWindow(firstWindowDict(["week_all_models", "week_all"]))
+
+        let rawEmail = (obj["account_email"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let email = (rawEmail?.isEmpty ?? true) ? nil : rawEmail
+        let rawOrg = (obj["account_org"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let org = (rawOrg?.isEmpty ?? true) ? nil : rawOrg
+        let loginMethod = (obj["login_method"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let opusWindow: RateWindow? = {
+            let candidates = firstWindowDict([
+                "week_sonnet",
+                "week_sonnet_only",
+                "week_opus",
+            ])
+            guard let opus = candidates else { return nil }
+            let pct = (opus["pct_used"] as? NSNumber)?.doubleValue ?? 0
+            let resets = opus["resets"] as? String
+            return RateWindow(
+                usedPercent: pct,
+                windowMinutes: nil,
+                resetsAt: Self.parseReset(text: resets),
+                resetDescription: resets)
+        }()
+        return ClaudeUsageSnapshot(
+            primary: session,
+            secondary: weekAll,
+            opus: opusWindow,
+            providerCost: nil,
+            updatedAt: Date(),
+            accountEmail: email,
+            accountOrganization: org,
+            loginMethod: loginMethod,
+            rawText: output)
+    }
+
+    private static func parseReset(text: String?) -> Date? {
+        guard let text, !text.isEmpty else { return nil }
+        let parts = text.split(separator: "(")
+        let timePart = parts.first?.trimmingCharacters(in: .whitespaces)
+        let tzPart = parts.count > 1
+            ? parts[1].replacingOccurrences(of: ")", with: "").trimmingCharacters(in: .whitespaces)
+            : nil
+        let tz = tzPart.flatMap(TimeZone.init(identifier:))
+        let formats = ["ha", "h:mma", "MMM d 'at' ha", "MMM d 'at' h:mma"]
+        for format in formats {
+            let df = DateFormatter()
+            df.locale = Locale(identifier: "en_US_POSIX")
+            df.timeZone = tz ?? TimeZone.current
+            df.dateFormat = format
+            if let t = timePart, let date = df.date(from: t) { return date }
+        }
+        return nil
+    }
+
+    // MARK: - Public API
+
+    public func detectVersion() -> String? {
+        // Avoid leaking terminal control sequences (some `claude` builds write to /dev/tty even when stdout is piped).
+        guard TTYCommandRunner.which("claude") != nil else { return nil }
+        do {
+            let out = try TTYCommandRunner().run(
+                binary: "claude",
+                send: "",
+                options: TTYCommandRunner.Options(
+                    timeout: 5.0,
+                    extraArgs: ["--allowed-tools", "", "--version"],
+                    initialDelay: 0.0)).text
+            return TextParsing.stripANSICodes(out).trimmingCharacters(in: .whitespacesAndNewlines)
+        } catch {
+            return nil
+        }
+    }
+
+    public func debugRawProbe(model: String = "sonnet") async -> String {
+        do {
+            let snap = try await self.loadViaPTY(model: model, timeout: 10)
+            let opus = snap.opus?.remainingPercent ?? -1
+            let email = snap.accountEmail ?? "nil"
+            let org = snap.accountOrganization ?? "nil"
+            let weekly = snap.secondary?.remainingPercent ?? -1
+            return """
+            session_left=\(snap.primary.remainingPercent) weekly_left=\(weekly)
+            opus_left=\(opus) email \(email) org \(org)
+            \(snap)
+            """
+        } catch {
+            return "Probe failed: \(error)"
+        }
+    }
+
+    public func loadLatestUsage(model: String = "sonnet") async throws -> ClaudeUsageSnapshot {
+        switch self.dataSource {
+        case .oauth:
+            var snap = try await self.loadViaOAuth()
+            snap = await self.applyWebExtrasIfNeeded(to: snap)
+            return snap
+        case .web:
+            return try await self.loadViaWebAPI()
+        case .cli:
+            do {
+                var snap = try await self.loadViaPTY(model: model, timeout: 10)
+                snap = await self.applyWebExtrasIfNeeded(to: snap)
+                return snap
+            } catch {
+                var snap = try await self.loadViaPTY(model: model, timeout: 24)
+                snap = await self.applyWebExtrasIfNeeded(to: snap)
+                return snap
+            }
+        }
+    }
+
+    // MARK: - OAuth API path
+
+    private func loadViaOAuth() async throws -> ClaudeUsageSnapshot {
+        do {
+            let creds = try ClaudeOAuthCredentialsStore.load()
+            if creds.isExpired {
+                throw ClaudeUsageError.oauthFailed("Claude OAuth token expired. Run `claude` to refresh.")
+            }
+            // The usage endpoint requires user:profile scope.
+            if !creds.scopes.contains("user:profile") {
+                throw ClaudeUsageError.oauthFailed(
+                    "Claude OAuth token missing 'user:profile' scope (has: \(creds.scopes.joined(separator: ", "))). "
+                        + "Rate limit data unavailable.")
+            }
+            let usage = try await ClaudeOAuthUsageFetcher.fetchUsage(accessToken: creds.accessToken)
+            return try Self.mapOAuthUsage(usage, credentials: creds)
+        } catch let error as ClaudeUsageError {
+            throw error
+        } catch let error as ClaudeOAuthCredentialsError {
+            throw ClaudeUsageError.oauthFailed(error.localizedDescription)
+        } catch let error as ClaudeOAuthFetchError {
+            throw ClaudeUsageError.oauthFailed(error.localizedDescription)
+        } catch {
+            throw ClaudeUsageError.oauthFailed(error.localizedDescription)
+        }
+    }
+
+    private static func mapOAuthUsage(
+        _ usage: OAuthUsageResponse,
+        credentials: ClaudeOAuthCredentials) throws -> ClaudeUsageSnapshot
+    {
+        func makeWindow(_ window: OAuthUsageWindow?, windowMinutes: Int?) -> RateWindow? {
+            guard let window,
+                  let utilization = window.utilization
+            else { return nil }
+            let resetDate = ClaudeOAuthUsageFetcher.parseISO8601Date(window.resetsAt)
+            let resetDescription = resetDate.map(Self.formatResetDate)
+            return RateWindow(
+                usedPercent: utilization,
+                windowMinutes: windowMinutes,
+                resetsAt: resetDate,
+                resetDescription: resetDescription)
+        }
+
+        guard let primary = makeWindow(usage.fiveHour, windowMinutes: 5 * 60) else {
+            throw ClaudeUsageError.parseFailed("missing session data")
+        }
+
+        let weekly = makeWindow(usage.sevenDay, windowMinutes: 7 * 24 * 60)
+        let modelSpecific = makeWindow(
+            usage.sevenDaySonnet ?? usage.sevenDayOpus,
+            windowMinutes: 7 * 24 * 60)
+
+        return ClaudeUsageSnapshot(
+            primary: primary,
+            secondary: weekly,
+            opus: modelSpecific,
+            providerCost: Self.oauthExtraUsageCost(usage.extraUsage),
+            updatedAt: Date(),
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: Self.inferPlan(rateLimitTier: credentials.rateLimitTier),
+            rawText: nil)
+    }
+
+    private static func oauthExtraUsageCost(_ extra: OAuthExtraUsage?) -> ProviderCostSnapshot? {
+        guard let extra, extra.isEnabled == true else { return nil }
+        guard let used = extra.usedCredits,
+              let limit = extra.monthlyLimit else { return nil }
+        let currency = extra.currency?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let code = (currency?.isEmpty ?? true) ? "USD" : currency!
+        return ProviderCostSnapshot(
+            used: used,
+            limit: limit,
+            currencyCode: code,
+            period: "Monthly",
+            resetsAt: nil,
+            updatedAt: Date())
+    }
+
+    private static func inferPlan(rateLimitTier: String?) -> String? {
+        let tier = rateLimitTier?.lowercased() ?? ""
+        if tier.contains("max") { return "Claude Max" }
+        if tier.contains("pro") { return "Claude Pro" }
+        if tier.contains("team") { return "Claude Team" }
+        if tier.contains("enterprise") { return "Claude Enterprise" }
+        return nil
+    }
+
+    // MARK: - Web API path (uses browser cookies)
+
+    private func loadViaWebAPI() async throws -> ClaudeUsageSnapshot {
+        let webData = try await ClaudeWebAPIFetcher.fetchUsage { msg in
+            Self.log.debug(msg)
+        }
+        // Convert web API data to ClaudeUsageSnapshot format
+        let primary = RateWindow(
+            usedPercent: webData.sessionPercentUsed,
+            windowMinutes: 5 * 60,
+            resetsAt: webData.sessionResetsAt,
+            resetDescription: webData.sessionResetsAt.map { Self.formatResetDate($0) })
+
+        let secondary: RateWindow? = webData.weeklyPercentUsed.map { pct in
+            RateWindow(
+                usedPercent: pct,
+                windowMinutes: 7 * 24 * 60,
+                resetsAt: webData.weeklyResetsAt,
+                resetDescription: webData.weeklyResetsAt.map { Self.formatResetDate($0) })
+        }
+
+        let opus: RateWindow? = webData.opusPercentUsed.map { opusPct in
+            RateWindow(
+                usedPercent: opusPct,
+                windowMinutes: 7 * 24 * 60,
+                resetsAt: webData.weeklyResetsAt,
+                resetDescription: webData.weeklyResetsAt.map { Self.formatResetDate($0) })
+        }
+
+        return ClaudeUsageSnapshot(
+            primary: primary,
+            secondary: secondary,
+            opus: opus,
+            providerCost: webData.extraUsageCost,
+            updatedAt: Date(),
+            accountEmail: webData.accountEmail,
+            accountOrganization: webData.accountOrganization,
+            loginMethod: webData.loginMethod,
+            rawText: nil)
+    }
+
+    private static func formatResetDate(_ date: Date) -> String {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "MMM d 'at' h:mma"
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        return formatter.string(from: date)
+    }
+
+    // MARK: - PTY-based probe (no tmux)
+
+    private func loadViaPTY(model: String, timeout: TimeInterval = 10) async throws -> ClaudeUsageSnapshot {
+        guard TTYCommandRunner.which("claude") != nil else { throw ClaudeUsageError.claudeNotInstalled }
+        let probe = ClaudeStatusProbe(claudeBinary: "claude", timeout: timeout)
+        let snap = try await probe.fetch()
+
+        guard let sessionPctLeft = snap.sessionPercentLeft else {
+            throw ClaudeUsageError.parseFailed("missing session data")
+        }
+
+        func makeWindow(pctLeft: Int?, reset: String?) -> RateWindow? {
+            guard let left = pctLeft else { return nil }
+            let used = max(0, min(100, 100 - Double(left)))
+            let resetClean = reset?.trimmingCharacters(in: .whitespacesAndNewlines)
+            return RateWindow(
+                usedPercent: used,
+                windowMinutes: nil,
+                resetsAt: ClaudeStatusProbe.parseResetDate(from: resetClean),
+                resetDescription: resetClean)
+        }
+
+        let primary = makeWindow(pctLeft: sessionPctLeft, reset: snap.primaryResetDescription)!
+        let weekly = makeWindow(pctLeft: snap.weeklyPercentLeft, reset: snap.secondaryResetDescription)
+        let opus = makeWindow(pctLeft: snap.opusPercentLeft, reset: snap.opusResetDescription)
+
+        return ClaudeUsageSnapshot(
+            primary: primary,
+            secondary: weekly,
+            opus: opus,
+            providerCost: nil,
+            updatedAt: Date(),
+            accountEmail: snap.accountEmail,
+            accountOrganization: snap.accountOrganization,
+            loginMethod: snap.loginMethod,
+            rawText: snap.rawText)
+    }
+
+    private func applyWebExtrasIfNeeded(to snapshot: ClaudeUsageSnapshot) async -> ClaudeUsageSnapshot {
+        guard self.useWebExtras, self.dataSource != .web else { return snapshot }
+        do {
+            let webData = try await ClaudeWebAPIFetcher.fetchUsage { msg in
+                Self.log.debug(msg)
+            }
+            // Only merge cost extras; keep identity fields from the primary data source.
+            if snapshot.providerCost == nil, let extra = webData.extraUsageCost {
+                return ClaudeUsageSnapshot(
+                    primary: snapshot.primary,
+                    secondary: snapshot.secondary,
+                    opus: snapshot.opus,
+                    providerCost: extra,
+                    updatedAt: snapshot.updatedAt,
+                    accountEmail: snapshot.accountEmail,
+                    accountOrganization: snapshot.accountOrganization,
+                    loginMethod: snapshot.loginMethod,
+                    rawText: snapshot.rawText)
+            }
+        } catch {
+            Self.log.debug("Claude web extras fetch failed: \(error.localizedDescription)")
+        }
+        return snapshot
+    }
+
+    // MARK: - Process helpers
+
+    private static func which(_ tool: String) -> String? {
+        let process = Process()
+        process.executableURL = URL(fileURLWithPath: "/usr/bin/which")
+        process.arguments = [tool]
+        let pipe = Pipe()
+        process.standardOutput = pipe
+        try? process.run()
+        process.waitUntilExit()
+        guard process.terminationStatus == 0 else { return nil }
+        let data = pipe.fileHandleForReading.readDataToEndOfFile()
+        guard let path = String(data: data, encoding: .utf8)?
+            .trimmingCharacters(in: .whitespacesAndNewlines),
+            !path.isEmpty else { return nil }
+        return path
+    }
+
+    private static func readString(cmd: String, args: [String]) -> String? {
+        let task = Process()
+        task.executableURL = URL(fileURLWithPath: cmd)
+        task.arguments = args
+        let pipe = Pipe()
+        task.standardOutput = pipe
+        try? task.run()
+        task.waitUntilExit()
+        guard task.terminationStatus == 0 else { return nil }
+        let data = pipe.fileHandleForReading.readDataToEndOfFile()
+        return String(data: data, encoding: .utf8)
+    }
+}
+
+#if DEBUG
+extension ClaudeUsageFetcher {
+    public static func _mapOAuthUsageForTesting(
+        _ data: Data,
+        rateLimitTier: String? = nil) throws -> ClaudeUsageSnapshot
+    {
+        let usage = try ClaudeOAuthUsageFetcher.decodeUsageResponse(data)
+        let creds = ClaudeOAuthCredentials(
+            accessToken: "test",
+            refreshToken: nil,
+            expiresAt: Date().addingTimeInterval(3600),
+            scopes: [],
+            rateLimitTier: rateLimitTier)
+        return try Self.mapOAuthUsage(usage, credentials: creds)
+    }
+}
+#endif