Fix: stderr-Pipe gegen Instant-Exit-Datenverlust, TCP-Vorab-Check, Fehler-Banner; Icon (Dracula) im Bundle

2026-09-21 23:14:08 +02:00
parent 1828a96a2b
commit 7dc6ff75d2
14 changed files with 397 additions and 33 deletions
@@ -9,9 +9,14 @@ enum PTYState: Equatable {
    case done(exitCode: Int32?, message: String)
 }

-/// SSH/SFTP-Session über ein echtes Pseudo-Terminal (PTY), damit interaktive
-/// Prompts (Passwort, Host-Key) funktionieren. Ausgabe wird via AnsiParser
-/// in gestylte Zeilen für die Dracula-Ansicht übersetzt.
+/// SSH/SFTP-Session über ein echtes Pseudo-Terminal (PTY).
+/// - stdin/stdout: PTY-Slave (interaktiv, TTY bleibt erhalten)
+/// - stderr: PIPE — macOS verwirft ungelesene PTY-Daten beim Slave-Close,
+///   dadurch gingen Fehlermeldungen bei Instant-Exit (z. B. Code 255) verloren.
+///   Pipes liefern gepufferte Daten garantiert aus (Bugfix, siehe docs/ERRORS.md #8).
+///
+/// FD-Regeln: masterFD wird NUR auf dem Main-Thread vergeben/geschlossen,
+/// auf ioQueue nur gelesen (EBADF-tolerant). Kein Close auf ioQueue.
 final class PTYSession: ObservableObject {
    @Published private(set) var lines: [[StyledText]] = [[]]
    @Published private(set) var state: PTYState = .never
@@ -22,9 +27,11 @@ final class PTYSession: ObservableObject {
    private var masterFD: Int32 = -1
    private var process: Process?
    private var readSource: DispatchSourceRead?
+    private var errPipe: Pipe?
    private let ioQueue = DispatchQueue(label: "RemminaMac.pty")
    private var parser = AnsiParser()
    private var finished = false
+    private var epoch = 0 // nur Main-Thread
    private let maxLines = 2000

    var isRunning: Bool {
@@ -42,7 +49,8 @@ final class PTYSession: ObservableObject {
    }

    func start() {
-        stop()
+        cleanupSync()
+        epoch += 1
        finished = false
        parser = AnsiParser()
        state = .running
@@ -64,6 +72,7 @@ final class PTYSession: ObservableObject {
        }
        masterFD = master

+        let pipe = Pipe()
        let p = Process()
        p.executableURL = URL(fileURLWithPath: executable)
        p.arguments = arguments
@@ -74,25 +83,44 @@ final class PTYSession: ObservableObject {
        // closeOnDealloc=false: Parent schließt slave explizit nach run().
        p.standardInput = FileHandle(fileDescriptor: slave)
        p.standardOutput = FileHandle(fileDescriptor: slave)
-        p.standardError = FileHandle(fileDescriptor: slave)
+        p.standardError = pipe.fileHandleForWriting
+        let myEpoch = epoch
        p.terminationHandler = { [weak self] proc in
-            DispatchQueue.main.async {
-                self?.finish(message: "Sitzung beendet (Code \(proc.terminationStatus)).", code: proc.terminationStatus)
+            DispatchQueue.main.async { [weak self] in
+                guard let self, self.epoch == myEpoch else { return }
+                self.ioQueue.async { [weak self] in
+                    self?.finalFlush(code: proc.terminationStatus, myEpoch: myEpoch)
+                }
            }
        }
        do {
            try p.run()
        } catch {
            close(slave); close(master); masterFD = -1
+            errPipe = nil
            finish(message: "Start fehlgeschlagen: \(error.localizedDescription)", code: nil)
            return
        }
        process = p
        close(slave) // Parent behält nur Master
+        errPipe = pipe
+        pipe.fileHandleForReading.readabilityHandler = { [weak self] h in
+            let data = h.availableData
+            guard let self else { return }
+            if data.isEmpty {
+                h.readabilityHandler = nil // EOF
+                return
+            }
+            self.ioQueue.async { [weak self] in
+                guard let self else { return }
+                let events = self.parser.feed(data)
+                DispatchQueue.main.async { self.apply(events) }
+            }
+        }

        let source = DispatchSource.makeReadSource(fileDescriptor: master, queue: ioQueue)
        source.setEventHandler { [weak self] in self?.drain() }
-        source.setCancelHandler { [master] in close(master) }
+        // Kein Close hier (Eigentum: Main-Thread) — nur Cancel.
        readSource = source
        source.resume()
    }
@@ -106,8 +134,27 @@ final class PTYSession: ObservableObject {
            let events = parser.feed(Data(buf[..<n]))
            DispatchQueue.main.async { [weak self] in self?.apply(events) }
        } else {
-            readSource?.cancel()
-            masterFD = -1
+            readSource?.cancel() // EOF/EIO — Rest holt finalFlush bzw. ist verworfen
+        }
+    }
+
+    /// Letzte Reste vom PTY-Master einsammeln (non-blocking, EBADF-safe).
+    /// Pipe-Reste kommen garantiert über den readabilityHandler.
+    private func finalFlush(code: Int32, myEpoch: Int) {
+        var events: [TerminalEvent] = []
+        let fd = masterFD
+        if fd >= 0 {
+            var buf = [UInt8](repeating: 0, count: 65536)
+            while true {
+                let n = read(fd, &buf, buf.count)
+                if n <= 0 { break }
+                events += parser.feed(Data(buf[..<n]))
+            }
+        }
+        DispatchQueue.main.async { [weak self] in
+            guard let self, self.epoch == myEpoch, !self.finished else { return }
+            self.apply(events)
+            self.finish(message: "Sitzung beendet (Code \(code)).", code: code)
        }
    }

@@ -168,36 +215,62 @@ final class PTYSession: ObservableObject {
        lines = [[]]
    }

+    func note(_ message: String) {
+        lines.append([StyledText(text: message, style: TermStyle(fg: 8))])
+    }
+
+    /// Vorab-Check-Fehlschlag (ohne Spawn): rote Notiz + done.
+    func fail(_ message: String) {
+        cleanupSync()
+        epoch += 1
+        finished = true
+        state = .done(exitCode: nil, message: message)
+        lines.append([StyledText(text: "— \(message) —", style: TermStyle(fg: 1))])
+        lines.append([])
+    }
+
    func stop() {
+        let wasRunning = isRunning
        process?.terminate()
-        process = nil
-        if !finished {
+        cleanupSync()
+        if wasRunning {
+            epoch += 1 // späte terminationHandler-Ausläufer verwerfen
            finished = true
-            readSource?.cancel()
-            readSource = nil
-            masterFD = -1
-            if case .running = state {
-                state = .done(exitCode: nil, message: "Getrennt.")
-            }
+            state = .done(exitCode: nil, message: "Getrennt.")
+            lines.append([StyledText(text: "— Getrennt. —", style: TermStyle(fg: 8))])
+            lines.append([])
        }
    }

+    /// Synchroner Cleanup auf Main: Source canceln, Master schließen, Pipe abklemmen.
+    /// Laufende ioQueue-Reads bekommen EBADF und beenden sich selbst.
+    private func cleanupSync() {
+        readSource?.cancel()
+        readSource = nil
+        if masterFD >= 0 {
+            close(masterFD)
+            masterFD = -1
+        }
+        if let pipe = errPipe {
+            pipe.fileHandleForReading.readabilityHandler = nil
+            errPipe = nil
+        }
+        process = nil
+    }
+
    private func finish(message: String, code: Int32?) {
        guard !finished else { return }
        finished = true
-        readSource?.cancel()
-        readSource = nil
-        masterFD = -1
-        process = nil
+        cleanupSync()
        state = .done(exitCode: code, message: message)
-        let note = StyledText(text: "— \(message) —", style: TermStyle(fg: 8))
-        lines.append([note])
+        lines.append([StyledText(text: "— \(message) —", style: TermStyle(fg: 8))])
        lines.append([])
    }

    deinit {
        process?.terminate()
        readSource?.cancel()
+        if masterFD >= 0 { close(masterFD) }
    }
 }

@@ -0,0 +1,65 @@
+import Foundation
+import Network
+
+/// Schneller TCP-Vorab-Check, BEVOR ssh gestartet wird.
+/// Falscher Port / falscher Host / Firewall â†’ sofort klare Meldung
+/// statt „Sitzung beendet (Code 255)" ohne Erklärung.
+enum TCPCheck {
+    private final class Flag {
+        var done = false
+    }
+
+    /// - completion: nil bei Erfolg, sonst deutsche Fehlermeldung.
+    static func check(host: String, port: Int, timeout: TimeInterval = 4.0, completion: @escaping (String?) -> Void) {
+        let h = host.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !h.isEmpty else { completion("Kein Host angegeben — Profil bearbeiten."); return }
+        guard (1...65535).contains(port), let p = NWEndpoint.Port(rawValue: UInt16(port)) else {
+            completion("Ungültiger Port \(port)."); return
+        }
+        let conn = NWConnection(host: NWEndpoint.Host(h), port: p, using: .tcp)
+        let lock = NSLock()
+        let flag = Flag()
+        func finish(_ message: String?) {
+            lock.lock()
+            defer { lock.unlock() }
+            guard !flag.done else { return }
+            flag.done = true
+            conn.cancel()
+            completion(message)
+        }
+        conn.stateUpdateHandler = { state in
+            switch state {
+            case .ready:
+                finish(nil)
+            case .failed(let err):
+                finish(describe(err, host: h, port: port))
+            default:
+                break
+            }
+        }
+        conn.start(queue: .global(qos: .userInitiated))
+        DispatchQueue.global().asyncAfter(deadline: .now() + timeout) {
+            finish("Keine Antwort in \(Int(timeout)) s — Hostname/IP, Netzwerk/VPN oder Firewall prüfen.")
+        }
+    }
+
+    static func describe(_ error: NWError, host: String, port: Int) -> String {
+        switch error {
+        case .posix(let code):
+            switch code.rawValue {
+            case 61:
+                return "Port \(port) auf \(host) verweigert die Verbindung — läuft SSH dort? Stimmt der Port?"
+            case 51, 64, 65:
+                return "Host \(host) nicht erreichbar — Netzwerk/VPN prüfen."
+            case 60:
+                return "Zeitüberschreitung — Host/Port/Firewall prüfen."
+            default:
+                return "Netzwerkfehler (\(code.rawValue)): \(error.localizedDescription)"
+            }
+        case .dns:
+            return "Hostname \(host) kann nicht aufgelöst werden — Tippfehler? DNS/VPN prüfen."
+        default:
+            return error.localizedDescription
+        }
+    }
+}
@@ -2,12 +2,15 @@ import SwiftUI
 import AppKit

 /// In-App-Terminal im Dracula-Look: Ausgabe (NSTextView, read-only) + Eingabezeile.
+/// Verbindet erst nach TCP-Vorab-Check (falscher Port/Host -> sofort klare Meldung).
 /// Zeilenumbruch ist an, Autoscroll ans Ende, Passwort-Modus via Auge-Icon.
 struct EmbeddedTerminalView: View {
    @ObservedObject var term: PTYSession
+    let profile: ConnectionProfile
    var canConnect: Bool
    @State private var input = ""
    @State private var secureInput = false
+    @State private var checking = false

    var body: some View {
        VStack(spacing: 0) {
@@ -18,8 +21,8 @@ struct EmbeddedTerminalView: View {
                Spacer()
                if term.isRunning {
                    Button("Trennen") { term.stop() }.buttonStyle(.link).font(.caption)
-                } else if canConnect {
-                    Button("Verbinden") { term.start() }.buttonStyle(.link).font(.caption)
+                } else if canConnect && !checking {
+                    Button("Verbinden") { connect() }.buttonStyle(.link).font(.caption)
                }
                Button("Leeren") { term.clear() }.buttonStyle(.link).font(.caption)
            }
@@ -27,6 +30,27 @@ struct EmbeddedTerminalView: View {
            .padding(.vertical, 6)
            .background(Dracula.currentLine.opacity(0.35))

+            // Fehler-Banner bei Fehlschlag (statt nur „Sitzung beendet")
+            if failed {
+                HStack(spacing: 8) {
+                    Image(systemName: "exclamationmark.triangle.fill")
+                        .foregroundStyle(Dracula.red)
+                    VStack(alignment: .leading, spacing: 2) {
+                        Text("Verbindung fehlgeschlagen\(exitSuffix)")
+                            .font(.callout).bold().foregroundStyle(Dracula.red)
+                        Text(lastMessage)
+                            .font(.caption).foregroundStyle(Dracula.foreground)
+                            .lineLimit(3)
+                    }
+                    Spacer()
+                    Button("Diagnose") { diagnose() }.buttonStyle(.link).font(.caption)
+                    Button("Erneut") { connect() }.buttonStyle(.link).font(.caption)
+                }
+                .padding(8)
+                .background(Dracula.red.opacity(0.12))
+                .overlay(Rectangle().fill(Dracula.red.opacity(0.4)).frame(height: 1), alignment: .bottom)
+            }
+
            // Ausgabe im Dracula-Theme
            DraculaTextView(lines: term.lines)
                .frame(maxWidth: .infinity, maxHeight: .infinity)
@@ -62,8 +86,39 @@ struct EmbeddedTerminalView: View {
        .cornerRadius(10)
        .overlay(RoundedRectangle(cornerRadius: 10).stroke(Dracula.currentLine, lineWidth: 1))
        .onAppear {
-            if case .never = term.state, canConnect {
-                term.start() // Auto-Connect beim Öffnen des Tabs (Bugfix: kein externes Terminal mehr nötig)
+            if case .never = term.state {
+                connect() // Auto-Connect beim Öffnen des Tabs
+            }
+        }
+    }
+
+    func connect() {
+        guard canConnect, !term.isRunning, !checking else { return }
+        checking = true
+        TCPCheck.check(host: profile.host, port: profile.port) { message in
+            DispatchQueue.main.async {
+                checking = false
+                if let message {
+                    term.fail("Vorab-Check: \(message)")
+                } else {
+                    term.start()
+                }
+            }
+        }
+    }
+
+    func diagnose() {
+        guard !checking else { return }
+        checking = true
+        term.note("Diagnose: TCP \(profile.host):\(profile.port) …")
+        TCPCheck.check(host: profile.host, port: profile.port) { message in
+            DispatchQueue.main.async {
+                checking = false
+                if let message {
+                    term.note("Diagnose: \(message)")
+                } else {
+                    term.note("Diagnose: Port offen — ssh selbst lehnt ab (User/Key/Passwort/Hostkey prüfen).")
+                }
            }
        }
    }
@@ -74,15 +129,39 @@ struct EmbeddedTerminalView: View {
        input = ""
    }

+    var failed: Bool {
+        if case .done(let code, _) = term.state {
+            return (code ?? 1) != 0
+        }
+        return false
+    }
+
+    var exitSuffix: String {
+        if case .done(let code, _) = term.state, let code {
+            return " (Exit \(code))"
+        }
+        return ""
+    }
+
+    var lastMessage: String {
+        for row in term.lines.reversed() {
+            let t = row.map(\.text).joined().trimmingCharacters(in: .whitespacesAndNewlines)
+            if !t.isEmpty && !t.hasPrefix("—") { return t }
+        }
+        if case .done(_, let msg) = term.state { return msg }
+        return "Unbekannter Fehler."
+    }
+
    var statusDot: some View {
        Group {
-            if term.isRunning { Image(systemName: "circle.fill").foregroundStyle(Dracula.green) }
-            else if case .done = term.state { Image(systemName: "circle.fill").foregroundStyle(Dracula.red) }
+            if checking || term.isRunning { Image(systemName: "circle.fill").foregroundStyle(Dracula.green) }
+            else if case .done = term.state { Image(systemName: "circle.fill").foregroundStyle(failed ? Dracula.red : Dracula.comment) }
            else { Image(systemName: "circle.fill").foregroundStyle(Dracula.comment) }
        }.font(.caption2)
    }

    var statusText: String {
+        if checking { return "Prüfe \(profile.host):\(profile.port) …" }
        switch term.state {
        case .never: return canConnect ? "Bereit — verbindet beim Öffnen." : "Host/Benutzer fehlt."
        case .running: return "Verbunden (PTY, TERM=xterm-256color)."
@@ -37,7 +37,7 @@ struct SessionView: View {

            if isSSH {
                // In-App-Terminal (Dracula) — kein externes Fenster mehr nötig
-                EmbeddedTerminalView(term: term, canConnect: canConnect)
+                EmbeddedTerminalView(term: term, profile: profile, canConnect: canConnect)
                    .frame(minHeight: 380)
                    .padding(.horizontal)
            }