@sriinnu/runic 1.0.0

package/Sources/RunicCore/Providers/DeepSeek/DeepSeekProviderDescriptor.swift

@@ -0,0 +1,85 @@
+import RunicMacroSupport
+import Foundation
+
+@ProviderDescriptorRegistration
+@ProviderDescriptorDefinition
+public enum DeepSeekProviderDescriptor {
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .deepseek,
+            metadata: ProviderMetadata(
+                id: .deepseek,
+                displayName: "DeepSeek",
+                sessionLabel: "Balance",
+                weeklyLabel: "",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: true,
+                creditsHint: "Shows remaining balance from DeepSeek API",
+                toggleTitle: "Show DeepSeek usage",
+                cliName: "deepseek",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                dashboardURL: "https://platform.deepseek.com/usage",
+                statusPageURL: nil,
+                usageCoverage: ProviderUsageCoverage(
+                    supportsModelBreakdown: false,
+                    supportsTokenMetrics: false,
+                    supportsProjectAttribution: false)),
+            branding: ProviderBranding(
+                iconStyle: .deepseek,
+                iconResourceName: "ProviderIcon-deepseek",
+                color: ProviderColor(red: 76 / 255, green: 110 / 255, blue: 245 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "DeepSeek cost summary is not supported." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .cli],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [DeepSeekAPIFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "deepseek",
+                aliases: ["ds"],
+                versionDetector: nil))
+    }
+}
+
+struct DeepSeekAPIFetchStrategy: ProviderFetchStrategy {
+    let id: String = "deepseek.api"
+    let kind: ProviderFetchKind = .apiToken
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        Self.resolveTokenResolution(environment: context.env) != nil
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        guard let tokenRes = Self.resolveTokenResolution(environment: context.env) else {
+            throw DeepSeekSettingsError.missingToken
+        }
+        let usage = try await DeepSeekUsageFetcher.fetchBalance(apiKey: tokenRes.token)
+        return self.makeResult(
+            usage: usage.toUsageSnapshot(),
+            credits: usage.toCreditsSnapshot(),
+            sourceLabel: tokenRes.source.rawValue)
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+
+    private static func resolveTokenResolution(environment: [String: String]) -> ProviderTokenResolution? {
+        ProviderTokenResolver.deepSeekResolution(environment: environment)
+    }
+}
+
+enum DeepSeekSettingsError: LocalizedError, Sendable {
+    case missingToken
+
+    var errorDescription: String? {
+        switch self {
+        case .missingToken:
+            "DeepSeek API key not found. Set it in Preferences → Providers → DeepSeek or " +
+                "export DEEPSEEK_API_KEY."
+        }
+    }
+}

package/Sources/RunicCore/Providers/DeepSeek/DeepSeekUsageFetcher.swift

