@sriinnu/runic 1.0.0

package/Sources/RunicCore/Providers/Cohere/CohereUsageFetcher.swift

@@ -0,0 +1,85 @@
+import Foundation
+
+struct CohereModelsResponse: Decodable {
+    let models: [Model]?
+    let data: [Model]?
+
+    struct Model: Decodable {
+        let id: String?
+        let name: String?
+
+        var modelID: String? {
+            let candidate = id ?? name
+            guard let candidate else { return nil }
+            let trimmed = candidate.trimmingCharacters(in: .whitespacesAndNewlines)
+            return trimmed.isEmpty ? nil : trimmed
+        }
+    }
+}
+
+struct CohereUsageFetcher {
+    static let apiURL = URL(string: "https://api.cohere.ai/v1/models")!
+
+    static func fetchModels(apiKey: String) async throws -> CohereModelsResponse {
+        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 CohereAPIError.invalidResponse
+        }
+
+        guard httpResponse.statusCode == 200 else {
+            let body = String(data: data, encoding: .utf8)?
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            throw CohereAPIError.httpError(
+                statusCode: httpResponse.statusCode,
+                body: body?.isEmpty == false ? body : nil)
+        }
+
+        let decoder = JSONDecoder()
+        return try decoder.decode(CohereModelsResponse.self, from: data)
+    }
+}
+
+extension CohereModelsResponse {
+    func toUsageSnapshot() -> UsageSnapshot {
+        let records = (self.models ?? []) + (self.data ?? [])
+        let models = records.compactMap(\.modelID)
+        var summary = "Models available: \(models.count)"
+        let preview = models.prefix(3).joined(separator: ", ")
+        if !preview.isEmpty {
+            summary += " (\(preview))"
+        }
+
+        return UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 0,
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: summary),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: Date(),
+            identity: nil)
+    }
+}
+
+enum CohereAPIError: LocalizedError, Sendable {
+    case invalidResponse
+    case httpError(statusCode: Int, body: String?)
+
+    var errorDescription: String? {
+        switch self {
+        case .invalidResponse:
+            return "Invalid response from Cohere API"
+        case let .httpError(statusCode, body):
+            if let body, !body.isEmpty {
+                return "Cohere API returned status code \(statusCode): \(body)"
+            }
+            return "Cohere API returned status code \(statusCode)"
+        }
+    }
+}

package/Sources/RunicCore/Providers/Copilot/CopilotDeviceFlow.swift

@@ -0,0 +1,123 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public struct CopilotDeviceFlow: Sendable {
+    private let clientID = "Iv1.b507a08c87ecfe98" // VS Code Client ID
+    private let scopes = "read:user"
+
+    public struct DeviceCodeResponse: Decodable, Sendable {
+        public let deviceCode: String
+        public let userCode: String
+        public let verificationUri: String
+        public let verificationUriComplete: String?
+        public let expiresIn: Int
+        public let interval: Int
+
+        enum CodingKeys: String, CodingKey {
+            case deviceCode = "device_code"
+            case userCode = "user_code"
+            case verificationUri = "verification_uri"
+            case verificationUriComplete = "verification_uri_complete"
+            case expiresIn = "expires_in"
+            case interval
+        }
+    }
+
+    public struct AccessTokenResponse: Decodable, Sendable {
+        public let accessToken: String
+        public let tokenType: String
+        public let scope: String
+
+        enum CodingKeys: String, CodingKey {
+            case accessToken = "access_token"
+            case tokenType = "token_type"
+            case scope
+        }
+    }
+
+    public init() {}
+
+    public func requestDeviceCode() async throws -> DeviceCodeResponse {
+        let components = URLComponents(string: "https://github.com/login/device/code")!
+        let request = URLRequest(url: components.url!)
+
+        var postRequest = request
+        postRequest.httpMethod = "POST"
+        postRequest.setValue("application/json", forHTTPHeaderField: "Accept")
+        postRequest.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+
+        let body = [
+            "client_id": self.clientID,
+            "scope": self.scopes,
+        ]
+        postRequest.httpBody = Self.formURLEncodedBody(body)
+
+        let (data, response) = try await URLSession.shared.data(for: postRequest)
+
+        guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
+            throw URLError(.badServerResponse)
+        }
+
+        return try JSONDecoder().decode(DeviceCodeResponse.self, from: data)
+    }
+
+    public func pollForToken(deviceCode: String, interval: Int) async throws -> String {
+        let url = URL(string: "https://github.com/login/oauth/access_token")!
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+
+        let body = [
+            "client_id": self.clientID,
+            "device_code": deviceCode,
+            "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+        ]
+        request.httpBody = Self.formURLEncodedBody(body)
+
+        while true {
+            try await Task.sleep(nanoseconds: UInt64(interval) * 1_000_000_000)
+            try Task.checkCancellation()
+
+            let (data, _) = try await URLSession.shared.data(for: request)
+
+            // Check for error in JSON
+            if let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+               let error = json["error"] as? String
+            {
+                if error == "authorization_pending" {
+                    continue
+                }
+                if error == "slow_down" {
+                    try await Task.sleep(nanoseconds: 5_000_000_000) // Add 5s
+                    continue
+                }
+                if error == "expired_token" {
+                    throw URLError(.timedOut)
+                }
+                throw URLError(.userAuthenticationRequired) // Generic failure
+            }
+
+            if let tokenResponse = try? JSONDecoder().decode(AccessTokenResponse.self, from: data) {
+                return tokenResponse.accessToken
+            }
+        }
+    }
+
+    private static func formURLEncodedBody(_ parameters: [String: String]) -> Data {
+        let pairs = parameters
+            .map { key, value in
+                "\(Self.formEncode(key))=\(Self.formEncode(value))"
+            }
+            .joined(separator: "&")
+        return Data(pairs.utf8)
+    }
+
+    private static func formEncode(_ value: String) -> String {
+        var allowed = CharacterSet.urlQueryAllowed
+        allowed.remove(charactersIn: "+&=")
+        return value.addingPercentEncoding(withAllowedCharacters: allowed) ?? value
+    }
+}

