@wangyaoshen/remux 0.3.8-dev.a8ceb0c

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

@@ -0,0 +1,257 @@
+import AppKit
+import SwiftUI
+import RemuxKit
+
+/// Main application delegate. Manages windows, tray, and global state.
+/// Architecture ref: cmux AppDelegate.swift
+@MainActor
+final class AppDelegate: NSObject, NSApplicationDelegate {
+    private var mainWindow: NSWindow?
+    private var additionalWindows: [NSWindow] = []
+    private var detachedWindows: [UUID: NSWindow] = [:]
+    private var statusItem: NSStatusItem?
+    private var menuBarManager: MenuBarManager?
+    private(set) var notificationManager: NotificationManager?
+    private var socketController: SocketController?
+    private var finderIntegration: FinderIntegration?
+
+    let state = RemuxState()
+
+    func applicationDidFinishLaunching(_ notification: Notification) {
+        // Install crash reporter first
+        CrashReporter.shared.install()
+
+        // Load saved session (if any)
+        let savedSession = SessionPersistence.shared.load()
+
+        setupMainWindow(savedSession: savedSession)
+        setupStatusItem()
+        menuBarManager = MenuBarManager(state: state)
+        notificationManager = NotificationManager()
+        setupGlobalShortcut()
+
+        // Start socket controller for CLI scripting
+        socketController = SocketController(state: state)
+        socketController?.start()
+
+        // Setup Finder integration
+        finderIntegration = FinderIntegration(state: state)
+        finderIntegration?.registerServices()
+
+        // Start autosave
+        SessionPersistence.shared.startAutosave { [weak self] in
+            guard let self else {
+                return AppSession()
+            }
+            return self.buildCurrentSession()
+        }
+
+        // Auto-connect after a brief delay to ensure UI is ready
+        Task {
+            try? await Task.sleep(for: .milliseconds(500))
+            self.autoConnectIfConfigured(savedSession: savedSession)
+        }
+
+        // Check for crash reports from previous launch
+        Task {
+            try? await Task.sleep(for: .seconds(1))
+            CrashReporter.shared.checkForPendingReports()
+        }
+    }
+
+    func applicationWillTerminate(_ notification: Notification) {
+        // Stop socket controller
+        socketController?.stop()
+
+        // Save session on quit (already on @MainActor via class annotation)
+        let session = buildCurrentSession()
+        SessionPersistence.shared.save(session)
+        SessionPersistence.shared.stopAutosave()
+    }
+
+    /// Build the current session state for persistence.
+    private func buildCurrentSession() -> AppSession {
+        var session = AppSession()
+
+        // Server URL
+        if case .connected = state.connectionStatus {
+            session.serverURL = state.serverURL?.absoluteString
+        }
+
+        // Window frame
+        if let frame = mainWindow?.frame {
+            session.windowFrame = CodableRect(rect: frame)
+        }
+
+        // Split layout — for now, save a single leaf; the MainContentView
+        // snapshot would need to be plumbed here for full persistence
+        session.splitLayout = .leaf(tabIndex: state.activeTabIndex)
+        session.sidebarCollapsed = false
+
+        return session
+    }
+
+    /// Auto-connect if REMUX_URL and REMUX_TOKEN environment variables are set,
+    /// or if a saved session has a server URL.
+    private func autoConnectIfConfigured(savedSession: AppSession?) {
+        // Priority 1: Environment variables
+        if let urlStr = ProcessInfo.processInfo.environment["REMUX_URL"],
+           let token = ProcessInfo.processInfo.environment["REMUX_TOKEN"],
+           let url = URL(string: urlStr) {
+            NSLog("[remux] Auto-connecting to %@ (env vars)", urlStr)
+            state.connect(url: url, credential: .token(token))
+            return
+        }
+
+        // Priority 2: Saved session with server URL
+        if let urlStr = savedSession?.serverURL,
+           let _ = URL(string: urlStr) {
+            NSLog("[remux] Saved session has server URL: %@, showing connection UI", urlStr)
+            // Don't auto-connect without credentials — just pre-fill the URL
+        }
+
+        NSLog("[remux] No REMUX_URL/REMUX_TOKEN env vars, showing connection UI")
+    }
+
+    func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool {
+        false // Keep running in tray
+    }
+
+    // MARK: - Main Window
+
+    private func setupMainWindow(savedSession: AppSession? = nil) {
+        let contentView = MainContentView()
+            .environment(state)
+
+        let defaultFrame = NSRect(x: 0, y: 0, width: 1280, height: 800)
+        let windowFrame = savedSession?.windowCGRect ?? defaultFrame
+
+        let window = NSWindow(
+            contentRect: windowFrame,
+            styleMask: [.titled, .closable, .miniaturizable, .resizable],
+            backing: .buffered,
+            defer: false
+        )
+        window.minSize = NSSize(width: 800, height: 500)
+        window.title = "Remux"
+        window.contentView = NSHostingView(rootView: contentView)
+
+        // Restore position or center
+        if savedSession?.windowCGRect != nil {
+            // Position is already set from windowFrame
+        } else {
+            window.center()
+        }
+
+        window.setFrameAutosaveName("RemuxMainWindow")
+        window.makeKeyAndOrderFront(nil)
+
+        mainWindow = window
+    }
+
+    // MARK: - System Tray
+
+    private func setupStatusItem() {
+        statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.squareLength)
+        if let button = statusItem?.button {
+            button.image = NSImage(systemSymbolName: "terminal", accessibilityDescription: "Remux")
+            button.action = #selector(toggleWindow)
+            button.target = self
+        }
+
+        let menu = NSMenu()
+        menu.addItem(NSMenuItem(title: "Show/Hide Window", action: #selector(toggleWindow), keyEquivalent: ""))
+        menu.addItem(NSMenuItem.separator())
+        menu.addItem(NSMenuItem(title: "Quit", action: #selector(NSApplication.terminate), keyEquivalent: "q"))
+        statusItem?.menu = menu
+    }
+
+    // MARK: - Global Shortcut (Cmd+Shift+R)
+
+    private func setupGlobalShortcut() {
+        NSEvent.addGlobalMonitorForEvents(matching: .keyDown) { event in
+            // Cmd+Shift+R
+            if event.modifierFlags.contains([.command, .shift]),
+               event.charactersIgnoringModifiers == "r" {
+                Task { @MainActor in
+                    if let appDelegate = NSApp.delegate as? AppDelegate {
+                        appDelegate.toggleWindow()
+                    }
+                }
+            }
+        }
+    }
+
+    /// Create a new window sharing the same RemuxState connection.
+    func createNewWindow() {
+        let contentView = MainContentView()
+            .environment(state)
+
+        let window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 1280, height: 800),
+            styleMask: [.titled, .closable, .miniaturizable, .resizable],
+            backing: .buffered,
+            defer: false
+        )
+        window.minSize = NSSize(width: 800, height: 500)
+        window.title = "Remux"
+        window.contentView = NSHostingView(rootView: contentView)
+        window.center()
+        window.makeKeyAndOrderFront(nil)
+        additionalWindows.append(window)
+    }
+
+    @objc private func toggleWindow() {
+        if let window = mainWindow {
+            if window.isVisible {
+                window.orderOut(nil)
+            } else {
+                window.makeKeyAndOrderFront(nil)
+                NSApp.activate(ignoringOtherApps: true)
+            }
+        }
+    }
+
+    // MARK: - Window Portal (Detach Pane to Window)
+
+    /// Detach a terminal panel to its own standalone window.
+    /// The panel is displayed in a new NSWindow.
+    func detachPaneToWindow() {
+        let panelID = UUID()
+        let contentView = TerminalContainerView()
+            .environment(state)
+
+        let window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 800, height: 600),
+            styleMask: [.titled, .closable, .miniaturizable, .resizable],
+            backing: .buffered,
+            defer: false
+        )
+        window.minSize = NSSize(width: 400, height: 300)
+        window.title = "Remux (Detached)"
+        window.contentView = NSHostingView(rootView: contentView)
+        window.center()
+        window.makeKeyAndOrderFront(nil)
+
+        detachedWindows[panelID] = window
+
+        // When the window closes, clean up
+        NotificationCenter.default.addObserver(
+            forName: NSWindow.willCloseNotification,
+            object: window,
+            queue: .main
+        ) { [weak self] _ in
+            Task { @MainActor in
+                self?.detachedWindows.removeValue(forKey: panelID)
+            }
+        }
+    }
+
+    /// Close all detached windows and return their panels to the main window.
+    func attachAllBack() {
+        for (_, window) in detachedWindows {
+            window.close()
+        }
+        detachedWindows.removeAll()
+    }
+}

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

