sitepong 0.1.8 → 0.1.10

package/README.md

@@ -596,6 +596,144 @@ Content inside `<SensitiveView>` is replaced with a black rectangle in recorded
 | `bufferDuration` | `10000` (10s) | `60000` (60s) | Rolling buffer size in ms |
 | `maxDuration` | `3600000` | `3600000` | Max recording duration in ms |
 
+### Push Notifications & Live Activities
+
+Native APNs (iOS) and FCM (Android) push notifications, plus iOS Live Activity updates. SitePong sends directly to Apple/Google — no Expo Push service in the path.
+
+#### Token lifecycle
+
+There are two halves to push: the **client SDK** registers device tokens with the SitePong ingest server, and the **server-side Push API** sends notifications to those tokens.
+
+```
+[App launches]
+   ↓
+[Notifications.getDevicePushTokenAsync()]   ← OS gives you a native token
+   ↓
+[registerDeviceToken(token, opts)]           ← SDK POSTs to /api/push/tokens
+   ↓                                            with X-API-Key: sp_live_xxx
+[Token stored in SitePong]
+   ↓
+[identify('user-123')]                        ← SDK auto re-registers token
+   ↓                                            with user_id (via lazy hook)
+[Your backend → POST /api/push/send]          ← server-only sp_push_xxx key
+   ↓
+[SitePong → APNs / FCM → Device]
+```
+
+#### 1. Install permission and get the native token
+
+```bash
+npx expo install expo-notifications
+```
+
+```typescript
+import * as Notifications from 'expo-notifications';
+import * as Device from 'expo-device';
+import { Platform } from 'react-native';
+
+if (!Device.isDevice) return; // simulator can't receive push
+
+const { status } = await Notifications.requestPermissionsAsync();
+if (status !== 'granted') return;
+
+// Returns the raw native token (APNs hex on iOS, FCM token on Android)
+const { data: token } = await Notifications.getDevicePushTokenAsync();
+```
+
+#### 2. Register the token with SitePong
+
+```typescript
+import { registerDeviceToken } from '@sitepong/sdk/react-native';
+import { Platform } from 'react-native';
+
+registerDeviceToken(token, {
+  platform: Platform.OS as 'ios' | 'android',
+  environment: __DEV__ ? 'sandbox' : 'production',
+  userId: 'user-123', // optional — can be set later via identify()
+});
+```
+
+This makes a `POST /api/push/tokens` request to the ingest server with `X-API-Key: <your SDK key>`. The body includes the token, `token_type` (`apns`/`fcm`), `device_id`, `user_id`, `platform`, app version, device model, and OS version. The server upserts by `(token, environment)` so re-registration is idempotent.
+
+#### 3. User identification (automatic)
+
+When you call `identify(userId)`, the SDK automatically re-registers all cached push, Live Activity, and push-to-start tokens with the new `user_id`. **You do not need to call `registerDeviceToken()` again after login.**
+
+```typescript
+import { identify } from '@sitepong/sdk/react-native';
+
+// Token already registered anonymously at app launch
+// Now user logs in:
+identify('user-123');
+// → SDK re-POSTs /api/push/tokens with user_id: "user-123"
+```
+
+The hook is installed lazily the first time any `register*` function is called, so it works whether you use `SitePongRNProvider` or call `initRN()` directly.
+
+#### 4. Send notifications from your backend
+
+Generate a separate **Push API key** (prefix `sp_push_`) from the Notifications tab in the SitePong dashboard. This is **not** the SDK key — it's server-only and has permission to send pushes.
+
+```bash
+curl -X POST https://api.sitepong.com/api/push/send \
+  -H "Authorization: Bearer sp_push_xxxxxxxxxxxxxxxx" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "title": "Order Shipped",
+    "body": "Your order #1234 is on its way",
+    "data": { "orderId": "1234" },
+    "target": { "user_ids": ["user-123"] }
+  }'
+```
+
+Targeting options (provide at least one):
+
+- `user_ids: string[]` — sends to all active devices for these users
+- `device_ids: string[]` — sends to specific SitePong device IDs
+- `tokens: string[]` — sends directly to raw APNs/FCM tokens
+
+#### Live Activities (iOS)
+
+Register the per-instance push token from your native bridge:
+
+```typescript
+import {
+  registerLiveActivityToken,
+  registerPushToStartToken,
+  endLiveActivity,
+} from '@sitepong/sdk/react-native';
+
+// When ActivityKit gives you a push token for a running activity
+registerLiveActivityToken('DeliveryActivityAttributes', activity.id, pushToken, {
+  environment: 'production',
+});
+
+// Or register a push-to-start token (iOS 17.2+) so the activity can be launched remotely
+registerPushToStartToken('DeliveryActivityAttributes', pushToStartToken, {
+  environment: 'production',
+});
+
+// When the activity ends, deactivate its token
+endLiveActivity('DeliveryActivityAttributes', activity.id);
+```
+
+#### Token invalidation
+
+When APNs or FCM reports a token as invalid (app uninstalled, notifications disabled, token rotated), SitePong marks it inactive on the server side and stops sending. No client action needed. To force a refresh after an OS-level token change, call `registerDeviceToken()` again with the new token.
+
+#### Endpoint reference
+
+| Method | Path | Auth | SDK function |
+|---|---|---|---|
+| POST | `/api/push/tokens` | `X-API-Key: sp_live_*` | `registerDeviceToken()` |
+| POST | `/api/push/live-activity-tokens` | `X-API-Key: sp_live_*` | `registerLiveActivityToken()` |
+| POST | `/api/push/push-to-start-tokens` | `X-API-Key: sp_live_*` | `registerPushToStartToken()` |
+| DELETE | `/api/push/live-activity-tokens` | `X-API-Key: sp_live_*` | `endLiveActivity()` |
+| POST | `/api/push/send` | `Authorization: Bearer sp_push_*` | (server-side only) |
+| POST | `/api/push/live-activity` | `Authorization: Bearer sp_push_*` | (server-side only) |
+
+Default ingest endpoint: `https://ingest.sitepong.com`. Override via the `endpoint` option in `initRN()` or `SitePongRNProvider`.
+
 ### Device Intelligence (React Native)
 
 Persistent device identification that **survives app reinstalls**. Requires the `@sitepong/device-id` native module.

