@sriinnu/runic 1.2.0 → 2.11.1

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

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