@sriinnu/runic 1.0.0

package/Sources/RunicCore/Providers/ProviderTokenResolver.swift

@@ -0,0 +1,501 @@
+import Foundation
+#if canImport(Security)
+import Security
+#endif
+#if canImport(LocalAuthentication)
+import LocalAuthentication
+#endif
+
+public enum ProviderTokenSource: String, Sendable {
+    case keychain
+    case environment
+    case vscode
+}
+
+public struct ProviderTokenResolution: Sendable {
+    public let token: String
+    public let source: ProviderTokenSource
+    public let sourceKey: String?
+
+    public init(token: String, source: ProviderTokenSource, sourceKey: String? = nil) {
+        self.token = token
+        self.source = source
+        self.sourceKey = sourceKey
+    }
+}
+
+public enum ProviderTokenResolver {
+    private static let log = RunicLog.logger("provider-token")
+
+    private static let keychainService = "com.sriinnu.athena.Runic"
+    private static let zaiAccount = "zai-api-token"
+    private static let copilotAccount = "copilot-api-token"
+    private static let minimaxAccount = "minimax-api-token"
+    private static let minimaxCookieAccount = "minimax-cookie-header"
+    private static let minimaxGroupAccount = "minimax-group-id"
+    private static let openRouterAccount = "openrouter-api-token"
+    private static let groqAccount = "groq-api-token"
+    private static let deepSeekAccount = "deepseek-api-token"
+    private static let fireworksAccount = "fireworks-api-token"
+    private static let mistralAccount = "mistral-api-token"
+    private static let perplexityAccount = "perplexity-api-token"
+    private static let kimiAccount = "kimi-api-token"
+    private static let auggieAccount = "auggie-api-token"
+    private static let togetherAccount = "together-api-token"
+    private static let cohereAccount = "cohere-api-token"
+    private static let xaiAccount = "xai-api-token"
+    private static let cerebrasAccount = "cerebras-api-token"
+    private static let sambanovaAccount = "sambanova-api-token"
+    private static let azureOpenAIAccount = "azure-openai-api-token"
+    private static let qwenAccount = "qwen-api-token"
+
+    public static func zaiToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.zaiResolution(environment: environment)?.token
+    }
+
+    public static func copilotToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.copilotResolution(environment: environment)?.token
+    }
+
+    public static func copilotCLIToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        CopilotGitHubCLITokenReader.token(environment: environment)
+    }
+
+    public static func minimaxToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.minimaxResolution(environment: environment)?.token
+    }
+
+    public static func minimaxCookieHeader(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.minimaxCookieHeaderResolution(environment: environment)?.token
+    }
+
+    public static func minimaxGroupID(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.minimaxGroupResolution(environment: environment)?.token
+    }
+
+    public static func openRouterToken(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.openRouterResolution(environment: environment)?.token
+    }
+
+    public static func groqToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.groqResolution(environment: environment)?.token
+    }
+
+    public static func deepSeekToken(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.deepSeekResolution(environment: environment)?.token
+    }
+
+    public static func fireworksToken(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.fireworksResolution(environment: environment)?.token
+    }
+
+    public static func mistralToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.mistralResolution(environment: environment)?.token
+    }
+
+    public static func perplexityToken(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.perplexityResolution(environment: environment)?.token
+    }
+
+    public static func kimiToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.kimiResolution(environment: environment)?.token
+    }
+
+    public static func auggieToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.auggieResolution(environment: environment)?.token
+    }
+
+    public static func togetherToken(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.togetherResolution(environment: environment)?.token
+    }
+
+    public static func cohereToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.cohereResolution(environment: environment)?.token
+    }
+
+    public static func xaiToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.xaiResolution(environment: environment)?.token
+    }
+
+    public static func cerebrasToken(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.cerebrasResolution(environment: environment)?.token
+    }
+
+    public static func sambaNovaToken(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.sambaNovaResolution(environment: environment)?.token
+    }
+
+    public static func azureOpenAIToken(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.azureOpenAIResolution(environment: environment)?.token
+    }
+
+    public static func qwenToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.qwenResolution(environment: environment)?.token
+    }
+
+    public static func zaiResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        if let token = self.keychainToken(service: self.keychainService, account: self.zaiAccount) {
+            return ProviderTokenResolution(token: token, source: .keychain)
+        }
+        if let token = ZaiSettingsReader.apiToken(environment: environment) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        return nil
+    }
+
+    public static func copilotResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        if let token = self.keychainToken(service: self.keychainService, account: self.copilotAccount) {
+            return ProviderTokenResolution(token: token, source: .keychain, sourceKey: "copilot-api-token")
+        }
+        if let token = self.cleaned(environment["COPILOT_API_TOKEN"]) {
+            return ProviderTokenResolution(token: token, source: .environment, sourceKey: "COPILOT_API_TOKEN")
+        }
+        if let token = self.cleaned(environment["GITHUB_TOKEN"]) {
+            return ProviderTokenResolution(token: token, source: .environment, sourceKey: "GITHUB_TOKEN")
+        }
+        if let token = self.cleaned(environment["GH_TOKEN"]) {
+            return ProviderTokenResolution(token: token, source: .environment, sourceKey: "GH_TOKEN")
+        }
+        if let token = self.copilotCLIToken(environment: environment) {
+            return ProviderTokenResolution(token: token, source: .environment, sourceKey: "gh-cli")
+        }
+        if let token = CopilotVSCodeTokenReader.token(environment: environment) {
+            return ProviderTokenResolution(token: token, source: .vscode, sourceKey: "vscode")
+        }
+        return nil
+    }
+
+    public static func minimaxResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        if let api = self.minimaxApiKeyResolution(environment: environment) {
+            return api
+        }
+        return self.minimaxCookieHeaderResolution(environment: environment)
+    }
+
+    public static func minimaxApiKeyResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        if let token = self.keychainToken(service: self.keychainService, account: self.minimaxAccount) {
+            return ProviderTokenResolution(token: token, source: .keychain)
+        }
+        if let token = self.cleaned(environment["MINIMAX_API_KEY"]) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        return nil
+    }
+
+    public static func minimaxCookieHeaderResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        if let token = self.keychainToken(service: self.keychainService, account: self.minimaxCookieAccount) {
+            return ProviderTokenResolution(token: token, source: .keychain)
+        }
+        if let token = MiniMaxSettingsReader.cookieHeader(environment: environment) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        return nil
+    }
+
+    public static func minimaxGroupResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        if let token = self.keychainToken(service: self.keychainService, account: self.minimaxGroupAccount) {
+            return ProviderTokenResolution(token: token, source: .keychain)
+        }
+        if let token = MiniMaxSettingsReader.groupID(environment: environment) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        return nil
+    }
+
+    public static func openRouterResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        if let token = self.keychainToken(service: self.keychainService, account: self.openRouterAccount) {
+            return ProviderTokenResolution(token: token, source: .keychain)
+        }
+        if let token = self.cleaned(environment["OPENROUTER_API_KEY"]) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        return nil
+    }
+
+    public static func groqResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        if let token = self.keychainToken(service: self.keychainService, account: self.groqAccount) {
+            return ProviderTokenResolution(token: token, source: .keychain)
+        }
+        if let token = self.cleaned(environment["GROQ_API_KEY"]) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        return nil
+    }
+
+    public static func deepSeekResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        if let token = self.keychainToken(service: self.keychainService, account: self.deepSeekAccount) {
+            return ProviderTokenResolution(token: token, source: .keychain)
+        }
+        if let token = self.cleaned(environment["DEEPSEEK_API_KEY"]) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        return nil
+    }
+
+    public static func fireworksResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        if let token = self.keychainToken(service: self.keychainService, account: self.fireworksAccount) {
+            return ProviderTokenResolution(token: token, source: .keychain)
+        }
+        if let token = self.cleaned(environment["FIREWORKS_API_KEY"]) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        return nil
+    }
+
+    public static func mistralResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        if let token = self.keychainToken(service: self.keychainService, account: self.mistralAccount) {
+            return ProviderTokenResolution(token: token, source: .keychain)
+        }
+        if let token = self.cleaned(environment["MISTRAL_API_KEY"]) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        return nil
+    }
+
+    public static func perplexityResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        if let token = self.keychainToken(service: self.keychainService, account: self.perplexityAccount) {
+            return ProviderTokenResolution(token: token, source: .keychain)
+        }
+        if let token = self.cleaned(environment["PPLX_API_KEY"]) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        if let token = self.cleaned(environment["PERPLEXITY_API_KEY"]) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        return nil
+    }
+
+    public static func kimiResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        if let token = self.keychainToken(service: self.keychainService, account: self.kimiAccount) {
+            return ProviderTokenResolution(token: token, source: .keychain)
+        }
+        if let token = self.cleaned(environment["KIMI_API_KEY"]) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        if let token = self.cleaned(environment["MOONSHOT_API_KEY"]) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        return nil
+    }
+
+    public static func auggieResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        if let token = self.keychainToken(service: self.keychainService, account: self.auggieAccount) {
+            return ProviderTokenResolution(token: token, source: .keychain)
+        }
+        if let token = self.cleaned(environment["AUGMENT_API_TOKEN"]) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        if let token = self.cleaned(environment["AUGGIE_API_TOKEN"]) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        return nil
+    }
+
+    public static func togetherResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        if let token = self.keychainToken(service: self.keychainService, account: self.togetherAccount) {
+            return ProviderTokenResolution(token: token, source: .keychain)
+        }
+        if let token = self.cleaned(environment["TOGETHER_API_KEY"]) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        return nil
+    }
+
+    public static func cohereResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        if let token = self.keychainToken(service: self.keychainService, account: self.cohereAccount) {
+            return ProviderTokenResolution(token: token, source: .keychain)
+        }
+        if let token = self.cleaned(environment["COHERE_API_KEY"]) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        return nil
+    }
+
+    public static func xaiResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        if let token = self.keychainToken(service: self.keychainService, account: self.xaiAccount) {
+            return ProviderTokenResolution(token: token, source: .keychain)
+        }
+        if let token = self.cleaned(environment["XAI_API_KEY"]) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        return nil
+    }
+
+    public static func cerebrasResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        if let token = self.keychainToken(service: self.keychainService, account: self.cerebrasAccount) {
+            return ProviderTokenResolution(token: token, source: .keychain)
+        }
+        if let token = self.cleaned(environment["CEREBRAS_API_KEY"]) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        return nil
+    }
+
+    public static func sambaNovaResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        if let token = self.keychainToken(service: self.keychainService, account: self.sambanovaAccount) {
+            return ProviderTokenResolution(token: token, source: .keychain)
+        }
+        if let token = self.cleaned(environment["SAMBANOVA_API_KEY"]) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        return nil
+    }
+
+    public static func azureOpenAIResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        if let token = self.keychainToken(service: self.keychainService, account: self.azureOpenAIAccount) {
+            return ProviderTokenResolution(token: token, source: .keychain)
+        }
+        if let token = self.cleaned(environment["AZURE_OPENAI_API_KEY"]) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        if let token = self.cleaned(environment["AZURE_AI_API_KEY"]) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        return nil
+    }
+
+    public static func qwenResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        if let token = self.keychainToken(service: self.keychainService, account: self.qwenAccount) {
+            return ProviderTokenResolution(token: token, source: .keychain)
+        }
+        if let token = QwenSettingsReader.apiToken(environment: environment) {
+            return ProviderTokenResolution(token: token, source: .environment)
+        }
+        return nil
+    }
+
+    private static func cleaned(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value.removeFirst()
+            value.removeLast()
+        }
+
+        value = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : value
+    }
+
+    private static func keychainToken(service: String, account: String) -> String? {
+        #if canImport(Security)
+        // Token stores write to the standard keychain (dataProtection: false),
+        // so try it first.  Fall back to the Data Protection keychain for
+        // pre-migration items that haven't been moved yet.
+        if let token = self.keychainRead(service: service, account: account, dataProtection: false) {
+            return token
+        }
+        return self.keychainRead(service: service, account: account, dataProtection: true)
+        #else
+        _ = service
+        _ = account
+        return nil
+        #endif
+    }
+
+    #if canImport(Security)
+    private static func keychainRead(service: String, account: String, dataProtection: Bool) -> String? {
+        var result: CFTypeRef?
+        var query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service,
+            kSecAttrAccount as String: account,
+            kSecUseAuthenticationUI as String: "kSecUseAuthenticationUIFail" as CFString,
+            kSecMatchLimit as String: kSecMatchLimitOne,
+            kSecReturnData as String: true,
+        ]
+        if dataProtection {
+            query[kSecUseDataProtectionKeychain as String] = true
+        }
+#if canImport(LocalAuthentication)
+        let authContext = LAContext()
+        authContext.interactionNotAllowed = true
+        query[kSecUseAuthenticationContext as String] = authContext
+#endif
+
+        let status = SecItemCopyMatching(query as CFDictionary, &result)
+        if status == errSecItemNotFound || status == errSecInteractionNotAllowed {
+            return nil
+        }
+        guard status == errSecSuccess else {
+            self.log.error("Keychain read failed: \(status)")
+            return nil
+        }
+
+        guard let data = result as? Data,
+              let token = String(data: data, encoding: .utf8),
+              let cleaned = self.cleaned(token),
+              !cleaned.isEmpty
+        else {
+            return nil
+        }
+
+        return cleaned
+    }
+    #endif
+}

