@wangyaoshen/remux 0.3.8-dev.bab6c95

package/apps/ios/Sources/Remux/Views/Now/NowView.swift

@@ -0,0 +1,173 @@
+import SwiftUI
+import RemuxKit
+
+/// Now tab: shows current status, active session, recent activity.
+/// Design ref: hapi's Now first screen — focus on the 3 most important things.
+struct NowView: View {
+    @Environment(RemuxState.self) private var state
+
+    var body: some View {
+        NavigationStack {
+            ScrollView {
+                VStack(spacing: 16) {
+                    // Connection status card
+                    ConnectionStatusCard()
+
+                    // Active session card
+                    if !state.currentSession.isEmpty {
+                        SessionCard(
+                            sessionName: state.currentSession,
+                            tabCount: state.tabs.count,
+                            activeTab: state.tabs.first { $0.index == state.activeTabIndex }
+                        )
+                    }
+
+                    // Client role
+                    HStack {
+                        Image(systemName: state.clientRole == "active" ? "hand.raised.fill" : "eye.fill")
+                        Text(state.clientRole == "active" ? "Active" : "Observer")
+                            .font(.subheadline)
+                        Spacer()
+                        if state.clientRole == "observer" {
+                            Button("Request Control") {
+                                state.requestControl()
+                            }
+                            .buttonStyle(.bordered)
+                            .controlSize(.small)
+                        }
+                    }
+                    .padding()
+                    .background(.regularMaterial)
+                    .cornerRadius(12)
+
+                    // Quick actions
+                    QuickActionsSection()
+                }
+                .padding()
+            }
+            .navigationTitle("Now")
+            .refreshable {
+                state.requestInspect(tabIndex: state.activeTabIndex)
+            }
+        }
+    }
+}
+
+struct ConnectionStatusCard: View {
+    @Environment(RemuxState.self) private var state
+
+    var body: some View {
+        HStack {
+            Circle()
+                .fill(statusColor)
+                .frame(width: 10, height: 10)
+            Text(statusText)
+                .font(.subheadline.bold())
+            Spacer()
+            if let url = state.serverURL {
+                Text(url.host ?? "")
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+            }
+        }
+        .padding()
+        .background(.regularMaterial)
+        .cornerRadius(12)
+    }
+
+    private var statusColor: Color {
+        switch state.connectionStatus {
+        case .connected: .green
+        case .reconnecting: .yellow
+        case .connecting, .authenticating: .orange
+        case .disconnected: .red
+        }
+    }
+
+    private var statusText: String {
+        switch state.connectionStatus {
+        case .connected: "Connected"
+        case .reconnecting(let n): "Reconnecting (\(n))..."
+        case .connecting: "Connecting..."
+        case .authenticating: "Authenticating..."
+        case .disconnected: "Disconnected"
+        }
+    }
+}
+
+struct SessionCard: View {
+    let sessionName: String
+    let tabCount: Int
+    let activeTab: WorkspaceTab?
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            HStack {
+                Image(systemName: "terminal")
+                Text(sessionName)
+                    .font(.headline)
+                Spacer()
+                Text("\(tabCount) tab\(tabCount == 1 ? "" : "s")")
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+            }
+            if let tab = activeTab {
+                HStack {
+                    Text("Active: \(tab.name)")
+                        .font(.subheadline)
+                        .foregroundStyle(.secondary)
+                    if let cwd = tab.panes.first?.cwd {
+                        Text(cwd)
+                            .font(.caption)
+                            .foregroundStyle(.tertiary)
+                            .lineLimit(1)
+                    }
+                }
+            }
+        }
+        .padding()
+        .background(.regularMaterial)
+        .cornerRadius(12)
+    }
+}
+
+struct QuickActionsSection: View {
+    @Environment(RemuxState.self) private var state
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            Text("Quick Actions")
+                .font(.caption)
+                .foregroundStyle(.secondary)
+
+            LazyVGrid(columns: [.init(.flexible()), .init(.flexible())], spacing: 8) {
+                QuickActionButton(icon: "plus", title: "New Tab") {
+                    state.createTab()
+                }
+                QuickActionButton(icon: "doc.text.magnifyingglass", title: "Inspect") {
+                    // Switch to inspect tab — handled by parent TabView
+                }
+            }
+        }
+    }
+}
+
+struct QuickActionButton: View {
+    let icon: String
+    let title: String
+    let action: () -> Void
+
+    var body: some View {
+        Button(action: action) {
+            VStack(spacing: 6) {
+                Image(systemName: icon)
+                    .font(.title3)
+                Text(title)
+                    .font(.caption)
+            }
+            .frame(maxWidth: .infinity)
+            .padding(.vertical, 12)
+        }
+        .buttonStyle(.bordered)
+    }
+}

