@sriinnu/runic 1.2.0 → 2.11.1

package/Sources/Runic/Core/Login/CursorLoginRunner.swift

@@ -1,206 +0,0 @@
-import AppKit
-import RunicCore
-import Foundation
-import WebKit
-
-/// Handles Cursor login flow using a WebKit-based browser window.
-/// Captures session cookies after successful authentication.
-@MainActor
-final class CursorLoginRunner: NSObject {
-    enum Phase: Sendable {
-        case loading
-        case waitingLogin
-        case success
-        case failed(String)
-    }
-
-    struct Result: Sendable {
-        enum Outcome: Sendable {
-            case success
-            case cancelled
-            case failed(String)
-        }
-
-        let outcome: Outcome
-        let email: String?
-    }
-
-    private var webView: WKWebView?
-    private var window: NSWindow?
-    private var continuation: CheckedContinuation<Result, Never>?
-    private var phaseCallback: ((Phase) -> Void)?
-    private var hasCompletedLogin = false
-
-    private static let dashboardURL = URL(string: "https://cursor.com/dashboard")!
-    private static let loginURLPattern = "authenticator.cursor.sh"
-
-    /// Runs the Cursor login flow in a browser window.
-    /// Returns the result after the user completes login or cancels.
-    func run(onPhaseChange: @escaping @Sendable (Phase) -> Void) async -> Result {
-        self.phaseCallback = onPhaseChange
-        onPhaseChange(.loading)
-
-        return await withCheckedContinuation { continuation in
-            self.continuation = continuation
-            self.setupWindow()
-        }
-    }
-
-    private func setupWindow() {
-        // Configure WebView with persistent data store
-        let config = WKWebViewConfiguration()
-        config.websiteDataStore = .default()
-
-        let webView = WKWebView(frame: NSRect(x: 0, y: 0, width: 480, height: 640), configuration: config)
-        webView.navigationDelegate = self
-        self.webView = webView
-
-        // Create window
-        let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 480, height: 640),
-            styleMask: [.titled, .closable, .resizable],
-            backing: .buffered,
-            defer: false)
-        window.title = "Cursor Login"
-        window.contentView = webView
-        window.center()
-        window.delegate = self
-        window.makeKeyAndOrderFront(nil)
-        self.window = window
-
-        // Navigate to dashboard (will redirect to login if not authenticated)
-        let request = URLRequest(url: Self.dashboardURL)
-        webView.load(request)
-    }
-
-    private func complete(with result: Result) {
-        guard let continuation = self.continuation else { return }
-        self.continuation = nil
-        self.cleanup()
-        continuation.resume(returning: result)
-    }
-
-    private func cleanup() {
-        self.window?.close()
-        self.window = nil
-        self.webView?.navigationDelegate = nil
-        self.webView = nil
-    }
-
-    private func captureSessionCookies() async {
-        guard let webView = self.webView else { return }
-
-        let dataStore = webView.configuration.websiteDataStore
-        let cookies = await dataStore.httpCookieStore.allCookies()
-
-        // Filter for cursor.com cookies
-        let cursorCookies = cookies.filter { cookie in
-            cookie.domain.contains("cursor.com") || cookie.domain.contains("cursor.sh")
-        }
-
-        guard !cursorCookies.isEmpty else {
-            self.phaseCallback?(.failed("No session cookies found"))
-            self.complete(with: Result(outcome: .failed("No session cookies found"), email: nil))
-            return
-        }
-
-        // Save cookies to the session store
-        await CursorSessionStore.shared.setCookies(cursorCookies)
-
-        // Try to get user email
-        let email = await self.fetchUserEmail()
-
-        self.hasCompletedLogin = true
-        self.phaseCallback?(.success)
-        self.complete(with: Result(outcome: .success, email: email))
-    }
-
-    private func fetchUserEmail() async -> String? {
-        do {
-            let probe = CursorStatusProbe()
-            let snapshot = try await probe.fetch()
-            return snapshot.accountEmail
-        } catch {
-            return nil
-        }
-    }
-}
-
-// MARK: - WKNavigationDelegate
-
-extension CursorLoginRunner: WKNavigationDelegate {
-    nonisolated func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
-        Task { @MainActor in
-            guard let url = webView.url else { return }
-
-            let urlString = url.absoluteString
-
-            // Check if on login page
-            if urlString.contains(Self.loginURLPattern) {
-                self.phaseCallback?(.waitingLogin)
-                return
-            }
-
-            // Check if on dashboard (login successful)
-            if urlString.contains("cursor.com/dashboard"), !self.hasCompletedLogin {
-                await self.captureSessionCookies()
-            }
-        }
-    }
-
-    nonisolated func webView(
-        _ webView: WKWebView,
-        didReceiveServerRedirectForProvisionalNavigation navigation: WKNavigation!)
-    {
-        Task { @MainActor in
-            guard let url = webView.url else { return }
-            let urlString = url.absoluteString
-
-            // Detect redirect to dashboard after login
-            if urlString.contains("cursor.com/dashboard"), !self.hasCompletedLogin {
-                // Wait a moment for cookies to be set, then capture
-                try? await Task.sleep(nanoseconds: 500_000_000)
-                await self.captureSessionCookies()
-            }
-        }
-    }
-
-    nonisolated func webView(
-        _ webView: WKWebView,
-        didFail navigation: WKNavigation!,
-        withError error: Error)
-    {
-        Task { @MainActor in
-            self.phaseCallback?(.failed(error.localizedDescription))
-            self.complete(with: Result(outcome: .failed(error.localizedDescription), email: nil))
-        }
-    }
-
-    nonisolated func webView(
-        _ webView: WKWebView,
-        didFailProvisionalNavigation navigation: WKNavigation!,
-        withError error: Error)
-    {
-        Task { @MainActor in
-            // Ignore cancelled navigations (common during redirects)
-            let nsError = error as NSError
-            if nsError.domain == NSURLErrorDomain, nsError.code == NSURLErrorCancelled {
-                return
-            }
-            self.phaseCallback?(.failed(error.localizedDescription))
-            self.complete(with: Result(outcome: .failed(error.localizedDescription), email: nil))
-        }
-    }
-}
-
-// MARK: - NSWindowDelegate
-
-extension CursorLoginRunner: NSWindowDelegate {
-    nonisolated func windowWillClose(_ notification: Notification) {
-        Task { @MainActor in
-            if !self.hasCompletedLogin {
-                self.complete(with: Result(outcome: .cancelled, email: nil))
-            }
-        }
-    }
-}

