byre/mac/Sources/Byre/Settings.swift

import ByreAPI
import SwiftUI
import UserNotifications

typealias NotificationPrefs = Components.Schemas.NotificationPrefs

@MainActor
private let kinds: [(key: WritableKeyPath<NotificationPrefs, Bool>, label: String)] = [
    (\.questions, "Questions"),
    (\.ready, "Ready to merge"),
    (\.discard, "Suggests discard"),
    (\.mergeProblems, "Merge problems"),
    (\.workflows, "Workflow finished"),
    (\.errors, "Session errors"),
    (\.rateLimits, "Rate limits"),
    (\.reports, "Turn summaries"),
]

struct SettingsView: View {
    @Environment(Store.self) private var store

    var body: some View {
        ScrollView {
            VStack(alignment: .leading, spacing: 0) {
                heading("Window color")
                Text("Windows for this server have a border in this color, on every Mac you use.")
                    .foregroundStyle(Palette.muted)
                    .fixedSize(horizontal: false, vertical: true)
                ServerColorPicker()
                heading("Font size")
                Text("The size of body text and of code, on every Mac you use. Other text grows and shrinks with them.")
                    .foregroundStyle(Palette.muted)
                    .fixedSize(horizontal: false, vertical: true)
                FontSizeStepper(label: "Text", size: FontSize.shared.body) { n in
                    FontSize.shared.set(body: n, code: FontSize.shared.code)
                }
                FontSizeStepper(label: "Code", size: FontSize.shared.code) { n in
                    FontSize.shared.set(body: FontSize.shared.body, code: n)
                }
                heading("Notifications")
                DeviceNotifications()
                PrefsBox()
                heading("Default model")
                Text("New tasks you start from byre run on this model.")
                    .foregroundStyle(Palette.muted)
                    .fixedSize(horizontal: false, vertical: true)
                ModelMenu(current: store.defaultModel, help: "Model for new tasks") { m in
                    try await store.api.client.updateDefaultModel(body: .json(.init(model: m))).ok.body.json
                }
                heading("Saved commands")
                Text("Each is a button in the Terminal tab of every task on this server. It opens a new shell in the task's worktree and runs the command there.")
                    .foregroundStyle(Palette.muted)
                    .fixedSize(horizontal: false, vertical: true)
                SavedCommands()
                heading("iCloud sync")
                SyncState()
                heading("This Mac's permissions")
                Text("The macOS privacy grants byre's app needs for agents to see and control this Mac. Checking asks macOS for any that are missing.")
                    .foregroundStyle(Palette.muted)
                    .fixedSize(horizontal: false, vertical: true)
                PermissionsCheck(run: checkLocalPermissions)
            }
            .padding(.horizontal, 16)
            .padding(.top, 8)
            .padding(.bottom, 16)
            .frame(maxWidth: .infinity, alignment: .leading)
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity)
        .background(Palette.bg)
    }

    private func heading(_ text: String) -> some View {
        Text(text)
            .font(Fonts.font(13, weight: 700))
            .padding(.top, 16)
            .padding(.bottom, 6)
    }
}

private struct ServerColorPicker: View {
    @Environment(Store.self) private var store

    var body: some View {
        let origin = store.api.origin.absoluteString
        let current = Servers.shared.record(origin)?.color
        HStack(spacing: 4) {
            ForEach(taskPalette.indices, id: \.self) { i in
                Button {
                    Servers.shared.setColor(origin, i)
                } label: {
                    Circle()
                        .fill(taskPalette[i])
                        .frame(width: 18, height: 18)
                        .padding(3)
                        .overlay(Circle().stroke(i == current ? Palette.text : .clear, lineWidth: 1.5))
                        .contentShape(Circle())
                }
                .buttonStyle(.plain)
            }
        }
        .padding(.top, 8)
    }
}

private struct FontSizeStepper: View {
    let label: String
    let size: Int
    let set: (Int) -> Void

