@sriinnu/runic 1.0.0

package/Sources/Runic/Providers/Copilot/CopilotLoginFlow.swift

@@ -0,0 +1,193 @@
+import AppKit
+import RunicCore
+import SwiftUI
+
+@MainActor
+struct CopilotLoginFlow {
+    static func run(settings: SettingsStore) async -> Bool {
+        let flow = CopilotDeviceFlow()
+
+        do {
+            let code = try await flow.requestDeviceCode()
+
+            // Copy code to clipboard
+            let pb = NSPasteboard.general
+            pb.clearContents()
+            pb.setString(code.userCode, forType: .string)
+
+            let alert = NSAlert()
+            alert.messageText = "GitHub Copilot Login"
+            alert.informativeText = """
+            A device code has been copied to your clipboard: \(code.userCode)
+
+            We will open GitHub with the code prefilled.
+            If the browser still asks for a code, paste: \(code.userCode)
+            """
+            alert.addButton(withTitle: "Open Browser")
+            alert.addButton(withTitle: "Cancel")
+
+            let response = alert.runModal()
+            if response == .alertSecondButtonReturn {
+                return false // Cancelled
+            }
+
+            if let url = Self.makeVerificationURL(code: code) {
+                NSWorkspace.shared.open(url)
+            }
+
+            // Poll in background (modal blocks, but we need to wait for token effectively)
+            // Ideally we'd show a "Waiting..." modal or spinner.
+            // For simplicity, we can use a non-modal window or just block a Task?
+            // `runModal` blocks the thread. We need to poll while the user is doing auth in browser.
+            // But we already returned from runModal to open the browser.
+            // We need a secondary "Waiting for confirmation..." alert or state.
+
+            // Let's show a "Waiting" alert that can be cancelled.
+            let waitingAlert = NSAlert()
+            waitingAlert.messageText = "Waiting for Authentication..."
+            waitingAlert.informativeText = """
+            Please complete the login in your browser.
+            This window will close automatically when finished.
+            """
+            waitingAlert.addButton(withTitle: "Cancel")
+            let parentWindow = Self.resolveWaitingParentWindow()
+            let hostWindow = parentWindow ?? Self.makeWaitingHostWindow()
+            let shouldCloseHostWindow = parentWindow == nil
+            let tokenTask = Task.detached(priority: .userInitiated) {
+                try await flow.pollForToken(deviceCode: code.deviceCode, interval: code.interval)
+            }
+
+            let waitTask = Task { @MainActor in
+                let response = await Self.presentWaitingAlert(waitingAlert, parentWindow: hostWindow)
+                if response == .alertFirstButtonReturn {
+                    tokenTask.cancel()
+                }
+                return response
+            }
+
+            let tokenResult: Result<String, Error>
+            do {
+                let token = try await tokenTask.value
+                tokenResult = .success(token)
+            } catch {
+                tokenResult = .failure(error)
+            }
+
+            Self.dismissWaitingAlert(waitingAlert, parentWindow: hostWindow, closeHost: shouldCloseHostWindow)
+            let waitResponse = await waitTask.value
+            if waitResponse == .alertFirstButtonReturn {
+                return false
+            }
+
+            switch tokenResult {
+            case let .success(token):
+                settings.copilotAPIToken = token
+                settings.setProviderEnabled(
+                    provider: .copilot,
+                    metadata: ProviderRegistry.shared.metadata[.copilot]!,
+                    enabled: true)
+
+                let success = NSAlert()
+                success.messageText = "Login Successful"
+                success.runModal()
+                return true
+            case let .failure(error):
+                guard !(error is CancellationError) else { return false }
+                let err = NSAlert()
+                err.messageText = "Login Failed"
+                err.informativeText = error.localizedDescription
+                err.runModal()
+                return false
+            }
+
+        } catch {
+            let err = NSAlert()
+            err.messageText = "Login Failed"
+            err.informativeText = error.localizedDescription
+            err.runModal()
+            return false
+        }
+    }
+
+    @MainActor
+    private static func presentWaitingAlert(
+        _ alert: NSAlert,
+        parentWindow: NSWindow) async -> NSApplication.ModalResponse
+    {
+        await withCheckedContinuation { continuation in
+            alert.beginSheetModal(for: parentWindow) { response in
+                continuation.resume(returning: response)
+            }
+        }
+    }
+
+    @MainActor
+    private static func dismissWaitingAlert(
+        _ alert: NSAlert,
+        parentWindow: NSWindow,
+        closeHost: Bool)
+    {
+        let alertWindow = alert.window
+        if alertWindow.sheetParent != nil {
+            parentWindow.endSheet(alertWindow)
+        } else {
+            alertWindow.orderOut(nil)
+        }
+
+        guard closeHost else { return }
+        parentWindow.orderOut(nil)
+        parentWindow.close()
+    }
+
+    @MainActor
+    private static func resolveWaitingParentWindow() -> NSWindow? {
+        if let window = NSApp.keyWindow ?? NSApp.mainWindow {
+            return window
+        }
+        if let window = NSApp.windows.first(where: { $0.isVisible && !$0.ignoresMouseEvents }) {
+            return window
+        }
+        return NSApp.windows.first
+    }
+
+    @MainActor
+    private static func makeWaitingHostWindow() -> NSWindow {
+        let window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 420, height: 1),
+            styleMask: [.titled, .fullSizeContentView],
+            backing: .buffered,
+            defer: false)
+        window.isReleasedWhenClosed = false
+        window.titleVisibility = .hidden
+        window.titlebarAppearsTransparent = true
+        window.standardWindowButton(.closeButton)?.isHidden = true
+        window.standardWindowButton(.miniaturizeButton)?.isHidden = true
+        window.standardWindowButton(.zoomButton)?.isHidden = true
+        window.backgroundColor = .clear
+        window.isOpaque = false
+        window.hasShadow = false
+        window.level = .floating
+        window.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary]
+        window.center()
+        window.makeKeyAndOrderFront(nil)
+        return window
+    }
+
+    private static func makeVerificationURL(code: CopilotDeviceFlow.DeviceCodeResponse) -> URL? {
+        if let complete = code.verificationUriComplete,
+           let completeURL = URL(string: complete)
+        {
+            return completeURL
+        }
+
+        guard var components = URLComponents(string: code.verificationUri) else {
+            return URL(string: code.verificationUri)
+        }
+        var items = components.queryItems ?? []
+        if !items.contains(where: { $0.name.caseInsensitiveCompare("user_code") == .orderedSame }) {
+            items.append(URLQueryItem(name: "user_code", value: code.userCode))
+        }
+        components.queryItems = items
+        return components.url ?? URL(string: code.verificationUri)
+    }
+}

