@wangyaoshen/remux 0.3.9-dev.390cb29 → 0.3.10-dev.574c4d2

package/apps/macos/Package.swift

@@ -29,6 +29,11 @@ let package = Package(
                 .linkedLibrary("z"),
             ]
         ),
+        .testTarget(
+            name: "RemuxTests",
+            dependencies: ["Remux"],
+            path: "Tests/RemuxTests"
+        ),
         .binaryTarget(
             name: "GhosttyKit",
             path: "../../vendor/ghostty/macos/GhosttyKit.xcframework"

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

@@ -0,0 +1,114 @@
+import Foundation
+
+enum WindowCommandAction: String, Sendable {
+    case splitRight
+    case splitDown
+    case closePane
+    case focusNextPane
+    case focusPreviousPane
+    case newBrowserPane
+    case newMarkdownPane
+    case commandPalette
+    case copyMode
+    case findInTerminal
+}
+
+struct WindowCommand: Equatable, Sendable {
+    private static let actionKey = "action"
+    private static let targetWindowNumberKey = "targetWindowNumber"
+
+    let action: WindowCommandAction
+    let targetWindowNumber: Int
+
+    init(action: WindowCommandAction, targetWindowNumber: Int) {
+        self.action = action
+        self.targetWindowNumber = targetWindowNumber
+    }
+
+    init?(notification: Notification) {
+        guard notification.name == .remuxWindowCommand,
+              let rawAction = notification.userInfo?[Self.actionKey] as? String,
+              let action = WindowCommandAction(rawValue: rawAction),
+              let targetWindowNumber = notification.userInfo?[Self.targetWindowNumberKey] as? Int else {
+            return nil
+        }
+        self.init(action: action, targetWindowNumber: targetWindowNumber)
+    }
+
+    func matches(windowNumber: Int?) -> Bool {
+        guard let windowNumber else { return false }
+        return targetWindowNumber == windowNumber
+    }
+
+    func post() {
+        NotificationCenter.default.post(
+            name: .remuxWindowCommand,
+            object: nil,
+            userInfo: [
+                Self.actionKey: action.rawValue,
+                Self.targetWindowNumberKey: targetWindowNumber,
+            ]
+        )
+    }
+}
+
+enum TerminalCommandAction: String, Sendable {
+    case showSearch
+}
+
+struct TerminalCommand: Equatable, Sendable {
+    private static let actionKey = "action"
+    private static let targetWindowNumberKey = "targetWindowNumber"
+    private static let leafIDKey = "leafID"
+
+    let action: TerminalCommandAction
+    let targetWindowNumber: Int
+    let leafID: UUID?
+
+    init(action: TerminalCommandAction, targetWindowNumber: Int, leafID: UUID?) {
+        self.action = action
+        self.targetWindowNumber = targetWindowNumber
+        self.leafID = leafID
+    }
+
+    init?(notification: Notification) {
+        guard notification.name == .remuxTerminalCommand,
+              let rawAction = notification.userInfo?[Self.actionKey] as? String,
+              let action = TerminalCommandAction(rawValue: rawAction),
+              let targetWindowNumber = notification.userInfo?[Self.targetWindowNumberKey] as? Int else {
+            return nil
+        }
+        self.init(
+            action: action,
+            targetWindowNumber: targetWindowNumber,
+            leafID: notification.userInfo?[Self.leafIDKey] as? UUID
+        )
+    }
+
+    func matches(windowNumber: Int?, leafID: UUID?) -> Bool {
+        guard let windowNumber, targetWindowNumber == windowNumber else {
+            return false
+        }
+        return self.leafID == leafID
+    }
+
+    func post() {
+        var userInfo: [String: Any] = [
+            Self.actionKey: action.rawValue,
+            Self.targetWindowNumberKey: targetWindowNumber,
+        ]
+        if let leafID {
+            userInfo[Self.leafIDKey] = leafID
+        }
+        NotificationCenter.default.post(
+            name: .remuxTerminalCommand,
+            object: nil,
+            userInfo: userInfo
+        )
+    }
+}
+
+extension Notification.Name {
+    static let remuxWindowCommand = Notification.Name("remuxWindowCommand")
+    static let remuxTerminalCommand = Notification.Name("remuxTerminalCommand")
+}

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

@@ -38,6 +38,13 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         finderIntegration = FinderIntegration(state: state)
         finderIntegration?.registerServices()
 
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleTerminalDataNotification(_:)),
+            name: .remuxTerminalData,
+            object: nil
+        )
+
         // Start autosave
         SessionPersistence.shared.startAutosave { [weak self] in
             guard let self else {
@@ -60,6 +67,8 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
     }
 
     func applicationWillTerminate(_ notification: Notification) {
+        NotificationCenter.default.removeObserver(self)
+
         // Stop socket controller
         socketController?.stop()
 
@@ -254,4 +263,21 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         }
         detachedWindows.removeAll()
     }
