@wangyaoshen/remux 0.3.8-dev.29e114b

package/apps/macos/Sources/Remux/GhosttyConfig.swift

@@ -0,0 +1,311 @@
+import AppKit
+
+/// Reads and parses the user's Ghostty configuration file.
+/// Ghostty config format: key = value, # comments, one setting per line.
+/// Ref: ghostty-org/ghostty config file specification.
+@MainActor
+final class GhosttyConfig: Sendable {
+
+    // MARK: - Parsed values
+
+    let fontFamily: String?
+    let fontSize: CGFloat?
+    let theme: String?
+    let background: NSColor?
+    let foreground: NSColor?
+    let cursorColor: NSColor?
+    let selectionBackground: NSColor?
+    let selectionForeground: NSColor?
+    let backgroundOpacity: CGFloat?
+    let palette: [Int: NSColor]  // ANSI palette 0-15
+
+    // MARK: - Cache
+
+    private static var cachedLight: GhosttyConfig?
+    private static var cachedDark: GhosttyConfig?
+
+    // MARK: - Standard config paths
+
+    /// Default user config path.
+    static let userConfigPath: String = {
+        let home = FileManager.default.homeDirectoryForCurrentUser.path
+        return home + "/.config/ghostty/config"
+    }()
+
+    /// Directories to search for themes.
+    static let themeSearchPaths: [String] = {
+        let home = FileManager.default.homeDirectoryForCurrentUser.path
+        return [
+            home + "/.config/ghostty/themes",
+            "/usr/share/ghostty/themes",
+            "/usr/local/share/ghostty/themes",
+        ]
+    }()
+
+    // MARK: - Init (private; use load())
+
+    private init(values: [String: String]) {
+        fontFamily = values["font-family"]
+        fontSize = values["font-size"].flatMap { CGFloat(Double($0) ?? 0) }
+        theme = values["theme"]
+        background = values["background"].flatMap { Self.parseColor($0) }
+        foreground = values["foreground"].flatMap { Self.parseColor($0) }
+        cursorColor = values["cursor-color"].flatMap { Self.parseColor($0) }
+        selectionBackground = values["selection-background"].flatMap { Self.parseColor($0) }
+        selectionForeground = values["selection-foreground"].flatMap { Self.parseColor($0) }
+
+        if let opStr = values["background-opacity"], let op = Double(opStr) {
+            backgroundOpacity = CGFloat(max(0, min(1, op)))
+        } else {
+            backgroundOpacity = nil
+        }
+
+        var pal: [Int: NSColor] = [:]
+        for i in 0...15 {
+            let key = "palette = \(i)"  // ghostty uses "palette = N=RRGGBB" format
+            // Actually ghostty uses "palette = 0=#RRGGBB" in a single key
+            // But the parsed format from our parser will be "palette" with value "N=#RRGGBB"
+            // We handle palette entries specially below
+            _ = key
+        }
+
+        // Parse palette entries from the raw values (handled in parsePalette)
+        pal = [:]  // Will be filled by load() using paletteEntries
+        palette = pal
+    }
+
+    private init(
+        fontFamily: String?,
+        fontSize: CGFloat?,
+        theme: String?,
+        background: NSColor?,
+        foreground: NSColor?,
+        cursorColor: NSColor?,
+        selectionBackground: NSColor?,
+        selectionForeground: NSColor?,
+        backgroundOpacity: CGFloat?,
+        palette: [Int: NSColor]
+    ) {
+        self.fontFamily = fontFamily
+        self.fontSize = fontSize
+        self.theme = theme
+        self.background = background
+        self.foreground = foreground
+        self.cursorColor = cursorColor
+        self.selectionBackground = selectionBackground
+        self.selectionForeground = selectionForeground
+        self.backgroundOpacity = backgroundOpacity
+        self.palette = palette
+    }
+
+    // MARK: - Public API
+
+    /// Load the Ghostty configuration. Caches per color scheme.
+    static func load(forScheme scheme: ColorScheme = .current) -> GhosttyConfig {
+        switch scheme {
+        case .dark:
+            if let cached = cachedDark { return cached }
+        case .light:
+            if let cached = cachedLight { return cached }
+        }
+
+        let config = parseConfigFile(at: userConfigPath, scheme: scheme)
+
+        switch scheme {
+        case .dark:  cachedDark = config
+        case .light: cachedLight = config
+        }
+
+        return config
+    }
+
+    /// Invalidate the cache (e.g., after detecting config file change).
+    static func invalidateCache() {
+        cachedLight = nil
+        cachedDark = nil
+    }
+
+    enum ColorScheme {
+        case light, dark
+
+        static var current: ColorScheme {
+            let appearance = NSApp.effectiveAppearance
+            if appearance.bestMatch(from: [.darkAqua, .aqua]) == .darkAqua {
+                return .dark
+            }
+            return .light
+        }
+    }
+
+    // MARK: - Parsing
+
+    /// Parse a Ghostty config file into a GhosttyConfig instance.
+    private static func parseConfigFile(at path: String, scheme: ColorScheme) -> GhosttyConfig {
+        var values: [String: String] = [:]
+        var paletteEntries: [Int: NSColor] = [:]
+
+        // Parse main config file
+        if let lines = readConfigLines(at: path) {
+            parseLines(lines, into: &values, palette: &paletteEntries)
+        }
+
+        // If a theme is specified, load theme overrides
+        if let themeName = values["theme"] {
+            let themeValues = loadTheme(name: themeName, scheme: scheme)
+            // Theme values are overridden by user config, so merge theme first
+            var merged = themeValues.values
+            for (k, v) in values {
+                merged[k] = v
+            }
+            for (k, v) in themeValues.palette {
+                if paletteEntries[k] == nil {
+                    paletteEntries[k] = v
+                }
+            }
+            values = merged
+        }
+
+        return GhosttyConfig(
+            fontFamily: values["font-family"],
+            fontSize: values["font-size"].flatMap { CGFloat(Double($0) ?? 0) },
+            theme: values["theme"],
+            background: values["background"].flatMap { parseColor($0) },
+            foreground: values["foreground"].flatMap { parseColor($0) },
+            cursorColor: values["cursor-color"].flatMap { parseColor($0) },
+            selectionBackground: values["selection-background"].flatMap { parseColor($0) },
+            selectionForeground: values["selection-foreground"].flatMap { parseColor($0) },
+            backgroundOpacity: values["background-opacity"].flatMap { Double($0) }.map { CGFloat(max(0, min(1, $0))) },
+            palette: paletteEntries
+        )
+    }
+
+    /// Read a config file and return its lines, skipping comments and empty lines.
+    private static func readConfigLines(at path: String) -> [String]? {
+        guard FileManager.default.fileExists(atPath: path),
+              let content = try? String(contentsOfFile: path, encoding: .utf8) else {
+            return nil
+        }
+        return content.components(separatedBy: .newlines)
+    }
+
+    /// Parse config lines into key-value pairs and palette entries.
+    private static func parseLines(
+        _ lines: [String],
+        into values: inout [String: String],
+        palette: inout [Int: NSColor]
+    ) {
+        for rawLine in lines {
+            let line = rawLine.trimmingCharacters(in: .whitespaces)
+
+            // Skip comments and empty lines
+            if line.isEmpty || line.hasPrefix("#") { continue }
+
+            // Split on first "=" sign
+            guard let eqIndex = line.firstIndex(of: "=") else { continue }
+            let key = String(line[line.startIndex..<eqIndex]).trimmingCharacters(in: .whitespaces)
+            let value = String(line[line.index(after: eqIndex)...]).trimmingCharacters(in: .whitespaces)
+
+            if key.isEmpty { continue }
+
+            // Handle palette entries: "palette = 0=#000000" or just key "palette" with value "0=#000000"
+            if key == "palette" {
+                if let parsed = parsePaletteEntry(value) {
+                    palette[parsed.index] = parsed.color
+                }
+                continue
+            }
+
+            values[key] = value
+        }
+    }
+
+    /// Parse a palette value like "0=#000000" into (index, color).
+    private static func parsePaletteEntry(_ value: String) -> (index: Int, color: NSColor)? {
+        // Format: "N=RRGGBB" or "N=#RRGGBB"
+        guard let eqIdx = value.firstIndex(of: "=") else { return nil }
+        let indexStr = String(value[value.startIndex..<eqIdx]).trimmingCharacters(in: .whitespaces)
+        let colorStr = String(value[value.index(after: eqIdx)...]).trimmingCharacters(in: .whitespaces)
+
+        guard let index = Int(indexStr), (0...15).contains(index) else { return nil }
+        guard let color = parseColor(colorStr) else { return nil }
+        return (index, color)
+    }
+
+    /// Theme file result container.
+    private struct ThemeResult {
+        var values: [String: String] = [:]
+        var palette: [Int: NSColor] = [:]
+    }
+
+    /// Load a theme by name from standard search paths.
+    private static func loadTheme(name: String, scheme: ColorScheme) -> ThemeResult {
+        // Ghostty supports "theme = auto" which picks light/dark variant
+        var themeName = name
+        if themeName == "auto" {
+            // No specific theme to load for "auto"
+            return ThemeResult()
+        }
+
+        // Search theme files
+        for searchPath in themeSearchPaths {
+            let themePath = searchPath + "/" + themeName
+            if let lines = readConfigLines(at: themePath) {
+                var result = ThemeResult()
+                parseLines(lines, into: &result.values, palette: &result.palette)
+                return result
+            }
+        }
+
+        // Also check with common extensions
+        for ext in ["", ".conf", ".theme"] {
+            for searchPath in themeSearchPaths {
+                let themePath = searchPath + "/" + themeName + ext
+                if let lines = readConfigLines(at: themePath) {
+                    var result = ThemeResult()
+                    parseLines(lines, into: &result.values, palette: &result.palette)
+                    return result
+                }
+            }
+        }
+
+        return ThemeResult()
+    }
+
+    // MARK: - Color parsing
+
+    /// Parse a hex color string to NSColor.
+    /// Supports: "#RRGGBB", "RRGGBB", "#RGB", "RGB", "#RRGGBBAA"
+    static func parseColor(_ str: String) -> NSColor? {
+        var hex = str.trimmingCharacters(in: .whitespaces)
+        if hex.hasPrefix("#") {
+            hex = String(hex.dropFirst())
+        }
+
+        // Expand shorthand #RGB to #RRGGBB
+        if hex.count == 3 {
+            let chars = Array(hex)
+            hex = String([chars[0], chars[0], chars[1], chars[1], chars[2], chars[2]])
+        }
+
+        let scanner = Scanner(string: hex)
+        var value: UInt64 = 0
+        guard scanner.scanHexInt64(&value) else { return nil }
+
+        if hex.count == 8 {
+            // RRGGBBAA
+            let r = CGFloat((value >> 24) & 0xFF) / 255.0
+            let g = CGFloat((value >> 16) & 0xFF) / 255.0
+            let b = CGFloat((value >> 8) & 0xFF) / 255.0
+            let a = CGFloat(value & 0xFF) / 255.0
+            return NSColor(srgbRed: r, green: g, blue: b, alpha: a)
+        } else if hex.count == 6 {
+            // RRGGBB
+            let r = CGFloat((value >> 16) & 0xFF) / 255.0
+            let g = CGFloat((value >> 8) & 0xFF) / 255.0
+            let b = CGFloat(value & 0xFF) / 255.0
+            return NSColor(srgbRed: r, green: g, blue: b, alpha: 1.0)
+        }
+
+        return nil
+    }
+}