package/Sources/Runic/Providers/Copilot/CopilotProviderImplementation.swift

@@ -0,0 +1,110 @@
+import AppKit
+import RunicCore
+import RunicMacroSupport
+import SwiftUI
+
+@ProviderImplementationRegistration
+struct CopilotProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .copilot
+    let supportsLoginFlow: Bool = true
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "copilot-api-token",
+                title: "GitHub Login",
+                subtitle: "Stored in Keychain (encrypted). Sign in via GitHub Device Flow below.",
+                kind: .secure,
+                placeholder: "Sign in via button below",
+                binding: context.stringBinding(\.copilotAPIToken),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "copilot-import-vscode",
+                        title: "Import VS Code login",
+                        style: .link,
+                        isVisible: { context.settings.copilotAPIToken.isEmpty },
+                        perform: {
+                            if let token = CopilotVSCodeTokenReader.token(allowUserInteraction: true) {
+                                context.settings.copilotAPIToken = token
+                                context.settings.setProviderEnabled(
+                                    provider: .copilot,
+                                    metadata: ProviderRegistry.shared.metadata[.copilot]!,
+                                    enabled: true)
+                                let success = NSAlert()
+                                success.messageText = "VS Code Login Imported"
+                                success.informativeText = "Runic imported your GitHub Copilot token from VS Code."
+                                success.runModal()
+                                await context.store.refresh(trigger: .login)
+                                return
+                            }
+
+                            let failure = NSAlert()
+                            failure.messageText = "Import Failed"
+                            failure.informativeText = """
+                            Runic could not access VS Code Copilot credentials.
+                            You can sign in directly using "Sign in with GitHub" below.
+                            """
+                            failure.runModal()
+                        }),
+                    ProviderSettingsActionDescriptor(
+                        id: "copilot-import-gh-cli",
+                        title: "Import GitHub CLI login",
+                        style: .link,
+                        isVisible: { context.settings.copilotAPIToken.isEmpty },
+                        perform: {
+                            if let token = CopilotGitHubCLITokenReader.token() {
+                                context.settings.copilotAPIToken = token
+                                context.settings.setProviderEnabled(
+                                    provider: .copilot,
+                                    metadata: ProviderRegistry.shared.metadata[.copilot]!,
+                                    enabled: true)
+                                let success = NSAlert()
+                                success.messageText = "GitHub CLI Login Imported"
+                                success.informativeText = "Runic imported your GitHub Copilot token from GitHub CLI."
+                                success.runModal()
+                                await context.store.refresh(trigger: .login)
+                                return
+                            }
+
+                            let failure = NSAlert()
+                            failure.messageText = "Import Failed"
+                            failure.informativeText = """
+                            Runic could not find a valid GitHub CLI token.
+                            Sign in with GitHub CLI (`gh auth login`) and retry, or use the GitHub sign in button.
+                            """
+                            failure.runModal()
+                        }),
+                    ProviderSettingsActionDescriptor(
+                        id: "copilot-login",
+                        title: "Sign in with GitHub",
+                        style: .bordered,
+                        isVisible: { context.settings.copilotAPIToken.isEmpty },
+                        perform: {
+                            let didLogin = await CopilotLoginFlow.run(settings: context.settings)
+                            guard didLogin else { return }
+                            await context.store.refresh(trigger: .login)
+                        }),
+                    ProviderSettingsActionDescriptor(
+                        id: "copilot-relogin",
+                        title: "Sign in again",
+                        style: .link,
+                        isVisible: { !context.settings.copilotAPIToken.isEmpty },
+                        perform: {
+                            let didLogin = await CopilotLoginFlow.run(settings: context.settings)
+                            guard didLogin else { return }
+                            await context.store.refresh(trigger: .login)
+                        }),
+                ],
+                isVisible: nil),
+        ]
+    }
+
+    @MainActor
+    func runLoginFlow(context: ProviderLoginContext) async -> Bool {
+        let didLogin = await CopilotLoginFlow.run(settings: context.controller.settings)
+        guard didLogin else { return false }
+        await context.controller.store.refresh(trigger: .login)
+        return true
+    }
+}

