@wangyaoshen/remux 0.3.8-dev.a8ceb0c

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

@@ -0,0 +1,152 @@
+import AppKit
+
+/// Lightweight update checker that polls GitHub releases API.
+/// Adapted from Sparkle's conceptual model but without the framework dependency.
+@MainActor
+@Observable
+final class UpdateChecker {
+
+    // MARK: - Published state
+
+    private(set) var latestVersion: String?
+    private(set) var releaseURL: String?
+    private(set) var releaseNotes: String?
+    private(set) var hasUpdate: Bool = false
+
+    // MARK: - Config
+
+    /// GitHub API endpoint for latest release.
+    static let apiURL = "https://api.github.com/repos/yaoshenwang/remux/releases/latest"
+
+    /// Check interval: 4 hours.
+    private let checkInterval: TimeInterval = 4 * 60 * 60
+
+    /// UserDefaults key for dismissed version.
+    private static let dismissedVersionKey = "UpdateChecker.dismissedVersion"
+
+    // MARK: - Internal state
+
+    private var timer: Timer?
+    private var isChecking = false
+
+    init() {}
+
+    // MARK: - Public API
+
+    /// Start the update checker: check immediately, then every 4 hours.
+    func start() {
+        Task { await check() }
+        timer = Timer.scheduledTimer(withTimeInterval: checkInterval, repeats: true) { [weak self] _ in
+            Task { @MainActor [weak self] in
+                await self?.check()
+            }
+        }
+    }
+
+    /// Stop the periodic check timer.
+    func stop() {
+        timer?.invalidate()
+        timer = nil
+    }
+
+    /// Dismiss the current update notification (suppress until a newer version appears).
+    func dismissCurrentUpdate() {
+        guard let version = latestVersion else { return }
+        UserDefaults.standard.set(version, forKey: Self.dismissedVersionKey)
+        hasUpdate = false
+    }
+
+    /// Open the release page in the default browser.
+    func openReleasePage() {
+        guard let urlStr = releaseURL, let url = URL(string: urlStr) else {
+            // Fallback to releases page
+            if let url = URL(string: "https://github.com/yaoshenwang/remux/releases") {
+                NSWorkspace.shared.open(url)
+            }
+            return
+        }
+        NSWorkspace.shared.open(url)
+    }
+
+    /// Force a manual check (ignores dismissed version).
+    func checkNow() async {
+        await check(ignoreDismissed: true)
+    }
+
+    // MARK: - Check logic
+
+    private func check(ignoreDismissed: Bool = false) async {
+        guard !isChecking else { return }
+        isChecking = true
+        defer { isChecking = false }
+
+        guard let url = URL(string: Self.apiURL) else { return }
+
+        do {
+            var request = URLRequest(url: url)
+            request.setValue("application/vnd.github+json", forHTTPHeaderField: "Accept")
+            request.timeoutInterval = 15
+
+            let (data, response) = try await URLSession.shared.data(for: request)
+
+            guard let httpResponse = response as? HTTPURLResponse,
+                  httpResponse.statusCode == 200 else {
+                NSLog("[remux] Update check: non-200 response")
+                return
+            }
+
+            guard let json = try JSONSerialization.jsonObject(with: data) as? [String: Any],
+                  let tagName = json["tag_name"] as? String else {
+                NSLog("[remux] Update check: failed to parse response")
+                return
+            }
+
+            let remoteVersion = tagName.hasPrefix("v") ? String(tagName.dropFirst()) : tagName
+            let htmlURL = json["html_url"] as? String
+            let body = json["body"] as? String
+
+            latestVersion = remoteVersion
+            releaseURL = htmlURL
+            releaseNotes = body
+
+            let currentVersion = Self.currentBundleVersion()
+            let isNewer = Self.isVersion(remoteVersion, newerThan: currentVersion)
+
+            // Check if this version was dismissed
+            let dismissedVersion = UserDefaults.standard.string(forKey: Self.dismissedVersionKey)
+            let isDismissed = !ignoreDismissed && dismissedVersion == remoteVersion
+
+            hasUpdate = isNewer && !isDismissed
+
+            if hasUpdate {
+                NSLog("[remux] Update available: %@ -> %@", currentVersion, remoteVersion)
+            }
+        } catch {
+            NSLog("[remux] Update check failed: %@", error.localizedDescription)
+        }
+    }
+
+    // MARK: - Version comparison
+
+    /// Get the current app version from the bundle, or a fallback.
+    static func currentBundleVersion() -> String {
+        Bundle.main.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String
+            ?? ProcessInfo.processInfo.environment["REMUX_VERSION"]
+            ?? "0.0.0"
+    }
+
+    /// Compare semantic version strings. Returns true if `a` is newer than `b`.
+    static func isVersion(_ a: String, newerThan b: String) -> Bool {
+        let aParts = a.split(separator: ".").compactMap { Int($0) }
+        let bParts = b.split(separator: ".").compactMap { Int($0) }
+
+        let maxLen = max(aParts.count, bParts.count)
+        for i in 0..<maxLen {
+            let aVal = i < aParts.count ? aParts[i] : 0
+            let bVal = i < bParts.count ? bParts[i] : 0
+            if aVal > bVal { return true }
+            if aVal < bVal { return false }
+        }
+        return false
+    }
+}

