@ateam-ai-mobile/expo 0.1.0

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@ateam-ai-mobile/expo",
+  "version": "0.1.0",
+  "description": "Expo-backed providers for the ADAS SDK \u2014 haptics, bundle disk cache, attachment cache, device bridge.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "tsup"
+  },
+  "dependencies": {
+    "@ateam-ai-mobile/core": "0.1.0",
+    "@ateam-ai-mobile/plugin-runtime": "0.1.0",
+    "@ateam-ai-mobile/ui": "0.1.0"
+  },
+  "peerDependencies": {
+    "@react-native-async-storage/async-storage": "*",
+    "expo-battery": "*",
+    "expo-calendar": "*",
+    "expo-contacts": "*",
+    "expo-device": "*",
+    "expo-file-system": "*",
+    "expo-haptics": "*",
+    "expo-linking": "*",
+    "expo-location": "*",
+    "expo-network": "*",
+    "expo-notifications": "*",
+    "expo-sms": "*",
+    "expo-web-browser": "*",
+    "react": ">=18",
+    "react-native": "*",
+    "expo-clipboard": "*"
+  },
+  "peerDependenciesMeta": {
+    "expo-battery": {
+      "optional": true
+    },
+    "expo-calendar": {
+      "optional": true
+    },
+    "expo-contacts": {
+      "optional": true
+    },
+    "expo-device": {
+      "optional": true
+    },
+    "expo-location": {
+      "optional": true
+    },
+    "expo-network": {
+      "optional": true
+    },
+    "expo-notifications": {
+      "optional": true
+    },
+    "expo-sms": {
+      "optional": true
+    }
+  },
+  "exports": {
+    ".": {
+      "react-native": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./bridge": {
+      "react-native": "./src/createBridge.ts",
+      "types": "./dist/createBridge.d.ts",
+      "import": "./dist/createBridge.mjs",
+      "require": "./dist/createBridge.js"
+    }
+  },
+  "module": "dist/index.mjs",
+  "source": "src/index.ts",
+  "react-native": "src/index.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/attachmentCache.ts

@@ -0,0 +1,75 @@
+/**
+ * Expo implementation of @ateam-ai-mobile/core's AttachmentCache: attachment bytes on
+ * disk, index in AsyncStorage. Mirrors the reference app's chat attachment
+ * cache (last-100 retention).
+ */
+import * as FileSystem from 'expo-file-system/legacy';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import type { AttachmentCache, AttachmentPreview, OutgoingAttachment } from '@ateam-ai-mobile/core';
+
+const INDEX_KEY = 'adas-chat-attachment-index-v1';
+const DIR = `${FileSystem.documentDirectory}chat-attachments/`;
+const MAX_JOBS = 100;
+
+interface CachedAttachment { mimeType: string; name: string; filePath: string }
+
+export class ExpoAttachmentCache implements AttachmentCache {
+  private index: Record<string, CachedAttachment[]> = {};
+  private loaded: Promise<void>;
+
+  constructor() {
+    this.loaded = (async () => {
+      try {
+        const info = await FileSystem.getInfoAsync(DIR);
+        if (!info.exists) await FileSystem.makeDirectoryAsync(DIR, { intermediates: true });
+        const raw = await AsyncStorage.getItem(INDEX_KEY);
+        if (raw) this.index = JSON.parse(raw);
+      } catch {}
+    })();
+  }
+
+  async ready(): Promise<void> {
+    await this.loaded;
+  }
+
+  async save(jobId: string, attachments: OutgoingAttachment[]): Promise<void> {
+    await this.loaded;
+    const entries: CachedAttachment[] = [];
+    for (let i = 0; i < attachments.length; i++) {
+      const att = attachments[i];
+      const ext = att.mimeType.startsWith('image/') ? att.mimeType.split('/')[1] || 'jpg' : 'bin';
+      const filePath = `${DIR}${jobId}_${i}.${ext}`;
+      try {
+        await FileSystem.writeAsStringAsync(filePath, att.data, { encoding: FileSystem.EncodingType.Base64 });
+        entries.push({ mimeType: att.mimeType, name: att.name, filePath });
+      } catch (err) {
+        console.warn('[ExpoAttachmentCache] write failed:', err);
+      }
+    }
+    if (entries.length === 0) return;
+
+    this.index[jobId] = entries;
+    // Keep only the most recent MAX_JOBS jobs; delete evicted files.
+    const keys = Object.keys(this.index);
+    if (keys.length > MAX_JOBS) {
+      for (const k of keys.slice(0, keys.length - MAX_JOBS)) {
+        const old = this.index[k];
+        if (old) for (const o of old) FileSystem.deleteAsync(o.filePath, { idempotent: true }).catch(() => {});
+        delete this.index[k];
+      }
+    }
+    try {
+      await AsyncStorage.setItem(INDEX_KEY, JSON.stringify(this.index));
+    } catch {}
+  }
+
+  get(jobId: string): AttachmentPreview[] | undefined {
+    const entries = this.index[jobId];
+    if (!entries || entries.length === 0) return undefined;
+    return entries.map(e => ({
+      mimeType: e.mimeType,
+      name: e.name,
+      previewUri: e.filePath,
+    }));
+  }
+}