package/Sources/Runic/Providers/Cursor/CursorLoginFlow.swift

@@ -0,0 +1,28 @@
+import RunicCore
+
+@MainActor
+extension StatusItemController {
+    func runCursorLoginFlow() async {
+        let cursorRunner = CursorLoginRunner()
+        let phaseHandler: @Sendable (CursorLoginRunner.Phase) -> Void = { [weak self] phase in
+            Task { @MainActor in
+                switch phase {
+                case .loading, .waitingLogin:
+                    self?.loginPhase = .waitingBrowser
+                case .success, .failed:
+                    self?.loginPhase = .idle
+                }
+            }
+        }
+        let result = await cursorRunner.run(onPhaseChange: phaseHandler)
+        guard !Task.isCancelled else { return }
+        self.loginPhase = .idle
+        self.presentCursorLoginResult(result)
+        let outcome = self.describe(result.outcome)
+        self.loginLogger.info("Cursor login", metadata: ["outcome": outcome])
+        print("[Runic] Cursor login outcome=\(outcome)")
+        if case .success = result.outcome {
+            self.postLoginNotification(for: .cursor)
+        }
+    }
+}

package/Sources/Runic/Providers/Cursor/CursorProviderImplementation.swift

@@ -0,0 +1,15 @@
+import RunicCore
+import RunicMacroSupport
+import Foundation
+
+@ProviderImplementationRegistration
+struct CursorProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .cursor
+    let supportsLoginFlow: Bool = true
+
+    @MainActor
+    func runLoginFlow(context: ProviderLoginContext) async -> Bool {
+        await context.controller.runCursorLoginFlow()
+        return true
+    }
+}

package/Sources/Runic/Providers/DeepSeek/DeepSeekProviderImplementation.swift

@@ -0,0 +1,24 @@
+import AppKit
+import RunicCore
+import RunicMacroSupport
+import Foundation
+
+@ProviderImplementationRegistration
+struct DeepSeekProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .deepseek
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "deepseek-api-token",
+                title: "API key",
+                subtitle: "Stored in Keychain (encrypted). Press Return to save.",
+                kind: .secure,
+                placeholder: "Paste key…",
+                binding: context.stringBinding(\.deepSeekAPIToken),
+                actions: [],
+                isVisible: nil),
+        ]
+    }
+}

