@wangyaoshen/remux 0.3.8-dev.a8ceb0c

package/apps/macos/Sources/Remux/Views/TabBarView.swift

@@ -0,0 +1,94 @@
+import SwiftUI
+import RemuxKit
+
+/// Horizontal tab bar showing tabs in the current session.
+/// Supports click to switch, + button to create, close button on hover.
+struct TabBarView: View {
+    @Environment(RemuxState.self) private var state
+
+    var body: some View {
+        ScrollView(.horizontal, showsIndicators: false) {
+            HStack(spacing: 0) {
+                ForEach(state.tabs, id: \.index) { tab in
+                    TabItemView(
+                        tab: tab,
+                        isActive: tab.index == state.activeTabIndex,
+                        onSelect: {
+                            if let pane = tab.panes.first {
+                                state.switchTab(id: pane.id)
+                            }
+                        },
+                        onClose: {
+                            if let pane = tab.panes.first {
+                                state.closeTab(id: pane.id)
+                            }
+                        }
+                    )
+                }
+
+                // New tab button
+                Button(action: { state.createTab() }) {
+                    Image(systemName: "plus")
+                        .font(.system(size: 11))
+                        .foregroundStyle(.secondary)
+                        .frame(width: 28, height: 28)
+                }
+                .buttonStyle(.plain)
+                .help("New Tab")
+
+                Spacer()
+            }
+        }
+        .frame(height: 32)
+        .background(.bar)
+    }
+}
+
+struct TabItemView: View {
+    let tab: WorkspaceTab
+    let isActive: Bool
+    let onSelect: () -> Void
+    let onClose: () -> Void
+
+    @State private var isHovering = false
+
+    var body: some View {
+        HStack(spacing: 4) {
+            if tab.hasBell {
+                Circle()
+                    .fill(.red)
+                    .frame(width: 6, height: 6)
+            }
+
+            Text(tab.name)
+                .font(.system(size: 12))
+                .lineLimit(1)
+
+            if isHovering {
+                Button(action: onClose) {
+                    Image(systemName: "xmark")
+                        .font(.system(size: 8, weight: .bold))
+                        .foregroundStyle(.secondary)
+                }
+                .buttonStyle(.plain)
+                .frame(width: 14, height: 14)
+            }
+        }
+        .padding(.horizontal, 12)
+        .padding(.vertical, 6)
+        .background(isActive ? Color.accentColor.opacity(0.15) : Color.clear)
+        .cornerRadius(6)
+        .overlay(
+            RoundedRectangle(cornerRadius: 6)
+                .stroke(isActive ? Color.accentColor.opacity(0.3) : Color.clear, lineWidth: 1)
+        )
+        .onHover { isHovering = $0 }
+        .onTapGesture { onSelect() }
+        .contextMenu {
+            Button("Close Tab") { onClose() }
+            Button("Rename Tab...") {
+                // TODO: rename dialog
+            }
+        }
+    }
+}

package/apps/macos/Sources/Remux/Views/Terminal/ClipboardHelper.swift

