@sriinnu/runic 1.2.0 → 2.11.1

package/Sources/RunicCore/Providers/Claude/ClaudeWeb/ClaudeWebAPIFetcher.swift

@@ -1,780 +0,0 @@
-import Foundation
-import Silo
-#if canImport(FoundationNetworking)
-import FoundationNetworking
-#endif
-
-/// Fetches Claude usage data directly from the claude.ai API using browser session cookies.
-///
-/// This approach mirrors what Claude Usage Tracker does, but automatically extracts the session key
-/// from browser cookies instead of requiring manual setup.
-///
-/// API endpoints used:
-/// - `GET https://claude.ai/api/organizations` → get org UUID
-/// - `GET https://claude.ai/api/organizations/{org_id}/usage` → usage percentages + reset times
-public enum ClaudeWebAPIFetcher {
-    private static let baseURL = "https://claude.ai/api"
-    private static let maxProbeBytes = 200_000
-    #if os(macOS)
-    private static let cookieClient = BrowserCookieClient()
-    private static let cookieImportOrder: BrowserCookieImportOrder =
-        ProviderDefaults.metadata[.claude]?.browserCookieOrder ?? Browser.defaultImportOrder
-    #else
-    private static let cookieImportOrder: BrowserCookieImportOrder = []
-    #endif
-
-    public struct OrganizationInfo: Sendable {
-        public let id: String
-        public let name: String?
-
-        public init(id: String, name: String?) {
-            self.id = id
-            self.name = name
-        }
-    }
-
-    public struct SessionKeyInfo: Sendable {
-        public let key: String
-        public let sourceLabel: String
-        public let cookieCount: Int
-
-        public init(key: String, sourceLabel: String, cookieCount: Int) {
-            self.key = key
-            self.sourceLabel = sourceLabel
-            self.cookieCount = cookieCount
-        }
-    }
-
-    public enum FetchError: LocalizedError, Sendable {
-        case noSessionKeyFound
-        case invalidSessionKey
-        case notSupportedOnThisPlatform
-        case networkError(Error)
-        case invalidResponse
-        case unauthorized
-        case serverError(statusCode: Int)
-        case noOrganization
-
-        public var errorDescription: String? {
-            switch self {
-            case .noSessionKeyFound:
-                "No Claude session key found in browser cookies."
-            case .invalidSessionKey:
-                "Invalid Claude session key format."
-            case .notSupportedOnThisPlatform:
-                "Claude web fetching is only supported on macOS."
-            case let .networkError(error):
-                "Network error: \(error.localizedDescription)"
-            case .invalidResponse:
-                "Invalid response from Claude API."
-            case .unauthorized:
-                "Unauthorized. Your Claude session may have expired."
-            case let .serverError(code):
-                "Claude API error: HTTP \(code)"
-            case .noOrganization:
-                "No Claude organization found for this account."
-            }
-        }
-    }
-
-    /// Claude usage data from the API
-    public struct WebUsageData: Sendable {
-        public let sessionPercentUsed: Double
-        public let sessionResetsAt: Date?
-        public let weeklyPercentUsed: Double?
-        public let weeklyResetsAt: Date?
-        public let opusPercentUsed: Double?
-        public let extraUsageCost: ProviderCostSnapshot?
-        public let accountOrganization: String?
-        public let accountEmail: String?
-        public let loginMethod: String?
-
-        public init(
-            sessionPercentUsed: Double,
-            sessionResetsAt: Date?,
-            weeklyPercentUsed: Double?,
-            weeklyResetsAt: Date?,
-            opusPercentUsed: Double?,
-            extraUsageCost: ProviderCostSnapshot?,
-            accountOrganization: String?,
-            accountEmail: String?,
-            loginMethod: String?)
-        {
-            self.sessionPercentUsed = sessionPercentUsed
-            self.sessionResetsAt = sessionResetsAt
-            self.weeklyPercentUsed = weeklyPercentUsed
-            self.weeklyResetsAt = weeklyResetsAt
-            self.opusPercentUsed = opusPercentUsed
-            self.extraUsageCost = extraUsageCost
-            self.accountOrganization = accountOrganization
-            self.accountEmail = accountEmail
-            self.loginMethod = loginMethod
-        }
-    }
-
-    public struct ProbeResult: Sendable {
-        public let url: String
-        public let statusCode: Int?
-        public let contentType: String?
-        public let topLevelKeys: [String]
-        public let emails: [String]
-        public let planHints: [String]
-        public let notableFields: [String]
-        public let bodyPreview: String?
-    }
-
-    // MARK: - Public API
-
-    #if os(macOS)
-
-    /// Attempts to fetch Claude usage data using cookies extracted from browsers.
-    /// Tries browser cookies using the standard import order.
-    public static func fetchUsage(logger: ((String) -> Void)? = nil) async throws -> WebUsageData {
-        let log: (String) -> Void = { msg in logger?("[claude-web] \(msg)") }
-
-        let sessionInfo = try extractSessionKeyInfo(logger: log)
-        log("Found session key: \(sessionInfo.key.prefix(20))...")
-
-        return try await self.fetchUsage(using: sessionInfo, logger: log)
-    }
-
-    public static func fetchUsage(
-        using sessionKeyInfo: SessionKeyInfo,
-        logger: ((String) -> Void)? = nil) async throws -> WebUsageData
-    {
-        let log: (String) -> Void = { msg in logger?(msg) }
-        let sessionKey = sessionKeyInfo.key
-
-        // Fetch organization info
-        let organization = try await fetchOrganizationInfo(sessionKey: sessionKey, logger: log)
-        log("Organization ID: \(organization.id)")
-        if let name = organization.name { log("Organization name: \(name)") }
-
-        var usage = try await fetchUsageData(orgId: organization.id, sessionKey: sessionKey, logger: log)
-        if usage.extraUsageCost == nil,
-           let extra = await fetchExtraUsageCost(orgId: organization.id, sessionKey: sessionKey, logger: log)
-        {
-            usage = WebUsageData(
-                sessionPercentUsed: usage.sessionPercentUsed,
-                sessionResetsAt: usage.sessionResetsAt,
-                weeklyPercentUsed: usage.weeklyPercentUsed,
-                weeklyResetsAt: usage.weeklyResetsAt,
-                opusPercentUsed: usage.opusPercentUsed,
-                extraUsageCost: extra,
-                accountOrganization: usage.accountOrganization,
-                accountEmail: usage.accountEmail,
-                loginMethod: usage.loginMethod)
-        }
-        if let account = await fetchAccountInfo(sessionKey: sessionKey, orgId: organization.id, logger: log) {
-            usage = WebUsageData(
-                sessionPercentUsed: usage.sessionPercentUsed,
-                sessionResetsAt: usage.sessionResetsAt,
-                weeklyPercentUsed: usage.weeklyPercentUsed,
-                weeklyResetsAt: usage.weeklyResetsAt,
-                opusPercentUsed: usage.opusPercentUsed,
-                extraUsageCost: usage.extraUsageCost,
-                accountOrganization: usage.accountOrganization,
-                accountEmail: account.email,
-                loginMethod: account.loginMethod)
-        }
-        if usage.accountOrganization == nil, let name = organization.name {
-            usage = WebUsageData(
-                sessionPercentUsed: usage.sessionPercentUsed,
-                sessionResetsAt: usage.sessionResetsAt,
-                weeklyPercentUsed: usage.weeklyPercentUsed,
-                weeklyResetsAt: usage.weeklyResetsAt,
-                opusPercentUsed: usage.opusPercentUsed,
-                extraUsageCost: usage.extraUsageCost,
-                accountOrganization: name,
-                accountEmail: usage.accountEmail,
-                loginMethod: usage.loginMethod)
-        }
-        return usage
-    }
-
-    /// Probes a list of endpoints using the current claude.ai session cookies.
-    /// - Parameters:
-    ///   - endpoints: Absolute URLs or "/api/..." paths. Supports "{orgId}" placeholder.
-    ///   - includePreview: When true, includes a truncated response preview in results.
-    public static func probeEndpoints(
-        _ endpoints: [String],
-        includePreview: Bool = false,
-        logger: ((String) -> Void)? = nil) async throws -> [ProbeResult]
-    {
-        let log: (String) -> Void = { msg in logger?("[claude-probe] \(msg)") }
-        let sessionInfo = try extractSessionKeyInfo(logger: log)
-        let sessionKey = sessionInfo.key
-        let organization = try? await fetchOrganizationInfo(sessionKey: sessionKey, logger: log)
-        let expanded = endpoints.map { endpoint -> String in
-            var url = endpoint
-            if let orgId = organization?.id {
-                url = url.replacingOccurrences(of: "{orgId}", with: orgId)
-            }
-            if url.hasPrefix("/") {
-                url = "https://claude.ai\(url)"
-            }
-            return url
-        }
-
-        var results: [ProbeResult] = []
-        results.reserveCapacity(expanded.count)
-
-        for endpoint in expanded {
-            guard let url = URL(string: endpoint) else { continue }
-            var request = URLRequest(url: url)
-            request.setValue("sessionKey=\(sessionKey)", forHTTPHeaderField: "Cookie")
-            request.setValue("application/json, text/html;q=0.9, */*;q=0.8", forHTTPHeaderField: "Accept")
-            request.httpMethod = "GET"
-            request.timeoutInterval = 20
-
-            do {
-                let (data, response) = try await URLSession.shared.data(for: request)
-                let http = response as? HTTPURLResponse
-                let contentType = http?.allHeaderFields["Content-Type"] as? String
-                let truncated = data.prefix(Self.maxProbeBytes)
-                let body = String(data: truncated, encoding: .utf8) ?? ""
-
-                let parsed = Self.parseProbeBody(data: data, fallbackText: body, contentType: contentType)
-                let preview = includePreview ? parsed.preview : nil
-
-                results.append(ProbeResult(
-                    url: endpoint,
-                    statusCode: http?.statusCode,
-                    contentType: contentType,
-                    topLevelKeys: parsed.keys,
-                    emails: parsed.emails,
-                    planHints: parsed.planHints,
-                    notableFields: parsed.notableFields,
-                    bodyPreview: preview))
-            } catch {
-                results.append(ProbeResult(
-                    url: endpoint,
-                    statusCode: nil,
-                    contentType: nil,
-                    topLevelKeys: [],
-                    emails: [],
-                    planHints: [],
-                    notableFields: [],
-                    bodyPreview: "Error: \(error.localizedDescription)"))
-            }
-        }
-
-        return results
-    }
-
-    /// Checks if we can find a Claude session key in browser cookies without making API calls.
-    public static func hasSessionKey(logger: ((String) -> Void)? = nil) -> Bool {
-        do {
-            _ = try self.sessionKeyInfo(logger: logger)
-            return true
-        } catch {
-            return false
-        }
-    }
-
-    public static func sessionKeyInfo(logger: ((String) -> Void)? = nil) throws -> SessionKeyInfo {
-        try self.extractSessionKeyInfo(logger: logger)
-    }
-
-    // MARK: - Session Key Extraction
-
-    private static func extractSessionKeyInfo(logger: ((String) -> Void)? = nil) throws -> SessionKeyInfo {
-        let log: (String) -> Void = { msg in logger?(msg) }
-
-        let cookieDomains = ["claude.ai"]
-
-        for browserSource in Self.cookieImportOrder {
-            do {
-                let query = BrowserCookieQuery(domains: cookieDomains)
-                let sources = try Self.cookieClient.records(
-                    matching: query,
-                    in: browserSource)
-                for source in sources {
-                    if let sessionKey = findSessionKey(in: source.records.map { record in
-                        (name: record.name, value: record.value)
-                    }) {
-                        log("Found sessionKey in \(source.label)")
-                        return SessionKeyInfo(
-                            key: sessionKey,
-                            sourceLabel: source.label,
-                            cookieCount: source.records.count)
-                    }
-                }
-            } catch {
-                log("\(browserSource.displayName) cookie load failed: \(error.localizedDescription)")
-            }
-        }
-
-        throw FetchError.noSessionKeyFound
-    }
-
-    private static func findSessionKey(in cookies: [(name: String, value: String)]) -> String? {
-        for cookie in cookies where cookie.name == "sessionKey" {
-            let value = cookie.value.trimmingCharacters(in: .whitespacesAndNewlines)
-            // Validate it looks like a Claude session key
-            if value.hasPrefix("sk-ant-") {
-                return value
-            }
-        }
-        return nil
-    }
-
-    // MARK: - API Calls
-
-    private static func fetchOrganizationInfo(
-        sessionKey: String,
-        logger: ((String) -> Void)? = nil) async throws -> OrganizationInfo
-    {
-        let url = URL(string: "\(baseURL)/organizations")!
-        var request = URLRequest(url: url)
-        request.setValue("sessionKey=\(sessionKey)", forHTTPHeaderField: "Cookie")
-        request.setValue("application/json", forHTTPHeaderField: "Accept")
-        request.httpMethod = "GET"
-        request.timeoutInterval = 15
-
-        let (data, response) = try await URLSession.shared.data(for: request)
-
-        guard let httpResponse = response as? HTTPURLResponse else {
-            throw FetchError.invalidResponse
-        }
-
-        logger?("Organizations API status: \(httpResponse.statusCode)")
-
-        switch httpResponse.statusCode {
-        case 200:
-            return try self.parseOrganizationResponse(data)
-        case 401, 403:
-            throw FetchError.unauthorized
-        default:
-            throw FetchError.serverError(statusCode: httpResponse.statusCode)
-        }
-    }
-
-    private static func fetchUsageData(
-        orgId: String,
-        sessionKey: String,
-        logger: ((String) -> Void)? = nil) async throws -> WebUsageData
-    {
-        let url = URL(string: "\(baseURL)/organizations/\(orgId)/usage")!
-        var request = URLRequest(url: url)
-        request.setValue("sessionKey=\(sessionKey)", forHTTPHeaderField: "Cookie")
-        request.setValue("application/json", forHTTPHeaderField: "Accept")
-        request.httpMethod = "GET"
-        request.timeoutInterval = 15
-
-        let (data, response) = try await URLSession.shared.data(for: request)
-
-        guard let httpResponse = response as? HTTPURLResponse else {
-            throw FetchError.invalidResponse
-        }
-
-        logger?("Usage API status: \(httpResponse.statusCode)")
-
-        switch httpResponse.statusCode {
-        case 200:
-            return try self.parseUsageResponse(data)
-        case 401, 403:
-            throw FetchError.unauthorized
-        default:
-            throw FetchError.serverError(statusCode: httpResponse.statusCode)
-        }
-    }
-
-    private static func parseUsageResponse(_ data: Data) throws -> WebUsageData {
-        guard let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
-            throw FetchError.invalidResponse
-        }
-
-        // Parse five_hour (session) usage
-        var sessionPercent: Double?
-        var sessionResets: Date?
-        if let fiveHour = json["five_hour"] as? [String: Any] {
-            if let utilization = fiveHour["utilization"] as? Int {
-                sessionPercent = Double(utilization)
-            }
-            if let resetsAt = fiveHour["resets_at"] as? String {
-                sessionResets = self.parseISO8601Date(resetsAt)
-            }
-        }
-        guard let sessionPercent else {
-            // If we can't parse session utilization, treat this as a failure so callers can fall back to the CLI.
-            throw FetchError.invalidResponse
-        }
-
-        // Parse seven_day (weekly) usage
-        var weeklyPercent: Double?
-        var weeklyResets: Date?
-        if let sevenDay = json["seven_day"] as? [String: Any] {
-            if let utilization = sevenDay["utilization"] as? Int {
-                weeklyPercent = Double(utilization)
-            }
-            if let resetsAt = sevenDay["resets_at"] as? String {
-                weeklyResets = self.parseISO8601Date(resetsAt)
-            }
-        }
-
-        // Parse seven_day_opus (Opus-specific weekly) usage
-        var opusPercent: Double?
-        if let sevenDayOpus = json["seven_day_opus"] as? [String: Any] {
-            if let utilization = sevenDayOpus["utilization"] as? Int {
-                opusPercent = Double(utilization)
-            }
-        }
-
-        return WebUsageData(
-            sessionPercentUsed: sessionPercent,
-            sessionResetsAt: sessionResets,
-            weeklyPercentUsed: weeklyPercent,
-            weeklyResetsAt: weeklyResets,
-            opusPercentUsed: opusPercent,
-            extraUsageCost: nil,
-            accountOrganization: nil,
-            accountEmail: nil,
-            loginMethod: nil)
-    }
-
-    // MARK: - Extra usage cost (Claude "Extra")
-
-    private struct OverageSpendLimitResponse: Decodable {
-        let monthlyCreditLimit: Double?
-        let currency: String?
-        let usedCredits: Double?
-        let isEnabled: Bool?
-
-        enum CodingKeys: String, CodingKey {
-            case monthlyCreditLimit = "monthly_credit_limit"
-            case currency
-            case usedCredits = "used_credits"
-            case isEnabled = "is_enabled"
-        }
-    }
-
-    /// Best-effort fetch of Claude Extra spend/limit (does not fail the main usage fetch).
-    private static func fetchExtraUsageCost(
-        orgId: String,
-        sessionKey: String,
-        logger: ((String) -> Void)? = nil) async -> ProviderCostSnapshot?
-    {
-        let url = URL(string: "\(baseURL)/organizations/\(orgId)/overage_spend_limit")!
-        var request = URLRequest(url: url)
-        request.setValue("sessionKey=\(sessionKey)", forHTTPHeaderField: "Cookie")
-        request.setValue("application/json", forHTTPHeaderField: "Accept")
-        request.httpMethod = "GET"
-        request.timeoutInterval = 15
-
-        do {
-            let (data, response) = try await URLSession.shared.data(for: request)
-            guard let httpResponse = response as? HTTPURLResponse else { return nil }
-            logger?("Overage API status: \(httpResponse.statusCode)")
-            guard httpResponse.statusCode == 200 else { return nil }
-            return Self.parseOverageSpendLimit(data)
-        } catch {
-            return nil
-        }
-    }
-
-    private static func parseOverageSpendLimit(_ data: Data) -> ProviderCostSnapshot? {
-        guard let decoded = try? JSONDecoder().decode(OverageSpendLimitResponse.self, from: data) else { return nil }
-        guard decoded.isEnabled == true else { return nil }
-        guard let used = decoded.usedCredits,
-              let limit = decoded.monthlyCreditLimit,
-              let currency = decoded.currency,
-              !currency.isEmpty else { return nil }
-
-        let usedAmount = used / 100.0
-        let limitAmount = limit / 100.0
-
-        return ProviderCostSnapshot(
-            used: usedAmount,
-            limit: limitAmount,
-            currencyCode: currency,
-            period: "Monthly",
-            resetsAt: nil,
-            updatedAt: Date())
-    }
-
-    #if DEBUG
-
-    // MARK: - Test hooks (DEBUG-only)
-
-    public static func _parseUsageResponseForTesting(_ data: Data) throws -> WebUsageData {
-        try self.parseUsageResponse(data)
-    }
-
-    public static func _parseOrganizationsResponseForTesting(_ data: Data) throws -> OrganizationInfo {
-        try self.parseOrganizationResponse(data)
-    }
-
-    public static func _parseOverageSpendLimitForTesting(_ data: Data) -> ProviderCostSnapshot? {
-        self.parseOverageSpendLimit(data)
-    }
-
-    public static func _parseAccountInfoForTesting(_ data: Data, orgId: String?) -> WebAccountInfo? {
-        self.parseAccountInfo(data, orgId: orgId)
-    }
-    #endif
-
-    private static func parseISO8601Date(_ string: String) -> Date? {
-        let formatter = ISO8601DateFormatter()
-        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
-        if let date = formatter.date(from: string) {
-            return date
-        }
-        // Try without fractional seconds
-        formatter.formatOptions = [.withInternetDateTime]
-        return formatter.date(from: string)
-    }
-
-    private struct OrganizationResponse: Decodable {
-        let uuid: String
-        let name: String?
-    }
-
-    private static func parseOrganizationResponse(_ data: Data) throws -> OrganizationInfo {
-        guard let organizations = try? JSONDecoder().decode([OrganizationResponse].self, from: data) else {
-            throw FetchError.invalidResponse
-        }
-        guard let first = organizations.first else { throw FetchError.noOrganization }
-        let name = first.name?.trimmingCharacters(in: .whitespacesAndNewlines)
-        let sanitized = (name?.isEmpty ?? true) ? nil : name
-        return OrganizationInfo(id: first.uuid, name: sanitized)
-    }
-
-    public struct WebAccountInfo: Sendable {
-        public let email: String?
-        public let loginMethod: String?
-
-        public init(email: String?, loginMethod: String?) {
-            self.email = email
-            self.loginMethod = loginMethod
-        }
-    }
-
-    private struct AccountResponse: Decodable {
-        let emailAddress: String?
-        let memberships: [Membership]?
-
-        enum CodingKeys: String, CodingKey {
-            case emailAddress = "email_address"
-            case memberships
-        }
-
-        struct Membership: Decodable {
-            let organization: Organization
-
-            struct Organization: Decodable {
-                let uuid: String?
-                let name: String?
-                let rateLimitTier: String?
-                let billingType: String?
-
-                enum CodingKeys: String, CodingKey {
-                    case uuid
-                    case name
-                    case rateLimitTier = "rate_limit_tier"
-                    case billingType = "billing_type"
-                }
-            }
-        }
-    }
-
-    private static func fetchAccountInfo(
-        sessionKey: String,
-        orgId: String?,
-        logger: ((String) -> Void)? = nil) async -> WebAccountInfo?
-    {
-        let url = URL(string: "\(baseURL)/account")!
-        var request = URLRequest(url: url)
-        request.setValue("sessionKey=\(sessionKey)", forHTTPHeaderField: "Cookie")
-        request.setValue("application/json", forHTTPHeaderField: "Accept")
-        request.httpMethod = "GET"
-        request.timeoutInterval = 15
-
-        do {
-            let (data, response) = try await URLSession.shared.data(for: request)
-            guard let httpResponse = response as? HTTPURLResponse else { return nil }
-            logger?("Account API status: \(httpResponse.statusCode)")
-            guard httpResponse.statusCode == 200 else { return nil }
-            return Self.parseAccountInfo(data, orgId: orgId)
-        } catch {
-            return nil
-        }
-    }
-
-    private static func parseAccountInfo(_ data: Data, orgId: String?) -> WebAccountInfo? {
-        guard let response = try? JSONDecoder().decode(AccountResponse.self, from: data) else { return nil }
-        let email = response.emailAddress?.trimmingCharacters(in: .whitespacesAndNewlines)
-        let membership = Self.selectMembership(response.memberships, orgId: orgId)
-        let plan = Self.inferPlan(
-            rateLimitTier: membership?.organization.rateLimitTier,
-            billingType: membership?.organization.billingType)
-        return WebAccountInfo(email: email, loginMethod: plan)
-    }
-
-    private static func selectMembership(
-        _ memberships: [AccountResponse.Membership]?,
-        orgId: String?) -> AccountResponse.Membership?
-    {
-        guard let memberships, !memberships.isEmpty else { return nil }
-        if let orgId {
-            if let match = memberships.first(where: { $0.organization.uuid == orgId }) { return match }
-        }
-        return memberships.first
-    }
-
-    private static func inferPlan(rateLimitTier: String?, billingType: String?) -> String? {
-        let tier = rateLimitTier?.lowercased() ?? ""
-        let billing = billingType?.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" }
-        if billing.contains("stripe"), tier.contains("claude") { return "Claude Pro" }
-        return nil
-    }
-
-    private struct ProbeParseResult: Sendable {
-        let keys: [String]
-        let emails: [String]
-        let planHints: [String]
-        let notableFields: [String]
-        let preview: String?
-    }
-
-    private static func parseProbeBody(
-        data: Data,
-        fallbackText: String,
-        contentType: String?) -> ProbeParseResult
-    {
-        let trimmed = fallbackText.trimmingCharacters(in: .whitespacesAndNewlines)
-        let looksJSON = (contentType?.lowercased().contains("application/json") ?? false) ||
-            trimmed.hasPrefix("{") || trimmed.hasPrefix("[")
-
-        var keys: [String] = []
-        var notableFields: [String] = []
-        if looksJSON, let json = try? JSONSerialization.jsonObject(with: data) {
-            if let dict = json as? [String: Any] {
-                keys = dict.keys.sorted()
-            } else if let array = json as? [[String: Any]], let first = array.first {
-                keys = first.keys.sorted()
-            }
-            notableFields = Self.extractNotableFields(from: json)
-        }
-
-        let emails = Self.extractEmails(from: trimmed)
-        let planHints = Self.extractPlanHints(from: trimmed)
-        let preview = trimmed.isEmpty ? nil : String(trimmed.prefix(500))
-        return ProbeParseResult(
-            keys: keys,
-            emails: emails,
-            planHints: planHints,
-            notableFields: notableFields,
-            preview: preview)
-    }
-
-    private static func extractEmails(from text: String) -> [String] {
-        let pattern = #"(?i)[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}"#
-        guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else { return [] }
-        let range = NSRange(text.startIndex..<text.endIndex, in: text)
-        var results: [String] = []
-        regex.enumerateMatches(in: text, options: [], range: range) { match, _, _ in
-            guard let match, let r = Range(match.range(at: 0), in: text) else { return }
-            let value = String(text[r]).trimmingCharacters(in: .whitespacesAndNewlines)
-            if !value.isEmpty { results.append(value) }
-        }
-        return Array(Set(results)).sorted()
-    }
-
-    private static func extractPlanHints(from text: String) -> [String] {
-        let pattern = #"(?i)\b(max|pro|team|ultra|enterprise)\b"#
-        guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else { return [] }
-        let range = NSRange(text.startIndex..<text.endIndex, in: text)
-        var results: [String] = []
-        regex.enumerateMatches(in: text, options: [], range: range) { match, _, _ in
-            guard let match, let r = Range(match.range(at: 1), in: text) else { return }
-            let value = String(text[r]).trimmingCharacters(in: .whitespacesAndNewlines)
-            if !value.isEmpty { results.append(value) }
-        }
-        return Array(Set(results)).sorted()
-    }
-
-    private static func extractNotableFields(from json: Any) -> [String] {
-        let pattern = #"(?i)(plan|tier|subscription|seat|billing|product)"#
-        guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else { return [] }
-        var results: [String] = []
-
-        func keyMatches(_ key: String) -> Bool {
-            let range = NSRange(key.startIndex..<key.endIndex, in: key)
-            return regex.firstMatch(in: key, options: [], range: range) != nil
-        }
-
-        func appendValue(_ keyPath: String, value: Any) {
-            if results.count >= 40 { return }
-            let rendered: String
-            switch value {
-            case let str as String:
-                rendered = str
-            case let num as NSNumber:
-                rendered = num.stringValue
-            case let bool as Bool:
-                rendered = bool ? "true" : "false"
-            default:
-                return
-            }
-            let trimmed = rendered.trimmingCharacters(in: .whitespacesAndNewlines)
-            guard !trimmed.isEmpty else { return }
-            results.append("\(keyPath)=\(trimmed)")
-        }
-
-        func walk(_ value: Any, path: String) {
-            if let dict = value as? [String: Any] {
-                for (key, nested) in dict {
-                    let nextPath = path.isEmpty ? key : "\(path).\(key)"
-                    if keyMatches(key) {
-                        appendValue(nextPath, value: nested)
-                    }
-                    walk(nested, path: nextPath)
-                }
-            } else if let array = value as? [Any] {
-                for (idx, nested) in array.enumerated() {
-                    let nextPath = "\(path)[\(idx)]"
-                    walk(nested, path: nextPath)
-                }
-            }
-        }
-
-        walk(json, path: "")
-        return results
-    }
-
-    #else
-
-    public static func fetchUsage(logger: ((String) -> Void)? = nil) async throws -> WebUsageData {
-        throw FetchError.notSupportedOnThisPlatform
-    }
-
-    public static func fetchUsage(
-        using sessionKeyInfo: SessionKeyInfo,
-        logger: ((String) -> Void)? = nil) async throws -> WebUsageData
-    {
-        throw FetchError.notSupportedOnThisPlatform
-    }
-
-    public static func probeEndpoints(
-        _ endpoints: [String],
-        includePreview: Bool = false,
-        logger: ((String) -> Void)? = nil) async throws -> [ProbeResult]
-    {
-        throw FetchError.notSupportedOnThisPlatform
-    }
-
-    public static func hasSessionKey(logger: ((String) -> Void)? = nil) -> Bool {
-        false
-    }
-
-    public static func sessionKeyInfo(logger: ((String) -> Void)? = nil) throws -> SessionKeyInfo {
-        throw FetchError.notSupportedOnThisPlatform
-    }
-
-    #endif
-}