@wangyaoshen/remux 0.3.8-dev.a8ceb0c

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

@@ -0,0 +1,149 @@
+import AppKit
+
+/// Persisted representation of a keyboard shortcut.
+/// Adapted from ghostty-org/ghostty KeyEquivalent binding storage.
+struct StoredShortcut: Codable, Equatable, Hashable, Sendable {
+    var key: String           // e.g. "d", "left", "\r"
+    var command: Bool
+    var shift: Bool
+    var option: Bool
+    var control: Bool
+
+    init(
+        key: String,
+        command: Bool = false,
+        shift: Bool = false,
+        option: Bool = false,
+        control: Bool = false
+    ) {
+        self.key = key
+        self.command = command
+        self.shift = shift
+        self.option = option
+        self.control = control
+    }
+
+    /// Human-readable display string like "⌘D" or "⌃⌘F".
+    var displayString: String {
+        var parts: [String] = []
+        if control { parts.append("⌃") }
+        if option  { parts.append("⌥") }
+        if shift   { parts.append("⇧") }
+        if command { parts.append("⌘") }
+        parts.append(keyDisplayName)
+        return parts.joined()
+    }
+
+    /// Display name for the key character.
+    private var keyDisplayName: String {
+        switch key.lowercased() {
+        case "left":   return "←"
+        case "right":  return "→"
+        case "up":     return "↑"
+        case "down":   return "↓"
+        case "\r", "return", "enter": return "↩"
+        case "\t", "tab":   return "⇥"
+        case " ", "space":  return "Space"
+        case "\u{1b}", "escape": return "⎋"
+        case "\u{7f}", "delete": return "⌫"
+        case "[":  return "["
+        case "]":  return "]"
+        case "{":  return "{"
+        case "}":  return "}"
+        default:
+            return key.uppercased()
+        }
+    }
+
+    // MARK: - NSEvent conversion
+
+    /// Create a StoredShortcut from an NSEvent (for recording shortcuts).
+    @MainActor
+    static func from(event: NSEvent) -> StoredShortcut? {
+        guard event.type == .keyDown else { return nil }
+
+        let mods = event.modifierFlags.intersection(.deviceIndependentFlagsMask)
+
+        // Require at least one modifier key (prevent bare letters from being shortcuts)
+        let hasModifier = mods.contains(.command) || mods.contains(.control) ||
+                          mods.contains(.option)
+        guard hasModifier else { return nil }
+
+        let keyStr: String
+        switch Int(event.keyCode) {
+        case 123: keyStr = "left"
+        case 124: keyStr = "right"
+        case 125: keyStr = "down"
+        case 126: keyStr = "up"
+        case 36:  keyStr = "return"
+        case 48:  keyStr = "tab"
+        case 53:  keyStr = "escape"
+        case 51:  keyStr = "delete"
+        case 49:  keyStr = "space"
+        default:
+            if let chars = event.charactersIgnoringModifiers, !chars.isEmpty {
+                keyStr = chars.lowercased()
+            } else {
+                return nil
+            }
+        }
+
+        return StoredShortcut(
+            key: keyStr,
+            command: mods.contains(.command),
+            shift: mods.contains(.shift),
+            option: mods.contains(.option),
+            control: mods.contains(.control)
+        )
+    }
+
+    /// Check if an NSEvent matches this shortcut.
+    @MainActor
+    func matches(event: NSEvent) -> Bool {
+        guard let recorded = StoredShortcut.from(event: event) else { return false }
+        return self == recorded
+    }
+
+    // MARK: - Persistence via UserDefaults
+
+    private static let defaultsKeyPrefix = "shortcut_"
+
+    /// Get the current shortcut for an action (user-customized or default).
+    static func shortcut(for action: ShortcutAction) -> StoredShortcut {
+        let key = defaultsKeyPrefix + action.rawValue
+        if let data = UserDefaults.standard.data(forKey: key),
+           let stored = try? JSONDecoder().decode(StoredShortcut.self, from: data) {
+            return stored
+        }
+        return action.defaultShortcut
+    }
+
+    /// Save a custom shortcut for an action.
+    static func setShortcut(_ shortcut: StoredShortcut, for action: ShortcutAction) {
+        let key = defaultsKeyPrefix + action.rawValue
+        if let data = try? JSONEncoder().encode(shortcut) {
+            UserDefaults.standard.set(data, forKey: key)
+        }
+    }
+
+    /// Reset a shortcut to its default.
+    static func resetShortcut(for action: ShortcutAction) {
+        let key = defaultsKeyPrefix + action.rawValue
+        UserDefaults.standard.removeObject(forKey: key)
+    }
+
+    /// Reset all shortcuts to defaults.
+    static func resetAll() {
+        for action in ShortcutAction.allCases {
+            resetShortcut(for: action)
+        }
+    }
+
+    /// Detect conflicts: returns any other actions that share the same shortcut.
+    static func conflicts(for action: ShortcutAction) -> [ShortcutAction] {
+        let current = shortcut(for: action)
+        return ShortcutAction.allCases.filter { other in
+            other != action && shortcut(for: other) == current
+        }
+    }
+}

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

