Include full contents of all nested repositories

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

openclaw/apps/ios/Tests/AppCoverageTests.swift

@@ -0,0 +1,31 @@
+import SwiftUI
+import Testing
+@testable import OpenClaw
+
+@Suite struct AppCoverageTests {
+    @Test @MainActor func nodeAppModelUpdatesBackgroundedState() {
+        let appModel = NodeAppModel()
+
+        appModel.setScenePhase(.background)
+        #expect(appModel.isBackgrounded == true)
+
+        appModel.setScenePhase(.inactive)
+        #expect(appModel.isBackgrounded == false)
+
+        appModel.setScenePhase(.active)
+        #expect(appModel.isBackgrounded == false)
+    }
+
+    @Test @MainActor func voiceWakeStartReportsUnsupportedOnSimulator() async {
+        let voiceWake = VoiceWakeManager()
+        voiceWake.isEnabled = true
+
+        await voiceWake.start()
+
+        #expect(voiceWake.isListening == false)
+        #expect(voiceWake.statusText.contains("Simulator"))
+
+        voiceWake.stop()
+        #expect(voiceWake.statusText == "Off")
+    }
+}

openclaw/apps/ios/Tests/CameraControllerClampTests.swift

@@ -0,0 +1,24 @@
+import Testing
+@testable import OpenClaw
+
+@Suite struct CameraControllerClampTests {
+    @Test func clampQualityDefaultsAndBounds() {
+        #expect(CameraController.clampQuality(nil) == 0.9)
+        #expect(CameraController.clampQuality(0.0) == 0.05)
+        #expect(CameraController.clampQuality(0.049) == 0.05)
+        #expect(CameraController.clampQuality(0.05) == 0.05)
+        #expect(CameraController.clampQuality(0.5) == 0.5)
+        #expect(CameraController.clampQuality(1.0) == 1.0)
+        #expect(CameraController.clampQuality(1.1) == 1.0)
+    }
+
+    @Test func clampDurationDefaultsAndBounds() {
+        #expect(CameraController.clampDurationMs(nil) == 3000)
+        #expect(CameraController.clampDurationMs(0) == 250)
+        #expect(CameraController.clampDurationMs(249) == 250)
+        #expect(CameraController.clampDurationMs(250) == 250)
+        #expect(CameraController.clampDurationMs(1000) == 1000)
+        #expect(CameraController.clampDurationMs(60000) == 60000)
+        #expect(CameraController.clampDurationMs(60001) == 60000)
+    }
+}

openclaw/apps/ios/Tests/CameraControllerErrorTests.swift

@@ -0,0 +1,14 @@
+import Testing
+@testable import OpenClaw
+
+@Suite struct CameraControllerErrorTests {
+    @Test func errorDescriptionsAreStable() {
+        #expect(CameraController.CameraError.cameraUnavailable.errorDescription == "Camera unavailable")
+        #expect(CameraController.CameraError.microphoneUnavailable.errorDescription == "Microphone unavailable")
+        #expect(CameraController.CameraError.permissionDenied(kind: "Camera")
+            .errorDescription == "Camera permission denied")
+        #expect(CameraController.CameraError.invalidParams("bad").errorDescription == "bad")
+        #expect(CameraController.CameraError.captureFailed("nope").errorDescription == "nope")
+        #expect(CameraController.CameraError.exportFailed("export").errorDescription == "export")
+    }
+}

openclaw/apps/ios/Tests/DeepLinkParserTests.swift

@@ -0,0 +1,181 @@
+import OpenClawKit
+import Foundation
+import Testing
+
+@Suite struct DeepLinkParserTests {
+    @Test func parseRejectsUnknownHost() {
+        let url = URL(string: "openclaw://nope?message=hi")!
+        #expect(DeepLinkParser.parse(url) == nil)
+    }
+
+    @Test func parseHostIsCaseInsensitive() {
+        let url = URL(string: "openclaw://AGENT?message=Hello")!
+        #expect(DeepLinkParser.parse(url) == .agent(.init(
+            message: "Hello",
+            sessionKey: nil,
+            thinking: nil,
+            deliver: false,
+            to: nil,
+            channel: nil,
+            timeoutSeconds: nil,
+            key: nil)))
+    }
+
+    @Test func parseRejectsNonOpenClawScheme() {
+        let url = URL(string: "https://example.com/agent?message=hi")!
+        #expect(DeepLinkParser.parse(url) == nil)
+    }
+
+    @Test func parseRejectsEmptyMessage() {
+        let url = URL(string: "openclaw://agent?message=%20%20%0A")!
+        #expect(DeepLinkParser.parse(url) == nil)
+    }
+
+    @Test func parseAgentLinkParsesCommonFields() {
+        let url =
+            URL(string: "openclaw://agent?message=Hello&deliver=1&sessionKey=node-test&thinking=low&timeoutSeconds=30")!
+        #expect(
+            DeepLinkParser.parse(url) == .agent(
+                .init(
+                    message: "Hello",
+                    sessionKey: "node-test",
+                    thinking: "low",
+                    deliver: true,
+                    to: nil,
+                    channel: nil,
+                    timeoutSeconds: 30,
+                    key: nil)))
+    }
+
+    @Test func parseAgentLinkParsesTargetRoutingFields() {
+        let url =
+            URL(
+                string: "openclaw://agent?message=Hello%20World&deliver=1&to=%2B15551234567&channel=whatsapp&key=secret")!
+        #expect(
+            DeepLinkParser.parse(url) == .agent(
+                .init(
+                    message: "Hello World",
+                    sessionKey: nil,
+                    thinking: nil,
+                    deliver: true,
+                    to: "+15551234567",
+                    channel: "whatsapp",
+                    timeoutSeconds: nil,
+                    key: "secret")))
+    }
+
+    @Test func parseRejectsNegativeTimeoutSeconds() {
+        let url = URL(string: "openclaw://agent?message=Hello&timeoutSeconds=-1")!
+        #expect(DeepLinkParser.parse(url) == .agent(.init(
+            message: "Hello",
+            sessionKey: nil,
+            thinking: nil,
+            deliver: false,
+            to: nil,
+            channel: nil,
+            timeoutSeconds: nil,
+            key: nil)))
+    }
+
+    @Test func parseGatewayLinkParsesCommonFields() {
+        let url = URL(
+            string: "openclaw://gateway?host=openclaw.local&port=18789&tls=1&token=abc&password=def")!
+        #expect(
+            DeepLinkParser.parse(url) == .gateway(
+                .init(host: "openclaw.local", port: 18789, tls: true, token: "abc", password: "def")))
+    }
+
+    @Test func parseGatewayLinkRejectsInsecureNonLoopbackWs() {
+        let url = URL(
+            string: "openclaw://gateway?host=attacker.example&port=18789&tls=0&token=abc")!
+        #expect(DeepLinkParser.parse(url) == nil)
+    }
+
+    @Test func parseGatewayLinkRejectsInsecurePrefixBypassHost() {
+        let url = URL(
+            string: "openclaw://gateway?host=127.attacker.example&port=18789&tls=0&token=abc")!
+        #expect(DeepLinkParser.parse(url) == nil)
+    }
+
+    @Test func parseGatewaySetupCodeParsesBase64UrlPayload() {
+        let payload = #"{"url":"wss://gateway.example.com:443","token":"tok","password":"pw"}"#
+        let encoded = Data(payload.utf8)
+            .base64EncodedString()
+            .replacingOccurrences(of: "+", with: "-")
+            .replacingOccurrences(of: "/", with: "_")
+            .replacingOccurrences(of: "=", with: "")
+
+        let link = GatewayConnectDeepLink.fromSetupCode(encoded)
+
+        #expect(link == .init(
+            host: "gateway.example.com",
+            port: 443,
+            tls: true,
+            token: "tok",
+            password: "pw"))
+    }
+
+    @Test func parseGatewaySetupCodeRejectsInvalidInput() {
+        #expect(GatewayConnectDeepLink.fromSetupCode("not-a-valid-setup-code") == nil)
+    }
+
+    @Test func parseGatewaySetupCodeDefaultsTo443ForWssWithoutPort() {
+        let payload = #"{"url":"wss://gateway.example.com","token":"tok"}"#
+        let encoded = Data(payload.utf8)
+            .base64EncodedString()
+            .replacingOccurrences(of: "+", with: "-")
+            .replacingOccurrences(of: "/", with: "_")
+            .replacingOccurrences(of: "=", with: "")
+
+        let link = GatewayConnectDeepLink.fromSetupCode(encoded)
+
+        #expect(link == .init(
+            host: "gateway.example.com",
+            port: 443,
+            tls: true,
+            token: "tok",
+            password: nil))
+    }
+
+    @Test func parseGatewaySetupCodeRejectsInsecureNonLoopbackWs() {
+        let payload = #"{"url":"ws://attacker.example:18789","token":"tok"}"#
+        let encoded = Data(payload.utf8)
+            .base64EncodedString()
+            .replacingOccurrences(of: "+", with: "-")
+            .replacingOccurrences(of: "/", with: "_")
+            .replacingOccurrences(of: "=", with: "")
+
+        let link = GatewayConnectDeepLink.fromSetupCode(encoded)
+        #expect(link == nil)
+    }
+
+    @Test func parseGatewaySetupCodeRejectsInsecurePrefixBypassHost() {
+        let payload = #"{"url":"ws://127.attacker.example:18789","token":"tok"}"#
+        let encoded = Data(payload.utf8)
+            .base64EncodedString()
+            .replacingOccurrences(of: "+", with: "-")
+            .replacingOccurrences(of: "/", with: "_")
+            .replacingOccurrences(of: "=", with: "")
+
+        let link = GatewayConnectDeepLink.fromSetupCode(encoded)
+        #expect(link == nil)
+    }
+
+    @Test func parseGatewaySetupCodeAllowsLoopbackWs() {
+        let payload = #"{"url":"ws://127.0.0.1:18789","token":"tok"}"#
+        let encoded = Data(payload.utf8)
+            .base64EncodedString()
+            .replacingOccurrences(of: "+", with: "-")
+            .replacingOccurrences(of: "/", with: "_")
+            .replacingOccurrences(of: "=", with: "")
+
+        let link = GatewayConnectDeepLink.fromSetupCode(encoded)
+
+        #expect(link == .init(
+            host: "127.0.0.1",
+            port: 18789,
+            tls: false,
+            token: "tok",
+            password: nil))
+    }
+}

openclaw/apps/ios/Tests/GatewayConnectionControllerTests.swift