@@ -0,0 +1,210 @@
+import AppKit
+import Foundation
+
+/// Lightweight crash reporter: saves crash info to disk and offers to
+/// copy the report on next launch. No external SDK dependency.
+///
+/// Crash files: ~/Library/Application Support/com.remux/crashes/
+///
+/// Adapted from PLCrashReporter conceptual design (without the framework).
+final class CrashReporter: @unchecked Sendable {
+
+    static let shared = CrashReporter()
+
+    private let fileManager = FileManager.default
+
+    private var crashDirectory: URL {
+        let appSupport = fileManager.urls(for: .applicationSupportDirectory, in: .userDomainMask).first!
+        return appSupport
+            .appendingPathComponent("com.remux", isDirectory: true)
+            .appendingPathComponent("crashes", isDirectory: true)
+    }
+
+    private init() {}
+
+    // MARK: - Install handler
+
+    /// Install the uncaught exception handler. Call once at app launch.
+    func install() {
+        // Ensure crash directory exists
+        try? fileManager.createDirectory(at: crashDirectory, withIntermediateDirectories: true)
+
+        NSSetUncaughtExceptionHandler { exception in
+            CrashReporter.shared.handleException(exception)
+        }
+
+        // Also handle POSIX signals for non-exception crashes
+        for sig: Int32 in [SIGABRT, SIGBUS, SIGSEGV, SIGFPE, SIGILL, SIGTRAP] {
+            signal(sig) { signalNumber in
+                CrashReporter.shared.handleSignal(signalNumber)
+            }
+        }
+
+        NSLog("[remux] CrashReporter installed")
+    }
+
+    // MARK: - Check for previous crash
+
+    /// Check if there are unsent crash reports from a previous launch.
+    /// If found, shows an alert offering to copy the report.
+    @MainActor
+    func checkForPendingReports() {
+        let reports = pendingReports()
+        guard let latest = reports.last else { return }
+
+        guard let content = try? String(contentsOf: latest, encoding: .utf8) else { return }
+
+        let alert = NSAlert()
+        alert.messageText = "Remux Crash Report"
+        alert.informativeText = "Remux crashed during the last session. Would you like to copy the crash report to your clipboard?"
+        alert.alertStyle = .warning
+        alert.addButton(withTitle: "Copy to Clipboard")
+        alert.addButton(withTitle: "Dismiss")
+        alert.addButton(withTitle: "Delete All Reports")
+
+        let response = alert.runModal()
+
+        switch response {
+        case .alertFirstButtonReturn:
+            // Copy to clipboard
+            NSPasteboard.general.clearContents()
+            NSPasteboard.general.setString(content, forType: .string)
+            NSLog("[remux] Crash report copied to clipboard")
+            // Mark as sent by renaming
+            let sentURL = latest.deletingPathExtension().appendingPathExtension("sent")
+            try? fileManager.moveItem(at: latest, to: sentURL)
+
+        case .alertThirdButtonReturn:
+            // Delete all reports
+            deleteAllReports()
+
+        default:
+            // Dismiss: rename to .dismissed so we don't ask again
+            let dismissedURL = latest.deletingPathExtension().appendingPathExtension("dismissed")
+            try? fileManager.moveItem(at: latest, to: dismissedURL)
+        }
+    }
+
+    // MARK: - Report listing
+
+    /// List pending (unsent) crash report files.
+    func pendingReports() -> [URL] {
+        guard let files = try? fileManager.contentsOfDirectory(
+            at: crashDirectory,
+            includingPropertiesForKeys: [.creationDateKey],
+            options: .skipsHiddenFiles
+        ) else { return [] }
+
+        return files
+            .filter { $0.pathExtension == "crash" }
+            .sorted { a, b in
+                let aDate = (try? a.resourceValues(forKeys: [.creationDateKey]).creationDate) ?? .distantPast
+                let bDate = (try? b.resourceValues(forKeys: [.creationDateKey]).creationDate) ?? .distantPast
+                return aDate < bDate
+            }
+    }
+
+    /// Delete all crash report files.
+    func deleteAllReports() {
+        guard let files = try? fileManager.contentsOfDirectory(
+            at: crashDirectory,
+            includingPropertiesForKeys: nil,
+            options: .skipsHiddenFiles
+        ) else { return }
+
+        for file in files {
+            try? fileManager.removeItem(at: file)
+        }
+        NSLog("[remux] All crash reports deleted")
+    }
+
+    // MARK: - Crash handling (called from signal/exception handler)
+
+    private func handleException(_ exception: NSException) {
+        let report = buildReport(
+            kind: "NSException",
+            name: exception.name.rawValue,
+            reason: exception.reason ?? "Unknown",
+            stackTrace: exception.callStackSymbols
+        )
+        writeReport(report)
+    }
+
+    private func handleSignal(_ signal: Int32) {
+        let signalName: String
+        switch signal {
+        case SIGABRT: signalName = "SIGABRT"
+        case SIGBUS:  signalName = "SIGBUS"
+        case SIGSEGV: signalName = "SIGSEGV"
+        case SIGFPE:  signalName = "SIGFPE"
+        case SIGILL:  signalName = "SIGILL"
+        case SIGTRAP: signalName = "SIGTRAP"
+        default:      signalName = "SIG\(signal)"
+        }
+
+        // Capture call stack (limited in signal context)
+        var symbols: [String] = []
+        var callstack = [UnsafeMutableRawPointer?](repeating: nil, count: 128)
+        let frames = backtrace(&callstack, Int32(callstack.count))
+        if frames > 0 {
+            if let strs = backtrace_symbols(&callstack, frames) {
+                for i in 0..<Int(frames) {
+                    if let sym = strs[i] {
+                        symbols.append(String(cString: sym))
+                    }
+                }
+                free(strs)
+            }
+        }
+
+        let report = buildReport(
+            kind: "Signal",
+            name: signalName,
+            reason: "Process received \(signalName)",
+            stackTrace: symbols
+        )
+        writeReport(report)
+
+        // Re-raise the signal to get the default behavior (crash)
+        Darwin.signal(signal, SIG_DFL)
+        raise(signal)
+    }
+
+    private func buildReport(kind: String, name: String, reason: String, stackTrace: [String]) -> String {
+        let date = ISO8601DateFormatter().string(from: Date())
+        // Read version from bundle directly (safe from any context)
+        let version = Bundle.main.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String
+            ?? ProcessInfo.processInfo.environment["REMUX_VERSION"]
+            ?? "0.0.0"
+        let os = ProcessInfo.processInfo.operatingSystemVersionString
+
+        var lines = [
+            "Remux Crash Report",
+            "==================",
+            "Date: \(date)",
+            "Version: \(version)",
+            "OS: macOS \(os)",
+            "Type: \(kind)",
+            "Name: \(name)",
+            "Reason: \(reason)",
+            "",
+            "Stack Trace:",
+            "------------",
+        ]
+        lines.append(contentsOf: stackTrace)
+
+        return lines.joined(separator: "\n")
+    }
+
+    private func writeReport(_ report: String) {
+        let timestamp = ISO8601DateFormatter().string(from: Date())
+            .replacingOccurrences(of: ":", with: "-")
+        let filename = "crash-\(timestamp).crash"
+        let fileURL = crashDirectory.appendingPathComponent(filename)
+
+        try? report.write(to: fileURL, atomically: true, encoding: .utf8)
+
+        // Also write to stderr for debugging
+        fputs("[remux] Crash report saved: \(fileURL.path)\n", stderr)
+    }
+}

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

