Reorg

Secretive/Views/ContentView.swift

@@ -0,0 +1,123 @@
+import SwiftUI
+import SecretKit
+
+struct ContentView<UpdaterType: UpdaterProtocol>: View {
+    
+    @ObservedObject var storeList: SecretStoreList
+    @ObservedObject var updater: UpdaterType
+
+    @State fileprivate var active: AnySecret.ID?
+    @State fileprivate var showingDeletion = false
+    @State fileprivate var deletingSecret: AnySecret?
+    
+    var body: some View {
+        VStack {
+            if updater.update != nil {
+                updateNotice()
+            }
+            NavigationView {
+                List(selection: $active) {
+                    ForEach(storeList.stores) { store in
+                        if store.isAvailable {
+                            Section(header: Text(store.name)) {
+                                if store.secrets.isEmpty {
+                                    if store is AnySecretStoreModifiable {
+                                        NavigationLink(destination: EmptyStoreModifiableView(), tag: Constants.emptyStoreModifiableTag, selection: self.$active) {
+                                            Text("No Secrets")
+                                        }
+                                    } else {
+                                        NavigationLink(destination: EmptyStoreView(), tag: Constants.emptyStoreTag, selection: self.$active) {
+                                            Text("No Secrets")
+                                        }
+                                    }
+                                } else {
+                                    ForEach(store.secrets) { secret in
+                                        NavigationLink(destination: SecretDetailView(secret: secret), tag: secret.id, selection: self.$active) {
+                                            Text(secret.name)
+                                        }.contextMenu {
+                                            if store is AnySecretStoreModifiable {
+                                                Button(action: { self.delete(secret: secret) }) {
+                                                    Text("Delete")
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }.onAppear {
+                    self.active = self.nextDefaultSecret
+                }
+                .listStyle(SidebarListStyle())
+                .frame(minWidth: 100, idealWidth: 240)
+            }
+            .navigationViewStyle(DoubleColumnNavigationViewStyle())
+            .sheet(isPresented: $showingDeletion) {
+                if self.storeList.modifiableStore != nil {
+                    DeleteSecretView(secret: self.deletingSecret!, store: self.storeList.modifiableStore!) { deleted in
+                        self.showingDeletion = false
+                        if deleted {
+                            self.active = self.nextDefaultSecret
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    func updateNotice() -> some View {
+        guard let update = updater.update else { return AnyView(Spacer()) }
+        let severity: NoticeView.Severity
+        let text: String
+        if update.critical {
+            severity = .critical
+            text = "Critical Security Update Required"
+        } else {
+            severity = .advisory
+            text = "Update Available"
+        }
+        return AnyView(NoticeView(text: text, severity: severity, actionTitle: "Update") {
+            NSWorkspace.shared.open(update.html_url)
+        })
+    }
+
+    func delete<SecretType: Secret>(secret: SecretType) {
+        deletingSecret = AnySecret(secret)
+        self.showingDeletion = true
+    }
+
+    var nextDefaultSecret: AnyHashable? {
+        let fallback: AnyHashable
+        if self.storeList.modifiableStore?.isAvailable ?? false {
+            fallback = Constants.emptyStoreModifiableTag
+        } else {
+            fallback = Constants.emptyStoreTag
+        }
+        return self.storeList.stores.compactMap { $0.secrets.first }.first?.id ?? fallback
+    }
+    
+}
+
+fileprivate enum Constants {
+    static let emptyStoreModifiableTag: AnyHashable = "emptyStoreModifiableTag"
+    static let emptyStoreTag: AnyHashable = "emptyStoreModifiableTag"
+}
+
+
+#if DEBUG
+
+struct ContentView_Previews: PreviewProvider {
+    static var previews: some View {
+        Group {
+            ContentView(storeList: Preview.storeList(stores: [Preview.Store(numberOfRandomSecrets: 0)], modifiableStores: [Preview.StoreModifiable(numberOfRandomSecrets: 0)]), updater: PreviewUpdater())
+            ContentView(storeList: Preview.storeList(stores: [Preview.Store()], modifiableStores: [Preview.StoreModifiable()]), updater: PreviewUpdater())
+            ContentView(storeList: Preview.storeList(stores: [Preview.Store()]), updater: PreviewUpdater())
+            ContentView(storeList: Preview.storeList(modifiableStores: [Preview.StoreModifiable()]), updater: PreviewUpdater())
+            ContentView(storeList: Preview.storeList(stores: [Preview.Store(numberOfRandomSecrets: 0)], modifiableStores: [Preview.StoreModifiable(numberOfRandomSecrets: 0)]), updater: PreviewUpdater(update: .advisory))
+            ContentView(storeList: Preview.storeList(stores: [Preview.Store(numberOfRandomSecrets: 0)], modifiableStores: [Preview.StoreModifiable(numberOfRandomSecrets: 0)]), updater: PreviewUpdater(update: .critical))
+        }
+    }
+}
+
+#endif

Secretive/Views/CreateSecretView.swift

@@ -0,0 +1,54 @@
+import SwiftUI
+import SecretKit
+
+struct CreateSecretView: View {
+    
+    @ObservedObject var store: AnySecretStoreModifiable
+    
+    @State var name = ""
+    @State var requiresAuthentication = true
+    
+    var dismissalBlock: () -> ()
+    
+    var body: some View {
+        VStack {
+            HStack {
+                Image(nsImage: NSApp.applicationIconImage)
+                    .resizable()
+                    .frame(width: 64, height: 64)
+                    .padding()
+                VStack {
+                    HStack {
+                        Text("Create a New Secret").bold()
+                        Spacer()
+                    }
+                    HStack {
+                        Text("Name:")
+                        TextField("Shhhhh", text: $name)
+                    }
+                    HStack {
+                        Toggle(isOn: $requiresAuthentication) {
+                            Text("Requires Authentication (Biometrics or Password)")
+                        }
+                        Spacer()
+                    }
+                }
+                .onExitCommand(perform: dismissalBlock)
+            }
+            HStack {
+                Spacer()
+                Button(action: dismissalBlock) {
+                    Text("Cancel")
+                }
+                Button(action: save) {
+                    Text("Create")
+                }.disabled(name.isEmpty)
+            }
+        }.padding()
+    }
+    
+    func save() {
+        try! store.create(name: name, requiresAuthentication: requiresAuthentication)
+        dismissalBlock()
+    }
+}

Secretive/Views/DeleteSecretView.swift

@@ -0,0 +1,60 @@
+import SwiftUI
+import SecretKit
+
+struct DeleteSecretView<StoreType: SecretStoreModifiable>: View {
+    
+    let secret: StoreType.SecretType
+    @ObservedObject var store: StoreType
+    
+    @State var confirm = ""
+    
+    fileprivate var dismissalBlock: (Bool) -> ()
+    
+    init(secret: StoreType.SecretType, store: StoreType, dismissalBlock: @escaping (Bool) -> ()) {
+        self.secret = secret
+        self.store = store
+        self.dismissalBlock = dismissalBlock
+    }
+    
+    var body: some View {
+        VStack {
+            HStack {
+                Image(nsImage: NSApp.applicationIconImage)
+                    .resizable()
+                    .frame(width: 64, height: 64)
+                    .padding()
+                VStack {
+                    HStack {
+                        Text("Delete \(secret.name)?").bold()
+                        Spacer()
+                    }
+                    HStack {
+                        Text("If you delete \(secret.name), you will not be able to recover it. Type \"\(secret.name)\" to confirm.")
+                        Spacer()
+                    }
+                    HStack {
+                        Text("Confirm Name:")
+                        TextField(secret.name, text: $confirm)
+                    }
+                }
+                .onExitCommand {
+                    self.dismissalBlock(false)
+                }
+            }
+            HStack {
+                Spacer()
+                Button(action: delete) {
+                    Text("Delete")
+                }.disabled(confirm != secret.name)
+                Button(action: { self.dismissalBlock(false) }) {
+                    Text("Don't Delete")
+                }
+            }
+        }.padding()
+    }
+    
+    func delete() {
+        try! store.delete(secret: secret)
+        self.dismissalBlock(true)
+    }
+}

Secretive/Views/EmptyStoreView.swift

@@ -0,0 +1,57 @@
+import SwiftUI
+
+struct EmptyStoreView: View {
+    
+    var body: some View {
+        VStack {
+            Text("No Secrets").bold()
+            Text("Use your Smart Card's management tool to create a secret.")
+            Text("Secretive only supports Elliptic Curve keys.")
+        }.frame(maxWidth: .infinity, maxHeight: .infinity)
+    }
+    
+}
+
+struct EmptyStoreModifiableView: View {
+    
+    var body: some View {
+        GeometryReader { windowGeometry in
+            VStack {
+                GeometryReader { g in
+                    Path { path in
+                        path.move(to: CGPoint(x: g.size.width / 2, y: g.size.height))
+                        path.addCurve(to:
+                            CGPoint(x: g.size.width * (3/4), y: g.size.height * (1/2)), control1:
+                            CGPoint(x: g.size.width / 2, y: g.size.height * (1/2)), control2:
+                            CGPoint(x: g.size.width * (3/4), y: g.size.height * (1/2)))
+                        path.addCurve(to:
+                            CGPoint(x: g.size.width, y: 0), control1:
+                            CGPoint(x: g.size.width, y: g.size.height * (1/2)), control2:
+                            CGPoint(x: g.size.width, y: 0))
+                    }.stroke(style: StrokeStyle(lineWidth: 5, lineCap: .round))
+                    Path { path in
+                        path.move(to: CGPoint(x: g.size.width - 10, y: 0))
+                        path.addLine(to: CGPoint(x: g.size.width, y: -10))
+                        path.addLine(to: CGPoint(x: g.size.width + 10, y: 0))
+                    }.fill()
+                }.frame(height: (windowGeometry.size.height/2) - 20).padding()
+                Text("No Secrets").bold()
+                Text("Create a new one by clicking here.")
+                Spacer()
+            }.frame(maxWidth: .infinity, maxHeight: .infinity)
+        }
+    }
+}
+
+#if DEBUG
+
+struct EmptyStoreModifiableView_Previews: PreviewProvider {
+    static var previews: some View {
+        Group {
+            EmptyStoreView()
+            EmptyStoreModifiableView()
+        }
+    }
+}
+
+#endif

Secretive/Views/NoticeView.swift

@@ -0,0 +1,57 @@
+import Foundation
+import SwiftUI
+
+struct NoticeView: View {
+
+    let text: String
+    let severity: Severity
+    let actionTitle: String?
+    let action: (() -> Void)?
+
+    var body: some View {
+        HStack {
+            Text(text).bold()
+            Spacer()
+            if action != nil {
+                Button(action: action!) {
+                    Text(actionTitle!)
+                }
+            }
+            }.padding().background(color)
+    }
+
+    var color: Color {
+        switch severity {
+        case .advisory:
+            return Color.orange
+        case .critical:
+            return Color.red
+        }
+    }
+
+}
+
+extension NoticeView {
+
+    enum Severity {
+        case advisory, critical
+    }
+
+}
+
+#if DEBUG
+
+struct NoticeView_Previews: PreviewProvider {
+    static var previews: some View {
+        Group {
+            NoticeView(text: "Agent Not Running", severity: .advisory, actionTitle: "Run Setup") {
+                print("OK")
+            }
+            NoticeView(text: "Critical Security Update Required", severity: .critical, actionTitle: "Update") {
+                print("OK")
+            }
+        }
+    }
+}
+
+#endif

Secretive/Views/SecretDetailView.swift

@@ -0,0 +1,67 @@
+import SwiftUI
+import SecretKit
+
+struct SecretDetailView<SecretType: Secret>: View {
+
+    @State var secret: SecretType
+    let keyWriter = OpenSSHKeyWriter()
+
+    var body: some View {
+        Form {
+            Section {
+                GroupBox(label: Text("Fingerprint")) {
+                    HStack {
+                        Text(keyWriter.openSSHFingerprint(secret: secret))
+                        Spacer()
+                    }
+                        .frame(minWidth: 150, maxWidth: .infinity)
+                        .padding()
+                }.onDrag {
+                    return NSItemProvider(item: NSData(data: self.keyWriter.openSSHFingerprint(secret: self.secret).data(using: .utf8)!), typeIdentifier: kUTTypeUTF8PlainText as String)
+                }
+                Spacer().frame(height: 10)
+                GroupBox(label: Text("Public Key")) {
+                    VStack {
+                        Text(keyWriter.openSSHString(secret: secret))
+                            .multilineTextAlignment(.leading)
+                            .frame(minWidth: 150, maxWidth: .infinity)
+                        HStack {
+                            Spacer()
+                            Button(action: copy) {
+                                Text("Copy")
+                            }
+                        }
+                    }
+                    .padding()
+                }
+                .onDrag {
+                    return NSItemProvider(item: NSData(data: self.keyString.data(using: .utf8)!), typeIdentifier: kUTTypeUTF8PlainText as String)
+                }
+                Spacer()
+            }
+        }.padding()
+            .frame(minHeight: 150, maxHeight: .infinity)
+
+    }
+
+    var keyString: String {
+        keyWriter.openSSHString(secret: secret)
+    }
+
+    func copy() {
+        NSPasteboard.general.declareTypes([.string], owner: nil)
+        NSPasteboard.general.setString(keyString, forType: .string)
+    }
+
+
+}
+
+#if DEBUG
+
+struct SecretDetailView_Previews: PreviewProvider {
+    static var previews: some View {
+        SecretDetailView(secret: Preview.Store(numberOfRandomSecrets: 1).secrets[0])
+    }
+}
+
+#endif

Secretive/Views/SetupView.swift

@@ -0,0 +1,133 @@
+import Foundation
+import SwiftUI
+import ServiceManagement
+
+struct SetupView: View {
+
+    var completion: ((Bool) -> Void)?
+
+    var body: some View {
+        Form {
+            SetupStepView<Spacer>(text: "Secretive needs to install a helper app to sign requests when the main app isn't running. This app is called \"SecretAgent\" and you might see it in Activity Manager from time to time.",
+                                index: 1,
+                                nestedView: nil,
+                                actionText: "Install") {
+                                    self.installLaunchAgent()
+            }
+            SetupStepView(text: "You need to add a line to your shell config (.bashrc or .zshrc) telling SSH to talk to SecretAgent when it wants to authenticate. Drag this into your config file.",
+                          index: 2,
+                          nestedView: SetupStepCommandView(text: Constants.socketPrompt),
+                          actionText: "Added") {
+                            self.markAsDone()
+            }
+            HStack {
+                Spacer()
+                    Button(action: { self.completion?(true) }) {
+                        Text("Finish")
+                    }
+                .padding()
+            }
+        }
+    }
+
+}
+
+struct SetupStepView<NestedViewType: View>: View {
+
+    let text: String
+    let index: Int
+    let nestedView: NestedViewType?
+    @State var completed = false
+    let actionText: String
+    let action: (() -> Bool)
+
+    var body: some View {
+        Section {
+            HStack {
+                ZStack {
+                    if completed {
+                        Circle().foregroundColor(.green)
+                            .frame(width: 30, height: 30)
+                        Text("✓")
+                            .foregroundColor(.white)
+                            .bold()
+                    } else {
+                        Circle().foregroundColor(.blue)
+                            .frame(width: 30, height: 30)
+                        Text(String(describing: index))
+                            .foregroundColor(.white)
+                            .bold()
+                    }
+                }
+                .padding()
+                VStack {
+                    Text(text)
+                        .opacity(completed ? 0.5 : 1)
+                        .lineLimit(nil)
+                        .frame(idealHeight: 0, maxHeight: .infinity)
+                    if nestedView != nil {
+                        Spacer()
+                        nestedView!
+                    }
+                }
+                .padding()
+                Button(action: {
+                    self.completed = self.action()
+                }) {
+                    Text(actionText)
+                }.disabled(completed)
+                    .padding()
+            }
+        }
+    }
+}
+
+struct SetupStepCommandView: View {
+
+    let text: String
+
+    var body: some View {
+        Text(text)
+            .font(.system(.caption, design: .monospaced))
+            .lineLimit(nil)
+            .frame(idealHeight: 0, maxHeight: .infinity)
+            .padding()
+            .background(Color(white: 0, opacity: 0.10))
+            .cornerRadius(10)
+            .onDrag {
+                return NSItemProvider(item: NSData(data: self.text.data(using: .utf8)!), typeIdentifier: kUTTypeUTF8PlainText as String)
+        }
+    }
+
+}
+
+extension SetupView {
+
+    func installLaunchAgent() -> Bool {
+        SMLoginItemSetEnabled("com.maxgoedjen.Secretive.SecretAgent" as CFString, true)
+    }
+
+    func markAsDone() -> Bool {
+        return true
+    }
+
+}
+
+extension SetupView {
+
+    enum Constants {
+        static let socketPath = (NSHomeDirectory().replacingOccurrences(of: "com.maxgoedjen.Secretive.Host", with: "com.maxgoedjen.Secretive.SecretAgent") as NSString).appendingPathComponent("socket.ssh") as String
+        static let socketPrompt = "export SSH_AUTH_SOCK=\(socketPath)"
+    }
+
+}
+
+#if DEBUG
+
+struct SetupView_Previews: PreviewProvider {
+    static var previews: some View {
+        SetupView()
+    }
+}
+
+#endif