@ateam-ai-mobile/expo 0.1.4 → 0.1.7

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

@@ -0,0 +1,217 @@
+/**
+ * Calendar Action Executor — creates/modifies events via expo-calendar.
+ * Executes 'calendar.create', 'calendar.reschedule', 'calendar.cancel' actions.
+ */
+
+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.
+// Derived rather than imported — see collectors/calendar.ts.
+type Event = Awaited<ReturnType<typeof ExpoCalendar.getEventsAsync>>[number];
+import type { ActionResult } from '../types';
+
+/**
+ * Get the default calendar ID for creating events.
+ */
+async function getDefaultCalendarId(): Promise<string | null> {
+  const calendars = await ExpoCalendar.getCalendarsAsync(ExpoCalendar.EntityTypes.EVENT);
+
+  // Prefer the default calendar
+  const defaultCal = calendars.find(c => c.isPrimary) || calendars[0];
+  return defaultCal?.id || null;
+}
+
+/**
+ * Execute a calendar.create action.
+ *
+ * Params expected:
+ *   - title: string
+ *   - date: string (YYYY-MM-DD)
+ *   - start_time: string (HH:MM)
+ *   - end_time?: string (HH:MM)
+ *   - location?: string
+ *   - attendees?: string[] (names — no email lookup here)
+ *   - notes?: string
+ */
+export async function executeCreate(
+  actionId: string,
+  params: Record<string, unknown>
+): Promise<ActionResult> {
+  const title = params.title as string;
+  const date = params.date as string;
+  const startTime = params.start_time as string;
+  const endTime = params.end_time as string | undefined;
+
+  if (!title || !date || !startTime) {
+    return {
+      id: actionId,
+      ok: false,
+      error: 'Missing title, date, or start_time',
+      executed_at: new Date().toISOString(),
+    };
+  }
+
+  try {
+    const calendarId = await getDefaultCalendarId();
+    if (!calendarId) {
+      return {
+        id: actionId,
+        ok: false,
+        error: 'No calendar found on device',
+        executed_at: new Date().toISOString(),
+      };
+    }
+
+    const [year, month, day] = date.split('-').map(Number);
+    const [startH, startM] = startTime.split(':').map(Number);
+
+    const startDate = new Date(year, month - 1, day, startH, startM);
+    let endDate: Date;
+
+    if (endTime) {
+      const [endH, endM] = endTime.split(':').map(Number);
+      endDate = new Date(year, month - 1, day, endH, endM);
+    } else {
+      // Default 1 hour duration
+      endDate = new Date(startDate.getTime() + 60 * 60 * 1000);
+    }
+
+    const eventId = await ExpoCalendar.createEventAsync(calendarId, {
+      title,
+      startDate,
+      endDate,
+      location: (params.location as string) || undefined,
+      notes: (params.notes as string) || undefined,
+      timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    });
+
+    return {
+      id: actionId,
+      ok: true,
+      result: {
+        event_id: eventId,
+        title,
+        date,
+        start: startTime,
+        end: endTime || formatTime(endDate),
+        message: `Event "${title}" created successfully`,
+      },
+      executed_at: new Date().toISOString(),
+    };
+  } catch (error) {
+    return {
+      id: actionId,
+      ok: false,
+      error: `Calendar create failed: ${error instanceof Error ? error.message : String(error)}`,
+      executed_at: new Date().toISOString(),
+    };
+  }
+}
+
+/**
+ * Execute a calendar.reschedule action.
+ *
+ * Params expected:
+ *   - event_id: string
+ *   - new_date?: string (YYYY-MM-DD)
+ *   - new_start_time?: string (HH:MM)
+ *   - new_end_time?: string (HH:MM)
+ */
+export async function executeReschedule(
+  actionId: string,
+  params: Record<string, unknown>
+): Promise<ActionResult> {
+  const eventId = params.event_id as string;
+
+  if (!eventId) {
+    return {
+      id: actionId,
+      ok: false,
+      error: 'Missing event_id',
+      executed_at: new Date().toISOString(),
+    };
+  }
+
+  try {
+    const updates: Partial<Event> = {};
+
+    if (params.new_date && params.new_start_time) {
+      const [year, month, day] = (params.new_date as string).split('-').map(Number);
+      const [h, m] = (params.new_start_time as string).split(':').map(Number);
+      updates.startDate = new Date(year, month - 1, day, h, m);
+
+      if (params.new_end_time) {
+        const [eh, em] = (params.new_end_time as string).split(':').map(Number);
+        updates.endDate = new Date(year, month - 1, day, eh, em);
+      } else {
+        updates.endDate = new Date(updates.startDate.getTime() + 60 * 60 * 1000);
+      }
+    }
+
+    await ExpoCalendar.updateEventAsync(eventId, updates);
+
+    return {
+      id: actionId,
+      ok: true,
+      result: { event_id: eventId, message: 'Event rescheduled successfully' },
+      executed_at: new Date().toISOString(),
+    };
+  } catch (error) {
+    return {
+      id: actionId,
+      ok: false,
+      error: `Calendar reschedule failed: ${error instanceof Error ? error.message : String(error)}`,
+      executed_at: new Date().toISOString(),
+    };
+  }
+}
+
+/**
+ * Execute a calendar.cancel action.
+ *
+ * Params expected:
+ *   - event_id: string
+ */
+export async function executeCancel(
+  actionId: string,
+  params: Record<string, unknown>
+): Promise<ActionResult> {
+  const eventId = params.event_id as string;
+
+  if (!eventId) {
+    return {
+      id: actionId,
+      ok: false,
+      error: 'Missing event_id',
+      executed_at: new Date().toISOString(),
+    };
+  }
+
+  try {
+    await ExpoCalendar.deleteEventAsync(eventId);
+
+    return {
+      id: actionId,
+      ok: true,
+      result: { event_id: eventId, message: 'Event cancelled successfully' },
+      executed_at: new Date().toISOString(),
+    };
+  } catch (error) {
+    return {
+      id: actionId,
+      ok: false,
+      error: `Calendar cancel failed: ${error instanceof Error ? error.message : String(error)}`,
+      executed_at: new Date().toISOString(),
+    };
+  }
+}
+
+// ─── Helpers ───
+
+function formatTime(date: Date): string {
+  return date.toLocaleTimeString('en-US', {
+    hour: '2-digit',
+    minute: '2-digit',
+    hour12: false,
+  });
+}

