@openchambery/relay-server 1.18.7-beta.1 → 1.18.7-beta.3

package/src/push/handler.js

@@ -0,0 +1,292 @@
+import { createApnsProvider } from './apns.js';
+import { normalizePushRelayOptions, resolvePushRelayClientIp } from './config.js';
+import { deriveServerId, verifyP1363 } from './crypto.js';
+import { createInFlightGate, createReplayGuard, createSlidingWindowLimiter, createWorkTracker } from './guard.js';
+import { JSON_BODY_BYTES, buildLiveActivityPayload, validateLiveActivityBody, validateLiveActivityRegisterBody, validateRegisterBody, validateSendBody } from './schema.js';
+import { createTokenStore } from './store.js';
+
+const WINDOW_MS = 60_000;
+const STOP_DEADLINE_MS = 5_500;
+
+const sendJson = (response, status, payload, method = 'GET') => {
+  if (response.writableEnded) return;
+  response.setHeader('cache-control', 'no-store');
+  response.writeHead(status, { 'content-type': 'application/json' });
+  response.end(method === 'HEAD' ? undefined : JSON.stringify(payload));
+};
+
+const readBody = (request, maxBytes) => new Promise((resolve, reject) => {
+  let done = false;
+  const fail = (error) => { if (done) return; done = true; reject(error); };
+  const succeed = (value) => { if (done) return; done = true; resolve(value); };
+  const tooLarge = () => {
+    const error = new Error('payload too large');
+    error.code = 'PAYLOAD_TOO_LARGE';
+    fail(error);
+  };
+  const drain = () => {
+    request.removeListener('data', onData);
+    request.resume();
+  };
+  const declared = Number(request.headers['content-length']);
+  if (Number.isFinite(declared) && declared > maxBytes) {
+    tooLarge();
+    request.resume();
+    return;
+  }
+  const chunks = [];
+  let size = 0;
+  const onData = (chunk) => {
+    size += chunk.length;
+    if (size > maxBytes) {
+      drain();
+      tooLarge();
+      return;
+    }
+    chunks.push(chunk);
+  };
+  request.on('data', onData);
+  request.on('end', () => succeed(Buffer.concat(chunks)));
+  request.on('error', fail);
+});
+
+export const createPushRelayHandler = (options = {}) => {
+  const claimHealthEndpoints = options.claimHealthEndpoints !== false;
+  const config = normalizePushRelayOptions(options);
+  const limits = config.limits;
+  const clock = { now: Date.now, setTimeout, clearTimeout, setInterval, clearInterval, setImmediate, ...config.clock };
+  const resolveClientIp = config.resolveClientIp ?? ((request) => resolvePushRelayClientIp(request, config.trustProxy));
+  const ownedStore = !config.store;
+  const ownedApns = !config.apnsProvider;
+  const openStore = () => config.store ?? createTokenStore(config.databasePath);
+  const openApns = () => config.apnsProvider ?? createApnsProvider({ ...config.apns, clock, http2: config.http2 });
+  let store = openStore();
+  let apns;
+  try {
+    apns = openApns();
+  } catch (error) {
+    if (ownedStore) try { store.close(); } catch { /* ignore */ }
+    throw error;
+  }
+  const liveStore = () => {
+    if (!ownedStore) return store;
+    if (state === 'stopping') return store;
+    try { store.count(); return store; } catch {
+      store = createTokenStore(config.databasePath);
+      return store;
+    }
+  };
+  const replay = createReplayGuard({ replayMs: limits.replayMs, maxReplayEntries: limits.maxReplayEntries, now: () => clock.now() });
+  const registerIpLimit = createSlidingWindowLimiter({ windowMs: WINDOW_MS, maxCount: limits.registerLimitPerMinute, maxEntries: limits.maxRateLimitEntries, now: () => clock.now() });
+  const sendIpLimit = createSlidingWindowLimiter({ windowMs: WINDOW_MS, maxCount: limits.sendLimitPerMinute, maxEntries: limits.maxRateLimitEntries, now: () => clock.now() });
+  const sendServerLimit = createSlidingWindowLimiter({ windowMs: WINDOW_MS, maxCount: limits.serverSendLimitPerMinute, maxEntries: limits.maxRateLimitEntries, now: () => clock.now() });
+  const inFlight = createInFlightGate(limits.maxInFlight);
+  const httpWork = createWorkTracker();
+  const reasons = { authRejected: 0, policyRejected: 0, limited: 0, replayRejected: 0 };
+  let stopPromise = null; let state = 'idle';
+  const snapshot = () => {
+    let tokenCount = 0;
+    try { tokenCount = store.count(); } catch { /* closed after stop */ }
+    return { state, tokenCount, inFlight: inFlight.active, replayEntries: replay.size, reasons: { ...reasons } };
+  };
+
+  const authenticate = (jwk, message, signature, ts) => {
+    if (Math.abs(clock.now() - ts) > limits.timestampSkewMs) { reasons.authRejected += 1; return 'timestamp'; }
+    if (!verifyP1363(message, jwk, signature)) { reasons.authRejected += 1; return 'invalid_signature'; }
+    return null;
+  };
+
+  const handleRegister = (parsed) => {
+    const message = parsed.kind
+      ? `${parsed.ts}.${parsed.token}.${parsed.platform}.${parsed.kind}`
+      : `${parsed.ts}.${parsed.token}.${parsed.platform}`;
+    const authError = authenticate(parsed.publicKeyJwk, message, parsed.sig, parsed.ts);
+    if (authError) return { status: 401, body: { error: authError } };
+    const serverId = deriveServerId(parsed.publicKeyJwk);
+    const replayKey = `${parsed.kind ? 'register-live-activity' : 'register'}.${serverId}.${parsed.ts}.${parsed.sig.toString('base64url')}`;
+    if (replay.has(replayKey)) return { status: 200, body: { ok: true } };
+    const tokens = liveStore();
+    const existing = tokens.get(parsed.token);
+    if (!existing && tokens.count() >= limits.maxTokens) { reasons.limited += 1; return { status: 429, body: { error: 'token_limit' } }; }
+    if (!replay.remember(replayKey)) { reasons.limited += 1; return { status: 429, body: { error: 'rate_limited' } }; }
+    tokens.upsert(parsed.token, serverId, parsed.platform, clock.now());
+    return { status: 200, body: { ok: true } };
+  };
+
+  const handleUnregisterLiveActivity = (parsed) => {
+    const authError = authenticate(parsed.publicKeyJwk, `${parsed.ts}.${parsed.token}.${parsed.platform}.${parsed.kind}`, parsed.sig, parsed.ts);
+    if (authError) return { status: 401, body: { error: authError } };
+    const serverId = deriveServerId(parsed.publicKeyJwk);
+    const replayKey = `unregister-live-activity.${serverId}.${parsed.ts}.${parsed.sig.toString('base64url')}`;
+    if (replay.has(replayKey)) return { status: 200, body: { ok: true } };
+    const tokens = liveStore();
+    const existing = tokens.get(parsed.token);
+    if (existing && existing.serverId !== serverId) { reasons.authRejected += 1; return { status: 401, body: { error: 'invalid_signature' } }; }
+    if (!replay.remember(replayKey)) { reasons.limited += 1; return { status: 429, body: { error: 'rate_limited' } }; }
+    if (existing) tokens.delete(parsed.token);
+    return { status: 200, body: { ok: true } };
+  };
+
+  const handleSend = async (parsed) => {
+    const sorted = [...parsed.tokens].sort();
+    const authError = authenticate(parsed.publicKeyJwk, `${parsed.ts}.${sorted.join(',')}.${parsed.title}`, parsed.sig, parsed.ts);
+    if (authError) return { status: 401, body: { error: authError } };
+    const serverId = deriveServerId(parsed.publicKeyJwk);
+    const replayKey = `send.${serverId}.${parsed.ts}.${parsed.sig.toString('base64url')}`;
+    if (replay.has(replayKey)) { reasons.replayRejected += 1; return { status: 401, body: { error: 'replay' } }; }
+    if (!replay.remember(replayKey)) { reasons.limited += 1; return { status: 429, body: { error: 'rate_limited' } }; }
+    if (!sendServerLimit.allow(serverId)) { reasons.limited += 1; return { status: 429, body: { error: 'rate_limited' } }; }
+    const tokens = liveStore();
+    const results = await Promise.all(parsed.uniqueTokens.map(async (token) => {
+      const binding = tokens.get(token);
+      if (!binding || binding.serverId !== serverId) return { token, ok: false };
+      const acquired = await inFlight.acquire();
+      if (!acquired) { reasons.limited += 1; return { token, ok: false }; }
+      try {
+        const outcome = await apns.send({ token, env: parsed.env, payload: parsed.payload, collapseId: parsed.collapseId });
+        if (outcome?.drop === true) {
+          tokens.delete(token);
+          return { token, ok: false, drop: true };
+        }
+        return { token, ok: outcome?.ok === true };
+      } catch {
+        return { token, ok: false };
+      } finally {
+        inFlight.release(acquired);
+      }
+    }));
+    return { status: 200, body: { results } };
+  };
+
+  const handleLiveActivity = async (parsed) => {
+    const sorted = [...parsed.tokens].sort();
+    const contentState = parsed.contentState;
+    const message = `${parsed.ts}.${sorted.join(',')}.${parsed.event}.${contentState.status}.${contentState.eventVersion}.${contentState.updatedAt}.${contentState.endedAt ?? ''}.${parsed.dismissalDate ?? ''}.${parsed.staleDate ?? ''}`;
+    const authError = authenticate(parsed.publicKeyJwk, message, parsed.sig, parsed.ts);
+    if (authError) return { status: 401, body: { error: authError } };
+    const serverId = deriveServerId(parsed.publicKeyJwk);
+    const replayKey = `live-activity.${serverId}.${parsed.ts}.${parsed.sig.toString('base64url')}`;
+    if (replay.has(replayKey)) { reasons.replayRejected += 1; return { status: 401, body: { error: 'replay' } }; }
+    if (!replay.remember(replayKey)) { reasons.limited += 1; return { status: 429, body: { error: 'rate_limited' } }; }
+    if (!sendServerLimit.allow(serverId)) { reasons.limited += 1; return { status: 429, body: { error: 'rate_limited' } }; }
+    const payload = buildLiveActivityPayload({
+      event: parsed.event,
+      contentState,
+      dismissalDate: parsed.dismissalDate,
+      staleDate: parsed.staleDate,
+      timestamp: Math.floor(clock.now() / 1000),
+    });
+    const tokens = liveStore();
+    const results = await Promise.all(parsed.uniqueTokens.map(async (token) => {
+      const binding = tokens.get(token);
+      if (!binding || binding.serverId !== serverId) return { token, ok: false };
+      const acquired = await inFlight.acquire();
+      if (!acquired) { reasons.limited += 1; return { token, ok: false }; }
+      try {
+        const outcome = await apns.send({ token, env: parsed.env, payload, pushType: 'liveactivity' });
+        if (outcome?.drop === true) {
+          tokens.delete(token);
+          return { token, ok: false, drop: true };
+        }
+        if (outcome?.ok === true && parsed.event === 'end') tokens.delete(token);
+        return { token, ok: outcome?.ok === true };
+      } catch {
+        return { token, ok: false };
+      } finally {
+        inFlight.release(acquired);
+      }
+    }));
+    return { status: 200, body: { results } };
+  };
+
+  const handleRequest = (request, response) => {
+    let pathname;
+    try { pathname = new URL(request.url ?? '/', 'http://push-relay').pathname; } catch {
+      if (!claimHealthEndpoints) return false;
+      response.writeHead(404); response.end(); return true;
+    }
+    if (!claimHealthEndpoints && !pathname.startsWith('/v1/push/')) return false;
+    const ready = pathname === '/readyz' && state === 'running';
+    const healthy = pathname === '/healthz';
+    if (claimHealthEndpoints && (healthy || ready) && (request.method === 'GET' || request.method === 'HEAD')) {
+      sendJson(response, 200, { status: 'ok' }, request.method);
+      return true;
+    }
+    const isRegister = pathname === '/v1/push/register-token';
+    const isRegisterLive = pathname === '/v1/push/register-live-activity-token';
+    const isUnregisterLive = pathname === '/v1/push/unregister-live-activity-token';
+    const isSend = pathname === '/v1/push/send';
+    const isLiveActivity = pathname === '/v1/push/live-activity';
+    if (request.method !== 'POST' || (!isRegister && !isRegisterLive && !isUnregisterLive && !isSend && !isLiveActivity) || state !== 'running') { response.writeHead(404); response.end(); return true; }
+    const ip = resolveClientIp(request);
+    const limiter = (isRegister || isRegisterLive || isUnregisterLive) ? registerIpLimit : sendIpLimit;
+    if (!limiter.allow(ip)) { reasons.limited += 1; sendJson(response, 429, { error: 'rate_limited' }); return true; }
+    const endHttp = httpWork.begin();
+    readBody(request, limits.jsonBodyBytes ?? JSON_BODY_BYTES).then(async (buffer) => {
+      let body;
+      try { body = JSON.parse(buffer.toString('utf8')); } catch { reasons.policyRejected += 1; sendJson(response, 400, { error: 'invalid_request' }); return; }
+      const parsed = isRegister ? validateRegisterBody(body)
+        : (isRegisterLive || isUnregisterLive) ? validateLiveActivityRegisterBody(body)
+          : isLiveActivity ? validateLiveActivityBody(body)
+            : validateSendBody(body);
+      if (parsed.error) {
+        reasons.policyRejected += 1;
+        sendJson(response, 400, { error: parsed.error });
+        return;
+      }
+      const result = (isRegister || isRegisterLive) ? handleRegister(parsed.value)
+        : isUnregisterLive ? handleUnregisterLiveActivity(parsed.value)
+          : isLiveActivity ? await handleLiveActivity(parsed.value)
+            : await handleSend(parsed.value);
+      sendJson(response, result.status, result.body);
+    }).catch((error) => {
+      if (error?.code === 'PAYLOAD_TOO_LARGE') { reasons.policyRejected += 1; sendJson(response, 413, { error: 'payload_too_large' }); return; }
+      sendJson(response, 500, { error: 'internal' });
+    }).finally(endHttp);
+    return true;
+  };
+
+  const activate = () => {
+    if (state === 'running') return;
+    liveStore();
+    inFlight.reset();
+    httpWork.reset();
+    if (ownedApns && state === 'stopped') apns = openApns();
+    state = 'running';
+  };
+
+  const deactivate = () => {
+    if (stopPromise) return stopPromise;
+    if (state === 'idle' || state === 'stopped') { state = 'stopped'; return Promise.resolve(); }
+    state = 'stopping';
+    stopPromise = Promise.resolve().then(async () => {
+      inFlight.rejectWaiters();
+      replay.clear();
+      registerIpLimit.clear();
+      sendIpLimit.clear();
+      sendServerLimit.clear();
+      let deadlineTimer = null;
+      try {
+        const graceful = Promise.all([inFlight.whenIdle(), httpWork.whenIdle()]);
+        const deadline = new Promise((resolve) => {
+          deadlineTimer = clock.setTimeout(() => resolve('deadline'), STOP_DEADLINE_MS);
+        });
+        await Promise.race([graceful.then(() => 'graceful'), deadline]);
+      } finally {
+        if (deadlineTimer !== null) try { clock.clearTimeout(deadlineTimer); } catch { /* ignore */ }
+      }
+      try { apns.close?.(); } catch { /* ignore */ }
+      if (ownedStore) try { store.close(); } catch { /* ignore */ }
+      state = 'stopped';
+      stopPromise = null;
+    });
+    return stopPromise;
+  };
+
+  return {
+    handleRequest,
+    activate,
+    deactivate,
+    getSnapshot: snapshot,
+  };
+};

