@wangyaoshen/remux 0.3.8-dev.29e114b

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

@@ -0,0 +1,151 @@
+import Foundation
+import AppKit
+
+/// Detects SSH connection patterns in terminal text.
+/// When detected: enables "Upload File" button in toolbar.
+/// Upload uses a command sent to the terminal (scp local remote).
+///
+/// Adapted from Warp SSH detection / Termius file transfer UX.
+@MainActor
+@Observable
+final class SSHDetector {
+
+    /// Detected SSH connection info.
+    struct SSHConnection: Identifiable, Equatable, Sendable {
+        let id: UUID
+        let user: String
+        let host: String
+        let port: Int?
+        let detectedAt: Date
+
+        /// SCP destination prefix, e.g. "user@host:"
+        var scpPrefix: String {
+            if let port {
+                return "-P \(port) \(user)@\(host):"
+            }
+            return "\(user)@\(host):"
+        }
+
+        var displayString: String {
+            if let port {
+                return "\(user)@\(host):\(port)"
+            }
+            return "\(user)@\(host)"
+        }
+
+        init(user: String, host: String, port: Int? = nil) {
+            self.id = UUID()
+            self.user = user
+            self.host = host
+            self.port = port
+            self.detectedAt = Date()
+        }
+    }
+
+    /// Currently detected SSH connections.
+    private(set) var connections: [SSHConnection] = []
+
+    /// Whether any SSH connection is active.
+    var hasActiveConnection: Bool {
+        !connections.isEmpty
+    }
+
+    /// The most recent SSH connection.
+    var latestConnection: SSHConnection? {
+        connections.last
+    }
+
+    // MARK: - Detection patterns
+
+    /// SSH command patterns to detect.
+    /// Matches: ssh user@host, ssh -p port user@host, ssh host
+    private static let sshPatterns: [(pattern: String, userGroup: Int, hostGroup: Int, portGroup: Int?)] = [
+        // ssh -p PORT user@host
+        ("ssh\\s+-p\\s+(\\d+)\\s+(\\w+)@([\\w\\.-]+)", 2, 3, 1),
+        // ssh user@host -p PORT
+        ("ssh\\s+(\\w+)@([\\w\\.-]+)\\s+-p\\s+(\\d+)", 1, 2, 3),
+        // ssh user@host
+        ("ssh\\s+(\\w+)@([\\w\\.-]+)", 1, 2, nil),
+    ]
+
+    /// SCP command patterns.
+    private static let scpPatterns: [String] = [
+        "scp\\s+.*?(\\w+)@([\\w\\.-]+):",
+        "scp\\s+-P\\s+(\\d+)\\s+.*?(\\w+)@([\\w\\.-]+):",
+    ]
+
+    // MARK: - Parse terminal text
+
+    /// Parse terminal text for SSH connection patterns.
+    func parseTerminalOutput(_ text: String) {
+        for (pattern, userGroup, hostGroup, portGroup) in Self.sshPatterns {
+            guard let regex = try? NSRegularExpression(pattern: pattern) else { continue }
+            let matches = regex.matches(in: text, range: NSRange(text.startIndex..., in: text))
+
+            for match in matches {
+                guard let userRange = Range(match.range(at: userGroup), in: text),
+                      let hostRange = Range(match.range(at: hostGroup), in: text) else {
+                    continue
+                }
+
+                let user = String(text[userRange])
+                let host = String(text[hostRange])
+
+                var port: Int?
+                if let pg = portGroup, let portRange = Range(match.range(at: pg), in: text) {
+                    port = Int(text[portRange])
+                }
+
+                addConnection(user: user, host: host, port: port)
+            }
+        }
+    }
+
+    /// Add a connection if not already tracked.
+    private func addConnection(user: String, host: String, port: Int?) {
+        let exists = connections.contains { c in
+            c.user == user && c.host == host && c.port == port
+        }
+        guard !exists else { return }
+
+        let conn = SSHConnection(user: user, host: host, port: port)
+        connections.append(conn)
+        NSLog("[remux] SSH detected: %@", conn.displayString)
+    }
+
+    /// Clear all detected connections.
+    func clearAll() {
+        connections.removeAll()
+    }
+
+    /// Remove a specific connection.
+    func remove(_ connection: SSHConnection) {
+        connections.removeAll { $0.id == connection.id }
+    }
+
+    // MARK: - File upload via SCP
+
+    /// Build an SCP command to upload a local file to the remote host.
+    /// Returns the command string to be typed into the terminal.
+    func buildUploadCommand(localPath: String, remotePath: String = "~", connection: SSHConnection? = nil) -> String? {
+        guard let conn = connection ?? latestConnection else { return nil }
+
+        let escapedLocal = localPath.replacingOccurrences(of: " ", with: "\\ ")
+
+        if let port = conn.port {
+            return "scp -P \(port) \(escapedLocal) \(conn.user)@\(conn.host):\(remotePath)"
+        }
+        return "scp \(escapedLocal) \(conn.user)@\(conn.host):\(remotePath)"
+    }
+
+    /// Show file picker and return selected file path.
+    func pickFileForUpload() -> URL? {
+        let panel = NSOpenPanel()
+        panel.allowsMultipleSelection = false
+        panel.canChooseDirectories = false
+        panel.canChooseFiles = true
+
+        guard panel.runModal() == .OK else { return nil }
+        return panel.url
+    }
+}

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

