expo-app-blocker 0.1.1 → 0.1.2

package/.github/workflows/publish.yml

@@ -0,0 +1,42 @@
+name: Publish to npm
+
+on:
+  push:
+    branches: [master]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    # Skip version bump commits to prevent loops
+    if: "!startsWith(github.event.head_commit.message, 'v')"
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org
+
+      - name: Determine version bump
+        id: version
+        run: |
+          COMMIT_MSG="${{ github.event.head_commit.message }}"
+          if echo "$COMMIT_MSG" | grep -qw "\[major\]"; then
+            echo "bump=major" >> $GITHUB_OUTPUT
+          elif echo "$COMMIT_MSG" | grep -qw "\[minor\]"; then
+            echo "bump=minor" >> $GITHUB_OUTPUT
+          else
+            echo "bump=patch" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Bump version (no git commit)
+        run: npm version ${{ steps.version.outputs.bump }} --no-git-tag-version
+
+      - name: Publish to npm
+        run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+      - name: Output version
+        run: echo "Published $(node -p 'require("./package.json").version')"

package/README.md

@@ -22,6 +22,8 @@ Cross-platform app blocking module for Expo. Block other apps and redirect users
 
 ### Apple Developer Portal (iOS)
 
+> **Full step-by-step guide**: [docs/APPLE_DEVELOPER_SETUP.md](docs/APPLE_DEVELOPER_SETUP.md)
+
 1. Register **4 App IDs** with **Family Controls** and **App Groups** capabilities:
    - `com.yourapp.id` (main app)
    - `com.yourapp.id.DeviceActivityMonitor`

package/docs/APPLE_DEVELOPER_SETUP.md

@@ -0,0 +1,161 @@
+# Apple Developer Portal Setup
+
+This guide walks you through the one-time setup required in the Apple Developer Portal for `expo-app-blocker` on iOS.
+
+## Prerequisites
+
+- A **paid Apple Developer account** ($99/year)
+- Access to https://developer.apple.com/account
+
+---
+
+## Step 1: Create the App Group
+
+The App Group enables data sharing between your main app and the three iOS extensions.
+
+1. Go to **Identifiers**: https://developer.apple.com/account/resources/identifiers/list
+2. Change the dropdown from **"App IDs"** to **"App Groups"**
+   - Or go directly to: https://developer.apple.com/account/resources/identifiers/list/applicationGroup
+3. Click the **+** (blue plus) button
+4. Select **App Groups** > **Continue**
+5. Fill in:
+   - **Description**: `Your App Name Shared` (e.g., "My App Blocker Shared")
+   - **Identifier**: The value you set in `ios.appGroup` in your plugin config
+     - Example: `group.com.yourapp.blocker`
+6. Click **Continue** > **Register**
+
+---
+
+## Step 2: Register the Main App ID
+
+1. Go to **Identifiers**: https://developer.apple.com/account/resources/identifiers/list
+2. Make sure the dropdown shows **"App IDs"**
+3. Click the **+** button
+4. Select **App IDs** > **Continue**
+5. Select **App** > **Continue**
+6. Fill in:
+   - **Description**: Your app name (e.g., "My App Blocker")
+   - **Bundle ID**: Select **Explicit**, enter your `ios.bundleIdentifier` from `app.json`
+     - Example: `com.yourapp.id`
+7. Scroll down to **Capabilities** and enable:
+   - **App Groups**
+   - **Family Controls**
+8. Click **Continue** > **Register**
+
+> **Note on Family Controls**: If you don't see Family Controls in the capabilities list, you may need to request it. Look for a link to request additional capabilities, or check if it appears under "Additional Capabilities".
+
+---
+
+## Step 3: Register the DeviceActivityMonitor Extension App ID
+
+1. Click the **+** button again
+2. **App IDs** > **App** > **Continue**
+3. Fill in:
+   - **Description**: `Your App DeviceActivityMonitor`
+   - **Bundle ID**: Explicit, enter `{your-bundle-id}.DeviceActivityMonitor`
+     - Example: `com.yourapp.id.DeviceActivityMonitor`
+4. Enable capabilities:
+   - **App Groups**
+   - **Family Controls**
+5. Click **Continue** > **Register**
+
+---
+
+## Step 4: Register the ShieldAction Extension App ID
+
+1. Click the **+** button
+2. **App IDs** > **App** > **Continue**
+3. Fill in:
+   - **Description**: `Your App ShieldAction`
+   - **Bundle ID**: Explicit, enter `{your-bundle-id}.ShieldAction`
+     - Example: `com.yourapp.id.ShieldAction`
+4. Enable capabilities:
+   - **App Groups**
+   - **Family Controls**
+5. Click **Continue** > **Register**
+
+---
+
+## Step 5: Register the ShieldConfiguration Extension App ID
+
+1. Click the **+** button
+2. **App IDs** > **App** > **Continue**
+3. Fill in:
+   - **Description**: `Your App ShieldConfiguration`
+   - **Bundle ID**: Explicit, enter `{your-bundle-id}.ShieldConfiguration`
+     - Example: `com.yourapp.id.ShieldConfiguration`
+4. Enable capabilities:
+   - **App Groups**
+   - **Family Controls**
+5. Click **Continue** > **Register**
+
+---
+
+## Step 6: Assign the App Group to All App IDs
+
+For **each of the 4 App IDs** you just created:
+
+1. Click on the App ID in the list
+2. Scroll to **App Groups**
+3. Click **Configure** (or **Edit**)
+4. Check your App Group (e.g., `group.com.yourapp.blocker`)
+5. Click **Save**
+
+Repeat for all 4:
+- `com.yourapp.id`
+- `com.yourapp.id.DeviceActivityMonitor`
+- `com.yourapp.id.ShieldAction`
+- `com.yourapp.id.ShieldConfiguration`
+
+---
+
+## Summary Checklist
+
+When you're done, you should have:
+
+- [ ] **1 App Group**: `group.com.yourapp.blocker`
+- [ ] **4 App IDs**, each with Family Controls + App Groups:
+
+| App ID | Description |
+|---|---|
+| `com.yourapp.id` | Main app |
+| `com.yourapp.id.DeviceActivityMonitor` | Relock timer extension |
+| `com.yourapp.id.ShieldAction` | Shield button handler extension |
+| `com.yourapp.id.ShieldConfiguration` | Custom shield UI extension |
+
+- [ ] App Group assigned to all 4 App IDs
+
+---
+
+## About Family Controls Approval
+
+- **Development builds** (run from Xcode): Family Controls works **without** formal Apple approval
+- **TestFlight**: May require approval depending on your account
+- **App Store**: Requires Family Controls capability approval from Apple
+
+To request approval:
+1. Go to https://developer.apple.com/contact/request/family-controls-distribution
+2. Fill out the form explaining your app's use case
+3. Wait for Apple's response (can take days to weeks)
+
+**You can develop and test locally without waiting for approval.**
+
+---
+
+## Troubleshooting
+
+**"Family Controls" not visible in capabilities list**
+- Make sure you're on a paid developer account (not free)
+- Try searching for it in the capabilities search bar
+- You may need to request access: https://developer.apple.com/contact/request/family-controls-distribution
+
+**"An App ID with this identifier is not available"**
+- The bundle ID might already be registered. Check your existing identifiers.
+
+**App Group not showing when configuring an App ID**
+- Make sure you created the App Group first (Step 1)
+- Try refreshing the page
+
+**Signing errors in Xcode after setup**
+- In Xcode: select each target > Signing & Capabilities > set your Team
+- Xcode should automatically create provisioning profiles using the registered App IDs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-app-blocker",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "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/ios/ExpoAppBlocker.podspec

