@elizaos/capacitor-mobile-signals 1.0.0

package/ios/Sources/MobileSignalsPlugin/ScreenTimeSupport.swift

@@ -0,0 +1,188 @@
+import FamilyControls
+import DeviceActivity
+import Foundation
+import Security
+
+enum ScreenTimeSupport {
+    private static let familyControlsEntitlement = "com.apple.developer.family-controls"
+    private static let requiredFrameworks = ["FamilyControls", "DeviceActivity"]
+
+    private struct EntitlementInspection {
+        let familyControls: Bool
+        let inspected: String
+        let reason: String?
+
+        var satisfied: Bool {
+            familyControls
+        }
+
+        var canAttemptAuthorization: Bool {
+            inspected == "not-inspectable" || familyControls
+        }
+    }
+
+    static func buildStatus(reasonOverride: String? = nil) -> [String: Any] {
+        let entitlementInspection = inspectEntitlements()
+        let familyControlsEnabled = entitlementInspection.familyControls
+        let authorizationEntitlementAvailable = entitlementInspection.canAttemptAuthorization
+        let authorizationStatus = authorizationStatusString()
+        let provisioningSatisfied = entitlementInspection.satisfied
+
+        let reason = reasonOverride ?? derivedReason(
+            familyControlsEnabled: authorizationEntitlementAvailable,
+            authorizationStatus: authorizationStatus
+        )
+        let provisioningReason: Any = provisioningSatisfied
+            ? NSNull()
+            : (entitlementInspection.reason ?? reason)
+
+        return [
+            "supported": provisioningSatisfied || entitlementInspection.inspected == "not-inspectable",
+            "requirements": [
+                "entitlements": [
+                    "familyControls": familyControlsEntitlement,
+                ],
+                "frameworks": requiredFrameworks,
+                "deviceActivityReportExtension": false,
+                "deviceActivityMonitorExtension": false,
+            ],
+            "entitlements": [
+                "familyControls": familyControlsEnabled,
+            ],
+            "provisioning": [
+                "satisfied": provisioningSatisfied,
+                "inspected": entitlementInspection.inspected,
+                "reason": provisioningReason,
+            ],
+            "authorization": [
+                "status": authorizationStatus,
+                "canRequest": canRequestAuthorization(
+                    familyControlsEnabled: authorizationEntitlementAvailable,
+                    authorizationStatus: authorizationStatus
+                ),
+            ],
+            "reportAvailable": false,
+            "coarseSummaryAvailable": false,
+            "thresholdEventsAvailable": false,
+            "rawUsageExportAvailable": false,
+            "reason": reason,
+        ]
+    }
+
+    static func requestAuthorizationIfAvailable(
+        completion: @escaping (String?) -> Void
+    ) {
+        let entitlementInspection = inspectEntitlements()
+        let authorizationStatus = authorizationStatusString()
+        guard canRequestAuthorization(
+            familyControlsEnabled: entitlementInspection.canAttemptAuthorization,
+            authorizationStatus: authorizationStatus
+        ) else {
+            DispatchQueue.main.async {
+                completion(nil)
+            }
+            return
+        }
+
+        if #available(iOS 16.0, *) {
+            Task { @MainActor in
+                do {
+                    try await AuthorizationCenter.shared.requestAuthorization(for: .individual)
+                    completion(nil)
+                } catch {
+                    completion("Screen Time authorization request failed: \(error.localizedDescription)")
+                }
+            }
+            return
+        }
+
+        DispatchQueue.main.async {
+            AuthorizationCenter.shared.requestAuthorization { result in
+                DispatchQueue.main.async {
+                    switch result {
+                    case .success:
+                        completion(nil)
+                    case .failure(let error):
+                        completion("Screen Time authorization request failed: \(error.localizedDescription)")
+                    }
+                }
+            }
+        }
+    }
+
+    private static func authorizationStatusString() -> String {
+        runOnMain {
+            switch AuthorizationCenter.shared.authorizationStatus {
+            case .approved:
+                return "approved"
+            case .denied:
+                return "denied"
+            case .notDetermined:
+                return "not-determined"
+            @unknown default:
+                return "unavailable"
+            }
+        }
+    }
+
+    private static func canRequestAuthorization(
+        familyControlsEnabled: Bool,
+        authorizationStatus: String
+    ) -> Bool {
+        familyControlsEnabled && authorizationStatus != "approved"
+    }
+
+    private static func derivedReason(
+        familyControlsEnabled: Bool,
+        authorizationStatus: String
+    ) -> String {
+        if !familyControlsEnabled {
+            return "Family Controls entitlement is missing from the app bundle."
+        }
+        if authorizationStatus == "not-determined" {
+            return "Screen Time authorization has not been granted yet."
+        }
+        if authorizationStatus == "denied" {
+            return "Screen Time authorization was denied on this device."
+        }
+        return "DeviceActivity report and monitor extensions are not wired in this checkout."
+    }
+
+    private static func inspectEntitlements() -> EntitlementInspection {
+        #if os(macOS)
+        return EntitlementInspection(
+            familyControls: entitlementIsEnabled(familyControlsEntitlement),
+            inspected: "code-signature",
+            reason: nil
+        )
+        #else
+        return EntitlementInspection(
+            familyControls: false,
+            inspected: "not-inspectable",
+            reason: "iOS entitlement inspection is handled by build validation and provisioning profile checks."
+        )
+        #endif
+    }
+
+    #if os(macOS)
+    private static func entitlementIsEnabled(_ key: String) -> Bool {
+        guard let task = SecTaskCreateFromSelf(nil) else {
+            return false
+        }
+        guard let value = SecTaskCopyValueForEntitlement(task, key as CFString, nil) else {
+            return false
+        }
+        if let boolean = value as? Bool {
+            return boolean
+        }
+        return false
+    }
+    #endif
+
+    private static func runOnMain<T>(_ work: () -> T) -> T {
+        if Thread.isMainThread {
+            return work()
+        }
+        return DispatchQueue.main.sync(execute: work)
+    }
+}

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@elizaos/capacitor-mobile-signals",
+  "version": "1.0.0",
+  "description": "Bridges mobile wake, lock, battery, and protected-data state into LifeOps.",
+  "keywords": [
+    "mobile",
+    "wake",
+    "sleep",
+    "battery",
+    "biometric"
+  ],
+  "main": "./dist/plugin.cjs.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/plugin.cjs.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "dist/",
+    "ios/Sources/",
+    "scripts/validate-ios-screen-time.mjs",
+    "*.podspec"
+  ],
+  "author": "elizaOS",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/elizaOS/eliza"
+  },
+  "scripts": {
+    "build": "npm run clean && tsc && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "validate:ios-screen-time": "node scripts/validate-ios-screen-time.mjs",
+    "watch": "tsc --watch"
+  },
+  "devDependencies": {
+    "@capacitor/android": "^8.0.0",
+    "@capacitor/core": "^8.3.1",
+    "@capacitor/ios": "^8.0.0",
+    "@rollup/plugin-node-resolve": "^16.0.0",
+    "rimraf": "^6.0.0",
+    "rollup": "^4.60.2",
+    "typescript": "^6.0.0",
+    "vitest": "^4.0.17"
+  },
+  "peerDependencies": {
+    "@capacitor/core": "^8.3.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios",
+      "podName": "ElizaosCapacitorMobileSignals"
+    },
+    "android": {
+      "src": "android"
+    }
+  },
+  "elizaos": {
+    "platforms": [
+      "browser",
+      "node"
+    ],
+    "runtime": "both",
+    "platformDetails": {
+      "browser": "Graceful web fallback from document visibility, focus, and Battery Status APIs.",
+      "node": "No desktop native integration; mobile signals are captured on iOS and Android only.",
+      "ios": true,
+      "android": true
+    }
+  }
+}

