@ateam-ai-mobile/expo 0.1.4 → 0.1.7

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

@@ -0,0 +1,70 @@
+/**
+ * Notifications Collector — reads notification state via expo-notifications.
+ * Output format matches device-mock-mcp's notifications.list schema.
+ *
+ * Note: On iOS/Android, expo-notifications only gives access to notifications
+ * that YOUR app has posted or received. System-wide notification access
+ * requires platform-specific APIs (NotificationListenerService on Android,
+ * UNUserNotificationCenter on iOS with app extensions).
+ *
+ * For the PA, the relay approach means we capture notifications delivered
+ * TO our app (from the PA system), not FROM other apps.
+ * Other-app notifications would need a native module or accessibility service.
+ */
+
+import * as ExpoNotifications from 'expo-notifications';
+import type { Notification, NotificationsData } from '../types';
+
+/**
+ * Request notification permissions.
+ */
+export async function requestPermission(): Promise<boolean> {
+  const { status } = await ExpoNotifications.requestPermissionsAsync();
+  return status === 'granted';
+}
+
+/**
+ * Check if notification permission is granted.
+ */
+export async function hasPermission(): Promise<boolean> {
+  const { status } = await ExpoNotifications.getPermissionsAsync();
+  return status === 'granted';
+}
+
+/**
+ * Collect delivered notifications from the notification tray.
+ * Only captures notifications delivered to THIS app.
+ * Matches the device.notifications.list tool output schema.
+ */
+export async function collectNotifications(): Promise<NotificationsData> {
+  const presented = await ExpoNotifications.getPresentedNotificationsAsync();
+
+  const notifications: Notification[] = presented.map((n, i) => ({
+    id: n.request.identifier || `n${i}`,
+    app: (n.request.content.data?.app as string) || 'A-Team',
+    title: n.request.content.title || '',
+    body: n.request.content.body || '',
+    timestamp: n.date ? new Date(n.date).toISOString() : new Date().toISOString(),
+    sender: (n.request.content.data?.sender as string) || null,
+    priority: mapPriority(n.request.content.data?.priority as string),
+    read: false, // Presented notifications are unread by definition
+  }));
+
+  const unread = notifications.filter(n => !n.read).length;
+
+  return {
+    ok: true,
+    timestamp: new Date().toISOString(),
+    total: notifications.length,
+    unread,
+    notifications,
+  };
+}
+
+// ─── Helpers ───
+
+function mapPriority(p: string | undefined): 'high' | 'medium' | 'low' {
+  if (p === 'high' || p === 'max') return 'high';
+  if (p === 'low' || p === 'min') return 'low';
+  return 'medium';
+}

package/src/device-bridge/cookies.ts

@@ -0,0 +1,89 @@
+/**
+ * Device-bridge: Cookies API
+ *
+ * Reads the platform's shared cookie jar (NSHTTPCookieStorage on iOS,
+ * CookieManager on Android) so upper layers (plugin-sdk → RN plugins) can
+ * extract session cookies captured during a native WebView login flow.
+ *
+ * Wraps `@react-native-cookies/cookies` so upper layers never import the
+ * native module directly. If we swap implementations, only this file changes.
+ *
+ * Why device-bridge owns this: cookies are a device-level capability (tied
+ * to the platform's shared HTTP stack). Plugins should consume a clean
+ * abstraction; the native wiring lives here.
+ */
+
+import CookieManager from '@react-native-cookies/cookies';
+
+export interface DeviceCookie {
+  name: string;
+  value: string;
+  domain?: string;
+  path?: string;
+  /** Unix seconds. Omitted for session cookies. */
+  expires?: number;
+  httpOnly?: boolean;
+  secure?: boolean;
+  sameSite?: 'Lax' | 'Strict' | 'None';
+}
+
+/**
+ * Get every cookie attached to the URL's effective domain.
+ * Set `includeHttpOnly` true to include HttpOnly cookies (required for
+ * LinkedIn/Google session tokens).
+ */
+export async function get(url: string, includeHttpOnly: boolean = true): Promise<DeviceCookie[]> {
+  const raw = (await CookieManager.get(url, includeHttpOnly)) as Record<string, any>;
+  const out: DeviceCookie[] = [];
+  for (const [name, c] of Object.entries(raw || {})) {
+    if (!c || typeof c !== 'object') continue;
+    const value = typeof c.value === 'string' ? c.value : String(c.value ?? '');
+    const cookie: DeviceCookie = { name, value };
+    if (c.domain) cookie.domain = String(c.domain);
+    if (c.path) cookie.path = String(c.path);
+    if (c.expires) {
+      const t = Date.parse(c.expires);
+      if (!Number.isNaN(t)) cookie.expires = Math.floor(t / 1000);
+    }
+    if (typeof c.httpOnly === 'boolean') cookie.httpOnly = c.httpOnly;
+    if (typeof c.secure === 'boolean') cookie.secure = c.secure;
+    if (c.sameSite === 'Lax' || c.sameSite === 'Strict' || c.sameSite === 'None') {
+      cookie.sameSite = c.sameSite;
+    }
+    out.push(cookie);
+  }
+  return out;
+}
+
+/**
+ * Wipe the shared cookie jar. Cross-platform scoped clear isn't supported
+ * uniformly; `clearAll` is the safe operation on both iOS and Android.
+ */
+export async function clearAll(): Promise<{ ok: boolean; error?: string }> {
+  try {
+    await CookieManager.clearAll(true);
+    return { ok: true };
+  } catch (e: any) {
+    return { ok: false, error: String(e?.message || e) };
+  }
+}
+
+/**
+ * Set a cookie programmatically. Useful when replaying a saved session on
+ * the device's shared jar before opening a WebView.
+ */
+export async function set(url: string, cookie: DeviceCookie): Promise<{ ok: boolean; error?: string }> {
+  try {
+    await CookieManager.set(url, {
+      name: cookie.name,
+      value: cookie.value,
+      domain: cookie.domain,
+      path: cookie.path || '/',
+      httpOnly: cookie.httpOnly,
+      secure: cookie.secure,
+    } as any, true);
+    return { ok: true };
+  } catch (e: any) {
+    return { ok: false, error: String(e?.message || e) };
+  }
+}