package/src/push/index.d.ts

@@ -0,0 +1,111 @@
+import type { IncomingMessage } from 'node:http';
+import type { AddressInfo } from 'node:net';
+
+export type PushRelayState = 'idle' | 'starting' | 'running' | 'stopping' | 'stopped';
+export type PushRelayEnv = 'production' | 'sandbox';
+
+export interface PushRelayLimits {
+  timestampSkewMs: number;
+  replayMs: number;
+  maxReplayEntries: number;
+  registerLimitPerMinute: number;
+  sendLimitPerMinute: number;
+  serverSendLimitPerMinute: number;
+  maxTokens: number;
+  maxInFlight: number;
+  maxRateLimitEntries: number;
+  jsonBodyBytes: number;
+}
+
+export interface PushRelayApnsConfig {
+  keyId: string;
+  teamId: string;
+  p8: string;
+  bundleId: string;
+}
+
+export interface PushRelayClock {
+  now: () => number;
+  setTimeout: typeof globalThis.setTimeout;
+  clearTimeout: typeof globalThis.clearTimeout;
+  setInterval: typeof globalThis.setInterval;
+  clearInterval: typeof globalThis.clearInterval;
+  setImmediate: typeof globalThis.setImmediate;
+}
+
+export interface PushApnsSendInput {
+  token: string;
+  env: PushRelayEnv;
+  payload: unknown;
+  collapseId?: string;
+  pushType?: 'alert' | 'liveactivity';
+}
+
+export interface PushApnsSendResult {
+  ok: boolean;
+  drop?: boolean;
+}
+
+export interface PushApnsProvider {
+  send(input: PushApnsSendInput): Promise<PushApnsSendResult>;
+  close?(): void;
+}
+
+export interface PushTokenRecord {
+  serverId: string;
+  platform: string;
+  updatedAt: number;
+}
+
+export interface PushTokenStore {
+  get(token: string): PushTokenRecord | null;
+  upsert(token: string, serverId: string, platform: string, updatedAt: number): void;
+  delete(token: string): void;
+  count(): number;
+  close(): void;
+}
+
+export interface PushRelaySnapshotReasons {
+  authRejected: number;
+  policyRejected: number;
+  limited: number;
+  replayRejected: number;
+}
+
+export interface PushRelaySnapshot {
+  state: PushRelayState;
+  tokenCount: number;
+  inFlight: number;
+  replayEntries: number;
+  reasons: PushRelaySnapshotReasons;
+}
+
+export interface PushRelayOptions {
+  host?: string;
+  port?: number;
+  trustProxy?: boolean;
+  databasePath?: string;
+  limits?: Partial<PushRelayLimits>;
+  apns?: PushRelayApnsConfig;
+  apnsProvider?: PushApnsProvider;
+  clock?: Partial<PushRelayClock>;
+  logger?: Pick<Console, 'info' | 'warn' | 'error'>;
+  resolveClientIp?: (request: IncomingMessage) => string;
+  store?: PushTokenStore;
+  http2?: { connect: typeof import('node:http2').connect };
+}
+
+export interface PushRelayServerInstance {
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  address(): string | AddressInfo | null | undefined;
+  readonly url: string | null;
+  getSnapshot(): PushRelaySnapshot;
+}
+
+export function resolvePushRelayClientIp(request: IncomingMessage, trustProxy?: boolean): string;
+export function formatPushRelayUrl(host: string, port: number): string;
+export function canonicalPublicJwkString(jwk: { crv: string; kty: string; x: string; y: string }): string;
+export function deriveServerId(jwk: { crv: string; kty: string; x: string; y: string }): string;
+export function createPushRelayServer(options?: PushRelayOptions): PushRelayServerInstance;
+export function startPushRelayServer(options?: PushRelayOptions): Promise<PushRelayServerInstance>;

