iOS: add Mac power controls

Packages/iOS/CmuxMobileShell/Sources/CmuxMobileShell/MobileMacPowerError.swift

@@ -0,0 +1,7 @@
+import Foundation
+
+public enum MobileMacPowerError: Error, Equatable, Sendable {
+    case unavailable
+    case unsupported
+    case invalidResponse
+}

Packages/iOS/CmuxMobileShell/Sources/CmuxMobileShell/MobileMacPowerStatus.swift

@@ -0,0 +1,20 @@
+import Foundation
+
+public struct MobileMacPowerStatus: Equatable, Sendable {
+    public let keepAwakeEnabled: Bool
+    public let lowPowerEnabled: Bool
+
+    static func decode(_ data: Data) throws -> MobileMacPowerStatus {
+        let envelope = try JSONSerialization.jsonObject(with: data) as? [String: Any]
+        guard envelope?["ok"] as? Bool == true,
+              let result = envelope?["result"] as? [String: Any],
+              let keepAwake = result["keep_awake_enabled"] as? Bool,
+              let lowPower = result["low_power_enabled"] as? Bool else {
+            throw MobileMacPowerError.invalidResponse
+        }
+        return MobileMacPowerStatus(
+            keepAwakeEnabled: keepAwake,
+            lowPowerEnabled: lowPower
+        )
+    }
+}

Packages/iOS/CmuxMobileShell/Sources/CmuxMobileShell/MobileShellComposite+MacPower.swift

@@ -0,0 +1,39 @@
+import CmuxMobileRPC
+import Foundation
+
+extension MobileShellComposite {
+    public var supportsMacPowerControl: Bool {
+        supportedHostCapabilities.contains(Self.macPowerCapability)
+    }
+
+    public func macPowerStatus() async throws -> MobileMacPowerStatus {
+        try await sendMacPowerRequest(method: "mac.power.status", params: [:])
+    }
+
+    public func sleepMacDisplay() async throws {
+        guard supportsMacPowerControl, let remoteClient else { throw MobileMacPowerError.unavailable }
+        let request = try MobileCoreRPCClient.requestData(method: "mac.power.sleep_display", params: [:])
+        _ = try await remoteClient.sendRequest(request)
+    }
+
+    public func setMacKeepAwake(_ enabled: Bool) async throws -> MobileMacPowerStatus {
+        try await sendMacPowerRequest(
+            method: "mac.power.keep_awake.set", params: ["enabled": enabled]
+        )
+    }
+
+    public func setMacLowPowerMode(_ enabled: Bool) async throws -> MobileMacPowerStatus {
+        try await sendMacPowerRequest(
+            method: "mac.power.low_power.set", params: ["enabled": enabled]
+        )
+    }
+
+    private func sendMacPowerRequest(
+        method: String, params: [String: Any]
+    ) async throws -> MobileMacPowerStatus {
+        guard supportsMacPowerControl, let remoteClient else { throw MobileMacPowerError.unavailable }
+        let request = try MobileCoreRPCClient.requestData(method: method, params: params)
+        let response = try await remoteClient.sendRequest(request)
+        return try MobileMacPowerStatus.decode(response)
+    }
+}

Packages/iOS/CmuxMobileShell/Sources/CmuxMobileShell/MobileShellComposite.swift

