import CoreLocation

import CryptoKit

import Observation

import OpenClawChatUI

import OpenClawKit

import OpenClawProtocol

import os

import Security

import SwiftUI

import UIKit

import UserNotifications

/// Wrap errors without pulling non-Sendable types into async notification paths.

private struct NotificationCallError: Error {

let message: String

}

private struct GatewayRelayIdentityResponse: Decodable {

let deviceId: String

let publicKey: String

}

private struct WatchChatPreview {

var items: [OpenClawWatchChatItem]

var statusText: String?

}

private struct WatchChatMetadataEnvelope: Decodable {

struct Metadata: Decodable {

var id: String?

}

var metadata: Metadata?

var messageToolMirror: [String: String]?

enum CodingKeys: String, CodingKey {

case metadata = "__openclaw"

case messageToolMirror = "openclawMessageToolMirror"

}

}

private struct WatchChatMessageEntry {

var message: OpenClawChatMessage

var text: String

var serverId: String?

var isMessageToolMirror: Bool

}

private struct ExecApprovalGatewayEventPayload: Decodable {

var id: String

}

/// Ensures notification requests return promptly even if the system prompt blocks.

private final class NotificationInvokeLatch<T: Sendable>: @unchecked Sendable {

private let lock = NSLock()

private var continuation: CheckedContinuation<Result<T, NotificationCallError>, Never>?

private var resumed = false

func setContinuation(_ continuation: CheckedContinuation<Result<T, NotificationCallError>, Never>) {

self.lock.lock()

defer { self.lock.unlock() }

self.continuation = continuation

}

func resume(_ response: Result<T, NotificationCallError>) {

let cont: CheckedContinuation<Result<T, NotificationCallError>, Never>?

self.lock.lock()

if self.resumed {

self.lock.unlock()

return

}

self.resumed = true

cont = self.continuation

self.continuation = nil

self.lock.unlock()

cont?.resume(returning: response)

}

}

private enum IOSDeepLinkAgentPolicy {

static let maxMessageChars = 20000

static let maxUnkeyedConfirmChars = 240

}

@MainActor

@Observable

// swiftlint:disable type_body_length file_length

