diff --git a/Sources/MacClean/App/MacCleanApp.swift b/Sources/MacClean/App/MacCleanApp.swift index 2ea6956..f0eb243 100644 --- a/Sources/MacClean/App/MacCleanApp.swift +++ b/Sources/MacClean/App/MacCleanApp.swift @@ -6,6 +6,8 @@ struct MacCleanApp: App { @NSApplicationDelegateAdaptor(AppDelegate.self) var appDelegate @State private var appState = AppState() @AppStorage("hasCompletedOnboarding") private var hasCompletedOnboarding = false + @AppStorage("showMenuBarWidget") private var showMenuBarWidget = true + @AppStorage("menuBarFirstLaunchDone") private var menuBarFirstLaunchDone = false @State private var showOnboarding = false var body: some Scene { @@ -21,10 +23,30 @@ struct MacCleanApp: App { showOnboarding = true hasCompletedOnboarding = true } + syncMenuBarOnLaunch() } } .windowStyle(.titleBar) .defaultSize(width: 960, height: 620) + + Settings { + SettingsView() + } + } + + /// First-launch default: ON (per product decision). On every launch + /// we re-sync the SMAppService state with the preference so the + /// truth of "is the helper actually running" matches the toggle — + /// macOS occasionally drops registrations after updates, especially + /// when the helper bundle path changes (which it doesn't here, but + /// re-registering is cheap and idempotent). + private func syncMenuBarOnLaunch() { + if !menuBarFirstLaunchDone { + menuBarFirstLaunchDone = true + // showMenuBarWidget already defaults to true; setEnabled is + // idempotent if already registered. + } + MenuBarLauncher.shared.setEnabled(showMenuBarWidget) } } diff --git a/Sources/MacClean/Services/MenuBarLauncher.swift b/Sources/MacClean/Services/MenuBarLauncher.swift new file mode 100644 index 0000000..22a2d91 --- /dev/null +++ b/Sources/MacClean/Services/MenuBarLauncher.swift @@ -0,0 +1,138 @@ +import Foundation +import AppKit +import ServiceManagement +import MacCleanKit + +/// Registers / unregisters the menu bar widget as a login item via +/// `SMAppService.loginItem(identifier:)`. The identifier is the bundle id +/// of the helper app embedded at +/// `Mac Clean.app/Contents/Library/LoginItems/MacCleanMenu.app/`. macOS +/// looks at that exact path to find the helper, so the bundling in +/// `scripts/build-dmg.sh` must match. +/// +/// On registration the system launches the helper immediately (no need +/// to call NSWorkspace.open). On unregister the helper is also stopped. +/// State is queryable via `status` so the Settings toggle can reflect +/// the truth of "is the widget actually running right now." +@MainActor +@Observable +public final class MenuBarLauncher { + public enum LauncherError: Error, LocalizedError { + case registrationFailed(String) + case unregisterFailed(String) + + public var errorDescription: String? { + switch self { + case .registrationFailed(let msg): + return "Couldn't enable the menu bar widget: \(msg)" + case .unregisterFailed(let msg): + return "Couldn't disable the menu bar widget: \(msg)" + } + } + } + + public static let shared = MenuBarLauncher() + + public private(set) var lastError: LauncherError? + + private let service = SMAppService.loginItem(identifier: MCConstants.menuBundleIdentifier) + + public var isRegistered: Bool { + service.status == .enabled + } + + public var status: SMAppService.Status { + service.status + } + + private init() {} + + public func register() throws { + do { + try service.register() + lastError = nil + } catch { + let wrapped = LauncherError.registrationFailed(error.localizedDescription) + lastError = wrapped + throw wrapped + } + } + + public func unregister() throws { + do { + try service.unregister() + lastError = nil + } catch { + let wrapped = LauncherError.unregisterFailed(error.localizedDescription) + lastError = wrapped + throw wrapped + } + } + + /// Best-effort enable; swallows errors so app launch can't be + /// blocked by a Settings-level "show in menu bar" preference flip + /// going sideways. The error surfaces via `lastError` and the + /// Settings UI can prompt the user to retry. + /// + /// Two-step on enable: + /// 1. SMAppService.register() — auto-start at login (the "real" + /// reason for the API). + /// 2. NSWorkspace.openApplication() — launch the helper NOW. + /// + /// Step 2 exists because SMAppService is finicky with ad-hoc + /// signed builds (the path Homebrew users get). It can return + /// `.enabled` from `register()` without macOS actually launching + /// the helper — the system intends to launch it at next login + /// but won't kick it off in the current session. We want the + /// widget visible the moment the toggle flips, so we kick it + /// directly via NSWorkspace. Idempotent: skips if already running. + public func setEnabled(_ enabled: Bool) { + if enabled { + try? register() + launchHelperIfNotRunning() + } else { + try? unregister() + terminateRunningHelper() + } + } + + /// Path to the bundled `MacCleanMenu.app` helper. Returns `nil` + /// when running under `swift run` (no .app wrapper around us), + /// which is fine — dev workflow is `swift run MacCleanMenu` + /// directly. + public func helperAppURL() -> URL? { + let helper = Bundle.main.bundleURL + .appending(path: "Contents") + .appending(path: "Library") + .appending(path: "LoginItems") + .appending(path: "MacCleanMenu.app") + guard FileManager.default.fileExists(atPath: helper.path) else { return nil } + return helper + } + + private func isHelperRunning() -> Bool { + NSWorkspace.shared.runningApplications.contains { + $0.bundleIdentifier == MCConstants.menuBundleIdentifier + } + } + + private func launchHelperIfNotRunning() { + guard !isHelperRunning(), let url = helperAppURL() else { return } + let config = NSWorkspace.OpenConfiguration() + config.activates = false // Don't steal focus from the main app + config.hides = false + NSWorkspace.shared.openApplication(at: url, configuration: config) { [weak self] _, error in + guard let self, let error else { return } + Task { @MainActor in + self.lastError = .registrationFailed(error.localizedDescription) + } + } + } + + private func terminateRunningHelper() { + for app in NSWorkspace.shared.runningApplications + where app.bundleIdentifier == MCConstants.menuBundleIdentifier { + app.terminate() + } + } +} diff --git a/Sources/MacClean/Views/Protection/MalwareView.swift b/Sources/MacClean/Views/Protection/MalwareView.swift index 96e005a..2959f62 100644 --- a/Sources/MacClean/Views/Protection/MalwareView.swift +++ b/Sources/MacClean/Views/Protection/MalwareView.swift @@ -78,6 +78,22 @@ struct MalwareView: View { for r in results { selectedItems.formUnion(r.items.map(\.url)) } isScanning = false scanComplete = true + + // Surface scan outcome to the menu bar widget. The widget + // reads SharedAppState every poll and shows the shield + // glyph color (green = clean recent, yellow = stale, + // red = threats) plus a "Last scan / X threats" card. + let depthLabel: String + switch scanDepth { + case .quick: depthLabel = "quick" + case .balanced: depthLabel = "balanced" + case .deep: depthLabel = "deep" + } + SharedAppState.protectionStatus = SharedAppState.ProtectionStatus( + lastScanDate: Date(), + threatsFound: results.reduce(0) { $0 + $1.items.count }, + scanDepth: depthLabel + ) } } diff --git a/Sources/MacClean/Views/Settings/SettingsView.swift b/Sources/MacClean/Views/Settings/SettingsView.swift new file mode 100644 index 0000000..d5486a8 --- /dev/null +++ b/Sources/MacClean/Views/Settings/SettingsView.swift @@ -0,0 +1,82 @@ +import SwiftUI +import ServiceManagement +import MacCleanKit + +struct SettingsView: View { + @AppStorage("showMenuBarWidget") private var showMenuBarWidget = true + @State private var launcher = MenuBarLauncher.shared + @State private var refreshTick = 0 + + var body: some View { + Form { + Section { + Toggle(isOn: $showMenuBarWidget) { + VStack(alignment: .leading, spacing: 2) { + Text("Show Mac Clean in the menu bar") + Text("Live CPU, memory, disk, battery, and network at the top of your screen. Click to expand the popover.") + .font(.caption) + .foregroundStyle(.secondary) + } + } + .onChange(of: showMenuBarWidget) { _, newValue in + launcher.setEnabled(newValue) + refreshTick &+= 1 + } + + statusRow + if let err = launcher.lastError { + Label(err.localizedDescription, systemImage: "exclamationmark.triangle.fill") + .foregroundStyle(.orange) + .font(.caption) + } + } header: { + Text("Menu Bar") + } + } + .formStyle(.grouped) + .frame(width: 480, height: 240) + .id(refreshTick) + } + + @ViewBuilder + private var statusRow: some View { + HStack { + Image(systemName: statusGlyph) + .foregroundStyle(statusColor) + Text("Widget status:") + .foregroundStyle(.secondary) + Text(statusText) + .font(.system(.body, design: .monospaced)) + Spacer() + } + .font(.caption) + } + + private var statusGlyph: String { + switch launcher.status { + case .enabled: return "checkmark.circle.fill" + case .notRegistered: return "minus.circle" + case .notFound: return "questionmark.circle" + case .requiresApproval: return "exclamationmark.triangle.fill" + @unknown default: return "questionmark.circle" + } + } + + private var statusColor: Color { + switch launcher.status { + case .enabled: return .green + case .requiresApproval: return .orange + default: return .secondary + } + } + + private var statusText: String { + switch launcher.status { + case .enabled: return "running" + case .notRegistered: return "not registered" + case .notFound: return "helper not found in bundle" + case .requiresApproval: return "needs approval in System Settings → Login Items" + @unknown default: return "unknown" + } + } +} diff --git a/Sources/MacClean/Views/Shared/OnboardingView.swift b/Sources/MacClean/Views/Shared/OnboardingView.swift index 64c8867..6c655db 100644 --- a/Sources/MacClean/Views/Shared/OnboardingView.swift +++ b/Sources/MacClean/Views/Shared/OnboardingView.swift @@ -61,7 +61,12 @@ struct OnboardingView: View { } .padding(24) } - .frame(width: 600, height: 450) + // Was 600x450; the FDA step's full content (icon + title + body + // + 4 numbered steps + "Open System Settings" button) exceeded + // that and clipped the Back/Next buttons at the bottom of the + // sheet on real installs. 620 height gives every step room + // without becoming an empty-looking sheet on shorter steps. + .frame(width: 600, height: 620) } private var welcomeStep: some View { diff --git a/Sources/MacClean/Views/Sidebar/SidebarView.swift b/Sources/MacClean/Views/Sidebar/SidebarView.swift index 65203b6..2a7a35f 100644 --- a/Sources/MacClean/Views/Sidebar/SidebarView.swift +++ b/Sources/MacClean/Views/Sidebar/SidebarView.swift @@ -88,31 +88,70 @@ public enum SidebarSection: String, CaseIterable, Identifiable { public struct SidebarView: View { @Binding var selection: SidebarItem? + @AppStorage("showMenuBarWidget") private var showMenuBarWidget = true + @State private var launcher = MenuBarLauncher.shared public init(selection: Binding) { self._selection = selection } public var body: some View { - List(selection: $selection) { - ForEach(SidebarSection.allCases) { section in - if section == .main { - ForEach(section.items) { item in - sidebarRow(item) - } - } else { - Section(section.rawValue) { + VStack(spacing: 0) { + List(selection: $selection) { + ForEach(SidebarSection.allCases) { section in + if section == .main { ForEach(section.items) { item in sidebarRow(item) } + } else { + Section(section.rawValue) { + ForEach(section.items) { item in + sidebarRow(item) + } + } } } } + .listStyle(.sidebar) + + Divider().opacity(0.4) + + menuBarFooter } - .listStyle(.sidebar) .frame(minWidth: 180, idealWidth: 200) } + /// Always-visible footer at the bottom of the sidebar with the + /// menu bar widget toggle. ⌘, Settings has the same control plus + /// a status diagnostic row; this one is the discoverable entry + /// point for users who haven't learned the keyboard shortcut. + private var menuBarFooter: some View { + HStack(spacing: 8) { + Image(systemName: showMenuBarWidget + ? "menubar.dock.rectangle.badge.record" + : "menubar.dock.rectangle") + .foregroundStyle(showMenuBarWidget ? .green : .secondary) + .font(.system(size: 14)) + VStack(alignment: .leading, spacing: 0) { + Text("Menu Bar Widget") + .font(.system(size: 11, weight: .medium)) + Text(showMenuBarWidget ? "Running" : "Off") + .font(.system(size: 9)) + .foregroundStyle(.secondary) + } + Spacer() + Toggle("", isOn: $showMenuBarWidget) + .toggleStyle(.switch) + .controlSize(.mini) + .labelsHidden() + } + .padding(.horizontal, 12) + .padding(.vertical, 10) + .onChange(of: showMenuBarWidget) { _, newValue in + launcher.setEnabled(newValue) + } + } + private func sidebarRow(_ item: SidebarItem) -> some View { Label { Text(item.rawValue) diff --git a/Sources/MacCleanKit/Constants.swift b/Sources/MacCleanKit/Constants.swift index 4fc502b..b6fca00 100644 --- a/Sources/MacCleanKit/Constants.swift +++ b/Sources/MacCleanKit/Constants.swift @@ -159,5 +159,5 @@ public enum MCConstants { // plugin was tried (commit history) but doesn't work under multi-arch // `swift build --arch arm64 --arch x86_64` because xcbuild doesn't // execute plugins. - public static let appVersion = "1.5.3" + public static let appVersion = "1.6.0" } diff --git a/Sources/MacCleanKit/SharedAppState.swift b/Sources/MacCleanKit/SharedAppState.swift new file mode 100644 index 0000000..f0b52d2 --- /dev/null +++ b/Sources/MacCleanKit/SharedAppState.swift @@ -0,0 +1,112 @@ +import Foundation + +/// Inter-process state shared between the main Mac Clean app and the +/// menu bar widget. We use a named `UserDefaults` suite — both processes +/// open the same suite by name, macOS backs it with a single plist at +/// `~/Library/Preferences/com.macclean.shared.plist`, and writes from +/// one process show up in the other on the next read. +/// +/// App Groups would be the canonical macOS pattern but they require +/// signed/notarized builds with matching team identifiers in the +/// entitlements. Mac Clean ships ad-hoc-signed today (`brew install +/// --cask mac-clean` users get an unsigned DMG with `xattr` stripping); +/// a named suite works without notarization and is good enough for the +/// state we share (small, JSON-serializable, no security-sensitive +/// data). +public enum SharedAppState { + public static let suiteName = "com.macclean.shared" + + public static var defaults: UserDefaults { + UserDefaults(suiteName: suiteName) ?? .standard + } + + // MARK: - Protection status (Phase 2) + + public struct ProtectionStatus: Codable, Sendable, Equatable { + public let lastScanDate: Date + public let threatsFound: Int + public let scanDepth: String + + public init(lastScanDate: Date, threatsFound: Int, scanDepth: String) { + self.lastScanDate = lastScanDate + self.threatsFound = threatsFound + self.scanDepth = scanDepth + } + + /// Stale = last scan was more than 7 days ago. The menu glyph + /// goes yellow at this threshold so users notice they haven't + /// run a malware scan in a while. + public var isStale: Bool { + Date().timeIntervalSince(lastScanDate) > 7 * 24 * 3600 + } + } + + private static let protectionStatusKey = "protectionStatus" + + public static var protectionStatus: ProtectionStatus? { + get { + guard let data = defaults.data(forKey: protectionStatusKey) else { return nil } + return try? JSONDecoder().decode(ProtectionStatus.self, from: data) + } + set { + if let newValue, let data = try? JSONEncoder().encode(newValue) { + defaults.set(data, forKey: protectionStatusKey) + } else { + defaults.removeObject(forKey: protectionStatusKey) + } + } + } + + // MARK: - Tip dismissals (Phase 5) + + /// Tips the user dismissed with "don't show again" — keyed by a + /// stable tip-id string. Re-suggesting an explicitly-dismissed tip + /// is annoying so we suppress them for 30 days. + private static let tipDismissalsKey = "tipDismissals" + + public static func dismissTip(id: String) { + var current = tipDismissals + current[id] = Date() + if let data = try? JSONEncoder().encode(current) { + defaults.set(data, forKey: tipDismissalsKey) + } + } + + public static var tipDismissals: [String: Date] { + guard let data = defaults.data(forKey: tipDismissalsKey) else { return [:] } + return (try? JSONDecoder().decode([String: Date].self, from: data)) ?? [:] + } + + public static func isTipDismissed(id: String, suppressionWindow: TimeInterval = 30 * 24 * 3600) -> Bool { + guard let when = tipDismissals[id] else { return false } + return Date().timeIntervalSince(when) < suppressionWindow + } + + // MARK: - Notification suppression (Phase 4) + + /// One-time notifications (battery health below threshold, etc.) + /// shouldn't re-fire every minute. We record the kind+date here so + /// the threshold watcher can throttle. + private static let notificationLogKey = "notificationLog" + + public static func recordNotification(kind: String) { + var current = notificationLog + current[kind] = Date() + if let data = try? JSONEncoder().encode(current) { + defaults.set(data, forKey: notificationLogKey) + } + } + + public static var notificationLog: [String: Date] { + guard let data = defaults.data(forKey: notificationLogKey) else { return [:] } + return (try? JSONDecoder().decode([String: Date].self, from: data)) ?? [:] + } + + /// `true` if the last notification of this kind fired within the + /// throttle window. Disk-low alerts use a short window (15 min); + /// battery-health/cycle alerts use a long one (7 days). + public static func recentlyNotified(kind: String, throttle: TimeInterval) -> Bool { + guard let when = notificationLog[kind] else { return false } + return Date().timeIntervalSince(when) < throttle + } +} diff --git a/Sources/MacCleanMenu/MacCleanMenuApp.swift b/Sources/MacCleanMenu/MacCleanMenuApp.swift index 8c15d87..b481c1e 100644 --- a/Sources/MacCleanMenu/MacCleanMenuApp.swift +++ b/Sources/MacCleanMenu/MacCleanMenuApp.swift @@ -1,25 +1,73 @@ import SwiftUI +import AppKit import MacCleanKit @main struct MacCleanMenuApp: App { + init() { + // Single-instance enforcement. macOS does NOT auto-deduplicate + // LSUIElement apps by bundle id the way it does for regular apps, + // and we have two launch paths (SMAppService + NSWorkspace). If a + // sibling instance is already running, terminate self immediately + // so the user never sees two icons in the menu bar. + // Only enforce when we have a real bundle id (i.e. running from + // the .app). Under `swift run` the bare executable has no bundle + // id, and matching against other nil-bundle processes would make + // the dev build exit immediately. + if let myBundleID = Bundle.main.bundleIdentifier { + let myPID = ProcessInfo.processInfo.processIdentifier + let duplicate = NSWorkspace.shared.runningApplications.contains { + $0.bundleIdentifier == myBundleID && $0.processIdentifier != myPID + } + if duplicate { exit(0) } + } + } + @State private var statsCollector = SystemStatsCollector() @State private var networkMonitor = NetworkSpeedMonitor() + @State private var devicesCollector = ConnectedDevicesCollector() + @State private var tipsEngine = TipsEngine() + @State private var healthMonitor = HealthMonitor() @State private var stats: SystemStatsCollector.SystemStats? @State private var networkSpeed: NetworkSpeedMonitor.NetworkSpeed? + @State private var devices: ConnectedDevices? + @State private var protection: SharedAppState.ProtectionStatus? + @State private var tips: [TipsEngine.Tip] = [] @State private var pollingTask: Task? + @State private var slowTickCount = 0 + + /// Menu-bar label icon: the Mac Clean vacuum, in color, at 18px. + /// Rendered as a normal (non-template) image so it shows the brand + /// colors instead of being flattened to a monochrome mask. + private static let labelIcon: NSImage = { + let img = VacuumAsset.image.copy() as! NSImage + img.isTemplate = false + img.size = NSSize(width: 18, height: 18) + return img + }() var body: some Scene { MenuBarExtra { - MenuContentView(stats: stats, networkSpeed: networkSpeed) - .onAppear { startPolling() } - .onDisappear { stopPolling() } + MenuContentView( + stats: stats, + networkSpeed: networkSpeed, + devices: devices, + protection: protection, + tips: tips, + onDismissTip: { tipId in + SharedAppState.dismissTip(id: tipId) + tips.removeAll { $0.id == tipId } + } + ) + .onAppear { startPolling() } + .onDisappear { stopPolling() } } label: { HStack(spacing: 4) { - Image(systemName: "leaf.fill") + Image(nsImage: Self.labelIcon) + .renderingMode(.original) if let stats { Text(FileSizeFormatter.format(stats.diskFree)) - .font(.system(size: 11, design: .monospaced)) + .font(.system(size: 11, weight: .medium, design: .monospaced)) } } } @@ -34,6 +82,13 @@ struct MacCleanMenuApp: App { let n = await networkMonitor.measure() stats = s networkSpeed = n + protection = SharedAppState.protectionStatus + slowTickCount += 1 + if slowTickCount % 10 == 1 { + devices = await devicesCollector.collect() + tips = await tipsEngine.generateTips() + } + await healthMonitor.evaluate(stats: s) try? await Task.sleep(for: .seconds(3)) } } @@ -45,162 +100,342 @@ struct MacCleanMenuApp: App { } } +// MARK: - Palette + +enum MenuPalette { + static let bgTop = Color(red: 0.33, green: 0.18, blue: 0.55) + static let bgBottom = Color(red: 0.13, green: 0.08, blue: 0.28) + static let card = Color(red: 0.10, green: 0.07, blue: 0.22) + static let teal = Color(red: 0.40, green: 0.85, blue: 0.82) + static let yellow = Color(red: 0.98, green: 0.82, blue: 0.30) + static let green = Color(red: 0.24, green: 0.80, blue: 0.47) + static let red = Color(red: 0.93, green: 0.33, blue: 0.34) + static let textPrimary = Color.white + static let textSecondary = Color.white.opacity(0.58) + + static func barColor(_ v: Double) -> Color { + if v > 0.85 { return Color(red: 0.98, green: 0.42, blue: 0.45) } // soft red + if v > 0.65 { return yellow } + return teal + } +} + +// MARK: - Popover + struct MenuContentView: View { let stats: SystemStatsCollector.SystemStats? let networkSpeed: NetworkSpeedMonitor.NetworkSpeed? + let devices: ConnectedDevices? + let protection: SharedAppState.ProtectionStatus? + let tips: [TipsEngine.Tip] + let onDismissTip: (String) -> Void var body: some View { - VStack(spacing: 12) { - HStack { - Image(systemName: "leaf.fill") - .foregroundStyle(.green) + ZStack { + LinearGradient(colors: [MenuPalette.bgTop, MenuPalette.bgBottom], + startPoint: .topLeading, endPoint: .bottomTrailing) + .ignoresSafeArea() + + VStack(spacing: 12) { + header + if let stats { + statGrid(stats) + networkCard(stats) + if !tips.isEmpty { recommendationsCard } + if let p = protection { protectionCard(p) } + if let d = devices, d.hasAny { devicesCard(d) } + } else { + ProgressView().controlSize(.small).tint(.white) + .frame(height: 100) + } + footer + } + .padding(14) + } + .frame(width: 340) + } + + // MARK: Header + + private var header: some View { + HStack(spacing: 10) { + Image(nsImage: VacuumAsset.image) + .resizable().interpolation(.high) + .frame(width: 30, height: 30) + .clipShape(RoundedRectangle(cornerRadius: 8, style: .continuous)) + VStack(alignment: .leading, spacing: 1) { Text("Mac Clean") - .font(.headline) - Spacer() + .font(.system(size: 15, weight: .bold)) + .foregroundStyle(MenuPalette.textPrimary) + Text("Live system stats") + .font(.system(size: 10)) + .foregroundStyle(MenuPalette.textSecondary) } + Spacer() + } + } - Divider() - - if let stats { - MonitorRow( - icon: "cpu", title: "CPU", - value: String(format: "%.1f%%", stats.cpuUsage * 100), - bar: stats.cpuUsage, color: barColor(stats.cpuUsage) - ) - - MonitorRow( - icon: "memorychip", title: "Memory", - value: "\(FileSizeFormatter.format(stats.memoryUsed)) / \(FileSizeFormatter.format(stats.memoryTotal))", - bar: stats.memoryPressure, color: barColor(stats.memoryPressure) - ) - - let diskUsage = stats.diskTotal > 0 ? Double(stats.diskTotal - stats.diskFree) / Double(stats.diskTotal) : 0 - MonitorRow( - icon: "internaldrive", title: "Disk", - value: "\(FileSizeFormatter.format(stats.diskFree)) free", - bar: diskUsage, color: barColor(diskUsage) - ) - - if let level = stats.batteryLevel { - MonitorRow( - icon: stats.batteryIsCharging ? "battery.100.bolt" : "battery.75", - title: "Battery", - value: String(format: "%.0f%%", level * 100) + (stats.batteryIsCharging ? " Charging" : ""), - bar: level, color: level > 0.2 ? .green : .red - ) - } + // MARK: Stat grid (rings) - // Network speed - if let net = networkSpeed { - HStack(spacing: 16) { - HStack(spacing: 4) { - Image(systemName: "arrow.down") - .font(.system(size: 9)) - .foregroundStyle(.green) - Text(net.formattedIn) - .font(.system(size: 11, design: .monospaced)) - } - HStack(spacing: 4) { - Image(systemName: "arrow.up") - .font(.system(size: 9)) - .foregroundStyle(.blue) - Text(net.formattedOut) - .font(.system(size: 11, design: .monospaced)) + private func statGrid(_ s: SystemStatsCollector.SystemStats) -> some View { + let diskUsed = s.diskTotal > 0 ? Double(s.diskTotal - s.diskFree) / Double(s.diskTotal) : 0 + return LazyVGrid(columns: [GridItem(.flexible(), spacing: 10), GridItem(.flexible(), spacing: 10)], spacing: 10) { + ringCard(icon: "cpu", label: "CPU", + value: s.cpuUsage, center: "\(Int((s.cpuUsage*100).rounded()))%", + sub: nil) + ringCard(icon: "memorychip", label: "Memory", + value: s.memoryPressure, center: "\(Int((s.memoryPressure*100).rounded()))%", + sub: FileSizeFormatter.format(s.memoryUsed)) + ringCard(icon: "internaldrive", label: "Disk", + value: diskUsed, center: "\(Int((diskUsed*100).rounded()))%", + sub: "\(FileSizeFormatter.format(s.diskFree)) free") + if let level = s.batteryLevel { + ringCard(icon: s.batteryIsCharging ? "battery.100.bolt" : "battery.75", + label: s.batteryIsCharging ? "Charging" : "Battery", + value: level, center: "\(Int((level*100).rounded()))%", + sub: nil, forceColor: level > 0.2 ? MenuPalette.teal : Color(red:0.98,green:0.42,blue:0.45)) + } else { + uptimeCard(s) + } + } + } + + private func ringCard(icon: String, label: String, value: Double, center: String, sub: String?, forceColor: Color? = nil) -> some View { + let color = forceColor ?? MenuPalette.barColor(value) + return VStack(spacing: 12) { + statHeader(icon: icon, label: label, tint: color) + RingGauge(value: value, color: color, center: center) + .frame(width: 58, height: 58) + // Always render the subtitle line (a space when empty) so + // every card is the same height and the rings line up. + Text(sub ?? " ") + .font(.system(size: 10, design: .monospaced)) + .foregroundStyle(MenuPalette.textSecondary) + .lineLimit(1) + } + .frame(maxWidth: .infinity, alignment: .top) + .padding(16) + .glassCard() + } + + private func uptimeCard(_ s: SystemStatsCollector.SystemStats) -> some View { + VStack(spacing: 12) { + statHeader(icon: "clock", label: "Uptime", tint: MenuPalette.teal) + Text(formatUptime(s.uptime)) + .font(.system(size: 22, weight: .semibold, design: .rounded)) + .foregroundStyle(.white) + .frame(height: 58) + Text(" ").font(.system(size: 10, design: .monospaced)) + } + .frame(maxWidth: .infinity, alignment: .top) + .padding(16) + .glassCard() + } + + /// Card header: icon + label, centered horizontally above the ring + /// (no Spacer, so the VStack centers the group). + private func statHeader(icon: String, label: String, tint: Color) -> some View { + HStack(spacing: 6) { + Image(systemName: icon).font(.system(size: 11, weight: .semibold)).foregroundStyle(tint) + Text(label).font(.system(size: 12, weight: .semibold)).foregroundStyle(MenuPalette.textPrimary) + } + } + + // MARK: Network strip + + private func networkCard(_ s: SystemStatsCollector.SystemStats) -> some View { + HStack(spacing: 0) { + if let net = networkSpeed { + netCell(icon: "arrow.down", color: MenuPalette.teal, value: net.formattedIn) + divider + netCell(icon: "arrow.up", color: MenuPalette.yellow, value: net.formattedOut) + divider + } + netCell(icon: "clock", color: MenuPalette.textSecondary, value: formatUptime(s.uptime)) + if s.swapUsed > 0 { + divider + netCell(icon: "arrow.triangle.swap", color: MenuPalette.textSecondary, value: FileSizeFormatter.format(s.swapUsed)) + } + } + .padding(.vertical, 9) + .glassCard() + } + + private func netCell(icon: String, color: Color, value: String) -> some View { + HStack(spacing: 4) { + Image(systemName: icon).font(.system(size: 9, weight: .bold)).foregroundStyle(color) + Text(value).font(.system(size: 10, weight: .medium, design: .monospaced)).foregroundStyle(.white.opacity(0.85)) + } + .frame(maxWidth: .infinity) + } + + private var divider: some View { + Rectangle().fill(Color.white.opacity(0.10)).frame(width: 1, height: 18) + } + + // MARK: Recommendations + + private var recommendationsCard: some View { + VStack(alignment: .leading, spacing: 9) { + sectionHeader(icon: "sparkles", title: "Recommendations", tint: MenuPalette.yellow) + ForEach(tips.prefix(3)) { tip in + VStack(alignment: .leading, spacing: 7) { + HStack(alignment: .top, spacing: 8) { + Image(systemName: tip.symbol).font(.system(size: 12)).foregroundStyle(MenuPalette.teal).frame(width: 16) + VStack(alignment: .leading, spacing: 2) { + Text(tip.title).font(.system(size: 11, weight: .semibold)).foregroundStyle(.white).lineLimit(2) + Text(tip.body).font(.system(size: 10)).foregroundStyle(MenuPalette.textSecondary).lineLimit(2) } - Spacer() + Spacer(minLength: 2) + Button { onDismissTip(tip.id) } label: { + Image(systemName: "xmark").font(.system(size: 8, weight: .bold)) + .foregroundStyle(MenuPalette.textSecondary).padding(4) + .background(Color.white.opacity(0.08), in: Circle()) + }.buttonStyle(.plain).help("Dismiss for 30 days") } - .padding(.vertical, 2) + Button { TipAction.open() } label: { + Text(tipCTA(tip)).font(.system(size: 11, weight: .bold)).foregroundStyle(Color(red:0.16,green:0.10,blue:0.30)) + .frame(maxWidth: .infinity).padding(.vertical, 6) + .background(MenuPalette.yellow, in: RoundedRectangle(cornerRadius: 7, style: .continuous)) + }.buttonStyle(.plain) } + } + } + .padding(11) + .glassCard() + } - HStack { - Image(systemName: "clock") - .foregroundStyle(.secondary) - .frame(width: 20) - Text("Uptime") - .foregroundStyle(.secondary) - Spacer() - Text(formatUptime(stats.uptime)) - .font(.system(.caption, design: .monospaced)) - } + private func tipCTA(_ tip: TipsEngine.Tip) -> String { + switch tip.id { + case "trash_large": return "Empty Trash" + case "caches_large": return "Free Up Space" + default: return "Open Mac Clean" + } + } - if stats.swapUsed > 0 { - HStack { - Image(systemName: "arrow.triangle.swap") - .foregroundStyle(.secondary) - .frame(width: 20) - Text("Swap") - .foregroundStyle(.secondary) - Spacer() - Text(FileSizeFormatter.format(stats.swapUsed)) - .font(.system(.caption, design: .monospaced)) - } - } - } else { - ProgressView("Loading...") + // MARK: Protection + + private func protectionCard(_ p: SharedAppState.ProtectionStatus) -> some View { + let tint = p.threatsFound > 0 ? Color(red:0.98,green:0.42,blue:0.45) : (p.isStale ? MenuPalette.yellow : MenuPalette.teal) + return HStack(spacing: 10) { + ZStack { + Circle().fill(tint.opacity(0.18)).frame(width: 30, height: 30) + Image(systemName: p.threatsFound > 0 ? "exclamationmark.shield.fill" : "checkmark.shield.fill") + .font(.system(size: 14, weight: .semibold)).foregroundStyle(tint) + } + VStack(alignment: .leading, spacing: 1) { + Text(p.threatsFound > 0 ? "\(p.threatsFound) threat\(p.threatsFound == 1 ? "" : "s") found" : "Protected") + .font(.system(size: 12, weight: .semibold)).foregroundStyle(.white) + Text("Scanned \(relativeTime(p.lastScanDate)) · \(p.scanDepth)") + .font(.system(size: 10)).foregroundStyle(MenuPalette.textSecondary) } + Spacer() + } + .padding(11).glassCard() + } - Divider() + // MARK: Connected devices - Button("Open Mac Clean") { - if let url = NSWorkspace.shared.urlForApplication(withBundleIdentifier: MCConstants.bundleIdentifier) { - NSWorkspace.shared.openApplication(at: url, configuration: .init()) + private func devicesCard(_ d: ConnectedDevices) -> some View { + VStack(alignment: .leading, spacing: 8) { + sectionHeader(icon: "externaldrive.connected.to.line.below", title: "Connected", tint: MenuPalette.teal) + ForEach(d.externalVolumes) { v in + HStack(spacing: 7) { + Image(systemName: "externaldrive.fill").font(.system(size: 10)).foregroundStyle(MenuPalette.teal.opacity(0.8)) + Text(v.name).font(.system(size: 11)).foregroundStyle(.white).lineLimit(1) + Spacer(minLength: 6) + Text("\(FileSizeFormatter.format(v.freeBytes)) free").font(.system(size: 10, design: .monospaced)).foregroundStyle(MenuPalette.textSecondary) } } - - Button("Quit Monitor") { - NSApplication.shared.terminate(nil) + if d.externalDisplays > 0 { + HStack(spacing: 7) { + Image(systemName: "display").font(.system(size: 10)).foregroundStyle(MenuPalette.teal.opacity(0.8)) + Text("\(d.externalDisplays) external display\(d.externalDisplays == 1 ? "" : "s")").font(.system(size: 11)).foregroundStyle(.white) + Spacer() + } } } - .padding() - .frame(width: 300) + .padding(11).glassCard() } - private func barColor(_ value: Double) -> Color { - if value > 0.85 { return .red } - if value > 0.65 { return .orange } - return .green + // MARK: Footer + + private var footer: some View { + HStack(spacing: 8) { + Button { NSApplication.shared.terminate(nil) } label: { + Image(systemName: "power").font(.system(size: 12, weight: .bold)).foregroundStyle(.white) + .frame(width: 34, height: 32) + .background(MenuPalette.red, in: RoundedRectangle(cornerRadius: 9, style: .continuous)) + }.buttonStyle(.plain).help("Quit Monitor") + + Button { TipAction.open() } label: { + HStack(spacing: 6) { + Image(systemName: "leaf.fill").font(.system(size: 11, weight: .bold)) + Text("Open Mac Clean").font(.system(size: 12, weight: .bold)) + } + .foregroundStyle(.white) + .frame(maxWidth: .infinity).padding(.vertical, 8) + .background(MenuPalette.green, in: RoundedRectangle(cornerRadius: 9, style: .continuous)) + }.buttonStyle(.plain) + } } - private func formatUptime(_ seconds: TimeInterval) -> String { - let hours = Int(seconds) / 3600 - let minutes = (Int(seconds) % 3600) / 60 - if hours > 24 { - return "\(hours / 24)d \(hours % 24)h" + // MARK: Helpers + + private func sectionHeader(icon: String, title: String, tint: Color) -> some View { + HStack(spacing: 7) { + Image(systemName: icon).font(.system(size: 11, weight: .semibold)).foregroundStyle(tint) + Text(title).font(.system(size: 11, weight: .semibold)).foregroundStyle(.white) + Spacer() } - return "\(hours)h \(minutes)m" + } + + private func formatUptime(_ seconds: TimeInterval) -> String { + let h = Int(seconds) / 3600, m = (Int(seconds) % 3600) / 60 + if h > 24 { return "\(h/24)d \(h%24)h" } + return "\(h)h \(m)m" + } + + private func relativeTime(_ date: Date) -> String { + let i = Date().timeIntervalSince(date) + if i < 60 { return "just now" } + if i < 3600 { return "\(Int(i/60)) min ago" } + if i < 86400 { return "\(Int(i/3600)) hr ago" } + return "\(Int(i/86400)) day\(Int(i/86400) == 1 ? "" : "s") ago" } } -struct MonitorRow: View { - let icon: String - let title: String - let value: String - let bar: Double +// MARK: - Ring gauge + +struct RingGauge: View { + let value: Double let color: Color + let center: String var body: some View { - VStack(spacing: 4) { - HStack { - Image(systemName: icon) - .foregroundStyle(.secondary) - .frame(width: 20) - Text(title) - .font(.system(size: 12, weight: .medium)) - Spacer() - Text(value) - .font(.system(size: 11, design: .monospaced)) - .foregroundStyle(.secondary) - } - GeometryReader { geo in - ZStack(alignment: .leading) { - RoundedRectangle(cornerRadius: 2) - .fill(Color.secondary.opacity(0.15)) - RoundedRectangle(cornerRadius: 2) - .fill(color) - .frame(width: geo.size.width * min(max(bar, 0), 1)) - } - } - .frame(height: 4) + ZStack { + Circle().stroke(Color.white.opacity(0.12), lineWidth: 5) + Circle() + .trim(from: 0, to: min(max(value, 0), 1)) + .stroke(color.gradient, style: StrokeStyle(lineWidth: 5, lineCap: .round)) + .rotationEffect(.degrees(-90)) + Text(center).font(.system(size: 13, weight: .bold, design: .rounded)).foregroundStyle(.white) } } } + +// MARK: - Glass card modifier + +private extension View { + func glassCard(cornerRadius: CGFloat = 14) -> some View { + self + .background(MenuPalette.card.opacity(0.45), + in: RoundedRectangle(cornerRadius: cornerRadius, style: .continuous)) + .background(.ultraThinMaterial.opacity(0.30), + in: RoundedRectangle(cornerRadius: cornerRadius, style: .continuous)) + .overlay { + RoundedRectangle(cornerRadius: cornerRadius, style: .continuous) + .strokeBorder(Color.white.opacity(0.08), lineWidth: 0.5) + } + } +} diff --git a/Sources/MacCleanMenu/SystemStats/ConnectedDevicesCollector.swift b/Sources/MacCleanMenu/SystemStats/ConnectedDevicesCollector.swift new file mode 100644 index 0000000..4f1ef27 --- /dev/null +++ b/Sources/MacCleanMenu/SystemStats/ConnectedDevicesCollector.swift @@ -0,0 +1,73 @@ +import Foundation +import AppKit + +public struct ConnectedDevices: Sendable, Equatable { + public let externalVolumes: [ExternalVolume] + public let externalDisplays: Int + + public struct ExternalVolume: Sendable, Equatable, Identifiable { + public let id: String + public let name: String + public let totalBytes: UInt64 + public let freeBytes: UInt64 + } + + public init(externalVolumes: [ExternalVolume], externalDisplays: Int) { + self.externalVolumes = externalVolumes + self.externalDisplays = externalDisplays + } + + public var hasAny: Bool { + !externalVolumes.isEmpty || externalDisplays > 0 + } +} + +public actor ConnectedDevicesCollector { + public init() {} + + public func collect() async -> ConnectedDevices { + let volumes = enumerateExternalVolumes() + // `NSScreen.screens` includes the built-in display, so external + // count = total - 1. Read on @MainActor since NSScreen is main- + // only; the value is small and the hop is cheap. + let displays = await MainActor.run { max(0, NSScreen.screens.count - 1) } + return ConnectedDevices(externalVolumes: volumes, externalDisplays: displays) + } + + private func enumerateExternalVolumes() -> [ConnectedDevices.ExternalVolume] { + let keys: [URLResourceKey] = [ + .volumeIsRemovableKey, + .volumeIsInternalKey, + .volumeNameKey, + .volumeTotalCapacityKey, + .volumeAvailableCapacityKey, + ] + let resourceKeySet = Set(keys) + guard let urls = FileManager.default.mountedVolumeURLs( + includingResourceValuesForKeys: keys, + options: [.skipHiddenVolumes] + ) else { return [] } + + return urls.compactMap { url -> ConnectedDevices.ExternalVolume? in + guard let values = try? url.resourceValues(forKeys: resourceKeySet) else { + return nil + } + // "External" = removable (USB stick) OR not-internal + // (network-mounted, externally-attached). The default + // root volume is internal & non-removable, so we drop it. + let isRemovable = values.volumeIsRemovable ?? false + let isInternal = values.volumeIsInternal ?? true + guard isRemovable || !isInternal else { return nil } + + let name = values.volumeName ?? url.lastPathComponent + let total = UInt64(values.volumeTotalCapacity ?? 0) + let free = UInt64(values.volumeAvailableCapacity ?? 0) + return ConnectedDevices.ExternalVolume( + id: url.path, + name: name, + totalBytes: total, + freeBytes: free + ) + } + } +} diff --git a/Sources/MacCleanMenu/SystemStats/HealthMonitor.swift b/Sources/MacCleanMenu/SystemStats/HealthMonitor.swift new file mode 100644 index 0000000..6b7bd4c --- /dev/null +++ b/Sources/MacCleanMenu/SystemStats/HealthMonitor.swift @@ -0,0 +1,137 @@ +import Foundation +import UserNotifications +import MacCleanKit + +/// Watches the rolling stats stream for crossed thresholds and fires +/// macOS notifications via `UNUserNotificationCenter`. Throttled +/// via `SharedAppState.recentlyNotified` so we don't spam — disk-low +/// re-fires every 15 minutes, battery-health/cycle once a week. +/// +/// Authorization is requested lazily on first notification attempt +/// (not eagerly on app launch — the menu widget shouldn't prompt +/// for permissions before the user has done anything). +public actor HealthMonitor { + public init() {} + + public struct Thresholds: Sendable { + public var minimumDiskFreeBytes: UInt64 = 5 * 1024 * 1024 * 1024 // 5 GB + public var memoryPressureSustained: Double = 0.85 + public var memoryPressureSustainedSamples: Int = 5 // ~15s at 3s poll + public var batteryHealthFloor: Double = 0.80 + public var batteryCyclesCeiling: Int = 1000 + } + + public var thresholds = Thresholds() + + private var memoryPressureSampleStreak = 0 + private var authorizationRequested = false + + /// Called every tick from the polling loop. Compares the latest + /// snapshot to thresholds and fires throttled notifications. + public func evaluate(stats: SystemStatsCollector.SystemStats) async { + await checkLowDisk(stats: stats) + await checkMemoryPressure(stats: stats) + await checkBatteryHealth(stats: stats) + await checkBatteryCycles(stats: stats) + } + + // MARK: - Individual checks + + private func checkLowDisk(stats: SystemStatsCollector.SystemStats) async { + guard stats.diskFree < thresholds.minimumDiskFreeBytes else { return } + // 15 min throttle — disk fills up gradually; one alert every + // quarter hour is plenty. + if SharedAppState.recentlyNotified(kind: "disk_low", throttle: 15 * 60) { return } + await fire( + kind: "disk_low", + title: "Storage critical", + body: "Only \(FileSizeFormatter.format(stats.diskFree)) free on your startup disk. Open Mac Clean to free up space." + ) + } + + private func checkMemoryPressure(stats: SystemStatsCollector.SystemStats) async { + if stats.memoryPressure >= thresholds.memoryPressureSustained { + memoryPressureSampleStreak += 1 + } else { + memoryPressureSampleStreak = 0 + return + } + guard memoryPressureSampleStreak >= thresholds.memoryPressureSustainedSamples else { return } + if SharedAppState.recentlyNotified(kind: "memory_high", throttle: 30 * 60) { return } + // Reset the streak so we don't re-trigger immediately after + // the next sample. + memoryPressureSampleStreak = 0 + await fire( + kind: "memory_high", + title: "Memory pressure high", + body: "Sustained \(Int(stats.memoryPressure * 100))% memory pressure. Mac Clean's Maintenance module can free up RAM." + ) + } + + private func checkBatteryHealth(stats: SystemStatsCollector.SystemStats) async { + guard let health = stats.batteryHealth, health < thresholds.batteryHealthFloor else { return } + // Battery health degrades very slowly — once a week is more + // than enough. + if SharedAppState.recentlyNotified(kind: "battery_health", throttle: 7 * 24 * 3600) { return } + await fire( + kind: "battery_health", + title: "Battery health below \(Int(thresholds.batteryHealthFloor * 100))%", + body: "Your battery's maximum capacity is now \(Int(health * 100))%. Consider scheduling a service appointment." + ) + } + + private func checkBatteryCycles(stats: SystemStatsCollector.SystemStats) async { + guard let cycles = stats.batteryCycleCount, cycles > thresholds.batteryCyclesCeiling else { return } + if SharedAppState.recentlyNotified(kind: "battery_cycles", throttle: 7 * 24 * 3600) { return } + await fire( + kind: "battery_cycles", + title: "Battery cycle count high", + body: "Your battery has been through \(cycles) cycles. Apple rates most batteries for ~1000 before noticeable wear." + ) + } + + // MARK: - Notification plumbing + + private func fire(kind: String, title: String, body: String) async { + let granted = await ensureAuthorization() + guard granted else { return } + + let content = UNMutableNotificationContent() + content.title = title + content.body = body + content.sound = .default + + let request = UNNotificationRequest( + identifier: "macclean.health.\(kind).\(UUID().uuidString)", + content: content, + trigger: nil + ) + do { + try await UNUserNotificationCenter.current().add(request) + SharedAppState.recordNotification(kind: kind) + } catch { + // Swallow — a failed notification is recoverable; the + // throttle log isn't updated, so the next eligible tick + // tries again. + } + } + + private func ensureAuthorization() async -> Bool { + if authorizationRequested { + return await Self.isAuthorized() + } + authorizationRequested = true + return (try? await UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound])) ?? false + } + + /// `UNNotificationSettings` is non-Sendable, so awaiting it from + /// inside the actor fails Swift 6 strict-concurrency. Hop through + /// a static (actor-unisolated) helper: the settings object is + /// created and consumed in the nonisolated context, and only the + /// Sendable `Bool` crosses back to the actor. + private static func isAuthorized() async -> Bool { + let settings = await UNUserNotificationCenter.current().notificationSettings() + return settings.authorizationStatus == .authorized + || settings.authorizationStatus == .provisional + } +} diff --git a/Sources/MacCleanMenu/SystemStats/TipsEngine.swift b/Sources/MacCleanMenu/SystemStats/TipsEngine.swift new file mode 100644 index 0000000..5376665 --- /dev/null +++ b/Sources/MacCleanMenu/SystemStats/TipsEngine.swift @@ -0,0 +1,117 @@ +import Foundation +import AppKit +import MacCleanKit + +/// Builds a short list of actionable suggestions for the popover. +/// Each tip has a stable id so the user can dismiss it for 30 days +/// (`SharedAppState.dismissTip`); the engine respects those dismissals. +/// +/// MVP tips: +/// * `trash_large` — Trash > 1 GB +/// * `caches_large` — User caches > 2 GB +/// +/// Future tips (separate phases): unused-apps, TM snapshot bloat, +/// outdated app updates. +public actor TipsEngine { + public struct Tip: Sendable, Identifiable, Equatable { + public let id: String + public let title: String + public let body: String + /// Bytes the tip estimates the user could reclaim. Used for + /// sorting (biggest payoff first) and the headline number. + public let estimatedSavings: UInt64 + public let symbol: String + + public init(id: String, title: String, body: String, estimatedSavings: UInt64, symbol: String) { + self.id = id + self.title = title + self.body = body + self.estimatedSavings = estimatedSavings + self.symbol = symbol + } + } + + public init() {} + + public func generateTips() async -> [Tip] { + async let trash = trashTip() + async let caches = cachesTip() + + var tips: [Tip] = [] + if let t = await trash { tips.append(t) } + if let c = await caches { tips.append(c) } + + return tips + .filter { !SharedAppState.isTipDismissed(id: $0.id) } + .sorted { $0.estimatedSavings > $1.estimatedSavings } + } + + private static let trashSizeMinimum: UInt64 = 1 * 1024 * 1024 * 1024 // 1 GB + private static let cachesSizeMinimum: UInt64 = 2 * 1024 * 1024 * 1024 // 2 GB + + private func trashTip() async -> Tip? { + let size = await directorySize(MCConstants.userTrash) + guard size >= Self.trashSizeMinimum else { return nil } + return Tip( + id: "trash_large", + title: "Trash is taking \(FileSizeFormatter.format(size))", + body: "Empty the Trash from Mac Clean to reclaim space.", + estimatedSavings: size, + symbol: "trash" + ) + } + + private func cachesTip() async -> Tip? { + let size = await directorySize(MCConstants.userCaches) + guard size >= Self.cachesSizeMinimum else { return nil } + return Tip( + id: "caches_large", + title: "User caches grew to \(FileSizeFormatter.format(size))", + body: "Run System Junk in Mac Clean to clear regenerable cache files.", + estimatedSavings: size, + symbol: "internaldrive" + ) + } + + /// Lightweight directory size — single `du -sk` equivalent via + /// FileManager. The user shouldn't pay a 30s scan for a tip; cap + /// to a shallow walk and fall back to 0 on errors. + private func directorySize(_ url: URL) async -> UInt64 { + let path = url.path(percentEncoded: false) + guard FileManager.default.fileExists(atPath: path) else { return 0 } + let enumerator = FileManager.default.enumerator( + at: url, + includingPropertiesForKeys: [.totalFileAllocatedSizeKey, .isDirectoryKey], + options: [.skipsHiddenFiles], + errorHandler: nil + ) + var total: UInt64 = 0 + var sampled = 0 + let cap = 50_000 // hard cap so a runaway dir can't stall the popover + while let next = enumerator?.nextObject() as? URL { + sampled += 1 + if sampled > cap { break } + if let values = try? next.resourceValues(forKeys: [.totalFileAllocatedSizeKey, .isDirectoryKey]), + values.isDirectory == false, + let size = values.totalFileAllocatedSize { + total += UInt64(size) + } + // Yield occasionally so we don't hog the actor. + if sampled % 5_000 == 0 { await Task.yield() } + } + return total + } +} + +/// Click-to-act on a tip. For MVP we just bring the main Mac Clean app +/// to the foreground — the user navigates to the relevant module from +/// the sidebar. Future enhancement: URL-scheme deep links direct to +/// `macclean://module/system-junk`. +public enum TipAction { + @MainActor + public static func open() { + if let url = NSWorkspace.shared.urlForApplication(withBundleIdentifier: MCConstants.bundleIdentifier) { + NSWorkspace.shared.openApplication(at: url, configuration: .init()) + } + } +} diff --git a/Sources/MacCleanMenu/VacuumAsset.swift b/Sources/MacCleanMenu/VacuumAsset.swift new file mode 100644 index 0000000..d17042b --- /dev/null +++ b/Sources/MacCleanMenu/VacuumAsset.swift @@ -0,0 +1,21 @@ +import AppKit + +/// The Mac Clean **menu-bar widget** icon: the user-supplied vacuum +/// (Downloads/vacuum.png), cropped to its content and rendered white on +/// the brand purple-gradient squircle (fills ~82% of the tile so it +/// reads at 18px). Embedded as base64 (128px) so it loads identically +/// under `swift run` and inside the DMG. +/// +/// ONLY the menu-bar widget icon. The main app icon +/// (Resources/AppIcon.icns) is intentionally left untouched. +enum VacuumAsset { + // NSImage isn't Sendable; this is built once and only read, so it's + // safe to mark unchecked for Swift 6 strict concurrency. + nonisolated(unsafe) static let image: NSImage = { + let b64 = "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" + guard let data = Data(base64Encoded: b64), let img = NSImage(data: data) else { + return NSImage(systemSymbolName: "wand.and.sparkles", accessibilityDescription: "Mac Clean") ?? NSImage() + } + return img + }() +} diff --git a/Tests/MacCleanKitTests/SharedAppStateTests.swift b/Tests/MacCleanKitTests/SharedAppStateTests.swift new file mode 100644 index 0000000..b08be30 --- /dev/null +++ b/Tests/MacCleanKitTests/SharedAppStateTests.swift @@ -0,0 +1,46 @@ +import XCTest +@testable import MacCleanKit + +final class SharedAppStateTests: XCTestCase { + + func testProtectionStatusFreshIsNotStale() { + let p = SharedAppState.ProtectionStatus( + lastScanDate: Date(), + threatsFound: 0, + scanDepth: "balanced" + ) + XCTAssertFalse(p.isStale, "A scan that just happened shouldn't be stale") + } + + func testProtectionStatusOneWeekOldIsStale() { + let p = SharedAppState.ProtectionStatus( + lastScanDate: Date().addingTimeInterval(-8 * 24 * 3600), + threatsFound: 0, + scanDepth: "balanced" + ) + XCTAssertTrue(p.isStale, "A scan from 8 days ago crosses the 7-day staleness threshold") + } + + func testProtectionStatusBoundaryNotStale() { + // Exactly the 7-day window edge — should not flip to stale yet. + // We subtract slightly less than 7 days to be safe against + // timing flake. + let p = SharedAppState.ProtectionStatus( + lastScanDate: Date().addingTimeInterval(-6 * 24 * 3600 - 23 * 3600), + threatsFound: 0, + scanDepth: "balanced" + ) + XCTAssertFalse(p.isStale) + } + + func testProtectionStatusIsCodable() throws { + let original = SharedAppState.ProtectionStatus( + lastScanDate: Date(timeIntervalSince1970: 1_700_000_000), + threatsFound: 5, + scanDepth: "deep" + ) + let data = try JSONEncoder().encode(original) + let decoded = try JSONDecoder().decode(SharedAppState.ProtectionStatus.self, from: data) + XCTAssertEqual(decoded, original) + } +} diff --git a/Tests/MacCleanTests/MenuBarLauncherTests.swift b/Tests/MacCleanTests/MenuBarLauncherTests.swift new file mode 100644 index 0000000..c4ac7ef --- /dev/null +++ b/Tests/MacCleanTests/MenuBarLauncherTests.swift @@ -0,0 +1,56 @@ +import XCTest +import ServiceManagement +@testable import MacClean +import MacCleanKit + +/// Tests for the `MenuBarLauncher` SMAppService wrapper. +/// +/// These tests deliberately **do not** call `register()` / `unregister()` +/// / `setEnabled()` — those mutate the real launchd database and would +/// plant a login item on every test run. See the comparable LaunchAgent +/// guidance: tests must not pollute the user's macOS state. The surface +/// we can safely exercise is the read-only side: identity, initial +/// state, status readability. +@MainActor +final class MenuBarLauncherTests: XCTestCase { + + func testSharedInstanceIsSingleton() { + let a = MenuBarLauncher.shared + let b = MenuBarLauncher.shared + XCTAssertTrue(a === b, "shared should return the same instance every time") + } + + func testInitialLastErrorIsNil() { + // Fresh state from the singleton — no prior register attempt + // should have left an error behind. + XCTAssertNil(MenuBarLauncher.shared.lastError) + } + + func testStatusIsReadableWithoutCrashing() { + // The actual returned status depends on whether the helper is + // bundled in the test runtime (it isn't, under `swift test`), + // but reading the value must not crash and must yield a known + // SMAppService.Status case. + let status = MenuBarLauncher.shared.status + let knownCases: [SMAppService.Status] = [ + .notRegistered, .enabled, .requiresApproval, .notFound, + ] + XCTAssertTrue(knownCases.contains(status), + "status returned an unexpected case: \(status)") + } + + func testIsRegisteredMatchesStatus() { + // isRegistered is the boolean projection of `status == .enabled`. + // Whichever side launchd reports, the two must agree. + let launcher = MenuBarLauncher.shared + XCTAssertEqual(launcher.isRegistered, launcher.status == .enabled) + } + + func testBundleIdentifierIsTheConstant() { + // The Service Management identifier must equal the constant the + // build script writes into MacCleanMenu.app's Info.plist + // (`com.macclean.menu`). If these ever diverge, register() fails + // silently with `.notFound`. Catch the drift here. + XCTAssertEqual(MCConstants.menuBundleIdentifier, "com.macclean.menu") + } +} diff --git a/VERSION b/VERSION index 8af85be..dc1e644 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.5.3 +1.6.0 diff --git a/scripts/build-dmg.sh b/scripts/build-dmg.sh index 24dc041..e29f922 100755 --- a/scripts/build-dmg.sh +++ b/scripts/build-dmg.sh @@ -100,6 +100,59 @@ if [ -f "Resources/AppIcon.icns" ]; then cp "Resources/AppIcon.icns" "${APP_BUNDLE}/Contents/Resources/" fi +# Step 2.5: Nest the menu bar widget inside the main app as a LoginItem. +# SMAppService.loginItem(identifier:) expects the helper at this exact path +# (Contents/Library/LoginItems/.app), and the helper's bundle id +# is what gets passed to register(). LSUIElement=true keeps it off the +# Dock; it lives in the menu bar only. +echo "[2.5/6] Bundling MacCleanMenu widget..." +MENU_APP="${APP_BUNDLE}/Contents/Library/LoginItems/MacCleanMenu.app" +mkdir -p "${MENU_APP}/Contents/MacOS" +mkdir -p "${MENU_APP}/Contents/Resources" + +cp "${BUILD_DIR}/MacCleanMenu" "${MENU_APP}/Contents/MacOS/" + +cat > "${MENU_APP}/Contents/Info.plist" << MENU_PLIST + + + + + CFBundleDevelopmentRegion + en + CFBundleExecutable + MacCleanMenu + CFBundleIdentifier + com.macclean.menu + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + Mac Clean Menu + CFBundleDisplayName + Mac Clean Menu + CFBundlePackageType + APPL + CFBundleShortVersionString + ${VERSION} + CFBundleVersion + 1 + LSMinimumSystemVersion + 14.0 + NSPrincipalClass + NSApplication + CFBundleIconFile + AppIcon + NSHighResolutionCapable + + LSUIElement + + + +MENU_PLIST + +if [ -f "Resources/AppIcon.icns" ]; then + cp "Resources/AppIcon.icns" "${MENU_APP}/Contents/Resources/" +fi + # Step 3: Entitlements (needed for notarization with hardened runtime) echo "[3/6] Creating entitlements..." cat > "${DMG_DIR}/entitlements.plist" << ENTITLEMENTS