@@ -0,0 +1,108 @@
+import Foundation
+
+struct DeepSeekBalanceResponse: Decodable {
+    let is_available: Bool?
+    let balance_infos: [BalanceInfo]?
+
+    struct BalanceInfo: Decodable {
+        let currency: String?
+        let total_balance: String?
+        let granted_balance: String?
+        let topped_up_balance: String?
+
+        var totalBalanceValue: Double? {
+            Self.parse(self.total_balance) ??
+                Self.parse(self.topped_up_balance) ??
+                Self.parse(self.granted_balance)
+        }
+
+        private static func parse(_ raw: String?) -> Double? {
+            guard let raw = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !raw.isEmpty else {
+                return nil
+            }
+            return Double(raw)
+        }
+    }
+}
+
+struct DeepSeekUsageFetcher {
+    static let apiURL = URL(string: "https://api.deepseek.com/user/balance")!
+
+    static func fetchBalance(apiKey: String) async throws -> DeepSeekBalanceResponse {
+        var request = URLRequest(url: apiURL)
+        request.addValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+        request.addValue("application/json", forHTTPHeaderField: "Content-Type")
+
+        let (data, response) = try await URLSession.shared.data(for: request)
+
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw DeepSeekAPIError.invalidResponse
+        }
+
+        guard httpResponse.statusCode == 200 else {
+            let body = String(data: data, encoding: .utf8)?
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            throw DeepSeekAPIError.httpError(
+                statusCode: httpResponse.statusCode,
+                body: body?.isEmpty == false ? body : nil)
+        }
+
+        let decoder = JSONDecoder()
+        return try decoder.decode(DeepSeekBalanceResponse.self, from: data)
+    }
+}
+
+extension DeepSeekBalanceResponse {
+    private var preferredBalanceInfo: BalanceInfo? {
+        guard let infos = self.balance_infos, !infos.isEmpty else { return nil }
+        if let funded = infos.first(where: { ($0.totalBalanceValue ?? 0) > 0 }) {
+            return funded
+        }
+        return infos.first
+    }
+
+    private var remainingBalance: Double {
+        self.preferredBalanceInfo?.totalBalanceValue ?? 0
+    }
+
+    private var currencyCode: String {
+        self.preferredBalanceInfo?.currency?.uppercased() ?? "USD"
+    }
+
+    func toUsageSnapshot() -> UsageSnapshot {
+        UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 0,
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: "Balance: \(String(format: "%.2f", self.remainingBalance)) \(self.currencyCode)"),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: Date(),
+            identity: nil)
+    }
+
+    func toCreditsSnapshot() -> CreditsSnapshot {
+        CreditsSnapshot(
+            remaining: self.remainingBalance,
+            events: [],
+            updatedAt: Date())
+    }
+}
+
+enum DeepSeekAPIError: LocalizedError, Sendable {
+    case invalidResponse
+    case httpError(statusCode: Int, body: String?)
+
+    var errorDescription: String? {
+        switch self {
+        case .invalidResponse:
+            return "Invalid response from DeepSeek API"
+        case let .httpError(statusCode, body):
+            if let body, !body.isEmpty {
+                return "DeepSeek API returned status code \(statusCode): \(body)"
+            }
+            return "DeepSeek API returned status code \(statusCode)"
+        }
+    }
+}

package/Sources/RunicCore/Providers/Factory/FactoryLocalStorageImporter.swift