package/apps/macos/Sources/Remux/Views/CommandPalette.swift

@@ -0,0 +1,198 @@
+import SwiftUI
+import AppKit
+
+/// Command entry for the palette. Each command has a display name,
+/// optional shortcut string, and an action closure.
+struct PaletteCommand: Identifiable {
+    let id: String
+    let name: String
+    let shortcut: String
+    let category: String
+    let action: @MainActor () -> Void
+}
+
+/// Modal command palette overlay triggered by Cmd+Shift+P.
+/// Provides fuzzy search over all available commands.
+/// Adapted from VS Code / Warp command palette UX pattern.
+struct CommandPalette: View {
+    @Binding var isPresented: Bool
+    let commands: [PaletteCommand]
+
+    @State private var query: String = ""
+    @State private var selectedIndex: Int = 0
+    @FocusState private var isFocused: Bool
+
+    private var filteredCommands: [PaletteCommand] {
+        if query.isEmpty { return commands }
+        let q = query.lowercased()
+        return commands.filter { cmd in
+            fuzzyMatch(query: q, target: cmd.name.lowercased())
+        }
+    }
+
+    var body: some View {
+        if isPresented {
+            ZStack {
+                // Dismiss backdrop
+                Color.black.opacity(0.3)
+                    .ignoresSafeArea()
+                    .onTapGesture { dismiss() }
+
+                VStack(spacing: 0) {
+                    // Search field
+                    HStack(spacing: 8) {
+                        Image(systemName: "magnifyingglass")
+                            .foregroundStyle(.secondary)
+                            .font(.system(size: 14))
+
+                        TextField("Type a command...", text: $query)
+                            .textFieldStyle(.plain)
+                            .font(.system(size: 14))
+                            .focused($isFocused)
+                            .onSubmit { executeSelected() }
+                            .onChange(of: query) { _, _ in
+                                selectedIndex = 0
+                            }
+                    }
+                    .padding(.horizontal, 14)
+                    .padding(.vertical, 10)
+
+                    Divider()
+
+                    // Command list
+                    ScrollViewReader { proxy in
+                        ScrollView {
+                            LazyVStack(spacing: 0) {
+                                let filtered = filteredCommands
+                                ForEach(Array(filtered.enumerated()), id: \.element.id) { idx, cmd in
+                                    CommandRow(
+                                        command: cmd,
+                                        isSelected: idx == selectedIndex
+                                    )
+                                    .id(idx)
+                                    .onTapGesture {
+                                        selectedIndex = idx
+                                        executeSelected()
+                                    }
+                                    .onHover { hovering in
+                                        if hovering { selectedIndex = idx }
+                                    }
+                                }
+
+                                if filtered.isEmpty {
+                                    Text("No matching commands")
+                                        .foregroundStyle(.secondary)
+                                        .font(.system(size: 13))
+                                        .padding(.vertical, 20)
+                                }
+                            }
+                        }
+                        .frame(maxHeight: 300)
+                        .onChange(of: selectedIndex) { _, newValue in
+                            proxy.scrollTo(newValue, anchor: .center)
+                        }
+                    }
+                }
+                .background(.regularMaterial, in: RoundedRectangle(cornerRadius: 10))
+                .overlay(
+                    RoundedRectangle(cornerRadius: 10)
+                        .stroke(Color.primary.opacity(0.1), lineWidth: 1)
+                )
+                .shadow(color: .black.opacity(0.25), radius: 20, y: 10)
+                .frame(width: 500)
+                .frame(maxHeight: 380)
+                .offset(y: -80)
+            }
+            .onAppear {
+                query = ""
+                selectedIndex = 0
+                isFocused = true
+            }
+            .onKeyPress(.upArrow) {
+                moveSelection(by: -1)
+                return .handled
+            }
+            .onKeyPress(.downArrow) {
+                moveSelection(by: 1)
+                return .handled
+            }
+            .onKeyPress(.escape) {
+                dismiss()
+                return .handled
+            }
+            .onKeyPress(.return) {
+                executeSelected()
+                return .handled
+            }
+        }
+    }
+
+    private func moveSelection(by delta: Int) {
+        let count = filteredCommands.count
+        guard count > 0 else { return }
+        selectedIndex = (selectedIndex + delta + count) % count
+    }
+
+    private func executeSelected() {
+        let filtered = filteredCommands
+        guard selectedIndex >= 0, selectedIndex < filtered.count else { return }
+        let cmd = filtered[selectedIndex]
+        dismiss()
+        cmd.action()
+    }
+
+    private func dismiss() {
+        isPresented = false
+        query = ""
+    }
+
+    /// Simple fuzzy match: all characters in query appear in order in target.
+    private func fuzzyMatch(query: String, target: String) -> Bool {
+        var targetIdx = target.startIndex
+        for qChar in query {
+            guard let found = target[targetIdx...].firstIndex(of: qChar) else {
+                return false
+            }
+            targetIdx = target.index(after: found)
+        }
+        return true
+    }
+}
+
+/// Single command row in the palette.
+struct CommandRow: View {
+    let command: PaletteCommand
+    let isSelected: Bool
+
+    var body: some View {
+        HStack {
+            VStack(alignment: .leading, spacing: 1) {
+                Text(command.name)
+                    .font(.system(size: 13))
+                    .foregroundStyle(isSelected ? .primary : .primary)
+
+                Text(command.category)
+                    .font(.system(size: 10))
+                    .foregroundStyle(.secondary)
+            }
+
+            Spacer()
+
+            if !command.shortcut.isEmpty {
+                Text(command.shortcut)
+                    .font(.system(size: 11, design: .monospaced))
+                    .foregroundStyle(.secondary)
+                    .padding(.horizontal, 6)
+                    .padding(.vertical, 2)
+                    .background(
+                        RoundedRectangle(cornerRadius: 4)
+                            .fill(Color.primary.opacity(0.06))
+                    )
+            }
+        }
+        .padding(.horizontal, 14)
+        .padding(.vertical, 6)
+        .background(isSelected ? Color.accentColor.opacity(0.15) : Color.clear)
+        .contentShape(Rectangle())
+    }
+}