final class NodeAppModel {

private nonisolated static let watchChatPreviewItemLimit = 5

struct AgentDeepLinkPrompt: Identifiable, Equatable {

let id: String

let messagePreview: String

let urlPreview: String

let request: AgentDeepLink

}

struct ExecApprovalPrompt: Identifiable, Equatable, Codable {

let id: String

let commandText: String

let commandPreview: String?

let allowedDecisions: [String]

let host: String?

let nodeId: String?

let agentId: String?

let expiresAtMs: Int?

var allowsAllowAlways: Bool {

self.allowedDecisions.contains("allow-always")

}

}

struct NotificationPermissionGuidancePrompt: Identifiable, Equatable {

let id = UUID()

let approvalId: String

}

private enum ExecApprovalResolutionOutcome {

case resolved

case stale

case unavailable

case failed(message: String)

}

private struct PersistedWatchExecApprovalBridgeState: Codable {

var approvals: [ExecApprovalPrompt]

var pendingApprovalIDs: [String]?

}

private let deepLinkLogger = Logger(subsystem: "ai.openclawfoundation.app", category: "DeepLink")

private nonisolated static let execApprovalNotificationGuidanceSuppressedKey =

"notifications.execApprovalGuidance.suppressed"

private let pushWakeLogger = Logger(subsystem: "ai.openclawfoundation.app", category: "PushWake")

private let pendingActionLogger = Logger(subsystem: "ai.openclawfoundation.app", category: "PendingAction")

private let locationWakeLogger = Logger(subsystem: "ai.openclawfoundation.app", category: "LocationWake")

private let watchReplyLogger = Logger(subsystem: "ai.openclawfoundation.app", category: "WatchReply")

private let watchExecApprovalLogger = Logger(subsystem: "ai.openclawfoundation.app", category: "WatchExecApproval")

private let execApprovalNotificationLogger = Logger(

subsystem: "ai.openclawfoundation.app",

category: "ExecApprovalNotification")

enum CameraHUDKind {

case photo

case recording

case success

case error

}

var isBackgrounded: Bool = false

let screen: ScreenController

private let camera: any CameraServicing

private let screenRecorder: any ScreenRecordingServicing

var gatewayStatusText: String = "Offline"

var nodeStatusText: String = "Offline"

var operatorStatusText: String = "Offline"

private(set) var isAppleReviewDemoModeEnabled: Bool = false

private(set) var isScreenshotFixtureModeEnabled: Bool = false

var isOperatorGatewayConnected: Bool {

self.operatorConnected

}

private(set) var hasOperatorAdminScope: Bool = false

var gatewayServerName: String?

var gatewayRemoteAddress: String?

var connectedGatewayID: String?

var gatewayAutoReconnectEnabled: Bool = true

// When the gateway requires pairing approval, we pause reconnect churn and show a stable UX.

// Reconnect loops (both our own and the underlying WebSocket watchdog) can otherwise generate

// multiple pending requests and cause the onboarding UI to "flip-flop".

var gatewayPairingPaused: Bool = false

var gatewayPairingRequestId: String?

// Bumped on every non-nil assignment, including re-reports of an equal problem;

// value equality alone cannot tell the UI to re-surface or shake the toast.

private(set) var gatewayProblemReportCount = 0

private(set) var lastGatewayProblem: GatewayConnectionProblem? {

didSet { if self.lastGatewayProblem != nil { self.gatewayProblemReportCount &+= 1 } }

}

private var operatorGatewayProblem: GatewayConnectionProblem?

var gatewayDisplayStatusText: String {

self.lastGatewayProblem?.statusText ?? self.gatewayStatusText

}

private var mainSessionBaseKey: String = "main"

private var focusedChatSessionKey: String?

var selectedAgentId: String?

var gatewayDefaultAgentId: String?

var gatewayAgents: [AgentSummary] = []

var homeCanvasRevision: Int = 0

var lastShareEventText: String = "No share events yet."

var openChatRequestID: Int = 0

var gatewaySetupRequestID: Int = 0

private(set) var pendingAgentDeepLinkPrompt: AgentDeepLinkPrompt?

private var pendingGatewaySetupLink: GatewayConnectDeepLink?

private(set) var pendingExecApprovalPrompt: ExecApprovalPrompt?

private(set) var pendingExecApprovalPromptResolving: Bool = false

private(set) var pendingExecApprovalPromptErrorText: String?

private var pendingExecApprovalPromptRequestGeneration: Int = 0

private(set) var pendingNotificationPermissionGuidancePrompt: NotificationPermissionGuidancePrompt?

private var queuedAgentDeepLinkPrompt: AgentDeepLinkPrompt?

private var lastAgentDeepLinkPromptAt: Date = .distantPast

@ObservationIgnored private var queuedAgentDeepLinkPromptTask: Task<Void, Never>?

/// Primary "node" connection: used for device capabilities and node.invoke requests.

private let nodeGateway = GatewayNodeSession()

// Secondary "operator" connection: used for chat/talk/config/voicewake requests.

private let operatorGateway = GatewayNodeSession()

private var nodeGatewayTask: Task<Void, Never>?

private var operatorGatewayTask: Task<Void, Never>?

private var forceOperatorTalkPermissionUpgradeRequest = false

private var lastTalkPermissionReconnectAttemptAt: Date?

private var voiceWakeSyncTask: Task<Void, Never>?

@ObservationIgnored private var cameraHUDDismissTask: Task<Void, Never>?

@ObservationIgnored private lazy var capabilityRouter: NodeCapabilityRouter = self.buildCapabilityRouter()

private let gatewayHealthMonitor = GatewayHealthMonitor()

private var gatewayHealthMonitorDisabled = false

private let notificationCenter: NotificationCentering

let voiceWake = VoiceWakeManager()

let talkMode: TalkModeManager

private let locationService: any LocationServicing

private let deviceStatusService: any DeviceStatusServicing

private let photosService: any PhotosServicing

private let contactsService: any ContactsServicing

private let calendarService: any CalendarServicing

private let remindersService: any RemindersServicing

private let motionService: any MotionServicing

private let watchMessagingService: any WatchMessagingServicing

private var pttVoiceWakeSuspended = false

private var talkVoiceWakeSuspended = false

private var backgroundVoiceWakeSuspended = false

private var backgroundTalkSuspended = false

private var backgroundTalkKeptActive = false

private var backgroundedAt: Date?

private var reconnectAfterBackgroundArmed = false

private var backgroundGraceTaskID: UIBackgroundTaskIdentifier = .invalid

@ObservationIgnored private var backgroundGraceTaskTimer: Task<Void, Never>?

private var backgroundReconnectSuppressed = false

private var backgroundReconnectLeaseUntil: Date?

@ObservationIgnored private var foregroundGatewayResumeCheckInFlight = false

private var lastSignificantLocationWakeAt: Date?

@ObservationIgnored private let watchReplyCoordinator = WatchReplyCoordinator()

@ObservationIgnored private let watchChatCoordinator = WatchChatCoordinator()

@ObservationIgnored private let appleReviewDemoChatTransport = AppleReviewDemoChatTransport()

private var watchExecApprovalPromptsByID: [String: ExecApprovalPrompt] = [:]

private var pendingWatchExecApprovalRecoveryIDs: [String] = []

private var pendingForegroundActionDrainInFlight = false

private var gatewayConnected = false

private var operatorConnected = false

private var shareDeliveryChannel: String?

private var shareDeliveryTo: String?

private var apnsDeviceTokenHex: String?

private var apnsLastRegisteredTokenHex: String?

@ObservationIgnored private let pushRegistrationManager = PushRegistrationManager()

var operatorSession: GatewayNodeSession {

self.operatorGateway

}

var localChatFixture: LocalChatFixture? {

if self.isScreenshotFixtureModeEnabled { return .appScreenshots }

if self.isAppleReviewDemoModeEnabled { return .appleReviewDemo }

return nil

}

var isLocalChatFixtureEnabled: Bool {

self.localChatFixture != nil

}

var isLocalGatewayFixtureEnabled: Bool {

self.isAppleReviewDemoModeEnabled || self.isScreenshotFixtureModeEnabled

}

var chatTransportModeID: String {

if self.isScreenshotFixtureModeEnabled { return "screenshots" }

if self.isAppleReviewDemoModeEnabled { return "apple-review-demo" }

return self.isOperatorGatewayConnected ? "operator" : "offline"

}

func makeChatTransport() -> any OpenClawChatTransport {

if self.isScreenshotFixtureModeEnabled {

return LocalFixtureChatTransport(fixture: .appScreenshots)

}

if self.isAppleReviewDemoModeEnabled {

return AppleReviewDemoChatTransport()

}

return IOSGatewayChatTransport(gateway: self.operatorSession)

}

private(set) var activeGatewayConnectConfig: GatewayConnectConfig?

private static let watchExecApprovalBridgeStateKey = "watch.execApproval.bridge.state.v1"

private static let backgroundAliveLastSuccessAtMsKey = "gateway.backgroundAlive.lastSuccessAtMs"

private static let backgroundAliveLastTriggerKey = "gateway.backgroundAlive.lastTrigger"

private static let foregroundResumeHealthTimeoutSeconds = 1

private static let watchChatCompletionWaitMs = 75000

private static let watchChatRunWaitSliceMs = 60000

var cameraHUDText: String?

var cameraHUDKind: CameraHUDKind?

var cameraFlashNonce: Int = 0

var screenRecordActive: Bool = false

init(

screen: ScreenController = ScreenController(),

camera: any CameraServicing = CameraController(),

screenRecorder: any ScreenRecordingServicing = ScreenRecordService(),

locationService: any LocationServicing = LocationService(),

notificationCenter: NotificationCentering = LiveNotificationCenter(),

deviceStatusService: any DeviceStatusServicing = DeviceStatusService(),

photosService: any PhotosServicing = PhotoLibraryService(),

contactsService: any ContactsServicing = ContactsService(),

calendarService: any CalendarServicing = CalendarService(),

remindersService: any RemindersServicing = RemindersService(),

motionService: any MotionServicing = MotionService(),

watchMessagingService: any WatchMessagingServicing = WatchMessagingService(),

talkMode: TalkModeManager = TalkModeManager())

{

self.screen = screen

self.camera = camera

self.screenRecorder = screenRecorder

self.locationService = locationService

self.notificationCenter = notificationCenter

self.deviceStatusService = deviceStatusService

self.photosService = photosService

self.contactsService = contactsService

self.calendarService = calendarService

self.remindersService = remindersService

self.motionService = motionService

self.watchMessagingService = watchMessagingService

self.talkMode = talkMode

self.apnsDeviceTokenHex = UserDefaults.standard.string(forKey: Self.apnsDeviceTokenUserDefaultsKey)

self.restorePersistedWatchExecApprovalBridgeState()

GatewayDiagnostics.bootstrap()

GatewayDiagnostics.log("node app model: init start")

self.watchMessagingService.setStatusHandler { [weak self] status in

Task { @MainActor in

GatewayDiagnostics.log(

"node app model: watch status callback "

+ "reachable=\(status.reachable) activation=\(status.activationState) "

+ "backgrounded=\(self?.isBackgrounded ?? false)")

await self?.handleWatchMessagingStatusChanged(status)

}

}

self.watchMessagingService.setReplyHandler { [weak self] event in

Task { @MainActor in

await self?.handleWatchQuickReply(event)

}

}

self.watchMessagingService.setExecApprovalResolveHandler { [weak self] event in

Task { @MainActor in

await self?.handleWatchExecApprovalResolve(event)

}

}

self.watchMessagingService.setExecApprovalSnapshotRequestHandler { [weak self] event in

Task { @MainActor in

guard let self else { return }

GatewayDiagnostics.log(

"node app model: watch snapshot request id=\(event.requestId) backgrounded=\(self.isBackgrounded)")

guard self.isBackgrounded else {

self.watchExecApprovalLogger.debug(

"watch exec approval snapshot skipped reason=watch_request_foreground")

GatewayDiagnostics.log("node app model: watch snapshot request skipped in foreground")

return

}

await self.refreshWatchExecApprovalSnapshotOnDemand(reason: "watch_request")

}

}

self.watchMessagingService.setAppSnapshotRequestHandler { [weak self] event in

Task { @MainActor in

guard let self else { return }

GatewayDiagnostics.log(

"node app model: watch app snapshot request id=\(event.requestId)")

await self.syncWatchAppSnapshot(reason: "watch_app_request", includeChat: true)

}

}

self.watchMessagingService.setAppCommandHandler { [weak self] event in

Task { @MainActor in

await self?.handleWatchAppCommand(event)

}

}

self.voiceWake.configure { [weak self] cmd in

guard let self else { return }

let sessionKey = await MainActor.run { self.mainSessionKey }

do {

try await self.sendVoiceTranscript(text: cmd, sessionKey: sessionKey)

} catch {

// Best-effort only.

}

}

let enabled = UserDefaults.standard.bool(forKey: "voiceWake.enabled")

self.voiceWake.setEnabled(enabled)

self.talkMode.attachGateway(self.operatorGateway)

self.refreshOperatorAdminScopeFromStore()

self.refreshLastShareEventFromRelay()

let talkEnabled = UserDefaults.standard.bool(forKey: "talk.enabled")

self.setTalkEnabled(talkEnabled)

self.locationService.setAuthorizationChangeHandler { [weak self] status in

guard let self else { return }

self.reconcileSignificantLocationMonitoring(

mode: self.locationMode(),

authorizationStatus: status)

}

// Wire up deep links from canvas taps

self.screen.onDeepLink = { [weak self] url in

guard let self else { return }

Task { @MainActor in

await self.handleDeepLink(url: url)

}

}

// Wire up A2UI action clicks (buttons, etc.)

self.screen.onA2UIAction = { [weak self] body in

guard let self else { return }

Task { @MainActor in

await self.handleCanvasA2UIAction(body: body)

}

}

}

private func handleCanvasA2UIAction(body: [String: Any]) async {

let userActionAny = body["userAction"] ?? body

let userAction: [String: Any] = {

if let dict = userActionAny as? [String: Any] { return dict }

if let dict = userActionAny as? [AnyHashable: Any] {

return dict.reduce(into: [String: Any]()) { acc, pair in

guard let key = pair.key as? String else { return }

acc[key] = pair.value

}

}

return [:]

}()

guard !userAction.isEmpty else { return }

guard let name = OpenClawCanvasA2UIAction.extractActionName(userAction) else { return }

let actionId: String = {

let id = (userAction["id"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""

return id.isEmpty ? UUID().uuidString : id

}()

let surfaceId: String = {

let raw = (userAction["surfaceId"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""

return raw.isEmpty ? "main" : raw

}()

let sourceComponentId: String = {

let raw = (userAction[

"sourceComponentId",

] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""

return raw.isEmpty ? "-" : raw

}()

let host = NodeDisplayName.resolve(

existing: UserDefaults.standard.string(forKey: "node.displayName"),

deviceName: UIDevice.current.name,

interfaceIdiom: UIDevice.current.userInterfaceIdiom)

let instanceId = (UserDefaults.standard.string(forKey: "node.instanceId") ?? "ios-node").lowercased()

let contextJSON = OpenClawCanvasA2UIAction.compactJSON(userAction["context"])

let sessionKey = self.mainSessionKey

let messageContext = OpenClawCanvasA2UIAction.AgentMessageContext(

actionName: name,

session: .init(key: sessionKey, surfaceId: surfaceId),

component: .init(id: sourceComponentId, host: host, instanceId: instanceId),

contextJSON: contextJSON)

let message = OpenClawCanvasA2UIAction.formatAgentMessage(messageContext)

let ok: Bool

var errorText: String?

if await !self.isGatewayConnected() {

ok = false

errorText = "gateway not connected"

} else {

do {

try await self.sendAgentRequest(link: AgentDeepLink(

message: message,

sessionKey: sessionKey,

thinking: "low",

deliver: false,

to: nil,

channel: nil,

timeoutSeconds: nil,

key: actionId))

ok = true

} catch {

ok = false

errorText = error.localizedDescription

}

}

let js = OpenClawCanvasA2UIAction.jsDispatchA2UIActionStatus(actionId: actionId, ok: ok, error: errorText)

do {

_ = try await self.screen.eval(javaScript: js)

} catch {

// ignore

}

}

func setScenePhase(_ phase: ScenePhase) {

let keepTalkActive = UserDefaults.standard.bool(forKey: "talk.background.enabled")

GatewayDiagnostics.log("node app model: scene phase=\(String(describing: phase))")

switch phase {

case .background:

self.isBackgrounded = true

self.stopGatewayHealthMonitor()

self.backgroundedAt = Date()

self.reconnectAfterBackgroundArmed = true

self.beginBackgroundConnectionGracePeriod()

// Release voice wake mic in background.

self.backgroundVoiceWakeSuspended = self.voiceWake.suspendForExternalAudioCapture()

let shouldKeepTalkActive = keepTalkActive && self.talkMode.isEnabled

self.backgroundTalkKeptActive = shouldKeepTalkActive

self.backgroundTalkSuspended = self.talkMode.suspendForBackground(keepActive: shouldKeepTalkActive)

case .active, .inactive:

self.isBackgrounded = false

self.endBackgroundConnectionGracePeriod(reason: "scene_foreground")

self.clearBackgroundReconnectSuppression(reason: "scene_foreground")

var shouldStartGatewayHealthMonitor = self.operatorConnected

if phase == .active {

self.voiceWake.resumeAfterExternalAudioCapture(wasSuspended: self.backgroundVoiceWakeSuspended)

self.backgroundVoiceWakeSuspended = false

Task { [weak self] in

guard let self else { return }

let suspended = await MainActor.run { self.backgroundTalkSuspended }

let keptActive = await MainActor.run { self.backgroundTalkKeptActive }

await MainActor.run {

self.backgroundTalkSuspended = false

self.backgroundTalkKeptActive = false

}

await self.talkMode.resumeAfterBackground(wasSuspended: suspended, wasKeptActive: keptActive)

}

Task { [weak self] in

await self?.resumePendingForegroundNodeActionsIfNeeded(trigger: "scene_active")

}

}

if phase == .active, self.reconnectAfterBackgroundArmed {

self.reconnectAfterBackgroundArmed = false

let backgroundedFor = self.backgroundedAt.map { Date().timeIntervalSince($0) } ?? 0

self.backgroundedAt = nil

// iOS may suspend network sockets in background without a clean close.

// On foreground, force a fresh handshake to avoid "connected but dead" states.

if backgroundedFor >= 3.0 {

shouldStartGatewayHealthMonitor = false

self.foregroundGatewayResumeCheckInFlight = true

Task { [weak self] in

guard let self else { return }

let operatorWasConnected = await MainActor.run { self.operatorConnected }

if operatorWasConnected {

// Prefer keeping the connection if it's healthy; reconnect only when needed.

let healthy = await (try? self.operatorGateway.request(

method: "health",

paramsJSON: nil,

timeoutSeconds: Self.foregroundResumeHealthTimeoutSeconds)) != nil

if healthy {

await MainActor.run {

self.foregroundGatewayResumeCheckInFlight = false

self.startGatewayHealthMonitor()

}

return

}

}

await MainActor.run {

self.foregroundGatewayResumeCheckInFlight = false

}

await self.restartGatewaySessionsAfterForegroundStaleConnection()

}

}

}

if shouldStartGatewayHealthMonitor {

self.startGatewayHealthMonitor()

}

@unknown default:

self.isBackgrounded = false

self.endBackgroundConnectionGracePeriod(reason: "scene_unknown")

self.clearBackgroundReconnectSuppression(reason: "scene_unknown")

}

}

private func beginBackgroundConnectionGracePeriod(seconds: TimeInterval = 25) {

self.grantBackgroundReconnectLease(seconds: seconds, reason: "scene_background_grace")

self.endBackgroundConnectionGracePeriod(reason: "restart")

let taskID = UIApplication.shared.beginBackgroundTask(withName: "gateway-background-grace") { [weak self] in

Task { @MainActor in

self?.suppressBackgroundReconnect(

reason: "background_grace_expired",

disconnectIfNeeded: true)

self?.endBackgroundConnectionGracePeriod(reason: "expired")

}

}

guard taskID != .invalid else {

self.pushWakeLogger.info("Background grace unavailable: beginBackgroundTask returned invalid")

return

}

self.backgroundGraceTaskID = taskID

self.pushWakeLogger.info("Background grace started seconds=\(seconds, privacy: .public)")

self.backgroundGraceTaskTimer = Task { [weak self] in

guard let self else { return }

try? await Task.sleep(nanoseconds: UInt64(max(1, seconds) * 1_000_000_000))

await MainActor.run {

self.suppressBackgroundReconnect(reason: "background_grace_timer", disconnectIfNeeded: true)

self.endBackgroundConnectionGracePeriod(reason: "timer")

}

}

}

private func endBackgroundConnectionGracePeriod(reason: String) {

self.backgroundGraceTaskTimer?.cancel()

self.backgroundGraceTaskTimer = nil

guard self.backgroundGraceTaskID != .invalid else { return }

UIApplication.shared.endBackgroundTask(self.backgroundGraceTaskID)

self.backgroundGraceTaskID = .invalid

self.pushWakeLogger.info("Background grace ended reason=\(reason, privacy: .public)")

}

private func grantBackgroundReconnectLease(seconds: TimeInterval, reason: String) {

guard self.isBackgrounded else { return }

let leaseSeconds = max(5, seconds)

let leaseUntil = Date().addingTimeInterval(leaseSeconds)

if let existing = self.backgroundReconnectLeaseUntil, existing > leaseUntil {

// Keep the longer lease if one is already active.

} else {

self.backgroundReconnectLeaseUntil = leaseUntil

}

let wasSuppressed = self.backgroundReconnectSuppressed

self.backgroundReconnectSuppressed = false

let leaseLogMessage =

"Background reconnect lease reason=\(reason) "

+ "seconds=\(leaseSeconds) wasSuppressed=\(wasSuppressed)"

self.pushWakeLogger.info("\(leaseLogMessage, privacy: .public)")

}

private func suppressBackgroundReconnect(reason: String, disconnectIfNeeded: Bool) {

guard self.isBackgrounded else { return }

let hadLease = self.backgroundReconnectLeaseUntil != nil

let changed = hadLease || !self.backgroundReconnectSuppressed

self.backgroundReconnectLeaseUntil = nil

self.backgroundReconnectSuppressed = true

guard changed else { return }

let suppressLogMessage =

"Background reconnect suppressed reason=\(reason) "

+ "disconnect=\(disconnectIfNeeded)"

self.pushWakeLogger.info("\(suppressLogMessage, privacy: .public)")

guard disconnectIfNeeded else { return }

Task { [weak self] in

guard let self else { return }

await self.operatorGateway.disconnect()

await self.nodeGateway.disconnect()

await MainActor.run {

guard !self.isLocalGatewayFixtureEnabled else { return }

self.setOperatorConnected(false)

self.gatewayConnected = false

self.talkMode.updateGatewayConnected(false)

if self.isBackgrounded {

self.gatewayStatusText = "Background idle"

LiveActivityManager.shared.endActivity(reason: "background_idle")

self.gatewayServerName = nil

self.gatewayRemoteAddress = nil

self.showLocalCanvasOnDisconnect()

}

}

}

}

private func clearBackgroundReconnectSuppression(reason: String) {

let changed = self.backgroundReconnectSuppressed || self.backgroundReconnectLeaseUntil != nil

self.backgroundReconnectSuppressed = false

self.backgroundReconnectLeaseUntil = nil

guard changed else { return }

self.pushWakeLogger.info("Background reconnect cleared reason=\(reason, privacy: .public)")

}

func setVoiceWakeEnabled(_ enabled: Bool) {

self.voiceWake.setEnabled(enabled)

if enabled {

// If talk is enabled, voice wake should not grab the mic.

if self.talkMode.isEnabled {

self.voiceWake.setSuppressedByTalk(true)

self.talkVoiceWakeSuspended = self.voiceWake.suspendForExternalAudioCapture()

}

} else {

self.voiceWake.setSuppressedByTalk(false)

self.talkVoiceWakeSuspended = false

}

}

func setTalkEnabled(_ enabled: Bool) {

if self.isAppleReviewDemoModeEnabled {

UserDefaults.standard.set(false, forKey: "talk.enabled")

self.talkMode.setEnabled(false)

self.talkMode.statusText = "Demo mode only"

return

}

UserDefaults.standard.set(enabled, forKey: "talk.enabled")

if enabled {

// Voice wake holds the microphone continuously; talk mode needs exclusive access for STT.

// When talk is enabled from the UI, prioritize talk and pause voice wake.

self.voiceWake.setSuppressedByTalk(true)

self.talkVoiceWakeSuspended = self.voiceWake.suspendForExternalAudioCapture()

} else {

self.voiceWake.setSuppressedByTalk(false)

self.voiceWake.resumeAfterExternalAudioCapture(wasSuspended: self.talkVoiceWakeSuspended)

self.talkVoiceWakeSuspended = false

}

self.talkMode.setEnabled(enabled)

Task { [weak self] in

await self?.pushTalkModeToGateway(

enabled: enabled,

phase: enabled ? "enabled" : "disabled")

}

}

func setTalkProviderSelection(_ rawValue: String) {

let selection = TalkModeProviderSelection.resolved(rawValue)

UserDefaults.standard.set(selection.rawValue, forKey: TalkModeProviderSelection.storageKey)

self.talkMode.applyProviderSelectionChanged()

}

func setTalkRealtimeVoiceSelection(_ rawValue: String) {

let voice = TalkModeRealtimeVoiceSelection.resolvedOverride(rawValue) ?? ""

UserDefaults.standard.set(voice, forKey: TalkModeRealtimeVoiceSelection.storageKey)

self.talkMode.applyProviderSelectionChanged()

}

func requestTalkPermissionUpgrade() {

guard let config = self.activeGatewayConnectConfig else {

self.talkMode.gatewayTalkPermissionState = .requestFailed("Gateway is not connected")

self.talkMode.statusText = "Gateway not connected"

return

}

GatewayDiagnostics.log("talk permission upgrade requested")

self.talkMode.gatewayTalkPermissionState = .requestingUpgrade

self.talkMode.statusText = "Requesting Talk approval"

self.forceOperatorTalkPermissionUpgradeRequest = true

self.gatewayAutoReconnectEnabled = true

self.gatewayPairingPaused = false

self.gatewayPairingRequestId = nil

self.lastGatewayProblem = nil

self.operatorGatewayProblem = nil

self.operatorGatewayTask?.cancel()

self.operatorGatewayTask = nil

let sessionBox = config.tls.map { WebSocketSessionBox(session: GatewayTLSPinningSession(params: $0)) }

Task { [weak self] in

guard let self else { return }

await self.operatorGateway.disconnect()

await MainActor.run {

self.startOperatorGatewayLoop(

url: config.url,

stableID: config.effectiveStableID,

token: config.token,

bootstrapToken: config.bootstrapToken,

password: config.password,

nodeOptions: config.nodeOptions,

sessionBox: sessionBox)

}

}

}

func pollTalkPermissionUpgrade() async {

guard self.talkMode.gatewayTalkPermissionState.isApprovalRequestInProgress else {

await self.talkMode.reloadConfig()

await self.talkMode.prefetchRealtimeSessionIfReady(reason: "talk_permission_poll")

return

}

guard let cfg = self.activeGatewayConnectConfig else {

self.talkMode.gatewayTalkPermissionState = .requestFailed("Gateway is not connected")

self.talkMode.statusText = "Gateway not connected"

return

}

let now = Date()

if let lastTalkPermissionReconnectAttemptAt,

now.timeIntervalSince(lastTalkPermissionReconnectAttemptAt) < 6

{

return

}

self.lastTalkPermissionReconnectAttemptAt = now

GatewayDiagnostics.log("talk permission approval poll reconnect")

self.gatewayAutoReconnectEnabled = true

self.gatewayPairingPaused = false

self.gatewayPairingRequestId = nil

self.ensureOperatorReconnectLoopIfNeeded()

if self.operatorGatewayTask == nil {

let sessionBox = cfg.tls.map { WebSocketSessionBox(session: GatewayTLSPinningSession(params: $0)) }

self.startOperatorGatewayLoop(

url: cfg.url,

stableID: cfg.effectiveStableID,

token: cfg.token,

bootstrapToken: cfg.bootstrapToken,

password: cfg.password,

nodeOptions: cfg.nodeOptions,

sessionBox: sessionBox)

}

guard await self.waitForOperatorConnection(timeoutMs: 2500, pollMs: 250) else {

return

}

await self.talkMode.reloadConfig()

await self.talkMode.prefetchRealtimeSessionIfReady(reason: "talk_permission_poll_connected")

}

func setTalkSpeakerphoneEnabled(_ enabled: Bool) {

UserDefaults.standard.set(enabled, forKey: TalkDefaults.speakerphoneEnabledKey)

self.talkMode.applyAudioRoutePreferenceChanged()

}

func requestLocationPermissions(mode: OpenClawLocationMode) async -> Bool {

guard mode != .off else {

self.reconcileSignificantLocationMonitoring(

mode: mode,

authorizationStatus: self.locationService.authorizationStatus())

return true

}

let status = await self.locationService.ensureAuthorization(mode: mode)

switch status {

case .authorizedAlways:

self.reconcileSignificantLocationMonitoring(mode: mode, authorizationStatus: status)

return true

case .authorizedWhenInUse:

self.reconcileSignificantLocationMonitoring(mode: mode, authorizationStatus: status)

return true

default:

self.reconcileSignificantLocationMonitoring(mode: mode, authorizationStatus: status)

return false

}

}

private func reconcileSignificantLocationMonitoring(

mode: OpenClawLocationMode,

authorizationStatus: CLAuthorizationStatus)

{

guard mode == .always, authorizationStatus == .authorizedAlways else {

self.locationService.setBackgroundLocationUpdatesEnabled(false)

self.locationService.stopMonitoringSignificantLocationChanges()

return

}

SignificantLocationMonitor.startIfNeeded(

locationService: self.locationService,

locationMode: mode,

gateway: self.nodeGateway,

beforeSend: { [weak self] in

await self?.handleSignificantLocationWakeIfNeeded()

})

}

private static let apnsDeviceTokenUserDefaultsKey = "push.apns.deviceTokenHex"

private static let deepLinkKeyUserDefaultsKey = "deeplink.agent.key"

private static let canvasUnattendedDeepLinkKey: String = NodeAppModel.generateDeepLinkKey()

private func refreshBrandingFromGateway() async {

do {

let res = try await self.operatorGateway.request(method: "config.get", paramsJSON: "{}", timeoutSeconds: 8)

guard let json = try JSONSerialization.jsonObject(with: res) as? [String: Any] else { return }

guard let config = json["config"] as? [String: Any] else { return }

let session = config["session"] as? [String: Any]

let mainKey = SessionKey.normalizeMainKey(session?["mainKey"] as? String)

await MainActor.run {

self.mainSessionBaseKey = mainKey

self.talkMode.updateMainSessionKey(self.mainSessionKey)

self.homeCanvasRevision &+= 1

}

} catch {

if let gatewayError = error as? GatewayResponseError {

let lower = gatewayError.message.lowercased()

if lower.contains("unauthorized role") {

return

}

}

// ignore

}

}

private func refreshAgentsFromGateway() async {

do {

let res = try await self.operatorGateway.request(method: "agents.list", paramsJSON: "{}", timeoutSeconds: 8)

let decoded = try JSONDecoder().decode(AgentsListResult.self, from: res)

await MainActor.run {

self.gatewayDefaultAgentId = decoded.defaultid

self.gatewayAgents = decoded.agents

self.applyMainSessionKey(decoded.mainkey)

let selected = (self.selectedAgentId ?? "").trimmingCharacters(in: .whitespacesAndNewlines)

if !selected.isEmpty, !decoded.agents.contains(where: { $0.id == selected }) {

self.selectedAgentId = nil

self.focusedChatSessionKey = nil

}

self.talkMode.updateMainSessionKey(self.mainSessionKey)

self.homeCanvasRevision &+= 1

}

} catch {

// Best-effort only.

}

}

func refreshGatewayOverviewIfConnected() async {

guard await self.isOperatorConnected() else { return }

if self.foregroundGatewayResumeCheckInFlight {

GatewayDiagnostics.log("gateway overview refresh deferred reason=foreground_resume_check")

try? await Task.sleep(

nanoseconds: UInt64(Self.foregroundResumeHealthTimeoutSeconds) * 1_000_000_000)

guard await self.isOperatorConnected(), !self.foregroundGatewayResumeCheckInFlight else { return }

}

await self.refreshBrandingFromGateway()

await self.refreshAgentsFromGateway()

}

func setSelectedAgentId(_ agentId: String?) {

let trimmed = (agentId ?? "").trimmingCharacters(in: .whitespacesAndNewlines)

let nextSelectedAgentId = trimmed.isEmpty ? nil : trimmed

let currentSelectedAgentId = self.selectedAgentId?.trimmingCharacters(in: .whitespacesAndNewlines)

let selectedAgentChanged = currentSelectedAgentId != nextSelectedAgentId

let stableID = (self.connectedGatewayID ?? "").trimmingCharacters(in: .whitespacesAndNewlines)

if stableID.isEmpty {

self.selectedAgentId = nextSelectedAgentId

} else {

self.selectedAgentId = nextSelectedAgentId

GatewaySettingsStore.saveGatewaySelectedAgentId(stableID: stableID, agentId: self.selectedAgentId)

}

if selectedAgentChanged {

self.focusedChatSessionKey = nil

}

self.talkMode.updateMainSessionKey(self.mainSessionKey)

self.homeCanvasRevision &+= 1

if let relay = ShareGatewayRelaySettings.loadConfig() {

ShareGatewayRelaySettings.saveConfig(

ShareGatewayRelayConfig(

gatewayURLString: relay.gatewayURLString,

token: relay.token,

password: relay.password,

sessionKey: self.mainSessionKey,

deliveryChannel: self.shareDeliveryChannel,

deliveryTo: self.shareDeliveryTo))

}

}

func setGlobalWakeWords(_ words: [String]) async {

let sanitized = VoiceWakePreferences.sanitizeTriggerWords(words)

struct Payload: Codable {

var triggers: [String]

}

let payload = Payload(triggers: sanitized)

guard let data = try? JSONEncoder().encode(payload),

let json = String(data: data, encoding: .utf8)

else { return }

do {

_ = try await self.operatorGateway.request(method: "voicewake.set", paramsJSON: json, timeoutSeconds: 12)

} catch {

// Best-effort only.

}

}

private func startVoiceWakeSync() async {

self.voiceWakeSyncTask?.cancel()

self.voiceWakeSyncTask = Task { [weak self] in

guard let self else { return }

if !self.isGatewayHealthMonitorDisabled() {

await self.refreshWakeWordsFromGateway()

}

let stream = await self.operatorGateway.subscribeServerEvents(bufferingNewest: 200)

for await evt in stream {

if Task.isCancelled { return }

guard let payload = evt.payload else { continue }

await self.handleOperatorGatewayServerEvent(evt)

}

}

}

private func handleOperatorGatewayServerEvent(_ evt: EventFrame) async {

guard let payload = evt.payload else { return }

switch evt.event {

case "voicewake.changed":

struct Payload: Decodable { var triggers: [String] }

guard let decoded = try? GatewayPayloadDecoding.decode(payload, as: Payload.self) else { return }

let triggers = VoiceWakePreferences.sanitizeTriggerWords(decoded.triggers)

VoiceWakePreferences.saveTriggerWords(triggers)

case "talk.mode":

struct Payload: Decodable {

var enabled: Bool

var phase: String?

}

guard let decoded = try? GatewayPayloadDecoding.decode(payload, as: Payload.self) else { return }

self.applyTalkModeSync(enabled: decoded.enabled, phase: decoded.phase)

case ExecApprovalNotificationBridge.requestedKind:

guard let approvalId = Self.execApprovalEventID(from: payload) else { return }

await self.presentNotificationPermissionGuidanceForExecApprovalIfNeeded(approvalId: approvalId)

await self.presentExecApprovalNotificationPrompt(

ExecApprovalNotificationPrompt(approvalId: approvalId))

case ExecApprovalNotificationBridge.resolvedKind:

guard let approvalId = Self.execApprovalEventID(from: payload) else { return }

await self.handleExecApprovalResolvedRemotePush(approvalId: approvalId)

default: