Merge remote-tracking branch 'upstream/main'

8 files changed, 1325 insertions, 0 deletions

diff --git a/Hotline/macOS/Files/FileDetailsSheet.swift b/Hotline/macOS/Files/FileDetailsSheet.swift
new file mode 100644
index 0000000..1bfacb2
--- /dev/null
+++ b/Hotline/macOS/Files/FileDetailsSheet.swift
@@ -0,0 +1,172 @@
+import Foundation
+import SwiftUI
+
+struct FileDetailsSheet: View {
+  @Environment(HotlineState.self) private var model: HotlineState
+  @Environment(\.dismiss) private var dismiss
+
+  var details: FileDetails
+  
+  @State private var saving: Bool = false
+  @State private var comment: String = ""
+  @State private var filename: String = ""
+  
+  var body: some View {
+    VStack(alignment: .leading, spacing: 16) {
+      HStack(alignment: .center, spacing: 16){
+        if self.isFolder {
+          FolderIconView()
+            .frame(width: 32, height: 32)
+        }
+        else {
+          FileIconView(filename: self.details.name, fileType: nil)
+            .frame(width: 32, height: 32)
+        }
+        
+        TextField("File Name", text: $filename)
+          .disabled(!self.canRename)
+      }
+      
+      let rows: [(String, String)] = [
+        ("Type", self.details.type),
+        ("Creator", self.details.creator),
+        ("Size", self.formattedSize(byteCount: self.details.size)),
+        ("Created", Self.dateFormatter.string(from: self.details.created)),
+        ("Modified", Self.dateFormatter.string(from: self.details.modified))
+      ]
+      
+      Grid(alignment: .leading, horizontalSpacing: 12, verticalSpacing: 8) {
+        ForEach(rows, id: \.0) { label, value in
+          GridRow {
+            Text(label)
+              .font(.body.bold())
+              .gridColumnAlignment(.trailing) // right-align label column
+            Text(value)
+              .font(.body)
+              .gridColumnAlignment(.leading)  // left-align value column
+          }
+        }
+      }
+      .frame(maxWidth: .infinity, alignment: .leading)
+      .padding(.leading, 32 + 16)
+      
+      TextField(text: self.$comment, prompt: Text("Comments"), axis: .vertical) {
+        EmptyView()
+      }
+      .font(.body)
+      .lineLimit(10, reservesSpace: true)
+      .padding(.leading, 32 + 16)
+      .disabled(!self.canSetComment)
+    }
+    .padding(.vertical, 24)
+    .padding(.horizontal, 24)
+    .frame(width: 400)
+    .toolbar {
+      if self.saving {
+        ToolbarItem {
+          ProgressView()
+            .controlSize(.small)
+        }
+      }
+      
+      ToolbarItem(placement: .cancellationAction) {
+        Button("Cancel") {
+          self.dismiss()
+        }
+      }
+      
+      ToolbarItem(placement: .primaryAction) {
+        Button{
+          var editedFilename: String?
+          if self.filename != self.details.name {
+            editedFilename = self.filename
+          }
+          
+          var editedComment: String?
+          if self.comment != self.details.comment {
+            editedComment = self.comment
+          }
+          
+          Task {
+            self.saving = true
+            defer { self.saving = false }
+            
+            if editedComment != nil || editedFilename != nil {
+              if try await self.model.setFileInfo(fileName: self.details.name, path: self.details.path, fileNewName: editedFilename, comment: editedComment) {
+                try await self.model.getFileList(path: self.details.path)
+              }
+            }
+            
+            // We dismiss even if there is an error for now
+            // This is not ideal as we may lose a user's written comment
+            // or new file name, but SwiftUI doesn't show the current
+            // alert above this sheet so we'll need a different way of
+            // handling errors to make this work. Until then...
+            self.dismiss()
+          }
+        } label: {
+          Text("Save")
+        }
+      }
+    }
+    .onAppear {
+      self.filename = self.details.name
+      self.comment = self.details.comment
+    }
+  }
+  
+  private var isFolder: Bool {
+    self.details.type == "Folder" || self.details.type == "fldr"
+  }
+  
+  private func isEdited() -> Bool {
+    return self.filename != self.details.name || self.comment != self.details.comment
+  }
+  
+  private var canRename: Bool {
+    if self.isFolder {
+      return self.model.access?.contains(.canRenameFolders) == true
+    }
+    return self.model.access?.contains(.canRenameFiles) == true
+  }
+  
+  private var canSetComment: Bool {
+    if self.isFolder {
+      return self.model.access?.contains(.canSetFolderComment) == true
+    }
+    return self.model.access?.contains(.canSetFileComment) == true
+  }
+  
+  static var dateFormatter: DateFormatter = {
+    var dateFormatter = DateFormatter()
+    dateFormatter.dateStyle = .long
+    dateFormatter.timeStyle = .short
+    
+    // Original format: Fri, Aug 20, 2021, 5:14:07 PM
+    return dateFormatter
+  }()
+  
+  static var byteCountSizeFormatter: NumberFormatter = {
+    let numberFormatter = NumberFormatter()
+    numberFormatter.numberStyle = .decimal
+    return numberFormatter
+  }()
+  
+  static let byteFormatter = ByteCountFormatter()
+  
+  private func formattedFileSize(_ fileSize: UInt) -> String {
+    FileItemView.byteFormatter.allowedUnits = [.useAll]
+    FileItemView.byteFormatter.countStyle = .file
+    return FileItemView.byteFormatter.string(fromByteCount: Int64(fileSize))
+  }
+  
+  // Format byte count Int into string like: 23.4M (24,601,664 bytes)
+  private func formattedSize(byteCount: Int) -> String {
+    let formattedByteCount = Self.byteCountSizeFormatter.string(from: NSNumber(value:byteCount)) ?? "0"
+    return "\(FileItemView.byteFormatter.string(fromByteCount: Int64(byteCount))) (\(formattedByteCount) bytes)"
+  }
+}
+
+//#Preview {
+//  FileDetailsView(details: FileDetails(name: "AppleWorks 6.sit", path: [""], size: 24601664, comment: "test comment", type: "SITD", creator: "SIT!", created: Date.now, modified: Date.now ))
+//}
diff --git a/Hotline/macOS/Files/FileItemView.swift b/Hotline/macOS/Files/FileItemView.swift
new file mode 100644
index 0000000..31a8af7
--- /dev/null
+++ b/Hotline/macOS/Files/FileItemView.swift
@@ -0,0 +1,67 @@
+import SwiftUI
+
+struct FileItemView: View {
+  @Environment(HotlineState.self) private var model: HotlineState
+  
+  var file: FileInfo
+  let depth: Int
+  
+  var body: some View {
+    HStack(alignment: .center, spacing: 0) {
+      Spacer()
+        .frame(width: CGFloat(depth * (12 + 2)))
+      
+      Spacer()
+        .frame(width: 10)
+        .padding(.leading, 4)
+        .padding(.trailing, 8)
+      
+      HStack(alignment: .center) {
+        if file.isUnavailable {
+          Image(systemName: "questionmark.app.fill")
+            .frame(width: 16, height: 16)
+            .opacity(0.5)
+        }
+        else {
+          FileIconView(filename: file.name, fileType: file.type)
+            .frame(width: 16, height: 16)
+        }
+      }
+      .frame(width: 16)
+      .padding(.trailing, 6)
+      
+      Text(file.name)
+        .lineLimit(1)
+        .truncationMode(.tail)
+        .opacity(file.isUnavailable ? 0.5 : 1.0)
+
+      Spacer()
+      if !file.isUnavailable {
+        Text(formattedFileSize(file.fileSize))
+          .foregroundStyle(.secondary)
+          .lineLimit(1)
+          .padding(.trailing, 6)
+      }
+    }
+    .frame(maxWidth: .infinity, maxHeight: .infinity)
+
+    if file.expanded {
+      ForEach(file.children!, id: \.self) { childFile in
+        if childFile.isFolder {
+          FolderItemView(file: childFile, depth: self.depth + 1).tag(file.id)
+        }
+        else {
+          FileItemView(file: childFile, depth: self.depth + 1).tag(file.id)
+        }
+      }
+    }
+  }
+  
+  static let byteFormatter = ByteCountFormatter()
+  
+  private func formattedFileSize(_ fileSize: UInt) -> String {
+    FileItemView.byteFormatter.allowedUnits = [.useAll]
+    FileItemView.byteFormatter.countStyle = .file
+    return FileItemView.byteFormatter.string(fromByteCount: Int64(fileSize))
+  }
+}
diff --git a/Hotline/macOS/Files/FilePreviewImageView.swift b/Hotline/macOS/Files/FilePreviewImageView.swift
new file mode 100644
index 0000000..5469e23
--- /dev/null
+++ b/Hotline/macOS/Files/FilePreviewImageView.swift
@@ -0,0 +1,124 @@
+import SwiftUI
+import UniformTypeIdentifiers
+
+struct FilePreviewImageView: View {
+  enum FilePreviewFocus: Hashable {
+    case window
+  }
+
+  @Environment(\.controlActiveState) private var controlActiveState
+  @Environment(\.colorScheme) private var colorScheme
+  @Environment(\.dismiss) var dismiss
+
+  @Binding var info: PreviewFileInfo?
+  
+  @State var preview: FilePreviewState? = nil
+  @FocusState private var focusField: FilePreviewFocus?
+
+  var body: some View {
+    Group {
+      if preview?.state != .loaded {
+        HStack(alignment: .center, spacing: 0) {
+          ProgressView(value: max(0.0, min(1.0, preview?.progress ?? 0.0)))
+            .focusable(false)
+            .progressViewStyle(.circular)
+            .controlSize(.extraLarge)
+            .tint(.white)
+            .frame(maxWidth: 300, alignment: .center)
+        }
+        .frame(minWidth: 350, maxWidth: 350, minHeight: 150, maxHeight: 150)
+        .padding()
+      } else {
+        if let image = preview?.image {
+          FileImageView(image: image)
+            .frame(minWidth: 200, maxWidth: .infinity, minHeight: 200, maxHeight: .infinity)
+        } else {
+          VStack(alignment: .center, spacing: 0) {
+            Spacer()
+
+            Image(systemName: "eye.trianglebadge.exclamationmark")
+              .resizable()
+              .scaledToFit()
+              .frame(maxWidth: .infinity)
+              .frame(height: 48)
+              .padding(.bottom)
+            Group {
+              Text("This file type is not previewable")
+                .bold()
+              Text("Try downloading and opening this file in another application.")
+                .foregroundStyle(Color.secondary)
+            }
+            .font(.system(size: 14.0))
+            .frame(maxWidth: 300)
+            .multilineTextAlignment(.center)
+
+            Spacer()
+          }
+          .frame(minWidth: 350, maxWidth: 350, minHeight: 150, maxHeight: 150)
+          .padding()
+        }
+      }
+    }
+    .focusable()
+    .focusEffectDisabled()
+    .focused($focusField, equals: .window)
+    .preferredColorScheme(.dark)
+    .navigationTitle(info?.name ?? "Preview")
+    .background(.black)
+    .toolbar {
+      ToolbarItem(placement: .navigation) {
+        FileIconView(filename: info?.name ?? "", fileType: nil)
+          .frame(width: 16, height: 16)
+          .opacity(controlActiveState == .inactive ? 0.5 : 1.0)
+      }
+
+      if let img = preview?.image {
+        if let info = info {
+          ToolbarItem(placement: .primaryAction) {
+            Button {
+              if let fileURL = preview?.fileURL,
+                 let data = try? Data(contentsOf: fileURL) {
+                let _ = data.saveAsFileToDownloads(filename: info.name)
+              }
+            } label: {
+              Label("Download Image...", systemImage: "arrow.down")
+            }
+            .help("Download Image")
+          }
+
+          ToolbarItem(placement: .primaryAction) {
+            ShareLink(item: img, preview: SharePreview(info.name, image: img)) {
+              Label("Share Image...", systemImage: "square.and.arrow.up")
+            }
+            .help("Share Image")
+          }
+        }
+      }
+    }
+    .task {
+      if let info = info {
+        preview = FilePreviewState(info: info)
+        preview?.download()
+      }
+    }
+    .onAppear {
+      if info == nil {
+        Task {
+          dismiss()
+        }
+        return
+      }
+
+      focusField = .window
+    }
+    .onDisappear {
+      preview?.cancel()
+      dismiss()
+    }
+    .onChange(of: preview?.state) {
+      if preview?.state == .failed {
+        dismiss()
+      }
+    }
+  }
+}
diff --git a/Hotline/macOS/Files/FilePreviewQuickLookView.swift b/Hotline/macOS/Files/FilePreviewQuickLookView.swift
new file mode 100644
index 0000000..a504a7a
--- /dev/null
+++ b/Hotline/macOS/Files/FilePreviewQuickLookView.swift
@@ -0,0 +1,114 @@
+import SwiftUI
+import UniformTypeIdentifiers
+
+struct FilePreviewQuickLookView: View {
+  enum FilePreviewFocus: Hashable {
+    case window
+  }
+
+  @Environment(\.controlActiveState) private var controlActiveState
+  @Environment(\.colorScheme) private var colorScheme
+  @Environment(\.dismiss) private var dismiss
+
+  @Binding var info: PreviewFileInfo?
+  @State private var preview: FilePreviewState? = nil
+  
+  @FocusState private var focusField: FilePreviewFocus?
+
+  var body: some View {
+    Group {
+      if self.preview?.state != .loaded {
+        VStack(alignment: .center, spacing: 0) {
+          Spacer()
+          ProgressView(value: max(0.0, min(1.0, self.preview?.progress ?? 0.0)))
+            .focusable(false)
+            .progressViewStyle(.circular)
+            .controlSize(.extraLarge)
+            .frame(maxWidth: 300, alignment: .center)
+            .padding(.bottom, 48)
+          Spacer()
+        }
+        .background(Color(nsColor: .textBackgroundColor))
+        .frame(minWidth: 350, maxWidth: .infinity, minHeight: 150, maxHeight: .infinity)
+        .padding()
+      }
+      else {
+        if let fileURL = self.preview?.fileURL {
+          QuickLookPreviewView(fileURL: fileURL)
+            .frame(minWidth: 400, maxWidth: .infinity, minHeight: 400, maxHeight: .infinity)
+        }
+        else {
+          VStack(alignment: .center, spacing: 0) {
+            Spacer()
+
+            Image(systemName: "eye.trianglebadge.exclamationmark")
+              .resizable()
+              .scaledToFit()
+              .frame(maxWidth: .infinity)
+              .frame(height: 48)
+              .padding(.bottom)
+            Group {
+              Text("This file type is not previewable")
+                .bold()
+              Text("Try downloading and opening this file in another application.")
+                .foregroundStyle(Color.secondary)
+            }
+            .font(.system(size: 14.0))
+            .frame(maxWidth: 300)
+            .multilineTextAlignment(.center)
+
+            Spacer()
+            Spacer()
+          }
+          .frame(minWidth: 350, maxWidth: .infinity, minHeight: 150, maxHeight: .infinity)
+          .padding()
+        }
+      }
+    }
+    .focusable()
+    .focusEffectDisabled()
+    .background(Color(nsColor: .textBackgroundColor))
+    .focused(self.$focusField, equals: .window)
+    .navigationTitle(self.info?.name ?? "File Preview")
+    .applyNavigationDocumentIfPresent(self.preview?.fileURL)
+    .toolbar {
+      if let fileURL = self.preview?.fileURL {
+        if let info = info {
+          ToolbarItem(placement: .primaryAction) {
+            Button {
+              FileManager.default.copyToDownloads(from: fileURL, using: info.name, bounceDock: true)
+            } label: {
+              Label("Download File...", systemImage: "arrow.down")
+            }
+            .help("Download File")
+          }
+        }
+      }
+    }
+    .task {
+      if let info = self.info {
+        self.preview = FilePreviewState(info: info)
+        self.preview?.download()
+      }
+    }
+    .onAppear {
+      guard self.info != nil else {
+        self.dismiss()
+        return
+      }
+
+      self.focusField = .window
+    }
+    .onDisappear {
+      self.preview?.cancel()
+      self.preview?.cleanup()
+      self.dismiss()
+    }
+    .onChange(of: self.preview?.state) {
+      if self.preview?.state == .failed {
+        self.dismiss()
+      }
+    }
+    .preferredColorScheme(.dark)
+  }
+}
diff --git a/Hotline/macOS/Files/FilePreviewTextView.swift b/Hotline/macOS/Files/FilePreviewTextView.swift
new file mode 100644
index 0000000..2f9a85c
--- /dev/null
+++ b/Hotline/macOS/Files/FilePreviewTextView.swift
@@ -0,0 +1,128 @@
+import SwiftUI
+import UniformTypeIdentifiers
+
+struct FilePreviewTextView: View {
+  enum FilePreviewFocus: Hashable {
+    case window
+  }
+
+  @Environment(\.controlActiveState) private var controlActiveState
+  @Environment(\.colorScheme) private var colorScheme
+  @Environment(\.dismiss) var dismiss
+
+  @Binding var info: PreviewFileInfo?
+  @State var preview: FilePreviewState? = nil
+  @FocusState private var focusField: FilePreviewFocus?
+
+  var body: some View {
+    Group {
+      if preview?.state != .loaded {
+        VStack(alignment: .center, spacing: 0) {
+          Spacer()
+          ProgressView(value: max(0.0, min(1.0, preview?.progress ?? 0.0)))
+            .focusable(false)
+            .progressViewStyle(.circular)
+            .controlSize(.extraLarge)
+            .tint(.white)
+            .frame(maxWidth: 300, alignment: .center)
+          Spacer()
+          Spacer()
+        }
+        .background(Color(nsColor: .textBackgroundColor))
+        .frame(minWidth: 350, maxWidth: .infinity, minHeight: 150, maxHeight: .infinity)
+        .padding()
+      } else {
+        if let text = preview?.text {
+          TextEditor(text: .constant(text))
+            .textEditorStyle(.plain)
+            .font(.system(size: 14))
+            .lineSpacing(3)
+            .padding(16)
+            .contentMargins(.top, -16.0, for: .scrollIndicators)
+            .contentMargins(.bottom, -16.0, for: .scrollIndicators)
+            .contentMargins(.trailing, -16.0, for: .scrollIndicators)
+            .scrollClipDisabled()
+            .frame(maxWidth: .infinity, maxHeight: .infinity)
+        } else {
+          VStack(alignment: .center, spacing: 0) {
+            Spacer()
+
+            Image(systemName: "eye.trianglebadge.exclamationmark")
+              .resizable()
+              .scaledToFit()
+              .frame(maxWidth: .infinity)
+              .frame(height: 48)
+              .padding(.bottom)
+            Group {
+              Text("This file type is not previewable")
+                .bold()
+              Text("Try downloading and opening this file in another application.")
+                .foregroundStyle(Color.secondary)
+            }
+            .font(.system(size: 14.0))
+            .frame(maxWidth: 300)
+            .multilineTextAlignment(.center)
+
+            Spacer()
+            Spacer()
+          }
+          .frame(minWidth: 350, maxWidth: .infinity, minHeight: 150, maxHeight: .infinity)
+          .padding()
+        }
+      }
+    }
+    .focusable()
+    .focusEffectDisabled()
+    .background(Color(nsColor: .textBackgroundColor))
+    .focused($focusField, equals: .window)
+    .navigationTitle(info?.name ?? "File Preview")
+    .toolbar {
+      ToolbarItem(placement: .navigation) {
+        FileIconView(filename: info?.name ?? "", fileType: nil)
+          .frame(width: 16, height: 16)
+          .opacity(controlActiveState == .inactive ? 0.5 : 1.0)
+      }
+
+      if preview?.text != nil {
+        if let info = info {
+          ToolbarItem(placement: .primaryAction) {
+            Button {
+              if let fileURL = preview?.fileURL,
+                 let data = try? Data(contentsOf: fileURL) {
+                let _ = data.saveAsFileToDownloads(filename: info.name)
+              }
+            } label: {
+              Label("Save Text File...", systemImage: "square.and.arrow.down")
+            }
+            .help("Save Text File")
+          }
+        }
+      }
+    }
+    .task {
+      if let info = info {
+        preview = FilePreviewState(info: info)
+        preview?.download()
+      }
+    }
+    .onAppear {
+      if info == nil {
+        Task {
+          dismiss()
+        }
+        return
+      }
+
+      focusField = .window
+    }
+    .onDisappear {
+      preview?.cancel()
+      dismiss()
+    }
+    .onChange(of: preview?.state) {
+      if preview?.state == .failed {
+        dismiss()
+      }
+    }
+  }
+}
diff --git a/Hotline/macOS/Files/FilesView.swift b/Hotline/macOS/Files/FilesView.swift
new file mode 100644
index 0000000..c9c4c24
--- /dev/null
+++ b/Hotline/macOS/Files/FilesView.swift
@@ -0,0 +1,529 @@
+import SwiftUI
+import UniformTypeIdentifiers
+import AppKit
+
+struct FilesView: View {
+  @Environment(HotlineState.self) private var model: HotlineState
+  @Environment(\.openWindow) private var openWindow
+  
+  @State private var selection: FileInfo?
+  @State private var fileDetails: FileDetails?
+  @State private var uploadFileSelectorDisplayed: Bool = false
+  @State private var searchText: String = ""
+  @State private var isSearching: Bool = false
+  @State private var dragOver: Bool = false
+  @State private var confirmDeleteShown: Bool = false
+  @State private var newFolderShown: Bool = false
+  
+  var body: some View {
+    NavigationStack {
+      List(self.displayedFiles, id: \.self, selection: self.$selection) { file in
+        if file.isFolder {
+          FolderItemView(file: file, depth: 0).tag(file.id)
+        }
+        else {
+          FileItemView(file: file, depth: 0).tag(file.id)
+        }
+      }
+      .environment(\.defaultMinListRowHeight, 28)
+      .listStyle(.inset)
+      .alternatingRowBackgrounds(.enabled)
+      .onDrop(of: [.fileURL], isTargeted: self.$dragOver) { items in
+        guard self.model.access?.contains(.canUploadFiles) == true,
+              let item = items.first,
+              let identifier = item.registeredTypeIdentifiers.first else {
+          return false
+        }
+        
+        item.loadItem(forTypeIdentifier: identifier, options: nil) { (urlData, error) in
+          DispatchQueue.main.async {
+            if let urlData = urlData as? Data,
+               let fileURL = URL(dataRepresentation: urlData, relativeTo: nil, isAbsolute: true) {
+
+              // Access security-scoped resource for drag-and-drop
+              let didStartAccessing = fileURL.startAccessingSecurityScopedResource()
+              defer {
+                if didStartAccessing {
+                  fileURL.stopAccessingSecurityScopedResource()
+                }
+              }
+
+              self.upload(file: fileURL, to: [])
+            }
+          }
+        }
+        
+        return true
+      }
+      .task {
+        if !self.model.filesLoaded {
+          let _ = try? await self.model.getFileList()
+        }
+      }
+      .contextMenu(forSelectionType: FileInfo.self) { items in
+        let selectedFile = items.first
+        
+        Button {
+          if let s = selectedFile {
+            downloadFile(s)
+          }
+        } label: {
+          Label("Download", systemImage: "arrow.down")
+        }
+        .disabled(selectedFile == nil)
+        
+        Divider()
+                
+        Button {
+          if let s = selectedFile {
+            getFileInfo(s)
+          }
+        } label: {
+          Label("Get Info", systemImage: "info.circle")
+        }
+        .disabled(selectedFile == nil)
+        
+        Button {
+          if let s = selectedFile {
+            previewFile(s)
+          }
+        } label: {
+          Label("Preview", systemImage: "eye")
+        }
+        .disabled(selectedFile == nil || (selectedFile != nil && !selectedFile!.isPreviewable))
+        
+        if model.access?.contains(.canDeleteFiles) == true {
+          Divider()
+          
+          Button {
+            self.confirmDeleteShown = true
+          } label: {
+            Label("Delete...", systemImage: "trash")
+          }
+          .disabled(selectedFile == nil)
+        }
+      } primaryAction: { items in
+        guard let clickedFile = items.first else {
+          return
+        }
+        
+        self.selection = clickedFile
+        if clickedFile.isFolder {
+          clickedFile.expanded.toggle()
+        }
+        else {
+          downloadFile(clickedFile)
+        }
+      }
+      .onKeyPress(.rightArrow) {
+        if let s = selection, s.isFolder {
+          s.expanded = true
+          return .handled
+        }
+        return .ignored
+      }
+      .onKeyPress(.leftArrow) {
+        if let s = selection, s.isFolder {
+          s.expanded = false
+          return .handled
+        }
+        return .ignored
+      }
+      .onKeyPress(.space) {
+        if let s = selection, s.isPreviewable {
+          previewFile(s)
+          return .handled
+        }
+        return .ignored
+      }
+      .overlay {
+        if !model.filesLoaded {
+          VStack {
+            ProgressView()
+              .controlSize(.large)
+          }
+          .frame(maxWidth: .infinity)
+        }
+      }
+      .searchable(text: $searchText, isPresented: $isSearching, placement: .automatic, prompt: "Search")
+      .background(Button("", action: { isSearching = true }).keyboardShortcut("f").hidden())
+      .toolbar {
+        ToolbarItem {
+          Button {
+            if let selectedFile = selection, selectedFile.isPreviewable {
+              self.previewFile(selectedFile)
+            }
+          } label: {
+            Label("Preview", systemImage: "eye")
+          }
+          .help("Preview")
+          .disabled(selection == nil || selection?.isPreviewable != true)
+        }
+        
+        ToolbarItem {
+          Button {
+            if let selectedFile = selection {
+              self.getFileInfo(selectedFile)
+            }
+          } label: {
+            Label("Get Info", systemImage: "info.circle")
+          }
+          .help("Get Info")
+          .disabled(selection == nil)
+        }
+        
+        ToolbarItem {
+          Button {
+            self.uploadFileSelectorDisplayed = true
+          } label: {
+            Label("Upload", systemImage: "arrow.up")
+          }
+          .help("Upload")
+          .disabled(model.access?.contains(.canUploadFiles) != true)
+        }
+        
+        ToolbarItem {
+          Button {
+            if let selectedFile = selection {
+              self.downloadFile(selectedFile)
+            }
+          } label: {
+            Label("Download", systemImage: "arrow.down")
+          }
+          .help("Download")
+          .disabled(selection == nil || model.access?.contains(.canDownloadFiles) != true)
+        }
+        
+        if #available(macOS 26.0, *) {
+          ToolbarSpacer()
+        }
+        
+        if self.model.access?.contains(.canCreateFolders) == true {
+          ToolbarItem {
+            Button {
+              self.newFolderShown = true
+            } label: {
+              Label("New Folder", systemImage: "folder.badge.plus")
+            }
+            .help("New Folder")
+            .popover(isPresented: self.$newFolderShown, arrowEdge: .bottom) {
+              NewFolderPopover { folderName in
+                self.newFolder(name: folderName, parent: self.selection)
+              }
+            }
+          }
+        }
+        
+        if self.model.access?.contains(.canDeleteFiles) == true || self.model.access?.contains(.canDeleteFolders) == true {
+          ToolbarItem {
+            Button {
+              self.confirmDeleteShown = true
+            } label: {
+              Label("Delete", systemImage: "trash")
+            }
+            .disabled(self.selection == nil)
+            .help("Delete")
+          }
+        }
+      }
+    }
+    .alert("Are you sure you want to permanently delete \"\(self.selection?.name ?? "this file")\"?", isPresented: self.$confirmDeleteShown, actions: {
+      Button("Delete", role: .destructive) {
+        if let s = self.selection {
+          Task {
+            await self.deleteFile(s)
+          }
+        }
+      }
+    }, message: {
+      Text("You cannot undo this action.")
+    })
+    .sheet(item: self.$fileDetails) { item in
+      FileDetailsSheet(details: item)
+    }
+    .fileImporter(isPresented: $uploadFileSelectorDisplayed, allowedContentTypes: [.data, .folder], allowsMultipleSelection: false, onCompletion: { results in
+      switch results {
+      case .success(let fileURLS):
+        guard fileURLS.count > 0,
+              let fileURL = fileURLS.first
+        else {
+          return
+        }
+        
+        var uploadPath: [String] = []
+        
+        if let selection = selection {
+          if selection.isFolder {
+            uploadPath = selection.path
+          }
+          else {
+            uploadPath = Array<String>(selection.path)
+            uploadPath.removeLast()
+          }
+        }
+        
+        print("UPLOAD PATH: \(uploadPath)")
+        self.upload(file: fileURL, to: uploadPath)
+//        uploadFile(file: fileURL, to: uploadPath)
+        
+      case .failure(let error):
+        print(error)
+      }
+    })
+    .onSubmit(of: .search) {
+      #if os(macOS)
+      let shiftPressed = NSApp.currentEvent?.modifierFlags.contains(.shift) ?? false
+      if shiftPressed {
+        model.clearFileListCache()
+      }
+      #endif
+
+      let trimmed = searchText.trimmingCharacters(in: .whitespacesAndNewlines)
+      guard !trimmed.isEmpty else {
+        model.cancelFileSearch()
+        return
+      }
+      searchText = trimmed
+      model.startFileSearch(query: trimmed)
+    }
+    .onChange(of: searchText) { _, newValue in
+      if newValue.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
+        if isShowingSearchResults {
+          model.cancelFileSearch()
+        }
+      }
+    }
+    .onChange(of: model.fileSearchQuery) { _, newValue in
+      if newValue != searchText {
+        searchText = newValue
+      }
+    }
+    .onAppear {
+      if searchText != model.fileSearchQuery {
+        searchText = model.fileSearchQuery
+      }
+    }
+    .safeAreaInset(edge: .top) {
+      if isShowingSearchResults, let message = searchStatusMessage {
+        HStack(alignment: .center, spacing: 6) {
+          if case .searching(_, _) = model.fileSearchStatus {
+            ProgressView()
+              .controlSize(.small)
+              .accentColor(.white)
+              .tint(.white)
+          }
+          else if case .completed = model.fileSearchStatus {
+            Image(systemName: "checkmark.circle.fill")
+              .resizable()
+              .symbolRenderingMode(.monochrome)
+              .foregroundStyle(.white)
+              .aspectRatio(contentMode: .fit)
+              .frame(width: 16, height: 16)
+          }
+          else if case .failed = model.fileSearchStatus {
+            Image(systemName: "exclamationmark.triangle.fill")
+              .resizable()
+              .symbolRenderingMode(.monochrome)
+              .foregroundStyle(.white)
+              .aspectRatio(contentMode: .fit)
+              .frame(width: 16, height: 16)
+          }
+          
+          Text(message)
+            .lineLimit(1)
+            .font(.body)
+            .foregroundStyle(.white)
+          
+          Spacer()
+          
+          if let pathMessage = searchStatusPath {
+            Text(pathMessage)
+              .lineLimit(1)
+              .truncationMode(.tail)
+              .font(.footnote)
+//              .fontWeight(.semibold)
+              .foregroundStyle(.white)
+              .opacity(0.5)
+              .padding(.top, 2)
+          }
+        }
+        .padding(.trailing, 14)
+        .padding(.leading, 8)
+        .padding(.vertical, 8)
+        .background {
+          Group {
+            if case .completed = model.fileSearchStatus {
+              Color.fileComplete
+            }
+            else {
+              Color(nsColor: .controlAccentColor)
+            }
+          }
+          .clipShape(.capsule(style: .continuous))
+        }
+        .padding(.horizontal, 8)
+        .padding(.top, 8)
+      }
+    }
+  }
+  
+  private var isShowingSearchResults: Bool {
+    switch model.fileSearchStatus {
+    case .idle:
+      return !model.fileSearchResults.isEmpty
+    case .cancelled(_):
+      return !model.fileSearchResults.isEmpty
+    default:
+      return true
+    }
+  }
+
+  private var displayedFiles: [FileInfo] {
+    isShowingSearchResults ? model.fileSearchResults : model.files
+  }
+
+  private var searchStatusMessage: String? {
+    switch model.fileSearchStatus {
+    case .searching(let processed, _):
+      let scanned = processed == 1 ? "folder" : "folders"
+      return "Searched \(processed) \(scanned)..."
+    case .completed(let processed):
+      let count = model.fileSearchResults.count
+      let folderWord = processed == 1 ? "folder" : "folders"
+      if count == 0 {
+        return "No files found in \(processed) \(folderWord)"
+      }
+      return "\(count) file\(count == 1 ? "" : "s") found in \(processed) \(folderWord)"
+    case .cancelled(_):
+      if model.fileSearchResults.isEmpty {
+        return nil
+      }
+      return "Search cancelled"
+    case .failed(let message):
+      return "Search failed: \(message)"
+    case .idle:
+      return nil
+    }
+  }
+  
+  private var searchStatusPath: String? {
+    guard let path = model.fileSearchCurrentPath else {
+      return nil
+    }
+    if path.isEmpty {
+      return "/"
+    }
+    return path.joined(separator: "/")
+  }
+    
+  private func openPreviewWindow(_ previewInfo: PreviewFileInfo) {
+    switch previewInfo.previewType {
+    case .image:
+      self.openWindow(id: "preview-quicklook", value: previewInfo)
+    case .text:
+      self.openWindow(id: "preview-quicklook", value: previewInfo)
+    case .unknown:
+      self.openWindow(id: "preview-quicklook", value: previewInfo)
+      return
+    }
+  }
+  
+  @MainActor private func newFolder(name: String, parent: FileInfo?) {
+    Task {
+      var parentFolder: FileInfo? = nil
+      if parent?.isFolder == true {
+        parentFolder = parent
+      }
+      
+      let path: [String] = parentFolder?.path ?? []
+      if try await self.model.newFolder(name: name, parentPath: path) {
+        try await self.model.getFileList(path: path)
+      }
+    }
+  }
+  
+  @MainActor private func getFileInfo(_ file: FileInfo) {
+    Task {
+      if let fileInfo = try? await model.getFileDetails(file.name, path: file.path) {
+        self.fileDetails = fileInfo
+      }
+    }
+  }
+  
+  @MainActor private func downloadFile(_ file: FileInfo) {
+    if file.isFolder {
+      self.model.downloadFolder(file.name, path: file.path)
+    }
+    else {
+      self.model.downloadFile(file.name, path: file.path)
+    }
+  }
+  
+  @MainActor private func uploadFile(file fileURL: URL, to path: [String]) throws {
+    self.model.uploadFile(url: fileURL, path: path) { info in
+      Task {
+        // Refresh file listing to display newly uploaded file.
+        try? await self.model.getFileList(path: path)
+      }
+    }
+  }
+  
+  @MainActor private func upload(file fileURL: URL, to path: [String]) {
+    var fileIsDirectory: ObjCBool = false
+    guard FileManager.default.fileExists(atPath: fileURL.path(percentEncoded: false), isDirectory: &fileIsDirectory) else {
+      return
+    }
+
+    if fileIsDirectory.boolValue {
+      self.model.uploadFolder(url: fileURL, path: path, complete: { info in
+        Task {
+          // Refresh file listing to display newly uploaded file.
+          try? await model.getFileList(path: path)
+        }
+      })
+    }
+    else {
+      self.model.uploadFile(url: fileURL, path: path) { info in
+        Task {
+          // Refresh file listing to display newly uploaded file.
+          try? await model.getFileList(path: path)
+        }
+      }
+    }
+  }
+  
+  @MainActor private func previewFile(_ file: FileInfo) {
+    guard file.isPreviewable else {
+      return
+    }
+  
+    self.model.previewFile(file.name, path: file.path) { info in
+      if let info = info {
+        var extendedInfo = info
+        extendedInfo.creator = file.creator
+        extendedInfo.type = file.type
+        self.openPreviewWindow(extendedInfo)
+      }
+    }
+  }
+  
+  private func deleteFile(_ file: FileInfo) async {
+    var parentPath: [String] = []
+    if file.path.count > 1 {
+      parentPath = Array(file.path[0..<file.path.count-1])
+    }
+    
+    do {
+      try await self.model.deleteFile(file.name, path: file.path)
+      try await self.model.getFileList(path: parentPath)
+    }
+    catch {
+      print("Error deleting file: \(error)")
+    }
+  }
+}
+
+#Preview {
+  FilesView()
+    .environment(HotlineState())
+}
diff --git a/Hotline/macOS/Files/FolderItemView.swift b/Hotline/macOS/Files/FolderItemView.swift
new file mode 100644
index 0000000..f82bb11
--- /dev/null
+++ b/Hotline/macOS/Files/FolderItemView.swift
@@ -0,0 +1,140 @@
+import SwiftUI
+
+struct FolderItemView: View {
+  @Environment(HotlineState.self) private var model: HotlineState
+  
+  @State var loading = false
+  @State var dragOver = false
+  
+  var file: FileInfo
+  let depth: Int
+  
+  @MainActor private func uploadFile(file fileURL: URL) {
+    var filePath: [String] = [String](self.file.path)
+    if !self.file.isFolder {
+      filePath.removeLast()
+    }
+    
+    print("UPLOADING TO PATH: ", filePath)
+    
+    self.model.uploadFile(url: fileURL, path: filePath) { info in
+      Task {
+        // Refresh file listing to display newly uploaded file.
+        try? await model.getFileList(path: filePath)
+      }
+    }
+  }
+  
+  var body: some View {
+    HStack(alignment: .center, spacing: 0) {
+      Spacer()
+        .frame(width: CGFloat(depth * (12 + 2)))
+      
+      Button {
+        if file.isFolder {
+          file.expanded.toggle()
+        }
+      } label: {
+        Text(Image(systemName: file.expanded ? "chevron.down" : "chevron.right"))
+          .bold()
+          .font(.system(size: 10))
+          .foregroundStyle(dragOver ? Color.white : Color.primary)
+          .opacity(0.5)
+      }
+      .buttonStyle(.plain)
+      .frame(width: 10)
+      .padding(.leading, 4)
+      .padding(.trailing, 8)
+      
+      HStack(alignment: .center) {
+        if file.isUnavailable {
+          Image(systemName: "questionmark.app.fill")
+            .frame(width: 16, height: 16)
+            .opacity(0.5)
+        }
+        else if file.isAdminDropboxFolder {
+          Image("Admin Drop Box")
+            .resizable()
+            .scaledToFit()
+            .frame(width: 16, height: 16)
+        }
+        else if file.isDropboxFolder {
+          Image("Drop Box")
+            .resizable()
+            .scaledToFit()
+            .frame(width: 16, height: 16)
+        }
+        else {
+          Image("Folder")
+            .resizable()
+            .scaledToFit()
+            .frame(width: 16, height: 16)
+        }
+      }
+      .frame(width: 16)
+      .padding(.trailing, 6)
+      
+      Text(file.name)
+        .lineLimit(1)
+        .truncationMode(.tail)
+        .foregroundStyle(dragOver ? Color.white : Color.primary)
+        .opacity(file.isUnavailable ? 0.5 : 1.0)
+      
+      if loading {
+        ProgressView().controlSize(.mini).padding([.leading, .trailing], 5)
+      }
+      Spacer()
+      if !file.isUnavailable {
+        Text(file.fileSize == 0 ? "Empty" : "^[\(file.fileSize) \("file")](inflect: true)")
+          .foregroundStyle(dragOver ? Color.white.opacity(0.75) : Color.secondary)
+          .lineLimit(1)
+          .padding(.trailing, 6)
+      }
+    }
+    .frame(maxWidth: .infinity, maxHeight: .infinity)
+    .background(
+      RoundedRectangle(cornerRadius: 4.0)
+        .fill(dragOver ? Color(nsColor: NSColor.selectedContentBackgroundColor) : Color.clear)
+        .padding(.horizontal, -6)
+        .padding(.vertical, -4)
+    )
+    .onChange(of: file.expanded) {
+      loading = false
+      if file.expanded && file.fileSize > 0 {
+        Task {
+          loading = true
+          let _ = try? await model.getFileList(path: file.path)
+          loading = false
+        }
+      }
+    }
+    .onDrop(of: [.fileURL], isTargeted: $dragOver) { items in
+      guard let item = items.first,
+            let identifier = item.registeredTypeIdentifiers.first else {
+        return false
+      }
+      
+      item.loadItem(forTypeIdentifier: identifier, options: nil) { (urlData, error) in
+        DispatchQueue.main.async {
+          if let urlData = urlData as? Data,
+             let fileURL = URL(dataRepresentation: urlData, relativeTo: nil, isAbsolute: true) {
+            self.uploadFile(file: fileURL)
+          }
+        }
+      }
+      
+      return true
+    }
+    
+    if file.expanded {
+      ForEach(file.children!, id: \.self) { childFile in
+        if childFile.isFolder {
+          FolderItemView(file: childFile, depth: self.depth + 1).tag(file.id)
+        }
+        else {
+          FileItemView(file: childFile, depth: self.depth + 1).tag(file.id)
+        }
+      }
+    }
+  }
+}
diff --git a/Hotline/macOS/Files/NewFolderPopover.swift b/Hotline/macOS/Files/NewFolderPopover.swift
new file mode 100644
index 0000000..4e282f5
--- /dev/null
+++ b/Hotline/macOS/Files/NewFolderPopover.swift
@@ -0,0 +1,51 @@
+import SwiftUI
+
+struct NewFolderPopover: View {
+  @Environment(\.dismiss) private var dismiss
+  
+  let action: ((String) -> Void)?
+  
+  @State private var folderName: String = "Untitled Folder"
+  
+  var body: some View {
+    VStack(spacing: 16) {
+      TextField("Folder Name", text: self.$folderName)
+        .onSubmit(of: .text) {
+          self.createFolder()
+        }
+      
+      HStack(spacing: 8) {
+        Spacer()
+        
+        Button("Cancel", role: .cancel) {
+          self.dismiss()
+        }
+        .buttonStyle(.bordered)
+        .buttonBorderShape(.capsule)
+        
+        if #available(macOS 26.0, *) {
+          Button("New Folder", role: .confirm) {
+            self.createFolder()
+          }
+          .buttonStyle(.borderedProminent)
+          .buttonBorderShape(.capsule)
+        }
+        else {
+          Button("OK") {
+            self.dismiss()
+            self.action?(self.folderName)
+          }
+          .buttonStyle(.borderedProminent)
+          .buttonBorderShape(.capsule)
+        }
+      }
+    }
+    .frame(width: 250)
+    .padding()
+  }
+  
+  private func createFolder() {
+    self.dismiss()
+    self.action?(self.folderName)
+  }
+}