package/apps/macos/Sources/Remux/Views/ConnectionView.swift

@@ -0,0 +1,84 @@
+import SwiftUI
+import RemuxKit
+
+/// Connection setup view — shown when not connected.
+struct ConnectionView: View {
+    @Environment(RemuxState.self) private var state
+    @State private var serverURL = ""
+    @State private var token = ""
+    @State private var errorMessage: String?
+
+    private let keychain = KeychainStore()
+
+    var body: some View {
+        VStack(spacing: 20) {
+            Image(systemName: "terminal")
+                .font(.system(size: 48))
+                .foregroundStyle(.secondary)
+
+            Text("Connect to Remux Server")
+                .font(.title2)
+
+            VStack(alignment: .leading, spacing: 12) {
+                TextField("Server URL (e.g. http://localhost:8767)", text: $serverURL)
+                    .textFieldStyle(.roundedBorder)
+
+                SecureField("Token", text: $token)
+                    .textFieldStyle(.roundedBorder)
+
+                if let error = errorMessage {
+                    Text(error)
+                        .foregroundStyle(.red)
+                        .font(.caption)
+                }
+            }
+            .frame(maxWidth: 400)
+
+            Button("Connect") {
+                connect()
+            }
+            .buttonStyle(.borderedProminent)
+            .disabled(serverURL.isEmpty || token.isEmpty)
+
+            // Saved servers
+            let savedServers = keychain.savedServers()
+            if !savedServers.isEmpty {
+                Divider()
+                Text("Recent Servers")
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+
+                ForEach(savedServers, id: \.self) { server in
+                    Button(server) {
+                        serverURL = server
+                        if let savedToken = keychain.loadServerToken(forServer: server) {
+                            token = savedToken
+                            connect()
+                        } else if let resumeToken = keychain.loadResumeToken(forServer: server) {
+                            connectWithResumeToken(server: server, resumeToken: resumeToken)
+                        }
+                    }
+                    .buttonStyle(.plain)
+                    .foregroundStyle(.blue)
+                }
+            }
+        }
+        .padding(40)
+        .frame(maxWidth: .infinity, maxHeight: .infinity)
+    }
+
+    private func connect() {
+        guard let url = URL(string: serverURL) else {
+            errorMessage = "Invalid URL"
+            return
+        }
+        errorMessage = nil
+        try? keychain.saveServerToken(token, forServer: serverURL)
+        state.connect(url: url, credential: .token(token))
+    }
+
+    private func connectWithResumeToken(server: String, resumeToken: String) {
+        guard let url = URL(string: server) else { return }
+        state.connect(url: url, credential: .resumeToken(resumeToken))
+    }
+}