package/Sources/RunicCore/Providers/Copilot/CopilotGitHubCLITokenReader.swift

@@ -0,0 +1,114 @@
+import Foundation
+
+public enum CopilotGitHubCLITokenReader {
+    private static let tokenPrefixes = [
+        "gho_",
+        "ghp_",
+        "ghu_",
+        "ghs_",
+        "ghr_",
+        "github_pat_",
+        "v1.",
+    ]
+
+    public static func token(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        for path in self.candidateHostConfigPaths(environment: environment) {
+            guard let raw = try? String(contentsOf: path, encoding: .utf8) else { continue }
+            if let token = self.token(fromHostsYAML: raw) {
+                return token
+            }
+        }
+        return nil
+    }
+
+    public static func token(fromHostsYAML yamlText: String) -> String? {
+        var insideGithubHost = false
+
+        for rawLine in yamlText.components(separatedBy: .newlines) {
+            let line = rawLine
+            let trimmedLine = line.trimmingCharacters(in: .whitespacesAndNewlines)
+            if trimmedLine.isEmpty || trimmedLine.hasPrefix("#") {
+                continue
+            }
+
+            let firstCharacter = line.first
+            let hasIndent = firstCharacter?.isWhitespace == true
+            if !hasIndent {
+                insideGithubHost = self.isGithubHostLine(trimmedLine)
+                continue
+            }
+
+            guard insideGithubHost else { continue }
+            if let token = self.extractOAuthToken(from: trimmedLine) {
+                return token
+            }
+        }
+        return nil
+    }
+
+    private static func isGithubHostLine(_ line: String) -> Bool {
+        guard line.hasSuffix(":") else { return false }
+        let host = String(line.dropLast()).trimmingCharacters(in: .whitespacesAndNewlines)
+        return host == "github.com"
+    }
+
+    private static func extractOAuthToken(from trimmedLine: String) -> String? {
+        guard let separator = trimmedLine.firstIndex(of: ":") else { return nil }
+        let key = trimmedLine[..<separator].trimmingCharacters(in: .whitespacesAndNewlines)
+        guard key == "oauth_token" else { return nil }
+
+        let value = String(trimmedLine[trimmedLine.index(after: separator)...])
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .trimmingCharacters(in: CharacterSet(charactersIn: "'\""))
+
+        guard self.isLikelyGitHubToken(value) else { return nil }
+        return value
+    }
+
+    private static func isLikelyGitHubToken(_ token: String) -> Bool {
+        guard !token.isEmpty else { return false }
+        return tokenPrefixes.contains { token.hasPrefix($0) }
+    }
+
+    private static func candidateHostConfigPaths(environment: [String: String]) -> [URL] {
+        var candidates: [URL] = []
+        var seen: Set<String> = []
+
+        func addCandidate(_ url: URL) {
+            let normalized = url.standardizedFileURL.path
+            if seen.insert(normalized).inserted {
+                candidates.append(url)
+            }
+        }
+
+        if let ghConfigDir = self.trimmed(environment["GH_CONFIG_DIR"]) {
+            let resolvedGHConfig = URL(fileURLWithPath: ghConfigDir)
+            if resolvedGHConfig.pathExtension == "yml" || resolvedGHConfig.lastPathComponent == "hosts.yml" {
+                addCandidate(resolvedGHConfig)
+            } else {
+                addCandidate(resolvedGHConfig.appendingPathComponent("hosts.yml"))
+            }
+        }
+
+        var homes = [FileManager.default.homeDirectoryForCurrentUser.path]
+        if let home = self.trimmed(environment["HOME"]), home != FileManager.default.homeDirectoryForCurrentUser.path {
+            homes.append(home)
+        }
+
+        for home in homes {
+            let homeURL = URL(fileURLWithPath: home)
+            addCandidate(homeURL.appendingPathComponent(".config").appendingPathComponent("gh").appendingPathComponent("hosts.yml"))
+            addCandidate(homeURL.appendingPathComponent("Library").appendingPathComponent("Application Support").appendingPathComponent("gh").appendingPathComponent("hosts.yml"))
+            addCandidate(homeURL.appendingPathComponent(".local").appendingPathComponent("share").appendingPathComponent("gh").appendingPathComponent("hosts.yml"))
+        }
+
+        return candidates
+    }
+
+    private static func trimmed(_ value: String?) -> String? {
+        guard let value else { return nil }
+        let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return nil }
+        return trimmed
+    }
+}

