@sriinnu/runic 2.0.0 → 2.11.2

package/Sources/RunicCore/OpenAIWeb/OpenAIDashboardWebViewCache.swift

@@ -1,204 +0,0 @@
-#if os(macOS)
-import AppKit
-import Foundation
-import WebKit
-
-struct OpenAIDashboardWebViewLease {
-    let webView: WKWebView
-    let log: (String) -> Void
-    let release: () -> Void
-}
-
-@MainActor
-final class OpenAIDashboardWebViewCache {
-    static let shared = OpenAIDashboardWebViewCache()
-
-    private final class Entry {
-        let webView: WKWebView
-        let host: OffscreenWebViewHost
-        var lastUsedAt: Date
-        var isBusy: Bool
-
-        init(webView: WKWebView, host: OffscreenWebViewHost, lastUsedAt: Date, isBusy: Bool) {
-            self.webView = webView
-            self.host = host
-            self.lastUsedAt = lastUsedAt
-            self.isBusy = isBusy
-        }
-    }
-
-    private var entries: [ObjectIdentifier: Entry] = [:]
-    private let idleTimeout: TimeInterval = 10 * 60
-
-    func acquire(
-        websiteDataStore: WKWebsiteDataStore,
-        usageURL: URL,
-        logger: ((String) -> Void)?) async throws -> OpenAIDashboardWebViewLease
-    {
-        let now = Date()
-        self.prune(now: now)
-
-        let log: (String) -> Void = { message in
-            logger?("[webview] \(message)")
-        }
-        let key = ObjectIdentifier(websiteDataStore)
-
-        if let entry = self.entries[key] {
-            if entry.isBusy {
-                log("Cached WebView busy; using a temporary WebView.")
-                let (webView, host) = self.makeWebView(websiteDataStore: websiteDataStore)
-                host.show()
-                do {
-                    try await self.prepareWebView(webView, usageURL: usageURL)
-                } catch {
-                    host.close()
-                    throw error
-                }
-                return OpenAIDashboardWebViewLease(
-                    webView: webView,
-                    log: log,
-                    release: { host.close() })
-            }
-
-            entry.isBusy = true
-            entry.lastUsedAt = now
-            entry.host.show()
-            do {
-                try await self.prepareWebView(entry.webView, usageURL: usageURL)
-            } catch {
-                entry.isBusy = false
-                entry.lastUsedAt = Date()
-                entry.host.hide()
-                throw error
-            }
-
-            return OpenAIDashboardWebViewLease(
-                webView: entry.webView,
-                log: log,
-                release: { [weak self, weak entry] in
-                    guard let self, let entry else { return }
-                    entry.isBusy = false
-                    entry.lastUsedAt = Date()
-                    entry.host.hide()
-                    self.prune(now: Date())
-                })
-        }
-
-        let (webView, host) = self.makeWebView(websiteDataStore: websiteDataStore)
-        let entry = Entry(webView: webView, host: host, lastUsedAt: now, isBusy: true)
-        self.entries[key] = entry
-        host.show()
-
-        do {
-            try await self.prepareWebView(webView, usageURL: usageURL)
-        } catch {
-            self.entries.removeValue(forKey: key)
-            host.close()
-            throw error
-        }
-
-        return OpenAIDashboardWebViewLease(
-            webView: webView,
-            log: log,
-            release: { [weak self, weak entry] in
-                guard let self, let entry else { return }
-                entry.isBusy = false
-                entry.lastUsedAt = Date()
-                entry.host.hide()
-                self.prune(now: Date())
-            })
-    }
-
-    func evict(websiteDataStore: WKWebsiteDataStore) {
-        let key = ObjectIdentifier(websiteDataStore)
-        guard let entry = self.entries.removeValue(forKey: key) else { return }
-        entry.host.close()
-    }
-
-    private func prune(now: Date) {
-        let expired = self.entries.filter { _, entry in
-            !entry.isBusy && now.timeIntervalSince(entry.lastUsedAt) > self.idleTimeout
-        }
-        for (key, entry) in expired {
-            entry.host.close()
-            self.entries.removeValue(forKey: key)
-        }
-    }
-
-    private func makeWebView(websiteDataStore: WKWebsiteDataStore) -> (WKWebView, OffscreenWebViewHost) {
-        let config = WKWebViewConfiguration()
-        config.websiteDataStore = websiteDataStore
-        if #available(macOS 14.0, *) {
-            config.preferences.inactiveSchedulingPolicy = .suspend
-        }
-
-        let webView = WKWebView(frame: .zero, configuration: config)
-        let host = OffscreenWebViewHost(webView: webView)
-        return (webView, host)
-    }
-
-    private func prepareWebView(_ webView: WKWebView, usageURL: URL) async throws {
-        try await withCheckedThrowingContinuation { (cont: CheckedContinuation<Void, Error>) in
-            let delegate = NavigationDelegate { result in
-                cont.resume(with: result)
-            }
-            webView.navigationDelegate = delegate
-            webView.codexNavigationDelegate = delegate
-            _ = webView.load(URLRequest(url: usageURL))
-        }
-    }
-}
-
-@MainActor
-private final class OffscreenWebViewHost {
-    private let window: NSWindow
-
-    init(webView: WKWebView) {
-        // WebKit throttles timers/RAF aggressively when a WKWebView is not considered "visible".
-        // The Codex usage page uses streaming SSR + client hydration; if RAF is throttled, the
-        // dashboard never becomes part of the visible DOM and `document.body.innerText` stays tiny.
-        //
-        // Keep a transparent (mouse-ignoring) window technically "on-screen" while scraping, but
-        // place it almost entirely off-screen so we never ghost-render dashboard UI over the desktop.
-        let visibleFrame = NSScreen.main?.visibleFrame ?? NSRect(x: 0, y: 0, width: 900, height: 700)
-        let frame = OpenAIDashboardFetcher.offscreenHostWindowFrame(for: visibleFrame)
-        let window = NSWindow(
-            contentRect: frame,
-            styleMask: [.borderless],
-            backing: .buffered,
-            defer: false)
-        window.isReleasedWhenClosed = false
-        window.backgroundColor = .clear
-        window.isOpaque = false
-        // Keep it effectively invisible, but non-zero alpha so WebKit treats it as "visible" and doesn't
-        // stall hydration (we've observed a head-only HTML shell for minutes at alpha=0).
-        window.alphaValue = OpenAIDashboardFetcher.offscreenHostAlphaValue()
-        window.hasShadow = false
-        window.ignoresMouseEvents = true
-        window.level = .floating
-        window.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary]
-        window.isExcludedFromWindowsMenu = true
-        window.contentView = webView
-
-        self.window = window
-    }
-
-    func show() {
-        self.window.alphaValue = OpenAIDashboardFetcher.offscreenHostAlphaValue()
-        self.window.orderFrontRegardless()
-    }
-
-    func hide() {
-        // Set alpha to 0 so WebKit recognizes the page as inactive and applies
-        // its scheduling policy (throttle/suspend), reducing CPU when idle.
-        self.window.alphaValue = 0.0
-        self.window.orderOut(nil)
-    }
-
-    func close() {
-        self.window.orderOut(nil)
-        self.window.close()
-    }
-}
-
-#endif

