@wangyaoshen/remux 0.3.8-dev.a8ceb0c

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

@@ -0,0 +1,275 @@
+import AppKit
+import RemuxKit
+
+/// Manages the native macOS menu bar.
+@MainActor
+final class MenuBarManager {
+    private weak var state: RemuxState?
+
+    /// Callback for split operations, wired from AppDelegate.
+    var onSplitRight: (() -> Void)?
+    var onSplitDown: (() -> Void)?
+    var onClosePane: (() -> Void)?
+    var onFocusNextPane: (() -> Void)?
+    var onFocusPreviousPane: (() -> Void)?
+
+    /// Callbacks for new features.
+    var onNewBrowserPane: (() -> Void)?
+    var onNewMarkdownPane: (() -> Void)?
+    var onCommandPalette: (() -> Void)?
+    var onCopyMode: (() -> Void)?
+    var onDetachPane: (() -> Void)?
+
+    init(state: RemuxState) {
+        self.state = state
+        setupMenuBar()
+    }
+
+    private func setupMenuBar() {
+        let mainMenu = NSMenu()
+
+        // App menu
+        let appMenu = NSMenu()
+        appMenu.addItem(withTitle: "About Remux", action: #selector(NSApplication.orderFrontStandardAboutPanel(_:)), keyEquivalent: "")
+        appMenu.addItem(.separator())
+        appMenu.addItem(withTitle: "Settings...", action: #selector(showSettings), keyEquivalent: ",")
+        appMenu.addItem(.separator())
+        appMenu.addItem(withTitle: "Hide Remux", action: #selector(NSApplication.hide(_:)), keyEquivalent: "h")
+        let hideOthers = appMenu.addItem(withTitle: "Hide Others", action: #selector(NSApplication.hideOtherApplications(_:)), keyEquivalent: "h")
+        hideOthers.keyEquivalentModifierMask = [.command, .option]
+        appMenu.addItem(withTitle: "Show All", action: #selector(NSApplication.unhideAllApplications(_:)), keyEquivalent: "")
+        appMenu.addItem(.separator())
+        appMenu.addItem(withTitle: "Quit Remux", action: #selector(NSApplication.terminate(_:)), keyEquivalent: "q")
+        let appMenuItem = NSMenuItem()
+        appMenuItem.submenu = appMenu
+        mainMenu.addItem(appMenuItem)
+
+        // File menu
+        let fileMenu = NSMenu(title: "File")
+        let newTab = fileMenu.addItem(withTitle: "New Tab", action: #selector(newTab(_:)), keyEquivalent: "t")
+        newTab.target = self
+        let closeTab = fileMenu.addItem(withTitle: "Close Tab", action: #selector(closeCurrentTab(_:)), keyEquivalent: "w")
+        closeTab.target = self
+        fileMenu.addItem(.separator())
+        let newWindow = fileMenu.addItem(withTitle: "New Window", action: #selector(newWindow(_:)), keyEquivalent: "n")
+        newWindow.target = self
+        fileMenu.addItem(.separator())
+        let newSession = fileMenu.addItem(withTitle: "New Session", action: #selector(newSession(_:)), keyEquivalent: "n")
+        newSession.keyEquivalentModifierMask = [.command, .shift]
+        newSession.target = self
+
+        fileMenu.addItem(.separator())
+
+        // Open in... submenu
+        let openInMenu = NSMenu(title: "Open in...")
+        for editor in FinderIntegration.installedEditors {
+            let item = openInMenu.addItem(withTitle: editor.name, action: #selector(openInEditor(_:)), keyEquivalent: "")
+            item.target = self
+            item.representedObject = editor
+            item.image = NSImage(systemSymbolName: editor.icon, accessibilityDescription: editor.name)
+        }
+        if openInMenu.items.isEmpty {
+            openInMenu.addItem(withTitle: "No Editors Found", action: nil, keyEquivalent: "")
+        }
+        let openInMenuItem = NSMenuItem(title: "Open in...", action: nil, keyEquivalent: "")
+        openInMenuItem.submenu = openInMenu
+        fileMenu.addItem(openInMenuItem)
+
+        let fileMenuItem = NSMenuItem()
+        fileMenuItem.submenu = fileMenu
+        mainMenu.addItem(fileMenuItem)
+
+        // Edit menu
+        let editMenu = NSMenu(title: "Edit")
+        editMenu.addItem(withTitle: "Copy", action: #selector(NSText.copy(_:)), keyEquivalent: "c")
+        editMenu.addItem(withTitle: "Paste", action: #selector(NSText.paste(_:)), keyEquivalent: "v")
+        editMenu.addItem(withTitle: "Select All", action: #selector(NSText.selectAll(_:)), keyEquivalent: "a")
+        editMenu.addItem(.separator())
+        let findItem = editMenu.addItem(withTitle: "Find...", action: #selector(findInTerminal(_:)), keyEquivalent: "f")
+        findItem.target = self
+        editMenu.addItem(.separator())
+        let copyModeItem = editMenu.addItem(withTitle: "Copy Mode", action: #selector(copyModeAction(_:)), keyEquivalent: "c")
+        copyModeItem.keyEquivalentModifierMask = [.command, .shift]
+        copyModeItem.target = self
+        let editMenuItem = NSMenuItem()
+        editMenuItem.submenu = editMenu
+        mainMenu.addItem(editMenuItem)
+
+        // View menu
+        let viewMenu = NSMenu(title: "View")
+        let toggleSidebar = viewMenu.addItem(withTitle: "Toggle Sidebar", action: #selector(toggleSidebar(_:)), keyEquivalent: "s")
+        toggleSidebar.keyEquivalentModifierMask = [.command, .control]
+        toggleSidebar.target = self
+
+        viewMenu.addItem(.separator())
+
+        // Command Palette
+        let cmdPalette = viewMenu.addItem(withTitle: "Command Palette", action: #selector(commandPaletteAction(_:)), keyEquivalent: "p")
+        cmdPalette.keyEquivalentModifierMask = [.command, .shift]
+        cmdPalette.target = self
+
+        viewMenu.addItem(.separator())
+
+        // Split pane items
+        let splitRight = viewMenu.addItem(withTitle: "Split Right", action: #selector(splitRightAction(_:)), keyEquivalent: "d")
+        splitRight.target = self
+
+        let splitDown = viewMenu.addItem(withTitle: "Split Down", action: #selector(splitDownAction(_:)), keyEquivalent: "d")
+        splitDown.keyEquivalentModifierMask = [.command, .shift]
+        splitDown.target = self
+
+        viewMenu.addItem(.separator())
+
+        // New panel types
+        let browserPane = viewMenu.addItem(withTitle: "New Browser Pane", action: #selector(newBrowserPaneAction(_:)), keyEquivalent: "b")
+        browserPane.keyEquivalentModifierMask = [.command, .shift]
+        browserPane.target = self
+
+        let markdownPane = viewMenu.addItem(withTitle: "New Markdown Pane", action: #selector(newMarkdownPaneAction(_:)), keyEquivalent: "m")
+        markdownPane.keyEquivalentModifierMask = [.command, .shift]
+        markdownPane.target = self
+
+        viewMenu.addItem(.separator())
+
+        let closePane = viewMenu.addItem(withTitle: "Close Pane", action: #selector(closePaneAction(_:)), keyEquivalent: "w")
+        closePane.keyEquivalentModifierMask = [.command, .shift]
+        closePane.target = self
+
+        viewMenu.addItem(.separator())
+
+        // Focus navigation
+        let focusNext = viewMenu.addItem(withTitle: "Focus Next Pane", action: #selector(focusNextAction(_:)), keyEquivalent: "]")
+        focusNext.keyEquivalentModifierMask = [.command, .option]
+        focusNext.target = self
+
+        let focusPrev = viewMenu.addItem(withTitle: "Focus Previous Pane", action: #selector(focusPrevAction(_:)), keyEquivalent: "[")
+        focusPrev.keyEquivalentModifierMask = [.command, .option]
+        focusPrev.target = self
+
+        let viewMenuItem = NSMenuItem()
+        viewMenuItem.submenu = viewMenu
+        mainMenu.addItem(viewMenuItem)
+
+        // Window menu
+        let windowMenu = NSMenu(title: "Window")
+        windowMenu.addItem(withTitle: "Minimize", action: #selector(NSWindow.performMiniaturize(_:)), keyEquivalent: "m")
+        windowMenu.addItem(withTitle: "Zoom", action: #selector(NSWindow.performZoom(_:)), keyEquivalent: "")
+        windowMenu.addItem(.separator())
+
+        let detachPane = windowMenu.addItem(withTitle: "Detach Pane to Window", action: #selector(detachPaneAction(_:)), keyEquivalent: "\r")
+        detachPane.keyEquivalentModifierMask = [.command, .shift]
+        detachPane.target = self
+
+        windowMenu.addItem(.separator())
+        windowMenu.addItem(withTitle: "Bring All to Front", action: #selector(NSApplication.arrangeInFront(_:)), keyEquivalent: "")
+        let windowMenuItem = NSMenuItem()
+        windowMenuItem.submenu = windowMenu
+        mainMenu.addItem(windowMenuItem)
+        NSApp.windowsMenu = windowMenu
+
+        // Help menu
+        let helpMenu = NSMenu(title: "Help")
+        let helpMenuItem = NSMenuItem()
+        helpMenuItem.submenu = helpMenu
+        mainMenu.addItem(helpMenuItem)
+        NSApp.helpMenu = helpMenu
+
+        NSApp.mainMenu = mainMenu
+    }
+
+    @objc private func showSettings(_ sender: Any?) {
+        NSApp.sendAction(Selector(("showSettingsWindow:")), to: nil, from: nil)
+    }
+
+    @objc private func newWindow(_ sender: Any?) {
+        if let appDelegate = NSApp.delegate as? AppDelegate {
+            appDelegate.createNewWindow()
+        }
+    }
+
+    @objc private func newTab(_ sender: Any?) {
+        state?.createTab()
+    }
+
+    @objc private func closeCurrentTab(_ sender: Any?) {
+        guard let state, !state.tabs.isEmpty else { return }
+        let activeTab = state.tabs.first { $0.index == state.activeTabIndex }
+        if let pane = activeTab?.panes.first {
+            state.closeTab(id: pane.id)
+        }
+    }
+
+    @objc private func newSession(_ sender: Any?) {
+        let name = "session-\(Int.random(in: 1000...9999))"
+        state?.createSession(name: name)
+    }
+
+    @objc private func toggleSidebar(_ sender: Any?) {
+        NSApp.keyWindow?.contentView?.window?.firstResponder?.tryToPerform(
+            #selector(NSSplitViewController.toggleSidebar(_:)), with: nil
+        )
+    }
+
+    @objc private func findInTerminal(_ sender: Any?) {
+        // Search is triggered through the GhosttyNativeView's performKeyEquivalent
+        // which intercepts Cmd+F. The menu item provides discoverability.
+    }
+
+    // MARK: - Split pane actions
+
+    @objc private func splitRightAction(_ sender: Any?) {
+        onSplitRight?()
+    }
+
+    @objc private func splitDownAction(_ sender: Any?) {
+        onSplitDown?()
+    }
+
+    @objc private func closePaneAction(_ sender: Any?) {
+        onClosePane?()
+    }
+
+    @objc private func focusNextAction(_ sender: Any?) {
+        onFocusNextPane?()
+    }
+
+    @objc private func focusPrevAction(_ sender: Any?) {
+        onFocusPreviousPane?()
+    }
+
+    // MARK: - New panel actions
+
+    @objc private func newBrowserPaneAction(_ sender: Any?) {
+        onNewBrowserPane?()
+    }
+
+    @objc private func newMarkdownPaneAction(_ sender: Any?) {
+        onNewMarkdownPane?()
+    }
+
+    @objc private func commandPaletteAction(_ sender: Any?) {
+        onCommandPalette?()
+    }
+
+    @objc private func copyModeAction(_ sender: Any?) {
+        onCopyMode?()
+    }
+
+    @objc private func detachPaneAction(_ sender: Any?) {
+        onDetachPane?()
+    }
+
+    @objc private func openInEditor(_ sender: Any?) {
+        guard let item = sender as? NSMenuItem,
+              let editor = item.representedObject as? FinderIntegration.ExternalEditor else { return }
+
+        // Get CWD from the active tab
+        guard let state,
+              let tab = state.tabs.first(where: { $0.active }),
+              let cwd = tab.panes.first?.cwd, !cwd.isEmpty else {
+            return
+        }
+
+        FinderIntegration.openInExternalEditor(path: cwd, editor: editor)
+    }
+}

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

@@ -0,0 +1,145 @@
+import AppKit
+import UserNotifications
+
+/// Manages terminal notifications with three-level escalation.
+/// Ref: cmux TerminalNotificationStore.swift (design pattern, not code)
+///
+/// Level 1: Tab badge (red dot + count) — always
+/// Level 2: Sidebar session highlight — always
+/// Level 3: System notification — only when window not focused
+@MainActor
+final class NotificationManager: NSObject {
+
+    struct TerminalNotification {
+        let title: String
+        let body: String
+        let tabIndex: Int
+        let sessionName: String
+    }
+
+    /// Notification counts per tab index
+    private(set) var badgeCounts: [Int: Int] = [:]
+
+    /// Rate limit: max 1 system notification per 30 seconds
+    private var lastSystemNotification = Date.distantPast
+    private let systemNotificationCooldown: TimeInterval = 30
+
+    /// Whether UNUserNotificationCenter is available (requires app bundle context)
+    private let notificationsAvailable: Bool
+
+    override init() {
+        // UNUserNotificationCenter.current() crashes if not running inside an app bundle
+        notificationsAvailable = Bundle.main.bundleIdentifier != nil
+        super.init()
+        guard notificationsAvailable else { return }
+        UNUserNotificationCenter.current().delegate = self
+        requestPermission()
+    }
+
+    private func requestPermission() {
+        guard notificationsAvailable else { return }
+        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { _, _ in }
+    }
+
+    func handleNotification(_ notification: TerminalNotification) {
+        // Level 1: Increment badge count
+        badgeCounts[notification.tabIndex, default: 0] += 1
+
+        // Level 3: System notification if window not focused
+        let windowFocused = NSApp.isActive && NSApp.keyWindow != nil
+        if !windowFocused {
+            sendSystemNotification(notification)
+        }
+    }
+
+    func clearBadge(forTab tabIndex: Int) {
+        badgeCounts[tabIndex] = nil
+    }
+
+    func clearAllBadges() {
+        badgeCounts.removeAll()
+    }
+
+    private func sendSystemNotification(_ notification: TerminalNotification) {
+        guard notificationsAvailable else { return }
+        let now = Date()
+        guard now.timeIntervalSince(lastSystemNotification) > systemNotificationCooldown else { return }
+        lastSystemNotification = now
+
+        let content = UNMutableNotificationContent()
+        content.title = notification.title
+        content.body = notification.body
+        content.sound = .default
+        content.userInfo = [
+            "tabIndex": notification.tabIndex,
+            "sessionName": notification.sessionName,
+        ]
+
+        let request = UNNotificationRequest(
+            identifier: UUID().uuidString,
+            content: content,
+            trigger: nil
+        )
+        UNUserNotificationCenter.current().add(request)
+    }
+}
+
+extension NotificationManager: @preconcurrency UNUserNotificationCenterDelegate {
+    nonisolated func userNotificationCenter(
+        _ center: UNUserNotificationCenter,
+        didReceive response: UNNotificationResponse,
+        withCompletionHandler completionHandler: @escaping () -> Void
+    ) {
+        DispatchQueue.main.async {
+            NSApp.activate(ignoringOtherApps: true)
+            NSApp.keyWindow?.makeKeyAndOrderFront(nil)
+        }
+        completionHandler()
+    }
+
+    nonisolated func userNotificationCenter(
+        _ center: UNUserNotificationCenter,
+        willPresent notification: UNNotification,
+        withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void
+    ) {
+        let options: UNNotificationPresentationOptions = NSApp.isActive ? [] : [.banner, .sound]
+        completionHandler(options)
+    }
+}
+
+// MARK: - OSC Notification Parser
+
+/// Parses OSC 9/99/777 notification sequences from PTY data.
+/// Ref: cmux OSC notification detection approach
+struct OSCNotificationParser {
+    /// Parse PTY data for notification sequences.
+    /// Returns extracted notifications (if any).
+    static func parse(_ data: Data) -> [String] {
+        guard let text = String(data: data, encoding: .utf8) else { return [] }
+        var notifications: [String] = []
+
+        // OSC 9: iTerm2 notification — ESC ] 9 ; <message> BEL/ST
+        let osc9Pattern = "\u{1b}]9;([^\u{07}\u{1b}]+)[\u{07}]"
+        if let regex = try? NSRegularExpression(pattern: osc9Pattern) {
+            let matches = regex.matches(in: text, range: NSRange(text.startIndex..., in: text))
+            for match in matches {
+                if let range = Range(match.range(at: 1), in: text) {
+                    notifications.append(String(text[range]))
+                }
+            }
+        }
+
+        // OSC 777: rxvt-unicode notification — ESC ] 777 ; notify ; <title> ; <body> BEL
+        let osc777Pattern = "\u{1b}]777;notify;([^;]*);([^\u{07}\u{1b}]*)[\u{07}]"
+        if let regex = try? NSRegularExpression(pattern: osc777Pattern) {
+            let matches = regex.matches(in: text, range: NSRange(text.startIndex..., in: text))
+            for match in matches {
+                if let range = Range(match.range(at: 2), in: text) {
+                    notifications.append(String(text[range]))
+                }
+            }
+        }
+
+        return notifications
+    }
+}

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

@@ -0,0 +1,152 @@
+import Foundation
+import RemuxKit
+
+/// Detects listening ports from server-reported process info.
+/// Displays detected ports in the sidebar and supports opening
+/// in the browser panel (localhost:port).
+///
+/// Adapted from VS Code port forwarding / detection feature.
+@MainActor
+@Observable
+final class PortScanner {
+
+    /// A detected listening port.
+    struct DetectedPort: Identifiable, Equatable, Hashable, Sendable {
+        var id: Int { port }
+        let port: Int
+        let processName: String
+        let pid: Int?
+        let detectedAt: Date
+
+        var localURL: URL? {
+            URL(string: "http://localhost:\(port)")
+        }
+    }
+
+    /// Currently detected ports.
+    private(set) var ports: [DetectedPort] = []
+
+    /// Known port patterns (for naming).
+    private static let knownPorts: [Int: String] = [
+        3000: "Dev Server",
+        3001: "Dev Server",
+        4200: "Angular",
+        5000: "Flask/ASP.NET",
+        5173: "Vite",
+        5174: "Vite",
+        8000: "Django/FastAPI",
+        8080: "HTTP Alt",
+        8443: "HTTPS Alt",
+        8767: "Remux",
+        8888: "Jupyter",
+        9000: "PHP-FPM",
+        9090: "Prometheus",
+    ]
+
+    /// Parse terminal output text for port listening patterns.
+    /// Common patterns:
+    ///   "listening on port 3000"
+    ///   "running on http://localhost:8080"
+    ///   "server started at :5173"
+    ///   "Local:   http://localhost:5173/"
+    func parseTerminalOutput(_ text: String) {
+        let patterns = [
+            // "listening on port NNNN" or "listening at port NNNN"
+            "(?:listening|started|running|serving)\\s+(?:on|at)\\s+(?:port\\s+)?(\\d{2,5})",
+            // "http://localhost:NNNN" or "http://127.0.0.1:NNNN"
+            "https?://(?:localhost|127\\.0\\.0\\.1):(\\d{2,5})",
+            // ":NNNN" at word boundary (e.g., "server at :3000")
+            "(?:at|on)\\s+:(\\d{2,5})",
+        ]
+
+        for pattern in patterns {
+            guard let regex = try? NSRegularExpression(pattern: pattern, options: .caseInsensitive) else {
+                continue
+            }
+            let matches = regex.matches(in: text, range: NSRange(text.startIndex..., in: text))
+            for match in matches {
+                if let range = Range(match.range(at: 1), in: text),
+                   let port = Int(text[range]),
+                   port >= 1024, port <= 65535 {
+                    addPort(port)
+                }
+            }
+        }
+    }
+
+    /// Add a detected port if not already tracked.
+    func addPort(_ port: Int, processName: String? = nil, pid: Int? = nil) {
+        guard !ports.contains(where: { $0.port == port }) else { return }
+
+        let name = processName ?? Self.knownPorts[port] ?? "Port \(port)"
+        let detected = DetectedPort(
+            port: port,
+            processName: name,
+            pid: pid,
+            detectedAt: Date()
+        )
+        ports.append(detected)
+        ports.sort { $0.port < $1.port }
+        NSLog("[remux] Port detected: %d (%@)", port, name)
+    }
+
+    /// Remove a port from the tracked list.
+    func removePort(_ port: Int) {
+        ports.removeAll { $0.port == port }
+    }
+
+    /// Clear all detected ports.
+    func clearAll() {
+        ports.removeAll()
+    }
+
+    /// Check if a port is reachable by attempting a TCP connection.
+    func isPortReachable(_ port: Int, timeout: TimeInterval = 1.0) -> Bool {
+        let fd = socket(AF_INET, SOCK_STREAM, 0)
+        guard fd >= 0 else { return false }
+        defer { close(fd) }
+
+        // Set non-blocking
+        var flags = fcntl(fd, F_GETFL, 0)
+        flags |= O_NONBLOCK
+        fcntl(fd, F_SETFL, flags)
+
+        var addr = sockaddr_in()
+        addr.sin_family = sa_family_t(AF_INET)
+        addr.sin_port = UInt16(port).bigEndian
+        addr.sin_addr.s_addr = inet_addr("127.0.0.1")
+
+        let result = withUnsafePointer(to: &addr) { ptr in
+            ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) { sockPtr in
+                connect(fd, sockPtr, socklen_t(MemoryLayout<sockaddr_in>.size))
+            }
+        }
+
+        if result == 0 { return true }
+        if errno != EINPROGRESS { return false }
+
+        // Wait for connection with timeout
+        var fdSet = fd_set()
+        __darwin_fd_zero(&fdSet)
+        withUnsafeMutablePointer(to: &fdSet) { ptr in
+            let rawPtr = UnsafeMutableRawPointer(ptr)
+            let offset = Int(fd / 32)
+            let bit = Int(fd % 32)
+            rawPtr.advanced(by: offset * MemoryLayout<Int32>.size)
+                .assumingMemoryBound(to: Int32.self)
+                .pointee |= Int32(1 << bit)
+        }
+
+        var tv = timeval(tv_sec: Int(timeout), tv_usec: 0)
+        let selectResult = select(fd + 1, nil, &fdSet, nil, &tv)
+        return selectResult > 0
+    }
+}
+
+// MARK: - fd_set helpers
+
+private func __darwin_fd_zero(_ set: inout fd_set) {
+    withUnsafeMutableBytes(of: &set) { rawBuf in
+        rawBuf.initializeMemory(as: UInt8.self, repeating: 0)
+    }
+}

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

@@ -0,0 +1,13 @@
+import SwiftUI
+import RemuxKit
+
+@main
+struct RemuxApp: App {
+    @NSApplicationDelegateAdaptor(AppDelegate.self) var appDelegate
+
+    var body: some Scene {
+        Settings {
+            SettingsView()
+        }
+    }
+}