@wangyaoshen/remux 0.3.8-dev.bab6c95

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

@@ -0,0 +1,95 @@
+import SwiftUI
+import RemuxKit
+
+/// Container connecting GhosttyNativeTerminalView to RemuxState via TerminalRelay.
+/// Data flow:
+///   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 {
+    @Environment(RemuxState.self) private var state
+    @State private var terminalView: GhosttyNativeView?
+    @State private var relay = TerminalRelay()
+
+    // Search state
+    @State private var searchVisible = false
+    @State private var searchText = ""
+    @State private var searchTotal = 0
+    @State private var searchSelected = -1
+
+    var body: some View {
+        ZStack(alignment: .topTrailing) {
+            GhosttyNativeTerminalView(
+                socketPath: relay.socketPath,
+                viewRef: $terminalView,
+                onResize: { cols, rows in
+                    state.sendJSON(["type": "resize", "cols": cols, "rows": rows])
+                },
+                onBell: {},
+                onTitle: { title in
+                    NSApp.mainWindow?.title = "Remux — \(title)"
+                },
+                onSearchStart: { needle in
+                    searchVisible = true
+                    if let needle, !needle.isEmpty {
+                        searchText = needle
+                    }
+                },
+                onSearchEnd: {
+                    searchVisible = false
+                    searchText = ""
+                    searchTotal = 0
+                    searchSelected = -1
+                },
+                onSearchTotal: { total in
+                    searchTotal = total
+                },
+                onSearchSelected: { selected in
+                    searchSelected = selected
+                }
+            )
+
+            SurfaceSearchOverlay(
+                isVisible: $searchVisible,
+                searchText: $searchText,
+                totalMatches: $searchTotal,
+                selectedMatch: $searchSelected,
+                onSearch: { query in
+                    guard let view = terminalView else { return }
+                    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()
+                },
+                onPrevious: {
+                    terminalView?.searchBackward()
+                },
+                onClose: {
+                    searchTotal = 0
+                    searchSelected = -1
+                }
+            )
+        }
+        .onReceive(NotificationCenter.default.publisher(for: .remuxTerminalData)) { notification in
+            if let data = notification.userInfo?["data"] as? Data {
+                relay.writeToTerminal(data)
+            }
+        }
+        .onAppear {
+            relay.onDataFromClient = { data in
+                state.sendTerminalData(data)
+            }
+            relay.start()
+        }
+        .onDisappear {
+            relay.stop()
+        }
+    }
+}

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