@@ -99,6 +99,7 @@ public final class MobileShellComposite: MobileTerminalOutputSinking {
     static let terminalArtifactCapability = "terminal.artifact.v1"
     static let dogfoodFeedbackCapability = "dogfood.v1"
     static let workspaceGroupsCapability = "workspace.groups.v1"
+    static let macPowerCapability = "mac.power.control.v1"
     private static let terminalOutputCapabilityTimeoutNanoseconds: UInt64 = 750_000_000
     /// How long the render-grid stream may stay silent (no event of any topic)
     /// before the liveness watchdog suspects the push subscription is dead and

Packages/iOS/CmuxMobileShell/Tests/CmuxMobileShellTests/MobileMacPowerStatusTests.swift

@@ -0,0 +1,28 @@
+import Foundation
+import Testing
+@testable import CmuxMobileShell
+
+@Suite struct MobileMacPowerStatusTests {
+    @Test func decodesAuthoritativeStatus() throws {
+        let data = try JSONSerialization.data(withJSONObject: [
+            "ok": true,
+            "result": [
+                "keep_awake_enabled": true,
+                "low_power_enabled": false,
+            ],
+        ])
+        let status = try MobileMacPowerStatus.decode(data)
+        #expect(status.keepAwakeEnabled)
+        #expect(!status.lowPowerEnabled)
+    }
+
+    @Test func rejectsIncompleteStatus() throws {
+        let data = try JSONSerialization.data(withJSONObject: [
+            "ok": true,
+            "result": ["keep_awake_enabled": true],
+        ])
+        #expect(throws: MobileMacPowerError.invalidResponse) {
+            try MobileMacPowerStatus.decode(data)
+        }
+    }
+}

Packages/iOS/CmuxMobileShellUI/Sources/CmuxMobileShellUI/MacComputerDetailView.swift

@@ -35,6 +35,10 @@ struct MacComputerDetailView: View {
     @State private var pendingCustomName: String?
     @State private var pendingCustomColor: String?
     @State private var pendingCustomIcon: String?
+    @State private var macPowerStatus: MobileMacPowerStatus?
+    @State private var macPowerError: String?
+    @State private var isMacPowerBusy = false
+    @State private var pendingDisplaySleep = false
 
     /// Curated icon choices: a few computer/utility SF Symbols + emojis.
     private static let symbolChoices = [
@@ -70,6 +74,7 @@ struct MacComputerDetailView: View {
             presenceSection
             routesSection
             identitySection
+            if isForeground && store.supportsMacPowerControl { macPowerSection }
             actionsSection
         }
         .navigationTitle(displayTitle)
@@ -86,6 +91,18 @@ struct MacComputerDetailView: View {
                 customColorPick = color
             }
         }
+        .confirmationDialog(
+            L10n.string("mobile.macPower.sleep.confirm.title", defaultValue: "Sleep Mac display?"),
+            isPresented: $pendingDisplaySleep,
+            titleVisibility: .visible
+        ) {
+            Button(L10n.string("mobile.macPower.sleep", defaultValue: "Sleep Display"), role: .destructive) {
+                runPowerAction { try await store.sleepMacDisplay() }
+            }
+            Button(L10n.string("mobile.common.cancel", defaultValue: "Cancel"), role: .cancel) {}
+        } message: {
+            Text(L10n.string("mobile.macPower.sleep.confirm.message", defaultValue: "The Mac stays awake, but all connected displays turn off."))
+        }
         .confirmationDialog(
             "\(L10n.string("mobile.computers.removeTitlePrefix", defaultValue: "Remove")) \(displayTitle)?",
             isPresented: $pendingRemoval,
@@ -100,6 +117,10 @@ struct MacComputerDetailView: View {
         } message: {
             Text(removeMessage)
         }
+        .task(id: "\(isForeground)-\(store.supportsMacPowerControl)") {
+            guard isForeground, store.supportsMacPowerControl else { return }
+            await refreshMacPower()
+        }
     }
 
     // MARK: - Appearance editing
@@ -450,6 +471,91 @@ struct MacComputerDetailView: View {
         }
     }
 