@@ -0,0 +1,226 @@
+import Foundation
+
+// MARK: - Data Models
+
+/// Snapshot of the entire app session for persistence.
+struct AppSession: Codable, Sendable {
+    var version: Int = 1
+    var serverURL: String?
+    var windowFrame: CodableRect?
+    var splitLayout: SplitNodeSnapshot
+    var sidebarCollapsed: Bool
+
+    init(
+        serverURL: String? = nil,
+        windowFrame: CGRect? = nil,
+        splitLayout: SplitNodeSnapshot = .leaf(tabIndex: 0),
+        sidebarCollapsed: Bool = false
+    ) {
+        self.serverURL = serverURL
+        self.windowFrame = windowFrame.map { CodableRect(rect: $0) }
+        self.splitLayout = splitLayout
+        self.sidebarCollapsed = sidebarCollapsed
+    }
+
+    var windowCGRect: CGRect? {
+        windowFrame?.cgRect
+    }
+}
+
+/// Codable wrapper for CGRect since CGRect's Codable is not reliable across platforms.
+struct CodableRect: Codable, Sendable {
+    var x: Double
+    var y: Double
+    var width: Double
+    var height: Double
+
+    init(rect: CGRect) {
+        self.x = rect.origin.x
+        self.y = rect.origin.y
+        self.width = rect.size.width
+        self.height = rect.size.height
+    }
+
+    var cgRect: CGRect {
+        CGRect(x: x, y: y, width: width, height: height)
+    }
+}
+
+/// Serializable snapshot of the split tree layout.
+indirect enum SplitNodeSnapshot: Codable, Sendable, Hashable {
+    case leaf(tabIndex: Int)
+    case branch(orientation: String, ratio: Double, first: SplitNodeSnapshot, second: SplitNodeSnapshot)
+
+    // Custom Codable implementation for indirect enum
+    private enum CodingKeys: String, CodingKey {
+        case type, tabIndex, orientation, ratio, first, second
+    }
+
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        switch self {
+        case .leaf(let tabIndex):
+            try container.encode("leaf", forKey: .type)
+            try container.encode(tabIndex, forKey: .tabIndex)
+        case .branch(let orientation, let ratio, let first, let second):
+            try container.encode("branch", forKey: .type)
+            try container.encode(orientation, forKey: .orientation)
+            try container.encode(ratio, forKey: .ratio)
+            try container.encode(first, forKey: .first)
+            try container.encode(second, forKey: .second)
+        }
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let type = try container.decode(String.self, forKey: .type)
+        switch type {
+        case "leaf":
+            let tabIndex = try container.decode(Int.self, forKey: .tabIndex)
+            self = .leaf(tabIndex: tabIndex)
+        case "branch":
+            let orientation = try container.decode(String.self, forKey: .orientation)
+            let ratio = try container.decode(Double.self, forKey: .ratio)
+            let first = try container.decode(SplitNodeSnapshot.self, forKey: .first)
+            let second = try container.decode(SplitNodeSnapshot.self, forKey: .second)
+            self = .branch(orientation: orientation, ratio: ratio, first: first, second: second)
+        default:
+            throw DecodingError.dataCorruptedError(
+                forKey: .type,
+                in: container,
+                debugDescription: "Unknown SplitNodeSnapshot type: \(type)"
+            )
+        }
+    }
+}
+
+// MARK: - SplitNode <-> Snapshot Conversion
+
+extension SplitNode {
+    /// Convert a live SplitNode tree to a serializable snapshot.
+    func toSnapshot() -> SplitNodeSnapshot {
+        switch self {
+        case .leaf(let data):
+            return .leaf(tabIndex: data.tabIndex)
+        case .branch(let data):
+            return .branch(
+                orientation: data.orientation.rawValue,
+                ratio: Double(data.ratio),
+                first: data.first.toSnapshot(),
+                second: data.second.toSnapshot()
+            )
+        }
+    }
+
+    /// Reconstruct a SplitNode tree from a snapshot.
+    static func fromSnapshot(_ snapshot: SplitNodeSnapshot) -> SplitNode {
+        switch snapshot {
+        case .leaf(let tabIndex):
+            return .leaf(LeafData(tabIndex: tabIndex))
+        case .branch(let orientation, let ratio, let first, let second):
+            let orient: Orientation = orientation == "horizontal" ? .horizontal : .vertical
+            return .branch(BranchData(
+                orientation: orient,
+                ratio: CGFloat(ratio),
+                first: fromSnapshot(first),
+                second: fromSnapshot(second)
+            ))
+        }
+    }
+}
+
+// MARK: - Persistence Manager
+
+/// Manages reading and writing the app session to disk.
+/// File location: ~/Library/Application Support/com.remux/session.json
+final class SessionPersistence: @unchecked Sendable {
+
+    static let shared = SessionPersistence()
+
+    private let fileManager = FileManager.default
+    nonisolated(unsafe) private var autosaveTimer: Timer?
+    nonisolated(unsafe) private var lastSavedHash: Int = 0
+
+    private var sessionDirectory: URL {
+        let appSupport = fileManager.urls(for: .applicationSupportDirectory, in: .userDomainMask).first!
+        return appSupport.appendingPathComponent("com.remux", isDirectory: true)
+    }
+
+    private var sessionFilePath: URL {
+        sessionDirectory.appendingPathComponent("session.json")
+    }
+
+    private init() {}
+
+    // MARK: - Save
+
+    /// Save the app session to disk.
+    @MainActor
+    func save(_ session: AppSession) {
+        do {
+            // Ensure directory exists
+            try fileManager.createDirectory(at: sessionDirectory, withIntermediateDirectories: true)
+
+            let encoder = JSONEncoder()
+            encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
+            let data = try encoder.encode(session)
+
+            // Skip write if unchanged
+            let hash = data.hashValue
+            if hash == lastSavedHash { return }
+            lastSavedHash = hash
+
+            try data.write(to: sessionFilePath, options: .atomic)
+            NSLog("[remux] Session saved to %@", sessionFilePath.path)
+        } catch {
+            NSLog("[remux] Failed to save session: %@", error.localizedDescription)
+        }
+    }
+
+    // MARK: - Load
+
+    /// Load the app session from disk. Returns nil if no saved session exists.
+    @MainActor
+    func load() -> AppSession? {
+        guard fileManager.fileExists(atPath: sessionFilePath.path) else {
+            NSLog("[remux] No saved session found at %@", sessionFilePath.path)
+            return nil
+        }
+
+        do {
+            let data = try Data(contentsOf: sessionFilePath)
+            let decoder = JSONDecoder()
+            let session = try decoder.decode(AppSession.self, from: data)
+            lastSavedHash = data.hashValue
+            NSLog("[remux] Session loaded from %@", sessionFilePath.path)
+            return session
+        } catch {
+            NSLog("[remux] Failed to load session: %@", error.localizedDescription)
+            return nil
+        }
+    }
+
+    // MARK: - Autosave
+
+    /// Start the autosave timer. The closure is called every 8 seconds to
+    /// get the current session state.
+    @MainActor
+    func startAutosave(sessionProvider: @escaping @MainActor () -> AppSession) {
+        stopAutosave()
+        autosaveTimer = Timer.scheduledTimer(withTimeInterval: 8.0, repeats: true) { [weak self] _ in
+            Task { @MainActor in
+                guard let self else { return }
+                let session = sessionProvider()
+                self.save(session)
+            }
+        }
+        NSLog("[remux] Autosave started (8s interval)")
+    }
+
+    /// Stop the autosave timer.
+    @MainActor
+    func stopAutosave() {
+        autosaveTimer?.invalidate()
+        autosaveTimer = nil
+    }
+}

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