package/src/push/index.js

@@ -0,0 +1,3 @@
+export { createPushRelayServer, startPushRelayServer } from './server.js';
+export { resolvePushRelayClientIp, formatPushRelayUrl } from './config.js';
+export { canonicalPublicJwkString, deriveServerId } from './crypto.js';

package/src/push/schema.js

@@ -0,0 +1,185 @@
+import { b64urlExact, parsePublicJwk } from './crypto.js';
+
+export const IOS_TOKEN = /^[0-9a-fA-F]{64}$/;
+export const JSON_BODY_BYTES = 16 * 1024;
+export const APNS_PAYLOAD_BYTES = 4096;
+export const MAX_TOKENS_PER_REQUEST = 100;
+export const MAX_TITLE_BYTES = 256;
+export const MAX_BODY_BYTES = 1024;
+export const MAX_COLLAPSE_ID_BYTES = 64;
+export const MAX_DATA_ENTRIES = 16;
+export const MAX_DATA_KEY_BYTES = 64;
+export const MAX_DATA_VALUE_BYTES = 256;
+export const MAX_DATA_TOTAL_BYTES = 2048;
+export const LIVE_ACTIVITY_KIND = 'liveactivity';
+export const LIVE_ACTIVITY_EVENTS = new Set(['update', 'end']);
+export const LIVE_ACTIVITY_STATUSES = new Set(['working', 'tool', 'retry', 'input', 'permission', 'stale', 'complete', 'error']);
+export const LIVE_ACTIVITY_CONTENT_KEYS = new Set(['status', 'eventVersion', 'updatedAt', 'endedAt']);
+
+const bytes = (value) => Buffer.byteLength(value, 'utf8');
+const isSafeInt = (value) => typeof value === 'number' && Number.isSafeInteger(value);
+const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
+
+export const isIosToken = (value) => typeof value === 'string' && IOS_TOKEN.test(value);
+
+const parseTs = (value) => (isSafeInt(value) ? value : null);
+const parseSig = (value) => b64urlExact(value, 64);
+
+const parseData = (value) => {
+  if (value === undefined) return {};
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const entries = Object.entries(value);
+  if (entries.length > MAX_DATA_ENTRIES) return null;
+  let total = 0;
+  const data = {};
+  for (const [key, entry] of entries) {
+    if (typeof key !== 'string' || key.length === 0 || key === 'aps' || typeof entry !== 'string') return null;
+    const keyBytes = bytes(key);
+    const valueBytes = bytes(entry);
+    if (keyBytes > MAX_DATA_KEY_BYTES || valueBytes > MAX_DATA_VALUE_BYTES) return null;
+    total += keyBytes + valueBytes;
+    if (total > MAX_DATA_TOTAL_BYTES) return null;
+    data[key] = entry;
+  }
+  return data;
+};
+
+export const buildApnsPayload = ({ title, body, badge, collapseId, data }) => {
+  const alert = { title };
+  if (body) alert.body = body;
+  const aps = { alert, sound: 'default', 'mutable-content': 1 };
+  if (badge !== undefined) aps.badge = badge;
+  if (collapseId) aps['thread-id'] = collapseId;
+  return Object.keys(data).length > 0 ? { aps, ...data } : { aps };
+};
+
+export const buildLiveActivityPayload = ({ event, contentState, dismissalDate, staleDate, timestamp }) => {
+  const aps = { timestamp, event, 'content-state': contentState };
+  if (event === 'end' && dismissalDate !== undefined) aps['dismissal-date'] = dismissalDate;
+  if (event === 'update' && staleDate !== undefined) aps['stale-date'] = staleDate;
+  return { aps };
+};
+
+const uniqueTokens = (tokens) => {
+  const unique = [];
+  const seen = new Set();
+  for (const token of tokens) {
+    if (seen.has(token)) continue;
+    seen.add(token);
+    unique.push(token);
+  }
+  return unique;
+};
+
+const parseContentState = (value, event) => {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const keys = Object.keys(value);
+  if (keys.length === 0 || keys.some((key) => !LIVE_ACTIVITY_CONTENT_KEYS.has(key))) return null;
+  if (typeof value.status !== 'string' || !LIVE_ACTIVITY_STATUSES.has(value.status)) return null;
+  if (!isSafeInt(value.eventVersion) || !isFiniteNumber(value.updatedAt)) return null;
+  if (event === 'end' && !isFiniteNumber(value.endedAt)) return null;
+  if (value.endedAt !== undefined && !isFiniteNumber(value.endedAt)) return null;
+  const contentState = { status: value.status, eventVersion: value.eventVersion, updatedAt: value.updatedAt };
+  if (value.endedAt !== undefined) contentState.endedAt = value.endedAt;
+  return contentState;
+};
+
+export const validateRegisterBody = (body) => {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return { error: 'invalid_request' };
+  if (body.platform === 'android') return { error: 'unsupported_platform' };
+  if (body.platform !== 'ios') return { error: 'invalid_request' };
+  if (!isIosToken(body.token)) return { error: 'invalid_request' };
+  const jwk = parsePublicJwk(body.publicKeyJwk);
+  const ts = parseTs(body.ts);
+  const sig = parseSig(body.sig);
+  if (!jwk || ts === null || !sig) return { error: 'invalid_request' };
+  return { value: { token: body.token, platform: 'ios', publicKeyJwk: jwk, ts, sig } };
+};
+
+export const validateLiveActivityRegisterBody = (body) => {
+  const parsed = validateRegisterBody(body);
+  if (parsed.error) return parsed;
+  if (body.kind !== LIVE_ACTIVITY_KIND) return { error: 'invalid_request' };
+  return { value: { ...parsed.value, kind: LIVE_ACTIVITY_KIND } };
+};
+
+export const validateSendBody = (body) => {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return { error: 'invalid_request' };
+  const tokens = body.tokens;
+  if (!Array.isArray(tokens) || tokens.length < 1 || tokens.length > MAX_TOKENS_PER_REQUEST) return { error: 'invalid_request' };
+  if (tokens.some((token) => !isIosToken(token))) return { error: 'invalid_request' };
+  if (typeof body.title !== 'string' || body.title.length === 0 || bytes(body.title) > MAX_TITLE_BYTES) return { error: 'invalid_request' };
+  if (body.body !== undefined && (typeof body.body !== 'string' || bytes(body.body) > MAX_BODY_BYTES)) return { error: 'invalid_request' };
+  if (body.badge !== undefined && (!isSafeInt(body.badge) || body.badge < 0)) return { error: 'invalid_request' };
+  if (body.collapseId !== undefined && (typeof body.collapseId !== 'string' || bytes(body.collapseId) > MAX_COLLAPSE_ID_BYTES)) return { error: 'invalid_request' };
+  if (body.env !== undefined && body.env !== 'production' && body.env !== 'sandbox') return { error: 'invalid_request' };
+  const jwk = parsePublicJwk(body.publicKeyJwk);
+  const ts = parseTs(body.ts);
+  const sig = parseSig(body.sig);
+  const data = parseData(body.data);
+  if (!jwk || ts === null || !sig || !data) return { error: 'invalid_request' };
+  const unique = uniqueTokens(tokens);
+  const payload = buildApnsPayload({
+    title: body.title,
+    body: body.body ?? '',
+    badge: body.badge,
+    collapseId: body.collapseId,
+    data,
+  });
+  if (bytes(JSON.stringify(payload)) > APNS_PAYLOAD_BYTES) return { error: 'invalid_request' };
+  return {
+    value: {
+      tokens,
+      uniqueTokens: unique,
+      title: body.title,
+      body: typeof body.body === 'string' ? body.body : '',
+      badge: body.badge,
+      collapseId: body.collapseId || undefined,
+      env: body.env === 'production' ? 'production' : 'sandbox',
+      publicKeyJwk: jwk,
+      ts,
+      sig,
+      payload,
+    },
+  };
+};
+
+export const validateLiveActivityBody = (body) => {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return { error: 'invalid_request' };
+  const tokens = body.tokens;
+  if (!Array.isArray(tokens) || tokens.length < 1 || tokens.length > MAX_TOKENS_PER_REQUEST) return { error: 'invalid_request' };
+  if (tokens.some((token) => !isIosToken(token))) return { error: 'invalid_request' };
+  if (typeof body.event !== 'string' || !LIVE_ACTIVITY_EVENTS.has(body.event)) return { error: 'invalid_request' };
+  const contentState = parseContentState(body.contentState, body.event);
+  if (!contentState) return { error: 'invalid_request' };
+  if (body.dismissalDate !== undefined && !isSafeInt(body.dismissalDate)) return { error: 'invalid_request' };
+  if (body.staleDate !== undefined && !isSafeInt(body.staleDate)) return { error: 'invalid_request' };
+  if (body.env !== undefined && body.env !== 'production' && body.env !== 'sandbox') return { error: 'invalid_request' };
+  const jwk = parsePublicJwk(body.publicKeyJwk);
+  const ts = parseTs(body.ts);
+  const sig = parseSig(body.sig);
+  if (!jwk || ts === null || !sig) return { error: 'invalid_request' };
+  const payload = buildLiveActivityPayload({
+    event: body.event,
+    contentState,
+    dismissalDate: body.dismissalDate,
+    staleDate: body.staleDate,
+    timestamp: 1_000_000_000,
+  });
+  if (bytes(JSON.stringify(payload)) > APNS_PAYLOAD_BYTES) return { error: 'invalid_request' };
+  return {
+    value: {
+      tokens,
+      uniqueTokens: uniqueTokens(tokens),
+      event: body.event,
+      contentState,
+      dismissalDate: body.dismissalDate,
+      staleDate: body.staleDate,
+      env: body.env === 'production' ? 'production' : 'sandbox',
+      publicKeyJwk: jwk,
+      ts,
+      sig,
+      payload,
+    },
+  };
+};