@@ -0,0 +1,122 @@
+import OpenClawKit
+import Foundation
+import Testing
+import UIKit
+@testable import OpenClaw
+
+private func withUserDefaults<T>(_ updates: [String: Any?], _ body: () throws -> T) rethrows -> T {
+    let defaults = UserDefaults.standard
+    var snapshot: [String: Any?] = [:]
+    for key in updates.keys {
+        snapshot[key] = defaults.object(forKey: key)
+    }
+    for (key, value) in updates {
+        if let value {
+            defaults.set(value, forKey: key)
+        } else {
+            defaults.removeObject(forKey: key)
+        }
+    }
+    defer {
+        for (key, value) in snapshot {
+            if let value {
+                defaults.set(value, forKey: key)
+            } else {
+                defaults.removeObject(forKey: key)
+            }
+        }
+    }
+    return try body()
+}
+
+@Suite(.serialized) struct GatewayConnectionControllerTests {
+    @Test @MainActor func resolvedDisplayNameSetsDefaultWhenMissing() {
+        let defaults = UserDefaults.standard
+        let displayKey = "node.displayName"
+
+        withUserDefaults([displayKey: nil, "node.instanceId": "ios-test"]) {
+            let appModel = NodeAppModel()
+            let controller = GatewayConnectionController(appModel: appModel, startDiscovery: false)
+
+            let resolved = controller._test_resolvedDisplayName(defaults: defaults)
+            #expect(!resolved.isEmpty)
+            #expect(defaults.string(forKey: displayKey) == resolved)
+        }
+    }
+
+    @Test @MainActor func currentCapsReflectToggles() {
+        withUserDefaults([
+            "node.instanceId": "ios-test",
+            "node.displayName": "Test Node",
+            "camera.enabled": true,
+            "location.enabledMode": OpenClawLocationMode.always.rawValue,
+            VoiceWakePreferences.enabledKey: true,
+        ]) {
+            let appModel = NodeAppModel()
+            let controller = GatewayConnectionController(appModel: appModel, startDiscovery: false)
+            let caps = Set(controller._test_currentCaps())
+
+            #expect(caps.contains(OpenClawCapability.canvas.rawValue))
+            #expect(caps.contains(OpenClawCapability.screen.rawValue))
+            #expect(caps.contains(OpenClawCapability.camera.rawValue))
+            #expect(caps.contains(OpenClawCapability.location.rawValue))
+            #expect(caps.contains(OpenClawCapability.voiceWake.rawValue))
+        }
+    }
+
+    @Test @MainActor func currentCommandsIncludeLocationWhenEnabled() {
+        withUserDefaults([
+            "node.instanceId": "ios-test",
+            "location.enabledMode": OpenClawLocationMode.whileUsing.rawValue,
+        ]) {
+            let appModel = NodeAppModel()
+            let controller = GatewayConnectionController(appModel: appModel, startDiscovery: false)
+            let commands = Set(controller._test_currentCommands())
+
+            #expect(commands.contains(OpenClawLocationCommand.get.rawValue))
+        }
+    }
+    @Test @MainActor func currentCommandsExcludeDangerousSystemExecCommands() {
+        withUserDefaults([
+            "node.instanceId": "ios-test",
+            "camera.enabled": true,
+            "location.enabledMode": OpenClawLocationMode.whileUsing.rawValue,
+        ]) {
+            let appModel = NodeAppModel()
+            let controller = GatewayConnectionController(appModel: appModel, startDiscovery: false)
+            let commands = Set(controller._test_currentCommands())
+
+            // iOS should expose notify, but not host shell/exec-approval commands.
+            #expect(commands.contains(OpenClawSystemCommand.notify.rawValue))
+            #expect(!commands.contains(OpenClawSystemCommand.run.rawValue))
+            #expect(!commands.contains(OpenClawSystemCommand.which.rawValue))
+            #expect(!commands.contains(OpenClawSystemCommand.execApprovalsGet.rawValue))
+            #expect(!commands.contains(OpenClawSystemCommand.execApprovalsSet.rawValue))
+        }
+    }
+
+    @Test @MainActor func loadLastConnectionReadsSavedValues() {
+        withUserDefaults([:]) {
+            GatewaySettingsStore.saveLastGatewayConnectionManual(
+                host: "gateway.example.com",
+                port: 443,
+                useTLS: true,
+                stableID: "manual|gateway.example.com|443")
+            let loaded = GatewaySettingsStore.loadLastGatewayConnection()
+            #expect(loaded == .manual(host: "gateway.example.com", port: 443, useTLS: true, stableID: "manual|gateway.example.com|443"))
+        }
+    }
+
+    @Test @MainActor func loadLastConnectionReturnsNilForInvalidData() {
+        withUserDefaults([
+            "gateway.last.kind": "manual",
+            "gateway.last.host": "",
+            "gateway.last.port": 0,
+            "gateway.last.tls": false,
+            "gateway.last.stableID": "manual|invalid|0",
+        ]) {
+            let loaded = GatewaySettingsStore.loadLastGatewayConnection()
+            #expect(loaded == nil)
+        }
+    }
+}

openclaw/apps/ios/Tests/GatewayConnectionIssueTests.swift

@@ -0,0 +1,33 @@
+import Testing
+@testable import OpenClaw
+
+@Suite(.serialized) struct GatewayConnectionIssueTests {
+    @Test func detectsTokenMissing() {
+        let issue = GatewayConnectionIssue.detect(from: "unauthorized: gateway token missing")
+        #expect(issue == .tokenMissing)
+        #expect(issue.needsAuthToken)
+    }
+
+    @Test func detectsUnauthorized() {
+        let issue = GatewayConnectionIssue.detect(from: "Gateway error: unauthorized role")
+        #expect(issue == .unauthorized)
+        #expect(issue.needsAuthToken)
+    }
+
+    @Test func detectsPairingWithRequestId() {
+        let issue = GatewayConnectionIssue.detect(from: "pairing required (requestId: abc123)")
+        #expect(issue == .pairingRequired(requestId: "abc123"))
+        #expect(issue.needsPairing)
+        #expect(issue.requestId == "abc123")
+    }
+
+    @Test func detectsNetworkError() {
+        let issue = GatewayConnectionIssue.detect(from: "Gateway error: Connection refused")
+        #expect(issue == .network)
+    }
+
+    @Test func returnsNoneForBenignStatus() {
+        let issue = GatewayConnectionIssue.detect(from: "Connected")
+        #expect(issue == .none)
+    }
+}

openclaw/apps/ios/Tests/GatewayConnectionSecurityTests.swift

@@ -0,0 +1,132 @@
+import Foundation
+import Network
+import OpenClawKit
+import Testing
+@testable import OpenClaw
+
+@Suite(.serialized) struct GatewayConnectionSecurityTests {
+    private func clearTLSFingerprint(stableID: String) {
+        let suite = UserDefaults(suiteName: "ai.openclaw.shared") ?? .standard
+        suite.removeObject(forKey: "gateway.tls.\(stableID)")
+    }
+
+    @Test @MainActor func discoveredTLSParams_prefersStoredPinOverAdvertisedTXT() async {
+        let stableID = "test|\(UUID().uuidString)"
+        defer { clearTLSFingerprint(stableID: stableID) }
+        clearTLSFingerprint(stableID: stableID)
+
+        GatewayTLSStore.saveFingerprint("11", stableID: stableID)
+
+        let endpoint: NWEndpoint = .service(name: "Test", type: "_openclaw-gw._tcp", domain: "local.", interface: nil)
+        let gateway = GatewayDiscoveryModel.DiscoveredGateway(
+            name: "Test",
+            endpoint: endpoint,
+            stableID: stableID,
+            debugID: "debug",
+            lanHost: "evil.example.com",
+            tailnetDns: "evil.example.com",
+            gatewayPort: 12345,
+            canvasPort: nil,
+            tlsEnabled: true,
+            tlsFingerprintSha256: "22",
+            cliPath: nil)
+
+        let appModel = NodeAppModel()
+        let controller = GatewayConnectionController(appModel: appModel, startDiscovery: false)
+
+        let params = controller._test_resolveDiscoveredTLSParams(gateway: gateway, allowTOFU: true)
+        #expect(params?.expectedFingerprint == "11")
+        #expect(params?.allowTOFU == false)
+    }
+
+    @Test @MainActor func discoveredTLSParams_doesNotTrustAdvertisedFingerprint() async {
+        let stableID = "test|\(UUID().uuidString)"
+        defer { clearTLSFingerprint(stableID: stableID) }
+        clearTLSFingerprint(stableID: stableID)
+
+        let endpoint: NWEndpoint = .service(name: "Test", type: "_openclaw-gw._tcp", domain: "local.", interface: nil)
+        let gateway = GatewayDiscoveryModel.DiscoveredGateway(
+            name: "Test",
+            endpoint: endpoint,
+            stableID: stableID,
+            debugID: "debug",
+            lanHost: nil,
+            tailnetDns: nil,
+            gatewayPort: nil,
+            canvasPort: nil,
+            tlsEnabled: true,
+            tlsFingerprintSha256: "22",
+            cliPath: nil)
+
+        let appModel = NodeAppModel()
+        let controller = GatewayConnectionController(appModel: appModel, startDiscovery: false)
+
+        let params = controller._test_resolveDiscoveredTLSParams(gateway: gateway, allowTOFU: true)
+        #expect(params?.expectedFingerprint == nil)
+        #expect(params?.allowTOFU == false)
+    }
+
+    @Test @MainActor func autoconnectRequiresStoredPinForDiscoveredGateways() async {
+        let stableID = "test|\(UUID().uuidString)"
+        defer { clearTLSFingerprint(stableID: stableID) }
+        clearTLSFingerprint(stableID: stableID)
+
+        let defaults = UserDefaults.standard
+        defaults.set(true, forKey: "gateway.autoconnect")
+        defaults.set(false, forKey: "gateway.manual.enabled")
+        defaults.removeObject(forKey: "gateway.last.host")
+        defaults.removeObject(forKey: "gateway.last.port")
+        defaults.removeObject(forKey: "gateway.last.tls")
+        defaults.removeObject(forKey: "gateway.last.stableID")
+        defaults.removeObject(forKey: "gateway.last.kind")
+        defaults.removeObject(forKey: "gateway.preferredStableID")
+        defaults.set(stableID, forKey: "gateway.lastDiscoveredStableID")
+
+        let endpoint: NWEndpoint = .service(name: "Test", type: "_openclaw-gw._tcp", domain: "local.", interface: nil)
+        let gateway = GatewayDiscoveryModel.DiscoveredGateway(
+            name: "Test",
+            endpoint: endpoint,
+            stableID: stableID,
+            debugID: "debug",
+            lanHost: "test.local",
+            tailnetDns: nil,
+            gatewayPort: 18789,
+            canvasPort: nil,
+            tlsEnabled: true,
+            tlsFingerprintSha256: nil,
+            cliPath: nil)
+
+        let appModel = NodeAppModel()
+        let controller = GatewayConnectionController(appModel: appModel, startDiscovery: false)
+        controller._test_setGateways([gateway])
+        controller._test_triggerAutoConnect()
+
+        #expect(controller._test_didAutoConnect() == false)
+    }
+
+    @Test @MainActor func manualConnectionsForceTLSForNonLoopbackHosts() async {
+        let appModel = NodeAppModel()
+        let controller = GatewayConnectionController(appModel: appModel, startDiscovery: false)
+
+        #expect(controller._test_resolveManualUseTLS(host: "gateway.example.com", useTLS: false) == true)
+        #expect(controller._test_resolveManualUseTLS(host: "openclaw.local", useTLS: false) == true)
+        #expect(controller._test_resolveManualUseTLS(host: "127.attacker.example", useTLS: false) == true)
+
+        #expect(controller._test_resolveManualUseTLS(host: "localhost", useTLS: false) == false)
+        #expect(controller._test_resolveManualUseTLS(host: "127.0.0.1", useTLS: false) == false)
+        #expect(controller._test_resolveManualUseTLS(host: "::1", useTLS: false) == false)
+        #expect(controller._test_resolveManualUseTLS(host: "[::1]", useTLS: false) == false)
+        #expect(controller._test_resolveManualUseTLS(host: "::ffff:127.0.0.1", useTLS: false) == false)
+        #expect(controller._test_resolveManualUseTLS(host: "0.0.0.0", useTLS: false) == false)
+    }
+
+    @Test @MainActor func manualDefaultPortUses443OnlyForTailnetTLSHosts() async {
+        let appModel = NodeAppModel()
+        let controller = GatewayConnectionController(appModel: appModel, startDiscovery: false)
+
+        #expect(controller._test_resolveManualPort(host: "gateway.example.com", port: 0, useTLS: true) == 18789)
+        #expect(controller._test_resolveManualPort(host: "device.sample.ts.net", port: 0, useTLS: true) == 443)
+        #expect(controller._test_resolveManualPort(host: "device.sample.ts.net.", port: 0, useTLS: true) == 443)
+        #expect(controller._test_resolveManualPort(host: "device.sample.ts.net", port: 18789, useTLS: true) == 18789)
+    }
+}