package/scripts/validate-ios-screen-time.mjs

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pluginRoot = path.resolve(__dirname, "..");
+const defaultRepoRoot = path.resolve(pluginRoot, "..", "..", "..");
+
+export const IOS_SCREEN_TIME_REQUIREMENTS = Object.freeze({
+  entitlements: Object.freeze({
+    familyControls: "com.apple.developer.family-controls",
+  }),
+  frameworks: Object.freeze(["FamilyControls", "DeviceActivity"]),
+  appEntitlementsRelativePath: path.join("App", "App.entitlements"),
+});
+
+export function defaultIosScreenTimeValidationPaths({
+  repoRootValue = defaultRepoRoot,
+} = {}) {
+  return {
+    entitlementsPath: path.join(
+      repoRootValue,
+      "packages",
+      "app-core",
+      "platforms",
+      "ios",
+      "App",
+      "App",
+      "App.entitlements",
+    ),
+    projectPath: path.join(
+      repoRootValue,
+      "packages",
+      "app-core",
+      "platforms",
+      "ios",
+      "App",
+      "App.xcodeproj",
+      "project.pbxproj",
+    ),
+    podspecPath: path.join(
+      repoRootValue,
+      "packages",
+      "native-plugins",
+      "mobile-signals",
+      "ElizaosCapacitorMobileSignals.podspec",
+    ),
+  };
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function addCheck(checks, id, ok, message, skipped = false) {
+  checks.push({ id, ok, skipped, message });
+}
+
+function readRequiredText(filePath, label) {
+  if (!filePath || !fs.existsSync(filePath)) {
+    throw new Error(`${label} does not exist at ${filePath ?? "(not set)"}`);
+  }
+  return fs.readFileSync(filePath, "utf8");
+}
+
+function findKeyEnd(plist, key) {
+  const pattern = new RegExp(`<key>\\s*${escapeRegExp(key)}\\s*</key>`, "m");
+  const match = pattern.exec(plist);
+  return match ? match.index + match[0].length : -1;
+}
+
+function extractNextDict(plist, startIndex) {
+  const dictStart = plist.indexOf("<dict>", startIndex);
+  if (dictStart === -1) return null;
+
+  const tokenPattern = /<\/?dict>/g;
+  tokenPattern.lastIndex = dictStart;
+  let depth = 0;
+  for (;;) {
+    const match = tokenPattern.exec(plist);
+    if (!match) return null;
+    depth += match[0] === "<dict>" ? 1 : -1;
+    if (depth === 0) {
+      return plist.slice(dictStart, tokenPattern.lastIndex);
+    }
+  }
+}
+
+function extractDictAfterKey(plist, key) {
+  const keyEnd = findKeyEnd(plist, key);
+  if (keyEnd === -1) return null;
+  return extractNextDict(plist, keyEnd);
+}
+
+function plistBooleanIsTrue(plist, key, { enclosingKey } = {}) {
+  const source = enclosingKey
+    ? extractDictAfterKey(plist, enclosingKey)
+    : plist;
+  if (!source) return false;
+  const pattern = new RegExp(
+    `<key>\\s*${escapeRegExp(key)}\\s*</key>\\s*<true\\s*/>`,
+    "m",
+  );
+  return pattern.test(source);
+}
+
+function missingRequiredEntitlements(plist, { enclosingKey } = {}) {
+  return Object.values(IOS_SCREEN_TIME_REQUIREMENTS.entitlements).filter(
+    (key) => !plistBooleanIsTrue(plist, key, { enclosingKey }),
+  );
+}
+
+function decodeProvisioningProfile(profilePath) {
+  const raw = fs.readFileSync(profilePath);
+  const text = raw.toString("utf8");
+  if (text.includes("<plist")) {
+    return text;
+  }
+
+  if (process.platform !== "darwin") {
+    throw new Error(
+      "binary provisioning profiles can only be decoded on macOS with the security tool",
+    );
+  }
+
+  const result = spawnSync("security", ["cms", "-D", "-i", profilePath], {
+    encoding: "utf8",
+  });
+  if (result.status !== 0) {
+    throw new Error(
+      result.stderr.trim() ||
+        `security cms failed with exit code ${result.status ?? 1}`,
+    );
+  }
+  return result.stdout;
+}
+
+export function validateIosScreenTimeBuildWiring(options = {}) {
+  const defaults = defaultIosScreenTimeValidationPaths(options);
+  const entitlementsPath =
+    options.entitlementsPath ?? defaults.entitlementsPath;
+  const projectPath = options.projectPath ?? defaults.projectPath;
+  const podspecPath = options.podspecPath ?? defaults.podspecPath;
+  const provisioningProfilePath =
+    options.provisioningProfilePath ??
+    process.env.MOBILE_SIGNALS_IOS_PROVISIONING_PROFILE;
+  const requireProvisioningProfile =
+    options.requireProvisioningProfile ??
+    process.env.MOBILE_SIGNALS_REQUIRE_IOS_PROVISIONING_PROFILE === "1";
+  const checks = [];
+
+  try {
+    const entitlements = readRequiredText(entitlementsPath, "iOS entitlements");
+    const missing = missingRequiredEntitlements(entitlements);
+    addCheck(
+      checks,
+      "app-entitlements",
+      missing.length === 0,
+      missing.length === 0
+        ? `App entitlements include ${Object.values(
+            IOS_SCREEN_TIME_REQUIREMENTS.entitlements,
+          ).join(", ")}.`
+        : `App entitlements are missing required Screen Time keys: ${missing.join(
+            ", ",
+          )}.`,
+    );
+  } catch (error) {
+    addCheck(checks, "app-entitlements", false, error.message);
+  }
+
+  try {
+    const project = readRequiredText(projectPath, "Xcode project");
+    const expected = `CODE_SIGN_ENTITLEMENTS = ${IOS_SCREEN_TIME_REQUIREMENTS.appEntitlementsRelativePath};`;
+    addCheck(
+      checks,
+      "xcode-entitlements-build-setting",
+      project.includes(expected),
+      project.includes(expected)
+        ? "Xcode project signs the app target with App/App.entitlements."
+        : `Xcode project does not contain ${expected}`,
+    );
+  } catch (error) {
+    addCheck(checks, "xcode-entitlements-build-setting", false, error.message);
+  }
+
+  try {
+    const podspec = readRequiredText(podspecPath, "mobile-signals podspec");
+    const missingFrameworks = IOS_SCREEN_TIME_REQUIREMENTS.frameworks.filter(
+      (framework) => !podspec.includes(framework),
+    );
+    addCheck(
+      checks,
+      "podspec-frameworks",
+      missingFrameworks.length === 0,
+      missingFrameworks.length === 0
+        ? "mobile-signals podspec links FamilyControls and DeviceActivity."
+        : `mobile-signals podspec is missing frameworks: ${missingFrameworks.join(
+            ", ",
+          )}.`,
+    );
+  } catch (error) {
+    addCheck(checks, "podspec-frameworks", false, error.message);
+  }
+
+  if (provisioningProfilePath) {
+    try {
+      if (!fs.existsSync(provisioningProfilePath)) {
+        throw new Error(
+          `Provisioning profile does not exist at ${provisioningProfilePath}`,
+        );
+      }
+      const profilePlist = decodeProvisioningProfile(provisioningProfilePath);
+      const missing = missingRequiredEntitlements(profilePlist, {
+        enclosingKey: "Entitlements",
+      });
+      addCheck(
+        checks,
+        "provisioning-entitlements",
+        missing.length === 0,
+        missing.length === 0
+          ? "Provisioning profile includes required Screen Time entitlements."
+          : `Provisioning profile is missing required Screen Time keys: ${missing.join(
+              ", ",
+            )}.`,
+      );
+    } catch (error) {
+      addCheck(checks, "provisioning-entitlements", false, error.message);
+    }
+  } else if (requireProvisioningProfile) {
+    addCheck(
+      checks,
+      "provisioning-entitlements",
+      false,
+      "MOBILE_SIGNALS_REQUIRE_IOS_PROVISIONING_PROFILE=1 but no provisioning profile was supplied.",
+    );
+  } else {
+    addCheck(
+      checks,
+      "provisioning-entitlements",
+      true,
+      "No provisioning profile supplied; skipping profile entitlement inspection.",
+      true,
+    );
+  }
+
+  const failures = checks.filter((check) => !check.ok);
+  return {
+    ok: failures.length === 0,
+    checks,
+    failures,
+    requirements: IOS_SCREEN_TIME_REQUIREMENTS,
+  };
+}
+
+export function assertIosScreenTimeBuildWiring(options = {}) {
+  const result = validateIosScreenTimeBuildWiring(options);
+  if (!result.ok) {
+    throw new Error(
+      [
+        "iOS Screen Time build wiring is invalid:",
+        ...result.failures.map((failure) => `- ${failure.message}`),
+      ].join("\n"),
+    );
+  }
+  return result;
+}
+
+function parseArgs(argv) {
+  const options = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    const next = () => argv[++index];
+    if (arg === "--json") {
+      options.json = true;
+    } else if (arg === "--repo-root") {
+      options.repoRootValue = path.resolve(next());
+    } else if (arg === "--entitlements") {
+      options.entitlementsPath = path.resolve(next());
+    } else if (arg === "--project") {
+      options.projectPath = path.resolve(next());
+    } else if (arg === "--podspec") {
+      options.podspecPath = path.resolve(next());
+    } else if (arg === "--provisioning-profile") {
+      options.provisioningProfilePath = path.resolve(next());
+    } else if (arg === "--require-provisioning-profile") {
+      options.requireProvisioningProfile = true;
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+  return options;
+}
+
+const isMain =
+  process.argv[1] &&
+  path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+
+if (isMain) {
+  try {
+    const options = parseArgs(process.argv.slice(2));
+    const result = validateIosScreenTimeBuildWiring(options);
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      for (const check of result.checks) {
+        const prefix = check.skipped ? "SKIP" : check.ok ? "OK" : "FAIL";
+        console.log(`[${prefix}] ${check.message}`);
+      }
+    }
+    if (!result.ok) {
+      process.exitCode = 1;
+    }
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+}