Skip to content

armgit / peel

Public Imported from GitHub
0

Uninstall Mac apps with every file they leave behind, and see why each belongs. Free up space, fine-tune macOS, and set up Terminal.

5.2 KB
Raw Blame
import AppKit
import Foundation
import Observation
import PeelCore

@Observable
final class TerminalLibrary {
    enum Action: Equatable {
        case use(TerminalTheme)
        case putBack
        case set(TerminalOption, Bool)
    }

    static let ledgerKey = "terminalThemes"
    private static let patience: Duration = .seconds(10)

    private let settings: any TerminalSettingsStoring
    private let defaults: UserDefaults
    private let home: URL
    private var ledger: TerminalThemeLedger
    private(set) var themeInUse: TerminalTheme?
    /// The profile Terminal's first window opens with when it isn't the theme new windows use: Terminal keeps the two
    /// apart, in Settings > General.
    private(set) var opensWith: String?
    private(set) var profileInUse: String?
    private(set) var canPutBack = false
    private(set) var isTerminalOpen = false
    private(set) var isQuittingTerminal = false
    private(set) var quietsLogin = false
    private(set) var isMovingQuietLogin = false
    private(set) var shellSessions: ShellSessions?
    private(set) var options: Set<TerminalOption>?
    private(set) var isManaged = false
    private(set) var showsWindowSwitch = false
    private(set) var wasRefused = false
    private(set) var areProfilesUnreadable = false
    var waitingForTerminal: Action?
    var terminalDidNotQuit = false

    init(
        settings: any TerminalSettingsStoring = TerminalSettings(),
        defaults: UserDefaults = .standard,
        home: URL = .homeDirectory
    ) {
        self.settings = settings
        self.defaults = defaults
        self.home = home
        ledger = TerminalThemeLedger(stored: defaults.dictionary(forKey: Self.ledgerKey) ?? [:])
        refresh()
    }

    func refresh() {
        profileInUse = settings.profileName(for: .newWindows)
        themeInUse = ledger.theme(in: settings)
        let startup = settings.profileName(for: .startup)
        opensWith = themeInUse != nil && startup != themeInUse?.profileName ? startup : nil
        canPutBack = ledger.canPutBack
        isTerminalOpen = settings.isTerminalOpen
        quietsLogin = HushLogin.isOn(in: home)
        shellSessions = ShellSessions.inTerminal(settings, home: home)
        areProfilesUnreadable = settings.profiles() == nil
        options = ledger.options(in: settings)
        isManaged = settings.isManaged
        showsWindowSwitch = TerminalWindows.switchMatters()
    }

    func forgetRefusal() {
        wasRefused = false
    }

    func perform(_ action: Action) {
        guard !settings.isTerminalOpen else {
            waitingForTerminal = action
            return
        }
        let outcome = switch action {
        case .use(let theme): (try? ledger.use(theme, in: settings)) ?? .refused
        case .putBack: ledger.putBack(in: settings)
        case .set(let option, let isOn): ledger.set(option, to: isOn, in: settings)
        }
        defaults.set(ledger.stored, forKey: Self.ledgerKey)
        refresh()
        wasRefused = outcome == .refused
    }

    func quitTerminal(andThen action: Action) async {
        waitingForTerminal = nil
        let running = NSRunningApplication.runningApplications(withBundleIdentifier: TerminalSettings.identifier)
        isQuittingTerminal = true
        defer { isQuittingTerminal = false }
        let ends = ProcessEnds.of(running.map(\.processIdentifier))
        running.forEach { $0.terminate() }
        let didQuit = await withTaskGroup(of: Bool.self) { group in
            group.addTask {
                for await _ in ends {}
                return true
            }
            group.addTask { try? await Task.sleep(for: Self.patience); return false }
            let first = await group.next() ?? false
            group.cancelAll()
            return first
        }
        guard didQuit else {
            terminalDidNotQuit = true
            return
        }
        perform(action)
    }

    func turnOnQuietLogin() {
        quietsLogin = HushLogin.turnOn(in: home)
    }

    func moveQuietLoginToTrash(recording record: (TrashResult, [URL: Int64]) async -> Void) async -> TrashResult {
        isMovingQuietLogin = true
        defer { isMovingQuietLogin = false }
        let file = HushLogin.url(in: home)
        let sizes = [URL: Int64](measured: [(file, await FileSize.reclaimableSize(of: file))])
        let result = await QuitGuard.shared.run {
            let result = await RecordedRemoval.$current.withValue(RecordedRemoval.current?.measuring(sizes)) {
                await TrashService(exclusions: ExclusionsStore.shared.exclusions).trash([file])
            }
            await record(result, sizes)
            return result
        }
        quietsLogin = HushLogin.isOn(in: home)
        return result
    }

    func openTerminal() {
        guard let terminal = NSWorkspace.shared.urlForApplication(withBundleIdentifier: TerminalSettings.identifier)
        else { return }
        if settings.isTerminalOpen {
            NSWorkspace.shared.open(
                [URL.homeDirectory],
                withApplicationAt: terminal,
                configuration: NSWorkspace.OpenConfiguration()
            )
        } else {
            NSWorkspace.shared.openApplication(at: terminal, configuration: NSWorkspace.OpenConfiguration())
        }
    }
}