package/Sources/RunicCore/OpenAIWeb/OpenAIDashboardWebsiteDataStore.swift

@@ -1,78 +0,0 @@
-#if os(macOS)
-import CryptoKit
-import Foundation
-import WebKit
-
-/// Per-account persistent `WKWebsiteDataStore` for the OpenAI dashboard scrape.
-///
-/// Why: `WKWebsiteDataStore.default()` is a single shared cookie jar. If the user switches Codex accounts,
-/// we want to keep multiple signed-in dashboard sessions around (one per email) without clearing cookies.
-///
-/// Implementation detail: macOS 14+ supports `WKWebsiteDataStore.dataStore(forIdentifier:)`, which creates
-/// persistent isolated stores keyed by an identifier. We derive a stable UUID from the email so the same
-/// account always maps to the same cookie store.
-@MainActor
-public enum OpenAIDashboardWebsiteDataStore {
-    public static func store(forAccountEmail email: String?) -> WKWebsiteDataStore {
-        guard let normalized = normalizeEmail(email) else { return .default() }
-        let id = Self.identifier(forNormalizedEmail: normalized)
-        return WKWebsiteDataStore(forIdentifier: id)
-    }
-
-    /// Clears the persistent cookie store for a single account email.
-    ///
-    /// Note: this does *not* impact other accounts, and is safe to use when the stored session is "stuck"
-    /// or signed in to a different account than expected.
-    public static func clearStore(forAccountEmail email: String?) async {
-        // Clear only ChatGPT/OpenAI domain data for the per-account store.
-        // Avoid deleting the entire persistent store (WebKit requires all WKWebViews using it to be released).
-        let store = self.store(forAccountEmail: email)
-        await withCheckedContinuation { cont in
-            store.fetchDataRecords(ofTypes: WKWebsiteDataStore.allWebsiteDataTypes()) { records in
-                let filtered = records.filter { record in
-                    let name = record.displayName.lowercased()
-                    return name.contains("chatgpt.com") || name.contains("openai.com")
-                }
-                store.removeData(ofTypes: WKWebsiteDataStore.allWebsiteDataTypes(), for: filtered) {
-                    cont.resume()
-                }
-            }
-        }
-    }
-
-    // MARK: - Private
-
-    private static func normalizeEmail(_ email: String?) -> String? {
-        guard let raw = email?.trimmingCharacters(in: .whitespacesAndNewlines), !raw.isEmpty else { return nil }
-        return raw.lowercased()
-    }
-
-    private static func identifier(forNormalizedEmail email: String) -> UUID {
-        let digest = SHA256.hash(data: Data(email.utf8))
-        var bytes = Array(digest.prefix(16))
-
-        // Make it a well-formed UUID (v4 + RFC4122 variant) while staying deterministic.
-        bytes[6] = (bytes[6] & 0x0F) | 0x40
-        bytes[8] = (bytes[8] & 0x3F) | 0x80
-
-        let uuidBytes: uuid_t = (
-            bytes[0],
-            bytes[1],
-            bytes[2],
-            bytes[3],
-            bytes[4],
-            bytes[5],
-            bytes[6],
-            bytes[7],
-            bytes[8],
-            bytes[9],
-            bytes[10],
-            bytes[11],
-            bytes[12],
-            bytes[13],
-            bytes[14],
-            bytes[15])
-        return UUID(uuid: uuidBytes)
-    }
-}
-#endif