package/dist/entries/rn.js

@@ -2811,83 +2811,21 @@ function createAsyncStorageAdapter(asyncStorage) {
     removeItem: (key) => asyncStorage.removeItem(key)
   };
 }
-var deviceIdModule = null;
-function getDeviceIdModule() {
-  if (!deviceIdModule) {
-    try {
-      const n = ["@sitepong", "device-id"].join("/");
-      deviceIdModule = __require(n);
-    } catch {
-      deviceIdModule = null;
-    }
-  }
-  return deviceIdModule;
-}
 function collectDeviceInfo() {
-  const info = {
+  const screen = reactNative.Dimensions.get("screen");
+  return {
     platform: reactNative.Platform.OS,
-    osVersion: String(reactNative.Platform.Version)
+    osVersion: String(reactNative.Platform.Version),
+    screenWidth: screen.width,
+    screenHeight: screen.height,
+    screenScale: screen.scale
   };
-  const screen = reactNative.Dimensions.get("screen");
-  info.screenWidth = screen.width;
-  info.screenHeight = screen.height;
-  info.screenScale = screen.scale;
-  let ExpoDevice = null;
-  try {
-    const n = ["expo", "device"].join("-");
-    ExpoDevice = __require(n);
-  } catch {
-  }
-  if (ExpoDevice) {
-    if (ExpoDevice.brand) info.deviceBrand = ExpoDevice.brand;
-    if (ExpoDevice.modelName) info.deviceModel = ExpoDevice.modelName;
-    if (ExpoDevice.deviceName) info.deviceName = ExpoDevice.deviceName;
-    info.isEmulator = !ExpoDevice.isDevice;
-  }
-  let ExpoApplication = null;
-  try {
-    const n = ["expo", "application"].join("-");
-    ExpoApplication = __require(n);
-  } catch {
-  }
-  if (ExpoApplication) {
-    if (ExpoApplication.nativeApplicationVersion) {
-      info.appVersion = ExpoApplication.nativeApplicationVersion;
-    }
-    if (ExpoApplication.nativeBuildVersion) {
-      info.appBuildNumber = ExpoApplication.nativeBuildVersion;
-    }
-  }
-  return info;
 }
 async function fetchPersistentDeviceId() {
-  const mod = getDeviceIdModule();
-  if (!mod) return null;
-  try {
-    return await mod.getDeviceId();
-  } catch {
-    return null;
-  }
+  return null;
 }
 async function fetchNativeDeviceSignals() {
-  const mod = getDeviceIdModule();
-  if (!mod) return null;
-  try {
-    const signals = await mod.getDeviceSignals();
-    return {
-      platform: signals.platform,
-      osVersion: signals.osVersion,
-      deviceModel: signals.model,
-      deviceBrand: signals.manufacturer,
-      isEmulator: signals.isEmulator,
-      screenScale: signals.screenScale,
-      deviceId: signals.deviceId,
-      identifierForVendor: signals.identifierForVendor,
-      androidId: signals.androidId
-    };
-  } catch {
-    return null;
-  }
+  return null;
 }
 
 // src/react-native/screen-recorder.ts
@@ -3222,7 +3160,20 @@ var RNPerformanceManager = class {
 };
 
 // src/react-native/push.ts
+var identifyHookInstalled = false;
+function ensureIdentifyHookInstalled() {
+  if (identifyHookInstalled) return;
+  identifyHookInstalled = true;
+  try {
+    const c = sitepong;
+    if (typeof c.registerIdentifyHook === "function") {
+      c.registerIdentifyHook(reRegisterTokensWithUserId);
+    }
+  } catch {
+  }
+}
 var cachedDeviceContext = null;
+var registeredPushToken = null;
 var registeredLiveActivityTokens = /* @__PURE__ */ new Map();
 var registeredPushToStartTokens = /* @__PURE__ */ new Map();
 function getEndpoint() {
@@ -3303,9 +3254,10 @@ async function deleteFromIngest(path, body) {
   }
 }
 function registerDeviceToken(token, options) {
+  ensureIdentifyHookInstalled();
   const device = getDeviceContext();
   const tokenType = options.platform === "ios" ? "apns" : "fcm";
-  ({ token, environment: options.environment });
+  registeredPushToken = { token, environment: options.environment };
   postToIngest("/api/push/tokens", {
     native_device_token: token,
     token_type: tokenType,
@@ -3319,6 +3271,7 @@ function registerDeviceToken(token, options) {
   });
 }
 function registerLiveActivityToken(activityType, activityId, pushToken, options) {
+  ensureIdentifyHookInstalled();
   const device = getDeviceContext();
   const userId = getUserId();
   const key = `${activityType}:${activityId}`;
@@ -3338,6 +3291,7 @@ function registerLiveActivityToken(activityType, activityId, pushToken, options)
   });
 }
 function registerPushToStartToken(activityType, pushToStartToken, options) {
+  ensureIdentifyHookInstalled();
   const device = getDeviceContext();
   const userId = getUserId();
   registeredPushToStartTokens.set(activityType, {
@@ -3361,6 +3315,42 @@ function endLiveActivity(activityType, activityId) {
     activity_id: activityId
   });
 }
+function reRegisterTokensWithUserId(userId) {
+  if (registeredPushToken) {
+    const device = getDeviceContext();
+    postToIngest("/api/push/tokens", {
+      expo_push_token: registeredPushToken.token,
+      environment: registeredPushToken.environment,
+      device_id: device.deviceId,
+      user_id: userId,
+      platform: device.platform,
+      app_version: device.appVersion,
+      device_model: device.deviceModel,
+      os_version: device.osVersion
+    });
+  }
+  for (const entry of registeredLiveActivityTokens.values()) {
+    const device = getDeviceContext();
+    postToIngest("/api/push/live-activity-tokens", {
+      activity_type: entry.activityType,
+      activity_id: entry.activityId,
+      push_token: entry.token,
+      environment: entry.environment,
+      device_id: device.deviceId,
+      user_id: userId
+    });
+  }
+  for (const entry of registeredPushToStartTokens.values()) {
+    const device = getDeviceContext();
+    postToIngest("/api/push/push-to-start-tokens", {
+      activity_type: entry.activityType,
+      push_to_start_token: entry.token,
+      environment: entry.environment,
+      device_id: device.deviceId,
+      user_id: userId
+    });
+  }
+}
 var SitePongRNContext = react.createContext({
   isInitialized: false,
   performanceManager: null