Files
shotdeck/Sources/Shotdeck/SendController.swift
T
Claude Fable 5 3061e45bcb feat(ui): rebuild the UX around two surfaces — a glance popover and a session window
The menu-bar popover was being used as a session manager: status, five text fields,
thumbnails, three buttons, a history list and eight more flat rows in 320 pt. The
redesign splits the product by job, from a UX pass whose mockups are kept under
design/ux-rework/.

- Popover: only the current session. Review details as one line plus a pencil that
  opens the window with the Lane field focused, at most three thumbnails, a Capture
  and a Send row, a New Session and Open Redline row, one status line when something
  happened, and a footer with the send channel, the retention policy and a ... menu
  for Settings / updates / quit.
- Window: sidebar of sessions grouped Today / Yesterday / This week / by month with
  a Current tag and each session's state, the selected session's pages as cards
  (select, Delete or Remove Page, sent sessions read-only), and an inspector with
  editable review details, the PDF facts (file name, pages, channel, status) and the
  session facts (started, id, files). Past sessions show their details read-only.
- Settings: three labelled groups (Capture, Sending, Sessions) replacing the
  headings-plus-grid layout.
- Sessions list/search/grouping/state live on the model, so the window and the popover
  read the same truth (came-back-marked state comes from the return ledger).
- Verification: 159 tests, the headless panel self-test, and an end-to-end run against
  the active app (scripts/run-e2e-ui.sh) which opens the real window, types into the
  Lane field with key events and clicks New Session, reporting what the launch mode
  could and could not deliver.
2026-10-31 13:03:08 +04:00

