Add detachable SSH PTY daemon persistence

.github/workflows/tmux-corpus.yml

@@ -1,6 +1,10 @@
 name: tmux corpus
 
 on:
+  pull_request:
+    paths:
+      - ".github/workflows/tmux-corpus.yml"
+      - "daemon/remote/**"
   workflow_dispatch:
     inputs:
       fuzztime:
@@ -41,7 +45,7 @@ jobs:
       - name: Run tmux corpus fuzz targets
         working-directory: daemon/remote
         env:
-          FUZZTIME: ${{ github.event.inputs.fuzztime || '2m' }}
+          FUZZTIME: ${{ github.event_name == 'pull_request' && '30s' || github.event.inputs.fuzztime || '2m' }}
         run: |
           set -euo pipefail
           for target in \

CLI/cmux.swift

@@ -6495,6 +6495,9 @@ struct CMUXCLI {
             sshOptions.extraArguments.isEmpty &&
             remoteTerminalBootstrapScript?.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false &&
             deferredRemoteReconnectCommandScript != nil
+        let persistentDaemonSlot = usesPersistentSSHPTY
+            ? "ssh-\(UUID().uuidString.lowercased())"
+            : nil
         let startupInitialSSHCommand = buildSSHCommandText(
             sshOptions,
             localCommandScript: combinedLocalCommandScript
@@ -6646,8 +6649,9 @@ struct CMUXCLI {
             if sshOptions.skipDaemonBootstrap {
                 configureParams["skip_daemon_bootstrap"] = true
             }
-            if usesPersistentSSHPTY {
+            if let persistentDaemonSlot {
                 configureParams["preserve_after_terminal_exit"] = true
+                configureParams["persistent_daemon_slot"] = persistentDaemonSlot
             }
 
             cliDebugLog(
@@ -6716,6 +6720,9 @@ struct CMUXCLI {
         if usesPersistentSSHPTY, let workspaceInitialSurfaceId {
             payload["ssh_pty_session_id"] = "ssh-\(workspaceId)-\(workspaceInitialSurfaceId)"
         }
+        if let persistentDaemonSlot {
+            payload["persistent_daemon_slot"] = persistentDaemonSlot
+        }
         logSSHTiming("complete", extra: "workspace=\(String(workspaceId.prefix(8)))")
         if jsonOutput {
             print(jsonString(formatIDs(payload, mode: idFormat)))

Sources/TerminalController.swift

@@ -376,6 +376,10 @@ class TerminalController {
         return body()
     }
 
+    nonisolated func currentSocketPathForRemoteRestore() -> String {
+        withListenerState { socketPath }
+    }
+
     private nonisolated func listenerStateSnapshot() -> ListenerStateSnapshot {
         withListenerState {
             ListenerStateSnapshot(
@@ -6200,6 +6204,21 @@ class TerminalController {
         let localSocketPath = v2RawString(params, "local_socket_path")
         let terminalStartupCommand = v2RawString(params, "terminal_startup_command")?
             .trimmingCharacters(in: .whitespacesAndNewlines)
+        let persistentDaemonSlot = v2RawString(params, "persistent_daemon_slot")?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        if v2HasNonNullParam(params, "persistent_daemon_slot") {
+            guard let persistentDaemonSlot,
+                  !persistentDaemonSlot.isEmpty,
+                  persistentDaemonSlot.range(of: "^[A-Za-z0-9._-]{1,128}$", options: .regularExpression) != nil,
+                  persistentDaemonSlot != ".",
+                  persistentDaemonSlot != ".." else {
+                return .err(
+                    code: "invalid_params",
+                    message: "persistent_daemon_slot must contain only letters, numbers, '.', '_' or '-'",
+                    data: nil
+                )
+            }
+        }
         let daemonWebSocketURL = v2RawString(params, "daemon_websocket_url")?
             .trimmingCharacters(in: .whitespacesAndNewlines)
         let daemonWebSocketToken = v2RawString(params, "daemon_websocket_token")?
@@ -6287,6 +6306,7 @@ class TerminalController {
                 foregroundAuthToken: foregroundAuthToken?.isEmpty == true ? nil : foregroundAuthToken,
                 daemonWebSocketEndpoint: daemonWebSocketEndpoint,
                 preserveAfterTerminalExit: preserveAfterTerminalExit,
+                persistentDaemonSlot: persistentDaemonSlot?.isEmpty == true ? nil : persistentDaemonSlot,
                 skipDaemonBootstrap: skipDaemonBootstrap
             )
             workspace.configureRemoteConnection(config, autoConnect: autoConnect)

Sources/Workspace.swift

@@ -266,7 +266,9 @@ extension Workspace {
         invalidatedRestoredAgentFingerprintsByPanelId.removeAll(keepingCapacity: false)
         surfaceResumeBindingsByPanelId.removeAll(keepingCapacity: false)
 
-        let restoredRemoteConfiguration = snapshot.remote?.workspaceConfiguration()
+        let restoredRemoteConfiguration = snapshot.remote?.workspaceConfiguration(
+            localSocketPath: TerminalController.shared.currentSocketPathForRemoteRestore()
+        )
         if let restoredRemoteConfiguration {
             let shouldAutoConnect = Self.shouldAutoConnectRestoredRemote(
                 foregroundAuthToken: restoredRemoteConfiguration.foregroundAuthToken,
@@ -1148,11 +1150,16 @@ extension Workspace {
                 restoredAgentResumeInput != nil ||
                 (restoredBindingInput != nil && resumeBinding?.isAgentHookBinding == true)
             )
-            // Snapshot session IDs belong to the previous app run's remote daemon.
-            // Restored persistent SSH terminals start a fresh attach path and replay
-            // local scrollback until the new remote PTY is ready.
-            let restoredRemotePTYSessionID: String? = nil
-            let restoredRemotePTYAttachCommand: String? = nil
+            let restoredRemotePTYSessionID: String? = {
+                guard remoteConfiguration?.preserveAfterTerminalExit == true,
+                      remoteConfiguration?.persistentDaemonSlot != nil else {
+                    return nil
+                }
+                return normalizedRemotePTYSessionID(snapshot.terminal?.remotePTYSessionID)
+            }()
+            let restoredRemotePTYAttachCommand = restoredRemotePTYSessionID.map {
+                remotePTYAttachStartupCommand(sessionID: $0)
+            }
 #if DEBUG
             if let restorableAgent {
                 let sessionPreview = String(restorableAgent.sessionId.prefix(8))
@@ -1816,7 +1823,8 @@ protocol WorkspaceRemotePTYBridgeRPCClient: AnyObject {
 nonisolated func remoteDaemonMissingRequiredCapabilitiesMessage(_ missingCapabilities: [String]) -> String {
     let missing = Set(missingCapabilities)
     if missing.contains(WorkspaceRemoteDaemonRPCClient.requiredPTYSessionCapability) ||
-        missing.contains(WorkspaceRemoteDaemonRPCClient.requiredPTYSessionTokenCapability) {
+        missing.contains(WorkspaceRemoteDaemonRPCClient.requiredPTYSessionTokenCapability) ||
+        missing.contains(WorkspaceRemoteDaemonRPCClient.requiredPTYPersistentDaemonCapability) {
         return "remote daemon does not support persistent SSH PTY sessions; reconnect the remote workspace to update cmux"
     }
     return "remote daemon is missing required functionality; reconnect the remote workspace to update cmux"
@@ -1829,6 +1837,7 @@ private final class WorkspaceRemoteDaemonRPCClient {
     static let requiredProxyStreamCapability = "proxy.stream.push"
     static let requiredPTYSessionCapability = "pty.session"
     static let requiredPTYSessionTokenCapability = "pty.session.token"
+    static let requiredPTYPersistentDaemonCapability = "pty.session.persistent_daemon"
 
     enum StreamEvent {
         case data(Data)
@@ -1970,6 +1979,9 @@ private final class WorkspaceRemoteDaemonRPCClient {
             capabilities.append(requiredPTYSessionCapability)
             capabilities.append(requiredPTYSessionTokenCapability)
         }
+        if configuration.persistentDaemonSlot != nil {
+            capabilities.append(requiredPTYPersistentDaemonCapability)
+        }
         return capabilities
     }
 
@@ -6654,7 +6666,8 @@ final class WorkspaceRemoteSessionController {
     private var bakedDaemonPreflightRequiredCapabilities: [String] {
         requiredDaemonCapabilities.filter {
             $0 != WorkspaceRemoteDaemonRPCClient.requiredPTYSessionCapability &&
-                $0 != WorkspaceRemoteDaemonRPCClient.requiredPTYSessionTokenCapability
+                $0 != WorkspaceRemoteDaemonRPCClient.requiredPTYSessionTokenCapability &&
+                $0 != WorkspaceRemoteDaemonRPCClient.requiredPTYPersistentDaemonCapability
         }
     }
 
@@ -11881,13 +11894,15 @@ final class Workspace: Identifiable, ObservableObject {
             payload["has_identity_file"] = remoteConfiguration.identityFile != nil
             payload["has_ssh_options"] = !remoteConfiguration.sshOptions.isEmpty
             payload["local_proxy_port"] = remoteConfiguration.localProxyPort ?? NSNull()
+            payload["persistent_daemon_slot"] = remoteConfiguration.persistentDaemonSlot ?? NSNull()
         } else {
             payload["transport"] = NSNull()
             payload["destination"] = NSNull()
             payload["port"] = NSNull()
             payload["has_identity_file"] = false
             payload["has_ssh_options"] = false
             payload["local_proxy_port"] = NSNull()
+            payload["persistent_daemon_slot"] = NSNull()
         }
         return payload
     }
@@ -16048,7 +16063,10 @@ final class Workspace: Identifiable, ObservableObject {
 
     private func forkAgentRemoteConfigurationForNewWorkspace(fromPanelId panelId: UUID) -> WorkspaceRemoteConfiguration? {
         guard forkAgentRemoteStartupCommand(fromPanelId: panelId) != nil else { return nil }
-        return remoteConfiguration?.sessionSnapshot()?.workspaceConfiguration() ?? remoteConfiguration
+        return remoteConfiguration?.sessionSnapshot()?.workspaceConfiguration(
+            localSocketPath: TerminalController.shared.currentSocketPathForRemoteRestore(),
+            allowPersistentPTYRestore: false
+        ) ?? remoteConfiguration
     }
 
     private static func firstNonEmptyPath(_ candidates: [String?]) -> String? {

Sources/WorkspaceRemoteConfiguration.swift

@@ -1,5 +1,8 @@
 import Darwin
 import Foundation
+#if canImport(Security)
+import Security
+#endif
 
 private enum WorkspaceRemoteSSHOptionFilter {
     private static let transientControlSocketKeys: Set<String> = [
@@ -61,6 +64,8 @@ nonisolated struct SessionRemoteWorkspaceSnapshot: Codable, Equatable, Sendable
     var sshOptions: [String]
     var preserveAfterTerminalExit: Bool?
     var skipDaemonBootstrap: Bool?
+    var relayPort: Int?
+    var persistentDaemonSlot: String?
 }
 
 struct WorkspaceRemoteWebSocketDaemonEndpoint: Equatable {
@@ -287,6 +292,7 @@ struct WorkspaceRemoteConfiguration: Equatable {
     let foregroundAuthToken: String?
     let daemonWebSocketEndpoint: WorkspaceRemoteWebSocketDaemonEndpoint?
     let preserveAfterTerminalExit: Bool
+    let persistentDaemonSlot: String?
     /// True for cloud-VM remotes (Freestyle snapshots) where cmuxd-remote is pre-baked in
     /// the image and started via systemd. Skip the upload+exec bootstrap entirely and synthesize
     /// a `DaemonHello`. Reverse-relay still stays off, but SSH-backed VM workspaces can talk to
@@ -308,6 +314,7 @@ struct WorkspaceRemoteConfiguration: Equatable {
         foregroundAuthToken: String? = nil,
         daemonWebSocketEndpoint: WorkspaceRemoteWebSocketDaemonEndpoint? = nil,
         preserveAfterTerminalExit: Bool = false,
+        persistentDaemonSlot: String? = nil,
         skipDaemonBootstrap: Bool = false
     ) {
         self.transport = transport
@@ -324,6 +331,7 @@ struct WorkspaceRemoteConfiguration: Equatable {
         self.foregroundAuthToken = foregroundAuthToken
         self.daemonWebSocketEndpoint = daemonWebSocketEndpoint
         self.preserveAfterTerminalExit = preserveAfterTerminalExit
+        self.persistentDaemonSlot = WorkspaceRemoteSSHOptionFilter.normalizedOptional(persistentDaemonSlot)
         self.skipDaemonBootstrap = skipDaemonBootstrap
     }
 
@@ -342,6 +350,7 @@ struct WorkspaceRemoteConfiguration: Equatable {
         let normalizedOptions = Self.proxyBrokerSSHOptions(sshOptions).joined(separator: "\u{1f}")
         let normalizedWebSocketDaemon = daemonWebSocketEndpoint?.proxyBrokerKeyComponent ?? ""
         let normalizedRequiredCapabilities = preserveAfterTerminalExit ? "pty.session" : ""
+        let normalizedPersistentDaemonSlot = persistentDaemonSlot ?? ""
         return [
             normalizedTransport,
             normalizedBootstrapMode,
@@ -352,6 +361,7 @@ struct WorkspaceRemoteConfiguration: Equatable {
             normalizedLocalProxyPort,
             normalizedWebSocketDaemon,
             normalizedRequiredCapabilities,
+            normalizedPersistentDaemonSlot,
         ]
             .joined(separator: "\u{1e}")
     }
@@ -362,7 +372,10 @@ struct WorkspaceRemoteConfiguration: Equatable {
 }
 
 extension SessionRemoteWorkspaceSnapshot {
-    func workspaceConfiguration() -> WorkspaceRemoteConfiguration? {
+    func workspaceConfiguration(
+        localSocketPath: String? = nil,
+        allowPersistentPTYRestore: Bool = true
+    ) -> WorkspaceRemoteConfiguration? {
         guard transport == .ssh else { return nil }
         let normalizedDestination = destination.trimmingCharacters(in: .whitespacesAndNewlines)
         guard !normalizedDestination.isEmpty else { return nil }
@@ -372,9 +385,16 @@ extension SessionRemoteWorkspaceSnapshot {
 
         let normalizedOptions = Self.normalizedSSHOptions(sshOptions)
         let optionsWithRestoreControlDefaults = SSHPTYAttachStartupCommandBuilder.sshOptionsWithRestoreControlDefaults(normalizedOptions)
+        let normalizedPersistentDaemonSlot = WorkspaceRemoteSSHOptionFilter.normalizedOptional(persistentDaemonSlot)
+        let normalizedRelayPort = relayPort.flatMap { port in
+            (1...65535).contains(port) ? port : nil
+        }
         let preservePTYSession =
+            allowPersistentPTYRestore &&
             preserveAfterTerminalExit == true &&
             skipDaemonBootstrap != true &&
+            normalizedPersistentDaemonSlot != nil &&
+            normalizedRelayPort != nil &&
             SSHPTYAttachStartupCommandBuilder.sshOptionsSupportReusableForegroundAuth(optionsWithRestoreControlDefaults)
         let restoredSSHOptions = preservePTYSession ? optionsWithRestoreControlDefaults : normalizedOptions
         let foregroundAuthToken = preservePTYSession ? UUID().uuidString.lowercased() : nil
@@ -387,17 +407,23 @@ extension SessionRemoteWorkspaceSnapshot {
                 token: $0
             )
         }
+        let restoredRelayID = preservePTYSession && normalizedRelayPort != nil
+            ? UUID().uuidString.lowercased()
+            : nil
+        let restoredRelayToken = preservePTYSession && normalizedRelayPort != nil
+            ? Self.restoreRelayTokenHex()
+            : nil
         return WorkspaceRemoteConfiguration(
             transport: transport,
             destination: normalizedDestination,
             port: normalizedPort,
             identityFile: Self.normalizedIdentityPath(identityFile),
             sshOptions: restoredSSHOptions,
             localProxyPort: nil,
-            relayPort: nil,
-            relayID: nil,
-            relayToken: nil,
-            localSocketPath: nil,
+            relayPort: preservePTYSession ? normalizedRelayPort : nil,
+            relayID: restoredRelayID,
+            relayToken: restoredRelayToken,
+            localSocketPath: preservePTYSession ? WorkspaceRemoteSSHOptionFilter.normalizedOptional(localSocketPath) : nil,
             terminalStartupCommand: preservePTYSession
                 ? SSHPTYAttachStartupCommandBuilder.command(
                     foregroundAuth: foregroundAuth,
@@ -410,10 +436,23 @@ extension SessionRemoteWorkspaceSnapshot {
             foregroundAuthToken: foregroundAuthToken,
             daemonWebSocketEndpoint: nil,
             preserveAfterTerminalExit: preservePTYSession,
+            persistentDaemonSlot: preservePTYSession ? normalizedPersistentDaemonSlot : nil,
             skipDaemonBootstrap: skipDaemonBootstrap == true
         )
     }
 
+    private static func restoreRelayTokenHex() -> String {
+        var bytes = [UInt8](repeating: 0, count: 32)
+#if canImport(Security)
+        if SecRandomCopyBytes(kSecRandomDefault, bytes.count, &bytes) == errSecSuccess {
+            return bytes.map { String(format: "%02x", $0) }.joined()
+        }
+#endif
+        return (UUID().uuidString + UUID().uuidString)
+            .replacingOccurrences(of: "-", with: "")
+            .lowercased()
+    }
+
     private func sshReconnectCommand(
         destination normalizedDestination: String,
         port normalizedPort: Int?
@@ -470,7 +509,9 @@ extension WorkspaceRemoteConfiguration {
             identityFile: WorkspaceRemoteSSHOptionFilter.normalizedIdentityPath(identityFile),
             sshOptions: WorkspaceRemoteSSHOptionFilter.durableOptions(sshOptions),
             preserveAfterTerminalExit: preserveAfterTerminalExit ? true : nil,
-            skipDaemonBootstrap: skipDaemonBootstrap
+            skipDaemonBootstrap: skipDaemonBootstrap,
+            relayPort: preserveAfterTerminalExit ? relayPort : nil,
+            persistentDaemonSlot: preserveAfterTerminalExit ? persistentDaemonSlot : nil
         )
     }
 }

Sources/WorkspaceRemoteSSHBatchCommandBuilder.swift

@@ -10,7 +10,15 @@ enum WorkspaceRemoteSSHBatchCommandBuilder {
         configuration: WorkspaceRemoteConfiguration,
         remotePath: String
     ) -> [String] {
-        let script = "exec \(shellSingleQuoted(remotePath)) serve --stdio"
+        var serveArguments = ["serve", "--stdio"]
+        if let slot = configuration.persistentDaemonSlot?.trimmingCharacters(in: .whitespacesAndNewlines),
+           !slot.isEmpty {
+            serveArguments += ["--persistent", "--slot", slot]
+        }
+        let daemonCommand = ([remotePath] + serveArguments)
+            .map(shellSingleQuoted)
+            .joined(separator: " ")
+        let script = "exec \(daemonCommand)"
         let command = "sh -c \(shellSingleQuoted(script))"
         return ["-T"]
             + batchArguments(configuration: configuration)