Skip to content

Run a virtual iPhone on an Apple Silicon Mac.

Swift
10.9 KB
Raw Blame
import SwiftUI

struct VPhoneKeychainBrowserView: View {
    @Bindable var model: VPhoneKeychainBrowserModel

    private let controlBarHeight: CGFloat = 24

    var body: some View {
        VStack(spacing: 0) {
            tableView
                .padding(.bottom, controlBarHeight)
                .overlay(controlBar.frame(maxHeight: .infinity, alignment: .bottom))

            if model.showDiagnostics {
                Divider()
                diagnosticsPanel
            }
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity)
        .task { await model.refresh() }
        .onChange(of: model.control.isConnected) { _, connected in
            if connected, model.items.isEmpty {
                Task { await model.refresh() }
            }
        }
        .onChange(of: model.filterClass) { _, _ in model.selection.removeAll() }
        .onChange(of: model.searchText) { _, _ in model.selection.removeAll() }
        .alert(
            "Error",
            isPresented: .init(
                get: { model.error != nil },
                set: {
                    if !$0 {
                        model.error = nil
                    }
                },
            ),
        ) {
            Button("OK") { model.error = nil }
        } message: {
            Text(model.error ?? "")
        }
        .confirmationDialog(
            "Delete the selected keychain items?",
            isPresented: .init(
                get: { model.pendingDeletion != nil },
                set: {
                    if !$0 {
                        model.pendingDeletion = nil
                    }
                },
            ),
            titleVisibility: .visible,
        ) {
            Button("Delete", role: .destructive) {
                let ids = model.pendingDeletion ?? []
                model.pendingDeletion = nil
                Task { await model.delete(ids: ids) }
            }
            Button("Cancel", role: .cancel) { model.pendingDeletion = nil }
        } message: {
            Text("The guest removes them from its keychain. This cannot be undone.")
        }
        .sheet(item: $model.editing) { _ in
            editSheet
        }
    }

    // MARK: - Edit Sheet

    @ViewBuilder
    var editSheet: some View {
        if let editing = model.editing {
            VStack(alignment: .leading, spacing: 12) {
                Text("Edit Value")
                    .font(.headline)

                Text(editing.item.displayName)
                    .font(.system(.body, design: .monospaced))
                    .foregroundStyle(.secondary)
                    .lineLimit(2)

                TextEditor(
                    text: .init(
                        get: { model.editing?.value ?? "" },
                        set: { model.editing?.value = $0 },
                    ),
                )
                .font(.system(.body, design: .monospaced))
                .frame(width: 380, height: 120)
                .border(Color.secondary.opacity(0.4))

                Text("The value is stored as its UTF-8 bytes.")
                    .font(.caption)
                    .foregroundStyle(.secondary)

                HStack {
                    Spacer()
                    Button("Cancel") { model.editing = nil }
                        .keyboardShortcut(.cancelAction)
                    Button("Save") { Task { await model.commitEditing() } }
                        .keyboardShortcut(.defaultAction)
                }
            }
            .padding(16)
        }
    }

    // MARK: - Table

    var tableView: some View {
        Table(of: VPhoneKeychainItem.self, selection: $model.selection, sortOrder: $model.sortOrder) {
            TableColumn(Text(verbatim: ""), value: \.itemClass) { item in
                Image(systemName: item.classIcon)
                    .foregroundStyle(.secondary)
                    .frame(width: 20)
                    .help(item.displayClass)
            }
            .width(28)

            TableColumn("Class", value: \.itemClass) { item in
                Text(item.displayClass)
                    .font(.system(.body, design: .monospaced))
            }
            .width(min: 60, ideal: 80, max: 100)

            TableColumn("Account", value: \.account) { item in
                Text(
                    item.account.isEmpty
                        ? (item.protectedMetadata ? VPhoneLocalization.text("Protected") : "-")
                        : item.account,
                )
                .lineLimit(1)
                .help(item.account)
            }
            .width(min: 80, ideal: 150, max: .infinity)

            TableColumn("Service", value: \.service) { item in
                Text(
                    item.service.isEmpty
                        ? (item.protectedMetadata ? VPhoneLocalization.text("Protected") : "-")
                        : item.service,
                )
                .lineLimit(1)
                .help(item.service)
            }
            .width(min: 80, ideal: 150, max: .infinity)

            TableColumn("Access Group", value: \.accessGroup) { item in
                Text(item.accessGroup.isEmpty ? "-" : item.accessGroup)
                    .font(.system(.body, design: .monospaced))
                    .lineLimit(1)
                    .help(item.accessGroup)
            }
            .width(min: 80, ideal: 160, max: .infinity)

            TableColumn("Protection", value: \.protection) { item in
                Text(item.protection.isEmpty ? "-" : item.protection)
                    .font(.system(.body, design: .monospaced))
                    .lineLimit(1)
                    .help(item.protectionDescription)
            }
            .width(min: 40, ideal: 60, max: 80)

            TableColumn("Value", value: \.value) { item in
                Text(item.displayValue)
                    .font(.system(.body, design: .monospaced))
                    .lineLimit(1)
                    .help(item.displayValue)
            }
            .width(min: 60, ideal: 120, max: .infinity)

            TableColumn("Modified", value: \.displayName) { item in
                Text(item.displayDate)
            }
            .width(min: 80, ideal: 120, max: .infinity)
        } rows: {
            ForEach(model.filteredItems) { item in
                TableRow(item)
            }
        }
        .contextMenu(forSelectionType: VPhoneKeychainItem.ID.self) { ids in
            contextMenu(for: ids)
        }
    }

