fix: make Cloud command palette actions follow workspace capabilities

Packages/iOS/CmuxMobileCloudUI/Tests/CmuxMobileCloudUITests/Fakes.swift

@@ -43,3 +43,5 @@ final class FakeConnector: CloudTerminalConnecting, @unchecked Sendable {
         return session
     }
 }
+
+#endif

Packages/macOS/CmuxCommandPalette/Sources/CmuxCommandPalette/Context/CommandPaletteContextKeys.swift

@@ -15,6 +15,24 @@ public struct CommandPaletteContextKeys: Hashable, Sendable {
 
     /// Whether a workspace is selected.
     public static let hasWorkspace = CommandPaletteContextKeys(rawValue: "workspace.hasSelection")
+    /// Whether the selected workspace is owned by a managed Cloud machine.
+    ///
+    /// The app sets this key from the workspace's explicit managed Cloud VM
+    /// identity. Generic SSH and other remote workspaces intentionally do not
+    /// set it; legacy managed Cloud SSH workspaces do.
+    public static let workspaceIsCloud = CommandPaletteContextKeys(rawValue: "workspace.isCloud")
+    /// Whether the selected Cloud VM has a server-provided capability snapshot.
+    public static let cloudVMCapabilitiesKnown = CommandPaletteContextKeys(rawValue: "workspace.cloudVM.capabilitiesKnown")
+    /// Whether the selected Cloud VM supports fork.
+    public static let cloudVMSupportsFork = CommandPaletteContextKeys(rawValue: "workspace.cloudVM.supportsFork")
+    /// Whether the selected Cloud VM supports checkpoint or template promotion.
+    public static let cloudVMSupportsSnapshot = CommandPaletteContextKeys(rawValue: "workspace.cloudVM.supportsSnapshot")
+    /// Whether the selected Cloud VM supports restoring a checkpoint.
+    public static let cloudVMSupportsRestore = CommandPaletteContextKeys(rawValue: "workspace.cloudVM.supportsRestore")
+    /// Whether the selected Cloud VM can provide port previews.
+    public static let cloudVMSupportsPorts = CommandPaletteContextKeys(rawValue: "workspace.cloudVM.supportsPorts")
+    /// Whether the selected Cloud VM permits control-plane command execution.
+    public static let cloudVMSupportsExec = CommandPaletteContextKeys(rawValue: "workspace.cloudVM.supportsExec")
     /// Selected workspace display name.
     public static let workspaceName = CommandPaletteContextKeys(rawValue: "workspace.name")
     /// Whether the workspace has a custom name.

Packages/macOS/CmuxCommandPalette/Sources/CmuxCommandPalette/Policy/CommandPaletteCloudCapabilityPolicy.swift

@@ -0,0 +1,100 @@
+import Foundation
+
+/// Describes where a command-palette action can run relative to a managed
+/// Cloud workspace.
+public enum CommandPaletteCloudCapability: Equatable, Sendable {
+    /// The action is valid for both local and Cloud workspaces.
+    case shared
+    /// The action needs a selected Cloud workspace and its current VM.
+    case cloudOnly
+    /// The action creates or reads a resource on this Mac's local filesystem,
+    /// browser stack, or simulator and cannot target a Cloud workspace.
+    case localOnly
+}
+
+/// Classifies built-in command-palette actions before they are materialized.
+/// The app owns command contributions and handlers; this package owns the
+/// pure capability decision so it can be tested without app singletons.
+public struct CommandPaletteCloudCapabilityPolicy: Sendable {
+    /// Creates the stateless capability policy.
+    public init() {}
+
+    /// Returns the Cloud capability for a built-in command ID. Unknown and
+    /// user-configured actions remain shared unless they add their own gate.
+    public func capability(for commandId: String) -> CommandPaletteCloudCapability {
+        if commandId.hasPrefix("palette.terminalOpenDirectory.") {
+            return .localOnly
+        }
+
+        switch commandId {
+        case "palette.cloud.fork",
+             "palette.cloud.snapshot",
+             "palette.cloud.promoteTemplate",
+             "palette.cloud.status",
+             "palette.cloud.ports",
+             "palette.cloud.tools",
+             "palette.cloud.handoff":
+            return .cloudOnly
+        case "palette.newBrowserWorkspace",
+             "palette.newAgentChat",
+             "palette.newSimulatorPane",
+             "palette.openFolder",
+             "palette.openFolderInVSCodeInline",
+             "palette.openWorkspacePullRequests",
+             "palette.openDiffViewer",
+             "palette.openDirectoryDiffViewer",
+             "palette.findInDirectory",
+             "palette.vscodeServeWebStop",
+             "palette.vscodeServeWebRestart",
+             "palette.terminalAttachTextBoxFile",
+             "palette.openTerminalChatView":
+            return .localOnly
+        default:
+            return .shared
+        }
+    }
+
+    /// Returns whether a command can be materialized for the supplied context.
+    /// Cloud-only commands require the selected Cloud workspace; local-only
+    /// commands are omitted while a Cloud workspace is selected.
+    public func allows(
+        commandId: String,
+        context: CommandPaletteContextSnapshot
+    ) -> Bool {
+        switch capability(for: commandId) {
+        case .shared:
+            // Restore creates a new VM from a supplied snapshot and remains
+            // available from a local workspace, but a selected Cloud VM can
+            // advertise that the provider does not support restore.
+            guard commandId == "palette.cloud.restore",
+                  context.bool(CommandPaletteContextKeys.workspaceIsCloud),
+                  context.bool(CommandPaletteContextKeys.cloudVMCapabilitiesKnown) else {
+                return true
+            }
+            return context.bool(CommandPaletteContextKeys.cloudVMSupportsRestore)
+        case .cloudOnly:
+            guard context.bool(CommandPaletteContextKeys.workspaceIsCloud) else {
+                return false
+            }
+            guard context.bool(CommandPaletteContextKeys.cloudVMCapabilitiesKnown) else {
+                return true
+            }
+            switch commandId {
+            case "palette.cloud.fork":
+                return context.bool(CommandPaletteContextKeys.cloudVMSupportsFork)
+            case "palette.cloud.snapshot", "palette.cloud.promoteTemplate":
+                return context.bool(CommandPaletteContextKeys.cloudVMSupportsSnapshot)
+            case "palette.cloud.restore":
+                return context.bool(CommandPaletteContextKeys.cloudVMSupportsRestore)
+            case "palette.cloud.ports":
+                return context.bool(CommandPaletteContextKeys.cloudVMSupportsPorts)
+            case "palette.cloud.tools":
+                return context.bool(CommandPaletteContextKeys.cloudVMSupportsExec)
+            default:
+                return true
+            }
+        case .localOnly:
+            return !context.bool(CommandPaletteContextKeys.workspaceIsCloud)
+        }
+    }
+}

Packages/macOS/CmuxCommandPalette/Tests/CmuxCommandPaletteTests/CommandPaletteCloudCapabilityPolicyTests.swift

@@ -0,0 +1,169 @@
+import CmuxCommandPalette
+import Testing
+
+@Suite("Command palette Cloud capability policy")
+struct CommandPaletteCloudCapabilityPolicyTests {
+    private let policy = CommandPaletteCloudCapabilityPolicy()
+
+    /// Representative command IDs cover each capability classification.
+    @Test("classifies representative shared, Cloud-only, and local-only commands")
+    func representativeCommandsHaveExpectedCapabilities() {
+        #expect(
+            policy.capability(for: "palette.newTerminalTab") == .shared
+        )
+        #expect(
+            policy.capability(for: "palette.terminalSplitRight") == .shared
+        )
+        #expect(
+            policy.capability(for: "palette.browserBack") == .shared
+        )
+        #expect(
+            policy.capability(for: "palette.cloud.status") == .cloudOnly
+        )
+        #expect(
+            policy.capability(for: "palette.cloud.fork") == .cloudOnly
+        )
+        #expect(
+            policy.capability(for: "palette.cloud.restore") == .shared
+        )
+        #expect(
+            policy.capability(for: "palette.cloud.newMachine") == .shared
+        )
+        #expect(
+            policy.capability(for: "palette.browserSplitRight") == .shared
+        )
+        #expect(
+            policy.capability(for: "palette.openDirectoryDiffViewer") == .localOnly
+        )
+        #expect(
+            policy.capability(for: "palette.terminalOpenDirectory.finder") == .localOnly
+        )
+        #expect(
+            policy.capability(for: "palette.openTerminalChatView") == .localOnly
+        )
+    }
+
+    /// The audited sets stay explicit so a new palette action cannot silently drift.
+    @Test("keeps the audited Cloud and local-only command sets explicit")
+    func auditedCapabilitySetsRemainStable() {
+        let cloudOnly = [
+            "palette.cloud.fork",
+            "palette.cloud.snapshot",
+            "palette.cloud.promoteTemplate",
+            "palette.cloud.status",
+            "palette.cloud.ports",
+            "palette.cloud.tools",
+            "palette.cloud.handoff",
+        ]
+        let localOnly = [
+            "palette.newBrowserWorkspace",
+            "palette.newAgentChat",
+            "palette.newSimulatorPane",
+            "palette.openFolder",
+            "palette.openFolderInVSCodeInline",
+            "palette.openWorkspacePullRequests",
+            "palette.openDiffViewer",
+            "palette.openDirectoryDiffViewer",
+            "palette.findInDirectory",
+            "palette.vscodeServeWebStop",
+            "palette.vscodeServeWebRestart",
+            "palette.terminalAttachTextBoxFile",
+            "palette.openTerminalChatView",
+            "palette.terminalOpenDirectory.finder",
+        ]
+
+        #expect(cloudOnly.allSatisfy { policy.capability(for: $0) == .cloudOnly })
+        #expect(localOnly.allSatisfy { policy.capability(for: $0) == .localOnly })
+        #expect(policy.capability(for: "palette.newTerminalTab") == .shared)
+        #expect(policy.capability(for: "palette.newBrowserTab") == .shared)
+        #expect(policy.capability(for: "palette.browserSplitRight") == .shared)
+        #expect(policy.capability(for: "palette.browserSplitDown") == .shared)
+        #expect(policy.capability(for: "palette.terminalSplitBrowserRight") == .shared)
+        #expect(policy.capability(for: "palette.terminalSplitBrowserDown") == .shared)
+        #expect(policy.capability(for: "palette.browserBack") == .shared)
+        #expect(policy.capability(for: "palette.cloud.restore") == .shared)
+    }
+
+    /// Context gating allows only capabilities valid for the selected workspace.
+    @Test("scopes Cloud-only and local-only commands to the workspace context")
+    func contextAllowsOnlyValidCapabilities() {
+        let localContext = CommandPaletteContextSnapshot()
+        var cloudContext = CommandPaletteContextSnapshot()
+        cloudContext.setBool(CommandPaletteContextKeys.workspaceIsCloud, true)
+
+        #expect(
+            policy.allows(
+                commandId: "palette.terminalSplitRight",
+                context: localContext
+            )
+        )
+        #expect(
+            policy.allows(
+                commandId: "palette.terminalSplitRight",
+                context: cloudContext
+            )
+        )
+        #expect(
+            policy.allows(
+                commandId: "palette.cloud.status",
+                context: cloudContext
+            )
+        )
+        #expect(
+            !policy.allows(
+                commandId: "palette.cloud.status",
+                context: localContext
+            )
+        )
+        #expect(
+            policy.allows(
+                commandId: "palette.browserSplitRight",
+                context: localContext
+            )
+        )
+        #expect(
+            policy.allows(
+                commandId: "palette.browserSplitRight",
+                context: cloudContext
+            )
+        )
+        #expect(policy.allows(commandId: "palette.cloud.restore", context: localContext))
+        #expect(policy.allows(commandId: "palette.cloud.restore", context: cloudContext))
+        #expect(
+            !policy.allows(
+                commandId: "palette.openTerminalChatView",
+                context: cloudContext
+            )
+        )
+        #expect(
+            policy.allows(
+                commandId: "palette.openTerminalChatView",
+                context: localContext
+            )
+        )
+
+        cloudContext.setBool(CommandPaletteContextKeys.cloudVMCapabilitiesKnown, true)
+        cloudContext.setBool(CommandPaletteContextKeys.cloudVMSupportsFork, false)
+        cloudContext.setBool(CommandPaletteContextKeys.cloudVMSupportsSnapshot, false)
+        cloudContext.setBool(CommandPaletteContextKeys.cloudVMSupportsRestore, false)
+        cloudContext.setBool(CommandPaletteContextKeys.cloudVMSupportsPorts, false)
+        cloudContext.setBool(CommandPaletteContextKeys.cloudVMSupportsExec, false)
+        #expect(!policy.allows(commandId: "palette.cloud.fork", context: cloudContext))
+        #expect(!policy.allows(commandId: "palette.cloud.snapshot", context: cloudContext))
+        #expect(!policy.allows(commandId: "palette.cloud.promoteTemplate", context: cloudContext))
+        #expect(!policy.allows(commandId: "palette.cloud.restore", context: cloudContext))
+        #expect(!policy.allows(commandId: "palette.cloud.ports", context: cloudContext))
+        #expect(!policy.allows(commandId: "palette.cloud.tools", context: cloudContext))
+        #expect(policy.allows(commandId: "palette.cloud.status", context: cloudContext))
+
+        cloudContext.setBool(CommandPaletteContextKeys.cloudVMSupportsRestore, true)
+        cloudContext.setBool(CommandPaletteContextKeys.cloudVMSupportsPorts, true)
+        #expect(policy.allows(commandId: "palette.cloud.restore", context: cloudContext))
+        #expect(policy.allows(commandId: "palette.cloud.ports", context: cloudContext))
+        #expect(!policy.allows(commandId: "palette.cloud.tools", context: cloudContext))
+
+        // Restore remains shared for local workspaces because it creates a
+        // new VM from an explicitly supplied snapshot ID.
+        #expect(policy.allows(commandId: "palette.cloud.restore", context: localContext))
+    }
+}