@@ -0,0 +1,117 @@
+import AppKit
+import RemuxKit
+
+/// Finder integration: "Open in Remux" service and external editor launcher.
+/// When invoked from Finder (or via Services menu), creates a new tab with
+/// the selected folder's CWD.
+///
+/// Also provides quick-launch for popular external editors.
+/// Adapted from iTerm2 / Warp Finder integration patterns.
+@MainActor
+final class FinderIntegration: NSObject {
+
+    private weak var state: RemuxState?
+
+    /// External editor definitions.
+    struct ExternalEditor: Identifiable {
+        let id: String
+        let name: String
+        let bundleID: String
+        let icon: String  // SF Symbol
+
+        /// Check if this editor is installed.
+        var isInstalled: Bool {
+            NSWorkspace.shared.urlForApplication(withBundleIdentifier: bundleID) != nil
+        }
+    }
+
+    /// Known external editors.
+    static let editors: [ExternalEditor] = [
+        ExternalEditor(id: "vscode", name: "VS Code", bundleID: "com.microsoft.VSCode", icon: "chevron.left.forwardslash.chevron.right"),
+        ExternalEditor(id: "cursor", name: "Cursor", bundleID: "com.todesktop.230313mzl4w4u92", icon: "cursorarrow.rays"),
+        ExternalEditor(id: "zed", name: "Zed", bundleID: "dev.zed.Zed", icon: "bolt.fill"),
+        ExternalEditor(id: "xcode", name: "Xcode", bundleID: "com.apple.dt.Xcode", icon: "hammer.fill"),
+        ExternalEditor(id: "sublime", name: "Sublime Text", bundleID: "com.sublimetext.4", icon: "text.alignleft"),
+    ]
+
+    init(state: RemuxState) {
+        self.state = state
+        super.init()
+    }
+
+    // MARK: - Open folder in Remux (create tab with CWD)
+
+    /// Handle "Open in Remux" service invocation.
+    /// Sends a new_tab request; the server will create a tab.
+    /// CWD is set by the server based on the default shell profile,
+    /// but we include the path hint in the request.
+    func openFolderInRemux(_ folderPath: String) {
+        guard let state else { return }
+
+        // Send a create-tab request with the folder path as a hint.
+        // The server can use this to set the initial CWD.
+        state.sendJSON([
+            "type": "new_tab",
+            "cwd": folderPath,
+        ])
+
+        // Bring Remux to front
+        NSApp.activate(ignoringOtherApps: true)
+        NSApp.keyWindow?.makeKeyAndOrderFront(nil)
+
+        NSLog("[remux] Open in Remux: %@", folderPath)
+    }
+
+    // MARK: - Open in external editor
+
+    /// Open a file or directory in the specified external editor.
+    static func openInExternalEditor(path: String, editor: ExternalEditor) {
+        guard let appURL = NSWorkspace.shared.urlForApplication(withBundleIdentifier: editor.bundleID) else {
+            NSLog("[remux] Editor not found: %@", editor.name)
+            return
+        }
+
+        let fileURL = URL(fileURLWithPath: path)
+        let config = NSWorkspace.OpenConfiguration()
+        config.activates = true
+
+        NSWorkspace.shared.open(
+            [fileURL],
+            withApplicationAt: appURL,
+            configuration: config
+        ) { _, error in
+            if let error {
+                NSLog("[remux] Failed to open in %@: %@", editor.name, error.localizedDescription)
+            }
+        }
+    }
+
+    /// Get list of installed editors (for building menu).
+    static var installedEditors: [ExternalEditor] {
+        editors.filter { $0.isInstalled }
+    }
+
+    // MARK: - NSServices provider
+
+    /// Register as services provider. Call from AppDelegate.
+    /// For full Finder integration, the app's Info.plist needs NSServices entries.
+    func registerServices() {
+        NSApp.servicesProvider = self
+    }
+
+    /// Handle the "Open in Remux" service invocation from Finder.
+    @objc func openInRemux(_ pboard: NSPasteboard, userData: String, error: AutoreleasingUnsafeMutablePointer<NSString>) {
+        guard let urls = pboard.readObjects(forClasses: [NSURL.self], options: [
+            .urlReadingFileURLsOnly: true,
+        ]) as? [URL] else { return }
+
+        for url in urls {
+            if url.hasDirectoryPath {
+                openFolderInRemux(url.path)
+            } else {
+                // For files, open the parent directory
+                openFolderInRemux(url.deletingLastPathComponent().path)
+            }
+        }
+    }
+}