openclaw/apps/ios/Tests/GatewayDiscoveryModelTests.swift

@@ -0,0 +1,22 @@
+import Testing
+@testable import OpenClaw
+
+@Suite(.serialized) struct GatewayDiscoveryModelTests {
+    @Test @MainActor func debugLoggingCapturesLifecycleAndResets() {
+        let model = GatewayDiscoveryModel()
+
+        #expect(model.debugLog.isEmpty)
+        #expect(model.statusText == "Idle")
+
+        model.setDebugLoggingEnabled(true)
+        #expect(model.debugLog.count >= 2)
+
+        model.stop()
+        #expect(model.statusText == "Stopped")
+        #expect(model.gateways.isEmpty)
+        #expect(model.debugLog.count >= 3)
+
+        model.setDebugLoggingEnabled(false)
+        #expect(model.debugLog.isEmpty)
+    }
+}

openclaw/apps/ios/Tests/GatewayEndpointIDTests.swift

@@ -0,0 +1,33 @@
+import OpenClawKit
+import Network
+import Testing
+@testable import OpenClaw
+
+@Suite struct GatewayEndpointIDTests {
+    @Test func stableIDForServiceDecodesAndNormalizesName() {
+        let endpoint = NWEndpoint.service(
+            name: "OpenClaw\\032Gateway   \\032  Node\n",
+            type: "_openclaw-gw._tcp",
+            domain: "local.",
+            interface: nil)
+
+        #expect(GatewayEndpointID.stableID(endpoint) == "_openclaw-gw._tcp|local.|OpenClaw Gateway Node")
+    }
+
+    @Test func stableIDForNonServiceUsesEndpointDescription() {
+        let endpoint = NWEndpoint.hostPort(host: NWEndpoint.Host("127.0.0.1"), port: 4242)
+        #expect(GatewayEndpointID.stableID(endpoint) == String(describing: endpoint))
+    }
+
+    @Test func prettyDescriptionDecodesBonjourEscapes() {
+        let endpoint = NWEndpoint.service(
+            name: "OpenClaw\\032Gateway",
+            type: "_openclaw-gw._tcp",
+            domain: "local.",
+            interface: nil)
+
+        let pretty = GatewayEndpointID.prettyDescription(endpoint)
+        #expect(pretty == BonjourEscapes.decode(String(describing: endpoint)))
+        #expect(!pretty.localizedCaseInsensitiveContains("\\032"))
+    }
+}

openclaw/apps/ios/Tests/GatewaySettingsStoreTests.swift

@@ -0,0 +1,214 @@
+import Foundation
+import Testing
+@testable import OpenClaw
+
+private struct KeychainEntry: Hashable {
+    let service: String
+    let account: String
+}
+
+private let gatewayService = "ai.openclaw.gateway"
+private let nodeService = "ai.openclaw.node"
+private let talkService = "ai.openclaw.talk"
+private let instanceIdEntry = KeychainEntry(service: nodeService, account: "instanceId")
+private let preferredGatewayEntry = KeychainEntry(service: gatewayService, account: "preferredStableID")
+private let lastGatewayEntry = KeychainEntry(service: gatewayService, account: "lastDiscoveredStableID")
+private let talkAcmeProviderEntry = KeychainEntry(service: talkService, account: "provider.apiKey.acme")
+
+private func snapshotDefaults(_ keys: [String]) -> [String: Any?] {
+    let defaults = UserDefaults.standard
+    var snapshot: [String: Any?] = [:]
+    for key in keys {
+        snapshot[key] = defaults.object(forKey: key)
+    }
+    return snapshot
+}
+
+private func applyDefaults(_ values: [String: Any?]) {
+    let defaults = UserDefaults.standard
+    for (key, value) in values {
+        if let value {
+            defaults.set(value, forKey: key)
+        } else {
+            defaults.removeObject(forKey: key)
+        }
+    }
+}
+
+private func restoreDefaults(_ snapshot: [String: Any?]) {
+    applyDefaults(snapshot)
+}
+
+private func snapshotKeychain(_ entries: [KeychainEntry]) -> [KeychainEntry: String?] {
+    var snapshot: [KeychainEntry: String?] = [:]
+    for entry in entries {
+        snapshot[entry] = KeychainStore.loadString(service: entry.service, account: entry.account)
+    }
+    return snapshot
+}
+
+private func applyKeychain(_ values: [KeychainEntry: String?]) {
+    for (entry, value) in values {
+        if let value {
+            _ = KeychainStore.saveString(value, service: entry.service, account: entry.account)
+        } else {
+            _ = KeychainStore.delete(service: entry.service, account: entry.account)
+        }
+    }
+}
+
+private func restoreKeychain(_ snapshot: [KeychainEntry: String?]) {
+    applyKeychain(snapshot)
+}
+
+@Suite(.serialized) struct GatewaySettingsStoreTests {
+    @Test func bootstrapCopiesDefaultsToKeychainWhenMissing() {
+        let defaultsKeys = [
+            "node.instanceId",
+            "gateway.preferredStableID",
+            "gateway.lastDiscoveredStableID",
+        ]
+        let entries = [instanceIdEntry, preferredGatewayEntry, lastGatewayEntry]
+        let defaultsSnapshot = snapshotDefaults(defaultsKeys)
+        let keychainSnapshot = snapshotKeychain(entries)
+        defer {
+            restoreDefaults(defaultsSnapshot)
+            restoreKeychain(keychainSnapshot)
+        }
+
+        applyDefaults([
+            "node.instanceId": "node-test",
+            "gateway.preferredStableID": "preferred-test",
+            "gateway.lastDiscoveredStableID": "last-test",
+        ])
+        applyKeychain([
+            instanceIdEntry: nil,
+            preferredGatewayEntry: nil,
+            lastGatewayEntry: nil,
+        ])
+
+        GatewaySettingsStore.bootstrapPersistence()
+
+        #expect(KeychainStore.loadString(service: nodeService, account: "instanceId") == "node-test")
+        #expect(KeychainStore.loadString(service: gatewayService, account: "preferredStableID") == "preferred-test")
+        #expect(KeychainStore.loadString(service: gatewayService, account: "lastDiscoveredStableID") == "last-test")
+    }
+
+    @Test func bootstrapCopiesKeychainToDefaultsWhenMissing() {
+        let defaultsKeys = [
+            "node.instanceId",
+            "gateway.preferredStableID",
+            "gateway.lastDiscoveredStableID",
+        ]
+        let entries = [instanceIdEntry, preferredGatewayEntry, lastGatewayEntry]
+        let defaultsSnapshot = snapshotDefaults(defaultsKeys)
+        let keychainSnapshot = snapshotKeychain(entries)
+        defer {
+            restoreDefaults(defaultsSnapshot)
+            restoreKeychain(keychainSnapshot)
+        }
+
+        applyDefaults([
+            "node.instanceId": nil,
+            "gateway.preferredStableID": nil,
+            "gateway.lastDiscoveredStableID": nil,
+        ])
+        applyKeychain([
+            instanceIdEntry: "node-from-keychain",
+            preferredGatewayEntry: "preferred-from-keychain",
+            lastGatewayEntry: "last-from-keychain",
+        ])
+
+        GatewaySettingsStore.bootstrapPersistence()
+
+        let defaults = UserDefaults.standard
+        #expect(defaults.string(forKey: "node.instanceId") == "node-from-keychain")
+        #expect(defaults.string(forKey: "gateway.preferredStableID") == "preferred-from-keychain")
+        #expect(defaults.string(forKey: "gateway.lastDiscoveredStableID") == "last-from-keychain")
+    }
+
+    @Test func lastGateway_manualRoundTrip() {
+        let keys = [
+            "gateway.last.kind",
+            "gateway.last.host",
+            "gateway.last.port",
+            "gateway.last.tls",
+            "gateway.last.stableID",
+        ]
+        let snapshot = snapshotDefaults(keys)
+        defer { restoreDefaults(snapshot) }
+
+        GatewaySettingsStore.saveLastGatewayConnectionManual(
+            host: "example.com",
+            port: 443,
+            useTLS: true,
+            stableID: "manual|example.com|443")
+
+        let loaded = GatewaySettingsStore.loadLastGatewayConnection()
+        #expect(loaded == .manual(host: "example.com", port: 443, useTLS: true, stableID: "manual|example.com|443"))
+    }
+
+    @Test func lastGateway_discoveredDoesNotPersistResolvedHostPort() {
+        let keys = [
+            "gateway.last.kind",
+            "gateway.last.host",
+            "gateway.last.port",
+            "gateway.last.tls",
+            "gateway.last.stableID",
+        ]
+        let snapshot = snapshotDefaults(keys)
+        defer { restoreDefaults(snapshot) }
+
+        // Simulate a prior manual record that included host/port.
+        applyDefaults([
+            "gateway.last.host": "10.0.0.99",
+            "gateway.last.port": 18789,
+            "gateway.last.tls": true,
+            "gateway.last.stableID": "manual|10.0.0.99|18789",
+            "gateway.last.kind": "manual",
+        ])
+
+        GatewaySettingsStore.saveLastGatewayConnectionDiscovered(stableID: "gw|abc", useTLS: true)
+
+        let defaults = UserDefaults.standard
+        #expect(defaults.object(forKey: "gateway.last.host") == nil)
+        #expect(defaults.object(forKey: "gateway.last.port") == nil)
+        #expect(GatewaySettingsStore.loadLastGatewayConnection() == .discovered(stableID: "gw|abc", useTLS: true))
+    }
+
+    @Test func lastGateway_backCompat_manualLoadsWhenKindMissing() {
+        let keys = [
+            "gateway.last.kind",
+            "gateway.last.host",
+            "gateway.last.port",
+            "gateway.last.tls",
+            "gateway.last.stableID",
+        ]
+        let snapshot = snapshotDefaults(keys)
+        defer { restoreDefaults(snapshot) }
+
+        applyDefaults([
+            "gateway.last.kind": nil,
+            "gateway.last.host": "example.org",
+            "gateway.last.port": 18789,
+            "gateway.last.tls": false,
+            "gateway.last.stableID": "manual|example.org|18789",
+        ])
+
+        let loaded = GatewaySettingsStore.loadLastGatewayConnection()
+        #expect(loaded == .manual(host: "example.org", port: 18789, useTLS: false, stableID: "manual|example.org|18789"))
+    }
+
+    @Test func talkProviderApiKey_genericRoundTrip() {
+        let keychainSnapshot = snapshotKeychain([talkAcmeProviderEntry])
+        defer { restoreKeychain(keychainSnapshot) }
+
+        _ = KeychainStore.delete(service: talkService, account: talkAcmeProviderEntry.account)
+
+        GatewaySettingsStore.saveTalkProviderApiKey("acme-key", provider: "acme")
+        #expect(GatewaySettingsStore.loadTalkProviderApiKey(provider: "acme") == "acme-key")
+
+        GatewaySettingsStore.saveTalkProviderApiKey(nil, provider: "acme")
+        #expect(GatewaySettingsStore.loadTalkProviderApiKey(provider: "acme") == nil)
+    }
+}