package/Sources/RunicCore/Providers/Copilot/CopilotProviderDescriptor.swift

@@ -0,0 +1,100 @@
+import RunicMacroSupport
+import Foundation
+
+@ProviderDescriptorRegistration
+@ProviderDescriptorDefinition
+public enum CopilotProviderDescriptor {
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .copilot,
+            metadata: ProviderMetadata(
+                id: .copilot,
+                displayName: "Copilot",
+                sessionLabel: "Premium",
+                weeklyLabel: "Chat",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show Copilot usage",
+                cliName: "copilot",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                dashboardURL: "https://github.com/settings/copilot",
+                statusPageURL: "https://www.githubstatus.com/",
+                usageCoverage: ProviderUsageCoverage(
+                    supportsModelBreakdown: false,
+                    supportsTokenMetrics: false,
+                    supportsProjectAttribution: false)),
+            branding: ProviderBranding(
+                iconStyle: .copilot,
+                iconResourceName: "ProviderIcon-copilot",
+                color: ProviderColor(red: 168 / 255, green: 85 / 255, blue: 247 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Copilot cost summary is not supported." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .cli],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [CopilotAPIFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "copilot",
+                versionDetector: nil))
+    }
+}
+
+struct CopilotAPIFetchStrategy: ProviderFetchStrategy {
+    let id: String = "copilot.api"
+    let kind: ProviderFetchKind = .apiToken
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        true
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        guard let selection = Self.resolveToken(context: context), !selection.token.isEmpty else {
+            throw CopilotUsageFetchError.missingCredentials(details: Self.missingTokenGuidance())
+        }
+        let fetcher = CopilotUsageFetcher(token: selection.token, tokenSourceLabel: selection.sourceLabel)
+        let snap = try await fetcher.fetch()
+        return self.makeResult(
+            usage: snap,
+            sourceLabel: "api(\(selection.sourceLabel))")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+
+    private struct CopilotTokenSelection {
+        let token: String
+        let sourceLabel: String
+    }
+
+    private static func resolveToken(context: ProviderFetchContext) -> CopilotTokenSelection? {
+        if let token = context.settings?.copilot?.apiToken?.trimmingCharacters(in: .whitespacesAndNewlines),
+           !token.isEmpty
+        {
+            return CopilotTokenSelection(token: token, sourceLabel: "settings")
+        }
+        guard let resolution = ProviderTokenResolver.copilotResolution(environment: context.env) else { return nil }
+        let sourceLabel = self.sourceLabel(from: resolution.source, sourceKey: resolution.sourceKey)
+        return CopilotTokenSelection(token: resolution.token, sourceLabel: sourceLabel)
+    }
+
+    private static func sourceLabel(from source: ProviderTokenSource, sourceKey: String?) -> String {
+        switch source {
+        case .keychain:
+            return sourceKey ?? "keychain"
+        case .environment:
+            return sourceKey ?? "env"
+        case .vscode:
+            return sourceKey ?? "vscode"
+        }
+    }
+
+    private static func missingTokenGuidance() -> String {
+        "Add one of COPILOT_API_TOKEN/GITHUB_TOKEN/GH_TOKEN, configure GitHub CLI token storage (`~/.config/gh/hosts.yml`), " +
+            "or sign in / re-import from VS Code in Runic settings."
+    }
+}