package/src/device-bridge/actions/dnd.ts

@@ -0,0 +1,74 @@
+/**
+ * DND Action Executor — manages Do Not Disturb via expo-notifications.
+ * Executes 'dnd.set' actions from the action queue.
+ *
+ * Note: True system-level DND control requires platform-specific APIs:
+ * - iOS: Focus modes (requires entitlements)
+ * - Android: NotificationManager.setInterruptionFilter (requires DND access)
+ *
+ * For now, this manages DND state within the PA system:
+ * - Stores DND state in relay for the connector to read
+ * - Controls notification channel behavior in-app
+ */
+
+import type { ActionResult, DndState } from '../types';
+
+// In-memory DND state (synced to relay)
+let currentDndState: DndState = {
+  enabled: false,
+  schedule: { start: '22:00', end: '07:00' },
+  allowlist: [],
+};
+
+/**
+ * Get current DND state.
+ */
+export function getState(): DndState {
+  return { ...currentDndState };
+}
+
+/**
+ * Execute a dnd.set action.
+ *
+ * Params expected:
+ *   - enabled?: boolean
+ *   - schedule_start?: string (HH:MM)
+ *   - schedule_end?: string (HH:MM)
+ *   - allowlist?: string[]
+ */
+export async function execute(
+  actionId: string,
+  params: Record<string, unknown>
+): Promise<ActionResult> {
+  try {
+    if (params.enabled !== undefined) {
+      currentDndState.enabled = params.enabled as boolean;
+    }
+    if (params.schedule_start) {
+      currentDndState.schedule.start = params.schedule_start as string;
+    }
+    if (params.schedule_end) {
+      currentDndState.schedule.end = params.schedule_end as string;
+    }
+    if (params.allowlist) {
+      currentDndState.allowlist = params.allowlist as string[];
+    }
+
+    return {
+      id: actionId,
+      ok: true,
+      result: {
+        message: `DND ${currentDndState.enabled ? 'enabled' : 'disabled'}`,
+        dnd: currentDndState,
+      },
+      executed_at: new Date().toISOString(),
+    };
+  } catch (error) {
+    return {
+      id: actionId,
+      ok: false,
+      error: `DND set failed: ${error instanceof Error ? error.message : String(error)}`,
+      executed_at: new Date().toISOString(),
+    };
+  }
+}