package/apps/macos/Sources/Remux/Views/InspectView.swift

@@ -0,0 +1,127 @@
+import SwiftUI
+import RemuxKit
+
+/// Inspect panel showing readable terminal content.
+/// Toggleable via Cmd+I or View menu.
+struct InspectView: View {
+    @Environment(RemuxState.self) private var state
+    @State private var searchQuery = ""
+    @State private var isAutoRefreshing = true
+
+    private let refreshTimer = Timer.publish(every: 2, on: .main, in: .common).autoconnect()
+
+    var body: some View {
+        VStack(spacing: 0) {
+            // Header with badges
+            HStack {
+                Text("Inspect")
+                    .font(.headline)
+
+                Spacer()
+
+                if let snapshot = state.inspectSnapshot {
+                    HStack(spacing: 6) {
+                        Badge(text: snapshot.descriptor.source, color: .blue)
+                        Badge(text: snapshot.descriptor.precision, color: precisionColor(snapshot.descriptor.precision))
+                        Badge(text: snapshot.descriptor.staleness, color: stalenessColor(snapshot.descriptor.staleness))
+                    }
+                }
+
+                Button(action: { requestInspect() }) {
+                    Image(systemName: "arrow.clockwise")
+                }
+                .buttonStyle(.plain)
+                .help("Refresh")
+            }
+            .padding(.horizontal, 12)
+            .padding(.vertical, 8)
+            .background(.bar)
+
+            // Search bar
+            HStack {
+                Image(systemName: "magnifyingglass")
+                    .foregroundStyle(.secondary)
+                TextField("Search terminal content...", text: $searchQuery)
+                    .textFieldStyle(.plain)
+                    .onSubmit { requestInspect() }
+                if !searchQuery.isEmpty {
+                    Button(action: { searchQuery = ""; requestInspect() }) {
+                        Image(systemName: "xmark.circle.fill")
+                            .foregroundStyle(.secondary)
+                    }
+                    .buttonStyle(.plain)
+                }
+            }
+            .padding(.horizontal, 12)
+            .padding(.vertical, 6)
+
+            Divider()
+
+            // Content
+            if let snapshot = state.inspectSnapshot {
+                ScrollView {
+                    LazyVStack(alignment: .leading, spacing: 0) {
+                        ForEach(Array(snapshot.items.enumerated()), id: \.offset) { _, item in
+                            Text(item.content)
+                                .font(.system(.body, design: .monospaced))
+                                .foregroundStyle(item.type == "output" ? .primary : .secondary)
+                                .textSelection(.enabled)
+                                .padding(.horizontal, 12)
+                                .padding(.vertical, 1)
+                        }
+                    }
+                }
+            } else {
+                ContentUnavailableView(
+                    "No Inspect Data",
+                    systemImage: "doc.text",
+                    description: Text("Connect to a server and switch to a tab to inspect terminal content.")
+                )
+            }
+        }
+        .onReceive(refreshTimer) { _ in
+            if isAutoRefreshing {
+                requestInspect()
+            }
+        }
+        .onAppear { requestInspect() }
+    }
+
+    private func requestInspect() {
+        state.requestInspect(
+            tabIndex: state.activeTabIndex,
+            query: searchQuery.isEmpty ? nil : searchQuery
+        )
+    }
+
+    private func precisionColor(_ p: String) -> Color {
+        switch p {
+        case "precise": .green
+        case "approximate": .yellow
+        default: .gray
+        }
+    }
+
+    private func stalenessColor(_ s: String) -> Color {
+        switch s {
+        case "fresh": .green
+        case "stale": .orange
+        default: .gray
+        }
+    }
+}
+
+struct Badge: View {
+    let text: String
+    let color: Color
+
+    var body: some View {
+        Text(text)
+            .font(.system(size: 10))
+            .padding(.horizontal, 6)
+            .padding(.vertical, 2)
+            .background(color.opacity(0.15))
+            .foregroundStyle(color)
+            .cornerRadius(4)
+    }
+}