package/src/bundleStorage.ts

@@ -0,0 +1,72 @@
+/**
+ * Disk-backed BundleStorage: bundle files in the Expo cache directory,
+ * index in AsyncStorage. Mirrors the reference app's cache semantics
+ * (index version key, files under plugin-bundles/).
+ */
+import * as FileSystem from 'expo-file-system/legacy';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import type { BundleStorage, BundleCacheEntry } from '@ateam-ai-mobile/plugin-runtime';
+
+const CACHE_DIR = `${FileSystem.cacheDirectory}plugin-bundles/`;
+const CACHE_INDEX_KEY = 'adas-plugin-bundles-index-v1';
+
+export class ExpoBundleStorage implements BundleStorage {
+  private dirReady = false;
+
+  private async ensureDir(): Promise<void> {
+    if (this.dirReady) return;
+    try {
+      const info = await FileSystem.getInfoAsync(CACHE_DIR);
+      if (!info.exists) {
+        await FileSystem.makeDirectoryAsync(CACHE_DIR, { intermediates: true });
+      }
+    } catch (err) {
+      console.warn('[ExpoBundleStorage] cache dir error:', err);
+    }
+    this.dirReady = true;
+  }
+
+  async loadIndex(): Promise<Record<string, BundleCacheEntry>> {
+    try {
+      const raw = await AsyncStorage.getItem(CACHE_INDEX_KEY);
+      return raw ? JSON.parse(raw) : {};
+    } catch {
+      return {};
+    }
+  }
+
+  async saveIndex(index: Record<string, BundleCacheEntry>): Promise<void> {
+    try {
+      await AsyncStorage.setItem(CACHE_INDEX_KEY, JSON.stringify(index));
+    } catch (err) {
+      console.warn('[ExpoBundleStorage] index save error:', err);
+    }
+  }
+
+  async readBundle(localPath: string): Promise<string | null> {
+    try {
+      const info = await FileSystem.getInfoAsync(localPath);
+      if (!info.exists) return null;
+      return await FileSystem.readAsStringAsync(localPath);
+    } catch {
+      return null; // file gone — caller re-downloads
+    }
+  }
+
+  async writeBundle(key: string, content: string): Promise<string> {
+    await this.ensureDir();
+    const localPath = `${CACHE_DIR}${key}`;
+    await FileSystem.writeAsStringAsync(localPath, content);
+    return localPath;
+  }
+
+  async deleteBundle(localPath: string): Promise<void> {
+    await FileSystem.deleteAsync(localPath, { idempotent: true }).catch(() => {});
+  }
+
+  async clearAll(): Promise<void> {
+    await FileSystem.deleteAsync(CACHE_DIR, { idempotent: true }).catch(() => {});
+    await AsyncStorage.removeItem(CACHE_INDEX_KEY).catch(() => {});
+    this.dirReady = false;
+  }
+}