package/src/device-bridge/actions/health-actions.ts

@@ -0,0 +1,58 @@
+/**
+ * Health Action Executor — on-demand reads from HealthKit.
+ *
+ * Two action types:
+ *   - 'health.today'        → returns one HealthDayMetrics for today
+ *   - 'health.history'      → returns last N days (1..30), newest-first
+ *
+ * Both are read-only; no params are required for `today`.
+ * `history` accepts { days: number } (default 30).
+ *
+ * For periodic snapshots use the `health` capability instead — this
+ * executor exists so a connector can pull fresher / longer-range data
+ * without waiting for the next sync tick.
+ */
+import * as health from '../collectors/health';
+import type { ActionResult } from '../types';
+
+export async function executeToday(actionId: string): Promise<ActionResult> {
+  try {
+    const today = await health.collectToday();
+    return {
+      id: actionId,
+      ok: true,
+      result: { today },
+      executed_at: new Date().toISOString(),
+    };
+  } catch (e: any) {
+    return {
+      id: actionId,
+      ok: false,
+      error: String(e?.message || e),
+      executed_at: new Date().toISOString(),
+    };
+  }
+}
+
+export async function executeHistory(
+  actionId: string,
+  params: Record<string, unknown>,
+): Promise<ActionResult> {
+  try {
+    const days = Number(params?.days) || 30;
+    const list = await health.collectHistory(days);
+    return {
+      id: actionId,
+      ok: true,
+      result: { days: list },
+      executed_at: new Date().toISOString(),
+    };
+  } catch (e: any) {
+    return {
+      id: actionId,
+      ok: false,
+      error: String(e?.message || e),
+      executed_at: new Date().toISOString(),
+    };
+  }
+}

package/src/device-bridge/actions/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Action Executors — handle write operations queued by MCP skills.
+ * The phone polls for pending actions and executes them natively.
+ */
+
+export { QueuePoller } from './queue-poller';
+export type { QueuePollerConfig } from './queue-poller';
+export * as messaging from './messaging';
+export * as calendarActions from './calendar-actions';
+export * as dnd from './dnd';
+export * as navigation from './navigation';
+export * as healthActions from './health-actions';

package/src/device-bridge/actions/messaging.ts