openclaw/apps/ios/Tests/IOSGatewayChatTransportTests.swift

@@ -0,0 +1,30 @@
+import OpenClawKit
+import Testing
+@testable import OpenClaw
+
+@Suite struct IOSGatewayChatTransportTests {
+    @Test func requestsFailFastWhenGatewayNotConnected() async {
+        let gateway = GatewayNodeSession()
+        let transport = IOSGatewayChatTransport(gateway: gateway)
+
+        do {
+            _ = try await transport.requestHistory(sessionKey: "node-test")
+            Issue.record("Expected requestHistory to throw when gateway not connected")
+        } catch {}
+
+        do {
+            _ = try await transport.sendMessage(
+                sessionKey: "node-test",
+                message: "hello",
+                thinking: "low",
+                idempotencyKey: "idempotency",
+                attachments: [])
+            Issue.record("Expected sendMessage to throw when gateway not connected")
+        } catch {}
+
+        do {
+            _ = try await transport.requestHealth(timeoutMs: 250)
+            Issue.record("Expected requestHealth to throw when gateway not connected")
+        } catch {}
+    }
+}

openclaw/apps/ios/Tests/Info.plist

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleDisplayName</key>
+	<string>OpenClawTests</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+			<string>BNDL</string>
+			<key>CFBundleShortVersionString</key>
+			<string>2026.2.26</string>
+			<key>CFBundleVersion</key>
+			<string>20260226</string>
+		</dict>
+	</plist>

openclaw/apps/ios/Tests/KeychainStoreTests.swift

@@ -0,0 +1,22 @@
+import Foundation
+import Testing
+@testable import OpenClaw
+
+@Suite struct KeychainStoreTests {
+    @Test func saveLoadUpdateDeleteRoundTrip() {
+        let service = "ai.openclaw.tests.\(UUID().uuidString)"
+        let account = "value"
+
+        #expect(KeychainStore.delete(service: service, account: account))
+        #expect(KeychainStore.loadString(service: service, account: account) == nil)
+
+        #expect(KeychainStore.saveString("first", service: service, account: account))
+        #expect(KeychainStore.loadString(service: service, account: account) == "first")
+
+        #expect(KeychainStore.saveString("second", service: service, account: account))
+        #expect(KeychainStore.loadString(service: service, account: account) == "second")
+
+        #expect(KeychainStore.delete(service: service, account: account))
+        #expect(KeychainStore.loadString(service: service, account: account) == nil)
+    }
+}

openclaw/apps/ios/Tests/NodeAppModelInvokeTests.swift

