Preserve image attachments when dropping or pasting into terminals

.github/workflows/cmux-tui-release-delivery.yml

@@ -18,7 +18,7 @@ concurrency:
 jobs:
   delivery:
     name: verify registry delivery
-    runs-on: ubuntu-latest
+    runs-on: ${{ vars.LINUX_RUNNER || 'blacksmith-4vcpu-ubuntu-2404' }}
     timeout-minutes: 5
     steps:
       # Always use the trusted default branch, never workflow_run's source.

Packages/Shared/CmuxIrxTransport/Sources/CmuxIrxTransport/IrxRelayCredentialInstaller.swift

@@ -61,6 +61,11 @@ actor IrxRelayCredentialInstaller {
         installed.removeAll()
     }
 
+    /// Waits for the current installation pass, including its retries, to finish.
+    func waitUntilSettled() async {
+        await task?.value
+    }
+
     private func run(id: UUID) async {
         defer {
             if taskID == id {

Packages/Shared/CmuxIrxTransport/Tests/CmuxIrxTransportTests/IrxLiveQUICTests.swift

@@ -694,7 +694,7 @@ struct IrxLiveQUICTests {
             )
         )
         await retired.connection.close(code: .explicitRedial, origin: .local)
-        try await Task.sleep(for: .milliseconds(150))
+        _ = await retired.connection.termination()
         #expect(await engine.currentSession() == nil)
         #expect(
             journal.counterSnapshot()["dial-started"] ?? 0

Packages/Shared/CmuxIrxTransport/Tests/CmuxIrxTransportTests/IrxLivenessTests.swift

@@ -52,14 +52,14 @@ struct IrxLivenessTests {
         let host = try await IrxLivenessTestHost.make(behavior: .delayFirstProbe)
         defer { Task { await host.stop() } }
         let session = try await host.dial()
+        let probe = Task { await session.connection.probeLiveness(deadline: .seconds(30)) }
+        try await waitUntil { await host.probeCount == 1 }
         try await session.connection.startClientKeepalive(interval: .milliseconds(10), deadline: .milliseconds(100)) {
             await host.recordDeath()
         }
-        try await waitUntil { await host.probeCount == 1 }
         await session.connection.setApplicationActive(false)
-        // Deliberately outlast the cancelled probe deadline. This represents time
-        // during which iOS is backgrounded and cannot perform application work.
-        try await Task.sleep(for: .milliseconds(250))
+        #expect(await probe.value == false)
+        try await expectControlRoundTrip(on: session, message: "control-survives-suspension")
         #expect(host.journal.counterSnapshot()["miss", default: 0] == 0)
         #expect(await host.deathCount == 0)
         #expect(await host.probeCount == 1)

Packages/Shared/CmuxIrxTransport/Tests/CmuxIrxTransportTests/IrxRelayCredentialInstallerTests.swift

@@ -35,16 +35,18 @@ struct IrxRelayCredentialInstallerTests {
     @Test func gatedInstallationRetriesWithoutAnotherMintAndStopsAfterInvalidation() async throws {
         let native = RelayInstallProbe(failFirst: true)
         let gate = IrxRelayCredentialRotationGate()
+        let retry = IrxAsyncLatch()
         let generation = await gate.begin()
         let installer = IrxRelayCredentialInstaller(installed: [], journal: IrxLiveTestSupport.journal(),
             sleep: { _ in
                 await native.noteSleep()
-                try await Task.sleep(for: .milliseconds(100))
+                await retry.wait()
             }, install: { try await native.install($0) })
         await installer.replace(with: [credential("old")], ownership: .init(gate: gate, generation: generation))
         try await waitUntil { await native.sleepCount == 1 }
         await gate.invalidate()
-        try await Task.sleep(for: .milliseconds(200))
+        await retry.signal()
+        await installer.waitUntilSettled()
         #expect(await native.tokens == ["old"])
 
         let current = await gate.begin()

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

@@ -9,16 +9,19 @@ extension TerminalPasteboardService: TerminalClipboardReading {
     public func stringContents(from pasteboard: NSPasteboard) -> String? {
         let types = pasteboard.types ?? []
 
-        if (types.contains(.fileURL) || types.contains(.URL)),
+        let hasImagePayload = hasImageData(in: pasteboard)
+        let hasRTFDAttachmentPayload = types.contains(.rtfd)
+        // Image copies may also advertise a source URL. Resolve their actual
+        // image/rich-text payload before treating that URL as paste text.
+        if !hasImagePayload && !hasRTFDAttachmentPayload,
+           (types.contains(.fileURL) || types.contains(.URL)),
            let urls = pasteboard.readObjects(forClasses: [NSURL.self]) as? [URL],
            !urls.isEmpty {
             return urls
                 .map { $0.isFileURL ? $0.path.terminalShellEscaped : $0.absoluteString }
                 .joined(separator: " ")
         }
 
-        let hasImagePayload = hasImageData(in: pasteboard)
-        let hasRTFDAttachmentPayload = types.contains(.rtfd)
         let plainText = plainTextContents(from: pasteboard)
         let parsedHTMLOutcome: HTMLPlainTextParseOutcome?
         if hasImagePayload || hasRTFDAttachmentPayload {

Sources/DragOverlayRoutingPolicy.swift

@@ -134,23 +134,25 @@ enum FileDropTextDropController {
         panelId: UUID,
         hostedView: GhosttySurfaceScrollView,
         urls: [URL],
-        window: NSWindow?
+        window: NSWindow?,
+        pasteboard: NSPasteboard? = nil
     ) -> Bool {
         performPanelTextDrop(
             workspace: workspace,
             panelId: panelId,
             focusIntent: .terminal(.surface),
             window: window,
             insert: {
-                hostedView.handleDroppedURLs(urls)
+                hostedView.handleDroppedURLs(urls, pasteboard: pasteboard)
             }
         )
     }
 
     @discardableResult
     static func performTerminalFileDrop(
         terminal: GhosttyNSView,
-        urls: [URL]
+        urls: [URL],
+        pasteboard: NSPasteboard? = nil
     ) -> Bool {
         guard let workspaceId = terminal.tabId,
               let terminalSurfaceId = terminal.terminalSurface?.id,
@@ -159,15 +161,15 @@ enum FileDropTextDropController {
                 terminalSurfaceId: terminalSurfaceId,
                 workspace: workspace
               ) else {
-            return terminal.handleDroppedFileURLs(urls)
+            return terminal.handleDroppedFileURLs(urls, pasteboard: pasteboard)
         }
         return performPanelTextDrop(
             workspace: workspace,
             panelId: panelId,
             focusIntent: .terminal(.surface),
             window: terminal.window,
             insert: {
-                terminal.handleDroppedFileURLs(urls)
+                terminal.handleDroppedFileURLs(urls, pasteboard: pasteboard)
             }
         )
     }

Sources/FileDropOverlayViewHitTesting.swift

@@ -193,7 +193,7 @@ extension FileDropOverlayView {
             return insert(text, into: textView)
         }
         if let terminal = terminalUnderPoint(windowPoint) {
-            return insert(urls, into: terminal)
+            return insert(urls, into: terminal, pasteboard: sender.draggingPasteboard)
         }
         return false
     }
@@ -235,10 +235,11 @@ extension FileDropOverlayView {
         return true
     }
 
-    private func insert(_ urls: [URL], into terminal: GhosttyNSView) -> Bool {
+    private func insert(_ urls: [URL], into terminal: GhosttyNSView, pasteboard: NSPasteboard) -> Bool {
         FileDropTextDropController.performTerminalFileDrop(
             terminal: terminal,
-            urls: urls
+            urls: urls,
+            pasteboard: pasteboard
         )
     }
 

Sources/GhosttyNSView+PreparedImageTransfer.swift

@@ -1,3 +1,4 @@
+import AppKit
 import Foundation
 
 extension GhosttyNSView {
@@ -35,33 +36,42 @@ extension GhosttyNSView {
                 )
                 return false
             }
-            let onTextCompletion: () -> Void
-            switch plan {
-            case .insertText:
-                onTextCompletion = {
-                    preparedContent.cleanupTransferredTemporaryFiles(
-                        using: GhosttyApp.terminalPasteboard
-                    )
-                }
-            case .insertTextSegments(let segments, _):
-                var remainingSegments = segments.count
-                onTextCompletion = {
-                    remainingSegments = max(0, remainingSegments - 1)
-                    guard remainingSegments == 0 else { return }
-                    preparedContent.cleanupTransferredTemporaryFiles(
-                        using: GhosttyApp.terminalPasteboard
-                    )
-                }
-            case .uploadFiles, .pasteCloudImages:
-                onTextCompletion = {}
-            case .reject:
-                onTextCompletion = {}
-            }
             return executeImageTransferPlan(
                 plan,
-                onCancel: onCancel,
-                onTextCompletion: onTextCompletion
+                onCancel: onCancel
+            )
+        }
+    }
+
+    func handleDroppedFileURLs(_ urls: [URL], pasteboard: NSPasteboard? = nil) -> Bool {
+        if let pasteboard {
+            return insertDroppedPasteboard(pasteboard)
+        }
+        let dragTypes = NSPasteboard(name: .drag).types ?? []
+        guard let durableURLs = GhosttyApp.terminalPasteboard.durableDroppedFileURLs(
+            urls,
+            sourceIsTransient: PasteboardFileURLReader.hasPromisedFileURLType(
+                dragTypes
             )
+        ) else {
+            return false
         }
+        return executePreparedImageTransfer(
+            .fileURLs(durableURLs),
+            onCancel: {}
+        )
+    }
+
+    @discardableResult
+    func insertDroppedPasteboard(_ pasteboard: NSPasteboard) -> Bool {
+        let prepared = TerminalImageTransferPlanner.prepareSynchronously(
+            pasteboard: pasteboard,
+            mode: .drop
+        )
+#if DEBUG
+        cmuxDebugLog("terminal.imageDrop.prepared surface=\(terminalSurface?.id.uuidString.prefix(5) ?? "nil") " +
+            "types=\((pasteboard.types ?? []).map(\.rawValue).joined(separator: ",")) prepared=\(prepared.cmuxDebugDescription)")
+#endif
+        return executePreparedImageTransfer(prepared, onCancel: {})
     }
 }

Sources/GhosttyTerminalView.swift

@@ -9408,32 +9408,6 @@ class GhosttyNSView: NSView, NSUserInterfaceValidations {
         }
     }
 
-    func handleDroppedFileURLs(_ urls: [URL]) -> Bool {
-        let dragTypes = NSPasteboard(name: .drag).types ?? []
-        guard let durableURLs = GhosttyApp.terminalPasteboard.durableDroppedFileURLs(
-            urls,
-            sourceIsTransient: PasteboardFileURLReader.hasPromisedFileURLType(
-                dragTypes
-            )
-        ) else {
-            return false
-        }
-        return executePreparedImageTransfer(
-            .fileURLs(durableURLs),
-            onCancel: {}
-        )
-    }
-
-    @discardableResult
-    fileprivate func insertDroppedPasteboard(_ pasteboard: NSPasteboard) -> Bool {
-        executePreparedImageTransfer(
-            TerminalImageTransferPlanner.prepareSynchronously(
-                pasteboard: pasteboard,
-                mode: .drop
-            ),
-            onCancel: {}
-        )
-    }
 
 
 #if DEBUG
@@ -11789,11 +11763,11 @@ final class GhosttySurfaceScrollView: NSView {
     }
 
     /// Handle file/URL drops, forwarding to the terminal as shell-escaped paths.
-    func handleDroppedURLs(_ urls: [URL]) -> Bool {
+    func handleDroppedURLs(_ urls: [URL], pasteboard: NSPasteboard? = nil) -> Bool {
         #if DEBUG
         cmuxDebugLog("terminal.swiftUIDrop surface=\(surfaceView.terminalSurface?.id.uuidString.prefix(5) ?? "nil") urls=\(urls.map(\.lastPathComponent))")
         #endif
-        return surfaceView.handleDroppedFileURLs(urls)
+        return surfaceView.handleDroppedFileURLs(urls, pasteboard: pasteboard)
     }
 
     func terminalViewForDrop(at point: NSPoint) -> GhosttyNSView? {

Sources/PaneDropContainer.swift

@@ -270,15 +270,16 @@ extension PaneDropContainer {
         _ urls: [URL],
         context: PaneDropContext,
         hostedView: GhosttySurfaceScrollView?,
-        window: NSWindow?
+        window: NSWindow?,
+        pasteboard: NSPasteboard? = nil
     ) -> Bool {
         if let hostedView {
             return performPanelTextDrop(
                 panelId: context.panelId,
                 focusIntent: .terminal(.surface),
                 window: window,
                 insert: {
-                    hostedView.handleDroppedURLs(urls)
+                    hostedView.handleDroppedURLs(urls, pasteboard: pasteboard)
                 }
             )
         }
@@ -292,7 +293,7 @@ extension PaneDropContainer {
                 focusIntent: .terminal(.surface),
                 window: window ?? terminalPanel.surface.uiWindow,
                 insert: {
-                    terminalPanel.hostedView.handleDroppedURLs(urls)
+                    terminalPanel.hostedView.handleDroppedURLs(urls, pasteboard: pasteboard)
                 }
             )
         }

Sources/PasteboardFileURLReader.swift

@@ -0,0 +1,82 @@
+import AppKit
+import Foundation
+
+enum PasteboardFileURLReader {
+    static let legacyFilenamesPboardType = NSPasteboard.PasteboardType(rawValue: "NSFilenamesPboardType")
+    static let promisedFileURLPasteboardType = NSPasteboard.PasteboardType(
+        rawValue: "com.apple.pasteboard.promised-file-url"
+    )
+    static let fileURLPasteboardTypes: Set<NSPasteboard.PasteboardType> = [
+        .fileURL,
+        legacyFilenamesPboardType,
+        promisedFileURLPasteboardType,
+    ]
+
+    static func hasFileURLType(_ pasteboardTypes: [NSPasteboard.PasteboardType]) -> Bool {
+        return pasteboardTypes.contains { fileURLPasteboardTypes.contains($0) }
+    }
+
+    static func hasPromisedFileURLType(
+        _ pasteboardTypes: [NSPasteboard.PasteboardType]
+    ) -> Bool {
+        pasteboardTypes.contains(promisedFileURLPasteboardType)
+    }
+
+    static func fileURLs(from pasteboard: NSPasteboard) -> [URL] {
+        var fileURLs: [URL] = []
+        var didReadPromisedFileURL = false
+
+        let objects = pasteboard.readObjects(
+            forClasses: [NSURL.self],
+            options: [.urlReadingFileURLsOnly: true]
+        ) ?? []
+        for object in objects {
+            if let url = object as? URL, url.isFileURL {
+                fileURLs.append(url.standardizedFileURL)
+            }
+        }
+
+        if let paths = pasteboard.propertyList(forType: legacyFilenamesPboardType) as? [String] {
+            fileURLs.append(
+                contentsOf: paths
+                    .filter { !$0.isEmpty }
+                    .map { URL(fileURLWithPath: $0).standardizedFileURL }
+            )
+        }
+
+        if let rawFileURL = pasteboard.string(forType: .fileURL),
+           let url = URL(string: rawFileURL),
+           url.isFileURL {
+            fileURLs.append(url.standardizedFileURL)
+        }
+
+        for item in pasteboard.pasteboardItems ?? [] {
+            guard let rawPromisedFileURL = item.string(
+                forType: promisedFileURLPasteboardType
+            ),
+            let url = URL(string: rawPromisedFileURL),
+            url.isFileURL else {
+                continue
+            }
+            fileURLs.append(url.standardizedFileURL)
+            didReadPromisedFileURL = true
+        }
+
+        // A few providers expose the promised value on the pasteboard rather
+        // than on an individual item. Preserve that legacy representation as
+        // a fallback after item-level extraction.
+        if !didReadPromisedFileURL,
+           let rawPromisedFileURL = pasteboard.string(
+               forType: promisedFileURLPasteboardType
+           ),
+           let url = URL(string: rawPromisedFileURL),
+           url.isFileURL {
+            fileURLs.append(url.standardizedFileURL)
+        }
+
+        var seen: Set<String> = []
+        return fileURLs.filter { url in
+            seen.insert(url.path).inserted
+        }
+    }
+}