Show a brief notice when Cmd+V fails on an oversized image or a timeout

Packages/macOS/CmuxTerminal/Sources/CmuxTerminal/Services/Pasteboard/TerminalPasteboardService+ImageMaterialization.swift

@@ -8,6 +8,8 @@ extension TerminalPasteboardService: TerminalImagePasteWriting {
     /// Attempts to materialize a decodable pasteboard image into a temporary file.
     /// `rejectedImagePayload` means a real image was found but could not be used,
     /// so callers should not fall back to auxiliary plain text or URLs.
+    /// `rejectedOversizedImagePayload` is the same rejection for an image over
+    /// ``maxClipboardImageSize``.
     public func materializeImageFileURLIfNeeded(
         from pasteboard: NSPasteboard = .general
     ) -> TerminalImageFileMaterialization {
@@ -20,6 +22,8 @@ extension TerminalPasteboardService: TerminalImagePasteWriting {
             return .noDecodableImagePayload
         case .rejectedImagePayload:
             return .rejectedImagePayload
+        case .rejectedOversizedImagePayload:
+            return .rejectedOversizedImagePayload
         }
     }
 
@@ -106,7 +110,7 @@ extension TerminalPasteboardService {
                 logDebugEvent("terminal.paste.image.rejected reason=tooLarge bytes=\(representation.data.count)")
 #endif
                 cleanupTransferredTemporaryImageFiles(fileURLs)
-                return .rejectedImagePayload
+                return .rejectedOversizedImagePayload
             }
 
             let fileURL = temporaryImageFileURL(fileExtension: representation.fileExtension)

Packages/macOS/CmuxTerminal/Tests/CmuxTerminalTests/Services/TerminalPasteboardServiceTests.swift

@@ -325,14 +325,26 @@ struct ImageMaterializationTests {
         scratch.pasteboard.declareTypes([.png], owner: nil)
         scratch.pasteboard.setData(Data(count: 10 * 1024 * 1024 + 1), forType: .png)
 
+        // Oversized is reported separately from a failed write so a paste
+        // can say why nothing arrived.
         #expect(
             service.materializeImageFileURLIfNeeded(from: scratch.pasteboard)
-                == .rejectedImagePayload
+                == .rejectedOversizedImagePayload
+        )
+        #expect(
+            service.materializeImageFileURLsIfNeeded(from: scratch.pasteboard)
+                == .rejectedOversizedImagePayload
         )
         let leftovers = try FileManager.default.contentsOfDirectory(atPath: scratchDir.path)
         #expect(leftovers.isEmpty)
     }
 
+    /// The app's paste notice says "Image is larger than 10 MB". Changing the
+    /// cap must change that string too.
+    @Test func clipboardImageCapMatchesThePasteNoticeText() {
+        #expect(TerminalPasteboardService.maxClipboardImageSize == 10 * 1024 * 1024)
+    }
+
     @Test func emptyPasteboardHasNoDecodableImagePayload() {
         let scratch = ScratchPasteboard()
         let service = TerminalPasteboardService()

Packages/macOS/CmuxTerminalCore/Sources/CmuxTerminalCore/Clipboard/TerminalImageFileListMaterialization.swift

@@ -5,7 +5,8 @@ public import Foundation
 /// `rejectedImagePayload` means at least one real image was found but the
 /// batch could not be used (an item was too large or failed to write; any
 /// files already written are cleaned up), so callers must not fall back to
-/// auxiliary plain text or URLs.
+/// auxiliary plain text or URLs. `rejectedOversizedImagePayload` is the same
+/// rejection when the reason is that an item exceeded the clipboard image cap.
 public enum TerminalImageFileListMaterialization: Equatable, Sendable {
     /// Every image was written; the URLs preserve pasteboard order.
     case saved([URL])
@@ -15,4 +16,8 @@ public enum TerminalImageFileListMaterialization: Equatable, Sendable {
 
     /// A real image payload was found but the batch could not be materialized.
     case rejectedImagePayload
+
+    /// An image in the batch is larger than the clipboard image cap; any files
+    /// already written are cleaned up.
+    case rejectedOversizedImagePayload
 }

Packages/macOS/CmuxTerminalCore/Sources/CmuxTerminalCore/Clipboard/TerminalImageFileMaterialization.swift

@@ -2,9 +2,10 @@ public import Foundation
 
 /// The outcome of materializing one pasteboard image into a temporary file.
 ///
-/// `rejectedImagePayload` means a real image was found but could not be used
-/// (too large, or the write failed), so callers must not fall back to
-/// auxiliary plain text or URLs.
+/// `rejectedOversizedImagePayload` and `rejectedImagePayload` both mean a real
+/// image was found but could not be used (too large, or the write failed), so
+/// callers must not fall back to auxiliary plain text or URLs. The oversized
+/// case is separate so a paste can tell the user why nothing arrived.
 public enum TerminalImageFileMaterialization: Equatable, Sendable {
     /// The image was written to the given temporary file.
     case saved(URL)
@@ -14,4 +15,8 @@ public enum TerminalImageFileMaterialization: Equatable, Sendable {
 
     /// A real image payload was found but could not be materialized.
     case rejectedImagePayload
+
+    /// A real image payload was found but it is larger than the clipboard
+    /// image cap, so nothing was written.
+    case rejectedOversizedImagePayload
 }

Resources/Localizable.xcstrings

@@ -554316,6 +554316,124 @@
           }
         }
       }