package/src/device-bridge/dynamic-connector.ts

@@ -0,0 +1,422 @@
+/**
+ * Device Bridge — Dynamic Connector
+ *
+ * Pure JavaScript implementation (zero native imports).
+ * Uses bridge APIs for all device operations.
+ * Can be downloaded and executed at runtime.
+ *
+ * This file compiles to pure JS that gets bundled as device-bridge-connector.js
+ */
+
+// Structural Bridge type. The old import pointed at '@ateam-mobile/bridge',
+// a package that does not exist here — it resolved to `any` and hid whatever
+// this file actually needs from the host.
+type Bridge = Record<string, any>;
+
+interface PendingAction {
+  id: string;
+  type: string;
+  params: Record<string, any>;
+  created_at: string;
+}
+
+interface ActionResult {
+  id: string;
+  ok: boolean;
+  result?: Record<string, any>;
+  error?: string;
+}
+
+interface RelayPushResult {
+  ok: boolean;
+  error?: string;
+}
+
+/**
+ * Main dynamic connector export
+ */
+export default {
+  id: 'device-bridge',
+  name: 'Device Bridge',
+  version: '1.0.0',
+
+  // State (persisted across syncs)
+  _config: {} as Record<string, string>,
+  // ReturnType<typeof setInterval>, not NodeJS.Timeout: this runs in React
+  // Native, where setInterval returns a number. @types/node is present in the
+  // workspace and made the Node type look right, so the annotation disagreed
+  // with every value ever assigned to it.
+  _syncTimers: new Map<string, ReturnType<typeof setInterval>>(),
+  _actionPollTimer: undefined as ReturnType<typeof setInterval> | undefined,
+  _lastSync: new Map<string, string>(),
+  _isRunning: false,
+
+  // ─────────────────────────────────────────────────────────────────────
+  // LIFECYCLE: onStart — Request permissions and start syncing
+  // ─────────────────────────────────────────────────────────────────────
+
+  async onStart(bridge: Bridge, config: Record<string, string>) {
+    this._config = config;
+    this._isRunning = true;
+
+    bridge.log.info('device-bridge starting', {
+      relay: config.relay_url,
+      deviceId: config.device_id,
+    });
+
+    // Request permissions for all capabilities
+    const capabilities = ['calendar', 'contacts', 'location', 'notifications'];
+    for (const cap of capabilities) {
+      try {
+        const granted = await bridge.permissions.request(cap);
+        bridge.log.info(`Permission requested: ${cap} = ${granted ? 'granted' : 'denied'}`);
+      } catch (err) {
+        bridge.log.warn(`Permission request failed for ${cap}:`, err);
+      }
+    }
+
+    // Do initial sync
+    await this.onSync!(bridge);
+
+    // Start periodic sync
+    this._setupSyncTimers(bridge);
+
+    // Start action polling
+    this._startActionPoll(bridge);
+
+    bridge.log.info('device-bridge started');
+  },
+
+  // ─────────────────────────────────────────────────────────────────────
+  // LIFECYCLE: onSync — Collect all device data and push to relay
+  // ─────────────────────────────────────────────────────────────────────
+
+  async onSync(bridge: Bridge) {
+    if (!this._isRunning) return;
+
+    bridge.log.info('device-bridge syncing');
+
+    try {
+      // Collect all domains in parallel
+      const results = await Promise.allSettled([
+        this._collectCalendar(bridge),
+        this._collectContacts(bridge),
+        this._collectLocation(bridge),
+        this._collectBattery(bridge),
+        this._collectNetwork(bridge),
+        this._collectNotifications(bridge),
+      ]);
+
+      // Push each domain to relay
+      const domains = [
+        { name: 'calendar', result: results[0] },
+        { name: 'contacts', result: results[1] },
+        { name: 'location', result: results[2] },
+        { name: 'battery', result: results[3] },
+        { name: 'connectivity', result: results[4] },
+        { name: 'notifications', result: results[5] },
+      ];
+
+      for (const { name, result } of domains) {
+        if (result.status !== 'fulfilled' || !result.value) {
+          bridge.log.warn(`Skipping ${name} (collection failed)`);
+          continue;
+        }
+
+        const pushResult = await this._pushDomain(bridge, name, result.value);
+        if (pushResult.ok) {
+          this._lastSync.set(name, new Date().toISOString());
+          bridge.log.info(`Synced ${name}`);
+        } else {
+          bridge.log.error(`Failed to sync ${name}: ${pushResult.error}`);
+        }
+      }
+    } catch (err) {
+      bridge.log.error('Sync failed', err);
+    }
+  },
+
+  // ─────────────────────────────────────────────────────────────────────
+  // LIFECYCLE: onAction — Execute inbound actions from relay
+  // ─────────────────────────────────────────────────────────────────────
+
+  async onAction(bridge: Bridge, action: PendingAction): Promise<ActionResult> {
+    try {
+      bridge.log.info(`Executing action: ${action.type}`, action.params);
+
+      switch (action.type) {
+        // Messaging
+        case 'messaging.send': {
+          const { phone, message } = action.params;
+          const result = await bridge.sms.send(phone, message);
+          return {
+            id: action.id,
+            ok: result.ok,
+            result: { status: result.status },
+          };
+        }
+
+        // Calendar — Create
+        case 'calendar.create': {
+          const { title, date, start_time, end_time, location, notes } = action.params;
+          const result = await bridge.calendar.create({
+            title,
+            date,
+            start_time,
+            end_time: end_time || undefined,
+            location: location || undefined,
+            notes: notes || undefined,
+          });
+          return {
+            id: action.id,
+            ok: true,
+            result,
+          };
+        }
+
+        // Calendar — Reschedule
+        case 'calendar.reschedule': {
+          const result = await bridge.calendar.reschedule(action.params as any);
+          return {
+            id: action.id,
+            ok: result.ok,
+          };
+        }
+
+        // Calendar — Cancel
+        case 'calendar.cancel': {
+          const { event_id } = action.params;
+          const result = await bridge.calendar.cancel(event_id);
+          return {
+            id: action.id,
+            ok: result.ok,
+          };
+        }
+
+        // Navigation
+        case 'navigation.start': {
+          const { destination, mode } = action.params;
+          const result = await bridge.maps.navigate(destination, mode || 'driving');
+          return {
+            id: action.id,
+            ok: result.ok,
+            result: { status: result.status },
+          };
+        }
+
+        // DND — Store as preference (app-level, not system-level)
+        case 'dnd.set': {
+          await bridge.storage.set('dnd-state', JSON.stringify(action.params));
+          return {
+            id: action.id,
+            ok: true,
+            result: { stored: true },
+          };
+        }
+
+        default:
+          return {
+            id: action.id,
+            ok: false,
+            error: `Unknown action type: ${action.type}`,
+          };
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        id: action.id,
+        ok: false,
+        error: message,
+      };
+    }
+  },
+
+  // ─────────────────────────────────────────────────────────────────────
+  // LIFECYCLE: onStop — Cleanup
+  // ─────────────────────────────────────────────────────────────────────
+
+  async onStop(bridge: Bridge) {
+    bridge.log.info('device-bridge stopping');
+    this._isRunning = false;
+
+    // Clear all timers
+    for (const timer of this._syncTimers.values()) {
+      clearInterval(timer);
+    }
+    this._syncTimers.clear();
+
+    if (this._actionPollTimer) {
+      clearInterval(this._actionPollTimer);
+      this._actionPollTimer = undefined;
+    }
+
+    bridge.log.info('device-bridge stopped');
+  },
+
+  // ─────────────────────────────────────────────────────────────────────
+  // LIFECYCLE: onForeground — Immediate sync on app wake
+  // ─────────────────────────────────────────────────────────────────────
+
+  async onForeground(bridge: Bridge) {
+    bridge.log.info('device-bridge foreground — immediate sync');
+    await this.onSync!(bridge);
+  },
+
+  // ─────────────────────────────────────────────────────────────────────
+  // INTERNAL: Data Collection (uses bridge APIs only)
+  // ─────────────────────────────────────────────────────────────────────
+
+  async _collectCalendar(bridge: Bridge) {
+    try {
+      const [today, upcoming] = await Promise.all([
+        bridge.calendar.getToday(),
+        bridge.calendar.getUpcoming(7),
+      ]);
+      return { today, upcoming };
+    } catch (err) {
+      return null;
+    }
+  },
+
+  async _collectContacts(bridge: Bridge) {
+    try {
+      const result = await bridge.contacts.getAll();
+      return { ok: true, contacts: result.contacts, count: result.count };
+    } catch (err) {
+      return null;
+    }
+  },
+
+  async _collectLocation(bridge: Bridge) {
+    try {
+      return await bridge.location.getCurrent();
+    } catch (err) {
+      return null;
+    }
+  },
+
+  async _collectBattery(bridge: Bridge) {
+    try {
+      return await bridge.battery.getStatus();
+    } catch (err) {
+      return null;
+    }
+  },
+
+  async _collectNetwork(bridge: Bridge) {
+    try {
+      return await bridge.network.getStatus();
+    } catch (err) {
+      return null;
+    }
+  },
+
+  async _collectNotifications(bridge: Bridge) {
+    try {
+      const result = await bridge.notifications.list();
+      return result;
+    } catch (err) {
+      return null;
+    }
+  },
+
+  // ─────────────────────────────────────────────────────────────────────
+  // INTERNAL: Relay Communication (uses bridge.http only)
+  // ─────────────────────────────────────────────────────────────────────
+
+  async _pushDomain(bridge: Bridge, domain: string, data: any): Promise<RelayPushResult> {
+    try {
+      const url = `${this._config.relay_url}/api/device/${this._config.device_id}/sync/${domain}`;
+      const response = await bridge.http.post(
+        url,
+        { data, timestamp: new Date().toISOString() },
+        { 'X-Device-Key': this._config.api_key }
+      );
+
+      if (!response.ok) {
+        return { ok: false, error: `HTTP ${response.status}` };
+      }
+
+      return { ok: true };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { ok: false, error: message };
+    }
+  },
+
+  async _getActions(bridge: Bridge): Promise<PendingAction[]> {
+    try {
+      const url = `${this._config.relay_url}/api/device/${this._config.device_id}/actions`;
+      const response = await bridge.http.get(url, {
+        'X-Device-Key': this._config.api_key,
+      });
+
+      if (!response.ok || !response.data?.actions) {
+        return [];
+      }
+
+      return response.data.actions.filter((a: any) => a.status === 'pending');
+    } catch (err) {
+      return [];
+    }
+  },
+
+  async _reportActionResult(
+    bridge: Bridge,
+    result: ActionResult
+  ): Promise<void> {
+    try {
+      const url = `${this._config.relay_url}/api/device/${this._config.device_id}/actions/${result.id}`;
+      await bridge.http.delete(
+        url,
+        { ...result, executed_at: new Date().toISOString() },
+        { 'X-Device-Key': this._config.api_key }
+      );
+    } catch (err) {
+      // Silently fail — action was executed, just couldn't report back
+    }
+  },
+
+  // ─────────────────────────────────────────────────────────────────────
+  // INTERNAL: Timers and Polling
+  // ─────────────────────────────────────────────────────────────────────
+
+  _setupSyncTimers(bridge: Bridge) {
+    const intervals = this._config.sync_intervals
+      ? JSON.parse(this._config.sync_intervals)
+      : {};
+
+    // Default intervals (ms)
+    const defaultIntervals: Record<string, number> = {
+      calendar: 60_000,
+      contacts: 300_000,
+      location: 30_000,
+      battery: 60_000,
+      connectivity: 30_000,
+      notifications: 15_000,
+    };
+
+    for (const [domain, defaultInterval] of Object.entries(defaultIntervals)) {
+      const interval = intervals[domain] || defaultInterval;
+      const timer = setInterval(() => this.onSync!(bridge), interval);
+      this._syncTimers.set(domain, timer);
+    }
+  },
+
+  _startActionPoll(bridge: Bridge) {
+    const pollInterval = 5_000; // 5 seconds
+
+    this._actionPollTimer = setInterval(async () => {
+      try {
+        const actions = await this._getActions(bridge);
+
+        for (const action of actions) {
+          const result = await this.onAction!(bridge, action);
+          await this._reportActionResult(bridge, result);
+        }
+      } catch (err) {
+        bridge.log.warn('Action poll failed', err);
+      }
+    }, pollInterval);
+  },
+};