cmux175: #12537 cloud startup latency

Sources/AppDelegate.swift

@@ -16969,11 +16969,11 @@ final class AppDelegate: NSObject, NSApplicationDelegate, UNUserNotificationCent
                         direction: direction.canvasDirection
                     ) != nil
                 }
-                return terminalContext.tabManager.createSplit(
+                return terminalContext.tabManager.createSplitOutcome(
                     tabId: terminalContext.workspaceId,
                     surfaceId: terminalContext.panelId,
                     direction: direction
-                ) != nil
+                ).isAccepted
             }
             if let workspace = tabManager?.selectedWorkspace,
                workspace.layoutMode == .canvas {
@@ -16983,7 +16983,7 @@ final class AppDelegate: NSObject, NSApplicationDelegate, UNUserNotificationCent
                     direction: direction.canvasDirection
                 ) != nil
             }
-            return tabManager?.createSplit(direction: direction) != nil
+            return tabManager?.createSplitOutcome(direction: direction).isAccepted ?? false
         }()
 #if DEBUG
         DispatchQueue.main.asyncAfter(deadline: .now() + 0.15) { [weak self] in

Sources/Cloud/CloudDiagnosticFailure.swift

@@ -56,6 +56,17 @@ enum CloudDiagnosticFailure: String, Codable, Sendable, Error {
             case .clientMissing, .spawnFailed, .exited: return .process
             }
         }
+        if let error = error as? CmuxTuiSurfaceProvider.ProviderError {
+            switch error {
+            case .notSignedIn: return .authentication
+            case .machineAsleep, .remoteWorkspaceNotFound, .remoteTabNotFound,
+                 .noWorkspaceOnMachine, .remotePlacementUnavailable, .terminalExited: return .notFound
+            case .terminalNotCreated, .invalidSnapshot, .stateUnavailable,
+                 .invalidPreviewURL, .localForwardURLUnavailable: return .response
+            case .terminalAttachTimedOut: return .timeout
+            case .snapshotOnly, .hubUnavailable: return .unsupported
+            }
+        }
         if error is CloudMachineLinkManager.ManagerError { return .connectFailure(error) }
         if error is DecodingError { return .response }
         return .unknown

Sources/Cloud/CloudTerminalAttachmentStatus.swift