package/apps/ios/Sources/Remux/Views/Onboarding/ManualConnectView.swift

@@ -0,0 +1,55 @@
+import SwiftUI
+import RemuxKit
+
+/// Manual connection entry: URL + token.
+struct ManualConnectView: View {
+    @Environment(RemuxState.self) private var state
+    @Environment(\.dismiss) private var dismiss
+    @State private var serverURL = ""
+    @State private var token = ""
+    @State private var errorMessage: String?
+
+    var body: some View {
+        NavigationStack {
+            Form {
+                Section("Server") {
+                    TextField("URL (e.g. http://192.168.1.100:8767)", text: $serverURL)
+                        .textContentType(.URL)
+                        .autocorrectionDisabled()
+                        .textInputAutocapitalization(.never)
+
+                    SecureField("Token", text: $token)
+                }
+
+                if let error = errorMessage {
+                    Section {
+                        Text(error)
+                            .foregroundStyle(.red)
+                    }
+                }
+            }
+            .navigationTitle("Connect")
+            .navigationBarTitleDisplayMode(.inline)
+            .toolbar {
+                ToolbarItem(placement: .cancellationAction) {
+                    Button("Cancel") { dismiss() }
+                }
+                ToolbarItem(placement: .confirmationAction) {
+                    Button("Connect") { connect() }
+                        .disabled(serverURL.isEmpty || token.isEmpty)
+                }
+            }
+        }
+    }
+
+    private func connect() {
+        guard let url = URL(string: serverURL) else {
+            errorMessage = "Invalid URL"
+            return
+        }
+        let keychain = KeychainStore()
+        try? keychain.saveServerToken(token, forServer: serverURL)
+        state.connect(url: url, credential: .token(token))
+        dismiss()
+    }
+}

package/apps/ios/Sources/Remux/Views/Onboarding/OnboardingView.swift

@@ -0,0 +1,70 @@
+import SwiftUI
+import RemuxKit
+
+/// First-launch onboarding: scan QR or manual input.
+struct OnboardingView: View {
+    @Environment(RemuxState.self) private var state
+    @State private var showScanner = false
+    @State private var showManualInput = false
+
+    var body: some View {
+        NavigationStack {
+            VStack(spacing: 32) {
+                Spacer()
+
+                Image(systemName: "terminal")
+                    .font(.system(size: 64))
+                    .foregroundStyle(.tint)
+
+                Text("Remux")
+                    .font(.largeTitle.bold())
+
+                Text("Remote terminal workspace")
+                    .font(.subheadline)
+                    .foregroundStyle(.secondary)
+
+                Spacer()
+
+                VStack(spacing: 16) {
+                    Button(action: { showScanner = true }) {
+                        Label("Scan QR Code", systemImage: "qrcode.viewfinder")
+                            .frame(maxWidth: .infinity)
+                    }
+                    .buttonStyle(.borderedProminent)
+                    .controlSize(.large)
+
+                    Button(action: { showManualInput = true }) {
+                        Label("Enter Manually", systemImage: "keyboard")
+                            .frame(maxWidth: .infinity)
+                    }
+                    .buttonStyle(.bordered)
+                    .controlSize(.large)
+                }
+                .padding(.horizontal, 40)
+
+                Spacer()
+            }
+            .sheet(isPresented: $showScanner) {
+                QRScannerView { payload in
+                    showScanner = false
+                    handleQRPayload(payload)
+                }
+            }
+            .sheet(isPresented: $showManualInput) {
+                ManualConnectView()
+            }
+        }
+    }
+
+    private func handleQRPayload(_ json: String) {
+        guard let data = json.data(using: .utf8),
+              let dict = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+              let urlStr = dict["url"] as? String,
+              let token = dict["token"] as? String,
+              let url = URL(string: urlStr) else { return }
+
+        let keychain = KeychainStore()
+        try? keychain.saveServerToken(token, forServer: urlStr)
+        state.connect(url: url, credential: .token(token))
+    }
+}