+
+    @objc private func handleTerminalDataNotification(_ notification: Notification) {
+        guard let data = notification.userInfo?["data"] as? Data else { return }
+
+        let oscNotifications = OSCNotificationParser.parse(data)
+        guard !oscNotifications.isEmpty else { return }
+
+        let sessionName = state.currentSession.isEmpty ? "Remux" : state.currentSession
+        for oscNotification in oscNotifications {
+            notificationManager?.handleNotification(.init(
+                title: oscNotification.title,
+                body: oscNotification.body,
+                tabIndex: state.activeTabIndex,
+                sessionName: sessionName
+            ))
+        }
+    }
 }

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

@@ -6,6 +6,7 @@ import RemuxKit
 struct MainContentView: View {
     @Environment(RemuxState.self) private var state
     @State private var showInspect = false
+    @State private var windowNumber: Int?
 
     // Split pane state
     @State private var splitRoot: SplitNode = .leaf(SplitNode.LeafData(tabIndex: 0))
@@ -88,6 +89,11 @@ struct MainContentView: View {
                 isPresented: $showCommandPalette,
                 commands: buildCommandList()
             )
+
+            WindowObserver { window in
+                windowNumber = window?.windowNumber
+            }
+            .frame(width: 0, height: 0)
         }
         .onAppear {
             // Set initial focused leaf
@@ -95,6 +101,13 @@ struct MainContentView: View {
                 focusedLeafID = splitRoot.allLeaves.first?.id
             }
         }
+        .onReceive(NotificationCenter.default.publisher(for: .remuxWindowCommand)) { notification in
+            guard let command = WindowCommand(notification: notification),
+                  command.matches(windowNumber: windowNumber) else {
+                return
+            }
+            handleWindowCommand(command.action)
+        }
     }
 
     @ViewBuilder
@@ -296,6 +309,49 @@ struct MainContentView: View {
         }
     }
 
+    private func handleWindowCommand(_ action: WindowCommandAction) {
+        switch action {
+        case .splitRight:
+            splitPane(orientation: .horizontal)
+        case .splitDown:
+            splitPane(orientation: .vertical)
+        case .closePane:
+            closePane()
+        case .focusNextPane:
+            focusNextPane()
+        case .focusPreviousPane:
+            focusPreviousPane()
+        case .newBrowserPane:
+            addBrowserPane()
+        case .newMarkdownPane:
+            addMarkdownPane()
+        case .commandPalette:
+            toggleCommandPalette()
+        case .copyMode:
+            toggleCopyMode()
+        case .findInTerminal:
+            guard let windowNumber,
+                  let leafID = activeTerminalLeafID else {
+                return
+            }
+            TerminalCommand(
+                action: .showSearch,
+                targetWindowNumber: windowNumber,
+                leafID: leafID
+            ).post()
+        }
+    }
+
+    private var activeTerminalLeafID: UUID? {
+        if let focusedLeafID,
+           let leaf = splitRoot.findLeaf(id: focusedLeafID),
+           leaf.panelType == .terminal {
+            return focusedLeafID
+        }
+
+        return splitRoot.allLeaves.first(where: { $0.panelType == .terminal })?.id
+    }
+
     // MARK: - SSH upload
 
     private func handleSSHUpload() {

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

@@ -6,20 +6,6 @@ import RemuxKit
 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()
@@ -211,52 +197,53 @@ final class MenuBarManager {
     }
 
     @objc private func findInTerminal(_ sender: Any?) {
-        // Search is triggered through the GhosttyNativeView's performKeyEquivalent
-        // which intercepts Cmd+F. The menu item provides discoverability.
+        dispatch(.findInTerminal)
     }
 
     // MARK: - Split pane actions
 
     @objc private func splitRightAction(_ sender: Any?) {
-        onSplitRight?()
+        dispatch(.splitRight)
     }
 
     @objc private func splitDownAction(_ sender: Any?) {
-        onSplitDown?()
+        dispatch(.splitDown)
     }
 
     @objc private func closePaneAction(_ sender: Any?) {
-        onClosePane?()
+        dispatch(.closePane)
     }
 
     @objc private func focusNextAction(_ sender: Any?) {
-        onFocusNextPane?()
+        dispatch(.focusNextPane)
     }
 
     @objc private func focusPrevAction(_ sender: Any?) {
-        onFocusPreviousPane?()
+        dispatch(.focusPreviousPane)
     }
 
     // MARK: - New panel actions
 
     @objc private func newBrowserPaneAction(_ sender: Any?) {
-        onNewBrowserPane?()
+        dispatch(.newBrowserPane)
     }
 
     @objc private func newMarkdownPaneAction(_ sender: Any?) {
-        onNewMarkdownPane?()
+        dispatch(.newMarkdownPane)
     }
 
     @objc private func commandPaletteAction(_ sender: Any?) {
-        onCommandPalette?()
+        dispatch(.commandPalette)
     }
 
     @objc private func copyModeAction(_ sender: Any?) {
-        onCopyMode?()
+        dispatch(.copyMode)
     }
 
     @objc private func detachPaneAction(_ sender: Any?) {
-        onDetachPane?()
+        if let appDelegate = NSApp.delegate as? AppDelegate {
+            appDelegate.detachPaneToWindow()
+        }
     }
 
     @objc private func openInEditor(_ sender: Any?) {
@@ -272,4 +259,9 @@ final class MenuBarManager {
 
         FinderIntegration.openInExternalEditor(path: cwd, editor: editor)
     }
+
+    private func dispatch(_ action: WindowCommandAction) {
+        guard let targetWindowNumber = NSApp.keyWindow?.windowNumber else { return }
+        WindowCommand(action: action, targetWindowNumber: targetWindowNumber).post()
+    }
 }

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

@@ -84,7 +84,7 @@ final class NotificationManager: NSObject {
     }
 }
 