+    },
+    "terminal.paste.notice.imageTooLarge": {
+      "extractionState": "manual",
+      "localizations": {
+        "ar": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "الصورة أكبر من 10 ميغابايت"
+          }
+        },
+        "de": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Bild ist größer als 10 MB"
+          }
+        },
+        "en": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Image is larger than 10 MB"
+          }
+        },
+        "es": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "La imagen supera los 10 MB"
+          }
+        },
+        "fr": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "L’image dépasse 10 Mo"
+          }
+        },
+        "ja": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "画像が 10 MB を超えています"
+          }
+        },
+        "ko": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "이미지가 10MB보다 큽니다"
+          }
+        },
+        "zh-Hans": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "图片大于 10 MB"
+          }
+        },
+        "zh-Hant": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "圖片大於 10 MB"
+          }
+        }
+      }
+    },
+    "terminal.paste.notice.timedOut": {
+      "extractionState": "manual",
+      "localizations": {
+        "ar": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "انتهت مهلة اللصق"
+          }
+        },
+        "de": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Zeitüberschreitung beim Einfügen"
+          }
+        },
+        "en": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Paste timed out"
+          }
+        },
+        "es": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Se agotó el tiempo para pegar"
+          }
+        },
+        "fr": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Le collage a expiré"
+          }
+        },
+        "ja": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "貼り付けがタイムアウトしました"
+          }
+        },
+        "ko": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "붙여넣기 시간이 초과되었습니다"
+          }
+        },
+        "zh-Hans": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "粘贴超时"
+          }
+        },
+        "zh-Hant": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "貼上逾時"
+          }
+        }
+      }
     }
   },
   "version": "1.0"

Sources/GhosttyApp+RuntimeClipboardRead.swift

