@ateam-ai-mobile/expo 0.1.19 → 0.1.21

package/src/capabilities/store.ts

@@ -1,10 +1,16 @@
 import { create } from 'zustand';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import { getTenant, getUser, onAppForeground } from '@ateam-ai-mobile/core';
+import { setPicturesToAiConsentProvider } from '@ateam-ai-mobile/plugin-runtime';
 import { DeviceBridge, capabilities as capFactories } from '../device-bridge';
 import type { Capability, PermissionState } from '../device-bridge/types';
 import { getOrCreateDeviceId } from '../device-bridge/deviceId';
 import { getDeviceSyncConfig } from './config';
+import { STORAGE_KEY, SETUP_KEY, HIDDEN_FROM_UI, loadChoices, isEnabled } from './choices';
+import { picturesToAiAllowed } from './picturesToAi';
+
+// The key the app used for this switch before the SDK owned it (branch pictures-to-ai-switch).
+const PICTURES_TO_AI_KEY = 'ateam.capabilities.picturesToAi';
 
 /**
  * Device permissions — the one source of truth for what this device shares.
@@ -45,6 +51,9 @@ export interface CapabilityState {
 
 interface CapabilitiesState {
   capabilities: CapabilityState[];
+  /** The "Camera pictures to AI" switch under Camera: the person's half of the
+   *  consent props.aiLive needs. Off until they turn it on (default no). */
+  picturesToAi: boolean;
   hasCompletedSetup: boolean;
   isLoading: boolean;
   bridgeRunning: boolean;