package/apps/macos/Sources/Remux/KeyboardShortcuts/ShortcutAction.swift

@@ -0,0 +1,115 @@
+import Foundation
+
+/// All bindable actions in the app.
+/// Adapted from ghostty-org/ghostty key binding action catalog design.
+enum ShortcutAction: String, CaseIterable, Codable, Sendable {
+    // Terminal
+    case find
+    case clearTerminal
+
+    // Tabs
+    case newTab
+    case closeTab
+    case nextTab
+    case prevTab
+
+    // Splits
+    case splitRight
+    case splitDown
+    case closePane
+    case focusNextPane
+    case focusPrevPane
+
+    // Window
+    case toggleSidebar
+    case toggleInspect
+    case toggleFullscreen
+
+    // Navigation (directional pane focus)
+    case focusLeft
+    case focusRight
+    case focusUp
+    case focusDown
+
+    /// Human-readable display name for settings UI.
+    var displayName: String {
+        switch self {
+        case .find:             return "Find"
+        case .clearTerminal:    return "Clear Terminal"
+        case .newTab:           return "New Tab"
+        case .closeTab:         return "Close Tab"
+        case .nextTab:          return "Next Tab"
+        case .prevTab:          return "Previous Tab"
+        case .splitRight:       return "Split Right"
+        case .splitDown:        return "Split Down"
+        case .closePane:        return "Close Pane"
+        case .focusNextPane:    return "Focus Next Pane"
+        case .focusPrevPane:    return "Focus Previous Pane"
+        case .toggleSidebar:    return "Toggle Sidebar"
+        case .toggleInspect:    return "Toggle Inspect"
+        case .toggleFullscreen: return "Toggle Fullscreen"
+        case .focusLeft:        return "Focus Left"
+        case .focusRight:       return "Focus Right"
+        case .focusUp:          return "Focus Up"
+        case .focusDown:        return "Focus Down"
+        }
+    }
+
+    /// Category for grouping in the settings UI.
+    var category: String {
+        switch self {
+        case .find, .clearTerminal:
+            return "Terminal"
+        case .newTab, .closeTab, .nextTab, .prevTab:
+            return "Tabs"
+        case .splitRight, .splitDown, .closePane, .focusNextPane, .focusPrevPane:
+            return "Splits"
+        case .toggleSidebar, .toggleInspect, .toggleFullscreen:
+            return "Window"
+        case .focusLeft, .focusRight, .focusUp, .focusDown:
+            return "Navigation"
+        }
+    }
+
+    /// Default keyboard shortcut for this action.
+    var defaultShortcut: StoredShortcut {
+        switch self {
+        case .find:
+            return StoredShortcut(key: "f", command: true)
+        case .clearTerminal:
+            return StoredShortcut(key: "k", command: true)
+        case .newTab:
+            return StoredShortcut(key: "t", command: true)
+        case .closeTab:
+            return StoredShortcut(key: "w", command: true)
+        case .nextTab:
+            return StoredShortcut(key: "}", command: true, shift: true)
+        case .prevTab:
+            return StoredShortcut(key: "{", command: true, shift: true)
+        case .splitRight:
+            return StoredShortcut(key: "d", command: true)
+        case .splitDown:
+            return StoredShortcut(key: "d", command: true, shift: true)
+        case .closePane:
+            return StoredShortcut(key: "w", command: true, shift: true)
+        case .focusNextPane:
+            return StoredShortcut(key: "]", command: true, option: true)
+        case .focusPrevPane:
+            return StoredShortcut(key: "[", command: true, option: true)
+        case .toggleSidebar:
+            return StoredShortcut(key: "s", command: true, control: true)
+        case .toggleInspect:
+            return StoredShortcut(key: "i", command: true)
+        case .toggleFullscreen:
+            return StoredShortcut(key: "f", command: true, control: true)
+        case .focusLeft:
+            return StoredShortcut(key: "left", command: true, option: true)
+        case .focusRight:
+            return StoredShortcut(key: "right", command: true, option: true)
+        case .focusUp:
+            return StoredShortcut(key: "up", command: true, option: true)
+        case .focusDown:
+            return StoredShortcut(key: "down", command: true, option: true)
+        }
+    }
+}