@@ -136,11 +136,13 @@ extension GhosttyApp {
                 .map(\.rawValue)
                 .joined(separator: ",")
 
-            let preparedContent = await TerminalImageTransferPlanner.prepare(
-                pasteboard: pasteboard,
-                mode: .paste,
-                using: preparationService
-            )
+            let preparationOutcome = await TerminalImageTransferPlanner
+                .prepareReportingFailure(
+                    pasteboard: pasteboard,
+                    mode: .paste,
+                    using: preparationService
+                )
+            let preparedContent = preparationOutcome.content
             pasteboardReadLease.finish()
 
             guard !operation.isCancelled else {
@@ -170,8 +172,15 @@ extension GhosttyApp {
             )
 #endif
 
+            // The beep for a timed-out worker already played in the
+            // preparation service; an oversized image was silent. Both now
+            // also get a brief notice over the pasting terminal.
+            if let notice = TerminalPasteFailureNotice.notice(for: preparationOutcome) {
+                requestTerminalSurface.hostedView.showPasteFailureNotice(notice)
+            }
+
             switch preparedContent {
-            case .reject:
+            case .reject, .rejectOversizedImage:
                 completeClipboardRequest(with: "")
             case .insertText(let text):
                 completeClipboardRequest(with: text)

Sources/GhosttyNSView+PreparedImageTransfer.swift

@@ -20,7 +20,7 @@ extension GhosttyNSView {
             return true
         }
         switch preparedContent {
-        case .reject:
+        case .reject, .rejectOversizedImage:
             return false
         case .insertText(let text):
             return terminalSurface?.sendText(text) ?? false

Sources/GhosttyTerminalView.swift

@@ -4960,7 +4960,7 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
             return
         }
 
-        if payload != .reject {
+        if !payload.isRejection {
             let payloadBytes = result.payloadBytes
             guard payloadBytes <= Self.maximumPendingPastePayloadBytes,
                   pendingPastePayloadBytes <=
@@ -5141,7 +5141,7 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
                 let (next, overflowed) = total.addingReportingOverflow(payloadBytes)
                 total = overflowed ? .max : next
             }
-        case .reject:
+        case .reject, .rejectOversizedImage:
             return 0
         }
     }
@@ -10224,6 +10224,7 @@ final class GhosttySurfaceScrollView: NSView {
     private var searchOverlayHostingView: NSHostingView<SurfaceSearchOverlay>?
     private let deferredSearchOverlayMutationScheduler = MainActorDeferredActionScheduler()
     private let imageTransferIndicatorShowScheduler = MainActorDeferredActionScheduler()
+    private lazy var pasteFailureNoticePresenter = TerminalPasteFailureNoticePresenter()
     private var activeImageTransferOperation: TerminalImageTransferOperation?
     private var activeImageTransferCancelHandler: (() -> Void)?
     private var lastSearchOverlayStateID: ObjectIdentifier?
@@ -11497,6 +11498,12 @@ final class GhosttySurfaceScrollView: NSView {
         imageTransferIndicatorSpinner.stopAnimation(nil)
         imageTransferIndicatorContainerView.isHidden = true
     }
+
+    /// Shows a brief, non-modal notice over this terminal for a paste that
+    /// produced nothing (see ``TerminalPasteFailureNotice``).
+    func showPasteFailureNotice(_ notice: TerminalPasteFailureNotice) {
+        pasteFailureNoticePresenter.show(notice, over: self)
+    }
     private func makeSearchOverlayRootView(
         terminalSurface: TerminalSurface,
         searchState: TerminalSurface.SearchState

Sources/TerminalImageTransfer.swift

@@ -19,6 +19,16 @@ enum TerminalImageTransferPreparedContent: Codable, Equatable, Sendable {
     case insertText(String)
     case fileURLs([URL])
     case reject
+    /// Rejected because the pasteboard image is over the clipboard image cap.
+    /// Handled exactly like `reject`, except that a paste can say why.
+    case rejectOversizedImage
+
+    var isRejection: Bool {
+        switch self {
+        case .reject, .rejectOversizedImage: return true
+        case .insertText, .fileURLs: return false
+        }
+    }
 }
 
 enum TerminalImageTransferExecutionError: Error {
@@ -132,7 +142,7 @@ enum TerminalImageTransferPlanner {
     ) -> TerminalImageTransferPlan {
         let preparedContent = prepareSynchronously(pasteboard: pasteboard, mode: mode)
         switch preparedContent {
-        case .insertText, .reject:
+        case .insertText, .reject, .rejectOversizedImage:
             return plan(preparedContent: preparedContent, target: .local, mode: mode)
         case .fileURLs:
             return plan(preparedContent: preparedContent, target: resolveTarget(), mode: mode)
@@ -159,6 +169,21 @@ enum TerminalImageTransferPlanner {
         )
     }
 
+    /// Like ``prepare(pasteboard:mode:using:)``, but also reports why an
+    /// accepted request produced no content (for example, a worker timeout).
+    @MainActor
+    static func prepareReportingFailure(
+        pasteboard: NSPasteboard,
+        mode: TerminalImageTransferMode,
+        using preparationService: TerminalImageTransferPreparationService
+    ) async -> TerminalImageTransferPreparationOutcome {
+        let request = TerminalPasteboardReadRequest(pasteboard: pasteboard)
+        return await preparationService.prepareReportingFailure(
+            request: request,
+            mode: mode
+        )
+    }
+
     static func prepareSynchronously(
         pasteboard: NSPasteboard,
         mode: TerminalImageTransferMode
@@ -199,7 +224,7 @@ enum TerminalImageTransferPlanner {
             return .insertText(text)
         case .fileURLs(let fileURLs):
             return plan(fileURLs: fileURLs, target: target, mode: mode)
-        case .reject:
+        case .reject, .rejectOversizedImage:
             return .reject
         }
     }
@@ -375,6 +400,8 @@ enum TerminalImageTransferPlanner {
                 return .fileURLs([imageURL])
             case .rejectedImagePayload:
                 return .reject
+            case .rejectedOversizedImagePayload:
+                return .rejectOversizedImage
             case .noDecodableImagePayload:
                 break
             }
@@ -467,7 +494,7 @@ enum TerminalImageTransferPlanner {
         }
         switch pasteboardService.materializeImageFileURLsIfNeeded(from: pasteboard) {
         case .saved(let urls): return urls
-        case .rejectedImagePayload: return nil
+        case .rejectedImagePayload, .rejectedOversizedImagePayload: return nil
         case .noDecodableImagePayload: return durableURLs()
         }
     }

Sources/TerminalImageTransferPreparationOutcome.swift

@@ -0,0 +1,7 @@
+/// What terminal paste preparation produced, and why it produced nothing when
+/// an accepted request failed (for example, the worker ran past its deadline).
+struct TerminalImageTransferPreparationOutcome: Equatable, Sendable {
+    let content: TerminalImageTransferPreparedContent
+    /// Nil when the worker returned content, including a `reject`.
+    let failure: TerminalPastePreparationFailure?
+}