@@ -1,21 +0,0 @@
-require 'json'
-
-package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
-
-Pod::Spec.new do |s|
-  s.name           = 'ExpoAppBlocker'
-  s.version        = package['version']
-  s.summary        = package['description']
-  s.description    = package['description']
-  s.license        = package['license']
-  s.author         = package['author'] || 'expo-app-blocker contributors'
-  s.homepage       = package['homepage']
-  s.platforms      = { :ios => '16.0' }
-  s.swift_version  = '5.9'
-  s.source         = { git: '' }
-  s.static_framework = true
-
-  s.dependency 'ExpoModulesCore'
-
-  s.source_files = '**/*.{h,m,swift}'
-end

package/ios/ExpoAppBlockerConfig.swift

@@ -1,19 +0,0 @@
-import Foundation
-
-// This file provides default configuration values.
-// The actual values are injected by the config plugin at prebuild time
-// into a generated file in the app's ios directory.
-// If the generated file exists, its values override these defaults.
-
-public struct ExpoAppBlockerConfig {
-  // Override this in your app by creating a file with:
-  // let expoAppBlockerAppGroup = "group.com.yourapp.blocker"
-  public static var appGroupIdentifier: String {
-    // Try to read from UserDefaults (set by config plugin)
-    if let appGroup = UserDefaults.standard.string(forKey: "expo.appblocker.appGroup") {
-      return appGroup
-    }
-    // Fallback - should be overridden
-    return "group.expo.app-blocker"
-  }
-}

package/ios/ExpoAppBlockerModule.swift

