@ateam-ai-mobile/expo 0.1.19 → 0.1.21

package/dist/push/silentSync.js

@@ -0,0 +1,1075 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/push/silentSync.ts
+var silentSync_exports = {};
+__export(silentSync_exports, {
+  registerSilentPushSync: () => registerSilentPushSync
+});
+module.exports = __toCommonJS(silentSync_exports);
+
+// src/device-bridge/background.ts
+var TaskManager = __toESM(require("expo-task-manager"));
+var BackgroundFetch = __toESM(require("expo-background-fetch"));
+
+// src/device-bridge/relay-client.ts
+var RelayClient = class {
+  constructor(config2) {
+    this.offlineQueue = [];
+    this.baseUrl = config2.relayUrl.replace(/\/$/, "");
+    this.deviceId = config2.deviceId;
+    this.tenant = config2.tenant;
+    this.actorId = config2.actorId ?? "default";
+    this.apiKey = config2.apiKey ?? "";
+    this.timeout = config2.timeout ?? 1e4;
+  }
+  // ─── Data Sync ───
+  /**
+   * Push a full device data bundle to the relay.
+   * If offline, buffers the bundle and retries on next sync.
+   */
+  async pushData(bundle) {
+    try {
+      const response = await this.fetch(
+        `/api/device/${this.deviceId}/sync`,
+        {
+          method: "POST",
+          body: JSON.stringify(bundle)
+        }
+      );
+      if (response.ok) {
+        await this.flushOfflineQueue();
+        return { ok: true };
+      }
+      return {
+        ok: false,
+        error: `Relay returned ${response.status}: ${await response.text()}`
+      };
+    } catch (error) {
+      this.offlineQueue.push(bundle);
+      return {
+        ok: false,
+        error: `Offline \u2014 buffered (${this.offlineQueue.length} pending)`
+      };
+    }
+  }
+  /**
+   * Push a single domain update (partial sync).
+   */
+  async pushDomain(domain, data) {
+    try {
+      const response = await this.fetch(
+        `/api/device/${this.deviceId}/sync/${domain}`,
+        {
+          method: "POST",
+          body: JSON.stringify({ domain, data, timestamp: (/* @__PURE__ */ new Date()).toISOString(), actorId: this.actorId })
+        }
+      );
+      if (response.ok) return { ok: true };
+      return {
+        ok: false,
+        error: `Relay returned ${response.status}`
+      };
+    } catch (error) {
+      return { ok: false, error: "Network error \u2014 domain sync failed" };
+    }
+  }
+  // ─── Action Queue ───
+  /**
+   * Poll for pending actions the phone needs to execute.
+   */
+  async pollActions() {
+    try {
+      const response = await this.fetch(
+        `/api/device/${this.deviceId}/actions`,
+        { method: "GET" }
+      );
+      if (response.ok) {
+        const data = await response.json();
+        return { ok: true, data: data.actions ?? [] };
+      }
+      return { ok: false, error: `Relay returned ${response.status}` };
+    } catch (error) {
+      return { ok: false, error: "Network error \u2014 action poll failed" };
+    }
+  }
+  /**
+   * Report action execution result and remove from queue.
+   */
+  async completeAction(result) {
+    try {
+      const response = await this.fetch(
+        `/api/device/${this.deviceId}/actions/${result.id}`,
+        {
+          method: "DELETE",
+          body: JSON.stringify(result)
+        }
+      );
+      if (response.ok) return { ok: true };
+      return { ok: false, error: `Relay returned ${response.status}` };
+    } catch (error) {
+      return { ok: false, error: "Network error \u2014 action complete failed" };
+    }
+  }
+  // ─── Health ───
+  /**
+   * Ping the relay to check connectivity.
+   */
+  async ping() {
+    try {
+      const response = await this.fetch(
+        `/api/health`,
+        { method: "GET" },
+        3e3
+        // short timeout for health check
+      );
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get count of buffered offline bundles.
+   */
+  getOfflineQueueSize() {
+    return this.offlineQueue.length;
+  }
+  // ─── Internal ───
+  async fetch(path, init, timeout) {
+    const controller = new AbortController();
+    const timer = setTimeout(
+      () => controller.abort(),
+      timeout ?? this.timeout
+    );
+    try {
+      return await fetch(`${this.baseUrl}${path}`, {
+        ...init,
+        signal: controller.signal,
+        headers: {
+          "Content-Type": "application/json",
+          "X-ADAS-TENANT": this.tenant,
+          "X-ADAS-ACTOR": this.actorId,
+          "X-Device-Id": this.deviceId,
+          // The relay (post-2026-04-25) gates every /api/device/* call on
+          // a shared secret. Send it as `Authorization: Bearer` so the
+          // server's relayAuth middleware accepts the request. Empty/missing
+          // secret = 401 from the relay (correct fail-closed behavior).
+          ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {},
+          ...init.headers || {}
+        }
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async flushOfflineQueue() {
+    if (this.offlineQueue.length === 0) return;
+    const queue = [...this.offlineQueue];
+    this.offlineQueue = [];
+    for (const bundle of queue) {
+      try {
+        const response = await this.fetch(
+          `/api/device/${this.deviceId}/sync`,
+          {
+            method: "POST",
+            body: JSON.stringify(bundle)
+          }
+        );
+        if (!response.ok) {
+          this.offlineQueue.push(bundle);
+        }
+      } catch {
+        this.offlineQueue.push(bundle);
+        break;
+      }
+    }
+  }
+};
+
+// src/device-bridge/collectors/calendar.ts
+var ExpoCalendar = __toESM(require("expo-calendar"));
+async function requestPermission() {
+  const { status } = await ExpoCalendar.requestCalendarPermissionsAsync();
+  return status === "granted";
+}
+async function hasPermission() {
+  const { status } = await ExpoCalendar.getCalendarPermissionsAsync();
+  return status === "granted";
+}
+async function collectToday() {
+  const now = /* @__PURE__ */ new Date();
+  const startOfDay2 = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  const endOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 23, 59, 59);
+  const calendars = await ExpoCalendar.getCalendarsAsync(ExpoCalendar.EntityTypes.EVENT);
+  const userCalendarIds = getUserCalendarIds(calendars);
+  const events = await ExpoCalendar.getEventsAsync(userCalendarIds, startOfDay2, endOfDay);
+  const filtered = filterHolidays(events);
+  const mapped = filtered.map((e) => ({
+    id: e.id,
+    title: e.title || "Untitled",
+    date: startOfDay2.toISOString().slice(0, 10),
+    start: formatTime(new Date(e.startDate)),
+    end: formatTime(new Date(e.endDate)),
+    location: e.location || "",
+    attendees: (e.attendees || []).map((a) => a.name || a.email || "Unknown"),
+    notes: e.notes || ""
+  }));
+  mapped.sort((a, b) => a.start.localeCompare(b.start));
+  return {
+    ok: true,
+    date: startOfDay2.toISOString().slice(0, 10),
+    day_of_week: now.toLocaleDateString("en-US", { weekday: "long" }),
+    event_count: mapped.length,
+    events: mapped
+  };
+}
+async function collectUpcoming(daysAhead = 3) {
+  const now = /* @__PURE__ */ new Date();
+  const tomorrow = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1);
+  const endDate = new Date(now.getFullYear(), now.getMonth(), now.getDate() + daysAhead + 1);
+  const calendars = await ExpoCalendar.getCalendarsAsync(ExpoCalendar.EntityTypes.EVENT);
+  const userCalendarIds = getUserCalendarIds(calendars);
+  const events = await ExpoCalendar.getEventsAsync(userCalendarIds, tomorrow, endDate);
+  const filtered = filterHolidays(events);
+  const mapped = filtered.map((e) => {
+    const startDt = new Date(e.startDate);
+    return {
+      id: e.id,
+      title: e.title || "Untitled",
+      date: startDt.toISOString().slice(0, 10),
+      start: formatTime(startDt),
+      end: formatTime(new Date(e.endDate)),
+      location: e.location || "",
+      attendees: (e.attendees || []).map((a) => a.name || a.email || "Unknown"),
+      notes: e.notes || ""
+    };
+  });
+  mapped.sort(
+    (a, b) => a.date === b.date ? a.start.localeCompare(b.start) : a.date.localeCompare(b.date)
+  );
+  return {
+    ok: true,
+    from: tomorrow.toISOString().slice(0, 10),
+    days_ahead: daysAhead,
+    event_count: mapped.length,
+    events: mapped
+  };
+}
+function getUserCalendarIds(calendars) {
+  const SKIP_SOURCES = ["birthdays", "other"];
+  const SKIP_TYPES = ["birthdays", "other"];
+  return calendars.filter((c) => {
+    const sourceType = (c.source?.type || "").toLowerCase();
+    const calType = (c.type || "").toLowerCase();
+    if (SKIP_SOURCES.includes(sourceType)) return false;
+    if (SKIP_TYPES.includes(calType)) return false;
+    return true;
+  }).map((c) => c.id);
+}
+function filterHolidays(events) {
+  const HOLIDAY_PATTERNS = [
+    /holiday/i,
+    /observance/i,
+    /eve\b.*\btentative\b/i,
+    /\btentative\b/i
+  ];
+  return events.filter((e) => {
+    const isAllDay = e.allDay === true;
+    const notes = (e.notes || "").toLowerCase();
+    if (isAllDay && HOLIDAY_PATTERNS.some((p) => p.test(notes))) return false;
+    if (isAllDay && HOLIDAY_PATTERNS.some((p) => p.test(e.title || ""))) return false;
+    return true;
+  });
+}
+function formatTime(date) {
+  return date.toLocaleTimeString("en-US", {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  });
+}
+
+// src/device-bridge/collectors/contacts.ts
+var ExpoContacts = __toESM(require("expo-contacts"));
+var import_async_storage = __toESM(require("@react-native-async-storage/async-storage"));
+var HASH_STORE_KEY = "device-bridge.contacts.hashes.v1";
+async function requestPermission2() {
+  const { status } = await ExpoContacts.requestPermissionsAsync();
+  return status === "granted";
+}
+async function hasPermission2() {
+  const { status } = await ExpoContacts.getPermissionsAsync();
+  return status === "granted";
+}
+var lastContactsStats = null;
+async function collectAll() {
+  const result = await ExpoContacts.getContactsAsync({
+    fields: [
+      ExpoContacts.Fields.Name,
+      ExpoContacts.Fields.PhoneNumbers,
+      ExpoContacts.Fields.Emails,
+      ExpoContacts.Fields.Birthday
+    ],
+    sort: ExpoContacts.SortTypes.LastName
+  });
+  const raw = Array.isArray(result?.data) ? result.data : [];
+  const contacts = [];
+  const currentHashes = {};
+  for (let i = 0; i < raw.length; i++) {
+    const c = raw[i];
+    const id = c.id || `c${i}`;
+    const mapped = {
+      id,
+      name: c.name || `${c.firstName || ""} ${c.lastName || ""}`.trim() || "Unknown",
+      relationship: "",
+      // dropped — was the iOS Unauthorized-Keys trigger
+      phone: c.phoneNumbers?.[0]?.number || null,
+      email: c.emails?.[0]?.email || null,
+      birthday: formatBirthday(c.birthday),
+      notes: ""
+      // dropped — Notes is restricted on iOS 16+
+    };
+    contacts.push(mapped);
+    currentHashes[id] = hashContact(mapped);
+  }
+  let stored = {};
+  try {
+    const blob = await import_async_storage.default.getItem(HASH_STORE_KEY);
+    if (blob) stored = JSON.parse(blob);
+  } catch {
+  }
+  const fullSync = Object.keys(stored).length === 0;
+  let added = 0;
+  let updated = 0;
+  let unchanged = 0;
+  for (const id of Object.keys(currentHashes)) {
+    const prev = stored[id];
+    if (prev === void 0) added++;
+    else if (prev !== currentHashes[id]) updated++;
+    else unchanged++;
+  }
+  let removed = 0;
+  for (const id of Object.keys(stored)) {
+    if (currentHashes[id] === void 0) removed++;
+  }
+  lastContactsStats = {
+    total: contacts.length,
+    added,
+    updated,
+    removed,
+    unchanged,
+    full_sync: fullSync
+  };
+  if (!fullSync && added === 0 && updated === 0 && removed === 0) {
+    return null;
+  }
+  try {
+    await import_async_storage.default.setItem(HASH_STORE_KEY, JSON.stringify(currentHashes));
+  } catch {
+  }
+  return contacts;
+}
+function fnv1a(str) {
+  let h = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+function hashContact(c) {
+  const parts = [
+    c.id,
+    (c.name || "").trim(),
+    c.phone || "\0",
+    (c.email || "\0").toLowerCase(),
+    c.birthday || "\0"
+  ];
+  return fnv1a(parts.join(""));
+}
+function formatBirthday(birthday) {
+  if (!birthday) return null;
+  const { year, month, day } = birthday;
+  if (month === void 0 || day === void 0) return null;
+  const m = String(month + 1).padStart(2, "0");
+  const d = String(day).padStart(2, "0");
+  if (!year) return `--${m}-${d}`;
+  return `${year}-${m}-${d}`;
+}
+
+// src/device-bridge/collectors/location.ts
+var ExpoLocation2 = __toESM(require("expo-location"));
+
+// src/maps/index.ts
+var import_react_native = require("react-native");
+var import_expo_modules_core = require("expo-modules-core");
+var ExpoLocation = __toESM(require("expo-location"));
+
+// src/maps/normalize.ts
+var text = (v) => typeof v === "string" && v.trim() !== "" ? v : null;
+function toMapsAddress(raw) {
+  const r = raw ?? {};
+  return {
+    name: text(r.name),
+    street: text(r.street),
+    streetNumber: text(r.streetNumber),
+    district: text(r.district),
+    city: text(r.city),
+    region: text(r.region),
+    postalCode: text(r.postalCode),
+    country: text(r.country),
+    isoCountryCode: text(r.isoCountryCode)
+  };
+}
+
+// src/maps/index.ts
+var native = (0, import_expo_modules_core.requireOptionalNativeModule)("AdaMaps");
+async function reverseGeocode(at) {
+  const [first] = await ExpoLocation.reverseGeocodeAsync({ latitude: at.latitude, longitude: at.longitude });
+  return first ? toMapsAddress(first) : null;
+}
+
+// src/device-bridge/collectors/location.ts
+async function requestPermission3() {
+  const { status: fg } = await ExpoLocation2.requestForegroundPermissionsAsync();
+  if (fg !== "granted") return false;
+  try {
+    await ExpoLocation2.requestBackgroundPermissionsAsync();
+  } catch {
+  }
+  return fg === "granted";
+}
+async function hasPermission3() {
+  const { status } = await ExpoLocation2.getForegroundPermissionsAsync();
+  return status === "granted";
+}
+async function collectCurrent() {
+  const location = await ExpoLocation2.getCurrentPositionAsync({
+    accuracy: ExpoLocation2.Accuracy.Balanced
+  });
+  let place = "Current Location";
+  let address = `${location.coords.latitude.toFixed(4)}, ${location.coords.longitude.toFixed(4)}`;
+  let locationType = "unknown";
+  try {
+    const geocoded = await reverseGeocode({
+      latitude: location.coords.latitude,
+      longitude: location.coords.longitude
+    });
+    if (geocoded) {
+      place = geocoded.name || geocoded.street || place;
+      address = [
+        geocoded.streetNumber,
+        geocoded.street,
+        geocoded.city,
+        geocoded.region
+      ].filter(Boolean).join(", ") || address;
+      locationType = classifyLocation(geocoded);
+    }
+  } catch {
+  }
+  return {
+    ok: true,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    location: {
+      place,
+      address,
+      lat: location.coords.latitude,
+      lng: location.coords.longitude,
+      type: locationType
+    }
+  };
+}
+var WATCH_TIER = {
+  navigation: ExpoLocation2.Accuracy.BestForNavigation,
+  high: ExpoLocation2.Accuracy.High,
+  balanced: ExpoLocation2.Accuracy.Balanced,
+  low: ExpoLocation2.Accuracy.Low
+};
+function classifyLocation(geocoded) {
+  const name = (geocoded.name || "").toLowerCase();
+  const street = (geocoded.street || "").toLowerCase();
+  if (name.includes("home") || name.includes("residence")) return "home";
+  if (name.includes("office") || name.includes("workplace") || name.includes("tech park")) return "work";
+  if (name.includes("school") || name.includes("elementary") || name.includes("university")) return "school";
+  if (name.includes("gym") || name.includes("fitness")) return "fitness";
+  if (name.includes("hospital") || name.includes("clinic") || name.includes("dental")) return "medical";
+  return "other";
+}
+
+// src/device-bridge/collectors/battery.ts
+var ExpoBattery = __toESM(require("expo-battery"));
+async function collectBattery() {
+  const level = await ExpoBattery.getBatteryLevelAsync();
+  const state = await ExpoBattery.getBatteryStateAsync();
+  const lowPower = await ExpoBattery.isLowPowerModeEnabledAsync();
+  return {
+    ok: true,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    battery: {
+      level: Math.round(level * 100),
+      // expo-battery returns 0-1
+      state: mapBatteryState(state),
+      low_power_mode: lowPower
+    }
+  };
+}
+function subscribeToBattery(callback) {
+  let lastLevel = null;
+  const levelSub = ExpoBattery.addBatteryLevelListener(({ batteryLevel }) => {
+    const pct = Math.round(batteryLevel * 100);
+    if (lastLevel === null || Math.abs(pct - lastLevel) >= 5) {
+      lastLevel = pct;
+      callback();
+    }
+  });
+  const stateSub = ExpoBattery.addBatteryStateListener(() => {
+    callback();
+  });
+  return () => {
+    levelSub?.remove?.();
+    stateSub?.remove?.();
+  };
+}
+function mapBatteryState(state) {
+  switch (state) {
+    case ExpoBattery.BatteryState.CHARGING:
+      return "charging";
+    case ExpoBattery.BatteryState.FULL:
+      return "full";
+    case ExpoBattery.BatteryState.UNPLUGGED:
+    default:
+      return "unplugged";
+  }
+}
+
+// src/device-bridge/collectors/connectivity.ts
+var ExpoNetwork = __toESM(require("expo-network"));
+async function collectConnectivity() {
+  const networkState = await ExpoNetwork.getNetworkStateAsync();
+  let type = "none";
+  let wifiName;
+  let cellularType;
+  if (networkState.type === ExpoNetwork.NetworkStateType.WIFI) {
+    type = "wifi";
+    try {
+      wifiName = await getWifiName();
+    } catch {
+      wifiName = void 0;
+    }
+  } else if (networkState.type === ExpoNetwork.NetworkStateType.CELLULAR) {
+    type = "cellular";
+    cellularType = getCellularGeneration();
+  }
+  return {
+    ok: true,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    connectivity: {
+      type,
+      is_connected: networkState.isConnected ?? false,
+      ...wifiName && { wifi_name: wifiName },
+      ...cellularType && { cellular_type: cellularType }
+    }
+  };
+}
+async function getWifiName() {
+  return void 0;
+}
+function getCellularGeneration() {
+  return "LTE";
+}
+
+// src/device-bridge/collectors/notifications.ts
+var ExpoNotifications = __toESM(require("expo-notifications"));
+async function requestPermission4() {
+  const { status } = await ExpoNotifications.requestPermissionsAsync();
+  return status === "granted";
+}
+async function hasPermission4() {
+  const { status } = await ExpoNotifications.getPermissionsAsync();
+  return status === "granted";
+}
+async function collectNotifications() {
+  const presented = await ExpoNotifications.getPresentedNotificationsAsync();
+  const notifications = presented.map((n, i) => ({
+    id: n.request.identifier || `n${i}`,
+    app: n.request.content.data?.app || "A-Team",
+    title: n.request.content.title || "",
+    body: n.request.content.body || "",
+    timestamp: n.date ? new Date(n.date).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+    sender: n.request.content.data?.sender || null,
+    priority: mapPriority(n.request.content.data?.priority),
+    read: false
+    // Presented notifications are unread by definition
+  }));
+  const unread = notifications.filter((n) => !n.read).length;
+  return {
+    ok: true,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    total: notifications.length,
+    unread,
+    notifications
+  };
+}
+function mapPriority(p) {
+  if (p === "high" || p === "max") return "high";
+  if (p === "low" || p === "min") return "low";
+  return "medium";
+}
+
+// src/device-bridge/collectors/health.ts
+var import_react_native2 = require("react-native");
+var _HK = null;
+var _hkProbed = false;
+function getHK() {
+  if (import_react_native2.Platform.OS !== "ios") return null;
+  if (_hkProbed) return _HK;
+  _hkProbed = true;
+  try {
+    const mod = require("@kingstinct/react-native-healthkit");
+    if (mod && typeof mod.requestAuthorization === "function") {
+      _HK = mod;
+    } else {
+      console.warn("[health] @kingstinct/react-native-healthkit native bridge unavailable \u2014 HealthKit disabled (Expo Go?)");
+    }
+  } catch (e) {
+    console.warn("[health] @kingstinct/react-native-healthkit require failed:", e);
+  }
+  return _HK;
+}
+var lastHealthInitError = null;
+var READ_TYPES = [
+  "HKQuantityTypeIdentifierStepCount",
+  "HKQuantityTypeIdentifierFlightsClimbed",
+  "HKQuantityTypeIdentifierActiveEnergyBurned",
+  "HKQuantityTypeIdentifierDistanceWalkingRunning",
+  // Added for mood signals — all read-only, covered by the same auth sheet.
+  "HKQuantityTypeIdentifierRestingHeartRate",
+  "HKQuantityTypeIdentifierAppleExerciseTime",
+  "HKCategoryTypeIdentifierSleepAnalysis"
+];
+var _initPromise = null;
+async function ensureInit() {
+  const HK = getHK();
+  if (!HK) {
+    lastHealthInitError = "@kingstinct/react-native-healthkit native module not loaded";
+    return false;
+  }
+  if (_initPromise) return _initPromise;
+  _initPromise = (async () => {
+    try {
+      await HK.requestAuthorization({ toRead: READ_TYPES, toWrite: [] });
+      lastHealthInitError = null;
+      return true;
+    } catch (e) {
+      lastHealthInitError = `requestAuthorization threw: ${e?.message || String(e)}`;
+      console.warn("[health]", lastHealthInitError);
+      _initPromise = null;
+      return false;
+    }
+  })();
+  return _initPromise;
+}
+async function hasPermission5() {
+  return ensureInit();
+}
+async function requestPermission5() {
+  return ensureInit();
+}
+function startOfDay(d) {
+  const out = new Date(d);
+  out.setHours(0, 0, 0, 0);
+  return out;
+}
+function dateKey(d) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+async function readDailySum(identifier, unit, start, end) {
+  const HK = getHK();
+  if (!HK?.queryStatisticsForQuantity) return 0;
+  try {
+    const result = await HK.queryStatisticsForQuantity(
+      identifier,
+      ["cumulativeSum"],
+      {
+        unit,
+        filter: { date: { startDate: start, endDate: end } }
+      }
+    );
+    const q = result?.sumQuantity?.quantity;
+    return typeof q === "number" ? q : 0;
+  } catch {
+    return 0;
+  }
+}
+async function readDay(date) {
+  const start = startOfDay(date);
+  const end = new Date(start);
+  end.setDate(end.getDate() + 1);
+  const [steps, floors, energy, distance] = await Promise.all([
+    readDailySum("HKQuantityTypeIdentifierStepCount", "count", start, end),
+    readDailySum("HKQuantityTypeIdentifierFlightsClimbed", "count", start, end),
+    readDailySum("HKQuantityTypeIdentifierActiveEnergyBurned", "kcal", start, end),
+    // Ask for kilometers directly so we don't have to convert from meters.
+    readDailySum("HKQuantityTypeIdentifierDistanceWalkingRunning", "km", start, end)
+  ]);
+  return {
+    date: dateKey(start),
+    available: true,
+    steps: Math.round(steps),
+    floors: Math.round(floors),
+    active_energy_kcal: Math.round(energy),
+    distance_km: Math.round(distance * 100) / 100
+  };
+}
+function unavailableDay(date) {
+  return {
+    date: dateKey(date),
+    available: false,
+    steps: null,
+    floors: null,
+    active_energy_kcal: null,
+    distance_km: null
+  };
+}
+async function collectToday2() {
+  const ok = await ensureInit();
+  if (!ok) {
+    return unavailableDay(/* @__PURE__ */ new Date());
+  }
+  return readDay(/* @__PURE__ */ new Date());
+}
+async function collectHistory(days) {
+  const n = Math.max(1, Math.min(30, Math.floor(days)));
+  const ok = await ensureInit();
+  if (!ok) return [];
+  const today = startOfDay(/* @__PURE__ */ new Date());
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const d = new Date(today);
+    d.setDate(d.getDate() - i);
+    out.push(await readDay(d));
+  }
+  return out;
+}
+
+// src/device-bridge/collectors/appEngagement.ts
+var import_react_native3 = require("react-native");
+var import_async_storage2 = __toESM(require("@react-native-async-storage/async-storage"));
+
+// src/device-bridge/collectors/camera.ts
+var import_expo_camera = require("expo-camera");
+
+// src/device-bridge/capabilities.ts
+function calendarCapability() {
+  return {
+    id: "calendar",
+    name: "Calendar",
+    description: "Syncs your calendar events so your assistant knows your schedule.",
+    reason: "Needed for scheduling, meeting prep, commute alerts, and daily briefings.",
+    icon: "calendar",
+    requiresPermission: true,
+    permissionState: "not_requested",
+    requestPermission,
+    checkPermission: hasPermission,
+    collect: async () => {
+      const [today, upcoming] = await Promise.all([
+        collectToday(),
+        collectUpcoming(7)
+      ]);
+      return { today, upcoming };
+    },
+    defaultInterval: 6e4
+    // 1 min
+  };
+}
+function contactsCapability() {
+  return {
+    id: "contacts",
+    name: "Contacts",
+    description: "Syncs your contacts so your assistant can find people and relationships.",
+    reason: "Needed for messaging, birthday reminders, and relationship insights.",
+    icon: "people",
+    requiresPermission: true,
+    permissionState: "not_requested",
+    requestPermission: requestPermission2,
+    checkPermission: hasPermission2,
+    collect: async () => {
+      const list = await collectAll();
+      if (list === null) return null;
+      return { contacts: list };
+    },
+    defaultInterval: 3e5
+    // 5 min
+  };
+}
+function locationCapability() {
+  return {
+    id: "location",
+    name: "Location",
+    description: "Syncs your location for weather, commute, and context-aware assistance.",
+    reason: "Needed for commute estimates, weather at your location, and situation detection.",
+    icon: "location",
+    requiresPermission: true,
+    permissionState: "not_requested",
+    requestPermission: requestPermission3,
+    checkPermission: hasPermission3,
+    collect: collectCurrent,
+    defaultInterval: 3e4
+    // 30 sec
+  };
+}
+function batteryCapability() {
+  return {
+    id: "battery",
+    name: "Battery",
+    description: "Syncs battery level and charging status.",
+    reason: "Helps your assistant adjust behavior when battery is low.",
+    icon: "battery",
+    requiresPermission: false,
+    permissionState: "not_needed",
+    requestPermission: async () => true,
+    checkPermission: async () => true,
+    collect: collectBattery,
+    defaultInterval: 6e4,
+    // 1 min
+    subscribe: subscribeToBattery
+  };
+}
+function connectivityCapability() {
+  return {
+    id: "connectivity",
+    name: "Connectivity",
+    description: "Syncs WiFi/cellular status.",
+    reason: "Helps your assistant know if you have internet access.",
+    icon: "wifi",
+    requiresPermission: false,
+    permissionState: "not_needed",
+    requestPermission: async () => true,
+    checkPermission: async () => true,
+    collect: collectConnectivity,
+    defaultInterval: 3e4
+    // 30 sec
+  };
+}
+function healthCapability() {
+  return {
+    id: "health",
+    name: "Health",
+    description: "Reads daily steps, floors, calories, and distance from Apple Health.",
+    reason: "Powers the personal health coach and pairs activity data with nutrition tracking.",
+    icon: "heart",
+    requiresPermission: true,
+    permissionState: "not_requested",
+    requestPermission: requestPermission5,
+    checkPermission: hasPermission5,
+    collect: async () => {
+      const days = await collectHistory(30);
+      const today = days[0] || await collectToday2();
+      return { today, days };
+    },
+    defaultInterval: 3e5
+    // 5 min
+  };
+}
+function notificationsCapability() {
+  return {
+    id: "notifications",
+    name: "Notifications",
+    description: "Syncs your notifications for triage and smart grouping.",
+    reason: "Needed for notification triage, priority filtering, and Do Not Disturb.",
+    icon: "notifications",
+    requiresPermission: true,
+    permissionState: "not_requested",
+    requestPermission: requestPermission4,
+    checkPermission: hasPermission4,
+    collect: collectNotifications,
+    defaultInterval: 15e3
+    // 15 sec
+  };
+}
+
+// src/device-bridge/background.ts
+var CAPABILITY_FACTORIES = {
+  calendar: calendarCapability,
+  contacts: contactsCapability,
+  location: locationCapability,
+  battery: batteryCapability,
+  connectivity: connectivityCapability,
+  notifications: notificationsCapability,
+  health: healthCapability
+};
+async function syncDomains(config2, domains) {
+  const relay = new RelayClient({
+    relayUrl: config2.relayUrl,
+    deviceId: config2.deviceId,
+    tenant: config2.tenant,
+    actorId: config2.actorId,
+    apiKey: config2.apiKey,
+    timeout: 15e3
+    // longer than foreground — background tasks are budget-limited but not latency-sensitive
+  });
+  const results = await Promise.allSettled(
+    domains.map((d) => collectAndPush(relay, d))
+  );
+  return results.some((r) => r.status === "fulfilled" && r.value);
+}
+async function collectAndPush(relay, domain) {
+  const factory = CAPABILITY_FACTORIES[domain];
+  if (!factory) {
+    console.warn(`[DeviceBridge] Unknown sync domain: ${domain}`);
+    return false;
+  }
+  const cap = factory();
+  if (cap.requiresPermission) {
+    const granted = await cap.checkPermission();
+    if (!granted) return false;
+  }
+  const data = await cap.collect();
+  const result = await relay.pushDomain(domain, data);
+  return result.ok;
+}
+
+// src/device-bridge/deviceId.ts
+var DEVICE_ID_KEY = "ateam.deviceId";
+function readDeviceId(storage) {
+  return storage.getItem(DEVICE_ID_KEY);
+}
+
+// src/capabilities/config.ts
+var config = null;
+function getDeviceSyncConfig() {
+  return config;
+}
+
+// src/capabilities/choices.ts
+var import_async_storage3 = __toESM(require("@react-native-async-storage/async-storage"));
+var STORAGE_KEY = "ateam.capabilities";
+var SETUP_KEY = "ateam.capabilities.setup";
+var DEFAULT_ENABLED = {
+  calendar: true,
+  contacts: true,
+  location: true,
+  battery: true,
+  connectivity: true,
+  health: true,
+  mood: true,
+  // Opt-IN: the camera is more invasive than the sync collectors and should not
+  // prompt every user for camera access on first launch. It lights up only when
+  // the user turns it on (which then requests the OS permission), so a solution
+  // that wants a camera preview asks the user to enable it.
+  camera: false
+};
+var HIDDEN_FROM_UI = /* @__PURE__ */ new Set(["notifications"]);
+async function loadChoices() {
+  const setupDone = await import_async_storage3.default.getItem(SETUP_KEY);
+  const saved = await import_async_storage3.default.getItem(STORAGE_KEY);
+  return { setupDone: setupDone === "true", prefs: saved ? JSON.parse(saved) : {} };
+}
+function isEnabled(id, prefs) {
+  return prefs[id] ?? DEFAULT_ENABLED[id] ?? true;
+}
+async function sharedDomains(domains) {
+  let choices;
+  try {
+    choices = await loadChoices();
+  } catch {
+    return [];
+  }
+  if (!choices.setupDone) return [];
+  return domains.filter((d) => !HIDDEN_FROM_UI.has(d) && isEnabled(d, choices.prefs));
+}
+
+// src/push/silentSync.ts
+var import_core = require("@ateam-ai-mobile/core");
+
+// src/push/messaging.ts
+var probed = false;
+var messaging = null;
+function getMessaging() {
+  if (probed) return messaging;
+  probed = true;
+  try {
+    const candidate = require("@react-native-firebase/messaging").default;
+    candidate();
+    messaging = candidate;
+  } catch {
+    console.warn("[adas/push] @react-native-firebase/messaging native module unavailable \u2014 push disabled (Expo Go?)");
+  }
+  return messaging;
+}
+
+// src/push/silentSync.ts
+function registerSilentPushSync(opts) {
+  const messaging2 = getMessaging();
+  if (!messaging2) return;
+  messaging2().setBackgroundMessageHandler((msg) => handleSilentPush(msg, opts));
+}
+async function handleSilentPush(msg, opts) {
+  const data = msg?.data || {};
+  if (data.action !== "sync") return;
+  let requested = data.domains;
+  try {
+    if (typeof requested === "string") requested = JSON.parse(requested);
+  } catch (err) {
+    console.warn("[adas/push] silent sync: bad domains:", err);
+    return;
+  }
+  if (!Array.isArray(requested)) return;
+  const domains = await sharedDomains(requested.filter((d) => typeof d === "string"));
+  if (domains.length === 0) return;
+  const deviceSync = getDeviceSyncConfig();
+  if (!deviceSync) {
+    console.warn("[adas/push] silent sync skipped: device sync is not configured");
+    return;
+  }
+  const deviceId = await readDeviceId(deviceSync.secureStorage);
+  if (!deviceId) return;
+  const jwt = await opts.loadToken();
+  if (!jwt) return;
+  const tenant = (0, import_core.tenantFromToken)(jwt);
+  const actorId = (0, import_core.userFromJwt)(jwt)?.actorId;
+  if (!tenant || !actorId) return;
+  console.log(`[adas/push] silent sync: ${domains.join(", ")}`);
+  try {
+    await syncDomains(
+      { relayUrl: deviceSync.relayUrl(), deviceId, tenant, actorId, apiKey: deviceSync.relayKey },
+      domains
+    );
+  } catch (err) {
+    console.warn("[adas/push] silent sync failed:", err);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerSilentPushSync
+});
+//# sourceMappingURL=silentSync.js.map