package/apps/ios/Sources/Remux/Views/Onboarding/QRScannerView.swift

@@ -0,0 +1,92 @@
+import SwiftUI
+import AVFoundation
+
+/// Camera QR code scanner for pairing.
+struct QRScannerView: UIViewControllerRepresentable {
+    let onScanned: (String) -> Void
+
+    func makeUIViewController(context: Context) -> QRScannerController {
+        let controller = QRScannerController()
+        controller.onScanned = onScanned
+        return controller
+    }
+
+    func updateUIViewController(_ uiViewController: QRScannerController, context: Context) {}
+}
+
+final class QRScannerController: UIViewController, @preconcurrency AVCaptureMetadataOutputObjectsDelegate {
+    var onScanned: ((String) -> Void)?
+    private var captureSession: AVCaptureSession?
+    private var hasScanned = false
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        view.backgroundColor = .black
+        setupCamera()
+    }
+
+    private func setupCamera() {
+        let session = AVCaptureSession()
+
+        guard let device = AVCaptureDevice.default(for: .video),
+              let input = try? AVCaptureDeviceInput(device: device) else {
+            showError("Camera not available")
+            return
+        }
+
+        session.addInput(input)
+
+        let output = AVCaptureMetadataOutput()
+        session.addOutput(output)
+        output.setMetadataObjectsDelegate(self, queue: .main)
+        output.metadataObjectTypes = [.qr]
+
+        let previewLayer = AVCaptureVideoPreviewLayer(session: session)
+        previewLayer.frame = view.bounds
+        previewLayer.videoGravity = .resizeAspectFill
+        view.layer.addSublayer(previewLayer)
+
+        captureSession = session
+
+        // Overlay instruction
+        let label = UILabel()
+        label.text = "Scan the QR code shown by your Remux server"
+        label.textColor = .white
+        label.font = .systemFont(ofSize: 14)
+        label.textAlignment = .center
+        label.translatesAutoresizingMaskIntoConstraints = false
+        view.addSubview(label)
+        NSLayoutConstraint.activate([
+            label.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor, constant: -40),
+            label.centerXAnchor.constraint(equalTo: view.centerXAnchor),
+        ])
+
+        DispatchQueue.global(qos: .userInitiated).async {
+            session.startRunning()
+        }
+    }
+
+    func metadataOutput(_ output: AVCaptureMetadataOutput, didOutput metadataObjects: [AVMetadataObject], from connection: AVCaptureConnection) {
+        guard !hasScanned,
+              let object = metadataObjects.first as? AVMetadataMachineReadableCodeObject,
+              let value = object.stringValue else { return }
+        hasScanned = true
+        captureSession?.stopRunning()
+
+        // Haptic feedback
+        UIImpactFeedbackGenerator(style: .medium).impactOccurred()
+
+        dismiss(animated: true) { [weak self] in
+            self?.onScanned?(value)
+        }
+    }
+
+    private func showError(_ message: String) {
+        let label = UILabel()
+        label.text = message
+        label.textColor = .white
+        label.textAlignment = .center
+        label.frame = view.bounds
+        view.addSubview(label)
+    }
+}

package/apps/ios/Sources/Remux/Views/Settings/MeView.swift

