feat: add remote folder picker to file sync GUI

Coder-Desktop/Coder-Desktop/Info.plist

@@ -2,6 +2,15 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
+	<key>NSAppTransportSecurity</key>
+	<dict>
+		<!--
+		Required to make HTTP (not HTTPS) requests to workspace agents
+		(i.e. workspace.coder:4). These are already encrypted over wireguard.
+		-->
+		<key>NSAllowsArbitraryLoads</key>
+		<true/>
+	</dict>
 	<key>NetworkExtension</key>
 	<dict>
 		<key>NEMachServiceName</key>

Coder-Desktop/Coder-Desktop/Views/FileSync/FilePicker.swift

@@ -0,0 +1,252 @@
+import CoderSDK
+import Foundation
+import SwiftUI
+
+struct FilePicker: View {
+    @Environment(\.dismiss) var dismiss
+    @StateObject private var model: FilePickerModel
+    @State private var selection: FilePickerItemModel.ID?
+
+    @Binding var outputAbsPath: String
+
+    let inspection = Inspection<Self>()
+
+    init(
+        host: String,
+        outputAbsPath: Binding<String>
+    ) {
+        _model = StateObject(wrappedValue: FilePickerModel(host: host))
+        _outputAbsPath = outputAbsPath
+    }
+
+    var body: some View {
+        VStack(spacing: 0) {
+            if model.rootIsLoading {
+                Spacer()
+                ProgressView()
+                    .controlSize(.large)
+                Spacer()
+            } else if let loadError = model.error {
+                Text("\(loadError.description)")
+                    .font(.headline)
+                    .foregroundColor(.red)
+                    .multilineTextAlignment(.center)
+                    .frame(maxWidth: .infinity, maxHeight: .infinity)
+                    .padding()
+            } else {
+                List(selection: $selection) {
+                    ForEach(model.rootFiles) { rootItem in
+                        FilePickerItem(item: rootItem)
+                    }
+                }.contextMenu(
+                    forSelectionType: FilePickerItemModel.ID.self,
+                    menu: { _ in },
+                    primaryAction: { selections in
+                        // Per the type of `selection`, this will only ever be a set of
+                        // one item.
+                        let files = model.findFilesByIds(ids: selections)
+                        files.forEach { file in withAnimation { file.isExpanded.toggle() } }
+                    }
+                ).listStyle(.sidebar)
+            }
+            Divider()
+            HStack {
+                Spacer()
+                Button("Cancel", action: { dismiss() }).keyboardShortcut(.cancelAction)
+                Button("Select", action: submit).keyboardShortcut(.defaultAction).disabled(selection == nil)
+            }.padding(20)
+        }
+        .onAppear {
+            model.loadRoot()
+        }
+        .onReceive(inspection.notice) { inspection.visit(self, $0) } // ViewInspector
+    }
+
+    private func submit() {
+        guard let selection else { return }
+        let files = model.findFilesByIds(ids: [selection])
+        if let file = files.first {
+            outputAbsPath = file.absolute_path
+        }
+        dismiss()
+    }
+}
+
+@MainActor
+class FilePickerModel: ObservableObject {
+    @Published var rootFiles: [FilePickerItemModel] = []
+    @Published var rootIsLoading: Bool = false
+    @Published var error: ClientError?
+
+    let client: AgentClient
+
+    init(host: String) {
+        client = AgentClient(agentHost: host)
+    }
+
+    func loadRoot() {
+        error = nil
+        rootIsLoading = true
+        Task {
+            defer { rootIsLoading = false }
+            do throws(ClientError) {
+                rootFiles = try await client
+                    .listAgentDirectory(.init(path: [], relativity: .root))
+                    .toModels(client: client, path: [])
+            } catch {
+                self.error = error
+            }
+        }
+    }
+
+    func findFilesByIds(ids: Set<FilePickerItemModel.ID>) -> [FilePickerItemModel] {
+        var result: [FilePickerItemModel] = []
+
+        for id in ids {
+            if let file = findFileByPath(path: id, in: rootFiles) {
+                result.append(file)
+            }
+        }
+
+        return result
+    }
+
+    private func findFileByPath(path: [String], in files: [FilePickerItemModel]?) -> FilePickerItemModel? {
+        guard let files, !path.isEmpty else { return nil }
+
+        if let file = files.first(where: { $0.name == path[0] }) {
+            if path.count == 1 {
+                return file
+            }
+            // Array slices are just views, so this isn't expensive
+            return findFileByPath(path: Array(path[1...]), in: file.contents)
+        }
+
+        return nil
+    }
+}
+
+struct FilePickerItem: View {
+    @ObservedObject var item: FilePickerItemModel
+
+    var body: some View {
+        Group {
+            if item.dir {
+                directory
+            } else {
+                Label(item.name, systemImage: "doc")
+                    .help(item.absolute_path)
+                    .selectionDisabled()
+                    .foregroundColor(.secondary)
+            }
+        }
+    }
+
+    private var directory: some View {
+        DisclosureGroup(isExpanded: $item.isExpanded) {
+            if let contents = item.contents {
+                ForEach(contents) { item in
+                    FilePickerItem(item: item)
+                }
+            }
+        } label: {
+            Label {
+                Text(item.name)
+                ZStack {
+                    ProgressView().controlSize(.small).opacity(item.isLoading && item.error == nil ? 1 : 0)
+                    Image(systemName: "exclamationmark.triangle.fill")
+                        .opacity(item.error != nil ? 1 : 0)
+                }
+            } icon: {
+                Image(systemName: "folder")
+            }.help(item.error != nil ? item.error!.description : item.absolute_path)
+        }
+    }
+}
+
+@MainActor
+class FilePickerItemModel: Identifiable, ObservableObject {
+    nonisolated let id: [String]
+    let name: String
+    // Components of the path as an array
+    let path: [String]
+    let absolute_path: String
+    let dir: Bool
+
+    let client: AgentClient
+
+    @Published var contents: [FilePickerItemModel]?
+    @Published var isLoading = false
+    @Published var error: ClientError?
+    @Published private var innerIsExpanded = false
+    var isExpanded: Bool {
+        get { innerIsExpanded }
+        set {
+            if !newValue {
+                withAnimation { self.innerIsExpanded = false }
+            } else {
+                Task {
+                    self.loadContents()
+                }
+            }
+        }
+    }
+
+    init(
+        name: String,
+        client: AgentClient,
+        absolute_path: String,
+        path: [String],
+        dir: Bool = false,
+        contents: [FilePickerItemModel]? = nil
+    ) {
+        self.name = name
+        self.client = client
+        self.path = path
+        self.dir = dir
+        self.absolute_path = absolute_path
+        self.contents = contents
+
+        // Swift Arrays are COW
+        id = path
+    }
+
+    func loadContents() {
+        self.error = nil
+        withAnimation { isLoading = true }
+        Task {
+            defer {
+                withAnimation {
+                    isLoading = false
+                    innerIsExpanded = true
+                }
+            }
+            do throws(ClientError) {
+                contents = try await client
+                    .listAgentDirectory(.init(path: path, relativity: .root))
+                    .toModels(client: client, path: path)
+            } catch {
+                self.error = error
+            }
+        }
+    }
+}
+
+extension LSResponse {
+    @MainActor
+    func toModels(client: AgentClient, path: [String]) -> [FilePickerItemModel] {
+        contents.compactMap { file in
+            // Filter dotfiles from the picker
+            guard !file.name.hasPrefix(".") else { return nil }
+
+            return FilePickerItemModel(
+                name: file.name,
+                client: client,
+                absolute_path: file.absolute_path_string,
+                path: path + [file.name],
+                dir: file.is_dir,
+                contents: nil
+            )
+        }
+    }
+}