@@ -0,0 +1,503 @@
+import OpenClawKit
+import Foundation
+import Testing
+import UIKit
+@testable import OpenClaw
+
+private func withUserDefaults<T>(_ updates: [String: Any?], _ body: () throws -> T) rethrows -> T {
+    let defaults = UserDefaults.standard
+    var snapshot: [String: Any?] = [:]
+    for key in updates.keys {
+        snapshot[key] = defaults.object(forKey: key)
+    }
+    for (key, value) in updates {
+        if let value {
+            defaults.set(value, forKey: key)
+        } else {
+            defaults.removeObject(forKey: key)
+        }
+    }
+    defer {
+        for (key, value) in snapshot {
+            if let value {
+                defaults.set(value, forKey: key)
+            } else {
+                defaults.removeObject(forKey: key)
+            }
+        }
+    }
+    return try body()
+}
+
+private func makeAgentDeepLinkURL(
+    message: String,
+    deliver: Bool = false,
+    to: String? = nil,
+    channel: String? = nil,
+    key: String? = nil) -> URL
+{
+    var components = URLComponents()
+    components.scheme = "openclaw"
+    components.host = "agent"
+    var queryItems: [URLQueryItem] = [URLQueryItem(name: "message", value: message)]
+    if deliver {
+        queryItems.append(URLQueryItem(name: "deliver", value: "1"))
+    }
+    if let to {
+        queryItems.append(URLQueryItem(name: "to", value: to))
+    }
+    if let channel {
+        queryItems.append(URLQueryItem(name: "channel", value: channel))
+    }
+    if let key {
+        queryItems.append(URLQueryItem(name: "key", value: key))
+    }
+    components.queryItems = queryItems
+    return components.url!
+}
+
+@MainActor
+private final class MockWatchMessagingService: @preconcurrency WatchMessagingServicing, @unchecked Sendable {
+    var currentStatus = WatchMessagingStatus(
+        supported: true,
+        paired: true,
+        appInstalled: true,
+        reachable: true,
+        activationState: "activated")
+    var nextSendResult = WatchNotificationSendResult(
+        deliveredImmediately: true,
+        queuedForDelivery: false,
+        transport: "sendMessage")
+    var sendError: Error?
+    var lastSent: (id: String, params: OpenClawWatchNotifyParams)?
+    private var replyHandler: (@Sendable (WatchQuickReplyEvent) -> Void)?
+
+    func status() async -> WatchMessagingStatus {
+        self.currentStatus
+    }
+
+    func setReplyHandler(_ handler: (@Sendable (WatchQuickReplyEvent) -> Void)?) {
+        self.replyHandler = handler
+    }
+
+    func sendNotification(id: String, params: OpenClawWatchNotifyParams) async throws -> WatchNotificationSendResult {
+        self.lastSent = (id: id, params: params)
+        if let sendError = self.sendError {
+            throw sendError
+        }
+        return self.nextSendResult
+    }
+
+    func emitReply(_ event: WatchQuickReplyEvent) {
+        self.replyHandler?(event)
+    }
+}
+
+@Suite(.serialized) struct NodeAppModelInvokeTests {
+    @Test @MainActor func decodeParamsFailsWithoutJSON() {
+        #expect(throws: Error.self) {
+            _ = try NodeAppModel._test_decodeParams(OpenClawCanvasNavigateParams.self, from: nil)
+        }
+    }
+
+    @Test @MainActor func encodePayloadEmitsJSON() throws {
+        struct Payload: Codable, Equatable {
+            var value: String
+        }
+        let json = try NodeAppModel._test_encodePayload(Payload(value: "ok"))
+        #expect(json.contains("\"value\""))
+    }
+
+    @Test @MainActor func chatSessionKeyDefaultsToIOSBase() {
+        let appModel = NodeAppModel()
+        #expect(appModel.chatSessionKey == "ios")
+    }
+
+    @Test @MainActor func chatSessionKeyUsesAgentScopedKeyForNonDefaultAgent() {
+        let appModel = NodeAppModel()
+        appModel.gatewayDefaultAgentId = "main"
+        appModel.setSelectedAgentId("agent-123")
+        #expect(appModel.chatSessionKey == SessionKey.makeAgentSessionKey(agentId: "agent-123", baseKey: "ios"))
+        #expect(appModel.mainSessionKey == "agent:agent-123:main")
+    }
+
+    @Test @MainActor func handleInvokeRejectsBackgroundCommands() async {
+        let appModel = NodeAppModel()
+        appModel.setScenePhase(.background)
+
+        let req = BridgeInvokeRequest(id: "bg", command: OpenClawCanvasCommand.present.rawValue)
+        let res = await appModel._test_handleInvoke(req)
+        #expect(res.ok == false)
+        #expect(res.error?.code == .backgroundUnavailable)
+    }
+
+    @Test @MainActor func handleInvokeRejectsCameraWhenDisabled() async {
+        let appModel = NodeAppModel()
+        let req = BridgeInvokeRequest(id: "cam", command: OpenClawCameraCommand.snap.rawValue)
+
+        let defaults = UserDefaults.standard
+        let key = "camera.enabled"
+        let previous = defaults.object(forKey: key)
+        defaults.set(false, forKey: key)
+        defer {
+            if let previous {
+                defaults.set(previous, forKey: key)
+            } else {
+                defaults.removeObject(forKey: key)
+            }
+        }
+
+        let res = await appModel._test_handleInvoke(req)
+        #expect(res.ok == false)
+        #expect(res.error?.code == .unavailable)
+        #expect(res.error?.message.contains("CAMERA_DISABLED") == true)
+    }
+
+    @Test @MainActor func handleInvokeRejectsInvalidScreenFormat() async {
+        let appModel = NodeAppModel()
+        let params = OpenClawScreenRecordParams(format: "gif")
+        let data = try? JSONEncoder().encode(params)
+        let json = data.flatMap { String(data: $0, encoding: .utf8) }
+
+        let req = BridgeInvokeRequest(
+            id: "screen",
+            command: OpenClawScreenCommand.record.rawValue,
+            paramsJSON: json)
+
+        let res = await appModel._test_handleInvoke(req)
+        #expect(res.ok == false)
+        #expect(res.error?.message.contains("screen format must be mp4") == true)
+    }
+
+    @Test @MainActor func handleInvokeCanvasCommandsUpdateScreen() async throws {
+        let appModel = NodeAppModel()
+        appModel.screen.navigate(to: "http://example.com")
+
+        let present = BridgeInvokeRequest(id: "present", command: OpenClawCanvasCommand.present.rawValue)
+        let presentRes = await appModel._test_handleInvoke(present)
+        #expect(presentRes.ok == true)
+        #expect(appModel.screen.urlString.isEmpty)
+
+        // Loopback URLs are rejected (they are not meaningful for a remote gateway).
+        let navigateParams = OpenClawCanvasNavigateParams(url: "http://example.com/")
+        let navData = try JSONEncoder().encode(navigateParams)
+        let navJSON = String(decoding: navData, as: UTF8.self)
+        let navigate = BridgeInvokeRequest(
+            id: "nav",
+            command: OpenClawCanvasCommand.navigate.rawValue,
+            paramsJSON: navJSON)
+        let navRes = await appModel._test_handleInvoke(navigate)
+        #expect(navRes.ok == true)
+        #expect(appModel.screen.urlString == "http://example.com/")
+
+        let evalParams = OpenClawCanvasEvalParams(javaScript: "1+1")
+        let evalData = try JSONEncoder().encode(evalParams)
+        let evalJSON = String(decoding: evalData, as: UTF8.self)
+        let eval = BridgeInvokeRequest(
+            id: "eval",
+            command: OpenClawCanvasCommand.evalJS.rawValue,
+            paramsJSON: evalJSON)
+        let evalRes = await appModel._test_handleInvoke(eval)
+        #expect(evalRes.ok == true)
+        let payloadData = try #require(evalRes.payloadJSON?.data(using: .utf8))
+        let payload = try JSONSerialization.jsonObject(with: payloadData) as? [String: Any]
+        #expect(payload?["result"] as? String == "2")
+    }
+
+    @Test @MainActor func handleInvokeA2UICommandsFailWhenHostMissing() async throws {
+        let appModel = NodeAppModel()
+
+        let reset = BridgeInvokeRequest(id: "reset", command: OpenClawCanvasA2UICommand.reset.rawValue)
+        let resetRes = await appModel._test_handleInvoke(reset)
+        #expect(resetRes.ok == false)
+        #expect(resetRes.error?.message.contains("A2UI_HOST_NOT_CONFIGURED") == true)
+
+        let jsonl = "{\"beginRendering\":{}}"
+        let pushParams = OpenClawCanvasA2UIPushJSONLParams(jsonl: jsonl)
+        let pushData = try JSONEncoder().encode(pushParams)
+        let pushJSON = String(decoding: pushData, as: UTF8.self)
+        let push = BridgeInvokeRequest(
+            id: "push",
+            command: OpenClawCanvasA2UICommand.pushJSONL.rawValue,
+            paramsJSON: pushJSON)
+        let pushRes = await appModel._test_handleInvoke(push)
+        #expect(pushRes.ok == false)
+        #expect(pushRes.error?.message.contains("A2UI_HOST_NOT_CONFIGURED") == true)
+    }
+
+    @Test @MainActor func handleInvokeUnknownCommandReturnsInvalidRequest() async {
+        let appModel = NodeAppModel()
+        let req = BridgeInvokeRequest(id: "unknown", command: "nope")
+        let res = await appModel._test_handleInvoke(req)
+        #expect(res.ok == false)
+        #expect(res.error?.code == .invalidRequest)
+    }
+
+    @Test @MainActor func handleInvokeWatchStatusReturnsServiceSnapshot() async throws {
+        let watchService = MockWatchMessagingService()
+        watchService.currentStatus = WatchMessagingStatus(
+            supported: true,
+            paired: true,
+            appInstalled: true,
+            reachable: false,
+            activationState: "inactive")
+        let appModel = NodeAppModel(watchMessagingService: watchService)
+        let req = BridgeInvokeRequest(id: "watch-status", command: OpenClawWatchCommand.status.rawValue)
+
+        let res = await appModel._test_handleInvoke(req)
+        #expect(res.ok == true)
+
+        let payloadData = try #require(res.payloadJSON?.data(using: .utf8))
+        let payload = try JSONDecoder().decode(OpenClawWatchStatusPayload.self, from: payloadData)
+        #expect(payload.supported == true)
+        #expect(payload.reachable == false)
+        #expect(payload.activationState == "inactive")
+    }
+
+    @Test @MainActor func handleInvokeWatchNotifyRoutesToWatchService() async throws {
+        let watchService = MockWatchMessagingService()
+        watchService.nextSendResult = WatchNotificationSendResult(
+            deliveredImmediately: false,
+            queuedForDelivery: true,
+            transport: "transferUserInfo")
+        let appModel = NodeAppModel(watchMessagingService: watchService)
+        let params = OpenClawWatchNotifyParams(
+            title: "OpenClaw",
+            body: "Meeting with Peter is at 4pm",
+            priority: .timeSensitive)
+        let paramsData = try JSONEncoder().encode(params)
+        let paramsJSON = String(decoding: paramsData, as: UTF8.self)
+        let req = BridgeInvokeRequest(
+            id: "watch-notify",
+            command: OpenClawWatchCommand.notify.rawValue,
+            paramsJSON: paramsJSON)
+
+        let res = await appModel._test_handleInvoke(req)
+        #expect(res.ok == true)
+        #expect(watchService.lastSent?.params.title == "OpenClaw")
+        #expect(watchService.lastSent?.params.body == "Meeting with Peter is at 4pm")
+        #expect(watchService.lastSent?.params.priority == .timeSensitive)
+
+        let payloadData = try #require(res.payloadJSON?.data(using: .utf8))
+        let payload = try JSONDecoder().decode(OpenClawWatchNotifyPayload.self, from: payloadData)
+        #expect(payload.deliveredImmediately == false)
+        #expect(payload.queuedForDelivery == true)
+        #expect(payload.transport == "transferUserInfo")
+    }
+
+    @Test @MainActor func handleInvokeWatchNotifyRejectsEmptyMessage() async throws {
+        let watchService = MockWatchMessagingService()
+        let appModel = NodeAppModel(watchMessagingService: watchService)
+        let params = OpenClawWatchNotifyParams(title: "   ", body: "\n")
+        let paramsData = try JSONEncoder().encode(params)
+        let paramsJSON = String(decoding: paramsData, as: UTF8.self)
+        let req = BridgeInvokeRequest(
+            id: "watch-notify-empty",
+            command: OpenClawWatchCommand.notify.rawValue,
+            paramsJSON: paramsJSON)
+
+        let res = await appModel._test_handleInvoke(req)
+        #expect(res.ok == false)
+        #expect(res.error?.code == .invalidRequest)
+        #expect(watchService.lastSent == nil)
+    }
+
+    @Test @MainActor func handleInvokeWatchNotifyAddsDefaultActionsForPrompt() async throws {
+        let watchService = MockWatchMessagingService()
+        let appModel = NodeAppModel(watchMessagingService: watchService)
+        let params = OpenClawWatchNotifyParams(
+            title: "Task",
+            body: "Action needed",
+            priority: .passive,
+            promptId: "prompt-123")
+        let paramsData = try JSONEncoder().encode(params)
+        let paramsJSON = String(decoding: paramsData, as: UTF8.self)
+        let req = BridgeInvokeRequest(
+            id: "watch-notify-default-actions",
+            command: OpenClawWatchCommand.notify.rawValue,
+            paramsJSON: paramsJSON)
+
+        let res = await appModel._test_handleInvoke(req)
+        #expect(res.ok == true)
+        #expect(watchService.lastSent?.params.risk == .low)
+        let actionIDs = watchService.lastSent?.params.actions?.map(\.id)
+        #expect(actionIDs == ["done", "snooze_10m", "open_phone", "escalate"])
+    }
+
+    @Test @MainActor func handleInvokeWatchNotifyAddsApprovalDefaults() async throws {
+        let watchService = MockWatchMessagingService()
+        let appModel = NodeAppModel(watchMessagingService: watchService)
+        let params = OpenClawWatchNotifyParams(
+            title: "Approval",
+            body: "Allow command?",
+            promptId: "prompt-approval",
+            kind: "approval")
+        let paramsData = try JSONEncoder().encode(params)
+        let paramsJSON = String(decoding: paramsData, as: UTF8.self)
+        let req = BridgeInvokeRequest(
+            id: "watch-notify-approval-defaults",
+            command: OpenClawWatchCommand.notify.rawValue,
+            paramsJSON: paramsJSON)
+
+        let res = await appModel._test_handleInvoke(req)
+        #expect(res.ok == true)
+        let actionIDs = watchService.lastSent?.params.actions?.map(\.id)
+        #expect(actionIDs == ["approve", "decline", "open_phone", "escalate"])
+        #expect(watchService.lastSent?.params.actions?[1].style == "destructive")
+    }
+
+    @Test @MainActor func handleInvokeWatchNotifyDerivesPriorityFromRiskAndCapsActions() async throws {
+        let watchService = MockWatchMessagingService()
+        let appModel = NodeAppModel(watchMessagingService: watchService)
+        let params = OpenClawWatchNotifyParams(
+            title: "Urgent",
+            body: "Check now",
+            risk: .high,
+            actions: [
+                OpenClawWatchAction(id: "a1", label: "A1"),
+                OpenClawWatchAction(id: "a2", label: "A2"),
+                OpenClawWatchAction(id: "a3", label: "A3"),
+                OpenClawWatchAction(id: "a4", label: "A4"),
+                OpenClawWatchAction(id: "a5", label: "A5"),
+            ])
+        let paramsData = try JSONEncoder().encode(params)
+        let paramsJSON = String(decoding: paramsData, as: UTF8.self)
+        let req = BridgeInvokeRequest(
+            id: "watch-notify-derive-priority",
+            command: OpenClawWatchCommand.notify.rawValue,
+            paramsJSON: paramsJSON)
+
+        let res = await appModel._test_handleInvoke(req)
+        #expect(res.ok == true)
+        #expect(watchService.lastSent?.params.priority == .timeSensitive)
+        #expect(watchService.lastSent?.params.risk == .high)
+        let actionIDs = watchService.lastSent?.params.actions?.map(\.id)
+        #expect(actionIDs == ["a1", "a2", "a3", "a4"])
+    }
+
+    @Test @MainActor func handleInvokeWatchNotifyReturnsUnavailableOnDeliveryFailure() async throws {
+        let watchService = MockWatchMessagingService()
+        watchService.sendError = NSError(
+            domain: "watch",
+            code: 1,
+            userInfo: [NSLocalizedDescriptionKey: "WATCH_UNAVAILABLE: no paired Apple Watch"])
+        let appModel = NodeAppModel(watchMessagingService: watchService)
+        let params = OpenClawWatchNotifyParams(title: "OpenClaw", body: "Delivery check")
+        let paramsData = try JSONEncoder().encode(params)
+        let paramsJSON = String(decoding: paramsData, as: UTF8.self)
+        let req = BridgeInvokeRequest(
+            id: "watch-notify-fail",
+            command: OpenClawWatchCommand.notify.rawValue,
+            paramsJSON: paramsJSON)
+
+        let res = await appModel._test_handleInvoke(req)
+        #expect(res.ok == false)
+        #expect(res.error?.code == .unavailable)
+        #expect(res.error?.message.contains("WATCH_UNAVAILABLE") == true)
+    }
+
+    @Test @MainActor func watchReplyQueuesWhenGatewayOffline() async {
+        let watchService = MockWatchMessagingService()
+        let appModel = NodeAppModel(watchMessagingService: watchService)
+        watchService.emitReply(
+            WatchQuickReplyEvent(
+                replyId: "reply-offline-1",
+                promptId: "prompt-1",
+                actionId: "approve",
+                actionLabel: "Approve",
+                sessionKey: "ios",
+                note: nil,
+                sentAtMs: 1234,
+                transport: "transferUserInfo"))
+        #expect(appModel._test_queuedWatchReplyCount() == 1)
+    }
+
+    @Test @MainActor func handleDeepLinkSetsErrorWhenNotConnected() async {
+        let appModel = NodeAppModel()
+        let url = URL(string: "openclaw://agent?message=hello")!
+        await appModel.handleDeepLink(url: url)
+        #expect(appModel.screen.errorText?.contains("Gateway not connected") == true)
+    }
+
+    @Test @MainActor func handleDeepLinkRejectsOversizedMessage() async {
+        let appModel = NodeAppModel()
+        let msg = String(repeating: "a", count: 20001)
+        let url = URL(string: "openclaw://agent?message=\(msg)")!
+        await appModel.handleDeepLink(url: url)
+        #expect(appModel.screen.errorText?.contains("Deep link too large") == true)
+    }
+
+    @Test @MainActor func handleDeepLinkRequiresConfirmationWhenConnectedAndUnkeyed() async {
+        let appModel = NodeAppModel()
+        appModel._test_setGatewayConnected(true)
+        let url = makeAgentDeepLinkURL(message: "hello from deep link")
+
+        await appModel.handleDeepLink(url: url)
+        #expect(appModel.pendingAgentDeepLinkPrompt != nil)
+        #expect(appModel.openChatRequestID == 0)
+
+        await appModel.approvePendingAgentDeepLinkPrompt()
+        #expect(appModel.pendingAgentDeepLinkPrompt == nil)
+        #expect(appModel.openChatRequestID == 1)
+    }
+
+    @Test @MainActor func handleDeepLinkStripsDeliveryFieldsWhenUnkeyed() async throws {
+        let appModel = NodeAppModel()
+        appModel._test_setGatewayConnected(true)
+        let url = makeAgentDeepLinkURL(
+            message: "route this",
+            deliver: true,
+            to: "123456",
+            channel: "telegram")
+
+        await appModel.handleDeepLink(url: url)
+        let prompt = try #require(appModel.pendingAgentDeepLinkPrompt)
+        #expect(prompt.request.deliver == false)
+        #expect(prompt.request.to == nil)
+        #expect(prompt.request.channel == nil)
+    }
+
+    @Test @MainActor func handleDeepLinkRejectsLongUnkeyedMessageWhenConnected() async {
+        let appModel = NodeAppModel()
+        appModel._test_setGatewayConnected(true)
+        let message = String(repeating: "x", count: 241)
+        let url = makeAgentDeepLinkURL(message: message)
+
+        await appModel.handleDeepLink(url: url)
+        #expect(appModel.pendingAgentDeepLinkPrompt == nil)
+        #expect(appModel.screen.errorText?.contains("blocked") == true)
+    }
+
+    @Test @MainActor func handleDeepLinkBypassesPromptWithValidKey() async {
+        let appModel = NodeAppModel()
+        appModel._test_setGatewayConnected(true)
+        let key = NodeAppModel._test_currentDeepLinkKey()
+        let url = makeAgentDeepLinkURL(message: "trusted request", key: key)
+
+        await appModel.handleDeepLink(url: url)
+        #expect(appModel.pendingAgentDeepLinkPrompt == nil)
+        #expect(appModel.openChatRequestID == 1)
+    }
+
+    @Test @MainActor func sendVoiceTranscriptThrowsWhenGatewayOffline() async {
+        let appModel = NodeAppModel()
+        await #expect(throws: Error.self) {
+            try await appModel.sendVoiceTranscript(text: "hello", sessionKey: "main")
+        }
+    }
+
+    @Test @MainActor func canvasA2UIActionDispatchesStatus() async {
+        let appModel = NodeAppModel()
+        let body: [String: Any] = [
+            "userAction": [
+                "name": "tap",
+                "id": "action-1",
+                "surfaceId": "main",
+                "sourceComponentId": "button-1",
+                "context": ["value": "ok"],
+            ],
+        ]
+        await appModel._test_handleCanvasA2UIAction(body: body)
+        #expect(appModel.screen.urlString.isEmpty)
+    }
+}