242 lines
12 KiB
Swift
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import AppKit
import Darwin
import Foundation
import ShotdeckCore
/// Result of composing a send PDF. Kept so the self-test can drive the share
/// outcome without presenting a real AirDrop sheet.
struct ComposedSend: Sendable {
let fileName: String
let fileURL: URL
let pageCount: Int
}
extension AppModel: SendCapable {
public func send(anchor: NSView?) async {
guard !session.isEmpty, !isSending else { return }
// Same synchronous guard as AppModel.startNewSession(): refuse while a session
// start is mid-flight, instead of composing from a session directory that is
// being renamed into the archive.
guard !isStartingNewSession else {
setStatus("Finish starting the new session first.")
return
}
setSending(true)
// Wait for any IN-FLIGHT transport/folder reconcile (chooseTransport/
// chooseOneDriveFolder in SettingsView.swift) to fully settle BEFORE
// snapshotting transport/folder below. Without this, a toggle immediately
// followed by Send could let send() read a state that is still mid-transition
// — e.g. the watcher's recordUncommented flag briefly lagging the just-chosen
// transport, so a freshly-sent unmarked OneDrive PDF gets misreported as an
// already-returned document. `Task<Void, Never>.value` never throws, and
// awaiting nil is an immediate no-op (AirDrop mode, or no toggle in flight).
await pendingReconcileTask?.value
// Snapshot BOTH the transport AND the destination folder into local `let`s
// ONCE, before any further `await` in this function. chooseTransport/
// chooseOneDriveFolder also refuse outright (status "Finish the current send
// first.") while isSending is true, but this snapshot is the actual fix for the
// send-vs-switch race: even without that guard, everything below operates on
// these frozen values — composePDFForSend(outbox:transport:) takes both as
// parameters and never re-reads `self.outboxURL`/`self.transport` after a
// suspension point, so a concurrent transport switch mid-send can no longer
// land the PDF under one transport's folder while the archive/status branch
// runs the other's.
let transport = TransportSettings.transport()
let destinationFolder: URL
// OneDrive mode: verify the real destination exists, is writable, AND actually
// accepts a real write RIGHT NOW, before composing anything. `isWritableDirectory`
// alone is not enough — a OneDrive Files-On-Demand directory whose provider
// domain is signed out can report as existing and POSIX-writable while an
// actual write fails, so `probeWritable` writes-fsyncs-removes a tiny real probe
// file to catch that. `outboxURL` is kept in sync with the resolved OneDrive
// folder by bootstrap/chooseTransport/chooseOneDriveFolder, but this is
// re-resolved fresh here (never trusted stale) so a folder that vanished or lost
// its permissions since then (OneDrive signed out, external volume unmounted,
// folder deleted, chmod'd unwritable) is caught instead of silently attempted
// and surfacing as a generic PDF-composition failure.
if transport == .oneDrive {
guard let folder = OneDriveLocator.resolveOneDriveFolder(),
OneDriveLocator.isWritableDirectory(at: folder),
OneDriveLocator.probeWritable(at: folder)
else {
let path = OneDriveLocator.resolveOneDriveFolder()?.path
?? TransportSettings.storedOneDriveFolderPath()
?? "no OneDrive folder found"
setResolvedOneDriveFolder(nil)
setStatus(ShotdeckError.oneDriveFolderUnavailable(path: path).errorDescription)
setSending(false)
return
}
destinationFolder = folder
setResolvedOneDriveFolder(folder)
if outboxURL != folder || watchFolderURL != folder {
setFolderURLs(outbox: folder, watch: folder)
try? await watcher.updateWatchFolder(folder)
}
} else {
destinationFolder = outboxURL
}
let pending: ComposedSend
do {
pending = try await composePDFForSend(outbox: destinationFolder, transport: transport)
} catch {
// Never unlink the published PDF, and never unlink the temp file either:
// a rename failure would leave the complete document at the temp name.
setStatus((error as? ShotdeckError)?.errorDescription ?? "The PDF could not be built.")
setSending(false)
return
}
switch transport {
case .oneDrive:
// No AirDrop, no anchor needed — the PDF is already in the watched
// OneDrive folder. Archive immediately; the iPad marks it up in place.
let pageWord = pending.pageCount == 1 ? "page" : "pages"
await handleDidShareItems(
fileName: pending.fileName,
sentSummary: "Saved to OneDrive — \(pending.pageCount) \(pageWord). Open it in Files on your iPad."
)
setSending(false)
case .airDrop:
guard let anchor else {
handleDidFailToShareItems(fileName: pending.fileName)
setSending(false)
return
}
do {
try Sharing.airDrop(fileURL: pending.fileURL, from: anchor) { [weak self] success in
guard let self else { return }
if success {
let pageWord = pending.pageCount == 1 ? "page" : "pages"
await self.handleDidShareItems(
fileName: pending.fileName,
sentSummary: "Sent — \(pending.pageCount) \(pageWord)."
)
} else {
self.handleDidFailToShareItems(fileName: pending.fileName)
}
self.setSending(false)
}
} catch {
// canPerform false, no service, or no visible window: same as cancel.
handleDidFailToShareItems(fileName: pending.fileName)
setSending(false)
}
}
}
/// Writes the PDF to `outboxDir` and records its path. Does not archive the session
/// and does not present AirDrop — that happens only after the share completes.
/// `outboxDir`/`transport` are passed in (values `send(anchor:)` snapshotted before
/// any await) rather than read from `self.outboxURL`/`self.transport` here, so a
/// concurrent transport switch mid-send can never redirect an in-flight compose to
/// a different folder. A write/rename failure specifically at the destination
/// folder (as opposed to composer.compose()'s own session/image-content failures)
/// is reported as `oneDriveFolderUnavailable` rather than the generic
/// `pdfCompositionFailed` when `transport == .oneDrive` — the File Provider edge
/// case where the folder looked writable moments ago in `send(anchor:)` but the
/// actual write still failed (e.g. OneDrive signed out mid-write).
func composePDFForSend(outbox outboxDir: URL, transport: SendTransport) async throws -> ComposedSend {
let workingSession = session
let composer = self.composer
let sourceDir = paths.sessionDirectory(workingSession.id)
let fileName = PDFComposer.fileName(for: workingSession)
let finalURL = outboxDir.appendingPathComponent(fileName)
// Same directory as the final target so the rename below is same-volume (atomic).
let tempURL = outboxDir.appendingPathComponent(".shotdeck-\(UUID().uuidString).pdf")
// The document title follows the same three parts as the file name: tool,
// lane (when recorded) and Dubai time.
let lane = workingSession.context.lane
let titleParts = ["Redline"]
+ (lane.isEmpty ? [] : [lane])
+ [DubaiTime.stamp(Date())]
let title = titleParts.joined(separator: " – ")
let toolVersion = appVersion
// D-13: build off the main actor. Only Sendable values cross into the
// detached task — never `anchor` (NSView is not Sendable).
try await Task.detached(priority: .userInitiated) {
_ = try composer.compose(
session: workingSession,
imageURL: { capture in sourceDir.appendingPathComponent(capture.fileName) },
title: title,
to: tempURL,
toolVersion: toolVersion
)
// POSIX rename onto `finalURL` replaces any same-name file in one
// directory operation; there is never a window where the PDF is gone.
if Darwin.rename(tempURL.path, finalURL.path) != 0 {
if transport == .oneDrive {
throw ShotdeckError.oneDriveFolderUnavailable(path: outboxDir.path)
}
throw ShotdeckError.pdfCompositionFailed(
reason: "could not publish the PDF: \(String(cString: strerror(errno)))"
)
}
do {
try AtomicFile.fsyncDirectory(at: outboxDir)
} catch {
if transport == .oneDrive {
throw ShotdeckError.oneDriveFolderUnavailable(path: outboxDir.path)
}
throw error
}
}.value
guard FileManager.default.fileExists(atPath: finalURL.path) else {
if transport == .oneDrive {
throw ShotdeckError.oneDriveFolderUnavailable(path: outboxDir.path)
}
throw ShotdeckError.pdfCompositionFailed(reason: "the PDF was not written to disk")
}
rememberLastComposedPDF(finalURL)
return ComposedSend(
fileName: fileName,
fileURL: finalURL,
pageCount: workingSession.captures.count
)
}
/// `NSSharingServiceDelegate.sharingService(_:didShareItems:)` seam — also the
/// OneDrive completion path. Composes ONE truthful status from the caller's success
/// summary (the share itself DID complete) plus, when they happened, the archive
/// error and any state-refresh problem — nothing is overwritten or hidden.
func handleDidShareItems(fileName: String, sentSummary: String) async {
guard !session.isEmpty else { return }
var message = sentSummary
var archivedID: UUID?
do {
archivedID = try await spool.archiveCurrent(pdfFileName: fileName).id
} catch {
message += " \((error as? ShotdeckError)?.errorDescription ?? "Could not archive the session.")"
}
// Refresh model state from the store on BOTH paths: after a successful archive
// the current session and the past-submissions list are stale until reloaded,
// and after a failure the store (not this model) knows whether the session
// actually moved. Any refresh problem is appended to the status, never hidden.
if let refreshProblem = await reloadFromSpool() {
message += " \(refreshProblem)"
}
// Leave the window on the session that was just sent: that is what the person
// is looking at when the PDF leaves.
if let archivedID {
selectSession(archivedID)
}
setStatus(message)
}
/// `NSSharingServiceDelegate.sharingService(_:didFailToShareItems:error:)` seam,
/// also used when `canPerform` is false or the user cancels. Does not archive.
func handleDidFailToShareItems(fileName: String) {
setStatus(
"AirDrop didn't complete — nothing was sent. Your captures are still here; the PDF is on your \(outboxDisplayName) as \(fileName)."
)
}
}