package/Sources/Runic/Core/Login/GeminiLoginRunner.swift

@@ -1,92 +0,0 @@
-import AppKit
-import RunicCore
-import Foundation
-
-enum GeminiLoginRunner {
-    private static let geminiConfigDir = FileManager.default.homeDirectoryForCurrentUser
-        .appendingPathComponent(".gemini")
-    private static let credentialsFile = "oauth_creds.json"
-
-    private static func clearCredentials() {
-        let fm = FileManager.default
-        let filesToDelete = [credentialsFile, "google_accounts.json"]
-        for file in filesToDelete {
-            let path = self.geminiConfigDir.appendingPathComponent(file)
-            try? fm.removeItem(at: path)
-        }
-    }
-
-    struct Result {
-        enum Outcome {
-            case success
-            case missingBinary
-            case launchFailed(String)
-        }
-
-        let outcome: Outcome
-    }
-
-    static func run(onCredentialsCreated: (@Sendable () -> Void)? = nil) async -> Result {
-        await Task(priority: .userInitiated) {
-            let env = ProcessInfo.processInfo.environment
-            guard let binary = BinaryLocator.resolveGeminiBinary(
-                env: env,
-                loginPATH: LoginShellPathCache.shared.current)
-            else {
-                return Result(outcome: .missingBinary)
-            }
-
-            // Clear existing credentials before auth (enables clean account switch)
-            Self.clearCredentials()
-
-            // Start watching for credentials file to be created
-            if let callback = onCredentialsCreated {
-                Self.watchForCredentials(callback: callback)
-            }
-
-            // Create a temporary shell script that runs gemini (auto-prompts for auth when no creds)
-            let escaped = binary.replacingOccurrences(of: "'", with: "'\\''")
-            let scriptContent = "#!/bin/bash\ncd ~\n'\(escaped)'\n"
-
-            let tempDir = FileManager.default.temporaryDirectory
-            let scriptURL = tempDir.appendingPathComponent("gemini_login_\(UUID().uuidString).command")
-
-            do {
-                try scriptContent.write(to: scriptURL, atomically: true, encoding: .utf8)
-                try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: scriptURL.path)
-
-                let config = NSWorkspace.OpenConfiguration()
-                config.activates = true
-                try await NSWorkspace.shared.open(scriptURL, configuration: config)
-
-                // Clean up script after Terminal has time to read it
-                let scriptPath = scriptURL.path
-                DispatchQueue.global().asyncAfter(deadline: .now() + 10) {
-                    try? FileManager.default.removeItem(atPath: scriptPath)
-                }
-
-                return Result(outcome: .success)
-            } catch {
-                return Result(outcome: .launchFailed(error.localizedDescription))
-            }
-        }.value
-    }
-
-    /// Watch for credentials file to be created, then call callback once
-    private static func watchForCredentials(callback: @escaping @Sendable () -> Void, timeout: TimeInterval = 300) {
-        let credsPath = self.geminiConfigDir.appendingPathComponent(self.credentialsFile).path
-
-        DispatchQueue.global(qos: .utility).async {
-            let startTime = Date()
-            while Date().timeIntervalSince(startTime) < timeout {
-                if FileManager.default.fileExists(atPath: credsPath) {
-                    // Small delay to ensure file is fully written
-                    Thread.sleep(forTimeInterval: 0.5)
-                    callback()
-                    return
-                }
-                Thread.sleep(forTimeInterval: 1.0)
-            }
-        }
-    }
-}