@ateam-ai-mobile/expo 0.1.0

package/dist/createBridge.mjs

@@ -0,0 +1,609 @@
+// src/createBridge.ts
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import * as ExpoCalendar from "expo-calendar";
+import * as ExpoContacts from "expo-contacts";
+import * as ExpoLocation from "expo-location";
+import * as ExpoBattery from "expo-battery";
+import * as ExpoNetwork from "expo-network";
+import * as ExpoNotifications from "expo-notifications";
+import * as ExpoSMS from "expo-sms";
+import * as ExpoLinking from "expo-linking";
+import { Platform } from "react-native";
+function createBridge(connectorId, deviceId) {
+  const storagePrefix = `connector:${connectorId}:`;
+  const log = {
+    info: (msg, data) => {
+      console.log(`[${connectorId}] ${msg}`, data || "");
+    },
+    warn: (msg, data) => {
+      console.warn(`[${connectorId}] ${msg}`, data || "");
+    },
+    error: (msg, data) => {
+      console.error(`[${connectorId}] ${msg}`, data || "");
+    }
+  };
+  const parseDateTime = (dateStr, timeStr) => {
+    const [year, month, day] = dateStr.split("-").map(Number);
+    const [hours, minutes] = timeStr.split(":").map(Number);
+    return new Date(year, month - 1, day, hours, minutes);
+  };
+  const formatDate = (date) => {
+    return date.toISOString().split("T")[0];
+  };
+  const getDayOfWeek = (date) => {
+    const days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+    return days[date.getDay()];
+  };
+  const addDays = (date, days) => {
+    const result = new Date(date);
+    result.setDate(result.getDate() + days);
+    return result;
+  };
+  const startOfDay = (date) => {
+    const result = new Date(date);
+    result.setHours(0, 0, 0, 0);
+    return result;
+  };
+  const endOfDay = (date) => {
+    const result = new Date(date);
+    result.setHours(23, 59, 59, 999);
+    return result;
+  };
+  const getCalendarIds = async () => {
+    try {
+      const calendars = await ExpoCalendar.getCalendarsAsync(ExpoCalendar.EntityTypes.EVENT);
+      return calendars.map((c) => c.id);
+    } catch (err) {
+      log.warn("Failed to get calendar IDs", err);
+      return [];
+    }
+  };
+  const getDefaultCalendarId = async () => {
+    try {
+      const calendars = await ExpoCalendar.getCalendarsAsync(ExpoCalendar.EntityTypes.EVENT);
+      return calendars.length > 0 ? calendars[0].id : "";
+    } catch (err) {
+      log.warn("Failed to get default calendar", err);
+      return "";
+    }
+  };
+  const formatCalendarEvent = (event) => {
+    return {
+      id: event.id,
+      title: event.title,
+      date: event.startDate ? formatDate(new Date(event.startDate)) : "",
+      start: event.startDate ? new Date(event.startDate).toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit" }) : "",
+      end: event.endDate ? new Date(event.endDate).toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit" }) : "",
+      location: event.location || "",
+      attendees: event.attendees ? event.attendees.map((a) => a.email || a.name) : [],
+      notes: event.notes || ""
+    };
+  };
+  const formatContact = (contact) => {
+    const phone = contact.phoneNumbers?.[0]?.number || null;
+    const email = contact.emails?.[0]?.email || null;
+    const birthday = contact.birthday ? `${contact.birthday.year}-${String(contact.birthday.month).padStart(2, "0")}-${String(contact.birthday.day).padStart(2, "0")}` : null;
+    return {
+      id: contact.id,
+      name: contact.name,
+      phone,
+      email,
+      relationship: contact.relationships?.[0]?.relationship || contact.contactType || "contact",
+      birthday,
+      notes: contact.note || ""
+    };
+  };
+  const classifyLocation = (geo) => {
+    const name = geo.name?.toLowerCase() || "";
+    if (name.includes("home")) return "home";
+    if (name.includes("work") || name.includes("office")) return "work";
+    if (name.includes("school") || name.includes("university")) return "school";
+    if (name.includes("gym") || name.includes("fitness")) return "fitness";
+    if (name.includes("hospital") || name.includes("clinic") || name.includes("medical")) return "medical";
+    return "other";
+  };
+  const formatPlace = (geo) => {
+    if (!geo) return "Unknown Location";
+    const name = geo.name || "";
+    const street = geo.street ? `${geo.street}` : "";
+    return name ? `${name} \u2014 ${street}` : street;
+  };
+  const formatAddress = (geo) => {
+    if (!geo) return "";
+    const parts = [geo.street, geo.city, geo.region, geo.postalCode].filter(Boolean);
+    return parts.join(", ");
+  };
+  const formatNotification = (notif) => {
+    return {
+      id: notif.request?.identifier || String(Math.random()),
+      app: notif.request?.content?.title || "Unknown",
+      title: notif.request?.content?.title || "",
+      body: notif.request?.content?.body || "",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      sender: null,
+      priority: "medium",
+      read: false
+    };
+  };
+  const mapBatteryState = (state) => {
+    if (state === ExpoBattery.BatteryState.CHARGING) return "charging";
+    if (state === ExpoBattery.BatteryState.FULL) return "full";
+    return "unplugged";
+  };
+  const bridge = {
+    calendar: {
+      async getToday() {
+        try {
+          const start = startOfDay(/* @__PURE__ */ new Date());
+          const end = endOfDay(/* @__PURE__ */ new Date());
+          const calendarIds = await getCalendarIds();
+          const events = await ExpoCalendar.getEventsAsync(calendarIds, start, end);
+          return {
+            date: formatDate(/* @__PURE__ */ new Date()),
+            day_of_week: getDayOfWeek(/* @__PURE__ */ new Date()),
+            events: events.map(formatCalendarEvent),
+            count: events.length
+          };
+        } catch (err) {
+          log.error("Failed to get today's calendar events", err);
+          return { date: formatDate(/* @__PURE__ */ new Date()), day_of_week: getDayOfWeek(/* @__PURE__ */ new Date()), events: [], count: 0 };
+        }
+      },
+      async getUpcoming(days = 7) {
+        try {
+          const start = /* @__PURE__ */ new Date();
+          const end = addDays(start, Math.min(days, 14));
+          const calendarIds = await getCalendarIds();
+          const events = await ExpoCalendar.getEventsAsync(calendarIds, start, end);
+          return {
+            from: formatDate(start),
+            days_ahead: days,
+            events: events.map(formatCalendarEvent),
+            count: events.length
+          };
+        } catch (err) {
+          log.error("Failed to get upcoming calendar events", err);
+          return { from: formatDate(/* @__PURE__ */ new Date()), days_ahead: days, events: [], count: 0 };
+        }
+      },
+      async create(event) {
+        try {
+          const calendarId = await getDefaultCalendarId();
+          if (!calendarId) throw new Error("No default calendar found");
+          const eventId = await ExpoCalendar.createEventAsync(calendarId, {
+            title: event.title,
+            startDate: parseDateTime(event.date, event.start_time),
+            endDate: parseDateTime(event.date, event.end_time || event.start_time),
+            location: event.location,
+            notes: event.notes
+          });
+          return { event_id: eventId };
+        } catch (err) {
+          log.error("Failed to create calendar event", err);
+          throw err;
+        }
+      },
+      async reschedule(params) {
+        try {
+          const updates = {};
+          if (params.new_date && params.new_start_time) {
+            updates.startDate = parseDateTime(params.new_date, params.new_start_time);
+          }
+          if (params.new_date && params.new_end_time) {
+            updates.endDate = parseDateTime(params.new_date, params.new_end_time);
+          }
+          await ExpoCalendar.updateEventAsync(params.event_id, updates);
+          return { ok: true };
+        } catch (err) {
+          log.error("Failed to reschedule event", err);
+          throw err;
+        }
+      },
+      async cancel(event_id) {
+        try {
+          await ExpoCalendar.deleteEventAsync(event_id);
+          return { ok: true };
+        } catch (err) {
+          log.error("Failed to cancel event", err);
+          throw err;
+        }
+      }
+    },
+    contacts: {
+      async search(query) {
+        try {
+          const { data } = await ExpoContacts.getContactsAsync({
+            fields: [
+              ExpoContacts.Fields.PhoneNumbers,
+              ExpoContacts.Fields.Emails,
+              ExpoContacts.Fields.Birthday,
+              ExpoContacts.Fields.Note,
+              ExpoContacts.Fields.Relationships
+            ]
+          });
+          const q = query.toLowerCase();
+          const filtered = data.filter(
+            (c) => c.name?.toLowerCase().includes(q) || c.note?.toLowerCase().includes(q)
+          );
+          return { contacts: filtered.map(formatContact), count: filtered.length };
+        } catch (err) {
+          log.error("Failed to search contacts", err);
+          return { contacts: [], count: 0 };
+        }
+      },
+      async get(idOrName) {
+        try {
+          const { data } = await ExpoContacts.getContactsAsync({
+            fields: [
+              ExpoContacts.Fields.PhoneNumbers,
+              ExpoContacts.Fields.Emails,
+              ExpoContacts.Fields.Birthday,
+              ExpoContacts.Fields.Note
+            ]
+          });
+          const contact = data.find((c) => c.id === idOrName || c.name === idOrName);
+          return contact ? formatContact(contact) : null;
+        } catch (err) {
+          log.error("Failed to get contact", err);
+          return null;
+        }
+      },
+      async getAll() {
+        try {
+          const { data } = await ExpoContacts.getContactsAsync({
+            fields: [
+              ExpoContacts.Fields.PhoneNumbers,
+              ExpoContacts.Fields.Emails,
+              ExpoContacts.Fields.Birthday,
+              ExpoContacts.Fields.Note,
+              ExpoContacts.Fields.Relationships
+            ],
+            sort: ExpoContacts.SortTypes.LastName
+          });
+          return { contacts: data.map(formatContact), count: data.length };
+        } catch (err) {
+          log.error("Failed to get all contacts", err);
+          return { contacts: [], count: 0 };
+        }
+      },
+      async birthdays(days = 30) {
+        try {
+          const { data } = await ExpoContacts.getContactsAsync({
+            fields: [ExpoContacts.Fields.Birthday]
+          });
+          const today = /* @__PURE__ */ new Date();
+          const futureDate = addDays(today, days);
+          const birthdays = data.filter((c) => c.birthday).map((c) => {
+            const birthday = c.birthday;
+            const thisYearBday = new Date(today.getFullYear(), birthday.month - 1, birthday.day);
+            if (thisYearBday < today) {
+              thisYearBday.setFullYear(today.getFullYear() + 1);
+            }
+            return {
+              name: c.name,
+              relationship: c.relationships?.[0]?.relationship || "contact",
+              birthday: `${birthday.year || "????"}-${String(birthday.month).padStart(2, "0")}-${String(birthday.day).padStart(2, "0")}`,
+              days_until: Math.floor((thisYearBday.getTime() - today.getTime()) / (1e3 * 60 * 60 * 24)),
+              is_today: thisYearBday.toDateString() === today.toDateString()
+            };
+          }).filter((b) => b.days_until >= 0 && b.days_until <= days);
+          return { birthdays, count: birthdays.length };
+        } catch (err) {
+          log.error("Failed to get birthdays", err);
+          return { birthdays: [], count: 0 };
+        }
+      }
+    },
+    location: {
+      async getCurrent() {
+        try {
+          const location = await ExpoLocation.getCurrentPositionAsync({
+            accuracy: ExpoLocation.Accuracy.Balanced
+          });
+          const [geo] = await ExpoLocation.reverseGeocodeAsync({
+            latitude: location.coords.latitude,
+            longitude: location.coords.longitude
+          });
+          return {
+            lat: location.coords.latitude,
+            lng: location.coords.longitude,
+            place: formatPlace(geo),
+            address: formatAddress(geo),
+            type: classifyLocation(geo),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        } catch (err) {
+          log.error("Failed to get current location", err);
+          throw err;
+        }
+      }
+    },
+    battery: {
+      async getStatus() {
+        try {
+          const [level, state, lowPower] = await Promise.all([
+            ExpoBattery.getBatteryLevelAsync(),
+            ExpoBattery.getBatteryStateAsync(),
+            ExpoBattery.isLowPowerModeEnabledAsync()
+          ]);
+          return {
+            ok: true,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            battery: {
+              level: Math.round(level * 100),
+              state: mapBatteryState(state),
+              low_power_mode: lowPower
+            }
+          };
+        } catch (err) {
+          log.error("Failed to get battery status", err);
+          throw err;
+        }
+      }
+    },
+    network: {
+      async getStatus() {
+        try {
+          const state = await ExpoNetwork.getNetworkStateAsync();
+          return {
+            type: state.type === ExpoNetwork.NetworkStateType.WIFI ? "wifi" : state.type === ExpoNetwork.NetworkStateType.CELLULAR ? "cellular" : "none",
+            is_connected: state.isConnected ?? false,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        } catch (err) {
+          log.error("Failed to get network status", err);
+          throw err;
+        }
+      }
+    },
+    notifications: {
+      async list() {
+        try {
+          const presented = await ExpoNotifications.getPresentedNotificationsAsync();
+          const notifications = presented.map(formatNotification);
+          return {
+            notifications,
+            total: notifications.length,
+            unread: notifications.filter((n) => !n.read).length
+          };
+        } catch (err) {
+          log.error("Failed to get notifications", err);
+          return { notifications: [], total: 0, unread: 0 };
+        }
+      }
+    },
+    sms: {
+      async isAvailable() {
+        try {
+          return await ExpoSMS.isAvailableAsync();
+        } catch (err) {
+          log.error("Failed to check SMS availability", err);
+          return false;
+        }
+      },
+      async send(phone, message) {
+        try {
+          const { result } = await ExpoSMS.sendSMSAsync([phone], message);
+          return {
+            ok: result === "sent" || result === "unknown",
+            status: result
+          };
+        } catch (err) {
+          log.error("Failed to send SMS", err);
+          throw err;
+        }
+      }
+    },
+    maps: {
+      async navigate(destination, mode = "driving") {
+        try {
+          const encoded = encodeURIComponent(destination);
+          const url = Platform.OS === "ios" ? `maps://maps.apple.com/?daddr=${encoded}&dirflg=${mode[0]}` : `google.navigation:q=${encoded}&mode=${mode}`;
+          const canOpen = await ExpoLinking.canOpenURL(url);
+          if (!canOpen) {
+            const fallbackUrl = `https://www.google.com/maps/search/${encoded}`;
+            await ExpoLinking.openURL(fallbackUrl);
+          } else {
+            await ExpoLinking.openURL(url);
+          }
+          return { ok: true, status: "navigating" };
+        } catch (err) {
+          log.error("Failed to navigate", err);
+          return { ok: false, status: "error" };
+        }
+      }
+    },
+    http: {
+      async get(url, headers = {}) {
+        try {
+          const res = await fetch(url, { headers });
+          const data = await res.json();
+          return {
+            ok: res.ok,
+            status: res.status,
+            data,
+            headers: Object.fromEntries(res.headers.entries())
+          };
+        } catch (err) {
+          log.error("HTTP GET failed", err);
+          throw err;
+        }
+      },
+      async post(url, body, headers = {}) {
+        try {
+          const res = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", ...headers },
+            body: JSON.stringify(body)
+          });
+          const data = await res.json();
+          return {
+            ok: res.ok,
+            status: res.status,
+            data,
+            headers: Object.fromEntries(res.headers.entries())
+          };
+        } catch (err) {
+          log.error("HTTP POST failed", err);
+          throw err;
+        }
+      },
+      async put(url, body, headers = {}) {
+        try {
+          const res = await fetch(url, {
+            method: "PUT",
+            headers: { "Content-Type": "application/json", ...headers },
+            body: JSON.stringify(body)
+          });
+          const data = await res.json();
+          return {
+            ok: res.ok,
+            status: res.status,
+            data,
+            headers: Object.fromEntries(res.headers.entries())
+          };
+        } catch (err) {
+          log.error("HTTP PUT failed", err);
+          throw err;
+        }
+      },
+      async delete(url, body, headers = {}) {
+        try {
+          const opts = {
+            method: "DELETE",
+            headers: { "Content-Type": "application/json", ...headers }
+          };
+          if (body) opts.body = JSON.stringify(body);
+          const res = await fetch(url, opts);
+          const data = await res.json();
+          return {
+            ok: res.ok,
+            status: res.status,
+            data,
+            headers: Object.fromEntries(res.headers.entries())
+          };
+        } catch (err) {
+          log.error("HTTP DELETE failed", err);
+          throw err;
+        }
+      }
+    },
+    storage: {
+      async get(key) {
+        try {
+          return await AsyncStorage.getItem(storagePrefix + key);
+        } catch (err) {
+          log.error(`Failed to get storage key: ${key}`, err);
+          return null;
+        }
+      },
+      async set(key, value) {
+        try {
+          await AsyncStorage.setItem(storagePrefix + key, value);
+        } catch (err) {
+          log.error(`Failed to set storage key: ${key}`, err);
+        }
+      },
+      async delete(key) {
+        try {
+          await AsyncStorage.removeItem(storagePrefix + key);
+        } catch (err) {
+          log.error(`Failed to delete storage key: ${key}`, err);
+        }
+      },
+      async keys() {
+        try {
+          const allKeys = await AsyncStorage.getAllKeys();
+          return allKeys.filter((k) => k.startsWith(storagePrefix)).map((k) => k.slice(storagePrefix.length));
+        } catch (err) {
+          log.error("Failed to list storage keys", err);
+          return [];
+        }
+      }
+    },
+    permissions: {
+      async check(capability) {
+        try {
+          switch (capability) {
+            case "calendar":
+              const cal = await ExpoCalendar.getCalendarPermissionsAsync();
+              return cal.status === "granted" ? "granted" : cal.status === "denied" ? "denied" : "not_requested";
+            case "contacts":
+              const con = await ExpoContacts.getPermissionsAsync();
+              return con.status === "granted" ? "granted" : con.status === "denied" ? "denied" : "not_requested";
+            case "location":
+              const loc = await ExpoLocation.getForegroundPermissionsAsync();
+              return loc.status === "granted" ? "granted" : loc.status === "denied" ? "denied" : "not_requested";
+            case "notifications":
+              const notif = await ExpoNotifications.getPermissionsAsync();
+              return notif.granted ? "granted" : notif.canAskAgain ? "not_requested" : "denied";
+            default:
+              return "not_requested";
+          }
+        } catch (err) {
+          log.error(`Failed to check permission: ${capability}`, err);
+          return "denied";
+        }
+      },
+      async request(capability) {
+        try {
+          switch (capability) {
+            case "calendar":
+              const cal = await ExpoCalendar.requestCalendarPermissionsAsync();
+              return cal.status === "granted";
+            case "contacts":
+              const con = await ExpoContacts.requestPermissionsAsync();
+              return con.status === "granted";
+            case "location":
+              const loc = await ExpoLocation.requestForegroundPermissionsAsync();
+              return loc.status === "granted";
+            case "notifications":
+              const notif = await ExpoNotifications.requestPermissionsAsync();
+              return notif.granted;
+            default:
+              return false;
+          }
+        } catch (err) {
+          log.error(`Failed to request permission: ${capability}`, err);
+          return false;
+        }
+      },
+      async getAll() {
+        try {
+          const [cal, con, loc, notif] = await Promise.allSettled([
+            ExpoCalendar.getCalendarPermissionsAsync(),
+            ExpoContacts.getPermissionsAsync(),
+            ExpoLocation.getForegroundPermissionsAsync(),
+            ExpoNotifications.getPermissionsAsync()
+          ]);
+          return {
+            calendar: cal.status === "fulfilled" ? cal.value.status === "granted" ? "granted" : cal.value.status === "denied" ? "denied" : "not_requested" : "denied",
+            contacts: con.status === "fulfilled" ? con.value.status === "granted" ? "granted" : con.value.status === "denied" ? "denied" : "not_requested" : "denied",
+            location: loc.status === "fulfilled" ? loc.value.status === "granted" ? "granted" : loc.value.status === "denied" ? "denied" : "not_requested" : "denied",
+            notifications: notif.status === "fulfilled" ? notif.value.granted ? "granted" : notif.value.canAskAgain ? "not_requested" : "denied" : "denied"
+          };
+        } catch (err) {
+          log.error("Failed to get all permissions", err);
+          return { calendar: "denied", contacts: "denied", location: "denied", notifications: "denied" };
+        }
+      }
+    },
+    device: {
+      getDeviceId() {
+        return deviceId;
+      },
+      getPlatform() {
+        return {
+          os: Platform.OS,
+          version: Platform.Version ? String(Platform.Version) : "unknown"
+        };
+      }
+    },
+    log
+  };
+  return bridge;
+}
+export {
+  createBridge
+};
+//# sourceMappingURL=createBridge.mjs.map