@ateam-ai-mobile/expo 0.1.4 → 0.1.7

package/src/device-bridge/relay-client.ts

@@ -0,0 +1,237 @@
+/**
+ * Relay Client — REST client for the cloud relay service.
+ * Handles data push, action polling, and offline buffering.
+ *
+ * Endpoints:
+ *   POST   /api/device/{deviceId}/sync           ← push data bundle
+ *   GET    /api/device/{deviceId}/data/{domain}   ← read latest (used by connector, not phone)
+ *   POST   /api/device/{deviceId}/actions         ← queue action (used by connector)
+ *   GET    /api/device/{deviceId}/actions          ← poll pending actions
+ *   DELETE /api/device/{deviceId}/actions/{id}     ← confirm action executed
+ */
+
+import type {
+  DeviceDataBundle,
+  PendingAction,
+  ActionResult,
+  RelayResponse,
+} from './types';
+
+export interface RelayClientConfig {
+  relayUrl: string;
+  deviceId: string;
+  tenant: string;
+  actorId?: string;
+  apiKey?: string;
+  timeout?: number; // ms, default 10000
+}
+
+export class RelayClient {
+  private baseUrl: string;
+  private deviceId: string;
+  private tenant: string;
+  private actorId: string;
+  private apiKey: string;
+  private timeout: number;
+  private offlineQueue: DeviceDataBundle[] = [];
+
+  constructor(config: RelayClientConfig) {
+    // Strip trailing slash
+    this.baseUrl = config.relayUrl.replace(/\/$/, '');
+    this.deviceId = config.deviceId;
+    this.tenant = config.tenant;
+    this.actorId = config.actorId ?? 'default';
+    this.apiKey = config.apiKey ?? '';
+    this.timeout = config.timeout ?? 10_000;
+  }
+
+  // ─── Data Sync ───
+
+  /**
+   * Push a full device data bundle to the relay.
+   * If offline, buffers the bundle and retries on next sync.
+   */
+  async pushData(bundle: DeviceDataBundle): Promise<RelayResponse<void>> {
+    try {
+      const response = await this.fetch(
+        `/api/device/${this.deviceId}/sync`,
+        {
+          method: 'POST',
+          body: JSON.stringify(bundle),
+        }
+      );
+
+      if (response.ok) {
+        // Flush any offline queue on successful connection
+        await this.flushOfflineQueue();
+        return { ok: true };
+      }
+
+      return {
+        ok: false,
+        error: `Relay returned ${response.status}: ${await response.text()}`,
+      };
+    } catch (error) {
+      // Network error — buffer for later
+      this.offlineQueue.push(bundle);
+      return {
+        ok: false,
+        error: `Offline — buffered (${this.offlineQueue.length} pending)`,
+      };
+    }
+  }
+
+  /**
+   * Push a single domain update (partial sync).
+   */
+  async pushDomain(
+    domain: string,
+    data: unknown
+  ): Promise<RelayResponse<void>> {
+    try {
+      const response = await this.fetch(
+        `/api/device/${this.deviceId}/sync/${domain}`,
+        {
+          method: 'POST',
+          body: JSON.stringify({ domain, data, timestamp: 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 — domain sync failed' };
+    }
+  }
+
+  // ─── Action Queue ───
+
+  /**
+   * Poll for pending actions the phone needs to execute.
+   */
+  async pollActions(): Promise<RelayResponse<PendingAction[]>> {
+    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 — action poll failed' };
+    }
+  }
+
+  /**
+   * Report action execution result and remove from queue.
+   */
+  async completeAction(result: ActionResult): Promise<RelayResponse<void>> {
+    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 — action complete failed' };
+    }
+  }
+
+  // ─── Health ───
+
+  /**
+   * Ping the relay to check connectivity.
+   */
+  async ping(): Promise<boolean> {
+    try {
+      const response = await this.fetch(
+        `/api/health`,
+        { method: 'GET' },
+        3_000 // short timeout for health check
+      );
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get count of buffered offline bundles.
+   */
+  getOfflineQueueSize(): number {
+    return this.offlineQueue.length;
+  }
+
+  // ─── Internal ───
+
+  private async fetch(
+    path: string,
+    init: RequestInit,
+    timeout?: number
+  ): Promise<Response> {
+    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);
+    }
+  }
+
+  private async flushOfflineQueue(): Promise<void> {
+    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) {
+          // Put it back if still failing
+          this.offlineQueue.push(bundle);
+        }
+      } catch {
+        this.offlineQueue.push(bundle);
+        break; // Stop trying if still offline
+      }
+    }
+  }
+}

