fix: preserve terminal protocol state across output drops

Author: sionic-khope

Sources/MikuCodeApp/TerminalANSIParser.swift

@@ -1,10 +1,13 @@
+import Foundation
+
 struct TerminalANSIParser: Sendable {
     enum Event: Sendable {
         case ground(UInt8)
         case clear
         case saveCursor
         case restoreCursor
         case bracketedPaste(enabled: Bool)
+        case malformed
         case csi(parameters: [Int], final: UInt8)
     }
 
@@ -107,6 +110,7 @@ struct TerminalANSIParser: Sendable {
             csiBytes.append(byte)
         } else {
             state = .ground
+            return .malformed
         }
         return nil
     }
@@ -120,6 +124,30 @@ struct TerminalANSIParser: Sendable {
     }
 }
 
+struct TerminalProtocolState: Sendable {
+    private var parser = TerminalANSIParser()
+    private(set) var isBracketedPasteEnabled = false
+
+    mutating func reset(bracketedPasteEnabled: Bool = false) {
+        parser.reset()
+        isBracketedPasteEnabled = bracketedPasteEnabled
+    }
+
+    mutating func consume(_ data: Data) {
+        for byte in data {
+            guard let event = parser.consume(byte) else { continue }
+            switch event {
+            case let .bracketedPaste(enabled):
+                isBracketedPasteEnabled = enabled
+            case .malformed:
+                isBracketedPasteEnabled = false
+            default:
+                break
+            }
+        }
+    }
+}
+
 enum TerminalGraphicRendition {
     static func applying(_ rawValues: [Int], to initialStyle: TerminalStyle) -> TerminalStyle {
         let values = rawValues.isEmpty ? [0] : rawValues

Sources/MikuCodeApp/TerminalBuffer.swift

@@ -74,10 +74,16 @@ struct TerminalBuffer: Sendable {
             cursor = min(savedCursor, currentLine.cells.count)
         case let .bracketedPaste(enabled):
             isBracketedPasteEnabled = enabled
+        case .malformed:
+            break
         case let .csi(parameters, final):
             handleCSI(parameters: parameters, final: final)
         }
     }
+    mutating func recoverFromInputDiscontinuity() {
+        parser.reset()
+        utf8Decoder.reset()
+    }
     private mutating func consumeGround(_ byte: UInt8) {
         switch byte {
         case 0x1B:

Sources/MikuCodeApp/TerminalSessionModel.swift

@@ -47,6 +47,7 @@ final class TerminalSessionModel: ObservableObject {
             isBracketedPasteEnabled = buffer.isBracketedPasteEnabled
             publishSnapshot()
         }
+        pendingOutput.reset(bracketedPasteEnabled: buffer.isBracketedPasteEnabled)
 
         do {
             let launchSize = lastSize ?? (80, 24)
@@ -152,12 +153,18 @@ final class TerminalSessionModel: ObservableObject {
     }
 
     private func flushPendingOutput() {
-        let chunks = pendingOutput.takeAll()
-        guard !chunks.isEmpty else { return }
-        for chunk in chunks {
+        let batch = pendingOutput.takeAll()
+        guard !batch.chunks.isEmpty else {
+            isBracketedPasteEnabled = batch.isBracketedPasteEnabled
+            return
+        }
+        if batch.hasDiscontinuity {
+            buffer.recoverFromInputDiscontinuity()
+        }
+        for chunk in batch.chunks {
             buffer.ingest(chunk)
         }
-        isBracketedPasteEnabled = buffer.isBracketedPasteEnabled
+        isBracketedPasteEnabled = batch.isBracketedPasteEnabled
         publishSnapshot()
     }
 
@@ -211,39 +218,71 @@ final class TerminalSessionModel: ObservableObject {
     }
 }
 
-private final class PendingTerminalOutputQueue: @unchecked Sendable {
-    private static let maximumByteCount = 1024 * 1024
+struct PendingTerminalOutputBatch: Sendable {
+    let chunks: [Data]
+    let hasDiscontinuity: Bool
+    let isBracketedPasteEnabled: Bool
+}
+
+final class PendingTerminalOutputQueue: @unchecked Sendable {
+    private let maximumByteCount: Int
 
     private let lock = NSLock()
     private var chunks: [Data] = []
     private var byteCount = 0
+    private var hasDiscontinuity = false
+    private var protocolState = TerminalProtocolState()
+
+    init(maximumByteCount: Int = 1024 * 1024) {
+        self.maximumByteCount = max(1, maximumByteCount)
+    }
+
+    func reset(bracketedPasteEnabled: Bool = false) {
+        lock.lock()
+        defer { lock.unlock() }
+        chunks.removeAll(keepingCapacity: true)
+        byteCount = 0
+        hasDiscontinuity = false
+        protocolState.reset(bracketedPasteEnabled: bracketedPasteEnabled)
+    }
 
     func append(_ data: Data) -> Bool {
         guard !data.isEmpty else { return false }
         lock.lock()
         defer { lock.unlock() }
 
         let wasEmpty = byteCount == 0
-        if data.count >= Self.maximumByteCount {
-            chunks = [Data(data.suffix(Self.maximumByteCount))]
-            byteCount = Self.maximumByteCount
+        protocolState.consume(data)
+        if data.count >= maximumByteCount {
+            chunks = [Data(data.suffix(maximumByteCount))]
+            byteCount = maximumByteCount
+            hasDiscontinuity = hasDiscontinuity || data.count > maximumByteCount || !wasEmpty
             return wasEmpty
         }
 
         chunks.append(data)
         byteCount += data.count
-        dropOldestBytes(byteCount - Self.maximumByteCount)
+        let droppedByteCount = byteCount - maximumByteCount
+        if droppedByteCount > 0 {
+            hasDiscontinuity = true
+            dropOldestBytes(droppedByteCount)
+        }
         return wasEmpty
     }
 
-    func takeAll() -> [Data] {
+    func takeAll() -> PendingTerminalOutputBatch {
         lock.lock()
         defer { lock.unlock() }
 
-        let pending = chunks
+        let batch = PendingTerminalOutputBatch(
+            chunks: chunks,
+            hasDiscontinuity: hasDiscontinuity,
+            isBracketedPasteEnabled: protocolState.isBracketedPasteEnabled
+        )
         chunks.removeAll(keepingCapacity: true)
         byteCount = 0
-        return pending
+        hasDiscontinuity = false
+        return batch
     }
 
     private func dropOldestBytes(_ count: Int) {

Tests/MikuCodeAppTests/TerminalBufferTests.swift

@@ -112,6 +112,61 @@ final class TerminalBufferTests: XCTestCase {
         XCTAssertFalse(buffer.isBracketedPasteEnabled)
     }
 
+    func testRecoversVisualParserAfterDroppedUTF8AndANSIPrefixes() {
+        let queue = PendingTerminalOutputQueue(maximumByteCount: 8)
+        let oversized = Data("drop".utf8)
+            + Data([0xEB, 0xB0, 0x1B, 0x5B, 0xB8])
+            + Data("31mkept".utf8)
+        XCTAssertTrue(queue.append(oversized))
+
+        let batch = queue.takeAll()
+        XCTAssertTrue(batch.hasDiscontinuity)
+
+        var buffer = TerminalBuffer()
+        buffer.recoverFromInputDiscontinuity()
+        for chunk in batch.chunks {
+            buffer.ingest(chunk)
+        }
+
+        XCTAssertEqual(buffer.snapshot.plainText, "�31mkept")
+        XCTAssertEqual(buffer.snapshot.lines[0].cells.last?.style, .default)
+    }
+
+    func testProtocolModeSurvivesDisplayDropAndTracksLaterDisable() {
+        let queue = PendingTerminalOutputQueue(maximumByteCount: 8)
+        var buffer = TerminalBuffer()
+
+        XCTAssertTrue(queue.append(Data("prefix\u{1B}[?2004h".utf8)))
+        XCTAssertFalse(queue.append(Data("oversized".utf8)))
+
+        let droppedBatch = queue.takeAll()
+        XCTAssertTrue(droppedBatch.hasDiscontinuity)
+        XCTAssertTrue(droppedBatch.isBracketedPasteEnabled)
+
+        buffer.recoverFromInputDiscontinuity()
+        for chunk in droppedBatch.chunks {
+            buffer.ingest(chunk)
+        }
+
+        XCTAssertTrue(queue.append(Data("\u{1B}[?2004l".utf8)))
+        let disabledBatch = queue.takeAll()
+        XCTAssertFalse(disabledBatch.isBracketedPasteEnabled)
+        for chunk in disabledBatch.chunks {
+            buffer.ingest(chunk)
+        }
+        XCTAssertFalse(buffer.isBracketedPasteEnabled)
+    }
+
+    func testProtocolModeFailsClosedOnOversizedCSI() {
+        var state = TerminalProtocolState()
+        state.consume(Data("\u{1B}[?2004h".utf8))
+        XCTAssertTrue(state.isBracketedPasteEnabled)
+
+        state.consume(Data([0x1B, 0x5B] + Array(repeating: 0x31, count: 65)))
+
+        XCTAssertFalse(state.isBracketedPasteEnabled)
+    }
+
     func testCapsCombiningScalarsWithoutGrowingStoredCells() {
         let maximumScalarsPerCell = 32
         var buffer = TerminalBuffer(maxLines: 1, maxCells: 1)