@@ -1,1014 +0,0 @@
-import ExpoModulesCore
-import FamilyControls
-import ManagedSettings
-import DeviceActivity
-import SwiftUI
-import Foundation
-
-public class ExpoAppBlockerModule: Module {
-  private let appGroupIdentifier = ExpoAppBlockerConfig.appGroupIdentifier
-
-  private let authCenter = AuthorizationCenter.shared
-  private let store = ManagedSettingsStore()
-  private let activityCenter = DeviceActivityCenter()
-  private var sharedDefaults: UserDefaults?
-  private let userDefaults = UserDefaults.standard
-  private let blockConfigStorageKey = "appBlocker.blockConfiguration.v1"
-  private let temporaryUnlockKey = "appBlocker.temporaryUnlock.v1"
-  private let unlockActivityName = "appBlocker.temporaryUnlock"
-  private let pendingUnlockKey = "appBlocker.pendingUnlock.v1"
-  private let minimumTemporaryUnlockMinutes = 1
-  private var didLoadPersistedConfig = false
-
-  private var currentBlockConfig: BlockConfig?
-  private let stateQueue = DispatchQueue(label: "expo.appblocker.state", qos: .userInitiated)
-  private let scheduleLock = NSLock()
-  private var isProcessingUnlockState = false
-
-  public func definition() -> ModuleDefinition {
-    Name("ExpoAppBlocker")
-
-    Events("onPendingUnlockRequest")
-
-    // Native view that renders blocked app tokens with real names and icons
-    View(BlockedAppsView.self) {
-      Prop("selectionData") { (view: BlockedAppsView, selectionBase64: String) in
-        guard !selectionBase64.isEmpty,
-              let data = Data(base64Encoded: selectionBase64),
-              let selection = try? JSONDecoder().decode(FamilyActivitySelection.self, from: data)
-        else { return }
-        view.viewModel.selection = selection
-      }
-
-      Prop("tokens") { (view: BlockedAppsView, tokens: [[String: String]]) in
-        var appTokens: Set<ApplicationToken> = []
-        var categoryTokens: Set<ActivityCategoryToken> = []
-
-        for tokenInfo in tokens {
-          guard let tokenString = tokenInfo["token"], let type = tokenInfo["type"] else { continue }
-          if type == "app" {
-            if let token = Self.decodeApplicationTokenStatic(from: tokenString) {
-              appTokens.insert(token)
-            }
-          } else if type == "category" {
-            if let token = Self.decodeCategoryTokenStatic(from: tokenString) {
-              categoryTokens.insert(token)
-            }
-          }
-        }
-
-        var selection = FamilyActivitySelection()
-        selection.applicationTokens = appTokens
-        selection.categoryTokens = categoryTokens
-        view.viewModel.selection = selection
-      }
-    }
-
-    OnCreate {
-      self.sharedDefaults = UserDefaults(suiteName: self.appGroupIdentifier)
-      self.setupUnlockNotificationObserver()
-
-      self.stateQueue.asyncAfter(deadline: .now() + 0.5) { [weak self] in
-        self?.checkAndApplyUnlockState()
-      }
-    }
-
-    AsyncFunction("requestAuthorization") { (promise: Promise) in
-      Task {
-        do {
-          try await self.authCenter.requestAuthorization(for: .individual)
-          let status = self.getAuthStatus()
-          promise.resolve([
-            "authorized": status.authorized,
-            "status": status.statusString
-          ])
-        } catch {
-          promise.resolve([
-            "authorized": false,
-            "status": "denied"
-          ])
-        }
-      }
-    }
-
-    Function("getAuthorizationStatus") {
-      let status = self.getAuthStatus()
-      return [
-        "authorized": status.authorized,
-        "status": status.statusString
-      ]
-    }
-
-    AsyncFunction("presentFamilyActivityPicker") { (promise: Promise) in
-      DispatchQueue.main.async {
-        self.ensureLoadedPersistedConfig()
-
-        guard self.authCenter.authorizationStatus == .approved else {
-          promise.reject("NOT_AUTHORIZED", "Family Controls authorization not granted")
-          return
-        }
-
-        let initialAppTokens = Set(self.currentBlockConfig?.items.compactMap { $0.appToken } ?? [])
-        let initialCategoryTokens = Set(self.currentBlockConfig?.items.compactMap { $0.categoryToken } ?? [])
-        let pickerView = FamilyActivityPickerView(
-          initialApplicationTokens: initialAppTokens,
-          initialCategoryTokens: initialCategoryTokens,
-          promise: promise
-        )
-        let hostingController = UIHostingController(rootView: pickerView)
-
-        if let rootVC = self.getRootViewController() {
-          hostingController.modalPresentationStyle = .formSheet
-          rootVC.present(hostingController, animated: true)
-        } else {
-          promise.reject("NO_ROOT_VC", "Could not find root view controller")
-        }
-      }
-    }
-
-    AsyncFunction("setBlockConfiguration") { (config: [String: Any], promise: Promise) in
-      self.stateQueue.async {
-        do {
-          self.ensureLoadedPersistedConfig()
-          let blockConfig = try self.parseBlockConfig(config)
-          self.currentBlockConfig = blockConfig
-          try self.applyBlocks(blockConfig)
-          self.persistBlockConfiguration(config)
-
-          DispatchQueue.main.async {
-            promise.resolve(nil)
-          }
-        } catch {
-          DispatchQueue.main.async {
-            promise.reject("CONFIG_ERROR", "Failed to set block configuration: \(error.localizedDescription)")
-          }
-        }
-      }
-    }
-
-    Function("getBlockConfiguration") { () -> [String: Any]? in
-      self.ensureLoadedPersistedConfig()
-
-      guard let config = self.currentBlockConfig else {
-        return nil
-      }
-      return self.serializeBlockConfig(config)
-    }
-
-    Function("clearAllBlocks") {
-      self.stateQueue.async {
-        self.ensureLoadedPersistedConfig()
-        self.cancelRelockActivity()
-        self.store.shield.applications = nil
-        self.store.shield.applicationCategories = nil
-        self.currentBlockConfig = nil
-        self.userDefaults.removeObject(forKey: self.blockConfigStorageKey)
-        self.sharedDefaults?.removeObject(forKey: self.blockConfigStorageKey)
-        self.sharedDefaults?.removeObject(forKey: self.temporaryUnlockKey)
-      }
-    }
-
-    Function("checkAndClearPendingUnlock") { () -> Bool in
-      guard let defaults = self.sharedDefaults else { return false }
-      let hasPending = defaults.bool(forKey: self.pendingUnlockKey)
-      if hasPending {
-        defaults.removeObject(forKey: self.pendingUnlockKey)
-        defaults.synchronize()
-      }
-      return hasPending
-    }
-
-    Function("isAppBlocked") { (bundleIdentifier: String) -> Bool in
-      self.ensureLoadedPersistedConfig()
-      guard let config = self.currentBlockConfig else {
-        return false
-      }
-      return config.items.contains { $0.bundleIdentifier == bundleIdentifier }
-    }
-
-    AsyncFunction("temporaryUnlock") { (durationMinutes: Int, promise: Promise) in
-      self.stateQueue.async {
-        self.ensureLoadedPersistedConfig()
-        let sanitizedDurationMinutes = max(self.minimumTemporaryUnlockMinutes, durationMinutes)
-
-        guard let config = self.currentBlockConfig, config.isActive else {
-          DispatchQueue.main.async {
-            promise.reject("NO_ACTIVE_BLOCKS", "No active blocks to unlock")
-          }
-          return
-        }
-
-        let expirationDate = Date().addingTimeInterval(TimeInterval(sanitizedDurationMinutes * 60))
-        self.sharedDefaults?.set(expirationDate, forKey: self.temporaryUnlockKey)
-
-        DispatchQueue.main.async {
-          self.store.shield.applications = nil
-          self.store.shield.applicationCategories = nil
-        }
-
-        // Try to schedule relock, but don't fail if schedule is too short
-        // (Apple requires minimum ~15 min for DeviceActivitySchedule)
-        do {
-          try self.scheduleRelockActivity(expirationDate: expirationDate)
-        } catch {
-          // Schedule failed (too short) - that's OK, we still unlock.
-          // The app will re-check and relock via checkAndApplyUnlockState
-          // when the expiration passes and user returns to the app.
-          print("[AppBlocker] Schedule relock failed (duration may be too short): \(error.localizedDescription)")
-        }
-
-        DispatchQueue.main.async {
-          promise.resolve([
-            "unlocked": true,
-            "expiresAt": expirationDate.timeIntervalSince1970
-          ])
-        }
-      }
-    }
-
-    Function("isTemporarilyUnlocked") { () -> Bool in
-      guard let expirationDate = self.sharedDefaults?.object(forKey: self.temporaryUnlockKey) as? Date else {
-        return false
-      }
-
-      if Date() < expirationDate {
-        return true
-      }
-
-      self.relockApps()
-      return false
-    }
-
-    Function("getRemainingUnlockTime") { () -> Int in
-      guard let expirationDate = self.sharedDefaults?.object(forKey: self.temporaryUnlockKey) as? Date else {
-        return 0
-      }
-
-      let remaining = expirationDate.timeIntervalSince(Date())
-      if remaining > 0 {
-        return Int(remaining)
-      }
-
-      self.relockApps()
-      return 0
-    }
-
-    AsyncFunction("relockApps") { (promise: Promise) in
-      self.stateQueue.async {
-        self.relockApps()
-
-        DispatchQueue.main.async {
-          promise.resolve(["locked": true])
-        }
-      }
-    }
-  }
-
-  // MARK: - Authorization
-
-  private func getAuthStatus() -> (authorized: Bool, statusString: String) {
-    let status = authCenter.authorizationStatus
-    switch status {
-    case .notDetermined:
-      return (false, "notDetermined")
-    case .denied:
-      return (false, "denied")
-    case .approved:
-      return (true, "approved")
-    @unknown default:
-      return (false, "denied")
-    }
-  }
-
-  private func getRootViewController() -> UIViewController? {
-    if let currentVC = appContext?.utilities?.currentViewController() {
-      return currentVC
-    }
-
-    let scenes = UIApplication.shared.connectedScenes
-    let windowScene = scenes.first as? UIWindowScene
-    let window = windowScene?.windows.first
-    return window?.rootViewController
-  }
-
-  // MARK: - Darwin Notification Observer
-
-  private func setupUnlockNotificationObserver() {
-    let notificationCenter = CFNotificationCenterGetDarwinNotifyCenter()
-    let observer = Unmanaged.passUnretained(self).toOpaque()
-
-    let legacyName = "expo.appblocker.temporaryUnlock" as CFString
-    CFNotificationCenterAddObserver(
-      notificationCenter,
-      observer,
-      { (_, observer, _, _, _) in
-        guard let observer else { return }
-        let module = Unmanaged<ExpoAppBlockerModule>.fromOpaque(observer).takeUnretainedValue()
-        module.stateQueue.async {
-          module.checkAndApplyUnlockState()
-        }
-      },
-      legacyName,
-      nil,
-      .deliverImmediately
-    )
-
-    let pendingName = "expo.appblocker.pendingUnlock" as CFString
-    CFNotificationCenterAddObserver(
-      notificationCenter,
-      observer,
-      { (_, observer, _, _, _) in
-        guard let observer else { return }
-        let module = Unmanaged<ExpoAppBlockerModule>.fromOpaque(observer).takeUnretainedValue()
-        module.handlePendingUnlockRequest()
-      },
-      pendingName,
-      nil,
-      .deliverImmediately
-    )
-  }
-
-  private func handlePendingUnlockRequest() {
-    DispatchQueue.main.async {
-      self.sendEvent("onPendingUnlockRequest", [:])
-    }
-  }
-
-  // MARK: - Unlock State
-
-  private func checkAndApplyUnlockState() {
-    guard !isProcessingUnlockState else {
-      return
-    }
-
-    isProcessingUnlockState = true
-    defer { isProcessingUnlockState = false }
-
-    ensureLoadedPersistedConfig()
-
-    if let expirationDate = sharedDefaults?.object(forKey: temporaryUnlockKey) as? Date {
-      let remaining = expirationDate.timeIntervalSince(Date())
-
-      if remaining > 0 {
-        DispatchQueue.main.async {
-          self.store.shield.applications = nil
-          self.store.shield.applicationCategories = nil
-        }
-
-        do {
-          try scheduleRelockActivity(expirationDate: expirationDate)
-        } catch {
-          relockApps()
-        }
-      } else {
-        relockApps()
-      }
-    } else if let config = currentBlockConfig {
-      do {
-        try applyBlocks(config)
-      } catch {
-      }
-    }
-  }
-
-  // MARK: - Block Configuration
-
-  private func parseBlockConfig(_ dict: [String: Any]) throws -> BlockConfig {
-    let rawItems: [[String: Any]]
-    if let blockedItems = dict["blockedItems"] as? [[String: Any]] {
-      rawItems = blockedItems
-    } else if let appSelections = dict["appSelections"] as? [[String: Any]] {
-      rawItems = appSelections.map { item in
-        var normalized = item
-        normalized["type"] = "app"
-        return normalized
-      }
-    } else {
-      throw NSError(domain: "AppBlocker", code: 1, userInfo: [NSLocalizedDescriptionKey: "Missing blockedItems"])
-    }
-
-    let items: [BlockedItemInfo] = rawItems.compactMap { selection -> BlockedItemInfo? in
-      guard let tokenString = selection["token"] as? String else {
-        return nil
-      }
-
-      let itemTypeRaw = (selection["type"] as? String ?? "app").lowercased()
-      let itemType: BlockedItemType = itemTypeRaw == "category" ? .category : .app
-
-      return BlockedItemInfo(
-        type: itemType,
-        tokenId: tokenString,
-        appToken: itemType == .app ? self.decodeApplicationToken(from: tokenString) : nil,
-        categoryToken: itemType == .category ? self.decodeCategoryToken(from: tokenString) : nil,
-        bundleIdentifier: selection["bundleIdentifier"] as? String,
-        displayName: selection["displayName"] as? String,
-        categoryName: selection["categoryName"] as? String,
-        iconBase64: selection["iconBase64"] as? String
-      )
-    }
-
-    let isActive = dict["isActive"] as? Bool ?? true
-
-    var schedule: ScheduleInfo?
-    if let scheduleDict = dict["schedule"] as? [String: Any] {
-      schedule = ScheduleInfo(
-        intervalStart: scheduleDict["intervalStart"] as? Int ?? 0,
-        intervalEnd: scheduleDict["intervalEnd"] as? Int ?? 24,
-        repeats: scheduleDict["repeats"] as? Bool ?? true,
-        warningTime: scheduleDict["warningTime"] as? Int ?? 5
-      )
-    }
-
-    return BlockConfig(items: items, isActive: isActive, schedule: schedule)
-  }
-
-  private func applyBlocks(_ config: BlockConfig) throws {
-    guard config.isActive else {
-      store.shield.applications = nil
-      store.shield.applicationCategories = nil
-      return
-    }
-
-    if isTemporarilyUnlockedInternal() {
-      store.shield.applications = nil
-      store.shield.applicationCategories = nil
-      return
-    }
-
-    let validAppTokens = config.items.compactMap { $0.appToken }
-    let validCategoryTokens = config.items.compactMap { $0.categoryToken }
-
-    guard !validAppTokens.isEmpty || !validCategoryTokens.isEmpty else {
-      store.shield.applications = nil
-      store.shield.applicationCategories = nil
-      return
-    }
-
-    if !validAppTokens.isEmpty {
-      store.shield.applications = Set(validAppTokens)
-    } else {
-      store.shield.applications = nil
-    }
-
-    if !validCategoryTokens.isEmpty {
-      store.shield.applicationCategories = .specific(Set(validCategoryTokens))
-    } else {
-      store.shield.applicationCategories = nil
-    }
-  }
-
-  private func relockApps() {
-    sharedDefaults?.removeObject(forKey: temporaryUnlockKey)
-    cancelRelockActivity()
-    ensureLoadedPersistedConfig()
-
-    guard let config = currentBlockConfig else {
-      return
-    }
-
-    do {
-      try applyBlocks(config)
-    } catch {
-    }
-  }
-
-  // MARK: - Activity Scheduling
-
-  private func scheduleRelockActivity(expirationDate: Date) throws {
-    scheduleLock.lock()
-    defer { scheduleLock.unlock() }
-
-    cancelRelockActivityLocked()
-
-    let activityName = DeviceActivityName(unlockActivityName)
-    let calendar = Calendar.current
-    let now = Date()
-    let startComponents = calendar.dateComponents([.hour, .minute, .second], from: now)
-    let endComponents = calendar.dateComponents([.hour, .minute, .second], from: expirationDate)
-    let nowDay = calendar.startOfDay(for: now)
-    let expirationDay = calendar.startOfDay(for: expirationDate)
-
-    let schedule: DeviceActivitySchedule
-
-    if nowDay == expirationDay {
-      schedule = DeviceActivitySchedule(
-        intervalStart: DateComponents(
-          hour: startComponents.hour,
-          minute: startComponents.minute,
-          second: startComponents.second
-        ),
-        intervalEnd: DateComponents(
-          hour: endComponents.hour,
-          minute: endComponents.minute,
-          second: endComponents.second
-        ),
-        repeats: false
-      )
-    } else {
-      schedule = DeviceActivitySchedule(
-        intervalStart: DateComponents(
-          hour: startComponents.hour,
-          minute: startComponents.minute,
-          second: startComponents.second
-        ),
-        intervalEnd: DateComponents(hour: 23, minute: 59, second: 59),
-        repeats: false
-      )
-    }
-
-    try activityCenter.startMonitoring(activityName, during: schedule)
-  }
-
-  private func cancelRelockActivity() {
-    scheduleLock.lock()
-    defer { scheduleLock.unlock() }
-    cancelRelockActivityLocked()
-  }
-
-  private func cancelRelockActivityLocked() {
-    let activityName = DeviceActivityName(unlockActivityName)
-    activityCenter.stopMonitoring([activityName])
-  }
-
-  private func isTemporarilyUnlockedInternal() -> Bool {
-    guard let expirationDate = sharedDefaults?.object(forKey: temporaryUnlockKey) as? Date else {
-      return false
-    }
-
-    if Date() < expirationDate {
-      return true
-    }
-
-    sharedDefaults?.removeObject(forKey: temporaryUnlockKey)
-    return false
-  }
-
-  // MARK: - Serialization
-
-  private func serializeBlockConfig(_ config: BlockConfig) -> [String: Any] {
-    let blockedItems: [[String: Any]] = config.items.compactMap { tokenInfo in
-      var tokenId = tokenInfo.tokenId
-      if tokenId.isEmpty {
-        switch tokenInfo.type {
-        case .app:
-          if let token = tokenInfo.appToken, let encoded = self.encodeApplicationToken(token) {
-            tokenId = encoded
-          }
-        case .category:
-          if let token = tokenInfo.categoryToken, let encoded = self.encodeCategoryToken(token) {
-            tokenId = encoded
-          }
-        }
-      }
-
-      guard !tokenId.isEmpty else {
-        return nil
-      }
-
-      var dict: [String: Any] = [
-        "type": tokenInfo.type.rawValue,
-        "token": tokenId
-      ]
-
-      if let bundleId = tokenInfo.bundleIdentifier {
-        dict["bundleIdentifier"] = bundleId
-      }
-      if let displayName = tokenInfo.displayName {
-        dict["displayName"] = displayName
-      }
-      if let categoryName = tokenInfo.categoryName {
-        dict["categoryName"] = categoryName
-      }
-      if let iconBase64 = tokenInfo.iconBase64 {
-        dict["iconBase64"] = iconBase64
-      }
-
-      return dict
-    }
-
-    let appSelections = blockedItems.filter { ($0["type"] as? String) == BlockedItemType.app.rawValue }
-
-    var result: [String: Any] = [
-      "blockedItems": blockedItems,
-      "appSelections": appSelections,
-      "isActive": config.isActive
-    ]
-
-    if let schedule = config.schedule {
-      result["schedule"] = [
-        "intervalStart": schedule.intervalStart,
-        "intervalEnd": schedule.intervalEnd,
-        "repeats": schedule.repeats,
-        "warningTime": schedule.warningTime
-      ]
-    }
-
-    return result
-  }
-
-  // MARK: - Persistence
-
-  private func ensureLoadedPersistedConfig() {
-    if didLoadPersistedConfig {
-      return
-    }
-    didLoadPersistedConfig = true
-
-    guard let savedConfig = userDefaults.dictionary(forKey: blockConfigStorageKey) else {
-      return
-    }
-
-    do {
-      let config = try parseBlockConfig(savedConfig)
-      currentBlockConfig = config
-      try applyBlocks(config)
-    } catch {
-      currentBlockConfig = nil
-      userDefaults.removeObject(forKey: blockConfigStorageKey)
-    }
-  }
-
-  private func persistBlockConfiguration(_ config: [String: Any]) {
-    userDefaults.set(config, forKey: blockConfigStorageKey)
-    sharedDefaults?.set(config, forKey: blockConfigStorageKey)
-  }
-
-  // MARK: - Token Encoding/Decoding
-
-  private func encodeApplicationToken(_ token: ApplicationToken) -> String? {
-    do {
-      let data = try JSONEncoder().encode(token)
-      return data.base64EncodedString()
-    } catch {
-      return nil
-    }
-  }
-
-  private func decodeApplicationToken(from encoded: String) -> ApplicationToken? {
-    guard let data = Data(base64Encoded: encoded) else {
-      return nil
-    }
-
-    do {
-      return try JSONDecoder().decode(ApplicationToken.self, from: data)
-    } catch {
-      return nil
-    }
-  }
-
-  private func encodeCategoryToken(_ token: ActivityCategoryToken) -> String? {
-    do {
-      let data = try JSONEncoder().encode(token)
-      return data.base64EncodedString()
-    } catch {
-      return nil
-    }
-  }
-
-  private func decodeCategoryToken(from encoded: String) -> ActivityCategoryToken? {
-    return Self.decodeCategoryTokenStatic(from: encoded)
-  }
-
-  // Static versions for use in View prop closures
-  static func decodeApplicationTokenStatic(from encoded: String) -> ApplicationToken? {
-    guard let data = Data(base64Encoded: encoded) else { return nil }
-    return try? JSONDecoder().decode(ApplicationToken.self, from: data)
-  }
-
-  static func decodeCategoryTokenStatic(from encoded: String) -> ActivityCategoryToken? {
-    guard let data = Data(base64Encoded: encoded) else { return nil }
-    return try? JSONDecoder().decode(ActivityCategoryToken.self, from: data)
-  }
-}
-
-// MARK: - Native View for rendering blocked app tokens with real names/icons
-
-class BlockedAppsViewModel: ObservableObject {
-  @Published var selection = FamilyActivitySelection()
-}
-
-class BlockedAppsView: ExpoView {
-  let viewModel = BlockedAppsViewModel()
-  private var hostingController: UIHostingController<BlockedAppsContentView>?
-
-  required init(appContext: AppContext? = nil) {
-    super.init(appContext: appContext)
-    clipsToBounds = true
-    let contentView = BlockedAppsContentView(viewModel: viewModel)
-    let hc = UIHostingController(rootView: contentView)
-    hc.view.backgroundColor = .clear
-    addSubview(hc.view)
-    hostingController = hc
-  }
-
-  override func layoutSubviews() {
-    super.layoutSubviews()
-    hostingController?.view.frame = bounds
-  }
-}
-
-struct BlockedAppsContentView: View {
-  @ObservedObject var viewModel: BlockedAppsViewModel
-
-  // Grandmizer design system colors
-  private let cardBg = Color(red: 1.0, green: 1.0, blue: 1.0)           // #ffffff
-  private let borderColor = Color(red: 0.91, green: 0.91, blue: 0.91)   // #e8e8e8
-  private let labelColor = Color(red: 0.067, green: 0.067, blue: 0.067) // #111111
-  private let subtitleColor = Color(red: 0.73, green: 0.73, blue: 0.73) // #bbbbbb
-  private let greenBadgeBg = Color(red: 0.94, green: 0.96, blue: 0.91)  // #f0f6e8
-  private let greenText = Color(red: 0.24, green: 0.31, blue: 0.0)      // #3d5000
-
-  var body: some View {
-    VStack(alignment: .leading, spacing: 8) {
-      ForEach(Array(viewModel.selection.applicationTokens), id: \.self) { token in
-        HStack(spacing: 12) {
-          Label(token)
-            .labelStyle(.titleAndIcon)
-            .font(.system(size: 16, weight: .semibold))
-            .tint(labelColor)
-            .foregroundStyle(labelColor)
-          Spacer()
-          Text("App")
-            .font(.system(size: 11, weight: .semibold))
-            .foregroundColor(greenText)
-            .padding(.horizontal, 10)
-            .padding(.vertical, 4)
-            .background(greenBadgeBg)
-            .cornerRadius(100)
-        }
-        .padding(.vertical, 10)
-        .padding(.horizontal, 14)
-        .background(cardBg)
-        .cornerRadius(16)
-        .overlay(
-          RoundedRectangle(cornerRadius: 16)
-            .stroke(borderColor, lineWidth: 1)
-        )
-      }
-
-      ForEach(Array(viewModel.selection.categoryTokens), id: \.self) { token in
-        HStack(spacing: 12) {
-          Label(token)
-            .labelStyle(.titleAndIcon)
-            .font(.system(size: 16, weight: .semibold))
-            .tint(labelColor)
-            .foregroundStyle(labelColor)
-          Spacer()
-          Text("Category")
-            .font(.system(size: 11, weight: .semibold))
-            .foregroundColor(greenText)
-            .padding(.horizontal, 10)
-            .padding(.vertical, 4)
-            .background(greenBadgeBg)
-            .cornerRadius(100)
-        }
-        .padding(.vertical, 10)
-        .padding(.horizontal, 14)
-        .background(cardBg)
-        .cornerRadius(16)
-        .overlay(
-          RoundedRectangle(cornerRadius: 16)
-            .stroke(borderColor, lineWidth: 1)
-        )
-      }
-
-      if viewModel.selection.applicationTokens.isEmpty && viewModel.selection.categoryTokens.isEmpty {
-        Text("No apps blocked")
-          .foregroundColor(subtitleColor)
-          .font(.system(size: 14))
-          .frame(maxWidth: .infinity, alignment: .center)
-          .padding(.vertical, 16)
-      }
-    }
-    .environment(\.colorScheme, .light)
-  }
-}
-
-// MARK: - Data Types
-
-enum BlockedItemType: String {
-  case app
-  case category
-}
-
-struct BlockedItemInfo {
-  let type: BlockedItemType
-  let tokenId: String
-  let appToken: ApplicationToken?
-  let categoryToken: ActivityCategoryToken?
-  let bundleIdentifier: String?
-  let displayName: String?
-  let categoryName: String?
-  let iconBase64: String?
-}
-
-struct BlockConfig {
-  let items: [BlockedItemInfo]
-  let isActive: Bool
-  let schedule: ScheduleInfo?
-}
-
-struct ScheduleInfo {
-  let intervalStart: Int
-  let intervalEnd: Int
-  let repeats: Bool
-  let warningTime: Int
-}
-
-// MARK: - FamilyActivityPicker SwiftUI View
-
-struct FamilyActivityPickerView: View {
-  @State private var selection: FamilyActivitySelection
-  @State private var didAppear = false
-  @State private var didFinish = false
-  let promise: Promise
-
-  init(
-    initialApplicationTokens: Set<ApplicationToken>,
-    initialCategoryTokens: Set<ActivityCategoryToken>,
-    promise: Promise
-  ) {
-    self.promise = promise
-
-    var initialSelection = FamilyActivitySelection()
-    initialSelection.applicationTokens = initialApplicationTokens
-    initialSelection.categoryTokens = initialCategoryTokens
-    self._selection = State(initialValue: initialSelection)
-  }
-
-  var body: some View {
-    NavigationView {
-      VStack {
-        familyActivityPicker
-          .onChange(of: selection) { newSelection in
-            _ = newSelection
-          }
-      }
-      .onAppear {
-        didAppear = true
-      }
-      .onDisappear {
-        handleInteractiveDismissIfNeeded()
-      }
-      .navigationBarItems(
-        leading: Button("Cancel") {
-          dismissWithCancel()
-        },
-        trailing: Button("Done") {
-          dismissWithSelection()
-        }
-      )
-    }
-  }
-
-  @ViewBuilder
-  private var familyActivityPicker: some View {
-    FamilyActivityPicker(selection: $selection)
-  }
-
-  private func dismissWithSelection() {
-    let appItems: [[String: Any]] = selection.applications.compactMap { selectedApp in
-      guard let token = selectedApp.token,
-            let tokenId = encodeSelectionToken(token) else {
-        return nil
-      }
-
-      let bundleIdentifier = selectedApp.bundleIdentifier ?? ""
-      let displayName = selectedApp.localizedDisplayName ?? ""
-      // String(describing:) on Application sometimes contains the app name
-      let descriptionString = String(describing: selectedApp)
-
-      // Log everything for debugging
-      print("[AppBlocker] Application: displayName='\(displayName)' bundleId='\(bundleIdentifier)' description='\(descriptionString)'")
-
-      // Try multiple strategies to get a meaningful name
-      let resolvedName: String
-      if !displayName.isEmpty {
-        resolvedName = displayName
-      } else if !bundleIdentifier.isEmpty {
-        // Try to make a readable name from bundle ID
-        // e.g. "com.instagram.android" -> "Instagram"
-        let parts = bundleIdentifier.split(separator: ".")
-        if let lastPart = parts.last {
-          let name = String(lastPart)
-          // Capitalize and clean up
-          resolvedName = name.prefix(1).uppercased() + name.dropFirst()
-        } else {
-          resolvedName = bundleIdentifier
-        }
-      } else if !descriptionString.isEmpty && descriptionString != "Application()" {
-        // Try to parse something useful from description
-        let cleaned = descriptionString
-          .replacingOccurrences(of: "Application(", with: "")
-          .replacingOccurrences(of: ")", with: "")
-          .trimmingCharacters(in: .whitespaces)
-        resolvedName = cleaned.isEmpty ? "Blocked App" : cleaned
-      } else {
-        resolvedName = "Blocked App"
-      }
-
-      return [
-        "type": "app",
-        "token": tokenId,
-        "bundleIdentifier": bundleIdentifier,
-        "displayName": resolvedName,
-        "description": descriptionString
-      ]
-    }
-
-    let categoryItems: [[String: Any]] = selection.categoryTokens.compactMap { categoryToken in
-      guard let tokenId = encodeSelectionCategoryToken(categoryToken) else {
-        return nil
-      }
-
-      let descriptionString = String(describing: categoryToken)
-      let name = resolveCategoryName(categoryToken)
-      print("[AppBlocker] Category: name='\(name)' description='\(descriptionString)'")
-
-      return [
-        "type": "category",
-        "token": tokenId,
-        "categoryName": name.isEmpty ? "Category" : name
-      ]
-    }
-
-    // Serialize the full FamilyActivitySelection for the native view
-    var selectionBase64 = ""
-    if let selectionData = try? JSONEncoder().encode(selection) {
-      selectionBase64 = selectionData.base64EncodedString()
-    }
-
-    var result: [[String: Any]] = appItems + categoryItems
-    result.append([
-      "type": "summary",
-      "totalApps": selection.applications.count,
-      "totalCategories": selection.categoryTokens.count,
-      "selectionData": selectionBase64
-    ])
-
-    dismissWithResult(result)
-  }
-
-  private func dismissWithCancel() {
-    didFinish = true
-
-    DispatchQueue.main.async {
-      if let rootVC = getRootViewController() {
-        rootVC.dismiss(animated: true) {
-          self.promise.reject("PICKER_CANCELLED", "User cancelled Family Activity Picker")
-        }
-      }
-    }
-  }
-
-  private func encodeSelectionCategoryToken(_ token: ActivityCategoryToken) -> String? {
-    do {
-      let data = try JSONEncoder().encode(token)
-      return data.base64EncodedString()
-    } catch {
-      return nil
-    }
-  }
-
-  private func resolveCategoryName(_ token: ActivityCategoryToken) -> String {
-    let raw = String(describing: token)
-    return raw.isEmpty ? "Category" : raw
-  }
-
-  private func encodeSelectionToken(_ token: ApplicationToken) -> String? {
-    do {
-      let data = try JSONEncoder().encode(token)
-      return data.base64EncodedString()
-    } catch {
-      return nil
-    }
-  }
-
-  private func dismissWithResult(_ result: [[String: Any]]) {
-    didFinish = true
-
-    DispatchQueue.main.async {
-      if let rootVC = getRootViewController() {
-        rootVC.dismiss(animated: true) {
-          self.promise.resolve(result)
-        }
-      }
-    }
-  }
-
-  private func getRootViewController() -> UIViewController? {
-    let scenes = UIApplication.shared.connectedScenes
-    let windowScene = scenes.first as? UIWindowScene
-    let window = windowScene?.windows.first
-    return window?.rootViewController
-  }
-
-  private func handleInteractiveDismissIfNeeded() {
-    guard didAppear, !didFinish else {
-      return
-    }
-
-    didFinish = true
-    promise.reject("PICKER_CANCELLED", "User dismissed Family Activity Picker")
-  }
-}