package/apps/macos/Sources/Remux/KeyboardShortcuts/ShortcutSettingsView.swift

@@ -0,0 +1,271 @@
+import SwiftUI
+
+/// Settings view for customizing keyboard shortcuts.
+/// Adapted from ghostty-org/ghostty macOS keybinding preferences pattern.
+struct ShortcutSettingsView: View {
+    @State private var shortcuts: [ShortcutAction: StoredShortcut] = loadAllShortcuts()
+    @State private var recordingAction: ShortcutAction?
+    @State private var conflicts: [ShortcutAction: [ShortcutAction]] = [:]
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 0) {
+            // Header
+            HStack {
+                Text("Keyboard Shortcuts")
+                    .font(.headline)
+                Spacer()
+                Button("Reset All") {
+                    resetAll()
+                }
+                .controlSize(.small)
+            }
+            .padding(.horizontal, 16)
+            .padding(.vertical, 12)
+
+            Divider()
+
+            // Shortcut list grouped by category
+            ScrollView {
+                LazyVStack(alignment: .leading, spacing: 0) {
+                    let categories = orderedCategories()
+                    ForEach(categories, id: \.self) { category in
+                        let actions = ShortcutAction.allCases.filter { $0.category == category }
+                        Section {
+                            ForEach(actions, id: \.self) { action in
+                                ShortcutRow(
+                                    action: action,
+                                    shortcut: shortcuts[action] ?? action.defaultShortcut,
+                                    isRecording: recordingAction == action,
+                                    hasConflict: !(conflicts[action]?.isEmpty ?? true),
+                                    onStartRecording: {
+                                        recordingAction = action
+                                    },
+                                    onRecorded: { newShortcut in
+                                        applyShortcut(newShortcut, for: action)
+                                    },
+                                    onReset: {
+                                        resetShortcut(for: action)
+                                    },
+                                    onCancelRecording: {
+                                        recordingAction = nil
+                                    }
+                                )
+                            }
+                        } header: {
+                            Text(category)
+                                .font(.subheadline.weight(.semibold))
+                                .foregroundStyle(.secondary)
+                                .padding(.horizontal, 16)
+                                .padding(.top, 12)
+                                .padding(.bottom, 4)
+                        }
+                    }
+                }
+                .padding(.bottom, 12)
+            }
+        }
+        .frame(minWidth: 500, minHeight: 400)
+        .onAppear { refreshConflicts() }
+    }
+
+    // MARK: - Actions
+
+    private func applyShortcut(_ shortcut: StoredShortcut, for action: ShortcutAction) {
+        StoredShortcut.setShortcut(shortcut, for: action)
+        shortcuts[action] = shortcut
+        recordingAction = nil
+        refreshConflicts()
+    }
+
+    private func resetShortcut(for action: ShortcutAction) {
+        StoredShortcut.resetShortcut(for: action)
+        shortcuts[action] = action.defaultShortcut
+        recordingAction = nil
+        refreshConflicts()
+    }
+
+    private func resetAll() {
+        StoredShortcut.resetAll()
+        shortcuts = Self.loadAllShortcuts()
+        recordingAction = nil
+        refreshConflicts()
+    }
+
+    private func refreshConflicts() {
+        var newConflicts: [ShortcutAction: [ShortcutAction]] = [:]
+        for action in ShortcutAction.allCases {
+            let found = StoredShortcut.conflicts(for: action)
+            if !found.isEmpty {
+                newConflicts[action] = found
+            }
+        }
+        conflicts = newConflicts
+    }
+
+    private func orderedCategories() -> [String] {
+        // Maintain a stable order
+        ["Terminal", "Tabs", "Splits", "Window", "Navigation"]
+    }
+
+    private static func loadAllShortcuts() -> [ShortcutAction: StoredShortcut] {
+        var map: [ShortcutAction: StoredShortcut] = [:]
+        for action in ShortcutAction.allCases {
+            map[action] = StoredShortcut.shortcut(for: action)
+        }
+        return map
+    }
+}
+
+// MARK: - Shortcut Row
+
+/// A single row in the shortcut list: action name + shortcut badge + record/reset controls.
+struct ShortcutRow: View {
+    let action: ShortcutAction
+    let shortcut: StoredShortcut
+    let isRecording: Bool
+    let hasConflict: Bool
+    var onStartRecording: () -> Void
+    var onRecorded: (StoredShortcut) -> Void
+    var onReset: () -> Void
+    var onCancelRecording: () -> Void
+
+    @State private var isHovering = false
+
+    var body: some View {
+        HStack {
+            Text(action.displayName)
+                .frame(minWidth: 160, alignment: .leading)
+
+            Spacer()
+
+            if isRecording {
+                ShortcutRecorderField(
+                    onRecorded: onRecorded,
+                    onCancel: onCancelRecording
+                )
+                .frame(width: 140)
+            } else {
+                // Shortcut display badge
+                Text(shortcut.displayString)
+                    .font(.system(size: 12, design: .monospaced))
+                    .padding(.horizontal, 8)
+                    .padding(.vertical, 3)
+                    .background(
+                        RoundedRectangle(cornerRadius: 4)
+                            .fill(hasConflict ? Color.red.opacity(0.15) : Color.primary.opacity(0.06))
+                    )
+                    .overlay(
+                        RoundedRectangle(cornerRadius: 4)
+                            .stroke(hasConflict ? Color.red.opacity(0.4) : Color.clear, lineWidth: 1)
+                    )
+                    .onTapGesture { onStartRecording() }
+            }
+
+            // Reset button (shown on hover or if customized)
+            if isHovering && shortcut != action.defaultShortcut {
+                Button(action: onReset) {
+                    Image(systemName: "arrow.counterclockwise")
+                        .font(.system(size: 10))
+                        .foregroundStyle(.secondary)
+                }
+                .buttonStyle(.plain)
+                .help("Reset to Default")
+            }
+
+            if hasConflict {
+                Image(systemName: "exclamationmark.triangle.fill")
+                    .font(.system(size: 10))
+                    .foregroundStyle(.yellow)
+                    .help("Shortcut conflict detected")
+            }
+        }
+        .padding(.horizontal, 16)
+        .padding(.vertical, 5)
+        .background(isHovering ? Color.primary.opacity(0.03) : Color.clear)
+        .onHover { isHovering = $0 }
+    }
+}
+
+// MARK: - Shortcut Recorder
+
+/// An inline field that captures the next key event as a new shortcut.
+struct ShortcutRecorderField: NSViewRepresentable {
+    var onRecorded: (StoredShortcut) -> Void
+    var onCancel: () -> Void
+
+    func makeNSView(context: Context) -> ShortcutRecorderNSView {
+        let view = ShortcutRecorderNSView()
+        view.onRecorded = onRecorded
+        view.onCancel = onCancel
+        // Become first responder after a brief delay to ensure the view is in the hierarchy
+        DispatchQueue.main.async {
+            view.window?.makeFirstResponder(view)
+        }
+        return view
+    }
+
+    func updateNSView(_ nsView: ShortcutRecorderNSView, context: Context) {
+        nsView.onRecorded = onRecorded
+        nsView.onCancel = onCancel
+    }
+}
+
+/// NSView that captures a single key event for shortcut recording.
+@MainActor
+final class ShortcutRecorderNSView: NSView {
+    var onRecorded: ((StoredShortcut) -> Void)?
+    var onCancel: (() -> Void)?
+
+    override var acceptsFirstResponder: Bool { true }
+
+    override init(frame frameRect: NSRect) {
+        super.init(frame: frameRect)
+        wantsLayer = true
+        layer?.cornerRadius = 4
+        layer?.borderWidth = 2
+        layer?.borderColor = NSColor.controlAccentColor.cgColor
+    }
+
+    required init?(coder: NSCoder) { fatalError() }
+
+    override func draw(_ dirtyRect: NSRect) {
+        super.draw(dirtyRect)
+        let str = NSAttributedString(
+            string: "Press shortcut...",
+            attributes: [
+                .foregroundColor: NSColor.secondaryLabelColor,
+                .font: NSFont.systemFont(ofSize: 11),
+            ]
+        )
+        let size = str.size()
+        let point = NSPoint(
+            x: (bounds.width - size.width) / 2,
+            y: (bounds.height - size.height) / 2
+        )
+        str.draw(at: point)
+    }
+
+    override func keyDown(with event: NSEvent) {
+        // Escape cancels recording
+        if event.keyCode == 53 {
+            onCancel?()
+            return
+        }
+
+        if let shortcut = StoredShortcut.from(event: event) {
+            onRecorded?(shortcut)
+        }
+        // If no valid shortcut (e.g. bare key press), ignore and keep recording
+    }
+
+    override func becomeFirstResponder() -> Bool {
+        layer?.borderColor = NSColor.controlAccentColor.cgColor
+        return true
+    }
+
+    override func resignFirstResponder() -> Bool {
+        layer?.borderColor = NSColor.separatorColor.cgColor
+        onCancel?()
+        return true
+    }
+}