fix(ios): reconcile significant location monitoring

steipete · web-flow · commit 31ddea5efa60 · 2026-07-03T14:04:41.000-07:00
diff --git a/apps/.i18n/native-source.json b/apps/.i18n/native-source.json
@@ -10843,63 +10843,63 @@
     },
     {
       "kind": "conditional-branch",
-      "line": 2275,
+      "line": 2296,
       "path": "apps/ios/Sources/Model/NodeAppModel.swift",
       "source": "Action required",
       "surface": "apple",
       "id": "native.apple.0d030e96f7738497"
     },
     {
       "kind": "conditional-branch",
-      "line": 2275,
+      "line": 2296,
       "path": "apps/ios/Sources/Model/NodeAppModel.swift",
       "source": "Approval needed",
       "surface": "apple",
       "id": "native.apple.ce6a022159f2fb41"
     },
     {
       "kind": "conditional-branch",
-      "line": 2608,
+      "line": 2629,
       "path": "apps/ios/Sources/Model/NodeAppModel.swift",
       "source": "Connecting…",
       "surface": "apple",
       "id": "native.apple.b0d9c1ba8ef7ec19"
     },
     {
       "kind": "conditional-branch",
-      "line": 2608,
+      "line": 2629,
       "path": "apps/ios/Sources/Model/NodeAppModel.swift",
       "source": "Reconnecting…",
       "surface": "apple",
       "id": "native.apple.bd98e19b49309284"
     },
     {
       "kind": "conditional-branch",
-      "line": 2612,
+      "line": 2633,
       "path": "apps/ios/Sources/Model/NodeAppModel.swift",
       "source": "Connecting...",
       "surface": "apple",
       "id": "native.apple.6504753f3621269e"
     },
     {
       "kind": "conditional-branch",
-      "line": 2612,
+      "line": 2633,
       "path": "apps/ios/Sources/Model/NodeAppModel.swift",
       "source": "Reconnecting...",
       "surface": "apple",
       "id": "native.apple.c7fbe2a713d78714"
     },
     {
       "kind": "conditional-branch",
-      "line": 2920,
+      "line": 2941,
       "path": "apps/ios/Sources/Model/NodeAppModel.swift",
       "source": "Connected",
       "surface": "apple",
       "id": "native.apple.c0a005f81d588867"
     },
     {
       "kind": "conditional-branch",
-      "line": 2920,
+      "line": 2941,
       "path": "apps/ios/Sources/Model/NodeAppModel.swift",
       "source": "Offline",
       "surface": "apple",
diff --git a/apps/ios/Sources/Location/LocationService.swift b/apps/ios/Sources/Location/LocationService.swift
@@ -14,6 +14,7 @@ final class LocationService: NSObject, CLLocationManagerDelegate, LocationServic
     private var authWaitID: UUID?
     private var authContinuation: CheckedContinuation<CLAuthorizationStatus, Never>?
     private var locationContinuation: CheckedContinuation<CLLocation, Swift.Error>?
+    private var authorizationChangeHandler: (@MainActor @Sendable (CLAuthorizationStatus) -> Void)?
     private var significantLocationCallback: (@Sendable (CLLocation) -> Void)?
     private var isMonitoringSignificantChanges = false
 
@@ -121,6 +122,12 @@ final class LocationService: NSObject, CLLocationManagerDelegate, LocationServic
         self.manager.allowsBackgroundLocationUpdates = enabled
     }
 