@@ -0,0 +1,308 @@
+import SwiftUI
+import RemuxKit
+
+/// Main content view: sidebar + tab bar + split terminal/inspect area.
+/// Includes command palette overlay and copy mode support.
+struct MainContentView: View {
+    @Environment(RemuxState.self) private var state
+    @State private var showInspect = false
+
+    // Split pane state
+    @State private var splitRoot: SplitNode = .leaf(SplitNode.LeafData(tabIndex: 0))
+    @State private var focusedLeafID: UUID?
+
+    // Command palette
+    @State private var showCommandPalette = false
+
+    // Copy mode
+    @State private var showCopyMode = false
+
+    // Port scanner
+    @State private var portScanner = PortScanner()
+
+    // SSH detector
+    @State private var sshDetector = SSHDetector()
+
+    var body: some View {
+        ZStack {
+            NavigationSplitView {
+                SidebarView(portScanner: portScanner)
+            } detail: {
+                if case .connected = state.connectionStatus {
+                    VStack(spacing: 0) {
+                        TabBarView()
+
+                        ZStack {
+                            if showInspect {
+                                HSplitView {
+                                    splitContent
+                                        .frame(minWidth: 300)
+                                    InspectView()
+                                        .frame(minWidth: 250, idealWidth: 350)
+                                }
+                            } else {
+                                splitContent
+                            }
+
+                            // Copy mode overlay
+                            CopyModeOverlay(
+                                isActive: $showCopyMode,
+                                onRequestContent: {
+                                    // Return terminal lines from inspect snapshot
+                                    if let snapshot = state.inspectSnapshot {
+                                        return snapshot.items.map { $0.content }
+                                    }
+                                    return []
+                                },
+                                onCopy: { _ in
+                                    // Text already copied to clipboard in the overlay
+                                }
+                            )
+                        }
+                    }
+                    .toolbar {
+                        ToolbarItemGroup(placement: .automatic) {
+                            // SSH upload button
+                            if sshDetector.hasActiveConnection {
+                                Button(action: { handleSSHUpload() }) {
+                                    Image(systemName: "square.and.arrow.up")
+                                }
+                                .help("Upload File via SCP")
+                            }
+
+                            Button(action: { showInspect.toggle() }) {
+                                Image(systemName: showInspect ? "doc.text.fill" : "doc.text")
+                            }
+                            .help("Toggle Inspect (\u{2318}I)")
+                            .keyboardShortcut("i", modifiers: .command)
+                        }
+                    }
+                } else {
+                    ConnectionView()
+                }
+            }
+            .navigationSplitViewColumnWidth(min: 180, ideal: 220, max: 300)
+
+            // Command palette overlay
+            CommandPalette(
+                isPresented: $showCommandPalette,
+                commands: buildCommandList()
+            )
+        }
+        .onAppear {
+            // Set initial focused leaf
+            if focusedLeafID == nil {
+                focusedLeafID = splitRoot.allLeaves.first?.id
+            }
+        }
+    }
+
+    @ViewBuilder
+    private var splitContent: some View {
+        SplitView(
+            node: splitRoot,
+            focusedLeafID: $focusedLeafID,
+            onSplit: { leafID, orientation in
+                splitPane(leafID: leafID, orientation: orientation)
+            },
+            onClose: { leafID in
+                closePane(leafID: leafID)
+            },
+            onRatioChange: { branchID, ratio in
+                splitRoot = splitRoot.updateRatio(branchID: branchID, ratio: ratio)
+            }
+        )
+    }
+
+    // MARK: - Split operations
+
+    /// Split the given (or focused) pane in the specified direction.
+    func splitPane(leafID: UUID? = nil, orientation: SplitNode.Orientation, panelType: PanelType = .terminal) {
+        let targetID = leafID ?? focusedLeafID ?? splitRoot.allLeaves.first?.id
+        guard let targetID else { return }
+
+        let newTabIndex = state.activeTabIndex
+        splitRoot = splitRoot.split(
+            leafID: targetID,
+            orientation: orientation,
+            newTabIndex: newTabIndex,
+            panelType: panelType
+        )
+
+        // Focus the new pane
+        if let newLeaves = splitRoot.allLeaves.last {
+            focusedLeafID = newLeaves.id
+        }
+    }
+
+    /// Close a specific pane.
+    func closePane(leafID: UUID? = nil) {
+        let targetID = leafID ?? focusedLeafID ?? splitRoot.allLeaves.last?.id
+        guard let targetID else { return }
+
+        // Don't close the last pane
+        guard splitRoot.allLeaves.count > 1 else { return }
+
+        // Move focus before removing
+        if focusedLeafID == targetID {
+            focusedLeafID = splitRoot.previousLeaf(before: targetID)?.id
+                ?? splitRoot.allLeaves.first?.id
+        }
+
+        if let newRoot = splitRoot.removeLeaf(id: targetID) {
+            splitRoot = newRoot
+        }
+    }
+
+    /// Focus the next pane.
+    func focusNextPane() {
+        guard let current = focusedLeafID,
+              let next = splitRoot.nextLeaf(after: current) else { return }
+        focusedLeafID = next.id
+    }
+
+    /// Focus the previous pane.
+    func focusPreviousPane() {
+        guard let current = focusedLeafID,
+              let prev = splitRoot.previousLeaf(before: current) else { return }
+        focusedLeafID = prev.id
+    }
+
+    /// Add a browser pane to the split tree.
+    func addBrowserPane() {
+        splitPane(orientation: .horizontal, panelType: .browser)
+    }
+
+    /// Add a markdown pane to the split tree.
+    func addMarkdownPane() {
+        splitPane(orientation: .horizontal, panelType: .markdown)
+    }
+
+    /// Toggle command palette visibility.
+    func toggleCommandPalette() {
+        showCommandPalette.toggle()
+    }
+
+    /// Toggle copy mode.
+    func toggleCopyMode() {
+        // Request inspect content first so copy mode has data
+        if !showCopyMode {
+            state.requestInspect(tabIndex: state.activeTabIndex)
+        }
+        showCopyMode.toggle()
+    }
+
+    /// Get the current split layout as a snapshot for persistence.
+    var splitLayoutSnapshot: SplitNodeSnapshot {
+        splitRoot.toSnapshot()
+    }
+
+    /// Restore split layout from a snapshot.
+    mutating func restoreSplitLayout(_ snapshot: SplitNodeSnapshot) {
+        splitRoot = SplitNode.fromSnapshot(snapshot)
+        focusedLeafID = splitRoot.allLeaves.first?.id
+    }
+
+    // MARK: - Command palette commands
+
+    private func buildCommandList() -> [PaletteCommand] {
+        var commands: [PaletteCommand] = []
+
+        // Commands from ShortcutAction
+        for action in ShortcutAction.allCases {
+            let shortcut = StoredShortcut.shortcut(for: action)
+            commands.append(PaletteCommand(
+                id: action.rawValue,
+                name: action.displayName,
+                shortcut: shortcut.displayString,
+                category: action.category,
+                action: { [self] in
+                    executeShortcutAction(action)
+                }
+            ))
+        }
+
+        // Additional commands
+        commands.append(PaletteCommand(
+            id: "newBrowserPane",
+            name: "New Browser Pane",
+            shortcut: "\u{2318}\u{21E7}B",
+            category: "Panels",
+            action: { [self] in addBrowserPane() }
+        ))
+
+        commands.append(PaletteCommand(
+            id: "newMarkdownPane",
+            name: "New Markdown Pane",
+            shortcut: "\u{2318}\u{21E7}M",
+            category: "Panels",
+            action: { [self] in addMarkdownPane() }
+        ))
+
+        commands.append(PaletteCommand(
+            id: "copyMode",
+            name: "Copy Mode",
+            shortcut: "\u{2318}\u{21E7}C",
+            category: "Terminal",
+            action: { [self] in toggleCopyMode() }
+        ))
+
+        commands.append(PaletteCommand(
+            id: "commandPalette",
+            name: "Command Palette",
+            shortcut: "\u{2318}\u{21E7}P",
+            category: "Window",
+            action: { /* Already open */ }
+        ))
+
+        return commands
+    }
+
+    private func executeShortcutAction(_ action: ShortcutAction) {
+        switch action {
+        case .find: break // Handled by terminal view
+        case .clearTerminal: break
+        case .newTab: state.createTab()
+        case .closeTab:
+            if let tab = state.tabs.first(where: { $0.active }),
+               let pane = tab.panes.first {
+                state.closeTab(id: pane.id)
+            }
+        case .nextTab:
+            let tabs = state.tabs
+            let idx = state.activeTabIndex
+            if let nextTab = tabs.first(where: { $0.index > idx }) ?? tabs.first,
+               let pane = nextTab.panes.first {
+                state.switchTab(id: pane.id)
+            }
+        case .prevTab:
+            let tabs = state.tabs
+            let idx = state.activeTabIndex
+            if let prevTab = tabs.last(where: { $0.index < idx }) ?? tabs.last,
+               let pane = prevTab.panes.first {
+                state.switchTab(id: pane.id)
+            }
+        case .splitRight: splitPane(orientation: .horizontal)
+        case .splitDown: splitPane(orientation: .vertical)
+        case .closePane: closePane()
+        case .focusNextPane: focusNextPane()
+        case .focusPrevPane: focusPreviousPane()
+        case .toggleSidebar: break // Handled by NSSplitViewController
+        case .toggleInspect: showInspect.toggle()
+        case .toggleFullscreen:
+            NSApp.keyWindow?.toggleFullScreen(nil)
+        case .focusLeft, .focusRight, .focusUp, .focusDown:
+            break // Directional focus — would need spatial awareness
+        }
+    }
+
+    // MARK: - SSH upload
+
+    private func handleSSHUpload() {
+        guard let url = sshDetector.pickFileForUpload(),
+              let cmd = sshDetector.buildUploadCommand(localPath: url.path) else {
+            return
+        }
+        state.sendTerminalInput(cmd + "\n")
+    }
+}