package/apps/macos/Sources/Remux/Views/SettingsView.swift

@@ -0,0 +1,77 @@
+import SwiftUI
+import ServiceManagement
+
+/// Settings window for Remux macOS app.
+struct SettingsView: View {
+    @AppStorage("theme") private var theme: String = "system"
+    @AppStorage("globalShortcut") private var globalShortcut: String = "⌘⇧R"
+    @AppStorage("notifyBell") private var notifyBell = true
+    @AppStorage("notifyRunComplete") private var notifyRunComplete = true
+    @AppStorage("notifyApproval") private var notifyApproval = true
+    @AppStorage("launchAtLogin") private var launchAtLogin = false
+
+    var body: some View {
+        TabView {
+            generalTab
+                .tabItem { Label("General", systemImage: "gear") }
+
+            ShortcutSettingsView()
+                .tabItem { Label("Shortcuts", systemImage: "keyboard") }
+
+            notificationsTab
+                .tabItem { Label("Notifications", systemImage: "bell") }
+        }
+        .frame(width: 560, height: 440)
+        .padding()
+    }
+
+    private var generalTab: some View {
+        Form {
+            Picker("Theme", selection: $theme) {
+                Text("System").tag("system")
+                Text("Dark").tag("dark")
+                Text("Light").tag("light")
+            }
+            .onChange(of: theme) { _, newValue in
+                applyTheme(newValue)
+            }
+
+            LabeledContent("Global Shortcut") {
+                Text(globalShortcut)
+                    .foregroundStyle(.secondary)
+            }
+
+            Toggle("Launch at Login", isOn: $launchAtLogin)
+                .onChange(of: launchAtLogin) { _, enabled in
+                    do {
+                        if enabled {
+                            try SMAppService.mainApp.register()
+                        } else {
+                            try SMAppService.mainApp.unregister()
+                        }
+                    } catch {
+                        launchAtLogin = !enabled
+                    }
+                }
+        }
+    }
+
+    private var notificationsTab: some View {
+        Form {
+            Toggle("Terminal Bell", isOn: $notifyBell)
+            Toggle("Run Complete", isOn: $notifyRunComplete)
+            Toggle("Approval Needed", isOn: $notifyApproval)
+        }
+    }
+
+    private func applyTheme(_ theme: String) {
+        switch theme {
+        case "dark":
+            NSApp.appearance = NSAppearance(named: .darkAqua)
+        case "light":
+            NSApp.appearance = NSAppearance(named: .aqua)
+        default:
+            NSApp.appearance = nil // system
+        }
+    }
+}