refactor(macos): inject main-actor services into node runtime

apps/macos/Tests/ClawdbotIPCTests/MacNodeRuntimeTests.swift

@@ -1,9 +1,9 @@
 import ClawdbotKit
+import CoreLocation
 import Foundation
 import Testing
 @testable import Clawdbot
 
-@Suite(.serialized)
 struct MacNodeRuntimeTests {
     @Test func handleInvokeRejectsUnknownCommand() async {
         let runtime = MacNodeRuntime()
@@ -31,21 +31,58 @@ struct MacNodeRuntimeTests {
     }
 
     @Test func handleInvokeCameraListRequiresEnabledCamera() async {
-        let defaults = UserDefaults.standard
-        let previous = defaults.object(forKey: cameraEnabledKey)
-        defaults.set(false, forKey: cameraEnabledKey)
-        defer {
-            if let previous {
-                defaults.set(previous, forKey: cameraEnabledKey)
-            } else {
-                defaults.removeObject(forKey: cameraEnabledKey)
+        await TestIsolation.withUserDefaultsValues([cameraEnabledKey: false]) {
+            let runtime = MacNodeRuntime()
+            let response = await runtime.handleInvoke(
+                BridgeInvokeRequest(id: "req-4", command: ClawdbotCameraCommand.list.rawValue))
+            #expect(response.ok == false)
+            #expect(response.error?.message.contains("CAMERA_DISABLED") == true)
+        }
+    }
+
+    @Test func handleInvokeScreenRecordUsesInjectedServices() async throws {
+        @MainActor
+        final class FakeMainActorServices: MacNodeRuntimeMainActorServices, @unchecked Sendable {
+            func recordScreen(
+                screenIndex: Int?,
+                durationMs: Int?,
+                fps: Double?,
+                includeAudio: Bool?,
+                outPath: String?) async throws -> (path: String, hasAudio: Bool)
+            {
+                let url = FileManager.default.temporaryDirectory
+                    .appendingPathComponent("clawdbot-test-screen-record-\(UUID().uuidString).mp4")
+                try Data("ok".utf8).write(to: url)
+                return (path: url.path, hasAudio: false)
+            }
+
+            func locationAuthorizationStatus() -> CLAuthorizationStatus { .authorizedAlways }
+            func locationAccuracyAuthorization() -> CLAccuracyAuthorization { .fullAccuracy }
+            func currentLocation(
+                desiredAccuracy: ClawdbotLocationAccuracy,
+                maxAgeMs: Int?,
+                timeoutMs: Int?) async throws -> CLLocation
+            {
+                CLLocation(latitude: 0, longitude: 0)
             }
         }
 
-        let runtime = MacNodeRuntime()
+        let services = await MainActor.run { FakeMainActorServices() }
+        let runtime = MacNodeRuntime(makeMainActorServices: { services })
+
+        let params = MacNodeScreenRecordParams(durationMs: 250)
+        let json = String(data: try JSONEncoder().encode(params), encoding: .utf8)
         let response = await runtime.handleInvoke(
-            BridgeInvokeRequest(id: "req-4", command: ClawdbotCameraCommand.list.rawValue))
-        #expect(response.ok == false)
-        #expect(response.error?.message.contains("CAMERA_DISABLED") == true)
+            BridgeInvokeRequest(id: "req-5", command: MacNodeScreenCommand.record.rawValue, paramsJSON: json))
+        #expect(response.ok == true)
+        let payloadJSON = try #require(response.payloadJSON)
+
+        struct Payload: Decodable {
+            var format: String
+            var base64: String
+        }
+        let payload = try JSONDecoder().decode(Payload.self, from: Data(payloadJSON.utf8))
+        #expect(payload.format == "mp4")
+        #expect(!payload.base64.isEmpty)
     }
 }