openclaw/apps/ios/Tests/OnboardingStateStoreTests.swift

@@ -0,0 +1,57 @@
+import Foundation
+import Testing
+@testable import OpenClaw
+
+@Suite(.serialized) struct OnboardingStateStoreTests {
+    @Test @MainActor func shouldPresentWhenFreshAndDisconnected() {
+        let testDefaults = self.makeDefaults()
+        let defaults = testDefaults.defaults
+        defer { self.reset(testDefaults) }
+
+        let appModel = NodeAppModel()
+        appModel.gatewayServerName = nil
+        #expect(OnboardingStateStore.shouldPresentOnLaunch(appModel: appModel, defaults: defaults))
+    }
+
+    @Test @MainActor func doesNotPresentWhenConnected() {
+        let testDefaults = self.makeDefaults()
+        let defaults = testDefaults.defaults
+        defer { self.reset(testDefaults) }
+
+        let appModel = NodeAppModel()
+        appModel.gatewayServerName = "gateway"
+        #expect(!OnboardingStateStore.shouldPresentOnLaunch(appModel: appModel, defaults: defaults))
+    }
+
+    @Test @MainActor func markCompletedPersistsMode() {
+        let testDefaults = self.makeDefaults()
+        let defaults = testDefaults.defaults
+        defer { self.reset(testDefaults) }
+
+        let appModel = NodeAppModel()
+        appModel.gatewayServerName = nil
+
+        OnboardingStateStore.markCompleted(mode: .remoteDomain, defaults: defaults)
+        #expect(OnboardingStateStore.lastMode(defaults: defaults) == .remoteDomain)
+        #expect(!OnboardingStateStore.shouldPresentOnLaunch(appModel: appModel, defaults: defaults))
+
+        OnboardingStateStore.markIncomplete(defaults: defaults)
+        #expect(OnboardingStateStore.shouldPresentOnLaunch(appModel: appModel, defaults: defaults))
+    }
+
+    private struct TestDefaults {
+        var suiteName: String
+        var defaults: UserDefaults
+    }
+
+    private func makeDefaults() -> TestDefaults {
+        let suiteName = "OnboardingStateStoreTests.\(UUID().uuidString)"
+        return TestDefaults(
+            suiteName: suiteName,
+            defaults: UserDefaults(suiteName: suiteName) ?? .standard)
+    }
+
+    private func reset(_ defaults: TestDefaults) {
+        defaults.defaults.removePersistentDomain(forName: defaults.suiteName)
+    }
+}

openclaw/apps/ios/Tests/ScreenControllerTests.swift

@@ -0,0 +1,87 @@
+import Testing
+import WebKit
+@testable import OpenClaw
+
+@MainActor
+private func mountScreen(_ screen: ScreenController) throws -> (ScreenWebViewCoordinator, WKWebView) {
+    let coordinator = ScreenWebViewCoordinator(controller: screen)
+    _ = coordinator.makeContainerView()
+    let webView = try #require(coordinator.managedWebView)
+    return (coordinator, webView)
+}
+
+@Suite struct ScreenControllerTests {
+    @Test @MainActor func canvasModeConfiguresWebViewForTouch() throws {
+        let screen = ScreenController()
+        let (coordinator, webView) = try mountScreen(screen)
+        defer { coordinator.teardown() }
+
+        #expect(webView.isOpaque == true)
+        #expect(webView.backgroundColor == .black)
+
+        let scrollView = webView.scrollView
+        #expect(scrollView.backgroundColor == .black)
+        #expect(scrollView.contentInsetAdjustmentBehavior == .never)
+        #expect(scrollView.isScrollEnabled == false)
+        #expect(scrollView.bounces == false)
+    }
+
+    @Test @MainActor func navigateEnablesScrollForWebPages() throws {
+        let screen = ScreenController()
+        let (coordinator, webView) = try mountScreen(screen)
+        defer { coordinator.teardown() }
+
+        screen.navigate(to: "https://example.com")
+
+        let scrollView = webView.scrollView
+        #expect(scrollView.isScrollEnabled == true)
+        #expect(scrollView.bounces == true)
+    }
+
+    @Test @MainActor func navigateSlashShowsDefaultCanvas() {
+        let screen = ScreenController()
+        screen.navigate(to: "/")
+
+        #expect(screen.urlString.isEmpty)
+    }
+
+    @Test @MainActor func evalExecutesJavaScript() async throws {
+        let screen = ScreenController()
+        let (coordinator, _) = try mountScreen(screen)
+        defer { coordinator.teardown() }
+
+        let deadline = ContinuousClock().now.advanced(by: .seconds(3))
+
+        while true {
+            do {
+                let result = try await screen.eval(javaScript: "1+1")
+                #expect(result == "2")
+                return
+            } catch {
+                if ContinuousClock().now >= deadline {
+                    throw error
+                }
+                try? await Task.sleep(nanoseconds: 100_000_000)
+            }
+        }
+    }
+
+    @Test @MainActor func localNetworkCanvasURLsAreAllowed() {
+        let screen = ScreenController()
+        #expect(screen.isLocalNetworkCanvasURL(URL(string: "http://localhost:18789/")!) == true)
+        #expect(screen.isLocalNetworkCanvasURL(URL(string: "http://openclaw.local:18789/")!) == true)
+        #expect(screen.isLocalNetworkCanvasURL(URL(string: "http://peters-mac-studio-1:18789/")!) == true)
+        #expect(screen.isLocalNetworkCanvasURL(URL(string: "https://peters-mac-studio-1.ts.net:18789/")!) == true)
+        #expect(screen.isLocalNetworkCanvasURL(URL(string: "http://192.168.0.10:18789/")!) == true)
+        #expect(screen.isLocalNetworkCanvasURL(URL(string: "http://10.0.0.10:18789/")!) == true)
+        #expect(screen.isLocalNetworkCanvasURL(URL(string: "http://100.123.224.76:18789/")!) == true) // Tailscale CGNAT
+        #expect(screen.isLocalNetworkCanvasURL(URL(string: "https://example.com/")!) == false)
+        #expect(screen.isLocalNetworkCanvasURL(URL(string: "http://8.8.8.8/")!) == false)
+    }
+
+    @Test func parseA2UIActionBodyAcceptsJSONString() throws {
+        let body = ScreenController.parseA2UIActionBody("{\"userAction\":{\"name\":\"hello\"}}")
+        let userAction = try #require(body?["userAction"] as? [String: Any])
+        #expect(userAction["name"] as? String == "hello")
+    }
+}