@@ -0,0 +1,101 @@
+import AppKit
+import UniformTypeIdentifiers
+
+/// Helper for enhanced clipboard operations in the terminal.
+/// Adapted from ghostty-org/ghostty macOS clipboard handling patterns.
+enum ClipboardHelper {
+
+    /// Read paste content from the pasteboard with priority:
+    /// file URLs -> plain text -> RTF -> HTML
+    static func pasteContent(from pasteboard: NSPasteboard) -> String? {
+        // Priority 1: File URLs — paste as escaped shell paths
+        if let urls = pasteboard.readObjects(forClasses: [NSURL.self], options: nil) as? [URL],
+           !urls.isEmpty {
+            let paths = urls.compactMap { url -> String? in
+                guard url.isFileURL else { return url.absoluteString }
+                return escapeForShell(url.path)
+            }
+            if !paths.isEmpty {
+                return paths.joined(separator: " ")
+            }
+        }
+
+        // Priority 2: Plain text
+        if let text = pasteboard.string(forType: .string), !text.isEmpty {
+            return text
+        }
+
+        // Priority 3: RTF — extract plain text from attributed string
+        if let rtfData = pasteboard.data(forType: .rtf) {
+            if let attrStr = NSAttributedString(rtf: rtfData, documentAttributes: nil) {
+                let text = attrStr.string
+                if !text.isEmpty { return text }
+            }
+        }
+
+        // Priority 4: HTML — extract plain text from HTML
+        if let htmlData = pasteboard.data(forType: .html) {
+            if let attrStr = try? NSAttributedString(
+                data: htmlData,
+                options: [.documentType: NSAttributedString.DocumentType.html],
+                documentAttributes: nil
+            ) {
+                let text = attrStr.string
+                if !text.isEmpty { return text }
+            }
+        }
+
+        return nil
+    }
+
+    /// Escape a file path for safe use in shell commands.
+    /// Handles spaces, parentheses, quotes, and other special characters.
+    static func escapeForShell(_ path: String) -> String {
+        let specialChars: Set<Character> = [
+            " ", "(", ")", "'", "\"", "\\", "!", "#", "$", "&",
+            ";", "|", "<", ">", "?", "*", "[", "]", "{", "}",
+            "~", "`", "^",
+        ]
+
+        var result = ""
+        for char in path {
+            if specialChars.contains(char) {
+                result.append("\\")
+            }
+            result.append(char)
+        }
+        return result
+    }
+
+    /// Save a pasted image from the pasteboard to a temp file.
+    /// Returns the file URL if successful.
+    static func saveImageToTemp(from pasteboard: NSPasteboard) -> URL? {
+        // Check for image data types
+        let imageTypes: [NSPasteboard.PasteboardType] = [.tiff, .png]
+
+        for imageType in imageTypes {
+            guard let imageData = pasteboard.data(forType: imageType) else { continue }
+
+            guard let image = NSImage(data: imageData),
+                  let tiffData = image.tiffRepresentation,
+                  let bitmap = NSBitmapImageRep(data: tiffData),
+                  let pngData = bitmap.representation(using: .png, properties: [:]) else {
+                continue
+            }
+
+            let tempDir = FileManager.default.temporaryDirectory
+            let filename = "remux-paste-\(UUID().uuidString.prefix(8)).png"
+            let fileURL = tempDir.appendingPathComponent(filename)
+
+            do {
+                try pngData.write(to: fileURL)
+                return fileURL
+            } catch {
+                NSLog("[remux] Failed to save pasted image: \(error)")
+                continue
+            }
+        }
+
+        return nil
+    }
+}

package/apps/macos/Sources/Remux/Views/Terminal/CopyModeOverlay.swift

