From 6ab398c3f2dbdd961c7d1f7ad4179a736b585f76 Mon Sep 17 00:00:00 2001 From: Claude Fable 5 Date: Sun, 11 Oct 2026 13:35:38 +0400 Subject: [PATCH 1/3] feat(sessions): past submissions list + start-new-session with 10-session retention MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit MMDB-2925. Two new menu functions in the Redline app: - "Start new session" keeps the current screenshots as a past session (moved into the single archive/ folder — never deleted on close) and opens a fresh empty session. Sessions closed without ever sending keep pdfFileName nil and show as "Not sent" in the list. - "Past submissions…" opens a window listing every retained session (timestamp, page count, what was sent) with actions to reveal the sent PDF and the session's screenshot folder. Retention (Ben's rule 2026-10-11: "retain the past 10 sessions"): both archive paths (send and close) keep the newest 10 archived session folders in archive/ and remove the rest. Any PDF a pruned session produced is untouched — it lives in the outbox/OneDrive folder. archivedSessions() ordering now tie-breaks same-second sessions by the session folder's creation date, so listing and pruning are deterministic (manifest timestamps are whole-second ISO8601 — format pinned in AtomicFileTests). Tests: 6 core tests in SessionRetentionTests (close/keep/reconcile, sent-vs-unsent, retention of 10, explicit prune, send-path retention) and 3 app-target tests in SessionWorkflowTests driving the real AppModel menu actions through AppDelegate.makeLaunchModel(). PanelSnapshot renders the new window as panel-06b-past-submissions.png. --- Sources/Shotdeck/AppModel.swift | 96 +++++++ Sources/Shotdeck/MenuBarView.swift | 20 ++ Sources/Shotdeck/PanelSnapshot.swift | 41 ++- Sources/Shotdeck/PastSubmissionsView.swift | 138 ++++++++++ .../ShotdeckCore/Model/CaptureSession.swift | 9 +- Sources/ShotdeckCore/Spool/SpoolStore.swift | 109 +++++++- .../SessionRetentionTests.swift | 242 ++++++++++++++++++ .../ShotdeckTests/SessionWorkflowTests.swift | 153 +++++++++++ 8 files changed, 790 insertions(+), 18 deletions(-) create mode 100644 Sources/Shotdeck/PastSubmissionsView.swift create mode 100644 Tests/ShotdeckCoreTests/SessionRetentionTests.swift create mode 100644 Tests/ShotdeckTests/SessionWorkflowTests.swift diff --git a/Sources/Shotdeck/AppModel.swift b/Sources/Shotdeck/AppModel.swift index 13d67c1..4ddc41e 100644 --- a/Sources/Shotdeck/AppModel.swift +++ b/Sources/Shotdeck/AppModel.swift @@ -14,6 +14,11 @@ public protocol SettingsWindowPresenting: AnyObject { func presentSettingsWindow() } +@MainActor +public protocol SubmissionsWindowPresenting: AnyObject { + func presentSubmissionsWindow() +} + @MainActor public protocol ReturnsSectionProviding: AnyObject { @ViewBuilder func returnsSection() -> AnyView @@ -27,6 +32,8 @@ public final class AppModel { public private(set) var screenRecordingGranted: Bool public private(set) var allReturns: [ReturnedDocument] = [] public private(set) var commentedReturns: [ReturnedDocument] = [] + /// Retained past sessions (newest first) — what the Past submissions window lists. + public private(set) var pastSessions: [CaptureSession] = [] public private(set) var statusLine: String? public private(set) var isCapturing: Bool = false public private(set) var isSending: Bool = false @@ -134,6 +141,7 @@ public final class AppModel { allReturns = all commentedReturns = commented } + func setPastSessions(_ value: [CaptureSession]) { pastSessions = value } func setFolderDisplayNames(outbox: String, watch: String) { outboxDisplayName = outbox watchFolderDisplayName = watch @@ -227,6 +235,12 @@ public final class AppModel { // Empty ledger on first run is not an error. } + do { + setPastSessions(try await spool.archivedSessions()) + } catch { + setStatus((error as? ShotdeckError)?.errorDescription ?? "Could not load past sessions.") + } + // OneDrive mode: outbox == watch folder, so a freshly written, unmarked PDF must // never show up as a return; only a document that already carries a mark does. // Also make sure the resolved OneDrive folder actually exists before the @@ -389,6 +403,88 @@ public final class AppModel { } } + /// True when "Start new session" applies: there is something to keep and no send + /// in flight that would archive the session on its own. + public var canStartNewSession: Bool { !session.isEmpty && !isSending } + + /// Menu "Start new session": keeps the current screenshots as a past session + /// (moved into the single archive folder — never deleted) and opens a fresh empty + /// session. Session retention (newest 10 kept) is applied inside the store, on + /// this path and on the send path alike. + public func startNewSession() async { + var message: String + do { + if let archived = try await spool.closeCurrentSession() { + let count = archived.captures.count + message = "New session — \(count) capture\(count == 1 ? "" : "s") kept as a past session." + } else { + message = "New session started." + } + } catch { + message = (error as? ShotdeckError)?.errorDescription ?? "Could not start a new session." + } + if let refreshProblem = await reloadFromSpool() { + message += " \(refreshProblem)" + } + setStatus(message) + } + + /// Re-reads the open session and the past-session list from the store. Returns a + /// problem description when either read failed (the caller decides how to surface + /// it), nil when everything was refreshed — never silently substitutes stale state. + func reloadFromSpool() async -> String? { + var problems: [String] = [] + do { + replaceSession(try await spool.currentSession()) + } catch { + problems.append( + "Could not reload the current session: \((error as? ShotdeckError)?.errorDescription ?? error.localizedDescription)") + } + do { + setPastSessions(try await spool.archivedSessions()) + } catch { + problems.append( + "Could not load past sessions: \((error as? ShotdeckError)?.errorDescription ?? error.localizedDescription)") + } + return problems.isEmpty ? nil : problems.joined(separator: " ") + } + + /// Where a past session's sent PDF lives now (the outbox in AirDrop mode, the + /// OneDrive folder in OneDrive mode), or nil when it was never sent / is gone. + public func sentPDFURL(for session: CaptureSession) -> URL? { + guard let name = session.pdfFileName else { return nil } + let url = outboxURL.appendingPathComponent(name) + return FileManager.default.fileExists(atPath: url.path) ? url : nil + } + + /// "PDF" action on a past-submission row: reveals the exact PDF that was sent. + public func revealSentPDF(_ session: CaptureSession) { + guard session.pdfFileName != nil else { + setStatus("That session was never sent.") + return + } + guard let url = sentPDFURL(for: session) else { + setStatus("The PDF is no longer in \(outboxDisplayName).") + return + } + NSWorkspace.shared.activateFileViewerSelecting([url]) + } + + /// "Captures" action on a past-submission row: reveals that session's folder. + public func revealSessionCaptures(_ session: CaptureSession) { + let dir = paths.archiveDirectory(session.id) + guard FileManager.default.fileExists(atPath: dir.path) else { + setStatus("That past session is no longer on disk.") + return + } + NSWorkspace.shared.activateFileViewerSelecting([dir]) + } + + /// The single folder every retained session lives in. + public func openSessionsFolder() { + NSWorkspace.shared.open(paths.archive) + } + public func copyCommentedLinks() async { do { let text = try await ledger.clipboardText() diff --git a/Sources/Shotdeck/MenuBarView.swift b/Sources/Shotdeck/MenuBarView.swift index 5e0cc1e..2316170 100644 --- a/Sources/Shotdeck/MenuBarView.swift +++ b/Sources/Shotdeck/MenuBarView.swift @@ -119,6 +119,26 @@ struct MenuBarView: View { } .disabled(!model.canRevealLastPDF) + Button { + Task { await model.startNewSession() } + } label: { + actionLabel("Start new session") + } + .disabled(!model.canStartNewSession) + + Button { + if let presenter = model as? SubmissionsWindowPresenting { + presenter.presentSubmissionsWindow() + } else { + model.setStatus("Past submissions are not available in this build.") + } + } label: { + actionLabel( + "Past submissions…", + trailing: model.pastSessions.isEmpty ? nil : "\(model.pastSessions.count)" + ) + } + Button { Task { await model.captureNow() } } label: { diff --git a/Sources/Shotdeck/PanelSnapshot.swift b/Sources/Shotdeck/PanelSnapshot.swift index b5a7640..cfb899c 100644 --- a/Sources/Shotdeck/PanelSnapshot.swift +++ b/Sources/Shotdeck/PanelSnapshot.swift @@ -46,6 +46,11 @@ enum PanelSnapshot { let region = sampleRegion() + // Two real past sessions through the REAL store paths (one sent with a PDF in + // the outbox, one closed without ever sending) so panel-06b has the exact two + // states the Past submissions window must distinguish. + try await seedPastSessions(to: model) + // 01 — Screen Recording missing (no public mutator; snapshot-only seam). model.snapshotSetScreenRecordingGranted(false) model.replaceRegion(nil) @@ -74,6 +79,15 @@ enum PanelSnapshot { to: directory.appendingPathComponent("panel-06-settings.png") ) + // 06b — Past submissions window against the same isolated model: the two + // seeded past sessions plus the live session's three captures from panel 04. + model.setPastSessions(try await model.spool.archivedSessions()) + try render( + PastSubmissionsView().environment(model), + to: directory.appendingPathComponent("panel-06b-past-submissions.png"), + width: 440 + ) + // 07/08/09 — OneDrive-mode Settings + menu bar, on a SEPARATE isolated model so // this transport switch never bleeds into the AirDrop-mode panels above. try await captureOneDrivePanels(to: directory) @@ -157,6 +171,27 @@ enum PanelSnapshot { try renderMenuBar(model: model, to: directory, name: "09-captures-present-onedrive") } + @MainActor + private static func seedPastSessions(to model: AppModel) async throws { + _ = try await model.spool.append( + pngData: try makePNGData(width: 192, height: 108, red: 0.55, green: 0.35, blue: 0.85), + pixelWidth: 192, pixelHeight: 108, scale: 2.0, capturedAt: Date()) + _ = try await model.spool.append( + pngData: try makePNGData(width: 192, height: 108, red: 0.25, green: 0.7, blue: 0.6), + pixelWidth: 192, pixelHeight: 108, scale: 2.0, capturedAt: Date()) + let sentName = "Redline-\(DubaiTime.fileStamp(Date())).pdf" + _ = try await model.spool.archiveCurrent(pdfFileName: sentName) + // The real send writes the PDF to the outbox; the fixture does the same so the + // row's PDF action is genuinely live in the snapshot. + try Data("%PDF-1.4\n% snapshot fixture\n".utf8).write( + to: model.paths.outbox.appendingPathComponent(sentName)) + + _ = try await model.spool.append( + pngData: try makePNGData(width: 160, height: 90, red: 0.9, green: 0.55, blue: 0.2), + pixelWidth: 160, pixelHeight: 90, scale: 2.0, capturedAt: Date()) + _ = try await model.spool.closeCurrentSession() + } + @MainActor private static func renderMenuBar(model: AppModel, to directory: URL, name: String) throws { try render( @@ -166,9 +201,9 @@ enum PanelSnapshot { } @MainActor - private static func render(_ view: some View, to url: URL) throws { + private static func render(_ view: some View, to url: URL, width: CGFloat = panelWidth) throws { let wrapped = view - .frame(width: panelWidth, alignment: .topLeading) + .frame(width: width, alignment: .topLeading) .fixedSize(horizontal: false, vertical: true) .background(Color(nsColor: .windowBackgroundColor)) @@ -196,7 +231,7 @@ enum PanelSnapshot { size.height = hosting.intrinsicContentSize.height } if size.height < 1 { size.height = 240 } - size.width = panelWidth + size.width = width size.height = ceil(size.height) hosting.setFrameSize(size) diff --git a/Sources/Shotdeck/PastSubmissionsView.swift b/Sources/Shotdeck/PastSubmissionsView.swift new file mode 100644 index 0000000..bfc23c8 --- /dev/null +++ b/Sources/Shotdeck/PastSubmissionsView.swift @@ -0,0 +1,138 @@ +import AppKit +import SwiftUI +import ShotdeckCore + +/// "Past submissions…" window: every retained session and what was sent for it. +/// Read-and-reveal only — keeping/starting sessions is driven from the menu rows +/// (and the button on the current-session row below). +struct PastSubmissionsView: View { + @Environment(AppModel.self) private var model + + var body: some View { + VStack(alignment: .leading, spacing: 8) { + currentSessionRow + Divider() + if model.pastSessions.isEmpty { + Text("No past sessions yet. Use “Start new session” to keep the current captures.") + .font(.caption) + .foregroundStyle(.secondary) + .fixedSize(horizontal: false, vertical: true) + } else { + ScrollView { + VStack(alignment: .leading, spacing: 6) { + ForEach(model.pastSessions) { session in + PastSessionRow(session: session) + } + } + } + .frame(maxHeight: 320) + } + Divider() + footer + } + .padding(10) + .frame(width: 420, alignment: .leading) + .controlSize(.small) + .task { + if let problem = await model.reloadFromSpool() { + model.setStatus(problem) + } + } + } + + private var currentSessionRow: some View { + HStack(alignment: .center, spacing: 8) { + VStack(alignment: .leading, spacing: 2) { + Text("Current session") + .font(.caption) + .foregroundStyle(.secondary) + Text(currentSessionSummary) + .fixedSize(horizontal: false, vertical: true) + } + Spacer(minLength: 8) + Button("Start new session") { + Task { await model.startNewSession() } + } + .disabled(!model.canStartNewSession) + .help("Keeps these captures as a past session and starts a fresh one.") + } + } + + private var currentSessionSummary: String { + let count = model.session.captures.count + if count == 0 { + return "Nothing captured yet." + } + return "\(count) capture\(count == 1 ? "" : "s") · started \(DubaiTime.stamp(model.session.createdAt))" + } + + private var footer: some View { + HStack(spacing: 8) { + Text("Sessions are kept in one folder — the newest \(SpoolStore.defaultRetainedSessionCount).") + .font(.caption) + .foregroundStyle(.secondary) + .fixedSize(horizontal: false, vertical: true) + Spacer(minLength: 8) + Button("Open sessions folder") { + model.openSessionsFolder() + } + } + } +} + +private struct PastSessionRow: View { + @Environment(AppModel.self) private var model + let session: CaptureSession + + var body: some View { + HStack(alignment: .center, spacing: 8) { + VStack(alignment: .leading, spacing: 2) { + Text(DubaiTime.stamp(session.createdAt)) + Text(submissionLabel) + .font(.caption) + .foregroundStyle(session.pdfFileName == nil ? .secondary : .primary) + .lineLimit(1) + } + Spacer(minLength: 8) + Button("PDF") { + model.revealSentPDF(session) + } + .disabled(model.sentPDFURL(for: session) == nil) + .help(session.pdfFileName.map { "Reveal \($0)" } ?? "This session was never sent.") + Button("Captures") { + model.revealSessionCaptures(session) + } + .help("Reveal this session's screenshots") + } + } + + private var submissionLabel: String { + let pages = "\(session.captures.count) page\(session.captures.count == 1 ? "" : "s")" + guard let name = session.pdfFileName else { + return "\(pages) · not sent" + } + return "\(pages) · sent as \(name)" + } +} + +extension AppModel: SubmissionsWindowPresenting { + private static var submissionsWindowController: NSWindowController? + + public func presentSubmissionsWindow() { + if let existing = Self.submissionsWindowController { + existing.window?.makeKeyAndOrderFront(nil) + NSApp.activate() + return + } + let hosting = NSHostingController(rootView: PastSubmissionsView().environment(self)) + let window = NSWindow(contentViewController: hosting) + window.title = "Redline — Past submissions" + window.styleMask = [.titled, .closable] + window.isReleasedWhenClosed = false + window.center() + let controller = NSWindowController(window: window) + Self.submissionsWindowController = controller + controller.showWindow(nil) + NSApp.activate() + } +} diff --git a/Sources/ShotdeckCore/Model/CaptureSession.swift b/Sources/ShotdeckCore/Model/CaptureSession.swift index c12644e..b61a65d 100644 --- a/Sources/ShotdeckCore/Model/CaptureSession.swift +++ b/Sources/ShotdeckCore/Model/CaptureSession.swift @@ -2,7 +2,7 @@ import Foundation public enum SessionState: String, Codable, Sendable { case open // accepting captures - case archived // its PDF has been built and sent; kept forever, never deleted + case archived // closed and kept as a past session (sent or not); pruned by retention } /// The manifest persisted as session.json alongside the PNGs. @@ -11,7 +11,9 @@ public struct CaptureSession: Codable, Sendable, Identifiable, Equatable { public let createdAt: Date public private(set) var state: SessionState public private(set) var captures: [Capture] - /// Set when the PDF is built, so a re-send reuses the same file. + /// Set when the PDF is built, so a re-send reuses the same file. nil on a + /// session that was closed without ever sending — the Past submissions list + /// shows that as "Not sent". public private(set) var pdfFileName: String? public init( @@ -61,7 +63,8 @@ public struct CaptureSession: Codable, Sendable, Identifiable, Equatable { } /// Value-semantic: returns a new session; does not mutate `self`. - public func markArchived(pdfFileName: String) -> CaptureSession { + /// `pdfFileName` is nil when the session is closed without ever sending. + public func markArchived(pdfFileName: String?) -> CaptureSession { CaptureSession( id: id, createdAt: createdAt, diff --git a/Sources/ShotdeckCore/Spool/SpoolStore.swift b/Sources/ShotdeckCore/Spool/SpoolStore.swift index 798399e..7225137 100644 --- a/Sources/ShotdeckCore/Spool/SpoolStore.swift +++ b/Sources/ShotdeckCore/Spool/SpoolStore.swift @@ -4,6 +4,13 @@ import CoreGraphics import Darwin public actor SpoolStore { + /// How many archived sessions (past submissions) are kept on disk. Ben's + /// retention rule (2026-10-11): "by default, retain the past 10 sessions" — + /// older session folders are removed from `archive/` once this is exceeded. + /// Any PDF a pruned session produced is not touched: it lives in the outbox + /// (or the OneDrive folder) it was sent to. + public static let defaultRetainedSessionCount = 10 + private let paths: AppSupportPaths private var openSession: CaptureSession @@ -87,25 +94,87 @@ public actor SpoolStore { } /// Closes the open session (must be non-empty), moves its directory under archive/, records - /// pdfFileName, and starts a fresh empty open session. Returns the archived one. + /// pdfFileName, starts a fresh empty open session, and applies session retention. + /// Returns the archived one. public func archiveCurrent(pdfFileName: String) throws -> CaptureSession { guard !openSession.isEmpty else { throw ShotdeckError.spoolWriteFailed( path: paths.sessionDirectory(openSession.id).path, underlying: "cannot archive an empty session") } - let archived = openSession.markArchived(pdfFileName: pdfFileName) - let sessionDir = paths.sessionDirectory(openSession.id) + let archived = try moveOpenSessionToArchive(openSession.markArchived(pdfFileName: pdfFileName)) + openSession = try Self.createFreshSession(paths: paths) + try applyRetention() + return archived + } + + /// Closes the open session — sent or not — and keeps its captures as a past + /// session under archive/, then starts a fresh empty open session. Unlike + /// `archiveCurrent(pdfFileName:)` this never requires a PDF: the archived session + /// keeps whatever pdfFileName it already has (nil when it was never sent, which + /// the Past submissions list shows as "Not sent"). An empty open session is + /// simply replaced — there is nothing to keep. Returns the archived session, or + /// nil when the open session was empty. + public func closeCurrentSession() throws -> CaptureSession? { + guard !openSession.isEmpty else { + openSession = try Self.createFreshSession(paths: paths) + return nil + } + let archived = try moveOpenSessionToArchive( + openSession.markArchived(pdfFileName: openSession.pdfFileName)) + openSession = try Self.createFreshSession(paths: paths) + try applyRetention() + return archived + } + + /// Keeps the newest `limit` archived sessions and removes the rest of the session + /// folders from archive/ (the single folder all sessions live in). Returns the + /// removed ids. Only UUID session folders directly under archive/ are ever + /// touched — never spool/, never anything else. This is the requested retention + /// policy (Ben, 2026-10-11: "retain the past 10 sessions"): a session folder + /// dropped here is gone for good, while any PDF it produced stays in the + /// outbox/OneDrive folder it was sent to. + public func pruneArchivedSessions(keeping limit: Int) throws -> [UUID] { + let sessions = try archivedSessions() + guard sessions.count > limit else { return [] } + var removed: [UUID] = [] + for session in sessions.dropFirst(limit) { + let dir = paths.archiveDirectory(session.id) + do { + try FileManager.default.removeItem(at: dir) + } catch { + throw ShotdeckError.spoolWriteFailed( + path: dir.path, + underlying: "could not remove an expired session: \(error.localizedDescription)") + } + removed.append(session.id) + } + try AtomicFile.fsyncDirectory(at: paths.archive) + return removed + } + + /// The retention policy every archive path funnels through, so it can never be + /// forgotten: new sessions over the default count are pruned. + private func applyRetention() throws { + let removed = try pruneArchivedSessions(keeping: Self.defaultRetainedSessionCount) + if !removed.isEmpty { + Log.spool.warning( + "Session retention: removed \(removed.count, privacy: .public) archived session(s) beyond the newest \(Self.defaultRetainedSessionCount, privacy: .public).") + } + } + + /// Writes the archived manifest, then renames the whole session directory from + /// spool/ into archive/ in one atomic operation. + private func moveOpenSessionToArchive(_ archived: CaptureSession) throws -> CaptureSession { + let sessionDir = paths.sessionDirectory(archived.id) try AtomicFile.writeJSON(archived, to: sessionDir.appendingPathComponent("session.json")) - let archiveDir = paths.archiveDirectory(openSession.id) + let archiveDir = paths.archiveDirectory(archived.id) guard rename(sessionDir.path, archiveDir.path) == 0 else { throw ShotdeckError.spoolWriteFailed( path: sessionDir.path, underlying: "could not move the session into archive/: \(String(cString: strerror(errno)))") } try AtomicFile.fsyncDirectory(at: paths.archive) - let fresh = try Self.createFreshSession(paths: paths) - openSession = fresh return archived } @@ -129,19 +198,35 @@ public actor SpoolStore { return dir.appendingPathComponent(capture.fileName) } - /// Archived sessions, newest createdAt first. Lazily reconciles each archive/ directory + /// Archived sessions, newest first. Lazily reconciles each archive/ directory /// the same way init reconciles spool/ candidates (orphan recovery, missing-drop, corrupt /// rebuild) — an archived session's manifest can degrade too and must self-heal without /// ever losing a PNG. + /// + /// Order: manifest `createdAt` first (whole-second ISO8601 — the manifest format is + /// pinned in AtomicFileTests), then the session folder's creation date to break ties + /// at real resolution (two sessions closed in the same second would otherwise order, + /// and therefore prune, arbitrarily by UUID), then the id as the final + /// deterministic tie-break. The folder date is a tie-break refinement only — the + /// manifest `createdAt` stays the authoritative timestamp; on a volume that reports no + /// creation date the tie-break degrades to the id. public func archivedSessions() throws -> [CaptureSession] { let ids = try Self.listUUIDDirectories(in: paths.archive, fileManager: .default) - var sessions: [CaptureSession] = [] + var keyed: [(session: CaptureSession, folderCreatedAt: Date)] = [] for id in ids { - sessions.append( - try Self.reconcileSessionDirectory( - at: paths.archiveDirectory(id), id: id, assumedStateIfRebuilt: .archived, fileManager: .default)) + let dir = paths.archiveDirectory(id) + let session = try Self.reconcileSessionDirectory( + at: dir, id: id, assumedStateIfRebuilt: .archived, fileManager: .default) + let folderCreatedAt = (try? dir.resourceValues(forKeys: [.creationDateKey]))?.creationDate + ?? session.createdAt + keyed.append((session, folderCreatedAt)) } - return sessions.sorted { ($0.createdAt, $0.id.uuidString) > ($1.createdAt, $1.id.uuidString) } + return keyed + .sorted { lhs, rhs in + (lhs.session.createdAt, lhs.folderCreatedAt, lhs.session.id.uuidString) + > (rhs.session.createdAt, rhs.folderCreatedAt, rhs.session.id.uuidString) + } + .map(\.session) } // MARK: - Reconciliation (static so they can run inside init) diff --git a/Tests/ShotdeckCoreTests/SessionRetentionTests.swift b/Tests/ShotdeckCoreTests/SessionRetentionTests.swift new file mode 100644 index 0000000..e3b80b6 --- /dev/null +++ b/Tests/ShotdeckCoreTests/SessionRetentionTests.swift @@ -0,0 +1,242 @@ +import CoreGraphics +import Foundation +import ImageIO +import Testing +import ShotdeckCore + +// Session lifecycle + retention (MMDB-2925): "Start new session" keeps the current +// screenshots as a past session, and the newest 10 sessions are retained in the one +// archive folder. + +// MARK: - 1. closeCurrentSession keeps the captures as a past session + +@Test +func closeCurrentSessionKeepsCapturesAsAPastSessionAndStartsFresh() async throws { + let (root, paths) = try makeIsolatedPaths() + defer { try? FileManager.default.removeItem(at: root) } + + let store = try SpoolStore(paths: paths) + let c1 = try await store.append( + pngData: try makePNGData(width: 8, height: 8, red: 1, green: 0, blue: 0), + pixelWidth: 8, pixelHeight: 8, scale: 1.0, capturedAt: Date()) + let c2 = try await store.append( + pngData: try makePNGData(width: 8, height: 8, red: 0, green: 1, blue: 0), + pixelWidth: 8, pixelHeight: 8, scale: 1.0, capturedAt: Date()) + + let closedID = try await store.currentSession().id + let archived = try #require(try await store.closeCurrentSession()) + + #expect(archived.id == closedID) + #expect(archived.state == .archived) + #expect(archived.pdfFileName == nil) // never sent — shown as "Not sent" + #expect(archived.captures.map(\.id) == [c1.id, c2.id]) + + // Nothing is deleted: both PNGs live on under archive//. + let archiveDir = paths.archiveDirectory(closedID) + for capture in archived.captures { + #expect(FileManager.default.fileExists( + atPath: archiveDir.appendingPathComponent(capture.fileName).path)) + } + #expect(!FileManager.default.fileExists(atPath: paths.sessionDirectory(closedID).path)) + + let fresh = try await store.currentSession() + #expect(fresh.id != closedID) + #expect(fresh.state == .open) + #expect(fresh.isEmpty) + + let past = try await store.archivedSessions() + #expect(past.map(\.id) == [closedID]) + #expect(past.first?.captures.count == 2) +} + +// MARK: - 2. closeCurrentSession on an empty open session just starts fresh + +@Test +func closeCurrentSessionOnAnEmptyOpenSessionStartsFreshWithoutArchiving() async throws { + let (root, paths) = try makeIsolatedPaths() + defer { try? FileManager.default.removeItem(at: root) } + + let store = try SpoolStore(paths: paths) + let before = try await store.currentSession().id + + let archived = try await store.closeCurrentSession() + #expect(archived == nil) + + let after = try await store.currentSession() + #expect(after.id != before) + #expect(after.isEmpty) + let past = try await store.archivedSessions() + #expect(past.isEmpty) +} + +// MARK: - 3. sent and unsent sessions are distinguishable in the past list + +@Test +func pastSessionsDistinguishSentFromUnsentByPDFFileName() async throws { + let (root, paths) = try makeIsolatedPaths() + defer { try? FileManager.default.removeItem(at: root) } + + let store = try SpoolStore(paths: paths) + _ = try await store.append( + pngData: try makePNGData(width: 6, height: 6, red: 1, green: 0, blue: 0), + pixelWidth: 6, pixelHeight: 6, scale: 1.0, capturedAt: Date()) + let sent = try await store.archiveCurrent(pdfFileName: "Redline-20261011-120000.pdf") + + _ = try await store.append( + pngData: try makePNGData(width: 6, height: 6, red: 0, green: 0, blue: 1), + pixelWidth: 6, pixelHeight: 6, scale: 1.0, capturedAt: Date()) + let closed = try #require(try await store.closeCurrentSession()) + + #expect(sent.pdfFileName == "Redline-20261011-120000.pdf") + #expect(closed.pdfFileName == nil) + + let past = try await store.archivedSessions() + #expect(past.map(\.id) == [closed.id, sent.id]) // newest first + #expect(past.map(\.pdfFileName) == [nil, "Redline-20261011-120000.pdf"]) +} + +// MARK: - 4. retention keeps the newest 10 sessions, in the one archive folder + +@Test +func retentionKeepsTheNewestTenSessionsAndRemovesTheRest() async throws { + let (root, paths) = try makeIsolatedPaths() + defer { try? FileManager.default.removeItem(at: root) } + + let store = try SpoolStore(paths: paths) + var closedIDs: [UUID] = [] + for index in 0..<12 { + _ = try await store.append( + pngData: try makePNGData(width: 4, height: 4, red: 0.1, green: 0.1, blue: 0.1), + pixelWidth: 4, pixelHeight: 4, scale: 1.0, + capturedAt: Date(timeIntervalSince1970: 1_700_000_000 + Double(index))) + let closed = try #require(try await store.closeCurrentSession()) + closedIDs.append(closed.id) + } + + // All 12 sessions live in the single archive/ folder as UUID session folders. + let fm = FileManager.default + let entries = try fm.contentsOfDirectory(at: paths.archive, includingPropertiesForKeys: nil) + let sessionDirs = entries.filter { UUID(uuidString: $0.lastPathComponent) != nil } + #expect(sessionDirs.count == SpoolStore.defaultRetainedSessionCount) + + let kept = try await store.archivedSessions().map(\.id) + #expect(kept == Array(closedIDs.suffix(SpoolStore.defaultRetainedSessionCount).reversed())) + + // The two oldest sessions are gone; the newest ten are fully on disk. + for id in closedIDs.prefix(2) { + #expect(!fm.fileExists(atPath: paths.archiveDirectory(id).path)) + } + for id in closedIDs.suffix(SpoolStore.defaultRetainedSessionCount) { + #expect(fm.fileExists(atPath: paths.archiveDirectory(id).appendingPathComponent("session.json").path)) + } + + // The open session is never touched by retention. + let open = try await store.currentSession() + #expect(open.state == .open) + #expect(open.isEmpty) + #expect(fm.fileExists(atPath: paths.sessionDirectory(open.id).path)) +} + +// MARK: - 5. explicit prune keeps exactly the requested count + +@Test +func pruneArchivedSessionsKeepingNRemovesExactlyTheOldest() async throws { + let (root, paths) = try makeIsolatedPaths() + defer { try? FileManager.default.removeItem(at: root) } + + let store = try SpoolStore(paths: paths) + var closedIDs: [UUID] = [] + for _ in 0..<4 { + _ = try await store.append( + pngData: try makePNGData(width: 4, height: 4, red: 0.2, green: 0.2, blue: 0.2), + pixelWidth: 4, pixelHeight: 4, scale: 1.0, capturedAt: Date()) + closedIDs.append(try #require(try await store.closeCurrentSession()).id) + } + + let removed = try await store.pruneArchivedSessions(keeping: 2) + #expect(removed == Array(closedIDs.prefix(2).reversed())) // newest-first walk order + let kept = try await store.archivedSessions().map(\.id) + #expect(kept == Array(closedIDs.suffix(2).reversed())) + + // Idempotent: nothing left to prune at that limit. + let removedAgain = try await store.pruneArchivedSessions(keeping: 2) + #expect(removedAgain.isEmpty) +} + +// MARK: - 6. retention runs on the send path too + +@Test +func theSendArchivePathAppliesRetention() async throws { + let (root, paths) = try makeIsolatedPaths() + defer { try? FileManager.default.removeItem(at: root) } + + let store = try SpoolStore(paths: paths) + var sentIDs: [UUID] = [] + for index in 0..<(SpoolStore.defaultRetainedSessionCount + 3) { + _ = try await store.append( + pngData: try makePNGData(width: 4, height: 4, red: 0.3, green: 0.3, blue: 0.3), + pixelWidth: 4, pixelHeight: 4, scale: 1.0, + capturedAt: Date(timeIntervalSince1970: 1_700_100_000 + Double(index))) + let archived = try await store.archiveCurrent(pdfFileName: "Redline-\(index).pdf") + sentIDs.append(archived.id) + } + + let kept = try await store.archivedSessions() + #expect(kept.count == SpoolStore.defaultRetainedSessionCount) + #expect(kept.map(\.id) == Array(sentIDs.suffix(SpoolStore.defaultRetainedSessionCount).reversed())) + #expect(kept.allSatisfy { $0.pdfFileName != nil }) +} + +// MARK: - Fixtures + +private enum FixtureError: Error { + case pngGenerationFailed +} + +private func makeIsolatedPaths() throws -> (root: URL, paths: AppSupportPaths) { + let root = FileManager.default.temporaryDirectory + .appendingPathComponent("shotdeck-retention-\(UUID().uuidString)", isDirectory: true) + let paths = try AppSupportPaths( + root: root, + outbox: root.appendingPathComponent("outbox", isDirectory: true), + watchFolder: root.appendingPathComponent("watch", isDirectory: true) + ) + return (root, paths) +} + +private func makePNGData( + width: Int, + height: Int, + red: CGFloat, + green: CGFloat, + blue: CGFloat +) throws -> Data { + let colorSpace = CGColorSpaceCreateDeviceRGB() + guard let context = CGContext( + data: nil, + width: width, + height: height, + bitsPerComponent: 8, + bytesPerRow: width * 4, + space: colorSpace, + bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue + ) else { + throw FixtureError.pngGenerationFailed + } + context.setFillColor(red: red, green: green, blue: blue, alpha: 1) + context.fill(CGRect(x: 0, y: 0, width: width, height: height)) + guard let image = context.makeImage() else { + throw FixtureError.pngGenerationFailed + } + let data = NSMutableData() + guard let destination = CGImageDestinationCreateWithData( + data, "public.png" as CFString, 1, nil + ) else { + throw FixtureError.pngGenerationFailed + } + CGImageDestinationAddImage(destination, image, nil) + guard CGImageDestinationFinalize(destination) else { + throw FixtureError.pngGenerationFailed + } + return data as Data +} diff --git a/Tests/ShotdeckTests/SessionWorkflowTests.swift b/Tests/ShotdeckTests/SessionWorkflowTests.swift new file mode 100644 index 0000000..4855994 --- /dev/null +++ b/Tests/ShotdeckTests/SessionWorkflowTests.swift @@ -0,0 +1,153 @@ +import AppKit +import CoreGraphics +import Foundation +import ImageIO +import Testing +import ShotdeckCore +@testable import Shotdeck + +/// MMDB-2925, through the REAL app-target seams the menu rows invoke (`AppModel` +/// actions + `SpoolStore`): "Start new session" keeps the current screenshots as a +/// past session, the Past submissions state reflects what was sent, and session +/// retention keeps the newest 10 sessions in the one archive folder. `bootstrap()` +/// itself is covered by LaunchWiringTests; here `addCapture` refreshes the session +/// from the store exactly the way `AppModel.captureNow()` does after a real capture. +@MainActor +@Test("Menu actions: start new session keeps captures, lists past submissions, retains 10") +func startNewSessionKeepsCapturesListsPastSubmissionsAndRetainsTen() async throws { + let fm = FileManager.default + let root = fm.temporaryDirectory + .appendingPathComponent("shotdeck-session-workflow-\(UUID().uuidString)", isDirectory: true) + defer { try? fm.removeItem(at: root) } + let model = AppDelegate.makeLaunchModel(appSupportRoot: root) + + // Two captures in the open session, then the menu's "Start new session". + let c1 = try await addCapture(to: model, red: 1, green: 0, blue: 0) + let c2 = try await addCapture(to: model, red: 0, green: 1, blue: 0) + let closedID = model.session.id + #expect(model.canStartNewSession) + + await model.startNewSession() + + // The fresh session is active and the captures are kept as a past session. + #expect(model.session.id != closedID) + #expect(model.session.isEmpty) + #expect(!model.canStartNewSession) + #expect(model.pastSessions.map(\.id) == [closedID]) + #expect(model.pastSessions.first?.captures.map(\.id) == [c1.id, c2.id]) + #expect(model.pastSessions.first?.pdfFileName == nil) // never sent + #expect(model.statusLine?.contains("kept as a past session") == true) + + // Nothing was deleted on close: both PNGs live in the single archive folder. + let archiveDir = model.paths.archiveDirectory(closedID) + for capture in [c1, c2] { + #expect(fm.fileExists(atPath: archiveDir.appendingPathComponent(capture.fileName).path)) + } + + // "PDF" on a never-sent row: visible missing state, no silent substitute. + #expect(model.sentPDFURL(for: model.pastSessions[0]) == nil) + model.revealSentPDF(model.pastSessions[0]) + #expect(model.statusLine == "That session was never sent.") +} + +@MainActor +@Test("Retention: 12 sessions through the menu action leave the newest 10 on disk") +func twelveSessionsLeaveTheNewestTenInTheOneArchiveFolder() async throws { + let fm = FileManager.default + let root = fm.temporaryDirectory + .appendingPathComponent("shotdeck-session-workflow-\(UUID().uuidString)", isDirectory: true) + defer { try? fm.removeItem(at: root) } + let model = AppDelegate.makeLaunchModel(appSupportRoot: root) + + var closedIDs: [UUID] = [] + for _ in 0..<12 { + _ = try await addCapture(to: model, red: 0.2, green: 0.2, blue: 0.2) + closedIDs.append(model.session.id) + await model.startNewSession() + } + + #expect(model.pastSessions.count == SpoolStore.defaultRetainedSessionCount) + #expect(model.pastSessions.map(\.id) + == Array(closedIDs.suffix(SpoolStore.defaultRetainedSessionCount).reversed())) + + let entries = try fm.contentsOfDirectory(at: model.paths.archive, includingPropertiesForKeys: nil) + let sessionDirs = entries.filter { UUID(uuidString: $0.lastPathComponent) != nil } + #expect(sessionDirs.count == SpoolStore.defaultRetainedSessionCount) + for id in closedIDs.prefix(2) { + #expect(!fm.fileExists(atPath: model.paths.archiveDirectory(id).path)) + } +} + +@MainActor +@Test("Menu action on an empty session reports it started without inventing a past session") +func startNewSessionOnEmptySessionCreatesNoPastSession() async throws { + let fm = FileManager.default + let root = fm.temporaryDirectory + .appendingPathComponent("shotdeck-session-workflow-\(UUID().uuidString)", isDirectory: true) + defer { try? fm.removeItem(at: root) } + let model = AppDelegate.makeLaunchModel(appSupportRoot: root) + + #expect(model.session.isEmpty) + await model.startNewSession() + + #expect(model.session.isEmpty) + #expect(model.pastSessions.isEmpty) + #expect(model.statusLine == "New session started.") +} + +// MARK: - Fixtures + +/// Appends one generated PNG through the store and refreshes `model.session` from +/// it — the same refresh `AppModel.captureNow()` performs after a real capture. +@MainActor +private func addCapture( + to model: AppModel, + red: CGFloat, + green: CGFloat, + blue: CGFloat +) async throws -> Capture { + let capture = try await model.spool.append( + pngData: try makePNGData(width: 8, height: 8, red: red, green: green, blue: blue), + pixelWidth: 8, pixelHeight: 8, scale: 1.0, capturedAt: Date()) + model.replaceSession(try await model.spool.currentSession()) + return capture +} + +private enum FixtureError: Error { + case pngGenerationFailed +} + +private func makePNGData( + width: Int, + height: Int, + red: CGFloat, + green: CGFloat, + blue: CGFloat +) throws -> Data { + let colorSpace = CGColorSpaceCreateDeviceRGB() + guard let context = CGContext( + data: nil, + width: width, + height: height, + bitsPerComponent: 8, + bytesPerRow: width * 4, + space: colorSpace, + bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue + ) else { + throw FixtureError.pngGenerationFailed + } + context.setFillColor(red: red, green: green, blue: blue, alpha: 1) + context.fill(CGRect(x: 0, y: 0, width: width, height: height)) + guard let image = context.makeImage() else { + throw FixtureError.pngGenerationFailed + } + let buffer = NSMutableData() + guard let destination = CGImageDestinationCreateWithData(buffer, "public.png" as CFString, 1, nil) else { + throw FixtureError.pngGenerationFailed + } + CGImageDestinationAddImage(destination, image, nil) + guard CGImageDestinationFinalize(destination) else { + throw FixtureError.pngGenerationFailed + } + return buffer as Data +} From eaa5bd58842bf518305ee3808a8267907f25dfcb Mon Sep 17 00:00:00 2001 From: Claude Fable 5 Date: Sun, 11 Oct 2026 13:48:31 +0400 Subject: [PATCH 2/3] fix(sessions): adversarial-review fixes for MMDB-2925 (PR #29 review round 1) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Review verdict FAIL raised 7 defects; this addresses 1-5 and 7. 6 is accepted as-is (see below). 1. Retention failure after a COMPLETED archive no longer throws: a failed prune is logged loudly with the exact path and otherwise ignored, so a successful send can never be reported as "The screenshot could not be saved". The visible symptom of a failed prune is simply more than 10 sessions listed. 2. handleDidShareItems now refreshes the current session AND the past-submissions list from the store on both the success and the failure path (previously the menu count and any open window went stale after every send). Any refresh problem is appended to the status line. 3. "Start new session" and send() now guard against each other synchronously before their first await (isStartingNewSession flag on both sides), instead of relying on the SwiftUI .disabled state alone — a queued Task could otherwise rename the session directory out from under an in-flight PDF compose. 4. Contract decision, documented in code: session retention prunes the whole session folder INCLUDING removed/ parked captures. That is the requested retention policy ("retain the past 10 sessions"), and the D-11 never-delete note on remove() now says so explicitly. 5. Session ordering tie-break chain extended: manifest createdAt, then the folder creation date, then the folder content-modification date, then the id — so retention stays on real creation order even on a volume that reports no creation date. 7. The PDF button's help text now distinguishes never-sent from sent-but-no-longer-on-disk (the button was already disabled in both). 6 (empty close leaves the old empty spool/ folder behind) is left exactly as the pinned SpoolStoreTests contract has it (startNewSession test 16 asserts the folder remains); it is pre-existing behavior, harmless (the store reconciles and picks the newest candidate), and out of scope here. Tests: 2 new app-target regression tests (send refreshes past submissions; start/send refuse to overlap) — 134 tests pass. --- Sources/Shotdeck/AppModel.swift | 26 +++++++- Sources/Shotdeck/PastSubmissionsView.swift | 10 ++- Sources/Shotdeck/SendController.swift | 21 ++++++- Sources/ShotdeckCore/Spool/SpoolStore.swift | 61 ++++++++++++------- .../ShotdeckTests/SessionWorkflowTests.swift | 55 +++++++++++++++++ 5 files changed, 144 insertions(+), 29 deletions(-) diff --git a/Sources/Shotdeck/AppModel.swift b/Sources/Shotdeck/AppModel.swift index 4ddc41e..bbab372 100644 --- a/Sources/Shotdeck/AppModel.swift +++ b/Sources/Shotdeck/AppModel.swift @@ -37,6 +37,11 @@ public final class AppModel { public private(set) var statusLine: String? public private(set) var isCapturing: Bool = false public private(set) var isSending: Bool = false + /// True while "Start new session" is between its guard and its store call — the + /// synchronous flag both this action and send() check BEFORE their first await, so + /// the two can never interleave a session close with an in-flight compose (a + /// SwiftUI `.disabled` render-time guard alone does not stop a queued Task). + public private(set) var isStartingNewSession: Bool = false public private(set) var outboxDisplayName: String public private(set) var watchFolderDisplayName: String /// Live transport choice; WP-onedrive reads this to pick the send path and to drive @@ -134,6 +139,9 @@ public final class AppModel { func setStatus(_ text: String?) { statusLine = text } func setSending(_ value: Bool) { isSending = value } + /// Fixture seam (same family as setSending): lets tests/PanelSnapshot stage the + /// in-flight-start state that production only ever reaches inside startNewSession(). + func setStartingNewSession(_ value: Bool) { isStartingNewSession = value } func setCapturing(_ value: Bool) { isCapturing = value } func replaceSession(_ new: CaptureSession) { session = new } func replaceRegion(_ new: CaptureRegion?) { region = new } @@ -403,15 +411,27 @@ public final class AppModel { } } - /// True when "Start new session" applies: there is something to keep and no send - /// in flight that would archive the session on its own. - public var canStartNewSession: Bool { !session.isEmpty && !isSending } + /// True when "Start new session" applies: there is something to keep and neither a + /// send nor another session start is in flight. + public var canStartNewSession: Bool { + !session.isEmpty && !isSending && !isStartingNewSession + } /// Menu "Start new session": keeps the current screenshots as a past session /// (moved into the single archive folder — never deleted) and opens a fresh empty /// session. Session retention (newest 10 kept) is applied inside the store, on /// this path and on the send path alike. public func startNewSession() async { + // Re-checked here on the main actor, synchronously, before the first await: + // the menu's `.disabled` state cannot stop a Task that was queued just before + // a send started. + guard !isSending, !isStartingNewSession else { + setStatus("Finish the current send first.") + return + } + isStartingNewSession = true + defer { isStartingNewSession = false } + var message: String do { if let archived = try await spool.closeCurrentSession() { diff --git a/Sources/Shotdeck/PastSubmissionsView.swift b/Sources/Shotdeck/PastSubmissionsView.swift index bfc23c8..50a3e89 100644 --- a/Sources/Shotdeck/PastSubmissionsView.swift +++ b/Sources/Shotdeck/PastSubmissionsView.swift @@ -98,7 +98,7 @@ private struct PastSessionRow: View { model.revealSentPDF(session) } .disabled(model.sentPDFURL(for: session) == nil) - .help(session.pdfFileName.map { "Reveal \($0)" } ?? "This session was never sent.") + .help(pdfHelpText) Button("Captures") { model.revealSessionCaptures(session) } @@ -106,6 +106,14 @@ private struct PastSessionRow: View { } } + private var pdfHelpText: String { + guard let name = session.pdfFileName else { return "This session was never sent." } + guard model.sentPDFURL(for: session) != nil else { + return "The PDF \(name) is no longer in the output folder." + } + return "Reveal \(name)" + } + private var submissionLabel: String { let pages = "\(session.captures.count) page\(session.captures.count == 1 ? "" : "s")" guard let name = session.pdfFileName else { diff --git a/Sources/Shotdeck/SendController.swift b/Sources/Shotdeck/SendController.swift index b033291..bc2cb98 100644 --- a/Sources/Shotdeck/SendController.swift +++ b/Sources/Shotdeck/SendController.swift @@ -14,6 +14,13 @@ struct ComposedSend: Sendable { 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/ @@ -190,14 +197,22 @@ extension AppModel: SendCapable { /// `NSSharingServiceDelegate.sharingService(_:didShareItems:)` seam. func handleDidShareItems(fileName: String, pageCount: Int) async { guard !session.isEmpty else { return } + var message: String do { _ = try await spool.archiveCurrent(pdfFileName: fileName) - replaceSession(try await spool.currentSession()) let pageWord = pageCount == 1 ? "page" : "pages" - setStatus("Sent — \(pageCount) \(pageWord).") + message = "Sent — \(pageCount) \(pageWord)." } catch { - setStatus((error as? ShotdeckError)?.errorDescription ?? "Could not archive the session.") + 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)" + } + setStatus(message) } /// `NSSharingServiceDelegate.sharingService(_:didFailToShareItems:error:)` seam, diff --git a/Sources/ShotdeckCore/Spool/SpoolStore.swift b/Sources/ShotdeckCore/Spool/SpoolStore.swift index 7225137..0d2632a 100644 --- a/Sources/ShotdeckCore/Spool/SpoolStore.swift +++ b/Sources/ShotdeckCore/Spool/SpoolStore.swift @@ -64,8 +64,12 @@ public actor SpoolStore { } /// D-11: moves the capture's PNG into `/removed/` (created lazily) and drops - /// its manifest entry. NEVER unlinks/deletes a user PNG. Throws (no filesystem change) if - /// `captureID` is not present in the open session. + /// its manifest entry. NEVER unlinks/deletes a user PNG on this path. Throws (no + /// filesystem change) if `captureID` is not present in the open session. + /// (Session retention is the one place that removes files: when a session falls + /// outside the newest `defaultRetainedSessionCount`, its WHOLE folder — including + /// `removed/` — is pruned. That is the requested retention policy (Ben, 2026-10-11), + /// not this remove path.) public func remove(captureID: UUID) throws -> CaptureSession { guard let capture = openSession.captures.first(where: { $0.id == captureID }) else { throw ShotdeckError.spoolWriteFailed( @@ -104,7 +108,7 @@ public actor SpoolStore { } let archived = try moveOpenSessionToArchive(openSession.markArchived(pdfFileName: pdfFileName)) openSession = try Self.createFreshSession(paths: paths) - try applyRetention() + applyRetention() return archived } @@ -123,7 +127,7 @@ public actor SpoolStore { let archived = try moveOpenSessionToArchive( openSession.markArchived(pdfFileName: openSession.pdfFileName)) openSession = try Self.createFreshSession(paths: paths) - try applyRetention() + applyRetention() return archived } @@ -154,12 +158,22 @@ public actor SpoolStore { } /// The retention policy every archive path funnels through, so it can never be - /// forgotten: new sessions over the default count are pruned. - private func applyRetention() throws { - let removed = try pruneArchivedSessions(keeping: Self.defaultRetainedSessionCount) - if !removed.isEmpty { - Log.spool.warning( - "Session retention: removed \(removed.count, privacy: .public) archived session(s) beyond the newest \(Self.defaultRetainedSessionCount, privacy: .public).") + /// forgotten: sessions over the default count are pruned. A retention failure is + /// logged loudly (with the exact path) and never thrown — the archive it follows + /// already succeeded, and converting a completed send into a reported failure + /// would be a lie (the safe direction of a failed prune is keeping too much, never + /// losing data). The visible symptom of a failed prune is simply more than 10 + /// sessions in the Past submissions list. + private func applyRetention() { + do { + let removed = try pruneArchivedSessions(keeping: Self.defaultRetainedSessionCount) + if !removed.isEmpty { + Log.spool.warning( + "Session retention: removed \(removed.count, privacy: .public) archived session(s) beyond the newest \(Self.defaultRetainedSessionCount, privacy: .public).") + } + } catch { + Log.spool.error( + "Session retention failed — past sessions were kept beyond \(Self.defaultRetainedSessionCount, privacy: .public): \((error as? ShotdeckError)?.errorDescription ?? error.localizedDescription, privacy: .public)") } } @@ -204,27 +218,30 @@ public actor SpoolStore { /// ever losing a PNG. /// /// Order: manifest `createdAt` first (whole-second ISO8601 — the manifest format is - /// pinned in AtomicFileTests), then the session folder's creation date to break ties - /// at real resolution (two sessions closed in the same second would otherwise order, - /// and therefore prune, arbitrarily by UUID), then the id as the final - /// deterministic tie-break. The folder date is a tie-break refinement only — the - /// manifest `createdAt` stays the authoritative timestamp; on a volume that reports no - /// creation date the tie-break degrades to the id. + /// pinned in AtomicFileTests), then the session folder's creation date and content + /// modification date to break ties at real resolution (two sessions closed in the + /// same second would otherwise order, and therefore prune, arbitrarily by UUID — + /// and on a volume that reports no creation date the modification date still keeps + /// retention on real order), then the id as the final deterministic tie-break. + /// The folder dates are tie-break refinements only — the manifest `createdAt` stays + /// the authoritative timestamp; if a volume reports neither date the tie-break + /// degrades to the id. public func archivedSessions() throws -> [CaptureSession] { let ids = try Self.listUUIDDirectories(in: paths.archive, fileManager: .default) - var keyed: [(session: CaptureSession, folderCreatedAt: Date)] = [] + var keyed: [(session: CaptureSession, folderCreatedAt: Date, folderModifiedAt: Date)] = [] for id in ids { let dir = paths.archiveDirectory(id) let session = try Self.reconcileSessionDirectory( at: dir, id: id, assumedStateIfRebuilt: .archived, fileManager: .default) - let folderCreatedAt = (try? dir.resourceValues(forKeys: [.creationDateKey]))?.creationDate - ?? session.createdAt - keyed.append((session, folderCreatedAt)) + let values = try? dir.resourceValues(forKeys: [.creationDateKey, .contentModificationDateKey]) + let folderCreatedAt = values?.creationDate ?? session.createdAt + let folderModifiedAt = values?.contentModificationDate ?? folderCreatedAt + keyed.append((session, folderCreatedAt, folderModifiedAt)) } return keyed .sorted { lhs, rhs in - (lhs.session.createdAt, lhs.folderCreatedAt, lhs.session.id.uuidString) - > (rhs.session.createdAt, rhs.folderCreatedAt, rhs.session.id.uuidString) + (lhs.session.createdAt, lhs.folderCreatedAt, lhs.folderModifiedAt, lhs.session.id.uuidString) + > (rhs.session.createdAt, rhs.folderCreatedAt, rhs.folderModifiedAt, rhs.session.id.uuidString) } .map(\.session) } diff --git a/Tests/ShotdeckTests/SessionWorkflowTests.swift b/Tests/ShotdeckTests/SessionWorkflowTests.swift index 4855994..a1b3809 100644 --- a/Tests/ShotdeckTests/SessionWorkflowTests.swift +++ b/Tests/ShotdeckTests/SessionWorkflowTests.swift @@ -95,6 +95,61 @@ func startNewSessionOnEmptySessionCreatesNoPastSession() async throws { #expect(model.statusLine == "New session started.") } +@MainActor +@Test("Send seam refreshes past submissions after archiving (menu count stays true)") +func successfulSendRefreshesPastSubmissions() async throws { + let fm = FileManager.default + let root = fm.temporaryDirectory + .appendingPathComponent("shotdeck-session-workflow-\(UUID().uuidString)", isDirectory: true) + defer { try? fm.removeItem(at: root) } + let model = AppDelegate.makeLaunchModel(appSupportRoot: root) + + _ = try await addCapture(to: model, red: 0.4, green: 0.4, blue: 0.4) + await model.handleDidShareItems(fileName: "Redline-20261011-120000.pdf", pageCount: 1) + + #expect(model.statusLine == "Sent — 1 page.") + #expect(model.session.isEmpty) + #expect(model.pastSessions.count == 1) + #expect(model.pastSessions.first?.pdfFileName == "Redline-20261011-120000.pdf") + #expect(model.pastSessions.first?.captures.count == 1) +} + +@MainActor +@Test("Start new session and send refuse to overlap (no mid-flight session close)") +func sessionStartAndSendRefuseToOverlap() async throws { + let fm = FileManager.default + let root = fm.temporaryDirectory + .appendingPathComponent("shotdeck-session-workflow-\(UUID().uuidString)", isDirectory: true) + defer { try? fm.removeItem(at: root) } + let model = AppDelegate.makeLaunchModel(appSupportRoot: root) + + let capture = try await addCapture(to: model, red: 0.1, green: 0.1, blue: 0.1) + let before = model.session.id + + // A send in flight: "Start new session" must refuse instead of renaming the + // session directory out from under the compose. + model.setSending(true) + await model.startNewSession() + #expect(model.session.id == before) + #expect(model.session.captures.map(\.id) == [capture.id]) + #expect(model.statusLine == "Finish the current send first.") + model.setSending(false) + + // A session start in flight: send must refuse before composing anything. + model.setStartingNewSession(true) + await model.send(anchor: nil) + #expect(model.statusLine == "Finish starting the new session first.") + #expect(model.session.id == before) + #expect(model.session.captures.map(\.id) == [capture.id]) + model.setStartingNewSession(false) + + // Both settled: the normal path still works. + await model.startNewSession() + #expect(model.session.id != before) + #expect(model.pastSessions.count == 1) + #expect(model.pastSessions.first?.captures.map(\.id) == [capture.id]) +} + // MARK: - Fixtures /// Appends one generated PNG through the store and refreshes `model.session` from From 0506ce04e9a28fb9798147d1bfc40f1f6a5fd448 Mon Sep 17 00:00:00 2001 From: Claude Fable 5 Date: Sun, 11 Oct 2026 13:58:45 +0400 Subject: [PATCH 3/3] fix(sessions): re-review fixes for MMDB-2925 (PR #29 review round 2) Round 2 of adversarial review confirmed defects 2,3,4,5,7 fixed and raised three new ones; all three are fixed here, plus the guard-message nit. NEW-1 (the FAIL driver): the OneDrive send path overwrote the truthful status from handleDidShareItems with its own success text, silently dropping an archive failure and any state-refresh problem. The seam now takes the caller's success summary and composes ONE truthful message: summary (the share itself did complete) + archive error if any + refresh problems if any. Both callers (AirDrop delegate, OneDrive) pass their summary; the OneDrive text is never clobbered. NEW-2: if the replacement open session could not be created after the archive rename (disk full), the store kept reporting the already-archived session as the open one. SpoolStore now has a truth guard (ensureOpenSession): the open session is verified to really exist on disk and be in state .open before any read/mutate; a stale one is replaced by a genuinely fresh session, or the call fails loudly. Never a lie. NEW-3: archivedSessions() read the folder tie-break dates AFTER reconciliation, so a healed same-second session could bump its own modification date and outrank a genuinely newer peer. The dates are now read BEFORE reconciling. Nit: the startNewSession guard now reports "A new session is already being started." when the refusal is about a concurrent session start, not a send. Also added REDLINE_SELFTEST_PHASE=sendtruth (mirroring the existing =onedrive escape hatch) so the SEND-TRUTH selftest can run without the picker chain's display-dependent REGION-PERSIST phase. Evidence: 136 swift tests pass (2 new: OneDrive summary survives archiving; stale open session never returned as current). REDLINE_SELFTEST_PHASE=sendtruth -> SEND-TRUTH PASS. REDLINE_SELFTEST_PHASE=onedrive -> ONEDRIVE-SELFTEST PASS against the real OneDrive sync root. --- Sources/Shotdeck/AppModel.swift | 2 +- Sources/Shotdeck/PickerSelfTest.swift | 37 ++++++++++- Sources/Shotdeck/SendController.swift | 22 ++++--- Sources/Shotdeck/main.swift | 3 + Sources/ShotdeckCore/Spool/SpoolStore.swift | 64 ++++++++++++++----- .../SessionRetentionTests.swift | 29 +++++++++ .../ShotdeckTests/SessionWorkflowTests.swift | 21 +++++- 7 files changed, 148 insertions(+), 30 deletions(-) diff --git a/Sources/Shotdeck/AppModel.swift b/Sources/Shotdeck/AppModel.swift index bbab372..26af946 100644 --- a/Sources/Shotdeck/AppModel.swift +++ b/Sources/Shotdeck/AppModel.swift @@ -426,7 +426,7 @@ public final class AppModel { // the menu's `.disabled` state cannot stop a Task that was queued just before // a send started. guard !isSending, !isStartingNewSession else { - setStatus("Finish the current send first.") + setStatus(isSending ? "Finish the current send first." : "A new session is already being started.") return } isStartingNewSession = true diff --git a/Sources/Shotdeck/PickerSelfTest.swift b/Sources/Shotdeck/PickerSelfTest.swift index fdf25b4..eaa50eb 100644 --- a/Sources/Shotdeck/PickerSelfTest.swift +++ b/Sources/Shotdeck/PickerSelfTest.swift @@ -241,7 +241,10 @@ enum PickerSelfTest { sendTruthFail("fail path status missing 'nothing was sent': \(model.statusLine ?? "nil")") } - await model.handleDidShareItems(fileName: pending.fileName, pageCount: pending.pageCount) + let pageWord = pending.pageCount == 1 ? "page" : "pages" + await model.handleDidShareItems( + fileName: pending.fileName, + sentSummary: "Sent — \(pending.pageCount) \(pageWord).") let fresh = try await model.spool.currentSession() guard fresh.isEmpty, fresh.id != openID, fresh.state == .open else { sendTruthFail("success path did not mint a fresh empty session") @@ -592,6 +595,38 @@ enum PickerSelfTest { return true } + /// Entry point for running ONLY the SEND-TRUTH phase, bypassing the on-screen picker + /// chain entirely — the chain's REGION-PERSIST phase needs an active display + /// (CGDisplayIsActive) and exits before SEND-TRUTH in headless/remote sessions. + /// Escape hatch: `REDLINE_SELFTEST_PHASE=sendtruth`. + static func runSendTruthOnlyIfRequested() { + guard ProcessInfo.processInfo.environment["REDLINE_SELFTEST_PHASE"] == "sendtruth" else { + return + } + // Same hop as runOneDriveOnlyIfRequested(): a plain main-queue turn after NSApp + // starts, so AppKit/PDFKit calls inside the phase are not racing app launch. + DispatchQueue.main.async { + MainActor.assumeIsolated { + runSendTruthAndExit() + } + } + } + + private static func runSendTruthAndExit() { + Task { @MainActor in + do { + try await executeSendTruth() + print("SEND-TRUTH PASS") + fflush(stdout) + exit(0) + } catch { + print("SEND-TRUTH FAIL \(error)") + fflush(stdout) + exit(1) + } + } + } + /// Entry point for running ONLY this phase, bypassing the on-screen picker chain /// entirely. The harness has no other per-phase selector, so this is the escape /// hatch: `REDLINE_SELFTEST_PHASE=onedrive`. diff --git a/Sources/Shotdeck/SendController.swift b/Sources/Shotdeck/SendController.swift index bc2cb98..f802dba 100644 --- a/Sources/Shotdeck/SendController.swift +++ b/Sources/Shotdeck/SendController.swift @@ -95,10 +95,10 @@ extension AppModel: SendCapable { 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. - await handleDidShareItems(fileName: pending.fileName, pageCount: pending.pageCount) let pageWord = pending.pageCount == 1 ? "page" : "pages" - setStatus( - "Saved to OneDrive — \(pending.pageCount) \(pageWord). Open it in Files on your iPad." + await handleDidShareItems( + fileName: pending.fileName, + sentSummary: "Saved to OneDrive — \(pending.pageCount) \(pageWord). Open it in Files on your iPad." ) setSending(false) @@ -113,9 +113,10 @@ extension AppModel: SendCapable { 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, - pageCount: pending.pageCount + sentSummary: "Sent — \(pending.pageCount) \(pageWord)." ) } else { self.handleDidFailToShareItems(fileName: pending.fileName) @@ -194,16 +195,17 @@ extension AppModel: SendCapable { ) } - /// `NSSharingServiceDelegate.sharingService(_:didShareItems:)` seam. - func handleDidShareItems(fileName: String, pageCount: Int) async { + /// `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: String + var message = sentSummary do { _ = try await spool.archiveCurrent(pdfFileName: fileName) - let pageWord = pageCount == 1 ? "page" : "pages" - message = "Sent — \(pageCount) \(pageWord)." } catch { - message = (error as? ShotdeckError)?.errorDescription ?? "Could not archive the session." + 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, diff --git a/Sources/Shotdeck/main.swift b/Sources/Shotdeck/main.swift index d6b1063..3a32799 100644 --- a/Sources/Shotdeck/main.swift +++ b/Sources/Shotdeck/main.swift @@ -10,6 +10,9 @@ if ProcessInfo.processInfo.environment["SHOTDECK_SNAPSHOT_DIR"] != nil { if ProcessInfo.processInfo.environment["REDLINE_SELFTEST_PHASE"] == "onedrive" { MainActor.assumeIsolated { PickerSelfTest.runOneDriveOnlyIfRequested() } } +if ProcessInfo.processInfo.environment["REDLINE_SELFTEST_PHASE"] == "sendtruth" { + MainActor.assumeIsolated { PickerSelfTest.runSendTruthOnlyIfRequested() } +} if ProcessInfo.processInfo.environment["SHOTDECK_PICKER_SELFTEST"] != nil { MainActor.assumeIsolated { PickerSelfTest.runIfRequested() } } diff --git a/Sources/ShotdeckCore/Spool/SpoolStore.swift b/Sources/ShotdeckCore/Spool/SpoolStore.swift index 0d2632a..5ceff82 100644 --- a/Sources/ShotdeckCore/Spool/SpoolStore.swift +++ b/Sources/ShotdeckCore/Spool/SpoolStore.swift @@ -35,9 +35,28 @@ public actor SpoolStore { } /// The session currently accepting captures. Cheap accessor — all reconciliation already - /// happened once, inside init. + /// happened once, inside init. A truth guard: if the stored session is no longer really + /// open on disk (its directory was archived away and the replacement session could not + /// be created — e.g. disk full), a fresh session is minted, or the call fails loudly. + /// It never returns an already-archived session as the open one. public func currentSession() throws -> CaptureSession { - openSession + try ensureOpenSession() + } + + /// Mint-or-verify the open session: returns the session that is REALLY open on disk, + /// creating a fresh one when the stored one is stale (archived away mid-run). Throws + /// loudly when no new session can be created either — never substitutes a lie. + private func ensureOpenSession() throws -> CaptureSession { + let dir = paths.sessionDirectory(openSession.id) + if openSession.state == .open && FileManager.default.fileExists(atPath: dir.path) { + return openSession + } + let staleID = openSession.id.uuidString + Log.spool.error( + "The stored open session \(staleID, privacy: .public) is not really open on disk; starting a fresh one.") + let fresh = try Self.createFreshSession(paths: paths) + openSession = fresh + return fresh } /// Writes `pngData` to disk and fsyncs it BEFORE the manifest is touched, then updates and @@ -47,17 +66,18 @@ public actor SpoolStore { pngData: Data, pixelWidth: Int, pixelHeight: Int, scale: CGFloat, capturedAt: Date ) throws -> Capture { + let open = try ensureOpenSession() let captureID = UUID() - let sequence = openSession.nextSequence + let sequence = open.nextSequence let fileName = "\(String(format: "%03d", sequence))-\(Self.hexSuffix(captureID)).png" - let sessionDir = paths.sessionDirectory(openSession.id) + let sessionDir = paths.sessionDirectory(open.id) let fileURL = sessionDir.appendingPathComponent(fileName) try AtomicFile.write(pngData, to: fileURL) let capture = Capture( id: captureID, sequence: sequence, fileName: fileName, pixelWidth: pixelWidth, pixelHeight: pixelHeight, scale: scale, capturedAt: capturedAt) - let updated = openSession.appending(capture) + let updated = open.appending(capture) try AtomicFile.writeJSON(updated, to: sessionDir.appendingPathComponent("session.json")) openSession = updated return capture @@ -71,12 +91,13 @@ public actor SpoolStore { /// `removed/` — is pruned. That is the requested retention policy (Ben, 2026-10-11), /// not this remove path.) public func remove(captureID: UUID) throws -> CaptureSession { - guard let capture = openSession.captures.first(where: { $0.id == captureID }) else { + let open = try ensureOpenSession() + guard let capture = open.captures.first(where: { $0.id == captureID }) else { throw ShotdeckError.spoolWriteFailed( - path: paths.sessionDirectory(openSession.id).path, + path: paths.sessionDirectory(open.id).path, underlying: "capture \(captureID) is not in the open session") } - let sessionDir = paths.sessionDirectory(openSession.id) + let sessionDir = paths.sessionDirectory(open.id) let removedDir = sessionDir.appendingPathComponent("removed", isDirectory: true) do { try FileManager.default.createDirectory(at: removedDir, withIntermediateDirectories: true) @@ -101,12 +122,13 @@ public actor SpoolStore { /// pdfFileName, starts a fresh empty open session, and applies session retention. /// Returns the archived one. public func archiveCurrent(pdfFileName: String) throws -> CaptureSession { - guard !openSession.isEmpty else { + let open = try ensureOpenSession() + guard !open.isEmpty else { throw ShotdeckError.spoolWriteFailed( - path: paths.sessionDirectory(openSession.id).path, + path: paths.sessionDirectory(open.id).path, underlying: "cannot archive an empty session") } - let archived = try moveOpenSessionToArchive(openSession.markArchived(pdfFileName: pdfFileName)) + let archived = try moveOpenSessionToArchive(open.markArchived(pdfFileName: pdfFileName)) openSession = try Self.createFreshSession(paths: paths) applyRetention() return archived @@ -120,12 +142,13 @@ public actor SpoolStore { /// simply replaced — there is nothing to keep. Returns the archived session, or /// nil when the open session was empty. public func closeCurrentSession() throws -> CaptureSession? { - guard !openSession.isEmpty else { + let open = try ensureOpenSession() + guard !open.isEmpty else { openSession = try Self.createFreshSession(paths: paths) return nil } let archived = try moveOpenSessionToArchive( - openSession.markArchived(pdfFileName: openSession.pdfFileName)) + open.markArchived(pdfFileName: open.pdfFileName)) openSession = try Self.createFreshSession(paths: paths) applyRetention() return archived @@ -195,10 +218,11 @@ public actor SpoolStore { /// Abandons the open session only if it is empty (mints a new id/dir/manifest); throws, /// with no filesystem change, if the open session has captures. public func startNewSession() throws -> CaptureSession { - guard openSession.isEmpty else { + let open = try ensureOpenSession() + guard open.isEmpty else { throw ShotdeckError.spoolWriteFailed( - path: paths.sessionDirectory(openSession.id).path, - underlying: "cannot start a new session: \(openSession.captures.count) capture(s) present in the open session") + path: paths.sessionDirectory(open.id).path, + underlying: "cannot start a new session: \(open.captures.count) capture(s) present in the open session") } let fresh = try Self.createFreshSession(paths: paths) openSession = fresh @@ -231,9 +255,15 @@ public actor SpoolStore { var keyed: [(session: CaptureSession, folderCreatedAt: Date, folderModifiedAt: Date)] = [] for id in ids { let dir = paths.archiveDirectory(id) + // Read the folder dates BEFORE reconciling: reconciliation can rewrite + // session.json and bump the folder's modification date to "now", which + // would let a healed older session outrank a genuinely newer same-second + // peer in the tie-break below. + let values = try? dir.resourceValues(forKeys: [.creationDateKey, .contentModificationDateKey]) let session = try Self.reconcileSessionDirectory( at: dir, id: id, assumedStateIfRebuilt: .archived, fileManager: .default) - let values = try? dir.resourceValues(forKeys: [.creationDateKey, .contentModificationDateKey]) + // The manifest `createdAt` is the authoritative timestamp; the folder dates + // only refine ties between same-second sessions. let folderCreatedAt = values?.creationDate ?? session.createdAt let folderModifiedAt = values?.contentModificationDate ?? folderCreatedAt keyed.append((session, folderCreatedAt, folderModifiedAt)) diff --git a/Tests/ShotdeckCoreTests/SessionRetentionTests.swift b/Tests/ShotdeckCoreTests/SessionRetentionTests.swift index e3b80b6..6a6b68b 100644 --- a/Tests/ShotdeckCoreTests/SessionRetentionTests.swift +++ b/Tests/ShotdeckCoreTests/SessionRetentionTests.swift @@ -187,6 +187,35 @@ func theSendArchivePathAppliesRetention() async throws { #expect(kept.allSatisfy { $0.pdfFileName != nil }) } +// MARK: - 7. a stale open session is never returned as current (truth guard) + +@Test +func aStaleOpenSessionIsNeverReturnedAsCurrent() async throws { + let (root, paths) = try makeIsolatedPaths() + defer { try? FileManager.default.removeItem(at: root) } + + let store = try SpoolStore(paths: paths) + _ = try await store.append( + pngData: try makePNGData(width: 6, height: 6, red: 0.7, green: 0.7, blue: 0.1), + pixelWidth: 6, pixelHeight: 6, scale: 1.0, capturedAt: Date()) + let archived = try await store.archiveCurrent(pdfFileName: "Redline-20261011-120200.pdf") + + // Simulate the mid-run failure the truth guard exists for: the archived session + // moved away and the replacement open session's folder is gone (e.g. the fresh + // session could not be created / survive). The store must mint a real fresh + // session — never report the already-archived one as open. + let fresh = try await store.currentSession() + try FileManager.default.removeItem(at: paths.sessionDirectory(fresh.id)) + + let recovered = try await store.currentSession() + #expect(recovered.id != fresh.id) + #expect(recovered.id != archived.id) + #expect(recovered.state == .open) + #expect(recovered.isEmpty) + let past = try await store.archivedSessions() + #expect(past.map(\.id) == [archived.id]) +} + // MARK: - Fixtures private enum FixtureError: Error { diff --git a/Tests/ShotdeckTests/SessionWorkflowTests.swift b/Tests/ShotdeckTests/SessionWorkflowTests.swift index a1b3809..2fe3f88 100644 --- a/Tests/ShotdeckTests/SessionWorkflowTests.swift +++ b/Tests/ShotdeckTests/SessionWorkflowTests.swift @@ -105,7 +105,8 @@ func successfulSendRefreshesPastSubmissions() async throws { let model = AppDelegate.makeLaunchModel(appSupportRoot: root) _ = try await addCapture(to: model, red: 0.4, green: 0.4, blue: 0.4) - await model.handleDidShareItems(fileName: "Redline-20261011-120000.pdf", pageCount: 1) + await model.handleDidShareItems( + fileName: "Redline-20261011-120000.pdf", sentSummary: "Sent — 1 page.") #expect(model.statusLine == "Sent — 1 page.") #expect(model.session.isEmpty) @@ -150,6 +151,24 @@ func sessionStartAndSendRefuseToOverlap() async throws { #expect(model.pastSessions.first?.captures.map(\.id) == [capture.id]) } +@MainActor +@Test("The OneDrive send summary survives archiving (never overwritten by the archive path)") +func oneDriveSendSummarySurvivesArchiving() async throws { + let fm = FileManager.default + let root = fm.temporaryDirectory + .appendingPathComponent("shotdeck-session-workflow-\(UUID().uuidString)", isDirectory: true) + defer { try? fm.removeItem(at: root) } + let model = AppDelegate.makeLaunchModel(appSupportRoot: root) + + _ = try await addCapture(to: model, red: 0.6, green: 0.2, blue: 0.2) + let summary = "Saved to OneDrive — 1 page. Open it in Files on your iPad." + await model.handleDidShareItems(fileName: "Redline-20261011-120100.pdf", sentSummary: summary) + + #expect(model.statusLine == summary) + #expect(model.pastSessions.count == 1) + #expect(model.pastSessions.first?.pdfFileName == "Redline-20261011-120100.pdf") +} + // MARK: - Fixtures /// Appends one generated PNG through the store and refreshes `model.session` from