@@ -0,0 +1,398 @@
+import Foundation
+#if os(macOS)
+import SQLite3
+#endif
+
+#if os(macOS)
+enum FactoryLocalStorageImporter {
+    struct TokenInfo: Sendable {
+        let refreshToken: String
+        let accessToken: String?
+        let organizationID: String?
+        let sourceLabel: String
+    }
+
+    static func importWorkOSTokens(logger: ((String) -> Void)? = nil) -> [TokenInfo] {
+        let log: (String) -> Void = { msg in logger?("[factory-storage] \(msg)") }
+        var tokens: [TokenInfo] = []
+
+        let safariCandidates = self.safariLocalStorageCandidates()
+        let chromeCandidates = self.chromeLocalStorageCandidates()
+        if !safariCandidates.isEmpty {
+            log("Safari local storage candidates: \(safariCandidates.count)")
+        }
+        if !chromeCandidates.isEmpty {
+            log("Chrome local storage candidates: \(chromeCandidates.count)")
+        }
+
+        let candidates = safariCandidates + chromeCandidates
+        for candidate in candidates {
+            let match: WorkOSTokenMatch? = switch candidate.kind {
+            case let .chromeLevelDB(levelDBURL):
+                self.readWorkOSToken(from: levelDBURL)
+            case let .safariSQLite(dbURL):
+                self.readWorkOSTokenFromSafariSQLite(dbURL: dbURL, logger: log)
+            }
+            guard let token = match else { continue }
+            log("Found WorkOS refresh token in \(candidate.label)")
+            tokens.append(TokenInfo(
+                refreshToken: token.refreshToken,
+                accessToken: token.accessToken,
+                organizationID: token.organizationID,
+                sourceLabel: candidate.label))
+        }
+
+        if tokens.isEmpty {
+            log("No WorkOS refresh token found in browser local storage")
+        }
+
+        return tokens
+    }
+
+    static func hasSafariWorkOSRefreshToken() -> Bool {
+        for candidate in self.safariLocalStorageCandidates() {
+            guard case let .safariSQLite(dbURL) = candidate.kind else { continue }
+            if self.readWorkOSTokenFromSafariSQLite(dbURL: dbURL) != nil {
+                return true
+            }
+        }
+        return false
+    }
+
+    // MARK: - Chrome local storage discovery
+
+    private enum LocalStorageSourceKind: Sendable {
+        case chromeLevelDB(URL)
+        case safariSQLite(URL)
+    }
+
+    private struct LocalStorageCandidate: Sendable {
+        let label: String
+        let kind: LocalStorageSourceKind
+    }
+
+    private static func chromeLocalStorageCandidates() -> [LocalStorageCandidate] {
+        let roots: [(url: URL, labelPrefix: String)] = self.candidateHomes().flatMap { home in
+            let appSupport = home
+                .appendingPathComponent("Library")
+                .appendingPathComponent("Application Support")
+            return [
+                (appSupport.appendingPathComponent("Google").appendingPathComponent("Chrome"), "Chrome"),
+                (appSupport.appendingPathComponent("Google").appendingPathComponent("Chrome Beta"), "Chrome Beta"),
+                (appSupport.appendingPathComponent("Google").appendingPathComponent("Chrome Canary"), "Chrome Canary"),
+                (appSupport.appendingPathComponent("Arc").appendingPathComponent("User Data"), "Arc"),
+                (appSupport.appendingPathComponent("Arc Beta").appendingPathComponent("User Data"), "Arc Beta"),
+                (appSupport.appendingPathComponent("Arc Canary").appendingPathComponent("User Data"), "Arc Canary"),
+                (
+                    appSupport
+                        .appendingPathComponent("com.openai.atlas")
+                        .appendingPathComponent("browser-data")
+                        .appendingPathComponent("host"),
+                    "ChatGPT Atlas"),
+                (appSupport.appendingPathComponent("Chromium"), "Chromium"),
+            ]
+        }
+
+        var candidates: [LocalStorageCandidate] = []
+        for root in roots {
+            candidates.append(contentsOf: self.chromeProfileLocalStorageDirs(
+                root: root.url,
+                labelPrefix: root.labelPrefix))
+        }
+        return candidates
+    }
+
+    private static func chromeProfileLocalStorageDirs(root: URL, labelPrefix: String) -> [LocalStorageCandidate] {
+        guard let entries = try? FileManager.default.contentsOfDirectory(
+            at: root,
+            includingPropertiesForKeys: [.isDirectoryKey],
+            options: [.skipsHiddenFiles])
+        else { return [] }
+
+        let profileDirs = entries.filter { url in
+            guard let isDir = (try? url.resourceValues(forKeys: [.isDirectoryKey]).isDirectory), isDir else {
+                return false
+            }
+            let name = url.lastPathComponent
+            return name == "Default" || name.hasPrefix("Profile ") || name.hasPrefix("user-")
+        }
+        .sorted { $0.lastPathComponent < $1.lastPathComponent }
+
+        return profileDirs.compactMap { dir in
+            let levelDBURL = dir.appendingPathComponent("Local Storage").appendingPathComponent("leveldb")
+            guard FileManager.default.fileExists(atPath: levelDBURL.path) else { return nil }
+            let label = "\(labelPrefix) \(dir.lastPathComponent)"
+            return LocalStorageCandidate(label: label, kind: .chromeLevelDB(levelDBURL))
+        }
+    }
+
+    private static func safariLocalStorageCandidates() -> [LocalStorageCandidate] {
+        let root = FileManager.default.homeDirectoryForCurrentUser
+            .appendingPathComponent("Library")
+            .appendingPathComponent("Containers")
+            .appendingPathComponent("com.apple.Safari")
+            .appendingPathComponent("Data")
+            .appendingPathComponent("Library")
+            .appendingPathComponent("WebKit")
+            .appendingPathComponent("WebsiteData")
+            .appendingPathComponent("Default")
+
+        guard FileManager.default.fileExists(atPath: root.path) else { return [] }
+
+        let targets = ["app.factory.ai", "auth.factory.ai"]
+        var candidates: [LocalStorageCandidate] = []
+
+        guard let enumerator = FileManager.default.enumerator(
+            at: root,
+            includingPropertiesForKeys: [.isRegularFileKey],
+            options: [.skipsHiddenFiles])
+        else { return [] }
+
+        for case let fileURL as URL in enumerator {
+            guard fileURL.lastPathComponent == "origin" else { continue }
+            guard (try? fileURL.resourceValues(forKeys: [.isRegularFileKey]).isRegularFile) == true else {
+                continue
+            }
+            guard let data = try? Data(contentsOf: fileURL, options: [.mappedIfSafe]) else { continue }
+            let ascii = String(data: data, encoding: .utf8) ?? String(data: data, encoding: .isoLatin1) ?? ""
+            guard targets.contains(where: { ascii.contains($0) }) else { continue }
+
+            let storageURL = fileURL.deletingLastPathComponent()
+                .appendingPathComponent("LocalStorage")
+                .appendingPathComponent("localstorage.sqlite3")
+            guard FileManager.default.fileExists(atPath: storageURL.path) else { continue }
+            let host = self.extractSafariOriginHost(from: ascii) ?? "app.factory.ai"
+            candidates.append(LocalStorageCandidate(label: "Safari (\(host))", kind: .safariSQLite(storageURL)))
+        }
+
+        var seen = Set<String>()
+        return candidates.filter { candidate in
+            let key: String = switch candidate.kind {
+            case let .chromeLevelDB(url):
+                url.path
+            case let .safariSQLite(url):
+                url.path
+            }
+            if seen.contains(key) { return false }
+            seen.insert(key)
+            return true
+        }
+    }
+
+    private static func extractSafariOriginHost(from ascii: String) -> String? {
+        let targets = ["app.factory.ai", "auth.factory.ai", "factory.ai"]
+        for host in targets where ascii.contains(host) {
+            return host
+        }
+        return nil
+    }
+
+    private static func candidateHomes() -> [URL] {
+        var homes: [URL] = []
+        homes.append(FileManager.default.homeDirectoryForCurrentUser)
+        if let userHome = NSHomeDirectoryForUser(NSUserName()) {
+            homes.append(URL(fileURLWithPath: userHome))
+        }
+        if let envHome = ProcessInfo.processInfo.environment["HOME"], !envHome.isEmpty {
+            homes.append(URL(fileURLWithPath: envHome))
+        }
+        var seen = Set<String>()
+        return homes.filter { home in
+            let path = home.path
+            guard !seen.contains(path) else { return false }
+            seen.insert(path)
+            return true
+        }
+    }
+
+    // MARK: - Token extraction
+
+    private struct WorkOSTokenMatch: Sendable {
+        let refreshToken: String
+        let accessToken: String?
+        let organizationID: String?
+    }
+
+    private static func readWorkOSToken(from levelDBURL: URL) -> WorkOSTokenMatch? {
+        guard let entries = try? FileManager.default.contentsOfDirectory(
+            at: levelDBURL,
+            includingPropertiesForKeys: [.contentModificationDateKey],
+            options: [.skipsHiddenFiles])
+        else { return nil }
+
+        let files = entries.filter { url in
+            let ext = url.pathExtension.lowercased()
+            return ext == "ldb" || ext == "log"
+        }
+        .sorted { lhs, rhs in
+            let left = (try? lhs.resourceValues(forKeys: [.contentModificationDateKey]).contentModificationDate)
+            let right = (try? rhs.resourceValues(forKeys: [.contentModificationDateKey]).contentModificationDate)
+            return (left ?? .distantPast) > (right ?? .distantPast)
+        }
+
+        for file in files {
+            guard let data = try? Data(contentsOf: file, options: [.mappedIfSafe]) else { continue }
+            if let match = self.extractWorkOSToken(from: data) {
+                return match
+            }
+        }
+        return nil
+    }
+
+    private static func extractWorkOSToken(from data: Data) -> WorkOSTokenMatch? {
+        guard let contents = String(data: data, encoding: .utf8) ??
+            String(data: data, encoding: .isoLatin1)
+        else { return nil }
+        guard contents.contains("workos:refresh-token") else { return nil }
+
+        let refreshToken = self.matchToken(
+            in: contents,
+            pattern: "workos:refresh-token[^A-Za-z0-9_-]*([A-Za-z0-9_-]{20,})")
+        guard let refreshToken else { return nil }
+
+        let accessToken = self.matchToken(
+            in: contents,
+            pattern: "workos:access-token[^A-Za-z0-9_-]*([A-Za-z0-9_-]{20,})")
+
+        let organizationID = self.extractOrganizationID(from: accessToken)
+        return WorkOSTokenMatch(
+            refreshToken: refreshToken,
+            accessToken: accessToken,
+            organizationID: organizationID)
+    }
+
+    private static func readWorkOSTokenFromSafariSQLite(
+        dbURL: URL,
+        logger: ((String) -> Void)? = nil) -> WorkOSTokenMatch?
+    {
+        var db: OpaquePointer?
+        guard sqlite3_open_v2(dbURL.path, &db, SQLITE_OPEN_READONLY, nil) == SQLITE_OK else {
+            if let c = sqlite3_errmsg(db) {
+                logger?("Safari local storage open failed: \(String(cString: c))")
+            }
+            return nil
+        }
+        defer { sqlite3_close(db) }
+
+        sqlite3_busy_timeout(db, 250)
+        let tables = self.fetchTableNames(db: db, logger: logger)
+        if tables.isEmpty {
+            logger?("Safari local storage table lookup returned no tables")
+        }
+        let table = tables
+            .contains("ItemTable") ? "ItemTable" : (tables.contains("localstorage") ? "localstorage" : nil)
+        guard let table else {
+            logger?("Safari local storage missing ItemTable/localstorage tables (found: \(tables.sorted()))")
+            return nil
+        }
+
+        let refreshToken = self.fetchLocalStorageValue(db: db, table: table, key: "workos:refresh-token")
+        guard let refreshToken, !refreshToken.isEmpty else {
+            logger?("Safari local storage missing workos:refresh-token")
+            return nil
+        }
+        let accessToken = self.fetchLocalStorageValue(db: db, table: table, key: "workos:access-token")
+
+        let organizationID = self.extractOrganizationID(from: accessToken)
+        return WorkOSTokenMatch(
+            refreshToken: refreshToken,
+            accessToken: accessToken,
+            organizationID: organizationID)
+    }
+
+    private static func extractOrganizationID(from accessToken: String?) -> String? {
+        guard let accessToken, accessToken.contains(".") else { return nil }
+        let parts = accessToken.split(separator: ".")
+        guard parts.count == 3 else { return nil }
+        let payload = String(parts[1])
+            .replacingOccurrences(of: "-", with: "+")
+            .replacingOccurrences(of: "_", with: "/")
+        let padded = payload + String(repeating: "=", count: (4 - payload.count % 4) % 4)
+        guard let data = Data(base64Encoded: padded),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+            return nil
+        }
+        return json["org_id"] as? String
+    }
+
+    private static func fetchTableNames(db: OpaquePointer?, logger: ((String) -> Void)? = nil) -> Set<String> {
+        let sql = "SELECT name FROM sqlite_master WHERE type='table'"
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else {
+            if let c = sqlite3_errmsg(db) {
+                logger?("Safari local storage table query failed: \(String(cString: c))")
+            }
+            return []
+        }
+        defer { sqlite3_finalize(stmt) }
+        var names = Set<String>()
+        while true {
+            let step = sqlite3_step(stmt)
+            if step == SQLITE_ROW {
+                if let c = sqlite3_column_text(stmt, 0) {
+                    names.insert(String(cString: c))
+                }
+            } else {
+                if step != SQLITE_DONE, let c = sqlite3_errmsg(db) {
+                    logger?("Safari local storage table query failed: \(String(cString: c))")
+                }
+                break
+            }
+        }
+        return names
+    }
+
+    private static func fetchLocalStorageValue(db: OpaquePointer?, table: String, key: String) -> String? {
+        let sql = "SELECT value FROM \(table) WHERE key = ? LIMIT 1"
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else { return nil }
+        defer { sqlite3_finalize(stmt) }
+        let transient = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
+        _ = key.withCString { cString in
+            sqlite3_bind_text(stmt, 1, cString, -1, transient)
+        }
+        guard sqlite3_step(stmt) == SQLITE_ROW else { return nil }
+        return self.decodeSQLiteValue(stmt: stmt, index: 0)
+    }
+
+    private static func decodeSQLiteValue(stmt: OpaquePointer?, index: Int32) -> String? {
+        let type = sqlite3_column_type(stmt, index)
+        switch type {
+        case SQLITE_TEXT:
+            guard let c = sqlite3_column_text(stmt, index) else { return nil }
+            return String(cString: c)
+        case SQLITE_BLOB:
+            guard let bytes = sqlite3_column_blob(stmt, index) else { return nil }
+            let count = Int(sqlite3_column_bytes(stmt, index))
+            let data = Data(bytes: bytes, count: count)
+            return self.decodeValueData(data)
+        default:
+            return nil
+        }
+    }
+
+    private static func decodeValueData(_ data: Data) -> String? {
+        if let decoded = String(data: data, encoding: .utf16LittleEndian) {
+            return decoded.trimmingCharacters(in: .controlCharacters)
+        }
+        if let decoded = String(data: data, encoding: .utf8) {
+            return decoded.trimmingCharacters(in: .controlCharacters)
+        }
+        if let decoded = String(data: data, encoding: .isoLatin1) {
+            return decoded.trimmingCharacters(in: .controlCharacters)
+        }
+        return nil
+    }
+
+    private static func matchToken(in contents: String, pattern: String) -> String? {
+        guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else { return nil }
+        let range = NSRange(contents.startIndex..<contents.endIndex, in: contents)
+        guard let match = regex.matches(in: contents, options: [], range: range).last else { return nil }
+        guard match.numberOfRanges > 1,
+              let tokenRange = Range(match.range(at: 1), in: contents)
+        else { return nil }
+        return String(contents[tokenRange])
+    }
+}
+#endif