package/Sources/Runic/Providers/Factory/FactoryLoginFlow.swift

@@ -0,0 +1,12 @@
+import AppKit
+import RunicCore
+
+@MainActor
+extension StatusItemController {
+    func runFactoryLoginFlow() async {
+        // Open Factory login page in default browser
+        if let url = URL(string: "https://app.factory.ai") {
+            NSWorkspace.shared.open(url)
+        }
+    }
+}

package/Sources/Runic/Providers/Factory/FactoryProviderImplementation.swift

@@ -0,0 +1,15 @@
+import RunicCore
+import RunicMacroSupport
+import Foundation
+
+@ProviderImplementationRegistration
+struct FactoryProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .factory
+    let supportsLoginFlow: Bool = true
+
+    @MainActor
+    func runLoginFlow(context: ProviderLoginContext) async -> Bool {
+        await context.controller.runFactoryLoginFlow()
+        return true
+    }
+}

package/Sources/Runic/Providers/Fireworks/FireworksProviderImplementation.swift

@@ -0,0 +1,24 @@
+import AppKit
+import RunicCore
+import RunicMacroSupport
+import Foundation
+
+@ProviderImplementationRegistration
+struct FireworksProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .fireworks
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "fireworks-api-token",
+                title: "API key",
+                subtitle: "Stored in Keychain (encrypted). Press Return to save.",
+                kind: .secure,
+                placeholder: "Paste key…",
+                binding: context.stringBinding(\.fireworksAPIToken),
+                actions: [],
+                isVisible: nil),
+        ]
+    }
+}

package/Sources/Runic/Providers/Gemini/GeminiLoginFlow.swift

@@ -0,0 +1,20 @@
+import RunicCore
+
+@MainActor
+extension StatusItemController {
+    func runGeminiLoginFlow() async {
+        let store = self.store
+        let result = await GeminiLoginRunner.run {
+            Task { @MainActor in
+                await store.refresh(trigger: .login, forceTokenUsage: true)
+                print("[Runic] Auto-refreshed after Gemini auth")
+            }
+        }
+        guard !Task.isCancelled else { return }
+        self.loginPhase = .idle
+        self.presentGeminiLoginResult(result)
+        let outcome = self.describe(result.outcome)
+        self.loginLogger.info("Gemini login", metadata: ["outcome": outcome])
+        print("[Runic] Gemini login outcome=\(outcome)")
+    }
+}

package/Sources/Runic/Providers/Gemini/GeminiProviderImplementation.swift

@@ -0,0 +1,15 @@
+import RunicCore
+import RunicMacroSupport
+import Foundation
+
+@ProviderImplementationRegistration
+struct GeminiProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .gemini
+    let supportsLoginFlow: Bool = true
+
+    @MainActor
+    func runLoginFlow(context: ProviderLoginContext) async -> Bool {
+        await context.controller.runGeminiLoginFlow()
+        return false
+    }
+}

package/Sources/Runic/Providers/Groq/GroqProviderImplementation.swift

@@ -0,0 +1,24 @@
+import AppKit
+import RunicCore
+import RunicMacroSupport
+import Foundation
+
+@ProviderImplementationRegistration
+struct GroqProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .groq
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "groq-api-token",
+                title: "API key",
+                subtitle: "Stored in Keychain (encrypted). Press Return to save.",
+                kind: .secure,
+                placeholder: "Paste key…",
+                binding: context.stringBinding(\.groqAPIToken),
+                actions: [],
+                isVisible: nil),
+        ]
+    }
+}

package/Sources/Runic/Providers/Kimi/KimiProviderImplementation.swift

@@ -0,0 +1,24 @@
+import AppKit
+import RunicCore
+import RunicMacroSupport
+import Foundation
+
+@ProviderImplementationRegistration
+struct KimiProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .kimi
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "kimi-api-token",
+                title: "API key",
+                subtitle: "Stored in Keychain (encrypted). Press Return to save.",
+                kind: .secure,
+                placeholder: "Paste key…",
+                binding: context.stringBinding(\.kimiAPIToken),
+                actions: [],
+                isVisible: nil),
+        ]
+    }
+}