openclaw/apps/ios/Tests/ScreenRecordServiceTests.swift

@@ -0,0 +1,32 @@
+import Testing
+@testable import OpenClaw
+
+@Suite(.serialized) struct ScreenRecordServiceTests {
+    @Test func clampDefaultsAndBounds() {
+        #expect(ScreenRecordService._test_clampDurationMs(nil) == 10000)
+        #expect(ScreenRecordService._test_clampDurationMs(0) == 250)
+        #expect(ScreenRecordService._test_clampDurationMs(60001) == 60000)
+
+        #expect(ScreenRecordService._test_clampFps(nil) == 10)
+        #expect(ScreenRecordService._test_clampFps(0) == 1)
+        #expect(ScreenRecordService._test_clampFps(120) == 30)
+        #expect(ScreenRecordService._test_clampFps(.infinity) == 10)
+    }
+
+    @Test @MainActor func recordRejectsInvalidScreenIndex() async {
+        let recorder = ScreenRecordService()
+        do {
+            _ = try await recorder.record(
+                screenIndex: 1,
+                durationMs: 250,
+                fps: 5,
+                includeAudio: false,
+                outPath: nil)
+            Issue.record("Expected invalid screen index to throw")
+        } catch let error as ScreenRecordService.ScreenRecordError {
+            #expect(error.localizedDescription.contains("Invalid screen index") == true)
+        } catch {
+            Issue.record("Unexpected error type: \(error)")
+        }
+    }
+}

openclaw/apps/ios/Tests/SettingsNetworkingHelpersTests.swift

@@ -0,0 +1,50 @@
+import Testing
+@testable import OpenClaw
+
+@Suite struct SettingsNetworkingHelpersTests {
+    @Test func parseHostPortParsesIPv4() {
+        #expect(SettingsNetworkingHelpers.parseHostPort(from: "127.0.0.1:8080") == .init(host: "127.0.0.1", port: 8080))
+    }
+
+    @Test func parseHostPortParsesHostnameAndTrims() {
+        #expect(SettingsNetworkingHelpers.parseHostPort(from: "  example.com:80 \n") == .init(
+            host: "example.com",
+            port: 80))
+    }
+
+    @Test func parseHostPortParsesBracketedIPv6() {
+        #expect(
+            SettingsNetworkingHelpers.parseHostPort(from: "[2001:db8::1]:443") ==
+                .init(host: "2001:db8::1", port: 443))
+    }
+
+    @Test func parseHostPortRejectsMissingPort() {
+        #expect(SettingsNetworkingHelpers.parseHostPort(from: "example.com") == nil)
+        #expect(SettingsNetworkingHelpers.parseHostPort(from: "[2001:db8::1]") == nil)
+    }
+
+    @Test func parseHostPortRejectsInvalidPort() {
+        #expect(SettingsNetworkingHelpers.parseHostPort(from: "example.com:lol") == nil)
+        #expect(SettingsNetworkingHelpers.parseHostPort(from: "[2001:db8::1]:lol") == nil)
+    }
+
+    @Test func httpURLStringFormatsIPv4AndPort() {
+        #expect(SettingsNetworkingHelpers
+            .httpURLString(host: "127.0.0.1", port: 8080, fallback: "fallback") == "http://127.0.0.1:8080")
+    }
+
+    @Test func httpURLStringBracketsIPv6() {
+        #expect(SettingsNetworkingHelpers
+            .httpURLString(host: "2001:db8::1", port: 8080, fallback: "fallback") == "http://[2001:db8::1]:8080")
+    }
+
+    @Test func httpURLStringLeavesAlreadyBracketedIPv6() {
+        #expect(SettingsNetworkingHelpers
+            .httpURLString(host: "[2001:db8::1]", port: 8080, fallback: "fallback") == "http://[2001:db8::1]:8080")
+    }
+
+    @Test func httpURLStringFallsBackWhenMissingHostOrPort() {
+        #expect(SettingsNetworkingHelpers.httpURLString(host: nil, port: 80, fallback: "x") == "http://x")
+        #expect(SettingsNetworkingHelpers.httpURLString(host: "example.com", port: nil, fallback: "y") == "http://y")
+    }
+}

openclaw/apps/ios/Tests/ShareToAgentDeepLinkTests.swift

@@ -0,0 +1,51 @@
+import OpenClawKit
+import Foundation
+import Testing
+
+@Suite struct ShareToAgentDeepLinkTests {
+    @Test func buildMessageIncludesSharedFields() {
+        let payload = SharedContentPayload(
+            title: "Article",
+            url: URL(string: "https://example.com/post")!,
+            text: "Read this")
+
+        let message = ShareToAgentDeepLink.buildMessage(
+            from: payload,
+            instruction: "Summarize and give next steps.")
+        #expect(message.contains("Shared from iOS."))
+        #expect(message.contains("Title: Article"))
+        #expect(message.contains("URL: https://example.com/post"))
+        #expect(message.contains("Text:\nRead this"))
+        #expect(message.contains("Summarize and give next steps."))
+    }
+
+    @Test func buildURLEncodesAgentRoute() {
+        let payload = SharedContentPayload(
+            title: "",
+            url: URL(string: "https://example.com")!,
+            text: nil)
+
+        let url = ShareToAgentDeepLink.buildURL(from: payload)
+        let parsed = url.flatMap { DeepLinkParser.parse($0) }
+        guard case let .agent(agent)? = parsed else {
+            Issue.record("Expected openclaw://agent deep link")
+            return
+        }
+
+        #expect(agent.thinking == "low")
+        #expect(agent.message.contains("https://example.com"))
+    }
+
+    @Test func buildURLReturnsNilWhenPayloadEmpty() {
+        let payload = SharedContentPayload(title: nil, url: nil, text: nil)
+        #expect(ShareToAgentDeepLink.buildURL(from: payload) == nil)
+    }
+
+    @Test func shareInstructionSettingsRoundTrip() {
+        let value = "Focus on booking constraints and alternatives."
+        ShareToAgentSettings.saveDefaultInstruction(value)
+        defer { ShareToAgentSettings.saveDefaultInstruction(nil) }
+
+        #expect(ShareToAgentSettings.loadDefaultInstruction() == value)
+    }
+}

openclaw/apps/ios/Tests/SwiftUIRenderSmokeTests.swift

@@ -0,0 +1,81 @@
+import OpenClawKit
+import SwiftUI
+import Testing
+import UIKit
+@testable import OpenClaw
+
+@Suite struct SwiftUIRenderSmokeTests {
+    @MainActor private static func host(_ view: some View) -> UIWindow {
+        let window = UIWindow(frame: UIScreen.main.bounds)
+        window.rootViewController = UIHostingController(rootView: view)
+        window.makeKeyAndVisible()
+        window.rootViewController?.view.setNeedsLayout()
+        window.rootViewController?.view.layoutIfNeeded()
+        return window
+    }
+
+    @Test @MainActor func statusPillConnectingBuildsAViewHierarchy() {
+        let root = StatusPill(gateway: .connecting, voiceWakeEnabled: true, brighten: true) {}
+        _ = Self.host(root)
+    }
+
+    @Test @MainActor func statusPillDisconnectedBuildsAViewHierarchy() {
+        let root = StatusPill(gateway: .disconnected, voiceWakeEnabled: false) {}
+        _ = Self.host(root)
+    }
+
+    @Test @MainActor func settingsTabBuildsAViewHierarchy() {
+        let appModel = NodeAppModel()
+        let gatewayController = GatewayConnectionController(appModel: appModel, startDiscovery: false)
+
+        let root = SettingsTab()
+            .environment(appModel)
+            .environment(appModel.voiceWake)
+            .environment(gatewayController)
+
+        _ = Self.host(root)
+    }
+
+    @Test @MainActor func rootTabsBuildAViewHierarchy() {
+        let appModel = NodeAppModel()
+        let gatewayController = GatewayConnectionController(appModel: appModel, startDiscovery: false)
+
+        let root = RootTabs()
+            .environment(appModel)
+            .environment(appModel.voiceWake)
+            .environment(gatewayController)
+
+        _ = Self.host(root)
+    }
+
+    @Test @MainActor func voiceTabBuildsAViewHierarchy() {
+        let appModel = NodeAppModel()
+
+        let root = VoiceTab()
+            .environment(appModel)
+            .environment(appModel.voiceWake)
+
+        _ = Self.host(root)
+    }
+
+    @Test @MainActor func voiceWakeWordsViewBuildsAViewHierarchy() {
+        let appModel = NodeAppModel()
+        let root = NavigationStack { VoiceWakeWordsSettingsView() }
+            .environment(appModel)
+        _ = Self.host(root)
+    }
+
+    @Test @MainActor func chatSheetBuildsAViewHierarchy() {
+        let appModel = NodeAppModel()
+        let gateway = GatewayNodeSession()
+        let root = ChatSheet(gateway: gateway, sessionKey: "test")
+            .environment(appModel)
+            .environment(appModel.voiceWake)
+        _ = Self.host(root)
+    }
+
+    @Test @MainActor func voiceWakeToastBuildsAViewHierarchy() {
+        let root = VoiceWakeToast(command: "openclaw: do something")
+        _ = Self.host(root)
+    }
+}