@@ -0,0 +1,74 @@
+/**
+ * Messaging Action Executor — sends SMS via expo-sms.
+ * Executes 'messaging.send' actions from the action queue.
+ */
+
+import * as SMS from 'expo-sms';
+import type { ActionResult } from '../types';
+
+/**
+ * Check if SMS is available on this device.
+ */
+export async function isAvailable(): Promise<boolean> {
+  return SMS.isAvailableAsync();
+}
+
+/**
+ * Execute a messaging.send action.
+ *
+ * Params expected:
+ *   - contact_name: string (for display only)
+ *   - phone: string (phone number to send to)
+ *   - message: string (message text)
+ */
+export async function execute(
+  actionId: string,
+  params: Record<string, unknown>
+): Promise<ActionResult> {
+  const phone = params.phone as string;
+  const message = params.message as string;
+
+  if (!phone || !message) {
+    return {
+      id: actionId,
+      ok: false,
+      error: 'Missing phone or message parameter',
+      executed_at: new Date().toISOString(),
+    };
+  }
+
+  try {
+    const available = await SMS.isAvailableAsync();
+    if (!available) {
+      return {
+        id: actionId,
+        ok: false,
+        error: 'SMS not available on this device',
+        executed_at: new Date().toISOString(),
+      };
+    }
+
+    // Opens the native SMS compose screen with pre-filled content
+    const { result } = await SMS.sendSMSAsync([phone], message);
+
+    return {
+      id: actionId,
+      ok: result === 'sent' || result === 'unknown', // 'unknown' on Android means it was sent
+      result: {
+        to: params.contact_name || phone,
+        phone,
+        message,
+        status: result,
+        sent_at: new Date().toISOString(),
+      },
+      executed_at: new Date().toISOString(),
+    };
+  } catch (error) {
+    return {
+      id: actionId,
+      ok: false,
+      error: `SMS send failed: ${error instanceof Error ? error.message : String(error)}`,
+      executed_at: new Date().toISOString(),
+    };
+  }
+}

package/src/device-bridge/actions/navigation.ts

@@ -0,0 +1,88 @@
+/**
+ * Navigation Action Executor — opens maps app via expo-linking.
+ * Executes 'navigation.start' actions from the action queue.
+ */
+
+import * as Linking from 'expo-linking';
+import { Platform } from 'react-native';
+import type { ActionResult } from '../types';
+
+/**
+ * Execute a navigation.start action.
+ * Opens the native maps app with turn-by-turn directions.
+ *
+ * Params expected:
+ *   - destination: string (address or place name)
+ *   - mode?: 'driving' | 'transit' | 'walking' (default: 'driving')
+ */
+export async function execute(
+  actionId: string,
+  params: Record<string, unknown>
+): Promise<ActionResult> {
+  const destination = params.destination as string;
+  const mode = (params.mode as string) || 'driving';
+
+  if (!destination) {
+    return {
+      id: actionId,
+      ok: false,
+      error: 'Missing destination parameter',
+      executed_at: new Date().toISOString(),
+    };
+  }
+
+  try {
+    const encodedDest = encodeURIComponent(destination);
+    let url: string;
+
+    if (Platform.OS === 'ios') {
+      // Apple Maps with directions
+      const modeMap: Record<string, string> = {
+        driving: 'd',
+        transit: 'r',
+        walking: 'w',
+      };
+      url = `maps://maps.apple.com/?daddr=${encodedDest}&dirflg=${modeMap[mode] || 'd'}`;
+    } else {
+      // Google Maps on Android
+      const modeMap: Record<string, string> = {
+        driving: 'driving',
+        transit: 'transit',
+        walking: 'walking',
+      };
+      url = `google.navigation:q=${encodedDest}&mode=${modeMap[mode] || 'driving'}`;
+    }
+
+    const canOpen = await Linking.canOpenURL(url);
+    if (!canOpen) {
+      // Fallback to Google Maps web URL
+      const webModeMap: Record<string, string> = {
+        driving: 'driving',
+        transit: 'transit',
+        walking: 'walking',
+      };
+      url = `https://www.google.com/maps/dir/?api=1&destination=${encodedDest}&travelmode=${webModeMap[mode] || 'driving'}`;
+    }
+
+    await Linking.openURL(url);
+
+    return {
+      id: actionId,
+      ok: true,
+      result: {
+        message: `Navigation started to ${destination} via ${mode}`,
+        destination,
+        mode,
+        status: 'navigating',
+      },
+      executed_at: new Date().toISOString(),
+    };
+  } catch (error) {
+    return {
+      id: actionId,
+      ok: false,
+      error: `Navigation failed: ${error instanceof Error ? error.message : String(error)}`,
+      executed_at: new Date().toISOString(),
+    };
+  }
+}

package/src/device-bridge/actions/queue-poller.ts