package/Sources/RunicCore/Providers/ProviderVersionDetector.swift

@@ -0,0 +1,68 @@
+import Foundation
+
+public enum ProviderVersionDetector {
+    public static func codexVersion() -> String? {
+        guard let path = TTYCommandRunner.which("codex") else { return nil }
+        let candidates = [
+            ["--version"],
+            ["version"],
+            ["-v"],
+        ]
+        for args in candidates {
+            if let version = Self.run(path: path, args: args) { return version }
+        }
+        return nil
+    }
+
+    public static func geminiVersion() -> String? {
+        let env = ProcessInfo.processInfo.environment
+        guard let path = BinaryLocator.resolveGeminiBinary(env: env, loginPATH: nil)
+            ?? TTYCommandRunner.which("gemini") else { return nil }
+        let candidates = [
+            ["--version"],
+            ["-v"],
+        ]
+        for args in candidates {
+            if let version = Self.run(path: path, args: args) { return version }
+        }
+        return nil
+    }
+
+    private static func run(path: String, args: [String]) -> String? {
+        let proc = Process()
+        proc.executableURL = URL(fileURLWithPath: path)
+        proc.arguments = args
+        let out = Pipe()
+        proc.standardOutput = out
+        proc.standardError = Pipe()
+
+        do {
+            try proc.run()
+        } catch {
+            return nil
+        }
+
+        let deadline = Date().addingTimeInterval(2.0)
+        while proc.isRunning, Date() < deadline {
+            usleep(50000)
+        }
+        if proc.isRunning {
+            proc.terminate()
+            let killDeadline = Date().addingTimeInterval(0.5)
+            while proc.isRunning, Date() < killDeadline {
+                usleep(20000)
+            }
+            if proc.isRunning {
+                kill(proc.processIdentifier, SIGKILL)
+            }
+        }
+
+        let data = out.fileHandleForReading.readDataToEndOfFile()
+        guard proc.terminationStatus == 0,
+              let text = String(data: data, encoding: .utf8)?
+                  .split(whereSeparator: \.isNewline).first
+        else { return nil }
+        let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        return trimmed.isEmpty ? nil : trimmed
+    }
+}