-extension NotificationManager: @preconcurrency UNUserNotificationCenterDelegate {
+extension NotificationManager: UNUserNotificationCenterDelegate {
     nonisolated func userNotificationCenter(
         _ center: UNUserNotificationCenter,
         didReceive response: UNNotificationResponse,
@@ -102,21 +102,44 @@ extension NotificationManager: @preconcurrency UNUserNotificationCenterDelegate
         willPresent notification: UNNotification,
         withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void
     ) {
-        let options: UNNotificationPresentationOptions = NSApp.isActive ? [] : [.banner, .sound]
+        let options: UNNotificationPresentationOptions
+        if Thread.isMainThread {
+            options = MainActor.assumeIsolated {
+                currentPresentationOptions()
+            }
+        } else {
+            options = DispatchQueue.main.sync {
+                MainActor.assumeIsolated {
+                    currentPresentationOptions()
+                }
+            }
+        }
         completionHandler(options)
     }
+
+    @MainActor
+    private func currentPresentationOptions() -> UNNotificationPresentationOptions {
+        NSApp.isActive ? [] : [.banner, .sound]
+    }
 }
 
 // MARK: - OSC Notification Parser
 
 /// Parses OSC 9/99/777 notification sequences from PTY data.
 /// Ref: cmux OSC notification detection approach
+struct OSCParsedNotification: Equatable {
+    let title: String
+    let body: String
+}
+
 struct OSCNotificationParser {
+    private static let defaultTitle = "Terminal Notification"
+
     /// Parse PTY data for notification sequences.
     /// Returns extracted notifications (if any).
-    static func parse(_ data: Data) -> [String] {
+    static func parse(_ data: Data) -> [OSCParsedNotification] {
         guard let text = String(data: data, encoding: .utf8) else { return [] }
-        var notifications: [String] = []
+        var notifications: [OSCParsedNotification] = []
 
         // OSC 9: iTerm2 notification — ESC ] 9 ; <message> BEL/ST
         let osc9Pattern = "\u{1b}]9;([^\u{07}\u{1b}]+)[\u{07}]"
@@ -124,7 +147,24 @@ struct OSCNotificationParser {
             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]))
+                    notifications.append(OSCParsedNotification(
+                        title: defaultTitle,
+                        body: String(text[range])
+                    ))
+                }
+            }
+        }
+
+        // OSC 99: kitty notification — ESC ] 99 ; <message> BEL
+        let osc99Pattern = "\u{1b}]99;([^\u{07}\u{1b}]+)[\u{07}]"
+        if let regex = try? NSRegularExpression(pattern: osc99Pattern) {
+            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(OSCParsedNotification(
+                        title: defaultTitle,
+                        body: String(text[range])
+                    ))
                 }
             }
         }