Coder-Desktop/Coder-Desktop/Views/FileSync/FileSyncSessionModal.swift

@@ -13,6 +13,7 @@ struct FileSyncSessionModal<VPN: VPNService, FS: FileSyncDaemon>: View {
 
     @State private var loading: Bool = false
     @State private var createError: DaemonError?
+    @State private var pickingRemote: Bool = false
 
     var body: some View {
         let agents = vpn.menuState.onlineAgents
@@ -46,7 +47,16 @@ struct FileSyncSessionModal<VPN: VPNService, FS: FileSyncDaemon>: View {
                     }
                 }
                 Section {
-                    TextField("Remote Path", text: $remotePath)
+                    HStack(spacing: 5) {
+                        TextField("Remote Path", text: $remotePath)
+                        Spacer()
+                        Button {
+                            pickingRemote = true
+                        } label: {
+                            Image(systemName: "folder")
+                        }.disabled(remoteHostname == nil)
+                            .help(remoteHostname == nil ? "Select a workspace first" : "Open File Picker")
+                    }
                 }
             }.formStyle(.grouped).scrollDisabled(true).padding(.horizontal)
             Divider()
@@ -72,6 +82,9 @@ struct FileSyncSessionModal<VPN: VPNService, FS: FileSyncDaemon>: View {
                 set: { if !$0 { createError = nil } }
             )) {} message: {
                 Text(createError?.description ?? "An unknown error occurred.")
+            }.sheet(isPresented: $pickingRemote) {
+                FilePicker(host: remoteHostname!, outputAbsPath: $remotePath)
+                    .frame(width: 300, height: 400)
             }
     }