@ateam-ai-mobile/plugin-runtime 0.1.0

package/src/surfaces/SurfaceFullscreen.tsx

@@ -0,0 +1,207 @@
+/**
+ * SurfaceFullscreen — edge-to-edge takeover container for plugins
+ * (voice mode, focus modes, photo capture, etc.).
+ *
+ * Plugins render their content; SurfaceFullscreen provides:
+ * - Paper background, fade-in motion
+ * - Top status line ("ada" wordmark + status text)
+ * - Optional hero element above body (e.g. AdaOrb)
+ * - Bottom close button with label
+ * - Spring entry on the hero (scale 0.6 → 1)
+ *
+ * Usage:
+ *   <SurfaceFullscreen
+ *     visible={open}
+ *     onClose={hangUp}
+ *     status="Ada is speaking"
+ *     hero={<AdaOrb size={180} state="speaking" />}
+ *     closeIcon="hangup"
+ *     closeLabel="End"
+ *   >
+ *     <Transcript ... />
+ *   </SurfaceFullscreen>
+ */
+import { useEffect, useRef, type ReactNode } from 'react';
+import {
+  View,
+  Text,
+  Pressable,
+  StyleSheet,
+  Animated,
+  Platform,
+} from 'react-native';
+import Svg, { Path } from 'react-native-svg';
+import { ada } from '@ateam-ai-mobile/core';
+
+const fontFam = Platform.OS === 'ios' ? 'SF Pro Rounded' : undefined;
+
+export interface SurfaceFullscreenProps {
+  visible: boolean;
+  onClose: () => void;
+  /** Status text shown under the wordmark */
+  status?: string;
+  /** Optional hero element above body (typically an AdaOrb) */
+  hero?: ReactNode;
+  /** Body content */
+  children?: ReactNode;
+  /** Whether to show the small "ada" wordmark (default: true) */
+  showWordmark?: boolean;
+  /** Built-in close icon flavor or a custom node. Default: 'x' */
+  closeIcon?: 'x' | 'hangup' | ReactNode;
+  /** Label under the close button (default: "Close") */
+  closeLabel?: string;
+}
+
+export default function SurfaceFullscreen({
+  visible,
+  onClose,
+  status,
+  hero,
+  children,
+  showWordmark = true,
+  closeIcon = 'x',
+  closeLabel = 'Close',
+}: SurfaceFullscreenProps) {
+  const fadeAnim = useRef(new Animated.Value(0)).current;
+  const heroScale = useRef(new Animated.Value(0.6)).current;
+
+  useEffect(() => {
+    if (visible) {
+      Animated.parallel([
+        Animated.timing(fadeAnim, { toValue: 1, duration: 280, useNativeDriver: true }),
+        Animated.spring(heroScale, { toValue: 1, useNativeDriver: true, tension: 60, friction: 11 }),
+      ]).start();
+    } else {
+      fadeAnim.setValue(0);
+      heroScale.setValue(0.6);
+    }
+  }, [visible]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  const close = () => {
+    Animated.parallel([
+      Animated.timing(fadeAnim, { toValue: 0, duration: 180, useNativeDriver: true }),
+      Animated.timing(heroScale, { toValue: 0.6, duration: 180, useNativeDriver: true }),
+    ]).start(() => onClose());
+  };
+
+  if (!visible) return null;
+
+  const renderCloseIcon = () => {
+    if (closeIcon === 'hangup') {
+      return (
+        <Svg width={22} height={22} viewBox="0 0 24 24" fill={ada.paper}>
+          <Path d="M3.68 16.07l3.92-3.11c.28-.23.68-.28 1.01-.14l2.77 1.15c.36.15.61.5.61.89v2.82c4.34-.76 7.93-4.35 8.69-8.69h-2.82c-.39 0-.74-.25-.89-.61L16.12 5.6c-.13-.33-.09-.73.14-1.01l3.11-3.92c.29-.37.81-.41 1.15-.08l3.24 3.24c.2.2.31.47.31.76C24 14.44 14.44 24 4.59 24c-.29 0-.56-.11-.76-.31L.59 20.45c-.33-.34-.29-.86.09-1.15z" />
+        </Svg>
+      );
+    }
+    if (closeIcon === 'x') {
+      return (
+        <Svg width={20} height={20} viewBox="0 0 24 24" fill="none" stroke={ada.paper} strokeWidth={2.5} strokeLinecap="round">
+          <Path d="M18 6L6 18M6 6l12 12" />
+        </Svg>
+      );
+    }
+    return closeIcon;
+  };
+
+  return (
+    <Animated.View style={[styles.overlay, { opacity: fadeAnim }]} pointerEvents="auto">
+      {/* Top status */}
+      <View style={styles.topBar}>
+        {showWordmark ? <Text style={styles.wordmark}>ada</Text> : null}
+        {status ? <Text style={styles.status}>{status}</Text> : null}
+      </View>
+
+      {/* Optional hero (e.g. AdaOrb) — springs in */}
+      {hero ? (
+        <View style={styles.heroWrap}>
+          <Animated.View style={{ transform: [{ scale: heroScale }] }}>
+            {hero}
+          </Animated.View>
+        </View>
+      ) : null}
+
+      {/* Body — caller content */}
+      <View style={styles.body}>{children}</View>
+
+      {/* Bottom close */}
+      <View style={styles.bottomBar}>
+        <Pressable
+          accessibilityRole="button"
+          accessibilityLabel={closeLabel}
+          style={styles.closeBtn}
+          onPress={close}
+          hitSlop={12}
+        >
+          {renderCloseIcon()}
+        </Pressable>
+        {closeLabel ? <Text style={styles.closeLabel}>{closeLabel}</Text> : null}
+      </View>
+    </Animated.View>
+  );
+}
+
+const styles = StyleSheet.create({
+  overlay: {
+    position: 'absolute',
+    top: 0, left: 0, right: 0, bottom: 0,
+    backgroundColor: ada.paper,
+    zIndex: 1000,
+    elevation: 1000,
+  },
+  topBar: {
+    paddingTop: Platform.OS === 'ios' ? 64 : 36,
+    paddingHorizontal: 24,
+    alignItems: 'center',
+    gap: 6,
+  },
+  wordmark: {
+    fontSize: 14,
+    fontFamily: fontFam,
+    fontWeight: '500',
+    color: ada.inkMuted,
+    letterSpacing: 4,
+  },
+  status: {
+    fontSize: 17,
+    fontFamily: fontFam,
+    fontWeight: '500',
+    color: ada.ink,
+    letterSpacing: -0.2,
+  },
+  heroWrap: {
+    paddingTop: 24,
+    paddingBottom: 12,
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  body: {
+    flex: 1,
+  },
+  bottomBar: {
+    paddingBottom: Platform.OS === 'ios' ? 48 : 32,
+    paddingTop: 12,
+    alignItems: 'center',
+    gap: 8,
+  },
+  closeBtn: {
+    width: 64,
+    height: 64,
+    borderRadius: 32,
+    backgroundColor: ada.ink,
+    justifyContent: 'center',
+    alignItems: 'center',
+    shadowColor: ada.ink,
+    shadowOffset: { width: 0, height: 8 },
+    shadowOpacity: 0.18,
+    shadowRadius: 14,
+    elevation: 8,
+  },
+  closeLabel: {
+    fontSize: 13,
+    fontFamily: fontFam,
+    fontWeight: '500',
+    color: ada.inkMuted,
+    letterSpacing: 0.3,
+  },
+});

package/src/utils/sha256.ts

@@ -0,0 +1,85 @@
+/**
+ * Pure-JS SHA-256 — used to verify integrity of downloaded plugin bundles.
+ * Avoids pulling expo-crypto / a native module into the dependency graph for
+ * what amounts to a one-shot post-download check.
+ *
+ * Hot path: hash a ~100KB-1MB bundle once after download. Performance is
+ * acceptable on every supported device (sub-50ms).
+ *
+ * Algorithm reference: FIPS 180-4. Implementation derived from the public-
+ * domain reference code; see https://en.wikipedia.org/wiki/SHA-2#Pseudocode.
+ */
+
+const K = new Uint32Array([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+
+const rotr = (n: number, x: number) => (x >>> n) | (x << (32 - n));
+
+/** SHA-256 of a UTF-8 string. Returns the lowercase hex digest. */
+export function sha256Hex(message: string): string {
+  // 1. Encode to UTF-8 bytes
+  const utf8 = unescape(encodeURIComponent(message));
+  const bytes = new Uint8Array(utf8.length);
+  for (let i = 0; i < utf8.length; i++) bytes[i] = utf8.charCodeAt(i);
+
+  // 2. Pre-processing: append 0x80, pad with zeros, then append 64-bit big-endian length
+  const bitLen = bytes.length * 8;
+  const padLen = (56 - (bytes.length + 1) % 64 + 64) % 64;
+  const buf = new Uint8Array(bytes.length + 1 + padLen + 8);
+  buf.set(bytes);
+  buf[bytes.length] = 0x80;
+  // 64-bit big-endian length (high 32 bits zeroed — bundles are well under 2^32 bits)
+  const len = buf.length;
+  buf[len - 4] = (bitLen >>> 24) & 0xff;
+  buf[len - 3] = (bitLen >>> 16) & 0xff;
+  buf[len - 2] = (bitLen >>> 8) & 0xff;
+  buf[len - 1] = bitLen & 0xff;
+
+  const h = new Uint32Array([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+    0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+  ]);
+  const w = new Uint32Array(64);
+
+  // 3. Process each 512-bit chunk
+  for (let i = 0; i < buf.length; i += 64) {
+    for (let t = 0; t < 16; t++) {
+      const j = i + t * 4;
+      w[t] = (buf[j] << 24) | (buf[j + 1] << 16) | (buf[j + 2] << 8) | buf[j + 3];
+    }
+    for (let t = 16; t < 64; t++) {
+      const s0 = rotr(7, w[t - 15]) ^ rotr(18, w[t - 15]) ^ (w[t - 15] >>> 3);
+      const s1 = rotr(17, w[t - 2]) ^ rotr(19, w[t - 2]) ^ (w[t - 2] >>> 10);
+      w[t] = (w[t - 16] + s0 + w[t - 7] + s1) | 0;
+    }
+
+    let a = h[0], b = h[1], c = h[2], d = h[3], e = h[4], f = h[5], g = h[6], hh = h[7];
+    for (let t = 0; t < 64; t++) {
+      const S1 = rotr(6, e) ^ rotr(11, e) ^ rotr(25, e);
+      const ch = (e & f) ^ (~e & g);
+      const temp1 = (hh + S1 + ch + K[t] + w[t]) | 0;
+      const S0 = rotr(2, a) ^ rotr(13, a) ^ rotr(22, a);
+      const maj = (a & b) ^ (a & c) ^ (b & c);
+      const temp2 = (S0 + maj) | 0;
+      hh = g; g = f; f = e; e = (d + temp1) | 0; d = c; c = b; b = a; a = (temp1 + temp2) | 0;
+    }
+
+    h[0] = (h[0] + a) | 0; h[1] = (h[1] + b) | 0; h[2] = (h[2] + c) | 0; h[3] = (h[3] + d) | 0;
+    h[4] = (h[4] + e) | 0; h[5] = (h[5] + f) | 0; h[6] = (h[6] + g) | 0; h[7] = (h[7] + hh) | 0;
+  }
+
+  // 4. Produce hex
+  let out = '';
+  for (let i = 0; i < 8; i++) {
+    out += h[i].toString(16).padStart(8, '0');
+  }
+  return out;
+}