From 6ab398c3f2dbdd961c7d1f7ad4179a736b585f76 Mon Sep 17 00:00:00 2001 From: Claude Fable 5 Date: Sun, 11 Oct 2026 13:35:38 +0400 Subject: [PATCH] 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 +}