feat(sessions): past submissions list + start-new-session with 10-session retention

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.
This commit is contained in:
Claude Fable 5
2026-10-11 13:35:38 +04:00
parent eb1af5bf18
commit 6ab398c3f2
8 changed files with 790 additions and 18 deletions
+96
View File
@@ -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()
+20
View File
@@ -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: {
+38 -3
View File
@@ -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)
+138
View File
@@ -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()
}
}
@@ -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,
+97 -12
View File
@@ -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)
@@ -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/<id>/.
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
}
@@ -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
}