    var body: some View {
        HStack(spacing: 8) {
            Text(label)
                .frame(width: 48, alignment: .leading)
            Button("−") {
                set(size - 1)
            }
            .buttonStyle(WebButtonStyle())
            .disabled(size <= FontSize.range.lowerBound)
            Text("\(size) pt")
                .monospacedDigit()
            Button("+") {
                set(size + 1)
            }
            .buttonStyle(WebButtonStyle())
            .disabled(size >= FontSize.range.upperBound)
        }
        .padding(.top, 8)
    }
}

private struct SyncState: View {
    var body: some View {
        TimelineView(.periodic(from: .now, by: 30)) { _ in
            if let sync = Servers.shared.sync {
                if sync.ok {
                    Text("This Mac shares its servers, window colors, font sizes, drafts and task visits through iCloud. Last synced \(ago(sync.at)).")
                        .fixedSize(horizontal: false, vertical: true)
                } else {
                    Text("iCloud sync is failing on this Mac, so changes made here aren't reaching your other Macs. Failed \(ago(sync.at)): \(sync.error ?? "")")
                        .foregroundStyle(Palette.danger)
                        .textSelection(.enabled)
                        .fixedSize(horizontal: false, vertical: true)
                }
            } else {
                Text("No iCloud sync has finished since byre started.").foregroundStyle(Palette.muted)
            }
        }
    }
}

private struct DeviceNotifications: View {
    @ViewState private var status: UNAuthorizationStatus?
    @ViewState private var asking = false

    var body: some View {
        Group {
            switch status {
            case .none:
                EmptyView()
            case .denied:
                Text("Notifications are blocked for byre in System Settings.").foregroundStyle(Palette.muted)
            case .authorized, .provisional:
                Text("This Mac shows notifications while byre is running.")
            default:
                VStack(alignment: .leading, spacing: 8) {
                    Text("This Mac doesn't show notifications from byre.")
                    Button("Turn on for this Mac") {
                        asking = true
                        Task {
                            _ = try? await UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound])
                            await read()
                            asking = false
                        }
                    }
                    .buttonStyle(WebButtonStyle())
                    .disabled(asking)
                }
            }
        }
        .padding(.bottom, 8)
        .task {
            await read()
        }
        .onReceive(NotificationCenter.default.publisher(for: NSApplication.didBecomeActiveNotification)) { _ in
            Task {
                await read()
            }
        }
    }

    private func read() async {
        status = await UNUserNotificationCenter.current().notificationSettings().authorizationStatus
    }
}

private struct PrefsBox: View {
    @Environment(Store.self) private var store
    @Environment(Overlays.self) private var overlays

    var body: some View {
        if let me = store.me {
            VStack(alignment: .leading, spacing: 4) {
                Text("Notify me about")
                    .foregroundStyle(Palette.muted)
                    .padding(.horizontal, 4)
                    .background(Palette.bg)
                    .offset(y: -18)
                    .padding(.bottom, -18)
                ForEach(kinds, id: \.label) { kind in
                    Toggle(kind.label, isOn: Binding(get: { me.notificationPrefs[keyPath: kind.key] }, set: { on in
                        var prefs = me.notificationPrefs
                        prefs[keyPath: kind.key] = on
                        Task {
                            do {
                                store.me = try await store.api.client.updateNotificationPrefs(body: .json(prefs)).ok.body.json
                            } catch {
                                overlays.showAlert(errorText(error))
                            }
                        }
                    }))
                    .toggleStyle(.checkbox)
                    .tint(Palette.accent)
                }
            }
            .padding(.horizontal, 12)
            .padding(.top, 8)
            .padding(.bottom, 10)
            .frame(maxWidth: .infinity, alignment: .leading)
            .background(RoundedRectangle(cornerRadius: 8).stroke(Palette.border))
            .padding(.top, 16)
        }
    }
}

private struct SavedCommands: View {
    @Environment(Store.self) private var store
    @Environment(Overlays.self) private var overlays
    @ViewState private var list: [SavedCommand] = []
    @ViewState private var editing: String?
    @ViewState private var name = ""
    @ViewState private var command = ""
    @ViewState private var off: (() -> Void)?

