@sriinnu/runic 2.0.0 → 2.11.2

package/Sources/Runic/Views/Preferences/PreferencesDebugPane.swift

@@ -1,469 +0,0 @@
-import AppKit
-import RunicCore
-import SwiftUI
-
-@MainActor
-struct DebugPane: View {
-    @Bindable var settings: SettingsStore
-    @Bindable var store: UsageStore
-    @State private var currentLogProvider: UsageProvider = .codex
-    @State private var currentFetchProvider: UsageProvider = .codex
-    @State private var isLoadingLog = false
-    @State private var logText: String = ""
-    @State private var isClearingCostCache = false
-    @State private var costCacheStatus: String?
-    #if DEBUG
-    @State private var currentErrorProvider: UsageProvider = .codex
-    @State private var simulatedErrorText: String = """
-    Simulated error for testing layout.
-    Second line.
-    Third line.
-    Fourth line.
-    """
-    #endif
-
-    var body: some View {
-        PreferencesPane {
-            SettingsSection {
-                PreferenceToggleRow(
-                    title: "Force animation on next ping",
-                    subtitle: "Temporarily shows the loading animation after the next ping.",
-                    binding: self.$store.debugForceAnimation)
-            }
-
-            SettingsSection(
-                title: "Loading animations",
-                caption: "Pick a pattern and replay it in the menu bar. \"Random\" keeps the existing behavior.")
-            {
-                Picker("Animation pattern", selection: self.animationPatternBinding) {
-                    Text("Random (default)").tag(nil as LoadingPattern?)
-                    ForEach(LoadingPattern.allCases) { pattern in
-                        Text(pattern.displayName).tag(Optional(pattern))
-                    }
-                }
-                .pickerStyle(.radioGroup)
-
-                Button("Replay selected animation") {
-                    self.replaySelectedAnimation()
-                }
-                .keyboardShortcut(.defaultAction)
-
-                Button {
-                    NotificationCenter.default.post(name: .runicDebugBlinkNow, object: nil)
-                } label: {
-                    Label("Blink now", systemImage: "eyes")
-                }
-                .controlSize(.small)
-            }
-
-            SettingsSection(
-                title: "Codex data source",
-                caption: "Debug override for Codex usage fetching.")
-            {
-                Picker("Source", selection: self.$settings.codexUsageDataSource) {
-                    ForEach(CodexUsageDataSource.allCases) { source in
-                        Text(source.displayName).tag(source)
-                    }
-                }
-                .pickerStyle(.menu)
-                .frame(width: 240)
-            }
-
-            SettingsSection(
-                title: "Claude data source",
-                caption: "Debug override for Claude usage fetching.")
-            {
-                Picker("Source", selection: self.$settings.claudeUsageDataSource) {
-                    ForEach(ClaudeUsageDataSource.allCases) { source in
-                        Text(source.displayName).tag(source)
-                    }
-                }
-                .pickerStyle(.menu)
-                .frame(width: 240)
-            }
-
-            SettingsSection(
-                title: "Probe logs",
-                caption: "Fetch the latest PTY scrape for Codex or Claude; Copy keeps the full text.")
-            {
-                Picker("Provider", selection: self.$currentLogProvider) {
-                    Text("Codex").tag(UsageProvider.codex)
-                    Text("Claude").tag(UsageProvider.claude)
-                }
-                .pickerStyle(.segmented)
-                .frame(width: 240)
-
-                HStack(spacing: RunicSpacing.sm) {
-                    Button { self.loadLog(self.currentLogProvider) } label: {
-                        Label("Fetch log", systemImage: "arrow.clockwise")
-                    }
-                    .disabled(self.isLoadingLog)
-
-                    Button { self.copyToPasteboard(self.logText) } label: {
-                        Label("Copy", systemImage: "doc.on.doc")
-                    }
-                    .disabled(self.logText.isEmpty)
-
-                    Button { self.saveLog(self.currentLogProvider) } label: {
-                        Label("Save to file", systemImage: "externaldrive.badge.plus")
-                    }
-                    .disabled(self.isLoadingLog && self.logText.isEmpty)
-
-                    if self.currentLogProvider == .claude {
-                        Button { self.loadClaudeDump() } label: {
-                            Label("Load parse dump", systemImage: "doc.text.magnifyingglass")
-                        }
-                        .disabled(self.isLoadingLog)
-                    }
-                }
-
-                Button {
-                    self.settings.rerunProviderDetection()
-                    self.loadLog(self.currentLogProvider)
-                } label: {
-                    Label("Re-run provider autodetect", systemImage: "dot.radiowaves.left.and.right")
-                }
-                .controlSize(.small)
-
-                ZStack(alignment: .topLeading) {
-                    ScrollView {
-                        Text(self.displayedLog)
-                            .font(RunicFont.footnote)
-                            .textSelection(.enabled)
-                            .frame(maxWidth: .infinity, alignment: .leading)
-                            .padding(RunicSpacing.xs)
-                    }
-                    .frame(minHeight: 160, maxHeight: 220)
-                    .background(Color(NSColor.textBackgroundColor))
-                    .cornerRadius(RunicCornerRadius.sm)
-
-                    if self.isLoadingLog {
-                        ProgressView()
-                            .progressViewStyle(.circular)
-                            .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .center)
-                            .padding()
-                    }
-                }
-            }
-
-            SettingsSection(
-                title: "Fetch strategy attempts",
-                caption: "Last fetch pipeline decisions and errors for a provider.")
-            {
-                Picker("Provider", selection: self.$currentFetchProvider) {
-                    ForEach(UsageProvider.allCases, id: \.self) { provider in
-                        Text(provider.rawValue.capitalized).tag(provider)
-                    }
-                }
-                .pickerStyle(.menu)
-                .frame(width: 240)
-
-                ScrollView {
-                    Text(self.fetchAttemptsText(for: self.currentFetchProvider))
-                        .font(RunicFont.footnote)
-                        .textSelection(.enabled)
-                        .frame(maxWidth: .infinity, alignment: .leading)
-                        .padding(RunicSpacing.xs)
-                }
-                .frame(minHeight: 120, maxHeight: 220)
-                .background(Color(NSColor.textBackgroundColor))
-                .cornerRadius(RunicCornerRadius.sm)
-            }
-
-            SettingsSection(
-                title: "OpenAI web access",
-                caption: "Cookie import + WebKit scrape logs from the last “Access OpenAI via web” attempt.")
-            {
-                HStack(spacing: RunicSpacing.sm) {
-                    Button { self.copyToPasteboard(self.store.openAIDashboardCookieImportDebugLog ?? "") } label: {
-                        Label("Copy", systemImage: "doc.on.doc")
-                    }
-                    .disabled((self.store.openAIDashboardCookieImportDebugLog ?? "").isEmpty)
-                }
-
-                ScrollView {
-                    Text(self.store.openAIDashboardCookieImportDebugLog?.isEmpty == false
-                        ? (self.store.openAIDashboardCookieImportDebugLog ?? "")
-                        : "No log yet. Enable \"Access OpenAI via web\" in General to run an import.")
-                        .font(RunicFont.footnote)
-                        .textSelection(.enabled)
-                        .frame(maxWidth: .infinity, alignment: .leading)
-                        .padding(RunicSpacing.xs)
-                }
-                .frame(minHeight: 120, maxHeight: 180)
-                .background(Color(NSColor.textBackgroundColor))
-                .cornerRadius(RunicCornerRadius.sm)
-            }
-
-            SettingsSection(
-                title: "Caches",
-                caption: "Clear cached cost scan results.")
-            {
-                let isTokenRefreshActive = self.store.isTokenRefreshInFlight(for: .codex)
-                    || self.store.isTokenRefreshInFlight(for: .claude)
-
-                HStack(spacing: RunicSpacing.sm) {
-                    Button {
-                        Task { await self.clearCostCache() }
-                    } label: {
-                        Label("Clear cost cache", systemImage: "trash")
-                    }
-                    .disabled(self.isClearingCostCache || isTokenRefreshActive)
-
-                    if let status = self.costCacheStatus {
-                        Text(status)
-                            .font(RunicFont.footnote)
-                            .foregroundStyle(.tertiary)
-                    }
-                }
-            }
-
-            SettingsSection(
-                title: "Notifications",
-                caption: "Trigger test notifications for the 5-hour session window (depleted/restored).")
-            {
-                Picker("Provider", selection: self.$currentLogProvider) {
-                    Text("Codex").tag(UsageProvider.codex)
-                    Text("Claude").tag(UsageProvider.claude)
-                }
-                .pickerStyle(.segmented)
-                .frame(width: 240)
-
-                HStack(spacing: RunicSpacing.sm) {
-                    Button {
-                        self.postSessionNotification(.depleted, provider: self.currentLogProvider)
-                    } label: {
-                        Label("Post depleted", systemImage: "bell.badge")
-                    }
-                    .controlSize(.small)
-
-                    Button {
-                        self.postSessionNotification(.restored, provider: self.currentLogProvider)
-                    } label: {
-                        Label("Post restored", systemImage: "bell")
-                    }
-                    .controlSize(.small)
-                }
-            }
-
-            #if DEBUG
-            SettingsSection(
-                title: "Error simulation",
-                caption: "Inject a fake error message into the menu card for layout testing.")
-            {
-                Picker("Provider", selection: self.$currentErrorProvider) {
-                    Text("Codex").tag(UsageProvider.codex)
-                    Text("Claude").tag(UsageProvider.claude)
-                    Text("Gemini").tag(UsageProvider.gemini)
-                    Text("Antigravity").tag(UsageProvider.antigravity)
-                }
-                .pickerStyle(.segmented)
-                .frame(width: 240)
-
-                TextField("Simulated error text", text: self.$simulatedErrorText, axis: .vertical)
-                    .lineLimit(4)
-
-                HStack(spacing: RunicSpacing.sm) {
-                    Button {
-                        self.store._setErrorForTesting(
-                            self.simulatedErrorText,
-                            provider: self.currentErrorProvider)
-                    } label: {
-                        Label("Set menu error", systemImage: "exclamationmark.triangle")
-                    }
-                    .controlSize(.small)
-
-                    Button {
-                        self.store._setErrorForTesting(nil, provider: self.currentErrorProvider)
-                    } label: {
-                        Label("Clear menu error", systemImage: "xmark.circle")
-                    }
-                    .controlSize(.small)
-                }
-
-                let supportsTokenError = self.currentErrorProvider == .codex || self.currentErrorProvider == .claude
-                HStack(spacing: RunicSpacing.sm) {
-                    Button {
-                        self.store._setTokenErrorForTesting(
-                            self.simulatedErrorText,
-                            provider: self.currentErrorProvider)
-                    } label: {
-                        Label("Set cost error", systemImage: "banknote")
-                    }
-                    .controlSize(.small)
-                    .disabled(!supportsTokenError)
-
-                    Button {
-                        self.store._setTokenErrorForTesting(nil, provider: self.currentErrorProvider)
-                    } label: {
-                        Label("Clear cost error", systemImage: "xmark.circle")
-                    }
-                    .controlSize(.small)
-                    .disabled(!supportsTokenError)
-                }
-            }
-            #endif
-
-            SettingsSection(
-                title: "CLI paths",
-                caption: "Resolved Codex binary and PATH layers; startup login PATH capture (short timeout).")
-            {
-                self.binaryRow(title: "Codex binary", value: self.store.pathDebugInfo.codexBinary)
-                self.binaryRow(title: "Claude binary", value: self.store.pathDebugInfo.claudeBinary)
-
-                VStack(alignment: .leading, spacing: RunicSpacing.xs) {
-                    Text("Effective PATH")
-                        .font(RunicFont.callout.weight(.semibold))
-                    ScrollView {
-                        Text(self.store.pathDebugInfo.effectivePATH.isEmpty
-                            ? "Unavailable"
-                            : self.store.pathDebugInfo.effectivePATH)
-                            .font(RunicFont.footnote)
-                            .textSelection(.enabled)
-                            .frame(maxWidth: .infinity, alignment: .leading)
-                            .padding(RunicSpacing.xs)
-                    }
-                    .frame(minHeight: 60, maxHeight: 110)
-                    .background(Color(NSColor.textBackgroundColor))
-                    .cornerRadius(RunicCornerRadius.sm)
-                }
-
-                if let loginPATH = self.store.pathDebugInfo.loginShellPATH {
-                    VStack(alignment: .leading, spacing: RunicSpacing.xs) {
-                        Text("Login shell PATH (startup capture)")
-                            .font(RunicFont.callout.weight(.semibold))
-                        ScrollView {
-                            Text(loginPATH)
-                                .font(RunicFont.footnote)
-                                .textSelection(.enabled)
-                                .frame(maxWidth: .infinity, alignment: .leading)
-                                .padding(RunicSpacing.xs)
-                        }
-                        .frame(minHeight: 60, maxHeight: 110)
-                        .background(Color(NSColor.textBackgroundColor))
-                        .cornerRadius(RunicCornerRadius.sm)
-                    }
-                }
-            }
-        }
-    }
-
-    private var animationPatternBinding: Binding<LoadingPattern?> {
-        Binding(
-            get: { self.settings.debugLoadingPattern },
-            set: { self.settings.debugLoadingPattern = $0 })
-    }
-
-    private func replaySelectedAnimation() {
-        var userInfo: [AnyHashable: Any] = [:]
-        if let pattern = self.settings.debugLoadingPattern {
-            userInfo["pattern"] = pattern.rawValue
-        }
-        NotificationCenter.default.post(
-            name: .runicDebugReplayAllAnimations,
-            object: nil,
-            userInfo: userInfo.isEmpty ? nil : userInfo)
-        self.store.replayLoadingAnimation(duration: 4)
-    }
-
-    private var displayedLog: String {
-        if self.logText.isEmpty {
-            return self.isLoadingLog ? "Loading…" : "No log yet. Fetch to load."
-        }
-        return self.logText
-    }
-
-    private func loadLog(_ provider: UsageProvider) {
-        self.isLoadingLog = true
-        Task {
-            let text = await self.store.debugLog(for: provider)
-            await MainActor.run {
-                self.logText = text
-                self.isLoadingLog = false
-            }
-        }
-    }
-
-    private func saveLog(_ provider: UsageProvider) {
-        Task {
-            if self.logText.isEmpty {
-                self.isLoadingLog = true
-                let text = await self.store.debugLog(for: provider)
-                await MainActor.run { self.logText = text }
-                self.isLoadingLog = false
-            }
-            _ = await self.store.dumpLog(toFileFor: provider)
-        }
-    }
-
-    private func copyToPasteboard(_ text: String) {
-        let pb = NSPasteboard.general
-        pb.clearContents()
-        pb.setString(text, forType: .string)
-    }
-
-    private func binaryRow(title: String, value: String?) -> some View {
-        VStack(alignment: .leading, spacing: RunicSpacing.xs) {
-            Text(title)
-                .font(RunicFont.callout.weight(.semibold))
-            Text(value ?? "Not found")
-                .font(RunicFont.footnote)
-                .foregroundStyle(value == nil ? .secondary : .primary)
-        }
-    }
-
-    private func loadClaudeDump() {
-        self.isLoadingLog = true
-        Task {
-            let text = await self.store.debugClaudeDump()
-            await MainActor.run {
-                self.logText = text
-                self.isLoadingLog = false
-            }
-        }
-    }
-
-    private func postSessionNotification(_ transition: SessionQuotaTransition, provider: UsageProvider) {
-        SessionQuotaNotifier().post(transition: transition, provider: provider, badge: 1)
-    }
-
-    private func clearCostCache() async {
-        guard !self.isClearingCostCache else { return }
-        self.isClearingCostCache = true
-        self.costCacheStatus = nil
-        defer { self.isClearingCostCache = false }
-
-        if let error = await self.store.clearCostUsageCache() {
-            self.costCacheStatus = "Failed: \(error)"
-            return
-        }
-
-        self.costCacheStatus = "Cleared."
-    }
-
-    private func fetchAttemptsText(for provider: UsageProvider) -> String {
-        let attempts = self.store.fetchAttempts(for: provider)
-        guard !attempts.isEmpty else { return "No fetch attempts yet." }
-        return attempts.map { attempt in
-            let kind = Self.fetchKindLabel(attempt.kind)
-            var line = "\(attempt.strategyID) (\(kind))"
-            line += attempt.wasAvailable ? " available" : " unavailable"
-            if let error = attempt.errorDescription, !error.isEmpty {
-                line += " error=\(error)"
-            }
-            return line
-        }.joined(separator: "\n")
-    }
-
-    private static func fetchKindLabel(_ kind: ProviderFetchKind) -> String {
-        switch kind {
-        case .cli: "cli"
-        case .web: "web"
-        case .oauth: "oauth"
-        case .apiToken: "api"
-        case .api: "api"
-        case .localProbe: "local"
-        case .webDashboard: "web"
-        }
-    }
-}