package/src/device-bridge/scanner.ts

@@ -0,0 +1,42 @@
+/**
+ * Device-bridge: Scanner (QR / barcode)
+ *
+ * Wraps expo-camera (which replaced the deprecated expo-barcode-scanner
+ * in Expo SDK 50+). The CameraView component has built-in barcode scanning.
+ *
+ * Use cases:
+ *   - Wi-Fi QR handoff
+ *   - OAuth / pairing codes
+ *   - Payment QR codes
+ *   - Product lookup
+ *
+ * Plugins mount <CameraView onBarcodeScanned={...} /> directly. This module
+ * exposes the permission helper + a result normalizer so plugins don't need
+ * to import expo-camera directly.
+ */
+
+import { CameraView, useCameraPermissions, type BarcodeScanningResult } from 'expo-camera';
+
+export interface ScanResult {
+  type: string;   // e.g. 'qr', 'ean13', 'code128'
+  data: string;   // decoded content
+}
+
+/** Request camera permission if not already granted. */
+export async function requestPermissions(): Promise<{ granted: boolean; status: string }> {
+  // useCameraPermissions is a hook; for the non-hook flow plugins should use
+  // Camera.requestCameraPermissionsAsync. But it's easier to expose the hook
+  // helper — plugins typically use the hook form inside their Component.
+  // For service-style callers, fall back to the imperative API:
+  const { Camera } = await import('expo-camera');
+  const { status } = await Camera.requestCameraPermissionsAsync();
+  return { granted: status === 'granted', status };
+}
+
+/** Normalize a CameraView barcode result to a stable shape. */
+export function normalizeResult(r: BarcodeScanningResult): ScanResult {
+  return { type: r.type, data: r.data };
+}
+
+/** Re-export the component + hook so plugins consume them via device-bridge. */
+export { CameraView, useCameraPermissions };

package/src/device-bridge/sharing.ts

@@ -0,0 +1,35 @@
+/**
+ * Device-bridge: Sharing (native share sheet)
+ *
+ * Wraps expo-sharing. Lets solutions hand content off to the OS share sheet
+ * — any installed app can receive it (Messages, WhatsApp, Mail, Files, etc.).
+ *
+ * Typical use: "Share this article / calendar invite / photo with a contact."
+ */
+
+import * as Sharing from 'expo-sharing';
+
+export interface ShareOptions {
+  /** MIME type, e.g. 'application/pdf'. Optional. */
+  mimeType?: string;
+  /** iOS UTI, e.g. 'public.image'. Optional. */
+  UTI?: string;
+  /** Dialog title (Android only). */
+  dialogTitle?: string;
+}
+
+/** Share a local file URI. */
+export async function shareFile(fileUri: string, opts: ShareOptions = {}): Promise<{ ok: boolean; error?: string }> {
+  try {
+    const available = await Sharing.isAvailableAsync();
+    if (!available) return { ok: false, error: 'sharing_unavailable' };
+    await Sharing.shareAsync(fileUri, opts);
+    return { ok: true };
+  } catch (e: any) {
+    return { ok: false, error: String(e?.message || e) };
+  }
+}
+
+export async function isAvailable(): Promise<boolean> {
+  return Sharing.isAvailableAsync();
+}

package/src/device-bridge/types.ts