package/Sources/Runic/Providers/MiniMax/MiniMaxProviderImplementation.swift

@@ -0,0 +1,32 @@
+import RunicCore
+import RunicMacroSupport
+import Foundation
+
+@ProviderImplementationRegistration
+struct MiniMaxProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .minimax
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "minimax-api-token",
+                title: "API Token",
+                subtitle: "Enter your MiniMax API Key.",
+                kind: .secure,
+                placeholder: "ey...",
+                binding: context.stringBinding(\.minimaxAPIToken),
+                actions: [],
+                isVisible: nil),
+            ProviderSettingsFieldDescriptor(
+                id: "minimax-cookie-header",
+                title: "Cookie header (manual)",
+                subtitle: "Paste a Cookie: header or Copy as cURL. Stored in Keychain. Press Return to save.",
+                kind: .secure,
+                placeholder: "Paste Cookie header or cURL…",
+                binding: context.stringBinding(\.minimaxCookieHeader),
+                actions: [],
+                isVisible: nil),
+        ]
+    }
+}

package/Sources/Runic/Providers/Mistral/MistralProviderImplementation.swift

@@ -0,0 +1,24 @@
+import AppKit
+import RunicCore
+import RunicMacroSupport
+import Foundation
+
+@ProviderImplementationRegistration
+struct MistralProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .mistral
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "mistral-api-token",
+                title: "API key",
+                subtitle: "Stored in Keychain (encrypted). Press Return to save.",
+                kind: .secure,
+                placeholder: "Paste key…",
+                binding: context.stringBinding(\.mistralAPIToken),
+                actions: [],
+                isVisible: nil),
+        ]
+    }
+}

package/Sources/Runic/Providers/OpenRouter/OpenRouterProviderImplementation.swift

@@ -0,0 +1,24 @@
+import AppKit
+import RunicCore
+import RunicMacroSupport
+import Foundation
+
+@ProviderImplementationRegistration
+struct OpenRouterProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .openrouter
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "openrouter-api-token",
+                title: "API key",
+                subtitle: "Stored in Keychain (encrypted). Press Return to save.",
+                kind: .secure,
+                placeholder: "Paste key…",
+                binding: context.stringBinding(\.openRouterAPIToken),
+                actions: [],
+                isVisible: nil),
+        ]
+    }
+}

package/Sources/Runic/Providers/Perplexity/PerplexityProviderImplementation.swift

@@ -0,0 +1,24 @@
+import AppKit
+import RunicCore
+import RunicMacroSupport
+import Foundation
+
+@ProviderImplementationRegistration
+struct PerplexityProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .perplexity
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "perplexity-api-token",
+                title: "API key",
+                subtitle: "Stored in Keychain (encrypted). Press Return to save.",
+                kind: .secure,
+                placeholder: "Paste key…",
+                binding: context.stringBinding(\.perplexityAPIToken),
+                actions: [],
+                isVisible: nil),
+        ]
+    }
+}

package/Sources/Runic/Providers/SambaNova/SambaNovaProviderImplementation.swift

@@ -0,0 +1,24 @@
+import AppKit
+import RunicCore
+import RunicMacroSupport
+import Foundation
+
+@ProviderImplementationRegistration
+struct SambaNovaProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .sambanova
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "sambanova-api-token",
+                title: "API key",
+                subtitle: "Stored in Keychain (encrypted). Press Return to save.",
+                kind: .secure,
+                placeholder: "Paste key…",
+                binding: context.stringBinding(\.sambaNovaAPIToken),
+                actions: [],
+                isVisible: nil),
+        ]
+    }
+}

package/Sources/Runic/Providers/Shared/ProviderCatalog.swift

@@ -0,0 +1,15 @@
+import RunicCore
+
+/// Source of truth for app-side provider implementations.
+///
+/// Keep provider registration centralized here. The rest of the app should *not* have to be updated when a new
+/// provider is added, aside from enum/metadata work in `RunicCore`.
+enum ProviderCatalog {
+    /// All provider implementations shipped in the app.
+    static let all: [any ProviderImplementation] = ProviderImplementationRegistry.all
+
+    /// Lookup for a single provider implementation.
+    static func implementation(for id: UsageProvider) -> (any ProviderImplementation)? {
+        ProviderImplementationRegistry.implementation(for: id)
+    }
+}