package/Sources/RunicCore/Providers/Factory/FactoryProviderDescriptor.swift

@@ -0,0 +1,65 @@
+import RunicMacroSupport
+import Foundation
+
+@ProviderDescriptorRegistration
+@ProviderDescriptorDefinition
+public enum FactoryProviderDescriptor {
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .factory,
+            metadata: ProviderMetadata(
+                id: .factory,
+                displayName: "Droid",
+                sessionLabel: "Standard",
+                weeklyLabel: "Premium",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show Droid usage",
+                cliName: "factory",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: ProviderBrowserCookieDefaults.defaultImportOrder,
+                dashboardURL: "https://app.factory.ai/settings/billing",
+                statusPageURL: "https://status.factory.ai",
+                statusLinkURL: nil,
+                usageCoverage: ProviderUsageCoverage(
+                    supportsModelBreakdown: false,
+                    supportsTokenMetrics: false,
+                    supportsProjectAttribution: false)),
+            branding: ProviderBranding(
+                iconStyle: .factory,
+                iconResourceName: "ProviderIcon-factory",
+                color: ProviderColor(red: 255 / 255, green: 107 / 255, blue: 53 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Droid cost summary is not supported." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .cli],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [FactoryStatusFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "factory",
+                versionDetector: nil))
+    }
+}
+
+struct FactoryStatusFetchStrategy: ProviderFetchStrategy {
+    let id: String = "factory.web"
+    let kind: ProviderFetchKind = .web
+
+    func isAvailable(_: ProviderFetchContext) async -> Bool { true }
+
+    func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let probe = FactoryStatusProbe()
+        let snap = try await probe.fetch()
+        return self.makeResult(
+            usage: snap.toUsageSnapshot(),
+            sourceLabel: "web")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}