@@ -0,0 +1,117 @@
+import Foundation
+
+/// Bidirectional relay between a Unix domain socket and the WebSocket connection.
+/// Ghostty spawns `nc -U <socketPath>` as its "shell" process.
+/// Data flow:
+///   Remote PTY → WebSocket → onDataFromServer → socket → nc stdout → ghostty renders
+///   User types → ghostty → nc stdin → socket → onDataFromClient → WebSocket → remote PTY
+@MainActor
+final class TerminalRelay {
+
+    let socketPath: String
+    var onDataFromClient: ((Data) -> Void)?  // user keystrokes → send to WebSocket
+
+    private var serverSocket: Int32 = -1
+    private var clientSocket: Int32 = -1
+    private var readSource: DispatchSourceRead?
+    private let queue = DispatchQueue(label: "remux.terminal-relay")
+
+    init() {
+        socketPath = NSTemporaryDirectory() + "remux-relay-\(ProcessInfo.processInfo.processIdentifier)-\(UUID().uuidString.prefix(8)).sock"
+    }
+
+    deinit {
+        stop()
+    }
+
+    /// Start listening on the Unix socket. Call before creating the ghostty surface.
+    func start() {
+        // Create Unix domain socket
+        serverSocket = socket(AF_UNIX, SOCK_STREAM, 0)
+        guard serverSocket >= 0 else { return }
+
+        // Remove stale socket file
+        unlink(socketPath)
+
+        var addr = sockaddr_un()
+        addr.sun_family = sa_family_t(AF_UNIX)
+        let pathBytes = socketPath.utf8CString
+        pathBytes.withUnsafeBufferPointer { buf in
+            withUnsafeMutableBytes(of: &addr.sun_path) { rawPath in
+                let count = min(buf.count, rawPath.count)
+                rawPath.copyBytes(from: UnsafeRawBufferPointer(buf).prefix(count))
+            }
+        }
+
+        let bindResult = withUnsafePointer(to: &addr) { ptr in
+            ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) { sockPtr in
+                Darwin.bind(serverSocket, sockPtr, socklen_t(MemoryLayout<sockaddr_un>.size))
+            }
+        }
+        guard bindResult == 0 else {
+            close(serverSocket); serverSocket = -1; return
+        }
+
+        listen(serverSocket, 1)
+
+        // Accept connection async (nc will connect when ghostty spawns)
+        let fd = serverSocket
+        queue.async { [weak self] in
+            let client = accept(fd, nil, nil)
+            guard client >= 0 else { return }
+            DispatchQueue.main.async {
+                self?.clientSocket = client
+                self?.startReading()
+            }
+        }
+    }
+
+    /// Write data to the socket → nc → ghostty PTY stdout → rendered on screen.
+    func writeToTerminal(_ data: Data) {
+        guard clientSocket >= 0 else { return }
+        data.withUnsafeBytes { ptr in
+            guard let base = ptr.baseAddress else { return }
+            _ = send(clientSocket, base, ptr.count, 0)
+        }
+    }
+
+    /// Stop the relay and clean up.
+    nonisolated func stop() {
+        MainActor.assumeIsolated {
+            readSource?.cancel()
+            readSource = nil
+            if clientSocket >= 0 { close(clientSocket); clientSocket = -1 }
+            if serverSocket >= 0 { close(serverSocket); serverSocket = -1 }
+            unlink(socketPath)
+        }
+    }
+
+    // MARK: - Private
+
+    private func startReading() {
+        guard clientSocket >= 0 else { return }
+        let source = DispatchSource.makeReadSource(fileDescriptor: clientSocket, queue: queue)
+        source.setEventHandler { [weak self] in
+            guard let self else { return }
+            var buf = [UInt8](repeating: 0, count: 65536)
+            let n = recv(self.clientSocket, &buf, buf.count, 0)
+            if n > 0 {
+                let data = Data(buf[0..<n])
+                DispatchQueue.main.async {
+                    self.onDataFromClient?(data)
+                }
+            } else if n == 0 {
+                // nc disconnected
+                source.cancel()
+            }
+        }
+        source.setCancelHandler { [weak self] in
+            guard let self else { return }
+            DispatchQueue.main.async {
+                self.clientSocket = -1
+            }
+        }
+        source.resume()
+        readSource = source
+    }
+}

package/build.mjs

@@ -0,0 +1,33 @@
+/**
+ * esbuild script — bundles src/ TypeScript modules into output files.
+ * Two entry points:
+ *   1. server.ts → server.js (main server)
+ *   2. pty-daemon.ts → pty-daemon.js (independent PTY daemon process)
+ * Externalizes native/npm dependencies (node-pty, ws, ghostty-web, qrcode-terminal).
+ */
+
+import esbuild from "esbuild";
+
+const commonOptions = {
+  bundle: true,
+  platform: "node",
+  target: "node20",
+  format: "esm",
+  external: ["node-pty", "ws", "ghostty-web", "qrcode-terminal", "better-sqlite3", "web-push", "simple-git"],
+};
+
+// Main server bundle
+esbuild.buildSync({
+  ...commonOptions,
+  entryPoints: ["src/server.ts"],
+  outfile: "server.js",
+  banner: { js: "#!/usr/bin/env node" },
+});
+
+// PTY daemon bundle (independent process)
+esbuild.buildSync({
+  ...commonOptions,
+  entryPoints: ["src/pty-daemon.ts"],
+  outfile: "pty-daemon.js",
+  banner: { js: "#!/usr/bin/env node" },
+});