    // MARK: - Control Bar

    var controlBar: some View {
        HStack(spacing: 6) {
            Circle()
                .fill(model.control.isConnected ? Color.green : Color.orange)
                .frame(width: 8, height: 8)

            Divider()

            Text(model.statusText)
                .font(.system(size: 11, design: .monospaced))
                .foregroundStyle(.secondary)
                .frame(minWidth: 60)

            Spacer()

            if model.isLoading {
                ProgressView()
                    .controlSize(.small)
            }
        }
        .padding(.horizontal, 8)
        .frame(height: controlBarHeight)
        .frame(maxWidth: .infinity)
        .background(.bar)
    }

    // MARK: - Diagnostics Panel

    var diagnosticsPanel: some View {
        VStack(spacing: 0) {
            HStack {
                Text("Diagnostics")
                    .font(.system(size: 11, weight: .semibold, design: .monospaced))
                    .foregroundStyle(.secondary)

                Spacer()

                Text(VPhoneLocalization.format("%@ entries", String(model.diagnostics.count)))
                    .font(.system(size: 10, design: .monospaced))
                    .foregroundStyle(.tertiary)

                Button {
                    let text = model.diagnostics.joined(separator: "\n")
                    if !text.isEmpty {
                        NSPasteboard.general.clearContents()
                        NSPasteboard.general.setString(text, forType: .string)
                    }
                } label: {
                    Image(systemName: "doc.on.doc")
                        .font(.system(size: 10))
                }
                .buttonStyle(.borderless)
                .help("Copy diagnostics to clipboard")
            }
            .padding(.horizontal, 8)
            .padding(.vertical, 4)
            .background(.bar)

            ScrollViewReader { proxy in
                ScrollView {
                    LazyVStack(alignment: .leading, spacing: 1) {
                        ForEach(Array(model.diagnostics.enumerated()), id: \.offset) { index, line in
                            Text(line)
                                .font(.system(size: 11, design: .monospaced))
                                .foregroundStyle(.secondary)
                                .textSelection(.enabled)
                                .frame(maxWidth: .infinity, alignment: .leading)
                                .padding(.horizontal, 8)
                                .padding(.vertical, 1)
                                .id(index)
                        }
                    }
                }
                .onChange(of: model.diagnostics.count) { _, newCount in
                    if newCount > 0 {
                        proxy.scrollTo(newCount - 1, anchor: .bottom)
                    }
                }
            }
            .frame(height: 140)
            .background(Color(nsColor: .textBackgroundColor).opacity(0.5))
        }
    }

    // MARK: - Context Menu

    @ViewBuilder
    func contextMenu(for ids: Set<VPhoneKeychainItem.ID>) -> some View {
        let editable = model.editableItems(ids: ids)
        if model.canEdit, !editable.isEmpty {
            Button("Reveal Value") { Task { await model.reveal(ids: ids) } }
            Button("Edit Value…") { Task { await model.beginEditing(ids: ids) } }
                .disabled(editable.count != 1)
            Button("Delete", role: .destructive) { model.pendingDeletion = ids }
            Divider()
        }
        Button("Copy Account") { copyField(ids: ids, keyPath: \.account) }
        Button("Copy Service") { copyField(ids: ids, keyPath: \.service) }
        Button("Copy Value") { copyField(ids: ids, keyPath: \.value) }
        Button("Copy Access Group") { copyField(ids: ids, keyPath: \.accessGroup) }
        Button("Copy Protection") { copyField(ids: ids, keyPath: \.protection) }
        Divider()
        Button("Copy Row (TSV)") { model.copyRows(ids: ids) }
        Divider()
        Button("Refresh") { Task { await model.refresh() } }
    }

    // MARK: - Copy Actions

    func copyField(ids: Set<VPhoneKeychainItem.ID>, keyPath: KeyPath<VPhoneKeychainItem, String>) {
        let values = model.filteredItems
            .filter { ids.contains($0.id) }
            .map { $0[keyPath: keyPath] }
            .filter { !$0.isEmpty }
            .joined(separator: "\n")
        guard !values.isEmpty else { return }
        NSPasteboard.general.clearContents()
        NSPasteboard.general.setString(values, forType: .string)
    }
}