refactor: rename to openclaw

apps/ios/Sources/Gateway/GatewayConnectionController.swift

@@ -1,4 +1,4 @@
-import MoltbotKit
+import OpenClawKit
 import Darwin
 import Foundation
 import Network
@@ -283,7 +283,7 @@ final class GatewayConnectionController {
             caps: self.currentCaps(),
             commands: self.currentCommands(),
             permissions: [:],
-            clientId: "moltbot-ios",
+            clientId: "openclaw-ios",
             clientMode: "node",
             clientDisplayName: displayName)
     }
@@ -304,51 +304,51 @@ final class GatewayConnectionController {
     }
 
     private func currentCaps() -> [String] {
-        var caps = [MoltbotCapability.canvas.rawValue, MoltbotCapability.screen.rawValue]
+        var caps = [OpenClawCapability.canvas.rawValue, OpenClawCapability.screen.rawValue]
 
         // Default-on: if the key doesn't exist yet, treat it as enabled.
         let cameraEnabled =
             UserDefaults.standard.object(forKey: "camera.enabled") == nil
                 ? true
                 : UserDefaults.standard.bool(forKey: "camera.enabled")
-        if cameraEnabled { caps.append(MoltbotCapability.camera.rawValue) }
+        if cameraEnabled { caps.append(OpenClawCapability.camera.rawValue) }
 
         let voiceWakeEnabled = UserDefaults.standard.bool(forKey: VoiceWakePreferences.enabledKey)
-        if voiceWakeEnabled { caps.append(MoltbotCapability.voiceWake.rawValue) }
+        if voiceWakeEnabled { caps.append(OpenClawCapability.voiceWake.rawValue) }
 
         let locationModeRaw = UserDefaults.standard.string(forKey: "location.enabledMode") ?? "off"
-        let locationMode = MoltbotLocationMode(rawValue: locationModeRaw) ?? .off
-        if locationMode != .off { caps.append(MoltbotCapability.location.rawValue) }
+        let locationMode = OpenClawLocationMode(rawValue: locationModeRaw) ?? .off
+        if locationMode != .off { caps.append(OpenClawCapability.location.rawValue) }
 
         return caps
     }
 
     private func currentCommands() -> [String] {
         var commands: [String] = [
-            MoltbotCanvasCommand.present.rawValue,
-            MoltbotCanvasCommand.hide.rawValue,
-            MoltbotCanvasCommand.navigate.rawValue,
-            MoltbotCanvasCommand.evalJS.rawValue,
-            MoltbotCanvasCommand.snapshot.rawValue,
-            MoltbotCanvasA2UICommand.push.rawValue,
-            MoltbotCanvasA2UICommand.pushJSONL.rawValue,
-            MoltbotCanvasA2UICommand.reset.rawValue,
-            MoltbotScreenCommand.record.rawValue,
-            MoltbotSystemCommand.notify.rawValue,
-            MoltbotSystemCommand.which.rawValue,
-            MoltbotSystemCommand.run.rawValue,
-            MoltbotSystemCommand.execApprovalsGet.rawValue,
-            MoltbotSystemCommand.execApprovalsSet.rawValue,
+            OpenClawCanvasCommand.present.rawValue,
+            OpenClawCanvasCommand.hide.rawValue,
+            OpenClawCanvasCommand.navigate.rawValue,
+            OpenClawCanvasCommand.evalJS.rawValue,
+            OpenClawCanvasCommand.snapshot.rawValue,
+            OpenClawCanvasA2UICommand.push.rawValue,
+            OpenClawCanvasA2UICommand.pushJSONL.rawValue,
+            OpenClawCanvasA2UICommand.reset.rawValue,
+            OpenClawScreenCommand.record.rawValue,
+            OpenClawSystemCommand.notify.rawValue,
+            OpenClawSystemCommand.which.rawValue,
+            OpenClawSystemCommand.run.rawValue,
+            OpenClawSystemCommand.execApprovalsGet.rawValue,
+            OpenClawSystemCommand.execApprovalsSet.rawValue,
         ]
 
         let caps = Set(self.currentCaps())
-        if caps.contains(MoltbotCapability.camera.rawValue) {
-            commands.append(MoltbotCameraCommand.list.rawValue)
-            commands.append(MoltbotCameraCommand.snap.rawValue)
-            commands.append(MoltbotCameraCommand.clip.rawValue)
+        if caps.contains(OpenClawCapability.camera.rawValue) {
+            commands.append(OpenClawCameraCommand.list.rawValue)
+            commands.append(OpenClawCameraCommand.snap.rawValue)
+            commands.append(OpenClawCameraCommand.clip.rawValue)
         }
-        if caps.contains(MoltbotCapability.location.rawValue) {
-            commands.append(MoltbotLocationCommand.get.rawValue)
+        if caps.contains(OpenClawCapability.location.rawValue) {
+            commands.append(OpenClawLocationCommand.get.rawValue)
         }
 
         return commands

apps/ios/Sources/Gateway/GatewayDiscoveryModel.swift

@@ -1,4 +1,4 @@
-import MoltbotKit
+import OpenClawKit
 import Foundation
 import Network
 import Observation
@@ -52,11 +52,11 @@ final class GatewayDiscoveryModel {
         if !self.browsers.isEmpty { return }
         self.appendDebugLog("start()")
 
-        for domain in MoltbotBonjour.gatewayServiceDomains {
+        for domain in OpenClawBonjour.gatewayServiceDomains {
             let params = NWParameters.tcp
             params.includePeerToPeer = true
             let browser = NWBrowser(
-                for: .bonjour(type: MoltbotBonjour.gatewayServiceType, domain: domain),
+                for: .bonjour(type: OpenClawBonjour.gatewayServiceType, domain: domain),
                 using: params)
 
             browser.stateUpdateHandler = { [weak self] state in
@@ -202,7 +202,7 @@ final class GatewayDiscoveryModel {
 
     private static func prettifyInstanceName(_ decodedName: String) -> String {
         let normalized = decodedName.split(whereSeparator: \.isWhitespace).joined(separator: " ")
-        let stripped = normalized.replacingOccurrences(of: " (Moltbot)", with: "")
+        let stripped = normalized.replacingOccurrences(of: " (OpenClaw)", with: "")
             .replacingOccurrences(of: #"\s+\(\d+\)$"#, with: "", options: .regularExpression)
         return stripped.trimmingCharacters(in: .whitespacesAndNewlines)
     }

apps/ios/Sources/Gateway/GatewaySettingsStore.swift

@@ -1,11 +1,8 @@
 import Foundation
 
 enum GatewaySettingsStore {
-    private static let gatewayService = "bot.molt.gateway"
-    private static let legacyGatewayService = "com.clawdbot.gateway"
-    private static let legacyBridgeService = "com.clawdbot.bridge"
-    private static let nodeService = "bot.molt.node"
-    private static let legacyNodeService = "com.clawdbot.node"
+    private static let gatewayService = "ai.openclaw.gateway"
+    private static let nodeService = "ai.openclaw.node"
 
     private static let instanceIdDefaultsKey = "node.instanceId"
     private static let preferredGatewayStableIDDefaultsKey = "gateway.preferredStableID"
@@ -16,13 +13,6 @@ enum GatewaySettingsStore {
     private static let manualTlsDefaultsKey = "gateway.manual.tls"
     private static let discoveryDebugLogsDefaultsKey = "gateway.discovery.debugLogs"
 
-    private static let legacyPreferredBridgeStableIDDefaultsKey = "bridge.preferredStableID"
-    private static let legacyLastDiscoveredBridgeStableIDDefaultsKey = "bridge.lastDiscoveredStableID"
-    private static let legacyManualEnabledDefaultsKey = "bridge.manual.enabled"
-    private static let legacyManualHostDefaultsKey = "bridge.manual.host"
-    private static let legacyManualPortDefaultsKey = "bridge.manual.port"
-    private static let legacyDiscoveryDebugLogsDefaultsKey = "bridge.discovery.debugLogs"
-
     private static let instanceIdAccount = "instanceId"
     private static let preferredGatewayStableIDAccount = "preferredStableID"
     private static let lastDiscoveredGatewayStableIDAccount = "lastDiscoveredStableID"
@@ -31,7 +21,6 @@ enum GatewaySettingsStore {
         self.ensureStableInstanceID()
         self.ensurePreferredGatewayStableID()
         self.ensureLastDiscoveredGatewayStableID()
-        self.migrateLegacyDefaults()
     }
 
     static func loadStableInstanceID() -> String? {
@@ -42,14 +31,6 @@ enum GatewaySettingsStore {
             return value
         }
 
-        if let legacy = KeychainStore.loadString(service: self.legacyNodeService, account: self.instanceIdAccount)?
-            .trimmingCharacters(in: .whitespacesAndNewlines),
-            !legacy.isEmpty
-        {
-            _ = KeychainStore.saveString(legacy, service: self.nodeService, account: self.instanceIdAccount)
-            return legacy
-        }
-
         return nil
     }
 
@@ -67,19 +48,6 @@ enum GatewaySettingsStore {
             return value
         }
 
-        if let legacy = KeychainStore.loadString(
-            service: self.legacyGatewayService,
-            account: self.preferredGatewayStableIDAccount
-        )?.trimmingCharacters(in: .whitespacesAndNewlines),
-            !legacy.isEmpty
-        {
-            _ = KeychainStore.saveString(
-                legacy,
-                service: self.gatewayService,
-                account: self.preferredGatewayStableIDAccount)
-            return legacy
-        }
-
         return nil
     }
 
@@ -100,19 +68,6 @@ enum GatewaySettingsStore {
             return value
         }
 
-        if let legacy = KeychainStore.loadString(
-            service: self.legacyGatewayService,
-            account: self.lastDiscoveredGatewayStableIDAccount
-        )?.trimmingCharacters(in: .whitespacesAndNewlines),
-            !legacy.isEmpty
-        {
-            _ = KeychainStore.saveString(
-                legacy,
-                service: self.gatewayService,
-                account: self.lastDiscoveredGatewayStableIDAccount)
-            return legacy
-        }
-
         return nil
     }
 
@@ -128,14 +83,6 @@ enum GatewaySettingsStore {
         let token = KeychainStore.loadString(service: self.gatewayService, account: account)?
             .trimmingCharacters(in: .whitespacesAndNewlines)
         if token?.isEmpty == false { return token }
-
-        let legacyAccount = self.legacyBridgeTokenAccount(instanceId: instanceId)
-        let legacy = KeychainStore.loadString(service: self.legacyBridgeService, account: legacyAccount)?
-            .trimmingCharacters(in: .whitespacesAndNewlines)
-        if let legacy, !legacy.isEmpty {
-            _ = KeychainStore.saveString(legacy, service: self.gatewayService, account: account)
-            return legacy
-        }
         return nil
     }
 
@@ -164,10 +111,6 @@ enum GatewaySettingsStore {
         "gateway-token.\(instanceId)"
     }
 
-    private static func legacyBridgeTokenAccount(instanceId: String) -> String {
-        "bridge-token.\(instanceId)"
-    }
-
     private static func gatewayPasswordAccount(instanceId: String) -> String {
         "gateway-password.\(instanceId)"
     }
@@ -231,54 +174,4 @@ enum GatewaySettingsStore {
         }
     }
 
-    private static func migrateLegacyDefaults() {
-        let defaults = UserDefaults.standard
-
-        if defaults.string(forKey: self.preferredGatewayStableIDDefaultsKey)?.isEmpty != false,
-           let legacy = defaults.string(forKey: self.legacyPreferredBridgeStableIDDefaultsKey),
-           !legacy.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
-        {
-            defaults.set(legacy, forKey: self.preferredGatewayStableIDDefaultsKey)
-            self.savePreferredGatewayStableID(legacy)
-        }
-
-        if defaults.string(forKey: self.lastDiscoveredGatewayStableIDDefaultsKey)?.isEmpty != false,
-           let legacy = defaults.string(forKey: self.legacyLastDiscoveredBridgeStableIDDefaultsKey),
-           !legacy.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
-        {
-            defaults.set(legacy, forKey: self.lastDiscoveredGatewayStableIDDefaultsKey)
-            self.saveLastDiscoveredGatewayStableID(legacy)
-        }
-
-        if defaults.object(forKey: self.manualEnabledDefaultsKey) == nil,
-           defaults.object(forKey: self.legacyManualEnabledDefaultsKey) != nil
-        {
-            defaults.set(
-                defaults.bool(forKey: self.legacyManualEnabledDefaultsKey),
-                forKey: self.manualEnabledDefaultsKey)
-        }
-
-        if defaults.string(forKey: self.manualHostDefaultsKey)?.isEmpty != false,
-           let legacy = defaults.string(forKey: self.legacyManualHostDefaultsKey),
-           !legacy.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
-        {
-            defaults.set(legacy, forKey: self.manualHostDefaultsKey)
-        }
-
-        if defaults.integer(forKey: self.manualPortDefaultsKey) == 0,
-           defaults.integer(forKey: self.legacyManualPortDefaultsKey) > 0
-        {
-            defaults.set(
-                defaults.integer(forKey: self.legacyManualPortDefaultsKey),
-                forKey: self.manualPortDefaultsKey)
-        }
-
-        if defaults.object(forKey: self.discoveryDebugLogsDefaultsKey) == nil,
-           defaults.object(forKey: self.legacyDiscoveryDebugLogsDefaultsKey) != nil
-        {
-            defaults.set(
-                defaults.bool(forKey: self.legacyDiscoveryDebugLogsDefaultsKey),
-                forKey: self.discoveryDebugLogsDefaultsKey)
-        }
-    }
 }