+    func setAuthorizationChangeHandler(
+        _ handler: @escaping @MainActor @Sendable (CLAuthorizationStatus) -> Void)
+    {
+        self.authorizationChangeHandler = handler
+    }
+
     func stopMonitoringSignificantLocationChanges() {
         self.significantLocationCallback = nil
         self.isMonitoringSignificantChanges = false
@@ -130,7 +137,7 @@ final class LocationService: NSObject, CLLocationManagerDelegate, LocationServic
     nonisolated func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
         let status = manager.authorizationStatus
         Task { @MainActor in
-            self.reconcileBackgroundMonitoringAuthorization(status)
+            self.authorizationChangeHandler?(status)
             guard let waitID = self.authWaitID else { return }
             self.finishAuthorizationWait(waitID: waitID, status: status)
         }
diff --git a/apps/ios/Sources/Model/NodeAppModel.swift b/apps/ios/Sources/Model/NodeAppModel.swift
@@ -1,3 +1,4 @@
+import CoreLocation
 import Observation
 import OpenClawChatUI
 import OpenClawKit
@@ -373,6 +374,12 @@ final class NodeAppModel {
         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
@@ -781,27 +788,41 @@ final class NodeAppModel {
 
     func requestLocationPermissions(mode: OpenClawLocationMode) async -> Bool {
         guard mode != .off else {
-            self.locationService.setBackgroundLocationUpdatesEnabled(false)
-            self.locationService.stopMonitoringSignificantLocationChanges()
+            self.reconcileSignificantLocationMonitoring(
+                mode: mode,
+                authorizationStatus: self.locationService.authorizationStatus())
             return true
         }
         let status = await self.locationService.ensureAuthorization(mode: mode)
         switch status {
         case .authorizedAlways:
-            self.locationService.setBackgroundLocationUpdatesEnabled(mode == .always)
-            if mode != .always {
-                self.locationService.stopMonitoringSignificantLocationChanges()
-            }
+            self.reconcileSignificantLocationMonitoring(mode: mode, authorizationStatus: status)
             return true
         case .authorizedWhenInUse:
-            self.locationService.setBackgroundLocationUpdatesEnabled(false)
-            self.locationService.stopMonitoringSignificantLocationChanges()
+            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 false
+            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"
diff --git a/apps/ios/Sources/Services/NodeServiceProtocols.swift b/apps/ios/Sources/Services/NodeServiceProtocols.swift
@@ -32,18 +32,12 @@ protocol LocationServicing: Sendable {
         maxAgeMs: Int?,
         timeoutMs: Int?) async throws -> CLLocation
     func setBackgroundLocationUpdatesEnabled(_ enabled: Bool)
+    func setAuthorizationChangeHandler(
+        _ handler: @escaping @MainActor @Sendable (CLAuthorizationStatus) -> Void)
     func startMonitoringSignificantLocationChanges(onUpdate: @escaping @Sendable (CLLocation) -> Void)
     func stopMonitoringSignificantLocationChanges()
 }
 
-extension LocationServicing {
-    func reconcileBackgroundMonitoringAuthorization(_ status: CLAuthorizationStatus) {
-        guard status != .authorizedAlways else { return }
-        self.setBackgroundLocationUpdatesEnabled(false)
-        self.stopMonitoringSignificantLocationChanges()
-    }
-}
-
 @MainActor
 protocol DeviceStatusServicing: Sendable {
     func status() async throws -> OpenClawDeviceStatusPayload
diff --git a/apps/ios/Tests/LocationPermissionSummaryTests.swift b/apps/ios/Tests/LocationPermissionSummaryTests.swift
@@ -110,7 +110,7 @@ import Testing
         #expect(locationService.stopMonitoringCallCount == 1)
     }
 
-    @MainActor @Test func `always mode keeps significant location monitoring eligible when always is granted`() async {
+    @MainActor @Test func `always mode starts significant location monitoring when always is granted`() async {
         let locationService = MockLocationService(authorizationStatus: .authorizedAlways)
         let appModel = NodeAppModel(locationService: locationService)
 
@@ -119,6 +119,7 @@ import Testing
         #expect(granted)
         #expect(locationService.backgroundUpdatesEnabled == true)
         #expect(locationService.stopMonitoringCallCount == 0)
+        #expect(locationService.startMonitoringCallCount == 1)
     }
 
     @MainActor @Test func `always mode remains selected when ios only grants while using`() async {
@@ -132,29 +133,38 @@ import Testing
         #expect(locationService.stopMonitoringCallCount == 1)
     }
 
-    @MainActor @Test func `authorization downgrade stops significant location monitoring`() {
+    @MainActor @Test func `external downgrade and always restoration reconcile significant monitoring`() {
+        let defaultsKey = "location.enabledMode"
+        let previous = UserDefaults.standard.object(forKey: defaultsKey)
+        defer {
+            if let previous {
+                UserDefaults.standard.set(previous, forKey: defaultsKey)
+            } else {
+                UserDefaults.standard.removeObject(forKey: defaultsKey)
+            }
+        }
+        UserDefaults.standard.set(OpenClawLocationMode.always.rawValue, forKey: defaultsKey)
         let locationService = MockLocationService(authorizationStatus: .authorizedAlways)
+        let appModel = NodeAppModel(locationService: locationService)
 
-        locationService.reconcileBackgroundMonitoringAuthorization(.authorizedWhenInUse)
+        withExtendedLifetime(appModel) {
+            locationService.simulateAuthorizationChange(.authorizedAlways)
+            locationService.simulateAuthorizationChange(.authorizedWhenInUse)
+            locationService.simulateAuthorizationChange(.authorizedAlways)
+        }
 
-        #expect(locationService.backgroundUpdatesEnabled == false)
+        #expect(locationService.backgroundUpdatesEnabled == true)
+        #expect(locationService.startMonitoringCallCount == 2)
         #expect(locationService.stopMonitoringCallCount == 1)
     }
-
-    @MainActor @Test func `authorized always keeps significant location monitoring active`() {
-        let locationService = MockLocationService(authorizationStatus: .authorizedAlways)
-
-        locationService.reconcileBackgroundMonitoringAuthorization(.authorizedAlways)
-
-        #expect(locationService.backgroundUpdatesEnabled == nil)
-        #expect(locationService.stopMonitoringCallCount == 0)
-    }
 }
 
 @MainActor
 private final class MockLocationService: LocationServicing, @unchecked Sendable {
-    private let status: CLAuthorizationStatus
+    private var status: CLAuthorizationStatus
+    private var authorizationChangeHandler: (@MainActor @Sendable (CLAuthorizationStatus) -> Void)?
     var backgroundUpdatesEnabled: Bool?
+    var startMonitoringCallCount = 0
     var stopMonitoringCallCount = 0
 
     init(authorizationStatus: CLAuthorizationStatus) {
@@ -191,11 +201,23 @@ private final class MockLocationService: LocationServicing, @unchecked Sendable
         self.backgroundUpdatesEnabled = enabled
     }
 
+    func setAuthorizationChangeHandler(
+        _ handler: @escaping @MainActor @Sendable (CLAuthorizationStatus) -> Void)
+    {
+        self.authorizationChangeHandler = handler
+    }
+
     func startMonitoringSignificantLocationChanges(onUpdate: @escaping @Sendable (CLLocation) -> Void) {
         _ = onUpdate
+        self.startMonitoringCallCount += 1
     }
 
     func stopMonitoringSignificantLocationChanges() {
         self.stopMonitoringCallCount += 1
     }
+
+    func simulateAuthorizationChange(_ status: CLAuthorizationStatus) {
+        self.status = status
+        self.authorizationChangeHandler?(status)
+    }
 }
diff --git a/src/daemon/launchd-plist.ts b/src/daemon/launchd-plist.ts
@@ -11,6 +11,7 @@ export const LAUNCH_AGENT_EXIT_TIMEOUT_SECONDS = 20;
 export const LAUNCH_AGENT_UMASK_DECIMAL = 0o077;
 export const LAUNCH_AGENT_PROCESS_TYPE = "Interactive";
 export const LAUNCH_AGENT_STDIN_PATH = "/dev/null";
+export const LAUNCH_AGENT_ENV_WRAPPER_SHELL = "/bin/sh";
 
 const plistEscape = (value: string): string =>
   value
@@ -68,12 +69,11 @@ function resolveSiblingGeneratedEnvFilePath(
   return `${envFilePath.slice(0, serviceEnvDirEnd)}/${label}.env`;
 }
 
-function isGeneratedEnvWrapperArgs(
-  programArguments: string[],
+function isExpectedGeneratedEnvWrapperPair(
+  wrapperPath: string | undefined,
+  envFilePath: string | undefined,
   options?: ReadLaunchAgentProgramArgumentsOptions,
 ): boolean {
-  const wrapperPath = programArguments[0];
-  const envFilePath = programArguments[1];
   if (!wrapperPath || !envFilePath) {
     return false;
   }
@@ -102,14 +102,34 @@ function isGeneratedEnvWrapperArgs(
   );
 }
 
+function resolveGeneratedEnvWrapperLayout(
+  programArguments: string[],
+  options?: ReadLaunchAgentProgramArgumentsOptions,
+): { envFilePath: string; commandStartIndex: number } | null {
+  if (programArguments[0] === LAUNCH_AGENT_ENV_WRAPPER_SHELL) {
+    const wrapperPath = programArguments[1];
+    const envFilePath = programArguments[2];
+    if (isExpectedGeneratedEnvWrapperPair(wrapperPath, envFilePath, options) && envFilePath) {
+      return { envFilePath, commandStartIndex: 3 };
+    }
+  }
+  const wrapperPath = programArguments[0];
+  const envFilePath = programArguments[1];
+  if (isExpectedGeneratedEnvWrapperPair(wrapperPath, envFilePath, options) && envFilePath) {
+    return { envFilePath, commandStartIndex: 2 };
+  }
+  return null;
+}
+
 async function readLaunchAgentEnvironmentFile(
   programArguments: string[],
   options?: ReadLaunchAgentProgramArgumentsOptions,
 ): Promise<Record<string, string>> {
-  const envFilePath = programArguments[1];
-  if (!isGeneratedEnvWrapperArgs(programArguments, options) || !envFilePath) {
+  const layout = resolveGeneratedEnvWrapperLayout(programArguments, options);
+  if (!layout) {
     return {};
   }
+  const envFilePath = layout.envFilePath;
   let content = "";
   const candidateEnvFilePaths = Array.from(
     new Set(
@@ -157,10 +177,11 @@ function unwrapGeneratedEnvWrapperArgs(
   programArguments: string[],
   options?: ReadLaunchAgentProgramArgumentsOptions,
 ): string[] {
-  if (!isGeneratedEnvWrapperArgs(programArguments, options)) {
+  const layout = resolveGeneratedEnvWrapperLayout(programArguments, options);
+  if (!layout) {
     return programArguments;
   }
-  return programArguments.slice(2);
+  return programArguments.slice(layout.commandStartIndex);
 }
 
 const renderEnvDict = (env: Record<string, string | undefined> | undefined): string => {
diff --git a/src/daemon/launchd.test.ts b/src/daemon/launchd.test.ts
diff --git a/src/daemon/launchd.ts b/src/daemon/launchd.ts
