@mobileai/react-native 0.9.10 → 0.9.12

package/src/services/telemetry/device.ts

@@ -1,16 +1,93 @@
-import { Platform } from 'react-native';
+/**
+ * Persistent device ID — a UUID generated on first launch and stored in AsyncStorage.
+ * Unique per app install, survives across sessions.
+ *
+ * AsyncStorage is an optional peer dependency — if not installed, the ID
+ * persists only in memory for the current session.
+ */
+
+const STORAGE_KEY = '@mobileai:device_id';
+
+let _cachedId: string | null = null;
+let _storageLoaded = false;
+let _storage: any = null;
+
+function loadStorage(): any {
+  if (_storageLoaded) return _storage;
+  _storageLoaded = true;
+  try {
+    // Suppress the RN red box that AsyncStorage triggers when its native module
+    // isn't linked ("NativeModule: AsyncStorage is null").
+    const origError = console.error;
+    console.error = (...args: unknown[]) => {
+      const msg = args[0];
+      if (typeof msg === 'string' && msg.includes('AsyncStorage')) return;
+      origError.apply(console, args);
+    };
+    try {
+      const mod = require('@react-native-async-storage/async-storage');
+      const candidate = mod.default ?? mod;
+      if (candidate && typeof candidate.getItem === 'function') {
+        _storage = candidate;
+      }
+    } finally {
+      console.error = origError;
+    }
+  } catch {
+    // Not installed — device ID won't persist across restarts
+  }
+  return _storage;
+}
+
+function generateUUID(): string {
+  if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+}
 
 /**
- * Deterministic device ID based on platform info.
- * This ensures analytics and flags remain consistent across sessions
- * without collecting PII hardware identifiers.
+ * Returns the persistent device ID synchronously (from cache).
+ * Returns null if not yet initialized.
  */