@@ -11,6 +11,9 @@ import Observation
 final class CloudTerminalAttachmentStatus {
     let machineID: String
     private(set) var state: CloudTerminalAttachmentState = .attaching(attempt: 1)
+    /// One-shot style hook for owners that are not SwiftUI views (the workspace
+    /// clearing an optimistic pane's tab spinner). Set by the pane owner only.
+    @ObservationIgnored var onStateChange: (@MainActor (CloudTerminalAttachmentState) -> Void)?
 
     init(machineID: String) {
         self.machineID = machineID
@@ -19,5 +22,6 @@ final class CloudTerminalAttachmentStatus {
     func update(_ state: CloudTerminalAttachmentState) {
         guard self.state != state else { return }
         self.state = state
+        onStateChange?(state)
     }
 }

Sources/Cloud/CloudTerminalConnectionPresentationPolicy.swift

@@ -0,0 +1,77 @@
+import Foundation
+
+/// When a native cloud pane shows its connection card.
+///
+/// The pane never shows a progress card: an attachment that is connecting or
+/// reconnecting keeps its last frame (or stays blank when brand new) and simply
+/// fills in when the stream is usable. A byte attachment normally becomes usable
+/// within a few hundred milliseconds, and the provider re-runs `reconnect` on
+/// every graph refresh, so any card on the first `.connecting` or
+/// `.disconnected` sample flashed for the duration of a healthy handoff and
+/// called a pane "unavailable" that automatic recovery repaired a moment later.
+/// The only card is the actionable one: Reconnect, shown once automatic
+/// recovery has kept failing for `failureGrace`, or at once when recovery has
+/// been given up. A usable attachment clears it immediately.
+struct CloudTerminalConnectionPresentationPolicy: Equatable, Sendable {
+    /// How long automatic recovery may keep failing before the pane offers Reconnect.
+    let failureGrace: Duration
+
+    init(failureGrace: Duration) {
+        precondition(failureGrace >= .zero)
+        self.failureGrace = failureGrace
+    }
+
+    /// Production bound: a few rounds of the provider's attachment backoff.
+    static let standard = Self(failureGrace: .seconds(8))
+
+    /// No grace: a disconnected attachment offers Reconnect at once. For tests
+    /// that assert card content rather than timing.
+    static let immediate = Self(failureGrace: .zero)
+
+    /// How long the current unusable episode has lasted, as the session tracks it.
+    enum Stage: Equatable, Sendable {
+        /// Shorter than `failureGrace`: show nothing.
+        case silent
+        /// Past `failureGrace`: a disconnected attachment offers Reconnect.
+        case failure
+    }
+
+    enum Outcome: Equatable, Sendable {
+        case none
+        case failure
+    }
+
+    struct Input: Equatable, Sendable {
+        var phase: CloudTuiManualMirrorPhase
+        var replayReceived: Bool
+        /// Whether the session or its provider will retry on its own.
+        var automaticRecovery: Bool
+        var stage: Stage
+    }
+
+    /// Whether `input` describes an attachment the user can type into.
+    static func isUsable(_ input: Input) -> Bool {
+        input.phase == .attached && input.replayReceived
+    }
+
+    /// Whether `input` is an episode the stage timer should be measuring.
+    static func isUnusableEpisode(_ input: Input) -> Bool {
+        switch input.phase {
+        case .idle, .stopped: return false
+        case .connecting, .disconnected: return true
+        case .attached: return !input.replayReceived
+        }
+    }
+
+    static func outcome(for input: Input) -> Outcome {
+        switch input.phase {
+        case .idle, .stopped, .connecting, .attached:
+            // Never started, cancelled by the user, or still being worked on:
+            // nothing to report; the pane fills in when the stream is usable.
+            return .none
+        case .disconnected:
+            guard input.automaticRecovery else { return .failure }
+            return input.stage == .failure ? .failure : .none
+        }
+    }
+}

Sources/Cloud/CloudTerminalCreationRequest.swift

@@ -0,0 +1,67 @@
+import Foundation
+
+/// Retains one UI intent's daemon identity across explicit retries.
+///
+/// The first create uses the existing idempotency-key contract. Only a user
+/// retry reads the durable receipt, once; no polling or automatic recreation
+/// runs behind a pending pane.
+@MainActor
+final class CloudTerminalCreationRequest {
+    let id: UUID
+    let correlationKey: String
+    private(set) var attemptKey: String
+    private var submitted = false
+
+    init(id: UUID = UUID()) {
+        self.id = id
+        let key = "cmux-cloud-create-\(id.uuidString.lowercased())"
+        correlationKey = key
+        attemptKey = key
+    }
+
+    /// First attempts omit the additive correlation flag for older daemons.
+    /// A new-key retry uses it only after the daemon explicitly authorizes one.
+    var correlationArgument: String? { attemptKey == correlationKey ? nil : correlationKey }
+
+    /// Returns an existing terminal, or authorizes exactly one mutation attempt.
+    func prepare(
+        using runner: any CloudTuiCommandRunning,
+        socketPath: String
+    ) async throws -> CmuxTuiSnapshotParser.CreatedTerminalPath? {
+        try Task.checkCancellation()
+        guard submitted else {
+            submitted = true
+            return nil
+        }
+        let data: Data
+        do {
+            data = try await runner.runTuiCommand(
+                arguments: ["--socket", socketPath, "--json", "session", "current", "creation", correlationKey, "resolve"],
+                deadline: .seconds(30)
+            )
+        } catch {
+            if case .rejected(let reason) = CloudTuiDaemonAnswer(error: error),
+               reason.contains("unsupported") || reason.contains("unknown command") {
+                throw CloudDiagnosticFailure.unsupported
+            }
+            throw error
+        }
+        try Task.checkCancellation()
+        guard let resolution = CloudTerminalCreationRetryResolution(
+            data: data, correlationKey: correlationKey, attemptKey: attemptKey
+        ) else { throw CloudDiagnosticFailure.response }
+        switch resolution {
+        case .created(let terminal):
+            return terminal
+        case .sameAttempt:
+            return nil
+        case .newAttempt:
+            attemptKey = "cmux-cloud-create-\(UUID().uuidString.lowercased())"
+            return nil
+        case .pending:
+            throw CloudDiagnosticFailure.timeout
+        case .indeterminate:
+            throw CloudDiagnosticFailure.response
+        }
+    }
+}

Sources/Cloud/CloudTerminalCreationRetryResolution.swift

@@ -0,0 +1,47 @@
+import Foundation
+
+/// The daemon's authoritative permission for one explicit terminal-creation retry.
+enum CloudTerminalCreationRetryResolution: Equatable, Sendable {
+    case created(CmuxTuiSnapshotParser.CreatedTerminalPath)
+    case sameAttempt
+    case newAttempt
+    case pending
+    case indeterminate
+
+    init?(data: Data, correlationKey: String, attemptKey: String) {
+        guard let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { return nil }
+        let envelope = (object["result"] as? [String: Any]) ?? (object["data"] as? [String: Any]) ?? object
+        let value = (envelope["value"] as? [String: Any]) ?? envelope
+        guard value["correlation_key"] as? String == correlationKey,
+              let state = value["state"] as? String,
+              let recovery = value["recovery"] as? String else { return nil }
+        let returnedKey = value["idempotency_key"] as? String
+        // An absent record can authorize a new attempt without an old key.
+        // Every existing receipt must name this request's current attempt.
+        guard returnedKey == attemptKey ||
+            (returnedKey == nil && state == "not_applied" && recovery == "retry_new_idempotency_key") else { return nil }
+        switch (state, recovery) {
+        case ("created", "none"):
+            guard let path = value["created_path"] as? [String: Any],
+                  path["kind"] as? String == "terminal",
+                  let generation = value["generation"] as? String, !generation.isEmpty,
+                  let revision = CloudWireNumber.unsigned(value["revision"]),
+                  let created = CmuxTuiSnapshotParser.createdTerminal(fromRunResult: [
+                    "value": path, "generation": generation, "revision": String(revision)
+                  ]),
+                  created.workspaceID != nil, created.screenID != nil,
+                  created.paneID != nil, created.tabID != nil else { return nil }
+            self = .created(created)
+        case ("not_applied", "retry_same_idempotency_key"):
+            self = .sameAttempt
+        case ("not_applied", "retry_new_idempotency_key"):
+            self = .newAttempt
+        case ("pending", "wait"):
+            self = .pending
+        case ("indeterminate", "do_not_retry"):
+            self = .indeterminate
+        default:
+            return nil
+        }
+    }
+}

Sources/Cloud/CloudTreeNodeActions.swift

@@ -196,6 +196,14 @@ struct CloudTreeNodeActions {
                 }
             },
             newTerminal: { machine, remoteWorkspaceID in
+                // A cloud machine gets its pane at once; the sidebar shares the
+                // shortcut routes' optimistic path. The local machine and a missing
+                // workspace keep the awaited create below.
+                if !machine.isLocal, let workspaceID = selectedWorkspaceID(),
+                   let workspace = Workspace.liveWorkspace(id: workspaceID),
+                   workspace.openCloudTerminalOptimistically(on: machine, remoteWorkspaceID: remoteWorkspaceID) {
+                    return
+                }
                 run(startingLabel(machine)) { catalog in
                     guard let provider = catalog.provider(for: machine) else { throw SurfaceCatalogError.noProvider(machine) }
                     let token = catalog.cloudWorkspaceProjectionCoordinator.beginLocalMutation(on: machine)
@@ -213,6 +221,11 @@ struct CloudTreeNodeActions {
             },
             openGroup: { machine, group, placement, remoteWorkspaceID in
                 if group.isEmpty {
+                    if !machine.isLocal, let workspaceID = selectedWorkspaceID(),
+                       let workspace = Workspace.liveWorkspace(id: workspaceID),
+                       workspace.openCloudTerminalOptimistically(on: machine, remoteWorkspaceID: remoteWorkspaceID) {
+                        return
+                    }
                     run(startingLabel(machine)) { catalog in
                         guard let provider = catalog.provider(for: machine) else { throw SurfaceCatalogError.noProvider(machine) }
                         let resource = try await provider.createTerminal(command: nil, cwd: nil, name: nil, remoteWorkspaceID: remoteWorkspaceID)
@@ -231,7 +244,8 @@ struct CloudTreeNodeActions {
                         _ = try await catalog.projectGroup(
                             routedGroup,
                             into: try destination(placement),
-                            focus: true
+                            focus: true,
+                            optimistic: .app
                         )
                     }
                 }
@@ -253,7 +267,7 @@ struct CloudTreeNodeActions {
                             ),
                             title: Self.localWorkspaceTitle(hostName: machineName(machine), group: group),
                             focus: true,
-                            host: .app
+                            host: .appOptimistic
                         )
                         catalog.bindCloudWorkspace(
                             localWorkspaceID: opened.workspaceID, machine: machine,
@@ -273,7 +287,7 @@ struct CloudTreeNodeActions {
                             routedGroup,
                             title: Self.localWorkspaceTitle(hostName: machineName(machine), group: group),
                             focus: true,
-                            host: .app,
+                            host: .appOptimistic,
                             layout: layout
                         )
                         catalog.bindCloudWorkspace(
@@ -442,7 +456,7 @@ struct CloudTreeNodeActions {
             group,
             title: localWorkspaceTitle(hostName: resolvedMachineName(machine, snapshot: catalog.snapshot), group: group),
             focus: focus,
-            host: .app
+            host: .appOptimistic
         )
         catalog.bindCloudWorkspace(
             localWorkspaceID: opened.workspaceID,

Sources/Cloud/CloudTreeTerminalNavigationCoordinator.swift

@@ -120,7 +120,7 @@ final class CloudTreeTerminalNavigationCoordinator {
                 group: group
             ),
             focus: true,
-            host: .app,
+            host: .appOptimistic,
             layout: layout
         )
         guard !Task.isCancelled else {

Sources/Cloud/CloudTuiCommandLine.swift

@@ -60,8 +60,10 @@ struct CloudTuiCommandLine: Sendable {
     /// `workspace <ws_id> run -- <argv…>`: a new terminal in that cmux-tui workspace
     /// running the exact argv. Result: `MutationResult<CreatedTerminalPath>`
     /// (`spec/resource-operations-v2.json` → `workspace.run`).
-    static func runArguments(socketPath: String, workspaceID: String, command: [String], onExit: String? = nil) -> [String] {
+    static func runArguments(socketPath: String, workspaceID: String, command: [String], onExit: String? = nil, idempotencyKey: String? = nil, correlationKey: String? = nil) -> [String] {
         var arguments = ["--socket", socketPath, "--json", "workspace", workspaceID, "run"]
+        if let idempotencyKey { arguments += ["--idempotency-key", idempotencyKey] }
+        if let correlationKey { arguments += ["--correlation-key", correlationKey] }
         // `--on-exit keep` retains the tab and the final screen after the process exits
         // (spec `workspace.run`): what a sender needs when the process's last lines ARE
         // the result (`CloudEnvDelivery`). The default (`close`) detaches every view.