@ateam-ai-mobile/expo 0.1.4 → 0.1.7

package/src/device-bridge/collectors/calendar.ts

@@ -0,0 +1,162 @@
+/**
+ * Calendar Collector — reads device calendar via expo-calendar.
+ * Output format matches device-mock-mcp's calendar.today / calendar.upcoming schemas.
+ */
+
+import * as ExpoCalendar from 'expo-calendar';
+// Type-only alias: the value namespace above cannot be used in type
+// position, so `ExpoCalendar.Calendar`-style annotations need this.
+// expo-calendar's types are not visible through the package entry under
+// bundler resolution, so derive them from the APIs that return them —
+// the shape then always matches the installed version.
+type Calendar = Awaited<ReturnType<typeof ExpoCalendar.getCalendarsAsync>>[number];
+type Event = Awaited<ReturnType<typeof ExpoCalendar.getEventsAsync>>[number];
+import type { CalendarEvent, CalendarTodayData, CalendarUpcomingData } from '../types';
+
+/**
+ * Request calendar permissions.
+ * @returns true if granted
+ */
+export async function requestPermission(): Promise<boolean> {
+  const { status } = await ExpoCalendar.requestCalendarPermissionsAsync();
+  return status === 'granted';
+}
+
+/**
+ * Check if calendar permission is granted.
+ */
+export async function hasPermission(): Promise<boolean> {
+  const { status } = await ExpoCalendar.getCalendarPermissionsAsync();
+  return status === 'granted';
+}
+
+/**
+ * Get all calendar events for today.
+ * Matches the device.calendar.today tool output schema.
+ */
+export async function collectToday(): Promise<CalendarTodayData> {
+  const now = new Date();
+  const startOfDay = 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, startOfDay, endOfDay);
+  const filtered = filterHolidays(events);
+
+  const mapped: CalendarEvent[] = filtered.map(e => ({
+    id: e.id,
+    title: e.title || 'Untitled',
+    date: startOfDay.toISOString().slice(0, 10),
+    start: formatTime(new Date(e.startDate)),
+    end: formatTime(new Date(e.endDate)),
+    location: e.location || '',
+    attendees: ((e as any).attendees || []).map((a: { name?: string; email?: string }) => a.name || a.email || 'Unknown'),
+    notes: e.notes || '',
+  }));
+
+  // Sort by start time
+  mapped.sort((a, b) => a.start.localeCompare(b.start));
+
+  return {
+    ok: true,
+    date: startOfDay.toISOString().slice(0, 10),
+    day_of_week: now.toLocaleDateString('en-US', { weekday: 'long' }),
+    event_count: mapped.length,
+    events: mapped,
+  };
+}
+
+/**
+ * Get upcoming calendar events for the next N days (tomorrow and beyond).
+ * Matches the device.calendar.upcoming tool output schema.
+ */
+export async function collectUpcoming(daysAhead: number = 3): Promise<CalendarUpcomingData> {
+  const now = 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: CalendarEvent[] = 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 as any).attendees || []).map((a: { name?: string; email?: string }) => a.name || a.email || 'Unknown'),
+      notes: e.notes || '',
+    };
+  });
+
+  // Sort by date then start time
+  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,
+  };
+}
+
+// ─── Helpers ───
+
+/**
+ * Filter out holiday/subscription calendars — only keep user-owned calendars
+ * (local, CalDAV, Exchange, Google). Subscription calendars are read-only
+ * holiday feeds that clutter the real schedule.
+ */
+function getUserCalendarIds(calendars: Calendar[]): string[] {
+  const SKIP_SOURCES = ['birthdays', 'other']; // 'other' = subscribed holiday feeds on iOS
+  const SKIP_TYPES = ['birthdays', 'other'];
+
+  return calendars
+    .filter(c => {
+      const sourceType = ((c.source as any)?.type || '').toLowerCase();
+      const calType = (c.type || '').toLowerCase();
+      // Skip subscription/holiday calendars
+      if (SKIP_SOURCES.includes(sourceType)) return false;
+      if (SKIP_TYPES.includes(calType)) return false;
+      return true;
+    })
+    .map(c => c.id);
+}
+
+/**
+ * Extra safety: filter out all-day events with holiday-like patterns
+ * in case they slip through from non-subscription calendars.
+ */
+function filterHolidays(events: Event[]): Event[] {
+  const HOLIDAY_PATTERNS = [
+    /holiday/i, /observance/i, /eve\b.*\btentative\b/i, /\btentative\b/i,
+  ];
+
+  return events.filter(e => {
+    // All-day events spanning exactly one day with "tentative" or "observance" in notes → holiday
+    const isAllDay = (e as any).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: Date): string {
+  return date.toLocaleTimeString('en-US', {
+    hour: '2-digit',
+    minute: '2-digit',
+    hour12: false,
+  });
+}

package/src/device-bridge/collectors/camera.ts

@@ -0,0 +1,27 @@
+/**
+ * Camera capability — permission only, NO collector.
+ *
+ * Unlike calendar/contacts/health, the camera is a LIVE capability: frames are
+ * used in the moment (deviceState.visual, a widget's camera preview) and are
+ * analysed on-device — never collected to the relay. So this module carries only
+ * the OS-permission check/request that the capability toggle drives; there is no
+ * `collect`. The user's grant (this toggle) is what gates access, on the same
+ * path as location/contacts.
+ */
+import { Camera } from 'expo-camera';
+
+export async function hasPermission(): Promise<boolean> {
+  try {
+    return (await Camera.getCameraPermissionsAsync()).granted;
+  } catch {
+    return false;
+  }
+}
+
+export async function requestPermission(): Promise<boolean> {
+  try {
+    return (await Camera.requestCameraPermissionsAsync()).granted;
+  } catch {
+    return false;
+  }
+}

package/src/device-bridge/collectors/connectivity.ts

@@ -0,0 +1,60 @@
+/**
+ * Connectivity Collector — reads network state via expo-network.
+ * Output format matches device-mock-mcp's device.connectivity schema.
+ */
+
+import * as ExpoNetwork from 'expo-network';
+import type { ConnectivityData } from '../types';
+
+// No special permission needed for network state
+
+/**
+ * Collect current connectivity status.
+ * Matches the device.connectivity tool output schema.
+ */
+export async function collectConnectivity(): Promise<ConnectivityData> {
+  const networkState = await ExpoNetwork.getNetworkStateAsync();
+
+  let type: 'wifi' | 'cellular' | 'none' = 'none';
+  let wifiName: string | undefined;
+  let cellularType: string | undefined;
+
+  if (networkState.type === ExpoNetwork.NetworkStateType.WIFI) {
+    type = 'wifi';
+    // Wi-Fi SSID requires additional permissions on newer OS versions
+    // and may not always be available
+    try {
+      wifiName = await getWifiName();
+    } catch {
+      wifiName = undefined;
+    }
+  } else if (networkState.type === ExpoNetwork.NetworkStateType.CELLULAR) {
+    type = 'cellular';
+    cellularType = getCellularGeneration();
+  }
+
+  return {
+    ok: true,
+    timestamp: new Date().toISOString(),
+    connectivity: {
+      type,
+      is_connected: networkState.isConnected ?? false,
+      ...(wifiName && { wifi_name: wifiName }),
+      ...(cellularType && { cellular_type: cellularType }),
+    },
+  };
+}
+
+// ─── Helpers ───
+
+async function getWifiName(): Promise<string | undefined> {
+  // expo-network doesn't expose SSID directly on all platforms
+  // This would need a native module or expo-wifi in production
+  return undefined;
+}
+
+function getCellularGeneration(): string {
+  // expo-network doesn't expose cellular generation
+  // In production, use a native module for this
+  return 'LTE';
+}

package/src/device-bridge/collectors/contacts.ts

@@ -0,0 +1,200 @@
+/**
+ * Contacts Collector — reads device contacts via expo-contacts.
+ *
+ * Two important properties for users with large address books (6000+ contacts):
+ *
+ *   1. Hash-based change detection. We persist a map of `contactId → contentHash`
+ *      across launches and on each collect cycle compare the freshly-read hashes
+ *      to the stored ones. If nothing changed, `collectAll()` returns null and
+ *      `syncCapability` skips the relay push entirely — no per-tick 1MB upload.
+ *
+ *   2. Reduced field set. iOS 16+ restricts which contact fields are accessible
+ *      without explicit user grants. Requesting `Note`/`Relationships` causes
+ *      `getContactsAsync` to throw "Failed to serialize contact data:
+ *      Unauthorized Keys", failing the entire collect. We stick to the four
+ *      fields actually used downstream (Name, PhoneNumbers, Emails, Birthday).
+ *
+ * Output format on push (when there ARE changes) is unchanged from before —
+ * a full `Contact[]` — so the relay/MCP layer doesn't have to know about the
+ * incremental scheme. The relay simply gets pushed less often.
+ */
+import * as ExpoContacts from 'expo-contacts';
+// Type-only alias: the value namespace above cannot be used in type
+// position, so `ExpoContacts.Calendar`-style annotations need this.
+// expo-contacts exports no `Date` type; take the shape from Contact itself.
+type ExpoContact = Awaited<ReturnType<typeof ExpoContacts.getContactsAsync>>['data'][number];
+type ContactDate = NonNullable<ExpoContact['birthday']>;
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import type { Contact } from '../types';
+
+const HASH_STORE_KEY = 'device-bridge.contacts.hashes.v1';
+
+/** Request contacts permissions. */
+export async function requestPermission(): Promise<boolean> {
+  const { status } = await ExpoContacts.requestPermissionsAsync();
+  return status === 'granted';
+}
+
+/** Check if contacts permission is granted. */
+export async function hasPermission(): Promise<boolean> {
+  const { status } = await ExpoContacts.getPermissionsAsync();
+  return status === 'granted';
+}
+
+/**
+ * Diagnostic counters from the most recent collect — exposed so the Profile
+ * debug view can surface "what changed since last sync".
+ */
+export interface ContactsCollectStats {
+  total: number;
+  added: number;
+  updated: number;
+  removed: number;
+  unchanged: number;
+  full_sync: boolean;
+}
+export let lastContactsStats: ContactsCollectStats | null = null;
+
+/**
+ * Read all contacts and detect changes vs the previously-stored hash map.
+ *
+ * Returns:
+ *   - the full Contact[] when anything changed (or this is the first sync),
+ *   - null when every contact's hash matches what we pushed last time, signalling
+ *     the bridge that no relay push is needed this cycle.
+ */
+export async function collectAll(): Promise<Contact[] | null> {
+  // Only the four fields we actually surface downstream. Adding more reawakens
+  // the iOS "Unauthorized Keys" failure unless the user has granted them via
+  // a separate flow.
+  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 : [];
+
+  // Map raw contacts to our schema, computing a stable per-contact hash that's
+  // independent of array ordering and resilient to spurious whitespace/case
+  // changes in fields we don't actually compare on.
+  const contacts: Contact[] = [];
+  const currentHashes: Record<string, string> = {};
+  for (let i = 0; i < raw.length; i++) {
+    const c = raw[i];
+    const id = c.id || `c${i}`;
+    const mapped: Contact = {
+      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);
+  }
+
+  // Compare against last-pushed hashes.
+  let stored: Record<string, string> = {};
+  try {
+    const blob = await AsyncStorage.getItem(HASH_STORE_KEY);
+    if (blob) stored = JSON.parse(blob) as Record<string, string>;
+  } catch {
+    /* corrupted store — treat as empty, will full-sync */
+  }
+  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 === undefined) added++;
+    else if (prev !== currentHashes[id]) updated++;
+    else unchanged++;
+  }
+  let removed = 0;
+  for (const id of Object.keys(stored)) {
+    if (currentHashes[id] === undefined) removed++;
+  }
+
+  lastContactsStats = {
+    total: contacts.length,
+    added,
+    updated,
+    removed,
+    unchanged,
+    full_sync: fullSync,
+  };
+
+  // No changes → tell the bridge to skip the relay push this cycle. Saves
+  // a 6000-row payload going up the wire every 5 minutes when nothing moved.
+  if (!fullSync && added === 0 && updated === 0 && removed === 0) {
+    return null;
+  }
+
+  // Persist the new hash map AFTER deciding to push. If the push fails we'll
+  // re-detect the same changes on the next cycle (push is idempotent enough).
+  try {
+    await AsyncStorage.setItem(HASH_STORE_KEY, JSON.stringify(currentHashes));
+  } catch {
+    /* a failed persist just means we'll redo the diff next time — non-fatal */
+  }
+
+  return contacts;
+}
+
+// ─── Helpers ────────────────────────────────────────────────
+
+/**
+ * Stable string hash (FNV-1a 32-bit, hex). Pure JS, no native dep, fine for
+ * change detection. NOT cryptographic — a determined collision attacker could
+ * mask a contact change, but that's not in our threat model.
+ */
+function fnv1a(str: string): string {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 0x01000193);
+  }
+  return (h >>> 0).toString(16).padStart(8, '0');
+}
+
+function hashContact(c: Contact): string {
+  // Concatenate the canonical-cased, trimmed values of every field we surface.
+  // Order matters and is fixed; null becomes a single sentinel character so
+  // empty-vs-missing differs from "actual whitespace" in the hash space.
+  const parts = [
+    c.id,
+    (c.name || '').trim(),
+    c.phone || '\0',
+    (c.email || '\0').toLowerCase(),
+    c.birthday || '\0',
+  ];
+  return fnv1a(parts.join('')); // unit separator — won't appear in any field
+}
+
+function formatBirthday(birthday: ContactDate | undefined): string | null {
+  if (!birthday) return null;
+  const { year, month, day } = birthday;
+  if (month === undefined || day === undefined) return null;
+  const m = String(month + 1).padStart(2, '0');
+  const d = String(day).padStart(2, '0');
+
+  // No year is the COMMON case on iOS — the contact editor lets you omit it,
+  // and most people do. Substituting 1900 made that indistinguishable from a
+  // real birth year, and the server dutifully computed an age from it: "Dana
+  // is turning 126 next Tuesday."
+  //
+  // `--MM-DD` is the ISO 8601 form for a recurring month-day with no year, so
+  // the absence is stated rather than filled in.
+  if (!year) return `--${m}-${d}`;
+
+  return `${year}-${m}-${d}`;
+}