openclaw/apps/ios/Tests/TalkModeConfigParsingTests.swift

@@ -0,0 +1,31 @@
+import Testing
+@testable import OpenClaw
+
+@MainActor
+@Suite struct TalkModeConfigParsingTests {
+    @Test func prefersNormalizedTalkProviderPayload() {
+        let talk: [String: Any] = [
+            "provider": "elevenlabs",
+            "providers": [
+                "elevenlabs": [
+                    "voiceId": "voice-normalized",
+                ],
+            ],
+            "voiceId": "voice-legacy",
+        ]
+
+        let selection = TalkModeManager.selectTalkProviderConfig(talk)
+        #expect(selection?.provider == "elevenlabs")
+        #expect(selection?.config["voiceId"] as? String == "voice-normalized")
+    }
+
+    @Test func ignoresLegacyTalkFieldsWhenNormalizedPayloadMissing() {
+        let talk: [String: Any] = [
+            "voiceId": "voice-legacy",
+            "apiKey": "legacy-key",
+        ]
+
+        let selection = TalkModeManager.selectTalkProviderConfig(talk)
+        #expect(selection == nil)
+    }
+}

openclaw/apps/ios/Tests/VoiceWakeGatewaySyncTests.swift

@@ -0,0 +1,22 @@
+import Foundation
+import Testing
+@testable import OpenClaw
+
+@Suite struct VoiceWakeGatewaySyncTests {
+    @Test func decodeGatewayTriggersFromJSONSanitizes() {
+        let payload = #"{"triggers":[" openclaw  ","", "computer"]}"#
+        let triggers = VoiceWakePreferences.decodeGatewayTriggers(from: payload)
+        #expect(triggers == ["openclaw", "computer"])
+    }
+
+    @Test func decodeGatewayTriggersFromJSONFallsBackWhenEmpty() {
+        let payload = #"{"triggers":["  ",""]}"#
+        let triggers = VoiceWakePreferences.decodeGatewayTriggers(from: payload)
+        #expect(triggers == VoiceWakePreferences.defaultTriggerWords)
+    }
+
+    @Test func decodeGatewayTriggersFromInvalidJSONReturnsNil() {
+        let triggers = VoiceWakePreferences.decodeGatewayTriggers(from: "not json")
+        #expect(triggers == nil)
+    }
+}

openclaw/apps/ios/Tests/VoiceWakeManagerExtractCommandTests.swift

@@ -0,0 +1,90 @@
+import Foundation
+import SwabbleKit
+import Testing
+@testable import OpenClaw
+
+@Suite struct VoiceWakeManagerExtractCommandTests {
+    @Test func extractCommandReturnsNilWhenNoTriggerFound() {
+        let transcript = "hello world"
+        let segments = makeSegments(
+            transcript: transcript,
+            words: [("hello", 0.0, 0.1), ("world", 0.2, 0.1)])
+        #expect(VoiceWakeManager.extractCommand(from: transcript, segments: segments, triggers: ["openclaw"]) == nil)
+    }
+
+    @Test func extractCommandTrimsTokensAndResult() {
+        let transcript = "hey openclaw do thing"
+        let segments = makeSegments(
+            transcript: transcript,
+            words: [
+                ("hey", 0.0, 0.1),
+                ("openclaw", 0.2, 0.1),
+                ("do", 0.9, 0.1),
+                ("thing", 1.1, 0.1),
+            ])
+        let cmd = VoiceWakeManager.extractCommand(
+            from: transcript,
+            segments: segments,
+            triggers: ["  openclaw  "],
+            minPostTriggerGap: 0.3)
+        #expect(cmd == "do thing")
+    }
+
+    @Test func extractCommandReturnsNilWhenGapTooShort() {
+        let transcript = "hey openclaw do thing"
+        let segments = makeSegments(
+            transcript: transcript,
+            words: [
+                ("hey", 0.0, 0.1),
+                ("openclaw", 0.2, 0.1),
+                ("do", 0.35, 0.1),
+                ("thing", 0.5, 0.1),
+            ])
+        let cmd = VoiceWakeManager.extractCommand(
+            from: transcript,
+            segments: segments,
+            triggers: ["openclaw"],
+            minPostTriggerGap: 0.3)
+        #expect(cmd == nil)
+    }
+
+    @Test func extractCommandReturnsNilWhenNothingAfterTrigger() {
+        let transcript = "hey openclaw"
+        let segments = makeSegments(
+            transcript: transcript,
+            words: [("hey", 0.0, 0.1), ("openclaw", 0.2, 0.1)])
+        #expect(VoiceWakeManager.extractCommand(from: transcript, segments: segments, triggers: ["openclaw"]) == nil)
+    }
+
+    @Test func extractCommandIgnoresEmptyTriggers() {
+        let transcript = "hey openclaw do thing"
+        let segments = makeSegments(
+            transcript: transcript,
+            words: [
+                ("hey", 0.0, 0.1),
+                ("openclaw", 0.2, 0.1),
+                ("do", 0.9, 0.1),
+                ("thing", 1.1, 0.1),
+            ])
+        let cmd = VoiceWakeManager.extractCommand(
+            from: transcript,
+            segments: segments,
+            triggers: ["", "   ", "openclaw"],
+            minPostTriggerGap: 0.3)
+        #expect(cmd == "do thing")
+    }
+}
+
+private func makeSegments(
+    transcript: String,
+    words: [(String, TimeInterval, TimeInterval)])
+-> [WakeWordSegment] {
+    var searchStart = transcript.startIndex
+    var output: [WakeWordSegment] = []
+    for (word, start, duration) in words {
+        let range = transcript.range(of: word, range: searchStart..<transcript.endIndex)
+        output.append(WakeWordSegment(text: word, start: start, duration: duration, range: range))
+        if let range { searchStart = range.upperBound }
+    }
+    return output
+}

openclaw/apps/ios/Tests/VoiceWakeManagerStateTests.swift

@@ -0,0 +1,65 @@
+import Foundation
+import SwabbleKit
+import Testing
+@testable import OpenClaw
+
+@Suite(.serialized) struct VoiceWakeManagerStateTests {
+    @Test @MainActor func suspendAndResumeCycleUpdatesState() async {
+        let manager = VoiceWakeManager()
+        manager.isEnabled = true
+        manager.isListening = true
+        manager.statusText = "Listening"
+
+        let suspended = manager.suspendForExternalAudioCapture()
+        #expect(suspended == true)
+        #expect(manager.isListening == false)
+        #expect(manager.statusText == "Paused")
+
+        manager.resumeAfterExternalAudioCapture(wasSuspended: true)
+        try? await Task.sleep(nanoseconds: 900_000_000)
+        #expect(manager.statusText.contains("Voice Wake") == true)
+    }
+
+    @Test @MainActor func handleRecognitionCallbackRestartsOnError() async {
+        let manager = VoiceWakeManager()
+        manager.isEnabled = true
+        manager.isListening = true
+
+        manager._test_handleRecognitionCallback(transcript: nil, segments: [], errorText: "boom")
+        #expect(manager.statusText.contains("Recognizer error") == true)
+        #expect(manager.isListening == false)
+
+        try? await Task.sleep(nanoseconds: 900_000_000)
+        #expect(manager.statusText.contains("Voice Wake") == true)
+    }
+
+    @Test @MainActor func handleRecognitionCallbackDispatchesCommand() async {
+        let manager = VoiceWakeManager()
+        manager.triggerWords = ["openclaw"]
+        manager.isEnabled = true
+
+        actor CaptureBox {
+            var value: String?
+            func set(_ next: String) { self.value = next }
+        }
+        let capture = CaptureBox()
+        manager.configure { cmd in
+            await capture.set(cmd)
+        }
+
+        let transcript = "openclaw hello"
+        let triggerRange = transcript.range(of: "openclaw")!
+        let helloRange = transcript.range(of: "hello")!
+        let segments = [
+            WakeWordSegment(text: "openclaw", start: 0.0, duration: 0.2, range: triggerRange),
+            WakeWordSegment(text: "hello", start: 0.8, duration: 0.2, range: helloRange),
+        ]
+
+        manager._test_handleRecognitionCallback(transcript: transcript, segments: segments, errorText: nil)
+        #expect(manager.lastTriggeredCommand == "hello")
+        #expect(manager.statusText == "Triggered")
+
+        try? await Task.sleep(nanoseconds: 300_000_000)
+        #expect(await capture.value == "hello")
+    }
+}

openclaw/apps/ios/Tests/VoiceWakePreferencesTests.swift

@@ -0,0 +1,38 @@
+import Foundation
+import Testing
+@testable import OpenClaw
+
+@Suite struct VoiceWakePreferencesTests {
+    @Test func sanitizeTriggerWordsTrimsAndDropsEmpty() {
+        #expect(VoiceWakePreferences.sanitizeTriggerWords([" openclaw ", "", " \nclaude\t"]) == ["openclaw", "claude"])
+    }
+
+    @Test func sanitizeTriggerWordsFallsBackToDefaultsWhenEmpty() {
+        #expect(VoiceWakePreferences.sanitizeTriggerWords(["", "  "]) == VoiceWakePreferences.defaultTriggerWords)
+    }
+
+    @Test func sanitizeTriggerWordsLimitsWordLength() {
+        let long = String(repeating: "x", count: VoiceWakePreferences.maxWordLength + 5)
+        let cleaned = VoiceWakePreferences.sanitizeTriggerWords(["ok", long])
+        #expect(cleaned[1].count == VoiceWakePreferences.maxWordLength)
+    }
+
+    @Test func sanitizeTriggerWordsLimitsWordCount() {
+        let words = (1...VoiceWakePreferences.maxWords + 3).map { "w\($0)" }
+        let cleaned = VoiceWakePreferences.sanitizeTriggerWords(words)
+        #expect(cleaned.count == VoiceWakePreferences.maxWords)
+    }
+
+    @Test func displayStringUsesSanitizedWords() {
+        #expect(VoiceWakePreferences.displayString(for: ["", " "]) == "openclaw, claude")
+    }
+
+    @Test func loadAndSaveTriggerWordsRoundTrip() {
+        let suiteName = "VoiceWakePreferencesTests.\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: suiteName)!
+
+        #expect(VoiceWakePreferences.loadTriggerWords(defaults: defaults) == VoiceWakePreferences.defaultTriggerWords)
+        VoiceWakePreferences.saveTriggerWords(["computer"], defaults: defaults)
+        #expect(VoiceWakePreferences.loadTriggerWords(defaults: defaults) == ["computer"])
+    }
+}