expo-app-blocker 0.1.66 → 0.1.68

package/ios/ExpoAppBlockerModule.swift

@@ -39,6 +39,7 @@ public class ExpoAppBlockerModule: Module {
   private let maxUsageSteps = 60
   private let pendingUnlockKey = "appBlocker.pendingUnlock.v1"
   private let pendingInterceptsKey = "appBlocker.pendingIntercepts.v1"
+  private let shieldInvokeCountKey = "appBlocker.shieldInvokeCount.v1"
   private let minimumTemporaryUnlockMinutes = 1
   private var didLoadPersistedConfig = false
 
@@ -203,14 +204,43 @@ public class ExpoAppBlockerModule: Module {
 
     Function("drainPendingIntercepts") { () -> [[String: Any]] in
       guard let defaults = self.sharedDefaults else { return [] }
-      let queue = defaults.array(forKey: self.pendingInterceptsKey) as? [[String: Any]] ?? []
-      if !queue.isEmpty {
+      // Refresh the cached suite so writes made by the (separate) shield
+      // extension process are visible to this long-lived app process.
+      defaults.synchronize()
+      var queue: [[String: Any]] = []
+      if let json = defaults.string(forKey: self.pendingInterceptsKey),
+         let data = json.data(using: .utf8),
+         let parsed = try? JSONSerialization.jsonObject(with: data) as? [[String: Any]] {
+        queue = parsed
+      }
+      if defaults.string(forKey: self.pendingInterceptsKey) != nil {
         defaults.removeObject(forKey: self.pendingInterceptsKey)
         defaults.synchronize()
       }
+      let invokes = defaults.integer(forKey: self.shieldInvokeCountKey)
+      NSLog("[appblocker] drainPendingIntercepts: returning \(queue.count) shieldInvokes=\(invokes)")
       return queue
     }
 
+    // TEMP diagnostic: surfaces whether the shield extension is being
+    // invoked at all (shieldInvokeCount) and the current queue depth,
+    // without clearing anything.
+    Function("debugInterceptState") { () -> [String: Any] in
+      guard let defaults = self.sharedDefaults else { return ["available": false] }
+      defaults.synchronize()
+      var depth = 0
+      if let json = defaults.string(forKey: self.pendingInterceptsKey),
+         let data = json.data(using: .utf8),
+         let parsed = try? JSONSerialization.jsonObject(with: data) as? [[String: Any]] {
+        depth = parsed.count
+      }
+      return [
+        "available": true,
+        "shieldInvokeCount": defaults.integer(forKey: self.shieldInvokeCountKey),
+        "queueDepth": depth,
+      ]
+    }
+
     Function("isAppBlocked") { (bundleIdentifier: String) -> Bool in
       self.ensureLoadedPersistedConfig()
       guard let config = self.currentBlockConfig else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-app-blocker",
-  "version": "0.1.66",
+  "version": "0.1.68",
   "description": "Expo module for cross-platform app blocking. Android: UsageStatsManager + Overlay. iOS: Screen Time API (FamilyControls + ManagedSettings + DeviceActivity).",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/index.ts

@@ -244,6 +244,16 @@ export function drainPendingIntercepts(): PendingIntercept[] {
   return NativeModule.drainPendingIntercepts() ?? [];
 }
 
+/**
+ * TEMP diagnostic: returns `{ shieldInvokeCount, queueDepth }` (iOS) without
+ * clearing the queue. `shieldInvokeCount` proves whether the shield
+ * extension is being invoked by the OS at all.
+ */
+export function debugInterceptState(): Record<string, unknown> {
+  if (Platform.OS !== "ios" && Platform.OS !== "android") return {};
+  return (NativeModule.debugInterceptState?.() as Record<string, unknown>) ?? {};
+}
+
 export function addPendingUnlockListener(
   handler: () => void
 ): { remove: () => void } | null {

package/targets/ShieldConfiguration/ShieldConfigurationExtension.swift

@@ -49,22 +49,54 @@ class ShieldConfigurationExtension: ShieldConfigurationDataSource {
   // those bursts into one logical block event.
   private let pendingInterceptsKey = "appBlocker.pendingIntercepts.v1"
   private let lastInterceptTsKey = "appBlocker.lastInterceptTs.v1"
+  private let shieldInvokeCountKey = "appBlocker.shieldInvokeCount.v1"
   private let interceptDebounceMs: Double = 2_000
   private let maxPendingIntercepts = 200
 
   private func recordIntercept(appName: String) {
-    guard let defaults = UserDefaults(suiteName: appGroupIdentifier) else { return }
+    guard let defaults = UserDefaults(suiteName: appGroupIdentifier) else {
+      NSLog("[appblocker] recordIntercept: no app-group defaults")
+      return
+    }
+    // The extension is a short-lived process; pull a fresh view before
+    // read-modify-write so we don't clobber the app's drain.
+    defaults.synchronize()
+
+    // Diagnostic: count every shield render, before any debounce/branch,
+    // so the app can confirm the extension is actually being invoked.
+    let invokes = defaults.integer(forKey: shieldInvokeCountKey) + 1
+    defaults.set(invokes, forKey: shieldInvokeCountKey)
+
     let nowMs = Date().timeIntervalSince1970 * 1000.0
     let lastMs = defaults.double(forKey: lastInterceptTsKey)
-    if lastMs > 0, (nowMs - lastMs) < interceptDebounceMs { return }
+    if lastMs > 0, (nowMs - lastMs) < interceptDebounceMs {
+      defaults.synchronize()
+      NSLog("[appblocker] recordIntercept: debounced (invokes=\(invokes))")
+      return
+    }
 
-    var queue = defaults.array(forKey: pendingInterceptsKey) as? [[String: Any]] ?? []
+    // Persist as a JSON string — the most robust representation to carry a
+    // nested array across the extension→app process boundary via the App
+    // Group (a raw [[String: Any]] does not reliably survive).
+    var queue: [[String: Any]] = []
+    if let json = defaults.string(forKey: pendingInterceptsKey),
+       let data = json.data(using: .utf8),
+       let parsed = try? JSONSerialization.jsonObject(with: data) as? [[String: Any]] {
+      queue = parsed
+    }
     queue.append(["appName": appName, "interceptedAt": nowMs])
     if queue.count > maxPendingIntercepts {
       queue = Array(queue.suffix(maxPendingIntercepts))
     }
-    defaults.set(queue, forKey: pendingInterceptsKey)
+    if let data = try? JSONSerialization.data(withJSONObject: queue),
+       let json = String(data: data, encoding: .utf8) {
+      defaults.set(json, forKey: pendingInterceptsKey)
+    }
     defaults.set(nowMs, forKey: lastInterceptTsKey)
+    // Force a flush to cfprefsd — the OS may suspend/kill the extension
+    // immediately after rendering, before an unflushed write persists.
+    defaults.synchronize()
+    NSLog("[appblocker] recordIntercept: queued \(appName), depth=\(queue.count) invokes=\(invokes)")
   }
 
   private func makeConfig(appName: String) -> ShieldConfiguration {