@@ -0,0 +1,325 @@
+import SwiftUI
+import AppKit
+
+/// Vi-like copy mode overlay for terminal text selection.
+/// Toggle with Cmd+Shift+C. Shows "COPY MODE" indicator.
+/// Arrow keys move cursor, v enters visual select, y copies, Escape exits.
+///
+/// Works by reading current terminal text from inspect API and
+/// rendering a selection overlay.
+///
+/// Adapted from tmux copy-mode and Zellij scroll/search mode UX patterns.
+struct CopyModeOverlay: View {
+    @Binding var isActive: Bool
+    @State private var cursorRow: Int = 0
+    @State private var cursorCol: Int = 0
+    @State private var selectionStart: CopyModePosition?
+    @State private var isVisualMode: Bool = false
+    @State private var terminalLines: [String] = []
+    @State private var statusMessage: String = ""
+
+    /// Callback to request terminal text content.
+    var onRequestContent: (() -> [String])?
+    /// Callback when text is copied.
+    var onCopy: ((String) -> Void)?
+
+    struct CopyModePosition: Equatable {
+        var row: Int
+        var col: Int
+    }
+
+    var body: some View {
+        if isActive {
+            ZStack {
+                // Semi-transparent overlay
+                Color.black.opacity(0.05)
+                    .allowsHitTesting(true)
+
+                VStack {
+                    // Mode indicator
+                    HStack {
+                        Spacer()
+
+                        HStack(spacing: 6) {
+                            Image(systemName: "doc.on.doc")
+                                .font(.system(size: 10))
+                            Text(isVisualMode ? "VISUAL" : "COPY MODE")
+                                .font(.system(size: 11, weight: .semibold, design: .monospaced))
+                        }
+                        .padding(.horizontal, 10)
+                        .padding(.vertical, 4)
+                        .background(.ultraThinMaterial, in: RoundedRectangle(cornerRadius: 6))
+                        .overlay(
+                            RoundedRectangle(cornerRadius: 6)
+                                .stroke(Color.yellow.opacity(0.5), lineWidth: 1)
+                        )
+                        .padding(.trailing, 12)
+                        .padding(.top, 8)
+                    }
+
+                    Spacer()
+
+                    // Status bar
+                    HStack {
+                        if !statusMessage.isEmpty {
+                            Text(statusMessage)
+                                .font(.system(size: 11, design: .monospaced))
+                                .foregroundStyle(.secondary)
+                        }
+
+                        Spacer()
+
+                        Text("Ln \(cursorRow + 1), Col \(cursorCol + 1)")
+                            .font(.system(size: 11, design: .monospaced))
+                            .foregroundStyle(.secondary)
+
+                        Text("| h/j/k/l: move | v: visual | y: yank | Esc: exit")
+                            .font(.system(size: 10, design: .monospaced))
+                            .foregroundStyle(.tertiary)
+                    }
+                    .padding(.horizontal, 10)
+                    .padding(.vertical, 4)
+                    .background(.ultraThinMaterial)
+                }
+            }
+            .onAppear {
+                loadContent()
+            }
+            .onKeyPress { keyPress in
+                handleKeyPress(keyPress)
+            }
+        }
+    }
+
+    private func loadContent() {
+        if let lines = onRequestContent?() {
+            terminalLines = lines
+            if !lines.isEmpty {
+                cursorRow = max(0, lines.count - 1)
+                cursorCol = 0
+            }
+        }
+        statusMessage = ""
+    }
+
+    private func handleKeyPress(_ keyPress: KeyPress) -> KeyPress.Result {
+        switch keyPress.characters {
+        // Movement: vi keys
+        case "h":
+            moveCursor(dRow: 0, dCol: -1)
+            return .handled
+        case "j":
+            moveCursor(dRow: 1, dCol: 0)
+            return .handled
+        case "k":
+            moveCursor(dRow: -1, dCol: 0)
+            return .handled
+        case "l":
+            moveCursor(dRow: 0, dCol: 1)
+            return .handled
+
+        // Movement: word
+        case "w":
+            moveWordForward()
+            return .handled
+        case "b":
+            moveWordBackward()
+            return .handled
+
+        // Line start/end
+        case "0":
+            cursorCol = 0
+            return .handled
+        case "$":
+            if cursorRow < terminalLines.count {
+                cursorCol = max(0, terminalLines[cursorRow].count - 1)
+            }
+            return .handled
+
+        // Top/bottom
+        case "g":
+            cursorRow = 0
+            cursorCol = 0
+            return .handled
+        case "G":
+            cursorRow = max(0, terminalLines.count - 1)
+            cursorCol = 0
+            return .handled
+
+        // Visual mode toggle
+        case "v":
+            toggleVisualMode()
+            return .handled
+
+        // Yank (copy)
+        case "y":
+            yankSelection()
+            return .handled
+
+        default:
+            break
+        }
+
+        // Arrow keys
+        switch keyPress.key {
+        case .upArrow:
+            moveCursor(dRow: -1, dCol: 0)
+            return .handled
+        case .downArrow:
+            moveCursor(dRow: 1, dCol: 0)
+            return .handled
+        case .leftArrow:
+            moveCursor(dRow: 0, dCol: -1)
+            return .handled
+        case .rightArrow:
+            moveCursor(dRow: 0, dCol: 1)
+            return .handled
+        case .escape:
+            if isVisualMode {
+                isVisualMode = false
+                selectionStart = nil
+                statusMessage = ""
+            } else {
+                isActive = false
+            }
+            return .handled
+        default:
+            break
+        }
+
+        return .ignored
+    }
+
+    private func moveCursor(dRow: Int, dCol: Int) {
+        let newRow = max(0, min(terminalLines.count - 1, cursorRow + dRow))
+        let maxCol = max(0, (newRow < terminalLines.count ? terminalLines[newRow].count : 80) - 1)
+        let newCol = max(0, min(maxCol, cursorCol + dCol))
+        cursorRow = newRow
+        cursorCol = newCol
+    }
+
+    private func moveWordForward() {
+        guard cursorRow < terminalLines.count else { return }
+        let line = terminalLines[cursorRow]
+        let chars = Array(line)
+        var col = cursorCol
+
+        // Skip current word characters
+        while col < chars.count && !chars[col].isWhitespace { col += 1 }
+        // Skip whitespace
+        while col < chars.count && chars[col].isWhitespace { col += 1 }
+
+        if col >= chars.count && cursorRow < terminalLines.count - 1 {
+            cursorRow += 1
+            cursorCol = 0
+        } else {
+            cursorCol = min(col, max(0, chars.count - 1))
+        }
+    }
+
+    private func moveWordBackward() {
+        guard cursorRow < terminalLines.count else { return }
+        let line = terminalLines[cursorRow]
+        let chars = Array(line)
+        var col = cursorCol
+
+        if col <= 0 && cursorRow > 0 {
+            cursorRow -= 1
+            cursorCol = max(0, terminalLines[cursorRow].count - 1)
+            return
+        }
+
+        // Skip whitespace backwards
+        while col > 0 && chars[max(0, col - 1)].isWhitespace { col -= 1 }
+        // Skip word characters backwards
+        while col > 0 && !chars[max(0, col - 1)].isWhitespace { col -= 1 }
+
+        cursorCol = max(0, col)
+    }
+
+    private func toggleVisualMode() {
+        if isVisualMode {
+            isVisualMode = false
+            selectionStart = nil
+            statusMessage = ""
+        } else {
+            isVisualMode = true
+            selectionStart = CopyModePosition(row: cursorRow, col: cursorCol)
+            statusMessage = "VISUAL: move to select, y to yank"
+        }
+    }
+
+    private func yankSelection() {
+        let text: String
+        if isVisualMode, let start = selectionStart {
+            text = extractSelection(from: start, to: CopyModePosition(row: cursorRow, col: cursorCol))
+        } else {
+            // Yank current line
+            if cursorRow < terminalLines.count {
+                text = terminalLines[cursorRow]
+            } else {
+                text = ""
+            }
+        }
+
+        guard !text.isEmpty else {
+            statusMessage = "Nothing to yank"
+            return
+        }
+
+        // Copy to clipboard
+        NSPasteboard.general.clearContents()
+        NSPasteboard.general.setString(text, forType: .string)
+
+        statusMessage = "Yanked \(text.count) chars"
+        onCopy?(text)
+
+        // Exit copy mode after yank
+        isVisualMode = false
+        selectionStart = nil
+
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.8) {
+            self.isActive = false
+        }
+    }
+
+    private func extractSelection(from start: CopyModePosition, to end: CopyModePosition) -> String {
+        let (s, e) = start.row < end.row || (start.row == end.row && start.col <= end.col)
+            ? (start, end) : (end, start)
+
+        guard s.row < terminalLines.count else { return "" }
+
+        if s.row == e.row {
+            let line = terminalLines[s.row]
+            let chars = Array(line)
+            let startIdx = min(s.col, chars.count)
+            let endIdx = min(e.col + 1, chars.count)
+            return String(chars[startIdx..<endIdx])
+        }
+
+        var result: [String] = []
+
+        // First line (from start col)
+        let firstLine = terminalLines[s.row]
+        let firstChars = Array(firstLine)
+        let startIdx = min(s.col, firstChars.count)
+        result.append(String(firstChars[startIdx...]))
+
+        // Middle lines (full)
+        for row in (s.row + 1)..<e.row {
+            if row < terminalLines.count {
+                result.append(terminalLines[row])
+            }
+        }
+
+        // Last line (up to end col)
+        if e.row < terminalLines.count {
+            let lastLine = terminalLines[e.row]
+            let lastChars = Array(lastLine)
+            let endIdx = min(e.col + 1, lastChars.count)
+            result.append(String(lastChars[..<endIdx]))
+        }
+
+        return result.joined(separator: "\n")
+    }
+}