@@ -134,8 +174,13 @@ struct OSCNotificationParser {
         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]))
+                if let titleRange = Range(match.range(at: 1), in: text),
+                   let bodyRange = Range(match.range(at: 2), in: text) {
+                    let title = String(text[titleRange]).isEmpty ? defaultTitle : String(text[titleRange])
+                    notifications.append(OSCParsedNotification(
+                        title: title,
+                        body: String(text[bodyRange])
+                    ))
                 }
             }
         }

package/apps/macos/Sources/Remux/Views/SplitTree/SplitView.swift

@@ -64,7 +64,7 @@ struct SplitLeafView: View {
     private var panelContent: some View {
         switch data.panelType {
         case .terminal:
-            TerminalContainerView()
+            TerminalContainerView(leafID: data.id)
 
         case .browser:
             let panel = getBrowserPanel()

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

@@ -243,15 +243,21 @@ final class GhosttyNativeView: NSView, @preconcurrency NSTextInputClient {
 
     /// Navigate to the next search match.
     func searchForward() {
-        guard let surface else { return }
-        let action = "search_forward"
-        _ = ghostty_surface_binding_action(surface, action, UInt(action.utf8.count))
+        performBindingAction("search_forward")
     }
 
     /// Navigate to the previous search match.
     func searchBackward() {
+        performBindingAction("search_backward")
+    }
+
+    /// Update the active search query for the surface.
+    func updateSearch(_ query: String) {
+        performBindingAction("search:\(query)")
+    }
+
+    private func performBindingAction(_ action: String) {
         guard let surface else { return }
-        let action = "search_backward"
         _ = ghostty_surface_binding_action(surface, action, UInt(action.utf8.count))
     }
 

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

@@ -6,9 +6,12 @@ import RemuxKit
 ///   Remote PTY -> WebSocket -> RemuxState -> relay.writeToTerminal() -> socket -> nc stdout -> ghostty Metal render
 ///   User types -> ghostty -> nc stdin -> socket -> relay.onDataFromClient -> state.sendTerminalData() -> WebSocket -> remote PTY
 struct TerminalContainerView: View {
+    let leafID: UUID?
+
     @Environment(RemuxState.self) private var state
     @State private var terminalView: GhosttyNativeView?
     @State private var relay = TerminalRelay()
+    @State private var windowNumber: Int?
 
     // Search state
     @State private var searchVisible = false
@@ -16,6 +19,10 @@ struct TerminalContainerView: View {
     @State private var searchTotal = 0
     @State private var searchSelected = -1
 
+    init(leafID: UUID? = nil) {
+        self.leafID = leafID
+    }
+
     var body: some View {
         ZStack(alignment: .topTrailing) {
             GhosttyNativeTerminalView(
@@ -55,15 +62,11 @@ struct TerminalContainerView: View {
                 selectedMatch: $searchSelected,
                 onSearch: { query in
                     guard let view = terminalView else { return }
+                    view.updateSearch(query)
                     if query.isEmpty {
                         searchTotal = 0
                         searchSelected = -1
                     }
-                    // Ghostty search is triggered by typing into the search bar,
-                    // which sends the text via binding_action
-                    let action = "search:\(query)"
-                    view.sendText("")  // ensure surface has focus
-                    _ = action  // search is driven by the overlay text field
                 },
                 onNext: {
                     terminalView?.searchForward()
@@ -74,14 +77,37 @@ struct TerminalContainerView: View {
                 onClose: {
                     searchTotal = 0
                     searchSelected = -1
+                    terminalView?.updateSearch("")
                 }
             )
+
+            WindowObserver { window in
+                windowNumber = window?.windowNumber
+            }
+            .frame(width: 0, height: 0)
         }
         .onReceive(NotificationCenter.default.publisher(for: .remuxTerminalData)) { notification in
             if let data = notification.userInfo?["data"] as? Data {
                 relay.writeToTerminal(data)
             }
         }
+        .onReceive(NotificationCenter.default.publisher(for: .remuxWindowCommand)) { notification in
+            guard leafID == nil,
+                  let command = WindowCommand(notification: notification),
+                  command.action == .findInTerminal,
+                  command.matches(windowNumber: windowNumber) else {
+                return
+            }
+            openSearch()
+        }
+        .onReceive(NotificationCenter.default.publisher(for: .remuxTerminalCommand)) { notification in
+            guard let command = TerminalCommand(notification: notification),
+                  command.action == .showSearch,
+                  command.matches(windowNumber: windowNumber, leafID: leafID) else {
+                return
+            }
+            openSearch()
+        }
         .onAppear {
             relay.onDataFromClient = { data in
                 state.sendTerminalData(data)
@@ -92,4 +118,8 @@ struct TerminalContainerView: View {
             relay.stop()
         }
     }
+
+    private func openSearch() {
+        searchVisible = true
+    }
 }

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

@@ -0,0 +1,38 @@
+import AppKit
+import SwiftUI
+
+struct WindowObserver: NSViewRepresentable {
+    var onWindowChange: (NSWindow?) -> Void
+
+    func makeNSView(context: Context) -> WindowObserverView {
+        let view = WindowObserverView()
+        view.onWindowChange = onWindowChange
+        return view
+    }
+
+    func updateNSView(_ nsView: WindowObserverView, context: Context) {
+        nsView.onWindowChange = onWindowChange
+        nsView.reportWindow()
+    }
+}
+
+final class WindowObserverView: NSView {
+    var onWindowChange: ((NSWindow?) -> Void)?
+
+    override func viewDidMoveToWindow() {
+        super.viewDidMoveToWindow()
+        reportWindow()
+    }
+
+    override func viewDidMoveToSuperview() {
+        super.viewDidMoveToSuperview()
+        reportWindow()
+    }
+
+    func reportWindow() {
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            self.onWindowChange?(self.window)
+        }
+    }
+}

package/apps/macos/Tests/RemuxTests/AppCommandTests.swift

@@ -0,0 +1,30 @@
+import Foundation
+import Testing
+@testable import Remux
+
+@Suite("AppCommand")
+struct AppCommandTests {
+
+    @Test("Window command only matches its target window")
+    func windowCommandMatchesTargetWindow() {
+        let command = WindowCommand(action: .splitRight, targetWindowNumber: 17)
+
+        #expect(command.matches(windowNumber: 17))
+        #expect(!command.matches(windowNumber: 18))
+        #expect(!command.matches(windowNumber: nil))
+    }
+
+    @Test("Terminal command matches both window and leaf")
+    func terminalCommandMatchesWindowAndLeaf() {
+        let leafID = UUID()
+        let command = TerminalCommand(
+            action: .showSearch,
+            targetWindowNumber: 42,
+            leafID: leafID
+        )
+
+        #expect(command.matches(windowNumber: 42, leafID: leafID))
+        #expect(!command.matches(windowNumber: 43, leafID: leafID))
+        #expect(!command.matches(windowNumber: 42, leafID: UUID()))
+    }
+}

package/apps/macos/Tests/RemuxTests/NotificationManagerTests.swift

@@ -0,0 +1,28 @@
+import Foundation
+import Testing
+@testable import Remux
+
+@Suite("OSCNotificationParser")
+struct OSCNotificationParserTests {
+
+    @Test("Parses OSC 9 and OSC 99 notifications")
+    func parsesOSC9And99() {
+        let payload = "\u{1b}]9;Build complete\u{07}\u{1b}]99;Tests passed\u{07}"
+        let parsed = OSCNotificationParser.parse(Data(payload.utf8))
+
+        #expect(parsed == [
+            OSCParsedNotification(title: "Terminal Notification", body: "Build complete"),
+            OSCParsedNotification(title: "Terminal Notification", body: "Tests passed"),
+        ])
+    }
+
+    @Test("Parses OSC 777 notifications with explicit title")
+    func parsesOSC777() {
+        let payload = "\u{1b}]777;notify;Deploy;Finished successfully\u{07}"
+        let parsed = OSCNotificationParser.parse(Data(payload.utf8))
+
+        #expect(parsed == [
+            OSCParsedNotification(title: "Deploy", body: "Finished successfully"),
+        ])
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wangyaoshen/remux",
-  "version": "0.3.9-dev.390cb29",
+  "version": "0.3.10-dev.574c4d2",
   "description": "Remote terminal workspace — powered by ghostty-web",
   "license": "MIT",
   "repository": {