+
+    @ViewBuilder
+    private var macPowerSection: some View {
+        Section(L10n.string("mobile.macPower.section", defaultValue: "Mac Power")) {
+            Toggle(
+                L10n.string("mobile.macPower.keepAwake", defaultValue: "Keep Mac Awake"),
+                isOn: Binding(
+                    get: { macPowerStatus?.keepAwakeEnabled ?? false },
+                    set: { enabled in
+                        runPowerStatusAction { try await store.setMacKeepAwake(enabled) }
+                    }
+                )
+            )
+            .disabled(isMacPowerBusy || macPowerStatus == nil)
+            .accessibilityIdentifier("MobileMacKeepAwakeSwitch")
+
+            Toggle(
+                L10n.string("mobile.macPower.lowPower", defaultValue: "Low Power Mode"),
+                isOn: Binding(
+                    get: { macPowerStatus?.lowPowerEnabled ?? false },
+                    set: { enabled in
+                        runPowerStatusAction { try await store.setMacLowPowerMode(enabled) }
+                    }
+                )
+            )
+            .disabled(isMacPowerBusy || macPowerStatus == nil)
+            .accessibilityIdentifier("MobileMacLowPowerSwitch")
+
+            Button {
+                pendingDisplaySleep = true
+            } label: {
+                Label(L10n.string("mobile.macPower.sleep", defaultValue: "Sleep Display"), systemImage: "moon.fill")
+            }
+            .disabled(isMacPowerBusy)
+            .accessibilityIdentifier("MobileMacSleepDisplayButton")
+
+            if isMacPowerBusy { ProgressView() }
+            if let macPowerError {
+                Text(macPowerError).foregroundStyle(.red)
+                    .accessibilityIdentifier("MobileMacPowerError")
+            }
+        }
+    }
+
+    private func refreshMacPower() async {
+        isMacPowerBusy = true
+        defer { isMacPowerBusy = false }
+        do {
+            let status = try await store.macPowerStatus()
+            macPowerStatus = status
+            macPowerError = nil
+        } catch {
+            macPowerError = L10n.string("mobile.macPower.error", defaultValue: "Couldn't update Mac power controls.")
+        }
+    }
+
+    private func runPowerAction(_ action: @escaping @MainActor () async throws -> Void) {
+        guard !isMacPowerBusy else { return }
+        isMacPowerBusy = true
+        macPowerError = nil
+        Task {
+            defer { isMacPowerBusy = false }
+            do { try await action() }
+            catch { macPowerError = L10n.string("mobile.macPower.error", defaultValue: "Couldn't update Mac power controls.") }
+        }
+    }
+
+    private func runPowerStatusAction(
+        _ action: @escaping @MainActor () async throws -> MobileMacPowerStatus
+    ) {
+        guard !isMacPowerBusy else { return }
+        isMacPowerBusy = true
+        macPowerError = nil
+        Task {
+            defer { isMacPowerBusy = false }
+            do {
+                let status = try await action()
+                macPowerStatus = status
+            } catch {
+                macPowerError = L10n.string("mobile.macPower.error", defaultValue: "Couldn't update Mac power controls.")
+                await refreshMacPower()
+            }
+        }
+    }
+
     private var connectionPhrase: String {
         switch connectionStatus {
         case .connected: return L10n.string("mobile.deviceTree.connected", defaultValue: "Connected")

Sources/MacPowerService.swift

@@ -0,0 +1,49 @@
+import Foundation
+
+@MainActor
+final class MacPowerService {
+    enum ServiceError: Error, Equatable { case assertionFailed, lowPowerMutationFailed }
+
+    private let powerControls: any SleepyPowerControlling
+    private let assertionHolder: any PowerAssertionHolding
+
+    init(
+        powerControls: any SleepyPowerControlling,
+        assertionHolder: any PowerAssertionHolding
+    ) {
+        self.powerControls = powerControls
+        self.assertionHolder = assertionHolder
+    }
+
+    convenience init() {
+        self.init(
+            powerControls: SleepyPowerControls(),
+            assertionHolder: PowerAssertionHolder()
+        )
+    }
+
+    func status() async -> MacPowerStatus {
+        MacPowerStatus(
+            keepAwakeEnabled: assertionHolder.isEnabled,
+            lowPowerEnabled: await powerControls.isLowPowerOn()
+        )
+    }
+
+    func sleepDisplay() async { await powerControls.sleepDisplayNow() }
+
+    func setKeepAwake(_ enabled: Bool) async throws -> MacPowerStatus {
+        do { try assertionHolder.setEnabled(enabled) }
+        catch { throw ServiceError.assertionFailed }
+        return await status()
+    }
+
+    func setLowPowerMode(_ enabled: Bool) async throws -> MacPowerStatus {
+        let applied = await powerControls.setLowPowerMode(enabled)
+        guard applied == enabled else { throw ServiceError.lowPowerMutationFailed }
+        let authoritative = await status()
+        guard authoritative.lowPowerEnabled == enabled else {
+            throw ServiceError.lowPowerMutationFailed
+        }
+        return authoritative
+    }
+}

Sources/MacPowerStatus.swift

@@ -0,0 +1,6 @@
+import Foundation
+
+struct MacPowerStatus: Equatable, Sendable {
+    let keepAwakeEnabled: Bool
+    let lowPowerEnabled: Bool
+}

Sources/Mobile/MobileHostService+Capabilities.swift

@@ -35,6 +35,7 @@ extension MobileHostService {
             "chat.artifact.v1",
             "chat.artifact.gallery.v1",
             "dogfood.v1",
+            "mac.power.control.v1",
             // The workspace list carries group sections (group_id per workspace +
             // a top-level groups array) and the host accepts
             // workspace.group.collapse/expand from mobile. iOS feature-detects

Sources/Mobile/MobileHostService+TicketAuthorization.swift

@@ -79,6 +79,9 @@ extension MobileHostService {
             )
         case "mobile.events.subscribe", "mobile.events.unsubscribe":
             return nil
+        case "mac.power.status", "mac.power.sleep_display",
+             "mac.power.keep_awake.set", "mac.power.low_power.set":
+            return ticketMacScopedWorkspaceMutationAuthorizationError(authorization: authorization)
         case "mobile.host.status":
             return nil
         default:

Sources/Mobile/MobileHostService.swift

@@ -1086,10 +1086,15 @@ final class MobileHostService {
             guard requiresAuthorization(method: request.method) else { return nil }
             return await stackAuthorization(request)
         case .irohAdmission:
-            return nil
+            guard isPrivilegedMacPowerMethod(request.method) else { return nil }
+            return await stackAuthorization(request)
         }
     }
 
+    nonisolated private static func isPrivilegedMacPowerMethod(_ method: String) -> Bool {
+        method == "mac.power.status" || method.hasPrefix("mac.power.")
+    }
+
     nonisolated static func connectionStatusResult(
         for request: MobileHostRPCRequest,
         authorization: MobileHostConnectionAuthorizationContext,

Sources/PowerAssertionHolder.swift

@@ -0,0 +1,33 @@
+import Foundation
+import IOKit.pwr_mgt
+
+@MainActor
+final class PowerAssertionHolder: PowerAssertionHolding {
+    enum HolderError: Error { case createFailed(IOReturn) }
+
+    private var assertionID = IOPMAssertionID(0)
+    var isEnabled: Bool { assertionID != 0 }
+
+    deinit {
+        if assertionID != 0 { IOPMAssertionRelease(assertionID) }
+    }
+
+    func setEnabled(_ enabled: Bool) throws {
+        guard enabled != isEnabled else { return }
+        if enabled {
+            var newID = IOPMAssertionID(0)
+            let result = IOPMAssertionCreateWithName(
+                kIOPMAssertionTypePreventUserIdleSystemSleep as CFString,
+                IOPMAssertionLevel(kIOPMAssertionLevelOn),
+                "cmux remote keep-awake" as CFString,
+                &newID
+            )
+            guard result == kIOReturnSuccess else { throw HolderError.createFailed(result) }
+            assertionID = newID
+        } else {
+            let result = IOPMAssertionRelease(assertionID)
+            guard result == kIOReturnSuccess else { throw HolderError.createFailed(result) }
+            assertionID = IOPMAssertionID(0)
+        }
+    }
+}

Sources/PowerAssertionHolding.swift

@@ -0,0 +1,7 @@
+import Foundation
+
+@MainActor
+protocol PowerAssertionHolding: AnyObject {
+    var isEnabled: Bool { get }
+    func setEnabled(_ enabled: Bool) throws
+}