package/apps/macos/Sources/Remux/Views/Terminal/GhosttyNativeTerminalView.swift

@@ -0,0 +1,39 @@
+import SwiftUI
+import RemuxKit
+
+/// SwiftUI wrapper for GhosttyNativeView (libghostty Metal renderer).
+/// The relay socket path is used to create the ghostty surface with `nc -U` as its command.
+struct GhosttyNativeTerminalView: NSViewRepresentable {
+    let socketPath: String
+    @Binding var viewRef: GhosttyNativeView?
+    var onResize: ((Int, Int) -> Void)?
+    var onBell: (() -> Void)?
+    var onTitle: ((String) -> Void)?
+    var onSearchStart: ((String?) -> Void)?
+    var onSearchEnd: (() -> Void)?
+    var onSearchTotal: ((Int) -> Void)?
+    var onSearchSelected: ((Int) -> Void)?
+
+    func makeNSView(context: Context) -> GhosttyNativeView {
+        let view = GhosttyNativeView(frame: .zero, socketPath: socketPath)
+        view.onResize = onResize
+        view.onBell = onBell
+        view.onTitle = onTitle
+        view.onSearchStart = onSearchStart
+        view.onSearchEnd = onSearchEnd
+        view.onSearchTotal = onSearchTotal
+        view.onSearchSelected = onSearchSelected
+        DispatchQueue.main.async { viewRef = view }
+        return view
+    }
+
+    func updateNSView(_ nsView: GhosttyNativeView, context: Context) {
+        nsView.onResize = onResize
+        nsView.onBell = onBell
+        nsView.onTitle = onTitle
+        nsView.onSearchStart = onSearchStart
+        nsView.onSearchEnd = onSearchEnd
+        nsView.onSearchTotal = onSearchTotal
+        nsView.onSearchSelected = onSearchSelected
+    }
+}