@@ -53,6 +62,8 @@ interface CapabilitiesState {
   initialize: () => Promise<void>;
   /** Toggle a capability on/off, persist, and update bridge if running */
   toggleCapability: (id: string, enabled: boolean) => Promise<void>;
+  /** Set and persist "Camera pictures to AI". The host asks first (PICTURES_TO_AI_ASK). */
+  setPicturesToAi: (on: boolean) => Promise<void>;
   /** Update OS permission state for a capability */
   setOsPermission: (id: string, state: PermissionState) => void;
   /** Mark initial setup as complete */
@@ -70,31 +81,6 @@ interface CapabilitiesState {
   syncNow: () => Promise<{ ok: boolean; error?: string }>;
 }
 
-// The keys the app used before the SDK owned them — existing installs keep their choices.
-const STORAGE_KEY = 'ateam.capabilities';
-const SETUP_KEY = 'ateam.capabilities.setup';
-
-// Default enabled state per capability (first-time only)
-const DEFAULT_ENABLED: Record<string, boolean> = {
-  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,
-};
-
-// Capabilities hidden from the user-facing list. The host's push-notifications
-// toggle is the single user control; the notifications collector is internal
-// plumbing and shouldn't surface as a separate switch.
-const HIDDEN_FROM_UI = new Set(['notifications']);
-
 // Module-level bridge singleton — NOT in Zustand (it's a mutable object with timers)
 let bridge: DeviceBridge | null = null;
 
@@ -242,6 +228,7 @@ export const useCapabilitiesStore = create<CapabilitiesState>((set, get) => {
 
   return {
     capabilities: [],
+    picturesToAi: false,
     hasCompletedSetup: false,
     isLoading: true,
     bridgeRunning: false,
@@ -253,6 +240,10 @@ export const useCapabilitiesStore = create<CapabilitiesState>((set, get) => {
         // (e.g. notifications → the host's notification settings).
         builtInCapabilities = capFactories.allBuiltIn().filter(c => !HIDDEN_FROM_UI.has(c.id));
 
+        // Saved user choices (override the defaults for returning users)
+        const { setupDone, prefs } = await loadChoices();
+        const picturesToAi = (await AsyncStorage.getItem(PICTURES_TO_AI_KEY)) === 'true';
+
         // Map to UI state (no functions, just data + enabled flag)
         const capStates: CapabilityState[] = builtInCapabilities.map(cap => ({
           id: cap.id,
@@ -261,25 +252,18 @@ export const useCapabilitiesStore = create<CapabilitiesState>((set, get) => {
           reason: cap.reason,
           icon: cap.icon || cap.id,
           requiresPermission: cap.requiresPermission,
-          enabled: DEFAULT_ENABLED[cap.id] ?? true,
+          enabled: isEnabled(cap.id, prefs),
           osPermission: cap.permissionState,
         }));
 
-        // Load saved user preferences (overrides defaults for returning users)
-        const setupDone = await AsyncStorage.getItem(SETUP_KEY);
-        const saved = await AsyncStorage.getItem(STORAGE_KEY);
-        const prefs: Record<string, boolean> = saved ? JSON.parse(saved) : {};
-
         set({
-          capabilities: capStates.map(cap => ({
-            ...cap,
-            enabled: prefs[cap.id] ?? cap.enabled,
-          })),
-          hasCompletedSetup: setupDone === 'true',
+          capabilities: capStates,
+          picturesToAi,
+          hasCompletedSetup: setupDone,
           isLoading: false,
         });
 
-        console.log(`[Capabilities] Initialized ${capStates.length} capabilities from device-bridge (setup ${setupDone === 'true' ? 'done' : 'pending'})`);
+        console.log(`[Capabilities] Initialized ${capStates.length} capabilities from device-bridge (setup ${setupDone ? 'done' : 'pending'})`);
       } catch (err) {
         console.error('[Capabilities] Initialize failed:', err);
         set({ isLoading: false });
@@ -301,6 +285,13 @@ export const useCapabilitiesStore = create<CapabilitiesState>((set, get) => {
       }
       await AsyncStorage.setItem(STORAGE_KEY, JSON.stringify(prefs));
 
+      // Turning the camera off also clears "Camera pictures to AI", so turning the
+      // camera back on later never silently re-opens that door: the person is asked
+      // again. (While the camera is off the consent already reads as no.)
+      if (id === 'camera' && !enabled && get().picturesToAi) {
+        await get().setPicturesToAi(false);
+      }
+
       // If bridge is running, dynamically update
       if (bridge && get().bridgeRunning) {
         if (enabled) {
@@ -324,6 +315,11 @@ export const useCapabilitiesStore = create<CapabilitiesState>((set, get) => {
       }
     },
 
+    setPicturesToAi: async (on: boolean) => {
+      set({ picturesToAi: on });
+      await AsyncStorage.setItem(PICTURES_TO_AI_KEY, on ? 'true' : 'false');
+    },
+
     setOsPermission: (id: string, permState: PermissionState) => {
       set(s => ({
         capabilities: s.capabilities.map(cap =>
@@ -385,3 +381,8 @@ export const useCapabilitiesStore = create<CapabilitiesState>((set, get) => {
     },
   };
 });
+
+// The person's half of "camera pictures to AI", for plugin-runtime's mayPicturesLeavePhone():
+// read from this store at CALL time (derive, never store). A host that never loads this store
+// has no consent provider, and the answer is no.
+setPicturesToAiConsentProvider(() => picturesToAiAllowed(useCapabilitiesStore.getState()));

package/src/index.ts

@@ -82,6 +82,9 @@ export function setupExpoProviders(opts?: {
 // The host passes this to setDeviceStateProvider(); per-plugin gating by
 // manifest.stateDomains happens in the SDK.
 export { createDeviceState, IMPLEMENTED_DOMAINS } from './device-state';
+
+// AI live (props.aiLive) lives on its own subpath, '@ateam-ai-mobile/expo/ai-live', like vision:
+// it uses the native vision module, which this entry must not import.
 export type { DeviceStateCollectors } from './device-state';
 // The mounted half of the Visual engine. The app renders this ONCE; it draws
 // nothing until a visual session is open. Required for deviceState.visual to

package/src/push/index.ts

@@ -0,0 +1,18 @@
+/**
+ * Push notifications on this device (FCM via @react-native-firebase/messaging,
+ * an optional peer — without it push is off and nothing breaks).
+ *
+ * For a host app embedding A-Team:
+ * - usePushNotifications({ enabled, onOpenApp }) — or startPushNotifications()
+ *   outside React — while signed in: permission, token → Core, incoming pushes;
+ * - pushRegistration — the current token (getToken) and unregister() for your
+ *   sign-out teardown, run while the session token still exists;
+ * - <PushBanner/> from @ateam-ai-mobile/ui — the drop-in in-app banner, or your
+ *   own UI on usePushBannerStore + routePushTap.
+ * The background silent sync is its own subpath, @ateam-ai-mobile/expo/silent-push.
+ *
+ * A SUBPATH because it statically pulls expo-notifications and expo-device.
+ */
+export { usePushNotifications, startPushNotifications } from './usePushNotifications';
+export type { UsePushNotificationsOptions, PushNotificationsOptions } from './usePushNotifications';
+export { pushRegistration } from './registration';

package/src/push/messaging.ts

@@ -0,0 +1,49 @@
+/**
+ * Firebase Cloud Messaging, if this build has it.
+ *
+ * @react-native-firebase/messaging is an optional peer: in Expo Go (or a host
+ * without Firebase) the JS module may exist but its native module does not, so
+ * we probe by calling messaging() once. No native module → null, and push is
+ * off (the hook and the background sync become no-ops). Probed on first use,
+ * not at import.
+ */
+
+/** The slice of the RNFB messaging API the SDK uses. */
+export interface RemoteMessage {
+  notification?: { title?: string; body?: string };
+  data?: Record<string, unknown>;
+}
+
+export interface MessagingInstance {
+  requestPermission(): Promise<number>;
+  isDeviceRegisteredForRemoteMessages: boolean;
+  registerDeviceForRemoteMessages(): Promise<void>;
+  getAPNSToken(): Promise<string | null>;
+  getToken(): Promise<string>;
+  onTokenRefresh(cb: (token: string) => void): () => void;
+  onMessage(cb: (msg: RemoteMessage) => void | Promise<void>): () => void;
+  onNotificationOpenedApp(cb: (msg: RemoteMessage) => void): () => void;
+  getInitialNotification(): Promise<RemoteMessage | null>;
+  setBackgroundMessageHandler(cb: (msg: RemoteMessage) => Promise<void>): void;
+}
+
+export interface Messaging {
+  (): MessagingInstance;
+  AuthorizationStatus: { AUTHORIZED: number; PROVISIONAL: number };
+}
+
+let probed = false;
+let messaging: Messaging | null = null;
+
+export function getMessaging(): Messaging | null {
+  if (probed) return messaging;
+  probed = true;
+  try {
+    const candidate = require('@react-native-firebase/messaging').default as Messaging;
+    candidate(); // throws "Native module RNFBAppModule not found" in Expo Go
+    messaging = candidate;
+  } catch {
+    console.warn('[adas/push] @react-native-firebase/messaging native module unavailable — push disabled (Expo Go?)');
+  }
+  return messaging;
+}

package/src/push/registration.ts

@@ -0,0 +1,31 @@
+/**
+ * This device's push registration with Core — the one owner of the current
+ * push token. The lifecycle (register, re-register on refresh, unregister on
+ * sign-out, the sign-out count) is core's createPushRegistration; this wires it
+ * to Core's notif-api with the platform. usePushNotifications feeds it tokens;
+ * the host's sign-out teardown calls pushRegistration.unregister() while the
+ * session token still exists. getToken() answers "is push registered on this
+ * device?".
+ */
+import { Platform } from 'react-native';
+import * as Notifications from 'expo-notifications';
+import { createPushRegistration, registerPushDevice, unregisterPushDevice, type PushRegistration } from '@ateam-ai-mobile/core';
+
+const lifecycle = createPushRegistration({
+  // Adapt to the lifecycle's void contract — the notif-api returns a body it doesn't need.
+  registerDevice: async (token) => { await registerPushDevice(token, Platform.OS === 'ios' ? 'ios' : 'android'); },
+  unregisterDevice: async (token) => { await unregisterPushDevice(token); },
+});
+
+export const pushRegistration: PushRegistration = {
+  ...lifecycle,
+  async unregister() {
+    await lifecycle.unregister();
+    // Notifications already in the list were for the user who is leaving, and
+    // a push carries no recipient: tapped later, one would act in the next
+    // user's chat. Best-effort, never blocks sign-out.
+    Promise.resolve().then(() => Notifications.dismissAllNotificationsAsync()).catch((e: any) =>
+      console.warn('[adas/push] clearing delivered notifications failed:', e?.message || e),
+    );
+  },
+};

package/src/push/silentSync.ts

@@ -0,0 +1,83 @@
+/**
+ * Silent-push device sync — the server wakes the phone to refresh device data.
+ *
+ * Call registerSilentPushSync({ loadToken }) once in your app's entry file,
+ * before the app component registers: Firebase wants its background handler
+ * set at the top level, outside React. It also needs device sync configured
+ * (bootstrapExpoAdas({ deviceSync }) or configureDeviceSync) — read when a push
+ * arrives, so the order of the two calls doesn't matter.
+ *
+ * Contract for a silent (data-only) push:
+ *   data: { action: "sync", domains: '["location","calendar"]' }  (JSON string array)
+ * Anything else is ignored here — visible pushes are usePushNotifications'.
+ *
+ * Syncs as the signed-in user and team from the SAVED session token (the app
+ * may be woken with no session restored) and under this install's device id;
+ * no token, no user, no team or no device id → nothing is sent. Only domains
+ * the user shares are synced (their saved choices), as the foreground bridge does.
+ *
+ * Moved from ateam-mobile's pushBackgroundHandler (2026-10-29). Changed on the
+ * way: it syncs only the domains the user turned on (it synced any domain the
+ * push named), and never without a user (it would sync as 'default').
+ */
+import { syncDomains } from '../device-bridge/background';
+import { readDeviceId } from '../device-bridge/deviceId';
+import { getDeviceSyncConfig } from '../capabilities/config';
+import { sharedDomains } from '../capabilities/choices';
+import { tenantFromToken, userFromJwt } from '@ateam-ai-mobile/core';
+import { getMessaging, type RemoteMessage } from './messaging';
+
+export interface SilentPushSyncOptions {
+  /** The saved session token — the same loader your auth session's persistence uses. */
+  loadToken: () => Promise<string | null>;
+}
+
+/** Register the background handler. No Firebase in this build → nothing to do. */
+export function registerSilentPushSync(opts: SilentPushSyncOptions): void {
+  const messaging = getMessaging();
+  if (!messaging) return;
+  messaging().setBackgroundMessageHandler((msg) => handleSilentPush(msg, opts));
+}
+
+async function handleSilentPush(msg: RemoteMessage, opts: SilentPushSyncOptions): Promise<void> {
+  const data = msg?.data || {};
+  if (data.action !== 'sync') return;
+
+  let requested: unknown = 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): d is string => 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;
+  }
+  // No id = nothing has synced from this install yet, so nothing to refresh.
+  const deviceId = await readDeviceId(deviceSync.secureStorage);
+  if (!deviceId) return;
+
+  // Identity AND team from the session token's own claims — never a stored
+  // copy, never a default. Signed out → no token → nothing to sync as.
+  const jwt = await opts.loadToken();
+  if (!jwt) return;
+  const tenant = tenantFromToken(jwt);
+  const actorId = 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);
+  }
+}

package/src/push/usePushNotifications.ts

@@ -0,0 +1,224 @@
+/**
+ * Push notifications on this device — the headless half.
+ *
+ * startPushNotifications() (or the usePushNotifications hook around it) asks
+ * for permission, gets this device's FCM token, registers it with Core through
+ * pushRegistration, re-registers when Firebase refreshes it, and handles what
+ * arrives:
+ *   - app open: a push with a visible notification goes to the in-app banner
+ *     (usePushBannerStore → <PushBanner/> from @ateam-ai-mobile/ui); data-only
+ *     pushes (silent syncs) are not shown;
+ *   - tapped in the background, or the tap that cold-started the app:
+ *     routePushTap (surface → prompt → the host's onOpenApp).
+ * Run it only while signed in — registering needs the session token. Sign-out
+ * unregisters through pushRegistration.unregister() in the host's teardown;
+ * from that moment this start adopts no token and routes no tap, even before
+ * the host's UI stops it. One push owner per app: a second start replaces the
+ * first.
+ *
+ * Payload from Core's notif-router → FCM:
+ *   notification: { title, body }
+ *   data: { jobId, skillSlug, messageId, surfaceId?, pluginId?, prompt? }
+ * In the background the OS shows the system banner itself.
+ *
+ * Moved from ateam-mobile's usePushNotifications (2026-10-29). Changed on the
+ * way: the expo-notifications foreground handler is set on start, not at import
+ * (an embedding app with its own passes foregroundHandler: false); a sign-out
+ * while the token was being fetched or registered no longer registers the
+ * signed-out phone or leaves a refresh listener behind; stopping clears the
+ * in-app banner; data-only pushes no longer pop an empty banner; the tap that
+ * opened the app is routed once, not again after every sign-in.
+ */
+import { useEffect, useRef } from 'react';
+import { Platform } from 'react-native';
+import * as Notifications from 'expo-notifications';
+import * as Device from 'expo-device';
+import { ada } from '@ateam-ai-mobile/core';
+import { routePushTap, usePushBannerStore } from '@ateam-ai-mobile/ui';
+import { getMessaging, type Messaging, type RemoteMessage } from './messaging';
+import { pushRegistration } from './registration';
+
+export interface PushNotificationsOptions {
+  /** A tapped push that names no surface or prompt — e.g. show your chat screen. */
+  onOpenApp?: () => void;
+  /**
+   * Set the expo-notifications handler so notifications also show while the app
+   * is open (banner, list, sound, badge) — this covers the local notifications
+   * plugins schedule. Default true; pass false if your app sets its own.
+   */
+  foregroundHandler?: boolean;
+}
+
+export interface UsePushNotificationsOptions extends PushNotificationsOptions {
+  /** Push runs while true — pass "signed in". */
+  enabled: boolean;
+}
+
+/** Push while `enabled`; stops (listeners off) when it turns false or on unmount. */
+export function usePushNotifications({ enabled, onOpenApp, foregroundHandler }: UsePushNotificationsOptions): void {
+  const onOpenAppRef = useRef(onOpenApp);
+  onOpenAppRef.current = onOpenApp;
+
+  useEffect(() => {
+    if (!enabled) return;
+    return startPushNotifications({ onOpenApp: () => onOpenAppRef.current?.(), foregroundHandler });
+  }, [enabled, foregroundHandler]);
+}
+
+// The tap that cold-started the app is routed once per launch — Firebase keeps
+// returning it, and a sign-out + sign-in starts push again — and never after a
+// sign-out: it was a push for the user signed in at launch.
+let initialTapHandled = false;
+const launchGeneration = pushRegistration.generation();
+let handlerSet = false;
+// The running start's stop — one push owner per app.
+let activeStop: (() => void) | null = null;
+
+/** Start push on this device; returns stop(). Call while signed in. No Firebase → no-op. */
+export function startPushNotifications(opts: PushNotificationsOptions = {}): () => void {
+  if (Platform.OS === 'web') return () => {};
+  // Before the Firebase check: it also shows the local notifications plugins
+  // schedule, which work without Firebase.
+  if (opts.foregroundHandler !== false) setForegroundHandler();
+  const messaging = getMessaging();
+  if (!messaging) return () => {};
+  activeStop?.();
+
+  // Live = not stopped AND no sign-out since this start began. The host's
+  // sign-out unregisters first and stops us only when its UI catches up; a
+  // token or tap arriving in between belongs to the user who left.
+  const startedIn = pushRegistration.generation();
+  let stopped = false;
+  const live = () => !stopped && pushRegistration.generation() === startedIn;
+  let unsubRefresh: (() => void) | null = null;
+  const routeTap = (msg: RemoteMessage | null) => {
+    if (live()) routePushTap(msg?.data, opts.onOpenApp);
+  };
+
+  (async () => {
+    const token = await registerForPush(messaging);
+    if (!token || !live()) return;
+    await pushRegistration.setToken(token);
+    // Signed out while registering: the teardown already unregistered this
+    // token — don't listen for refreshes as a signed-out user.
+    if (!live()) return;
+    unsubRefresh = messaging().onTokenRefresh((next) => {
+      if (live()) void pushRegistration.setToken(next);
+    });
+
+    const initial = await messaging().getInitialNotification();
+    if (initial && !initialTapHandled && live() && startedIn === launchGeneration) {
+      initialTapHandled = true;
+      routeTap(initial);
+    }
+  })().catch((err) => console.warn('[adas/push] start failed:', err?.message || err));
+
+  // App open: Firebase delivers but the OS shows nothing — use the in-app banner.
+  const unsubMessage = messaging().onMessage((msg) => {
+    const n = msg.notification;
+    if (!live()) return;
+    if (!n?.title && !n?.body) return; // data-only (e.g. a silent sync) — nothing to show
+    usePushBannerStore.getState().show({ title: n.title || 'Ada', body: n.body || undefined, data: msg.data || {} });
+  });
+
+  // App brought back from the background by a tap.
+  const unsubOpened = messaging().onNotificationOpenedApp(routeTap);
+
+  const stop = () => {
+    if (stopped) return;
+    stopped = true;
+    unsubRefresh?.();
+    unsubMessage();
+    unsubOpened();
+    // A banner shown for the user who is leaving must not stay tappable.
+    usePushBannerStore.getState().dismiss();
+    if (activeStop === stop) activeStop = null;
+  };
+  activeStop = stop;
+  return stop;
+}
+
+function setForegroundHandler(): void {
+  if (handlerSet) return;
+  handlerSet = true;
+  Notifications.setNotificationHandler({
+    handleNotification: async () => ({
+      shouldShowAlert: true,
+      shouldPlaySound: true,
+      shouldSetBadge: true,
+      shouldShowBanner: true,
+      shouldShowList: true,
+    }),
+  });
+}
+
+async function registerForPush(messaging: Messaging): Promise<string | null> {
+  if (!Device.isDevice) {
+    console.warn('[adas/push] requires a physical device');
+    return null;
+  }
+
+  try {
+    if (Platform.OS === 'ios') {
+      const status = await messaging().requestPermission();
+      const granted =
+        status === messaging.AuthorizationStatus.AUTHORIZED ||
+        status === messaging.AuthorizationStatus.PROVISIONAL;
+      if (!granted) {
+        console.warn(`[adas/push] iOS permission not granted (status ${status})`);
+        return null;
+      }
+    } else if (Platform.OS === 'android') {
+      const { status: existing } = await Notifications.getPermissionsAsync();
+      let final = existing;
+      if (existing !== 'granted') {
+        const { status } = await Notifications.requestPermissionsAsync();
+        final = status;
+      }
+      if (final !== 'granted') {
+        console.warn(`[adas/push] Android permission not granted (${final})`);
+        return null;
+      }
+      await Notifications.setNotificationChannelAsync('default', {
+        name: 'Default',
+        importance: Notifications.AndroidImportance.MAX,
+        vibrationPattern: [0, 250, 250, 250],
+        lightColor: ada.orange,
+      });
+    }
+
+    // iOS: register with APNs and WAIT for the APNs token before asking
+    // Firebase for an FCM token. Calling getToken() before the APNs token
+    // is available can return a stale/non-bridged token that the server
+    // can't deliver to.
+    if (Platform.OS === 'ios') {
+      if (!messaging().isDeviceRegisteredForRemoteMessages) {
+        await messaging().registerDeviceForRemoteMessages();
+      }
+      if (!(await waitForApnsToken(messaging))) {
+        console.warn(
+          '[adas/push] APNs token never arrived — Firebase cannot mint an FCM token. Check the aps-environment entitlement and the APNs key in Firebase Console → Cloud Messaging → Apple app config.',
+        );
+      }
+    }
+
+    const token = await messaging().getToken();
+    console.log(`[adas/push] FCM token ${token ? 'acquired' : 'missing'}`);
+    return token || null;
+  } catch (err) {
+    console.error('[adas/push] register failed:', err);
+    return null;
+  }
+}
+
+/** Polls getAPNSToken() up to ~5s. iOS sometimes needs a tick after
+ *  registerDeviceForRemoteMessages() returns before the token is available. */
+async function waitForApnsToken(messaging: Messaging, maxMs = 5000): Promise<string | null> {
+  const deadline = Date.now() + maxMs;
+  let token = await messaging().getAPNSToken();
+  while (!token && Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 250));
+    token = await messaging().getAPNSToken();
+  }
+  return token || null;
+}

package/src/vision/index.ts

@@ -76,6 +76,8 @@ interface AdaVisionNative {
   startVision(intervalMs: number): Promise<void>;
   /** Absent from binaries built before the front camera existed. */
   startVisionCamera?(intervalMs: number, facing: VisionFacing): Promise<void>;
+  /** Absent from binaries built before AI live existed. A base64 JPEG. */
+  jpegById?(id: string, maxSide: number, quality: number): Promise<string>;
   stopVision(): void;
   visionRetentionMs(): number;
   qualityById(id: string): RawFrameQuality | null;
@@ -168,3 +170,15 @@ export async function describe(id: string, maxLabels = 5): Promise<VisionLabel[]
 export async function detectObjects(id: string, maxItems = 10, minConfidence = 0.25): Promise<VisionObject[]> {
   return verb('detectObjects')(id, maxItems, minConfidence);
 }
+
+/**
+ * A published frame as a base64 JPEG, its longer side at most `maxSide`. FOR THE SDK'S AI LIVE SENDER ONLY
+ * (aiLive/provider.ts), which calls it after the two-sided "Pictures to AI" consent: this is the one way a
+ * picture leaves native, and no plugin-facing API reaches it. An older binary refuses by name.
+ */
+export async function jpegById(id: string, maxSide = 768, quality = 0.7): Promise<string> {
+  if (native && typeof native.jpegById !== 'function') {
+    throw new Error('sending pictures to AI needs a newer app build — this one cannot make a picture from a camera frame');
+  }
+  return verb('jpegById')!(id, maxSide, quality);
+}