@@ -0,0 +1,151 @@
+/**
+ * Action Queue Poller — polls the relay for pending actions and executes them.
+ * Routes each action to the appropriate executor based on action type.
+ */
+
+import type { RelayClient } from '../relay-client';
+import type { PendingAction, ActionResult, ActionType } from '../types';
+import * as messaging from './messaging';
+import * as calendarActions from './calendar-actions';
+import * as dnd from './dnd';
+import * as navigation from './navigation';
+import * as healthActions from './health-actions';
+
+export interface QueuePollerConfig {
+  /** Polling interval in ms (default: 5000) */
+  pollInterval?: number;
+  /** Relay client instance */
+  relayClient: RelayClient;
+  /** Callback when an action is executed */
+  onActionExecuted?: (result: ActionResult) => void;
+  /** Callback for errors */
+  onError?: (error: Error) => void;
+}
+
+export class QueuePoller {
+  private relayClient: RelayClient;
+  private pollInterval: number;
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private running = false;
+  private onActionExecuted?: (result: ActionResult) => void;
+  private onError?: (error: Error) => void;
+
+  constructor(config: QueuePollerConfig) {
+    this.relayClient = config.relayClient;
+    this.pollInterval = config.pollInterval ?? 5_000;
+    this.onActionExecuted = config.onActionExecuted;
+    this.onError = config.onError;
+  }
+
+  /**
+   * Start polling for actions.
+   */
+  start(): void {
+    if (this.running) return;
+    this.running = true;
+
+    // Poll immediately, then on interval
+    this.poll();
+    this.timer = setInterval(() => this.poll(), this.pollInterval);
+  }
+
+  /**
+   * Stop polling.
+   */
+  stop(): void {
+    this.running = false;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  /**
+   * Check if poller is running.
+   */
+  isRunning(): boolean {
+    return this.running;
+  }
+
+  /**
+   * Execute a single poll cycle.
+   */
+  private async poll(): Promise<void> {
+    if (!this.running) return;
+
+    try {
+      const response = await this.relayClient.pollActions();
+      if (!response.ok || !response.data) return;
+
+      for (const action of response.data) {
+        // The relay only ever returns pending actions — it filters in the
+        // query. A missing status therefore means "the server didn't say",
+        // not "already handled", and treating it as the latter discarded
+        // every queued action while every write tool still answered "queued".
+        // Only an explicitly non-pending status is skipped.
+        if (action.status && action.status !== 'pending') continue;
+
+        const result = await this.executeAction(action);
+
+        // Report result back to relay
+        await this.relayClient.completeAction(result);
+
+        this.onActionExecuted?.(result);
+      }
+    } catch (error) {
+      this.onError?.(
+        error instanceof Error ? error : new Error(String(error))
+      );
+    }
+  }
+
+  /**
+   * Route an action to the appropriate executor.
+   */
+  private async executeAction(action: PendingAction): Promise<ActionResult> {
+    const { id, type, params } = action;
+
+    try {
+      switch (type as ActionType) {
+        case 'messaging.send':
+          return await messaging.execute(id, params);
+
+        case 'calendar.create':
+          return await calendarActions.executeCreate(id, params);
+
+        case 'calendar.reschedule':
+          return await calendarActions.executeReschedule(id, params);
+
+        case 'calendar.cancel':
+          return await calendarActions.executeCancel(id, params);
+
+        case 'dnd.set':
+          return await dnd.execute(id, params);
+
+        case 'navigation.start':
+          return await navigation.execute(id, params);
+
+        case 'health.today':
+          return await healthActions.executeToday(id);
+
+        case 'health.history':
+          return await healthActions.executeHistory(id, params);
+
+        default:
+          return {
+            id,
+            ok: false,
+            error: `Unknown action type: ${type}`,
+            executed_at: new Date().toISOString(),
+          };
+      }
+    } catch (error) {
+      return {
+        id,
+        ok: false,
+        error: `Action execution failed: ${error instanceof Error ? error.message : String(error)}`,
+        executed_at: new Date().toISOString(),
+      };
+    }
+  }
+}