@sriinnu/runic 1.0.0

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

@@ -0,0 +1,268 @@
+import AppKit
+import RunicCore
+import KeyboardShortcuts
+import SwiftUI
+
+@MainActor
+struct AdvancedPane: View {
+    @Bindable var settings: SettingsStore
+    @Bindable var store: UsageStore
+    @State private var isInstallingCLI = false
+    @State private var cliStatus: String?
+
+    var body: some View {
+        PreferencesPane {
+            SettingsSection(contentSpacing: PreferencesLayoutMetrics.sectionSpacing) {
+                Text("Refresh cadence")
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+                    .textCase(.uppercase)
+                Picker("", selection: self.$settings.refreshFrequency) {
+                    ForEach(RefreshFrequency.allCases) { option in
+                        Text(option.label).tag(option)
+                    }
+                }
+                .pickerStyle(.segmented)
+
+                if self.settings.refreshFrequency == .manual {
+                    Text("Auto-refresh is off; use the menu's Refresh command.")
+                        .font(.footnote)
+                        .foregroundStyle(.secondary)
+                }
+                if let badgeText = self.store.autoRefreshDisableBadgeText() {
+                    Text(badgeText)
+                        .font(.caption2.weight(.medium))
+                        .padding(.horizontal, RunicSpacing.xs)
+                        .padding(.vertical, RunicSpacing.xxs)
+                        .background(Color(nsColor: .controlBackgroundColor))
+                        .clipShape(Capsule())
+                        .foregroundStyle(.secondary)
+                }
+                Text("Auto-refresh can switch to Manual when your Mac is idle or sleeps/locks. Adjust below.")
+                    .font(.footnote)
+                    .foregroundStyle(.secondary)
+            }
+
+            PreferencesDivider()
+
+            SettingsSection(contentSpacing: PreferencesLayoutMetrics.sectionSpacing) {
+                Text("Auto-refresh safety")
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+                    .textCase(.uppercase)
+
+                VStack(alignment: .leading, spacing: RunicSpacing.xs) {
+                    Toggle(isOn: self.$settings.autoDisableRefreshWhenIdleEnabled) {
+                        Text("Switch to Manual when idle")
+                            .font(.body)
+                    }
+                    .toggleStyle(.checkbox)
+
+                    Text("If your Mac is idle for the threshold below, Runic switches auto-refresh to Manual.")
+                        .font(.footnote)
+                        .foregroundStyle(.tertiary)
+                        .fixedSize(horizontal: false, vertical: true)
+
+                    PreferenceStepperRow(
+                        title: "Idle threshold",
+                        subtitle: nil,
+                        step: 1,
+                        range: 1...60,
+                        valueLabel: { "\($0) min" },
+                        value: self.$settings.autoDisableRefreshWhenIdleMinutes)
+                    .disabled(!self.settings.autoDisableRefreshWhenIdleEnabled)
+                    .opacity(self.settings.autoDisableRefreshWhenIdleEnabled ? 1 : 0.5)
+                }
+
+                VStack(alignment: .leading, spacing: RunicSpacing.xs) {
+                    Toggle(isOn: self.$settings.autoDisableRefreshOnSleepEnabled) {
+                        Text("Switch to Manual on sleep/lock")
+                            .font(.body)
+                    }
+                    .toggleStyle(.checkbox)
+
+                    Text("When your Mac sleeps or locks, auto-refresh moves to Manual to avoid background checks.")
+                        .font(.footnote)
+                        .foregroundStyle(.tertiary)
+                        .fixedSize(horizontal: false, vertical: true)
+                }
+
+                VStack(alignment: .leading, spacing: RunicSpacing.xs) {
+                    Toggle(isOn: self.$settings.autoRefreshWarningEnabled) {
+                        Text("Warn after repeated auto-refreshes")
+                            .font(.body)
+                    }
+                    .toggleStyle(.checkbox)
+
+                    Text("Sends a notification after the configured number of auto-refresh cycles.")
+                        .font(.footnote)
+                        .foregroundStyle(.tertiary)
+                        .fixedSize(horizontal: false, vertical: true)
+
+                    PreferenceStepperRow(
+                        title: "Warning threshold",
+                        subtitle: nil,
+                        step: 1,
+                        range: 5...100,
+                        valueLabel: { "\($0) runs" },
+                        value: self.$settings.autoRefreshWarningThreshold)
+                    .disabled(!self.settings.autoRefreshWarningEnabled)
+                    .opacity(self.settings.autoRefreshWarningEnabled ? 1 : 0.5)
+                }
+
+                VStack(alignment: .leading, spacing: RunicSpacing.xs) {
+                    Toggle(isOn: self.$settings.autoSuspendInactiveProvidersEnabled) {
+                        Text("Skip inactive providers")
+                            .font(.body)
+                    }
+                    .toggleStyle(.checkbox)
+
+                    Text("Pauses auto-refresh for providers with no usage changes for the threshold below.")
+                        .font(.footnote)
+                        .foregroundStyle(.tertiary)
+                        .fixedSize(horizontal: false, vertical: true)
+
+                    PreferenceStepperRow(
+                        title: "Inactive threshold",
+                        subtitle: nil,
+                        step: 30,
+                        range: 30...10080,
+                        valueLabel: { Self.inactiveThresholdLabel(for: $0) },
+                        value: self.$settings.autoSuspendInactiveProvidersMinutes)
+                    .disabled(!self.settings.autoSuspendInactiveProvidersEnabled)
+                    .opacity(self.settings.autoSuspendInactiveProvidersEnabled ? 1 : 0.5)
+                }
+
+                Text("Auto-refresh can read local logs or browser cookies depending on provider settings.")
+                    .font(.footnote)
+                    .foregroundStyle(.tertiary)
+                    .fixedSize(horizontal: false, vertical: true)
+                Text("Auto-refresh also switches to Manual when your Mac sleeps or is locked.")
+                    .font(.footnote)
+                    .foregroundStyle(.tertiary)
+                    .fixedSize(horizontal: false, vertical: true)
+            }
+
+            PreferencesDivider()
+
+            SettingsSection(contentSpacing: PreferencesLayoutMetrics.sectionSpacing) {
+                Text("Keyboard shortcut")
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+                    .textCase(.uppercase)
+                HStack(alignment: .center, spacing: RunicSpacing.sm) {
+                    Text("Open menu")
+                        .font(.body)
+                    Spacer()
+                    KeyboardShortcuts.Recorder(for: .openMenu)
+                }
+                Text("Trigger the menu bar menu from anywhere.")
+                    .font(.footnote)
+                    .foregroundStyle(.tertiary)
+            }
+
+            PreferencesDivider()
+
+            SettingsSection(contentSpacing: PreferencesLayoutMetrics.sectionSpacing) {
+                HStack(spacing: RunicSpacing.sm) {
+                    Button {
+                        Task { await self.installCLI() }
+                    } label: {
+                        if self.isInstallingCLI {
+                            ProgressView().controlSize(.small)
+                        } else {
+                            Text("Install CLI")
+                        }
+                    }
+                    .disabled(self.isInstallingCLI)
+
+                    if let status = self.cliStatus {
+                        Text(status)
+                            .font(.footnote)
+                            .foregroundStyle(.tertiary)
+                            .lineLimit(2)
+                    }
+                }
+                Text("Symlink RunicCLI to /usr/local/bin and /opt/homebrew/bin as runic.")
+                    .font(.footnote)
+                    .foregroundStyle(.tertiary)
+            }
+
+            PreferencesDivider()
+
+            SettingsSection(contentSpacing: PreferencesLayoutMetrics.sectionSpacing) {
+                PreferenceToggleRow(
+                    title: "Show Debug Settings",
+                    subtitle: "Expose troubleshooting tools in the Debug tab.",
+                    binding: self.$settings.debugMenuEnabled)
+            }
+        }
+    }
+
+    private static func inactiveThresholdLabel(for minutes: Int) -> String {
+        let inactiveMinutes = max(1, minutes)
+        if inactiveMinutes % 60 == 0 {
+            return "\(inactiveMinutes / 60) hr"
+        }
+        return "\(inactiveMinutes) min"
+    }
+}
+
+extension AdvancedPane {
+    private func installCLI() async {
+        if self.isInstallingCLI { return }
+        self.isInstallingCLI = true
+        defer { self.isInstallingCLI = false }
+
+        let helperURL = Bundle.main.bundleURL.appendingPathComponent("Contents/Helpers/RunicCLI")
+        let fm = FileManager.default
+        guard fm.fileExists(atPath: helperURL.path) else {
+            self.cliStatus = "RunicCLI not found in app bundle."
+            return
+        }
+
+        let destinations = [
+            "/usr/local/bin/runic",
+            "/opt/homebrew/bin/runic",
+        ]
+
+        var results: [String] = []
+        for dest in destinations {
+            let dir = (dest as NSString).deletingLastPathComponent
+            guard fm.fileExists(atPath: dir) else { continue }
+            guard fm.isWritableFile(atPath: dir) else {
+                results.append("No write access: \(dir)")
+                continue
+            }
+
+            if fm.fileExists(atPath: dest) {
+                if Self.isLink(atPath: dest, pointingTo: helperURL.path) {
+                    results.append("Installed: \(dir)")
+                } else {
+                    results.append("Exists: \(dir)")
+                }
+                continue
+            }
+
+            do {
+                try fm.createSymbolicLink(atPath: dest, withDestinationPath: helperURL.path)
+                results.append("Installed: \(dir)")
+            } catch {
+                results.append("Failed: \(dir)")
+            }
+        }
+
+        self.cliStatus = results.isEmpty
+            ? "No writable bin dirs found."
+            : results.joined(separator: " · ")
+    }
+
+    private static func isLink(atPath path: String, pointingTo destination: String) -> Bool {
+        guard let link = try? FileManager.default.destinationOfSymbolicLink(atPath: path) else { return false }
+        let dir = (path as NSString).deletingLastPathComponent
+        let resolved = URL(fileURLWithPath: link, relativeTo: URL(fileURLWithPath: dir))
+            .standardizedFileURL
+            .path
+        return resolved == destination
+    }
+}

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