@@ -0,0 +1,258 @@
+import Foundation
+import RemuxKit
+
+/// Unix socket control API for scriptable automation.
+/// Listens on ~/Library/Application Support/com.remux/remux.sock
+/// Protocol: JSON-RPC — request: {"method": "...", "params": {...}, "id": 1}
+///                       response: {"result": {...}, "id": 1} or {"error": "...", "id": 1}
+///
+/// Supported methods: list_tabs, create_tab, close_tab, write_input,
+///                    get_state, list_sessions, switch_tab
+///
+/// Adapted from tmux control-mode / neovim --listen socket API patterns.
+final class SocketController: @unchecked Sendable {
+
+    private let socketPath: String
+    private var serverFD: Int32 = -1
+    private var isRunning = false
+    private let queue = DispatchQueue(label: "remux.socket-controller")
+    private weak var state: RemuxState?
+
+    init(state: RemuxState) {
+        self.state = state
+
+        let appSupport = FileManager.default.urls(
+            for: .applicationSupportDirectory, in: .userDomainMask
+        ).first!
+        let dir = appSupport.appendingPathComponent("com.remux", isDirectory: true)
+        try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+        socketPath = dir.appendingPathComponent("remux.sock").path
+    }
+
+    /// Start listening on the Unix socket.
+    func start() {
+        guard !isRunning else { return }
+        isRunning = true
+
+        // Remove stale socket
+        unlink(socketPath)
+
+        serverFD = socket(AF_UNIX, SOCK_STREAM, 0)
+        guard serverFD >= 0 else {
+            NSLog("[remux] SocketController: failed to create socket")
+            isRunning = false
+            return
+        }
+
+        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(serverFD, sockPtr, socklen_t(MemoryLayout<sockaddr_un>.size))
+            }
+        }
+
+        guard bindResult == 0 else {
+            NSLog("[remux] SocketController: bind failed: %d", errno)
+            close(serverFD)
+            serverFD = -1
+            isRunning = false
+            return
+        }
+
+        listen(serverFD, 1)
+        NSLog("[remux] SocketController: listening on %@", socketPath)
+
+        queue.async { [weak self] in
+            self?.acceptLoop()
+        }
+    }
+
+    /// Stop the socket controller and clean up.
+    func stop() {
+        isRunning = false
+        if serverFD >= 0 {
+            close(serverFD)
+            serverFD = -1
+        }
+        unlink(socketPath)
+        NSLog("[remux] SocketController: stopped")
+    }
+
+    // MARK: - Accept loop
+
+    private func acceptLoop() {
+        while isRunning {
+            let clientFD = accept(serverFD, nil, nil)
+            guard clientFD >= 0 else {
+                if isRunning { NSLog("[remux] SocketController: accept failed") }
+                break
+            }
+            handleClient(fd: clientFD)
+            close(clientFD)
+        }
+    }
+
+    // MARK: - Client handling
+
+    /// Thread-safe result container using a class marked @unchecked Sendable.
+    private final class RPCResultBox: @unchecked Sendable {
+        var resultJSON: String?
+        var errorMsg: String?
+    }
+
+    private func handleClient(fd: Int32) {
+        var buffer = [UInt8](repeating: 0, count: 65536)
+        let n = recv(fd, &buffer, buffer.count, 0)
+        guard n > 0 else { return }
+
+        let data = Data(buffer[0..<n])
+        guard let _ = String(data: data, encoding: .utf8),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            sendResponse(fd: fd, error: "Invalid JSON", id: nil)
+            return
+        }
+
+        let method = json["method"] as? String ?? ""
+        let requestID = json["id"]
+
+        // Extract params as Sendable strings before crossing isolation boundary
+        let tabIDParam = (json["params"] as? [String: Any])?["tabId"] as? String
+        let textParam = (json["params"] as? [String: Any])?["text"] as? String
+        let indexParam = (json["params"] as? [String: Any])?["index"] as? Int
+
+        let sem = DispatchSemaphore(value: 0)
+        let box = RPCResultBox()
+
+        DispatchQueue.main.async { [weak self, box] in
+            defer { sem.signal() }
+            guard let self, let state = self.state else {
+                box.errorMsg = "State unavailable"
+                return
+            }
+
+            switch method {
+            case "list_tabs":
+                let tabs: [[String: Any]] = state.tabs.map { tab in
+                    [
+                        "index": tab.index,
+                        "name": tab.name,
+                        "active": tab.active,
+                        "paneCount": tab.panes.count,
+                    ]
+                }
+                let dict: [String: Any] = ["tabs": tabs]
+                if let d = try? JSONSerialization.data(withJSONObject: dict),
+                   let s = String(data: d, encoding: .utf8) {
+                    box.resultJSON = s
+                }
+
+            case "create_tab":
+                state.createTab()
+                box.resultJSON = "{\"ok\":true}"
+
+            case "close_tab":
+                if let tabID = tabIDParam {
+                    state.closeTab(id: tabID)
+                    box.resultJSON = "{\"ok\":true}"
+                } else {
+                    box.errorMsg = "Missing tabId parameter"
+                }
+
+            case "write_input":
+                if let text = textParam {
+                    state.sendTerminalInput(text)
+                    box.resultJSON = "{\"ok\":true}"
+                } else {
+                    box.errorMsg = "Missing text parameter"
+                }
+
+            case "get_state":
+                let dict: [String: Any] = [
+                    "session": state.currentSession,
+                    "activeTabIndex": state.activeTabIndex,
+                    "tabCount": state.tabs.count,
+                    "role": state.clientRole,
+                    "connected": state.connectionStatus == .connected,
+                ]
+                if let d = try? JSONSerialization.data(withJSONObject: dict),
+                   let s = String(data: d, encoding: .utf8) {
+                    box.resultJSON = s
+                }
+
+            case "list_sessions":
+                let dict: [String: Any] = ["session": state.currentSession]
+                if let d = try? JSONSerialization.data(withJSONObject: dict),
+                   let s = String(data: d, encoding: .utf8) {
+                    box.resultJSON = s
+                }
+
+            case "switch_tab":
+                if let tabID = tabIDParam {
+                    state.switchTab(id: tabID)
+                    box.resultJSON = "{\"ok\":true}"
+                } else if let index = indexParam,
+                          index < state.tabs.count,
+                          let pane = state.tabs[index].panes.first {
+                    state.switchTab(id: pane.id)
+                    box.resultJSON = "{\"ok\":true}"
+                } else {
+                    box.errorMsg = "Missing or invalid tabId/index parameter"
+                }
+
+            default:
+                box.errorMsg = "Unknown method: \(method)"
+            }
+        }
+
+        sem.wait()
+
+        if let error = box.errorMsg {
+            sendResponse(fd: fd, error: error, id: requestID)
+        } else {
+            sendResponseRaw(fd: fd, json: box.resultJSON ?? "{\"ok\":true}", id: requestID)
+        }
+    }
+
+    // MARK: - Response helpers
+
+    private func sendResponse(fd: Int32, error: String, id: Any?) {
+        var dict: [String: Any] = ["error": error]
+        if let id { dict["id"] = id }
+        guard let data = try? JSONSerialization.data(withJSONObject: dict),
+              var response = String(data: data, encoding: .utf8) else { return }
+        response += "\n"
+        response.withCString { ptr in
+            _ = send(fd, ptr, strlen(ptr), 0)
+        }
+    }
+
+    private func sendResponseRaw(fd: Int32, json: String, id: Any?) {
+        // Wrap the pre-serialized JSON result into a response envelope
+        var response: String
+        if let id {
+            let idStr: String
+            if let intID = id as? Int {
+                idStr = "\(intID)"
+            } else if let strID = id as? String {
+                idStr = "\"\(strID)\""
+            } else {
+                idStr = "null"
+            }
+            response = "{\"result\":\(json),\"id\":\(idStr)}\n"
+        } else {
+            response = "{\"result\":\(json)}\n"
+        }
+        response.withCString { ptr in
+            _ = send(fd, ptr, strlen(ptr), 0)
+        }
+    }
+}