@@ -0,0 +1,326 @@
+// ─── Device Bridge Types ───
+// All types mirror the exact output schemas from device-mock-mcp
+// so that device-mcp connector can serve identical responses.
+
+// ─── Configuration ───
+
+export interface DeviceBridgeConfig {
+  /** Cloud relay base URL (e.g., https://relay.example.com) */
+  relayUrl: string;
+  /** Unique device identifier */
+  deviceId: string;
+  /** Tenant ID — required by relay for data isolation */
+  tenant: string;
+  /** Actor/user ID — scopes device data per user in relay */
+  actorId?: string;
+  /** API key for relay authentication (reserved for future use) */
+  apiKey?: string;
+  /** Sync intervals per domain in milliseconds */
+  syncIntervals?: Partial<Record<string, number>>;
+  /** Enable background sync (requires expo-task-manager) */
+  backgroundSync?: boolean;
+  /** Callback for sync status changes */
+  onStatusChange?: (status: BridgeStatus) => void;
+  /** Callback for errors */
+  onError?: (error: BridgeError) => void;
+}
+
+// ─── Capability System ───
+
+export type PermissionState = 'not_requested' | 'granted' | 'denied' | 'not_needed';
+
+export interface Capability {
+  /** Unique ID (e.g., 'calendar', 'contacts', 'whatsapp') */
+  id: string;
+  /** Human-readable name for UI */
+  name: string;
+  /** One-line description of what this capability does */
+  description: string;
+  /** Why the app needs this — shown to user BEFORE the OS dialog */
+  reason: string;
+  /** Does this capability require OS permission? */
+  requiresPermission: boolean;
+  /** Current permission state */
+  permissionState: PermissionState;
+  /** Request permission from the OS. Returns true if granted. */
+  requestPermission: () => Promise<boolean>;
+  /** Check current permission without prompting. */
+  checkPermission: () => Promise<boolean>;
+  /** Collect data for this capability. Returns domain data. */
+  collect: () => Promise<unknown>;
+  /** Default sync interval in ms */
+  defaultInterval: number;
+  /** Optional icon name (for host app UI) */
+  icon?: string;
+  /**
+   * Optional OS-event subscription. When provided, the bridge wires this up
+   * during startSync and the callback triggers an immediate sync of this
+   * capability — useful for sources that change unpredictably (battery
+   * level/state) where polling on a fixed interval misses changes while the
+   * app is backgrounded. Return an unsubscribe function.
+   */
+  subscribe?: (notify: () => void) => () => void;
+}
+
+// ─── Bridge Status ───
+
+export type SyncState = 'idle' | 'syncing' | 'error' | 'stopped';
+
+export interface DomainSyncStatus {
+  domain: string;
+  lastSync: string | null; // ISO timestamp
+  state: SyncState;
+  error?: string;
+  itemCount?: number;
+}
+
+export interface BridgeStatus {
+  running: boolean;
+  capabilities: CapabilityStatus[];
+  lastFullSync: string | null;
+  pendingActions: number;
+}
+
+export interface CapabilityStatus {
+  id: string;
+  name: string;
+  permission: PermissionState;
+  sync: DomainSyncStatus;
+}
+
+export interface BridgeError {
+  domain: string;
+  message: string;
+  code: string;
+  timestamp: string;
+}
+
+// ─── Calendar ───
+
+export interface CalendarEvent {
+  id: string;
+  title: string;
+  date: string;       // YYYY-MM-DD
+  start: string;      // HH:MM
+  end: string;        // HH:MM
+  location: string;
+  attendees: string[];
+  notes: string;
+}
+
+export interface CalendarTodayData {
+  ok: true;
+  date: string;
+  day_of_week: string;
+  event_count: number;
+  events: CalendarEvent[];
+}
+
+export interface CalendarUpcomingData {
+  ok: true;
+  from: string;
+  days_ahead: number;
+  event_count: number;
+  events: CalendarEvent[];
+}
+
+// ─── Contacts ───
+
+export interface Contact {
+  id: string;
+  name: string;
+  relationship: string;
+  phone: string | null;
+  email: string | null;
+  birthday: string | null; // YYYY-MM-DD
+  notes: string;
+}
+
+export interface ContactSearchData {
+  ok: true;
+  query: string;
+  count: number;
+  contacts: Contact[];
+}
+
+export interface ContactLastContactData {
+  ok: true;
+  contact: string;
+  relationship: string;
+  days_since_last_contact: number;
+  last_contact_date: string;
+  last_contact_type: string;
+  suggestion: string | null;
+}
+
+// ─── Location ───
+
+export interface LocationData {
+  ok: true;
+  timestamp: string;
+  location: {
+    place: string;
+    address: string;
+    lat: number;
+    lng: number;
+    type: string;
+  };
+}
+
+// ─── Battery ───
+
+export interface BatteryData {
+  ok: true;
+  timestamp: string;
+  battery: {
+    level: number;          // 0-100
+    state: 'charging' | 'unplugged' | 'full';
+    low_power_mode: boolean;
+  };
+}
+
+// ─── Health (HealthKit on iOS, Health Connect on Android — iOS only for now) ───
+
+export interface HealthDayMetrics {
+  /** ISO date in local time, e.g. "2026-05-03" */
+  date: string;
+  /**
+   * False when HealthKit is unavailable or the user denied access.
+   *
+   * The metrics below are then null, NOT zero. A zero here used to be
+   * indistinguishable from a real sedentary day, so a denied permission was
+   * reported to the user as "you have taken 0 steps today" — and a coaching
+   * skill would act on it.
+   */
+  available: boolean;
+  /** Total step count for the day. null when unavailable. */
+  steps: number | null;
+  /** Flights of stairs climbed. null when unavailable. */
+  floors: number | null;
+  /** Active energy burned, kcal. null when unavailable. */
+  active_energy_kcal: number | null;
+  /** Walking + running distance, kilometers. null when unavailable. */
+  distance_km: number | null;
+}
+
+export interface HealthTodayData {
+  ok: true;
+  timestamp: string;
+  /** Same shape as a single history entry — date is today in local time. */
+  today: HealthDayMetrics;
+}
+
+export interface HealthHistoryData {
+  ok: true;
+  timestamp: string;
+  /** Newest-first: index 0 is today, index N is N days ago. */
+  days: HealthDayMetrics[];
+}
+
+// ─── Connectivity ───
+
+export interface ConnectivityData {
+  ok: true;
+  timestamp: string;
+  connectivity: {
+    type: 'wifi' | 'cellular' | 'none';
+    is_connected: boolean;
+    wifi_name?: string;
+    cellular_type?: string; // '5G', 'LTE', etc.
+  };
+}
+
+// ─── Notifications ───
+
+export interface Notification {
+  id: string;
+  app: string;
+  title: string;
+  body: string;
+  timestamp: string;
+  sender: string | null;
+  priority: 'high' | 'medium' | 'low';
+  read: boolean;
+}
+
+export interface NotificationsData {
+  ok: true;
+  timestamp: string;
+  total: number;
+  unread: number;
+  notifications: Notification[];
+}
+
+// ─── DND ───
+
+export interface DndState {
+  enabled: boolean;
+  schedule: { start: string; end: string };
+  allowlist: string[];
+}
+
+export interface DndData {
+  ok: true;
+  dnd: DndState;
+}
+
+// ─── App Usage ───
+
+export interface AppUsageEntry {
+  app: string;
+  last_used: string;
+  usage_minutes_today: number;
+  category: string;
+}
+
+export interface AppUsageData {
+  ok: true;
+  timestamp: string;
+  total_screen_time_minutes: number;
+  app_count: number;
+  apps: AppUsageEntry[];
+}
+
+// ─── Data Bundle (full sync payload) ───
+
+export interface DeviceDataBundle {
+  deviceId: string;
+  timestamp: string;
+  domains: Record<string, unknown>;
+}
+
+// ─── Action Queue ───
+
+export type ActionType =
+  | 'messaging.send'
+  | 'calendar.create'
+  | 'calendar.reschedule'
+  | 'calendar.cancel'
+  | 'dnd.set'
+  | 'navigation.start'
+  | 'health.today'
+  | 'health.history';
+
+export interface PendingAction {
+  id: string;
+  type: ActionType;
+  params: Record<string, unknown>;
+  created_at: string;
+  status: 'pending' | 'executing' | 'completed' | 'failed';
+}
+
+export interface ActionResult {
+  id: string;
+  ok: boolean;
+  result?: Record<string, unknown>;
+  error?: string;
+  executed_at: string;
+}
+
+// ─── Relay Client Types ───
+
+export interface RelayResponse<T> {
+  ok: boolean;
+  data?: T;
+  error?: string;
+}