@@ -0,0 +1,422 @@
+import AppKit
+import RunicCore
+import SwiftUI
+
+@MainActor
+struct AlertsPane: View {
+    @Bindable var settings: SettingsStore
+    @Bindable var store: UsageStore
+
+    @State private var alertsData: AlertRuleStore.AlertsData = AlertRuleStore.load()
+    @State private var showingAddRule = false
+    @State private var editingRule: AlertRuleStore.AlertRule?
+    @State private var showingTestResult: String?
+    @State private var defaultWebhookURL: String = ""
+    @State private var webhookFormat: WebhookFormat = .slack
+
+    enum WebhookFormat: String, CaseIterable, Identifiable {
+        case slack
+        case discord
+        case generic
+
+        var id: String { self.rawValue }
+
+        var label: String {
+            switch self {
+            case .slack: return "Slack"
+            case .discord: return "Discord"
+            case .generic: return "Generic"
+            }
+        }
+    }
+
+    var body: some View {
+        PreferencesPane {
+            SettingsSection(contentSpacing: PreferencesLayoutMetrics.sectionSpacing) {
+                Text("Alert Rules")
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+                    .textCase(.uppercase)
+
+                VStack(alignment: .leading, spacing: RunicSpacing.xs) {
+                    HStack {
+                        Text("\(self.alertsData.rules.count) rules configured")
+                            .font(.footnote)
+                            .foregroundStyle(.secondary)
+
+                        Spacer()
+
+                        Button {
+                            self.showingAddRule = true
+                        } label: {
+                            Label("Add Rule", systemImage: "plus")
+                        }
+                        .buttonStyle(.bordered)
+                        .controlSize(.small)
+                    }
+
+                    if self.alertsData.rules.isEmpty {
+                        Text("No alert rules configured. Add a rule to get started.")
+                            .font(.footnote)
+                            .foregroundStyle(.tertiary)
+                            .padding(.vertical, RunicSpacing.md)
+                            .frame(maxWidth: .infinity)
+                    } else {
+                        VStack(spacing: RunicSpacing.xxs) {
+                            ForEach(self.alertsData.rules) { rule in
+                                self.ruleRow(rule)
+                            }
+                        }
+                        .padding(.vertical, RunicSpacing.xs)
+                    }
+                }
+            }
+
+            PreferencesDivider()
+
+            SettingsSection(contentSpacing: PreferencesLayoutMetrics.sectionSpacing) {
+                Text("Webhook Configuration")
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+                    .textCase(.uppercase)
+
+                VStack(alignment: .leading, spacing: RunicSpacing.sm) {
+                    VStack(alignment: .leading, spacing: 4) {
+                        Text("Default webhook URL")
+                            .font(.body)
+                        TextField("https://hooks.slack.com/services/...", text: self.$defaultWebhookURL)
+                            .textFieldStyle(.roundedBorder)
+                        Text("Used for all alerts unless overridden in rule settings.")
+                            .font(.footnote)
+                            .foregroundStyle(.tertiary)
+                    }
+
+                    VStack(alignment: .leading, spacing: 4) {
+                        Text("Webhook format")
+                            .font(.body)
+                        Picker("", selection: self.$webhookFormat) {
+                            ForEach(WebhookFormat.allCases) { format in
+                                Text(format.label).tag(format)
+                            }
+                        }
+                        .pickerStyle(.segmented)
+                        .frame(maxWidth: 300)
+                    }
+
+                    HStack(spacing: RunicSpacing.xs) {
+                        Button("Test Webhook") {
+                            self.testWebhook()
+                        }
+                        .buttonStyle(.bordered)
+                        .disabled(self.defaultWebhookURL.isEmpty)
+
+                        if let result = self.showingTestResult {
+                            Text(result)
+                                .font(.footnote)
+                                .foregroundStyle(result.contains("Success") ? .green : .red)
+                        }
+                    }
+                }
+            }
+
+            PreferencesDivider()
+
+            SettingsSection(contentSpacing: PreferencesLayoutMetrics.sectionSpacing) {
+                Text("Alert History")
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+                    .textCase(.uppercase)
+
+                VStack(alignment: .leading, spacing: RunicSpacing.xs) {
+                    HStack {
+                        Text("Last 20 triggered alerts")
+                            .font(.footnote)
+                            .foregroundStyle(.secondary)
+
+                        Spacer()
+
+                        Button("Clear History") {
+                            self.clearHistory()
+                        }
+                        .buttonStyle(.bordered)
+                        .controlSize(.small)
+                        .disabled(self.alertsData.history.isEmpty)
+                    }
+
+                    let recentHistory = AlertRuleStore.getRecentHistory(limit: 20)
+
+                    if recentHistory.isEmpty {
+                        Text("No alerts triggered yet.")
+                            .font(.footnote)
+                            .foregroundStyle(.tertiary)
+                            .padding(.vertical, RunicSpacing.md)
+                            .frame(maxWidth: .infinity)
+                    } else {
+                        ScrollView {
+                            VStack(spacing: RunicSpacing.xxs) {
+                                ForEach(recentHistory) { entry in
+                                    self.historyRow(entry)
+                                }
+                            }
+                        }
+                        .frame(maxHeight: 200)
+                    }
+                }
+            }
+        }
+        .sheet(isPresented: self.$showingAddRule) {
+            RuleEditorSheet(
+                rule: nil,
+                onSave: { newRule in
+                    do {
+                        try AlertRuleStore.addRule(newRule)
+                        self.alertsData = AlertRuleStore.load()
+                    } catch {
+                        print("Failed to add rule: \(error)")
+                    }
+                }
+            )
+        }
+        .sheet(item: self.$editingRule) { rule in
+            RuleEditorSheet(
+                rule: rule,
+                onSave: { updatedRule in
+                    do {
+                        try AlertRuleStore.updateRule(updatedRule)
+                        self.alertsData = AlertRuleStore.load()
+                    } catch {
+                        print("Failed to update rule: \(error)")
+                    }
+                }
+            )
+        }
+    }
+
+    private func ruleRow(_ rule: AlertRuleStore.AlertRule) -> some View {
+        HStack(spacing: RunicSpacing.sm) {
+            Toggle("", isOn: Binding(
+                get: { rule.enabled },
+                set: { enabled in
+                    var updatedRule = rule
+                    updatedRule.enabled = enabled
+                    try? AlertRuleStore.updateRule(updatedRule)
+                    self.alertsData = AlertRuleStore.load()
+                }
+            ))
+            .toggleStyle(.switch)
+            .controlSize(.small)
+
+            VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
+                HStack(spacing: RunicSpacing.xs) {
+                    Text(self.alertTypeLabel(rule.type))
+                        .font(.body)
+
+                    self.severityBadge(rule.severity)
+                }
+
+                Text("Threshold: \(Int(rule.threshold))%")
+                    .font(.footnote)
+                    .foregroundStyle(.secondary)
+            }
+
+            Spacer()
+
+            HStack(spacing: 4) {
+                Button {
+                    self.editingRule = rule
+                } label: {
+                    Image(systemName: "pencil")
+                }
+                .buttonStyle(.borderless)
+                .controlSize(.small)
+
+                Button {
+                    self.deleteRule(rule)
+                } label: {
+                    Image(systemName: "trash")
+                }
+                .buttonStyle(.borderless)
+                .controlSize(.small)
+                .foregroundStyle(.red)
+            }
+        }
+        .padding(RunicSpacing.xs)
+        .background(Color(nsColor: .controlBackgroundColor))
+        .cornerRadius(RunicCornerRadius.sm)
+    }
+
+    private func historyRow(_ entry: AlertRuleStore.AlertHistoryEntry) -> some View {
+        HStack(spacing: RunicSpacing.sm) {
+            self.severityBadge(entry.severity)
+
+            VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
+                Text(entry.message)
+                    .font(.footnote)
+                    .lineLimit(2)
+
+                Text(self.relativeTime(entry.triggeredAt))
+                    .font(.caption2)
+                    .foregroundStyle(.tertiary)
+            }
+
+            Spacer()
+
+            if !entry.acknowledged {
+                Button("Ack") {
+                    try? AlertRuleStore.acknowledgeAlert(id: entry.id)
+                    self.alertsData = AlertRuleStore.load()
+                }
+                .buttonStyle(.borderless)
+                .controlSize(.mini)
+                .foregroundStyle(.blue)
+            }
+        }
+        .padding(RunicSpacing.xs)
+        .background(Color(nsColor: .controlBackgroundColor).opacity(entry.acknowledged ? 0.5 : 1.0))
+        .cornerRadius(RunicCornerRadius.sm)
+    }
+
+    private func severityBadge(_ severity: AlertRuleStore.AlertSeverity) -> some View {
+        let color: Color = {
+            switch severity {
+            case .info: return .blue
+            case .warning: return .orange
+            case .critical: return .red
+            }
+        }()
+
+        return Text(severity.rawValue.uppercased())
+            .font(.caption2.weight(.semibold))
+            .padding(.horizontal, RunicSpacing.xs)
+            .padding(.vertical, RunicSpacing.xxs)
+            .background(color.opacity(0.2))
+            .foregroundStyle(color)
+            .cornerRadius(RunicCornerRadius.xs)
+    }
+
+    private func alertTypeLabel(_ type: AlertRuleStore.AlertType) -> String {
+        switch type {
+        case .projectBudget: return "Project Budget"
+        case .usageVelocity: return "Usage Velocity"
+        case .costAnomaly: return "Cost Anomaly"
+        case .quotaThreshold: return "Quota Threshold"
+        }
+    }
+
+    private func relativeTime(_ date: Date) -> String {
+        let formatter = RelativeDateTimeFormatter()
+        formatter.unitsStyle = .abbreviated
+        return formatter.localizedString(for: date, relativeTo: Date())
+    }
+
+    private func deleteRule(_ rule: AlertRuleStore.AlertRule) {
+        try? AlertRuleStore.removeRule(id: rule.id)
+        self.alertsData = AlertRuleStore.load()
+    }
+
+    private func clearHistory() {
+        var data = self.alertsData
+        data.history = []
+        try? AlertRuleStore.save(data)
+        self.alertsData = AlertRuleStore.load()
+    }
+
+    private func testWebhook() {
+        guard !self.defaultWebhookURL.isEmpty else { return }
+
+        // Simulate webhook test
+        Task {
+            self.showingTestResult = "Testing..."
+            try? await Task.sleep(nanoseconds: 1_000_000_000)
+            self.showingTestResult = "Success: 200 OK"
+
+            try? await Task.sleep(nanoseconds: 3_000_000_000)
+            self.showingTestResult = nil
+        }
+    }
+}
+
+// MARK: - Rule Editor Sheet
+
+@MainActor
+private struct RuleEditorSheet: View {
+    @Environment(\.dismiss) private var dismiss
+
+    let rule: AlertRuleStore.AlertRule?
+    let onSave: (AlertRuleStore.AlertRule) -> Void
+
+    @State private var alertType: AlertRuleStore.AlertType
+    @State private var threshold: Double
+    @State private var severity: AlertRuleStore.AlertSeverity
+    @State private var webhookURL: String
+    @State private var notifyWebhook: Bool
+
+    init(rule: AlertRuleStore.AlertRule?, onSave: @escaping (AlertRuleStore.AlertRule) -> Void) {
+        self.rule = rule
+        self.onSave = onSave
+
+        self._alertType = State(initialValue: rule?.type ?? .projectBudget)
+        self._threshold = State(initialValue: rule?.threshold ?? 80.0)
+        self._severity = State(initialValue: rule?.severity ?? .warning)
+        self._webhookURL = State(initialValue: rule?.webhookURL ?? "")
+        self._notifyWebhook = State(initialValue: rule?.notifyWebhook ?? false)
+    }
+
+    var body: some View {
+        VStack(spacing: RunicSpacing.lg) {
+            Text(self.rule == nil ? "Add Alert Rule" : "Edit Alert Rule")
+                .font(.headline)
+
+            Form {
+                Picker("Alert Type", selection: self.$alertType) {
+                    Text("Project Budget").tag(AlertRuleStore.AlertType.projectBudget)
+                    Text("Usage Velocity").tag(AlertRuleStore.AlertType.usageVelocity)
+                    Text("Cost Anomaly").tag(AlertRuleStore.AlertType.costAnomaly)
+                    Text("Quota Threshold").tag(AlertRuleStore.AlertType.quotaThreshold)
+                }
+
+                VStack(alignment: .leading, spacing: 4) {
+                    Text("Threshold: \(Int(self.threshold))%")
+                    Slider(value: self.$threshold, in: 0...100, step: 5)
+                }
+
+                Picker("Severity", selection: self.$severity) {
+                    Text("Info").tag(AlertRuleStore.AlertSeverity.info)
+                    Text("Warning").tag(AlertRuleStore.AlertSeverity.warning)
+                    Text("Critical").tag(AlertRuleStore.AlertSeverity.critical)
+                }
+
+                Toggle("Enable webhook notifications", isOn: self.$notifyWebhook)
+
+                if self.notifyWebhook {
+                    TextField("Webhook URL", text: self.$webhookURL)
+                }
+            }
+            .padding()
+
+            HStack {
+                Button("Cancel") {
+                    self.dismiss()
+                }
+                .keyboardShortcut(.cancelAction)
+
+                Button("Save") {
+                    let newRule = AlertRuleStore.AlertRule(
+                        id: self.rule?.id ?? UUID().uuidString,
+                        type: self.alertType,
+                        threshold: self.threshold,
+                        severity: self.severity,
+                        notifyWebhook: self.notifyWebhook,
+                        webhookURL: self.webhookURL.isEmpty ? nil : self.webhookURL,
+                        createdAt: self.rule?.createdAt ?? Date()
+                    )
+                    self.onSave(newRule)
+                    self.dismiss()
+                }
+                .keyboardShortcut(.defaultAction)
+            }
+        }
+        .padding(RunicSpacing.lg)
+        .frame(width: 400)
+    }
+}