React Native push notifications

import { createHmac } from 'node:crypto';

type AuthenticatedCustomer = {
  id: string; // Your stable customer ID, matching your webhook mapping.
  email?: string; // Optional contact details your brand authorizes for this customer.
  phone?: string;
};

/** Signs a five-minute push proof for a customer already authenticated by your backend. */
export function createPushIdentityProof(customer: AuthenticatedCustomer) {
  const secret = process.env.SAGEPILOT_PUSH_IDENTITY_SECRET;
  const channelId = process.env.SAGEPILOT_PUSH_CHANNEL_ID;
  if (!secret || !channelId) throw new Error('Push signing configuration is missing');
  if (!customer.id.trim() || customer.id.length > 255) {
    throw new Error('A stable customer ID of at most 255 characters is required');
  }

  const now = Math.floor(Date.now() / 1000);
  const header = Buffer.from(JSON.stringify({ alg: 'HS256', typ: 'JWT' })).toString('base64url');
  const payload = Buffer.from(JSON.stringify({
    aud: 'sagepilot-brand-push',
    channel_id: channelId,
    client_customer_id: customer.id,
    ...(customer.email ? { email: customer.email } : {}),
    ...(customer.phone ? { phone: customer.phone } : {}),
    iat: now,
    exp: now + 300,
  })).toString('base64url');
  const unsigned = `${header}.${payload}`;
  const signature = createHmac('sha256', secret).update(unsigned).digest('base64url');
  return { identity_token: `${unsigned}.${signature}` };
}

import {
  getMessaging, getToken, onTokenRefresh, onMessage,
  onNotificationOpenedApp, getInitialNotification,
} from '@react-native-firebase/messaging';
import type { RemoteMessage } from '@react-native-firebase/messaging';
import {
  createFirebasePushAdapter, SagepilotChatError,
  type SagepilotPushMessage,
} from '@sagepilot-ai/react-native-sdk';
import {
  createSagepilotNativePushAdapter, getSagepilotPushPermission,
} from '@sagepilot-ai/react-native-push-addon';

/** Preserves Sagepilot's signed tracking fields when adapting a Firebase message. */
export function toPushMessage(message: RemoteMessage): SagepilotPushMessage {
  const data: Record<string, string> = {};
  for (const [key, value] of Object.entries(message.data ?? {})) {
    if (typeof value === 'string') data[key] = value;
  }
  return {
    data,
    notification: message.notification ? {
      title: message.notification.title,
      body: message.notification.body,
      imageUrl: message.notification.android?.imageUrl,
    } : undefined,
  };
}

/** Reports an integration error without logging tokens, profiles or notification payloads. */
export function reportPushError(error: unknown): void {
  console.warn('Sagepilot push failed',
    error instanceof SagepilotChatError ? { code: error.code, status: error.status } : 'Check native setup and connectivity');
}

const messaging = getMessaging();
const firebaseTransport = createFirebasePushAdapter({
  getToken: () => getToken(messaging),
  onTokenRefresh: callback => onTokenRefresh(messaging, callback),
  onMessage: callback => onMessage(messaging, message => callback(toPushMessage(message))),
  onNotificationOpenedApp: callback => onNotificationOpenedApp(messaging, message => callback(toPushMessage(message))),
  getInitialNotification: async () => {
    const message = await getInitialNotification(messaging);
    return message ? toPushMessage(message) : null;
  },
}, {
  getPermission: () => getSagepilotPushPermission(),
  requestPermission: () => getSagepilotPushPermission(true),
});

export const pushAdapter = createSagepilotNativePushAdapter(firebaseTransport, {
  displayMode: 'provider', // Use 'sdk' for SDK display on supported Android installations.
  channelName: 'Notifications',
  notificationSettingsPrompt: true,
  onError: reportPushError,
});

import { getMessaging, setBackgroundMessageHandler } from '@react-native-firebase/messaging';
import { handleSagepilotBackgroundPush } from '@sagepilot-ai/react-native-push-addon';
import { toPushMessage, reportPushError } from './src/sagepilot/pushTransport';

setBackgroundMessageHandler(getMessaging(), async message => {
  try {
    await handleSagepilotBackgroundPush(toPushMessage(message));
  } catch (error) {
    reportPushError(error);
  }
});

// Keep your existing AppRegistry/registerRootComponent call below this handler.
// Expo Router only: require('expo-router/entry');

/** Requests a fresh proof using the brand app's existing authenticated session. */
export async function fetchPushProof(appAccessToken: string): Promise<string> {
  const response = await fetch('https://api.yourbrand.com/api/sagepilot/push-proof', {
    method: 'POST',
    headers: { Authorization: `Bearer ${appAccessToken}`, Accept: 'application/json' },
  });
  if (!response.ok) throw new Error(`Push proof request failed (${response.status})`);
  const body: unknown = await response.json();
  if (!body || typeof body !== 'object' || !('identity_token' in body)
    || typeof body.identity_token !== 'string' || !body.identity_token.trim()) {
    throw new Error('Backend did not return identity_token');
  }
  return body.identity_token;
}

import { push } from './pushClient';

/** Runs when the customer explicitly chooses to enable marketing notifications. */
export async function enableMarketingPush() {
  const permission = await push.requestPermission();
  if (permission !== 'authorized' && permission !== 'provisional') return false;

  await push.setPreferences({ enabled: true, marketing_enabled: true });
  return true;
}

/** Runs when the customer opts out of marketing without opting out of other categories. */
export async function disableMarketingPush(): Promise<void> {
  await push.setPreferences({ marketing_enabled: false });
}

/** Reads saved consent to populate your notification settings screen. */
export async function readPushPreferences() {
  return push.getPreferences();
}

import { Linking } from 'react-native';
import type { SagepilotPushMessage } from '@sagepilot-ai/react-native-sdk';

/** Opens only the brand's allowlisted links through the app's existing link handler. */
export async function openPushDestination(message: SagepilotPushMessage): Promise<void> {
  const destination = message.data?.deep_link;
  if (!destination) return; // A notification without a destination simply opens the app.
  if (!destination.startsWith('https://shop.yourbrand.com/')) {
    throw new Error('Unsupported push destination');
  }
  await Linking.openURL(destination);
}