    var body: some View {
        VStack(alignment: .leading, spacing: 0) {
            ForEach(list, id: \.id) { c in
                if editing == c.id {
                    form(c.id)
                } else {
                    HStack(alignment: .firstTextBaseline, spacing: 12) {
                        VStack(alignment: .leading, spacing: 2) {
                            Text(c.name)
                            Text(c.command)
                                .font(Fonts.font(12, mono: true))
                                .foregroundStyle(Palette.muted)
                                .textSelection(.enabled)
                                .fixedSize(horizontal: false, vertical: true)
                        }
                        .frame(maxWidth: .infinity, alignment: .leading)
                        Button("Edit") {
                            editing = c.id
                            name = c.name
                            command = c.command
                        }
                        .buttonStyle(SmallLinkButtonStyle())
                        Button("Delete") {
                            delete(c)
                        }
                        .buttonStyle(SmallLinkButtonStyle(color: Palette.danger))
                    }
                    .padding(.vertical, 6)
                    .overlay(alignment: .top) {
                        Rectangle().fill(Palette.border).frame(height: 1)
                    }
                }
            }
            if editing == nil {
                form(nil)
            }
        }
        .padding(.top, 8)
        .onAppear {
            off = store.events.add { ev in
                if ev.kind == "command.saved" || ev.kind == "command.deleted" {
                    load()
                }
            }
            load()
        }
        .onDisappear {
            off?()
            off = nil
        }
    }

    private func form(_ id: String?) -> some View {
        let valid = !name.trimmingCharacters(in: .whitespaces).isEmpty && !command.trimmingCharacters(in: .whitespaces).isEmpty
        return HStack(spacing: 6) {
            TextField("Name", text: $name)
                .modifier(FieldStyle())
                .frame(width: 180)
                .onSubmit {
                    save(id, valid)
                }
            TextField("Command", text: $command)
                .font(Fonts.font(13, mono: true))
                .modifier(FieldStyle())
                .onSubmit {
                    save(id, valid)
                }
            Button(id == nil ? "Add" : "Save") {
                save(id, valid)
            }
            .buttonStyle(WebButtonStyle())
            .disabled(!valid)
            if id != nil {
                Button("Cancel") {
                    editing = nil
                    name = ""
                    command = ""
                }
                .buttonStyle(WebButtonStyle())
            }
        }
        .padding(.vertical, 6)
    }

    private func load() {
        Task {
            do {
                list = try await store.api.client.listSavedCommands().ok.body.json
            } catch {
                overlays.showAlert(errorText(error))
            }
        }
    }

    private func save(_ id: String?, _ valid: Bool) {
        if !valid {
            return
        }
        let body = Components.Schemas.SavedCommandSave(name: name, command: command)
        Task {
            do {
                if let id {
                    _ = try await store.api.client.updateSavedCommand(path: .init(commandId: id), body: .json(body)).ok.body.json
                } else {
                    _ = try await store.api.client.createSavedCommand(body: .json(body)).created.body.json
                }
                editing = nil
                name = ""
                command = ""
            } catch {
                overlays.showAlert(errorText(error))
            }
        }
    }

    private func delete(_ c: SavedCommand) {
        Task {
            do {
                _ = try await store.api.client.deleteSavedCommand(path: .init(commandId: c.id)).noContent
            } catch {
                overlays.showAlert(errorText(error))
            }
        }
    }
}

private struct ModelMenu: View {
    let current: String
    let help: String
    let pick: (String) async throws -> User
    @Environment(Store.self) private var store
    @Environment(Overlays.self) private var overlays

    var body: some View {
        Menu {
            ForEach(models, id: \.self) { m in
                Button(m) {
                    Task {
                        do {
                            store.me = try await pick(m)
                        } catch {
                            overlays.showAlert(errorText(error))
                        }
                    }
                }
            }
        } label: {
            HStack(spacing: 8) {
                Text(current)
                Image(systemName: "chevron.up.chevron.down")
                    .font(Fonts.font(9, weight: 600))
            }
            .foregroundStyle(Palette.text)
            .modifier(FieldStyle())
            .contentShape(Rectangle())
        }
        .menuStyle(.button)
        .buttonStyle(.plain)
        .menuIndicator(.hidden)
        .fixedSize()
        .help(help)
        .padding(.top, 8)
    }
}