-export function getDeviceId(): string {
-  const raw = `${Platform.OS}_${Platform.Version}`;
-  let hash = 0;
-  for (let i = 0; i < raw.length; i++) {
-    hash = (hash << 5) - hash + raw.charCodeAt(i);
-    hash |= 0;
+export function getDeviceId(): string | null {
+  return _cachedId;
+}
+
+/**
+ * Initializes or retrieves the persistent device ID.
+ * Call once on app startup. Subsequent getDeviceId() calls are synchronous.
+ */
+export async function initDeviceId(): Promise<string> {
+  if (_cachedId) return _cachedId;
+
+  const storage = loadStorage();
+  if (storage) {
+    try {
+      const stored: string | null = await storage.getItem(STORAGE_KEY);
+      if (stored) {
+        _cachedId = stored;
+        return stored;
+      }
+    } catch {
+      // Storage read failed — continue with new ID
+    }
   }
-  return `dev_${Math.abs(hash).toString(36)}`;
+
+  const newId = generateUUID();
+  _cachedId = newId;
+
+  if (storage) {
+    try {
+      await storage.setItem(STORAGE_KEY, newId);
+    } catch {
+      // Storage write failed — ID works for this session only
+    }
+  }
+
+  return newId;
 }

package/src/services/telemetry/deviceMetadata.ts

@@ -0,0 +1,13 @@
+import { Platform } from 'react-native';
+
+export interface DeviceMetadata {
+  platform: string;
+  osVersion: string;
+}
+
+export function getDeviceMetadata(): DeviceMetadata {
+  return {
+    platform: Platform.OS === 'ios' ? 'iOS' : Platform.OS === 'android' ? 'Android' : Platform.OS,
+    osVersion: String(Platform.Version),
+  };
+}

package/src/support/EscalationEventSource.ts

@@ -0,0 +1,190 @@
+/**
+ * EscalationEventSource — SSE client using fetch + ReadableStream.
+ *
+ * Uses only the fetch API (available in all React Native runtimes)
+ * to consume Server-Sent Events — no EventSource polyfill needed.
+ * Provides a reliable, auto-reconnecting channel for server-push
+ * events like `ticket_closed` that complements the bidirectional
+ * WebSocket used for chat.
+ *
+ * Lifecycle:
+ * 1. SDK calls connect() → fetch with streaming response
+ * 2. Server holds connection open, pushes `ticket_closed` when agent resolves
+ * 3. On disconnect, auto-reconnects with exponential backoff (max 5 attempts)
+ * 4. If ticket is already closed, server responds immediately with the event
+ */
+
+import { logger } from '../utils/logger';
+
+export interface EscalationEventSourceOptions {
+  url: string;
+  onTicketClosed?: (ticketId: string) => void;
+  onConnected?: (ticketId: string) => void;
+  onError?: (error: Error) => void;
+}
+
+export class EscalationEventSource {
+  private abortController: AbortController | null = null;
+  private intentionalClose = false;
+  private reconnectAttempts = 0;
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private readonly maxReconnectAttempts = 5;
+  private readonly options: EscalationEventSourceOptions;
+
+  constructor(options: EscalationEventSourceOptions) {
+    this.options = options;
+  }
+
+  connect(): void {
+    this.intentionalClose = false;
+    this.reconnectAttempts = 0;
+    this.openConnection();
+  }
+
+  disconnect(): void {
+    this.intentionalClose = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+  }
+
+  private async openConnection(): Promise<void> {
+    if (this.intentionalClose) return;
+
+    this.abortController = new AbortController();
+
+    try {
+      const response = await fetch(this.options.url, {
+        signal: this.abortController.signal,
+        headers: { Accept: 'text/event-stream' },
+      });
+
+      if (!response.ok) {
+        logger.warn('EscalationSSE', 'Non-OK response:', response.status);
+        this.scheduleReconnect();
+        return;
+      }
+
+      if (!response.body) {
+        logger.warn('EscalationSSE', 'No readable body — falling back to reading full response');
+        await this.readFullResponse(response);
+        return;
+      }
+
+      this.reconnectAttempts = 0;
+      await this.readStream(response.body);
+    } catch (err) {
+      if (this.intentionalClose) return;
+      if ((err as Error).name === 'AbortError') return;
+      logger.warn('EscalationSSE', 'Connection error:', (err as Error).message);
+      this.options.onError?.(err as Error);
+      this.scheduleReconnect();
+    }
+  }
+
+  private async readStream(body: ReadableStream<Uint8Array>): Promise<void> {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop()!;
+
+        let currentEvent = '';
+        let currentData = '';
+
+        for (const line of lines) {
+          if (line.startsWith('event: ')) {
+            currentEvent = line.slice(7).trim();
+          } else if (line.startsWith('data: ')) {
+            currentData = line.slice(6).trim();
+          } else if (line === '' && currentEvent && currentData) {
+            this.handleEvent(currentEvent, currentData);
+            currentEvent = '';
+            currentData = '';
+          }
+        }
+      }
+    } catch (err) {
+      if (this.intentionalClose) return;
+      if ((err as Error).name === 'AbortError') return;
+      logger.warn('EscalationSSE', 'Stream read error:', (err as Error).message);
+    }
+
+    if (!this.intentionalClose) {
+      this.scheduleReconnect();
+    }
+  }
+
+  private async readFullResponse(response: Response): Promise<void> {
+    try {
+      const text = await response.text();
+      let currentEvent = '';
+      let currentData = '';
+
+      for (const line of text.split('\n')) {
+        if (line.startsWith('event: ')) {
+          currentEvent = line.slice(7).trim();
+        } else if (line.startsWith('data: ')) {
+          currentData = line.slice(6).trim();
+        } else if (line === '' && currentEvent && currentData) {
+          this.handleEvent(currentEvent, currentData);
+          currentEvent = '';
+          currentData = '';
+        }
+      }
+    } catch (err) {
+      if (this.intentionalClose) return;
+      logger.warn('EscalationSSE', 'Full response read error:', (err as Error).message);
+    }
+
+    if (!this.intentionalClose) {
+      this.scheduleReconnect();
+    }
+  }
+
+  private handleEvent(event: string, data: string): void {
+    try {
+      const parsed = JSON.parse(data);
+
+      if (event === 'connected') {
+        logger.info('EscalationSSE', 'Connected for ticket:', parsed.ticketId);
+        this.options.onConnected?.(parsed.ticketId);
+      } else if (event === 'ticket_closed') {
+        logger.info('EscalationSSE', 'Ticket closed event:', parsed.ticketId);
+        this.options.onTicketClosed?.(parsed.ticketId);
+        this.intentionalClose = true;
+        this.abortController?.abort();
+      }
+    } catch {
+      // ignore parse error
+    }
+  }
+
+  private scheduleReconnect(): void {
+    if (this.intentionalClose) return;
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      logger.warn('EscalationSSE', 'Max reconnect attempts reached — giving up');
+      return;
+    }
+
+    const delay = Math.min(1000 * 2 ** this.reconnectAttempts, 16_000);
+    this.reconnectAttempts++;
+    logger.info('EscalationSSE', `Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+
+    this.reconnectTimer = setTimeout(() => {
+      this.openConnection();
+    }, delay);
+  }
+}

package/src/support/EscalationSocket.ts

@@ -14,11 +14,13 @@
  * - Auto-reconnect on unexpected close (max 3 attempts, exponential backoff)
  */
 
-export type SocketReplyHandler = (reply: string) => void;
+export type SocketReplyHandler = (reply: string, ticketId?: string) => void;
 
 interface EscalationSocketOptions {
   onReply: SocketReplyHandler;
   onError?: (error: Event) => void;
+  onTypingChange?: (isTyping: boolean) => void;
+  onTicketClosed?: (ticketId?: string) => void;
   maxReconnectAttempts?: number;
 }
 
@@ -31,11 +33,15 @@ export class EscalationSocket {
 
   private readonly onReply: SocketReplyHandler;
   private readonly onError?: (error: Event) => void;
+  private readonly onTypingChange?: (isTyping: boolean) => void;
+  private readonly onTicketClosed?: (ticketId?: string) => void;
   private readonly maxReconnectAttempts: number;
 
   constructor(options: EscalationSocketOptions) {
     this.onReply = options.onReply;
     this.onError = options.onError;
+    this.onTypingChange = options.onTypingChange;
+    this.onTicketClosed = options.onTicketClosed;
     this.maxReconnectAttempts = options.maxReconnectAttempts ?? 3;
   }
 
@@ -45,6 +51,22 @@ export class EscalationSocket {
     this.openConnection();
   }
 
+  sendText(text: string): boolean {
+    if (this.ws?.readyState === 1) { // WebSocket.OPEN
+      this.ws.send(JSON.stringify({ type: 'user_message', content: text }));
+      return true;
+    }
+    return false;
+  }
+
+  sendTypingStatus(isTyping: boolean): boolean {
+    if (this.ws?.readyState === 1) {
+      this.ws.send(JSON.stringify({ type: isTyping ? 'typing_start' : 'typing_stop' }));
+      return true;
+    }
+    return false;
+  }
+
   disconnect(): void {
     this.intentionalClose = true;
     if (this.reconnectTimer) {
@@ -68,16 +90,33 @@ export class EscalationSocket {
     }
 
     this.ws.onopen = () => {
-      console.log('[EscalationSocket] Connected:', this.wsUrl);
+      console.log('[EscalationSocket] ✅ Connected to:', this.wsUrl);
       this.reconnectAttempts = 0;
     };
 
     this.ws.onmessage = (event) => {
       try {
-        const msg = JSON.parse(String(event.data));
-        if (msg.type === 'ping') return; // heartbeat — ignore
+        const rawData = String(event.data);
+        console.log('[EscalationSocket] Message received:', rawData);
+        const msg = JSON.parse(rawData);
+        if (msg.type === 'ping') {
+          console.log('[EscalationSocket] Heartbeat ping received');
+          return;
+        }
         if (msg.type === 'reply' && msg.reply) {
-          this.onReply(msg.reply);
+          console.log('[EscalationSocket] Human reply received:', msg.reply);
+          this.onTypingChange?.(false);
+          this.onReply(msg.reply, msg.ticketId);
+        } else if (msg.type === 'typing_start') {
+          this.onTypingChange?.(true);
+        } else if (msg.type === 'typing_stop') {
+          this.onTypingChange?.(false);
+        } else if (msg.type === 'ticket_closed') {
+          console.log('[EscalationSocket] Ticket closed by agent');
+          this.onTypingChange?.(false);
+          this.onTicketClosed?.(msg.ticketId);
+          this.intentionalClose = true;
+          this.ws?.close();
         }
       } catch {
         // Non-JSON message — ignore
@@ -85,13 +124,13 @@ export class EscalationSocket {
     };
 
     this.ws.onerror = (event) => {
-      console.error('[EscalationSocket] Error:', event);
+      console.error('[EscalationSocket] ❌ WebSocket error. URL was:', this.wsUrl, event);
       this.onError?.(event);
     };
 
-    this.ws.onclose = () => {
+    this.ws.onclose = (event) => {
+      console.warn(`[EscalationSocket] Connection closed. Code=${event.code} Reason="${event.reason}" Intentional=${this.intentionalClose}`);
       if (this.intentionalClose) return;
-      console.warn('[EscalationSocket] Connection closed unexpectedly');
       this.scheduleReconnect();
     };
   }