@@ -0,0 +1,136 @@
+import SwiftUI
+import RemuxKit
+import LocalAuthentication
+
+/// Me tab: server management, devices, settings.
+struct MeView: View {
+    @Environment(RemuxState.self) private var state
+    @AppStorage("faceIdEnabled") private var faceIdEnabled = false
+    private let keychain = KeychainStore()
+
+    var body: some View {
+        NavigationStack {
+            List {
+                // Connection
+                Section("Connection") {
+                    HStack {
+                        Circle()
+                            .fill(state.connectionStatus.color)
+                            .frame(width: 8, height: 8)
+                        Text(state.connectionStatus.text)
+                        Spacer()
+                        if let url = state.serverURL {
+                            Text(url.host ?? "")
+                                .font(.caption)
+                                .foregroundStyle(.secondary)
+                        }
+                    }
+
+                    if case .connected = state.connectionStatus {
+                        Button("Disconnect", role: .destructive) {
+                            state.disconnect()
+                        }
+                    }
+                }
+
+                // Saved servers
+                Section("Servers") {
+                    ForEach(keychain.savedServers(), id: \.self) { server in
+                        HStack {
+                            Image(systemName: "server.rack")
+                            Text(server)
+                                .font(.subheadline)
+                            Spacer()
+                            if state.serverURL?.absoluteString == server {
+                                Image(systemName: "checkmark")
+                                    .foregroundStyle(.tint)
+                            }
+                        }
+                        .swipeActions {
+                            Button(role: .destructive) {
+                                keychain.deleteAll(forServer: server)
+                            } label: {
+                                Label("Delete", systemImage: "trash")
+                            }
+                        }
+                    }
+                }
+
+                // Devices
+                if !state.devices.isEmpty {
+                    Section("Devices") {
+                        ForEach(state.devices, id: \.id) { device in
+                            HStack {
+                                Image(systemName: deviceIcon(device.platform))
+                                VStack(alignment: .leading) {
+                                    Text(device.name ?? device.id.prefix(8).description)
+                                        .font(.subheadline)
+                                    Text(device.trustLevel)
+                                        .font(.caption)
+                                        .foregroundStyle(device.trustLevel == "trusted" ? .green : .orange)
+                                }
+                                Spacer()
+                                if let lastSeen = device.lastSeen {
+                                    Text(lastSeen.prefix(10).description)
+                                        .font(.caption2)
+                                        .foregroundStyle(.tertiary)
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // Settings
+                Section("Security") {
+                    Toggle("Face ID / Touch ID", isOn: $faceIdEnabled)
+                }
+
+                // App info
+                Section("About") {
+                    HStack {
+                        Text("Version")
+                        Spacer()
+                        Text(Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "0.3.5")
+                            .foregroundStyle(.secondary)
+                    }
+                }
+            }
+            .navigationTitle("Me")
+            .onAppear {
+                // Request device list
+                state.sendJSON(["type": "list_devices"])
+            }
+        }
+    }
+
+    private func deviceIcon(_ platform: String?) -> String {
+        switch platform {
+        case "ios": "iphone"
+        case "macos": "desktopcomputer"
+        case "android": "apps.iphone"
+        case "web": "globe"
+        default: "questionmark.circle"
+        }
+    }
+}
+
+extension ConnectionStatus {
+    var color: Color {
+        switch self {
+        case .connected: .green
+        case .reconnecting: .yellow
+        case .connecting, .authenticating: .orange
+        case .disconnected: .red
+        }
+    }
+
+    var text: String {
+        switch self {
+        case .connected: "Connected"
+        case .reconnecting(let n): "Reconnecting (\(n))..."
+        case .connecting: "Connecting..."
+        case .authenticating: "Authenticating..."
+        case .disconnected: "Disconnected"
+        }
+    }
+}

package/apps/macos/Package.swift

@@ -0,0 +1,37 @@
+// swift-tools-version: 6.0
+
+import PackageDescription
+
+let package = Package(
+    name: "Remux",
+    platforms: [.macOS(.v14)],
+    dependencies: [
+        .package(path: "../../packages/RemuxKit"),
+    ],
+    targets: [
+        .executableTarget(
+            name: "Remux",
+            dependencies: ["RemuxKit", "GhosttyKit"],
+            path: "Sources/Remux",
+            linkerSettings: [
+                .linkedFramework("Cocoa"),
+                .linkedFramework("Metal"),
+                .linkedFramework("MetalKit"),
+                .linkedFramework("QuartzCore"),
+                .linkedFramework("Carbon"),
+                .linkedFramework("CoreText"),
+                .linkedFramework("CoreGraphics"),
+                .linkedFramework("Foundation"),
+                .linkedFramework("IOKit"),
+                .linkedFramework("IOSurface"),
+                .linkedFramework("UniformTypeIdentifiers"),
+                .linkedLibrary("c++"),
+                .linkedLibrary("z"),
+            ]
+        ),
+        .binaryTarget(
+            name: "GhosttyKit",
+            path: "../../vendor/ghostty/macos/GhosttyKit.xcframework"
+        ),
+    ]
+)