expo-app-blocker 0.1.67 → 0.1.69

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
 
@@ -206,15 +207,40 @@ public class ExpoAppBlockerModule: Module {
       // Refresh the cached suite so writes made by the (separate) shield
       // extension process are visible to this long-lived app process.
       defaults.synchronize()
-      let queue = defaults.array(forKey: self.pendingInterceptsKey) as? [[String: Any]] ?? []
-      if !queue.isEmpty {
+      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()
       }
-      NSLog("[appblocker] drainPendingIntercepts: returning \(queue.count)")
+      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.67",
+  "version": "0.1.69",
   "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/ShieldAction/ShieldActionExtension.swift

@@ -6,6 +6,11 @@ import UserNotifications
 class ShieldActionExtension: ShieldActionDelegate {
   private let appGroupIdentifier = "APP_GROUP_PLACEHOLDER"
   private let pendingUnlockKey = "appBlocker.pendingUnlock.v1"
+  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 let pendingUnlockNotificationIdentifier = "expo.appblocker.pendingUnlock.local"
   // Notification copy + behavior — configurable via plugin options so apps
   // can localize without forking. Defaults preserve the original English
@@ -27,6 +32,11 @@ class ShieldActionExtension: ShieldActionDelegate {
   }
 
   private func handleAction(_ action: ShieldAction, completionHandler: @escaping (ShieldActionResponse) -> Void) {
+    // Any interaction with the shield is a confirmed block event. The
+    // ShieldConfiguration data source is cached by the system and not
+    // re-invoked per open, so this — the action handler, which fires every
+    // time — is the reliable place to record the block.
+    recordIntercept()
     switch action {
     case .primaryButtonPressed:
       setPendingUnlockFlag()
@@ -54,6 +64,41 @@ class ShieldActionExtension: ShieldActionDelegate {
     }
   }
 
+  /// Queue a block event (JSON-string queue in the App Group), debounced,
+  /// for the app to drain into `blocker_intercepts`.
+  private func recordIntercept() {
+    guard let defaults = UserDefaults(suiteName: appGroupIdentifier) else { return }
+    defaults.synchronize()
+
+    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 {
+      defaults.synchronize()
+      return
+    }
+
+    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": NSNull(), "interceptedAt": nowMs])
+    if queue.count > maxPendingIntercepts {
+      queue = Array(queue.suffix(maxPendingIntercepts))
+    }
+    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)
+    defaults.synchronize()
+    NSLog("[appblocker] ShieldAction recordIntercept queued depth=\(queue.count) invokes=\(invokes)")
+  }
+
   private func setPendingUnlockFlag() {
     guard let sharedDefaults = UserDefaults(suiteName: appGroupIdentifier) else { return }
     sharedDefaults.set(true, forKey: pendingUnlockKey)

package/targets/ShieldConfiguration/ShieldConfigurationExtension.swift

@@ -49,6 +49,7 @@ 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
 
@@ -60,24 +61,42 @@ class ShieldConfigurationExtension: ShieldConfigurationDataSource {
     // 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 {
-      NSLog("[appblocker] recordIntercept: debounced")
+      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)")
+    NSLog("[appblocker] recordIntercept: queued \(appName), depth=\(queue.count) invokes=\(invokes)")
   }
 
   private func makeConfig(appName: String) -> ShieldConfiguration {