@agent-native/core 0.109.2 → 0.109.4

package/corpus/core/src/integrations/remote-push-delivery.ts

@@ -0,0 +1,370 @@
+import {
+  claimNextRemotePushDelivery,
+  deactivateRemotePushRegistration,
+  failRemotePushDelivery,
+  markRemotePushDelivered,
+  markRemotePushTicketAccepted,
+  retryRemotePushDelivery,
+  type ClaimedRemotePushDelivery,
+} from "./remote-push-store.js";
+
+const EXPO_PUSH_SEND_URL = "https://exp.host/--/api/v2/push/send";
+const EXPO_PUSH_RECEIPTS_URL = "https://exp.host/--/api/v2/push/getReceipts";
+const REQUEST_TIMEOUT_MS = 10_000;
+const RECEIPT_CHECK_DELAY_MS = 15 * 60_000;
+const MAX_DELIVERY_ATTEMPTS = 12;
+const DEFAULT_DELIVERY_LIMIT = 100;
+
+type ExpoResult = {
+  status?: unknown;
+  id?: unknown;
+  message?: unknown;
+  details?: { error?: unknown };
+};
+
+type ExpoPushResponse = {
+  data?: ExpoResult | ExpoResult[] | Record<string, ExpoResult>;
+  errors?: Array<{ code?: unknown; message?: unknown }>;
+};
+
+type DeliveryOutcome =
+  | { kind: "ticket"; ticketId: string }
+  | { kind: "delivered" }
+  | { kind: "retry"; errorCode: string; resend?: boolean }
+  | { kind: "failed"; errorCode: string; deactivate?: boolean };
+
+export async function deliverPendingRemotePushNotifications(options?: {
+  fetchImpl?: typeof fetch;
+  now?: () => number;
+  limit?: number;
+}): Promise<{
+  sent: number;
+  delivered: number;
+  retried: number;
+  failed: number;
+}> {
+  const fetchImpl = options?.fetchImpl ?? fetch;
+  const now = options?.now ?? Date.now;
+  const limit = Math.max(
+    1,
+    Math.min(options?.limit ?? DEFAULT_DELIVERY_LIMIT, 100),
+  );
+  const summary = { sent: 0, delivered: 0, retried: 0, failed: 0 };
+  const claimedDeliveries: ClaimedRemotePushDelivery[] = [];
+
+  for (let processed = 0; processed < limit; processed++) {
+    const delivery = await claimNextRemotePushDelivery({ now: now() });
+    if (!delivery) break;
+
+    if (delivery.attempts > MAX_DELIVERY_ATTEMPTS) {
+      await failRemotePushDelivery({
+        id: delivery.id,
+        phase: delivery.phase,
+        errorCode: "attempts_exhausted",
+      });
+      summary.failed++;
+      continue;
+    }
+
+    claimedDeliveries.push(delivery);
+  }
+
+  const sendDeliveries = claimedDeliveries.filter(
+    (delivery) => delivery.phase === "send",
+  );
+  if (sendDeliveries.length > 0) {
+    let outcomes: DeliveryOutcome[];
+    try {
+      outcomes = await sendExpoPushNotifications(sendDeliveries, fetchImpl);
+    } catch (error) {
+      const errorCode = classifyTransportError(error);
+      outcomes = sendDeliveries.map(() => ({ kind: "retry", errorCode }));
+    }
+    for (let index = 0; index < sendDeliveries.length; index++) {
+      await applyDeliveryOutcome(
+        sendDeliveries[index]!,
+        outcomes[index]!,
+        summary,
+        now,
+      );
+    }
+  }
+
+  for (const delivery of claimedDeliveries) {
+    if (delivery.phase !== "receipt") continue;
+    let outcome: DeliveryOutcome;
+    try {
+      outcome = await readExpoPushReceipt(delivery, fetchImpl);
+    } catch (error) {
+      outcome = {
+        kind: "retry",
+        errorCode: classifyTransportError(error),
+      };
+    }
+
+    await applyDeliveryOutcome(delivery, outcome, summary, now);
+  }
+
+  return summary;
+}
+
+async function applyDeliveryOutcome(
+  delivery: ClaimedRemotePushDelivery,
+  outcome: DeliveryOutcome,
+  summary: {
+    sent: number;
+    delivered: number;
+    retried: number;
+    failed: number;
+  },
+  now: () => number,
+): Promise<void> {
+  if (outcome.kind === "ticket") {
+    await markRemotePushTicketAccepted({
+      id: delivery.id,
+      providerTicketId: outcome.ticketId,
+      checkAfter: now() + RECEIPT_CHECK_DELAY_MS,
+    });
+    summary.sent++;
+    return;
+  }
+  if (outcome.kind === "delivered") {
+    await markRemotePushDelivered(delivery.id);
+    summary.delivered++;
+    return;
+  }
+  if (outcome.kind === "failed") {
+    await failRemotePushDelivery({
+      id: delivery.id,
+      phase: delivery.phase,
+      errorCode: outcome.errorCode,
+    });
+    if (outcome.deactivate) {
+      await deactivateRemotePushRegistration(delivery.registrationId);
+    }
+    summary.failed++;
+    return;
+  }
+
+  await retryRemotePushDelivery({
+    id: delivery.id,
+    phase: delivery.phase,
+    retryAt: now() + retryDelayMs(delivery.attempts),
+    errorCode: outcome.errorCode,
+    resend: outcome.resend,
+  });
+  summary.retried++;
+}
+
+async function sendExpoPushNotifications(
+  deliveries: ClaimedRemotePushDelivery[],
+  fetchImpl: typeof fetch,
+): Promise<DeliveryOutcome[]> {
+  const outcomes = new Map<string, DeliveryOutcome>();
+  const supportedDeliveries = deliveries.filter((delivery) => {
+    const supported =
+      delivery.provider === "expo" && isExpoPushToken(delivery.token);
+    if (!supported) {
+      outcomes.set(delivery.id, {
+        kind: "failed",
+        errorCode: "unsupported_push_registration",
+        deactivate: true,
+      });
+    }
+    return supported;
+  });
+  if (supportedDeliveries.length === 0) {
+    return deliveries.map((delivery) => outcomes.get(delivery.id)!);
+  }
+
+  const messages = supportedDeliveries.map(buildExpoMessage);
+  const response = await fetchWithTimeout(
+    fetchImpl,
+    EXPO_PUSH_SEND_URL,
+    expoRequestInit(messages.length === 1 ? messages[0] : messages),
+  );
+  const body = await readExpoResponse(response);
+  if (!response.ok) {
+    const outcome = responseFailure(response.status, body);
+    for (const delivery of supportedDeliveries) {
+      outcomes.set(delivery.id, outcome);
+    }
+    return deliveries.map((delivery) => outcomes.get(delivery.id)!);
+  }
+
+  const tickets = Array.isArray(body.data)
+    ? body.data
+    : body.data && isExpoResult(body.data)
+      ? [body.data]
+      : [];
+  if (
+    tickets.length !== supportedDeliveries.length ||
+    tickets.some((ticket) => !isExpoResult(ticket))
+  ) {
+    for (const delivery of supportedDeliveries) {
+      outcomes.set(delivery.id, {
+        kind: "retry",
+        errorCode: "invalid_push_ticket",
+      });
+    }
+    return deliveries.map((delivery) => outcomes.get(delivery.id)!);
+  }
+
+  for (let index = 0; index < supportedDeliveries.length; index++) {
+    const delivery = supportedDeliveries[index]!;
+    const ticket = tickets[index]!;
+    outcomes.set(
+      delivery.id,
+      ticket.status === "ok" && typeof ticket.id === "string"
+        ? { kind: "ticket", ticketId: ticket.id }
+        : expoResultFailure(ticket, false),
+    );
+  }
+  return deliveries.map((delivery) => outcomes.get(delivery.id)!);
+}
+
+async function readExpoPushReceipt(
+  delivery: ClaimedRemotePushDelivery,
+  fetchImpl: typeof fetch,
+): Promise<DeliveryOutcome> {
+  if (!delivery.providerTicketId) {
+    return { kind: "retry", errorCode: "missing_push_ticket", resend: true };
+  }
+  const response = await fetchWithTimeout(
+    fetchImpl,
+    EXPO_PUSH_RECEIPTS_URL,
+    expoRequestInit({ ids: [delivery.providerTicketId] }),
+  );
+  const body = await readExpoResponse(response);
+  if (!response.ok) return responseFailure(response.status, body);
+
+  const receipts = body.data;
+  if (!receipts || Array.isArray(receipts) || isExpoResult(receipts)) {
+    return { kind: "retry", errorCode: "push_receipt_unavailable" };
+  }
+  const receipt = receipts[delivery.providerTicketId];
+  if (!receipt) {
+    return { kind: "retry", errorCode: "push_receipt_unavailable" };
+  }
+  if (receipt.status === "ok") return { kind: "delivered" };
+  return expoResultFailure(receipt, true);
+}
+
+function buildExpoMessage(delivery: ClaimedRemotePushDelivery) {
+  const payload = readRecord(delivery.payload);
+  const title = boundedString(payload?.title, 120) ?? "Agent Native update";
+  const body = boundedString(payload?.body, 300);
+  const data = compactData(payload);
+  return {
+    to: delivery.token,
+    title,
+    ...(body ? { body } : {}),
+    sound: "default",
+    priority: "high",
+    data: {
+      url: "agentnative://sessions",
+      ...data,
+    },
+  };
+}
+
+function compactData(payload: Record<string, unknown> | null) {
+  if (!payload) return {};
+  const data: Record<string, string | number> = {};
+  for (const key of ["commandId", "hostId", "kind", "status"] as const) {
+    const value = boundedString(payload[key], 200);
+    if (value) data[key] = value;
+  }
+  if (
+    typeof payload.updatedAt === "number" &&
+    Number.isFinite(payload.updatedAt)
+  ) {
+    data.updatedAt = payload.updatedAt;
+  }
+  return data;
+}
+
+function expoRequestInit(body: unknown): RequestInit {
+  const headers: Record<string, string> = {
+    Accept: "application/json",
+    "Content-Type": "application/json",
+  };
+  const accessToken = process.env.EXPO_ACCESS_TOKEN?.trim();
+  if (accessToken) headers.Authorization = `Bearer ${accessToken}`;
+  return { method: "POST", headers, body: JSON.stringify(body) };
+}
+
+async function fetchWithTimeout(
+  fetchImpl: typeof fetch,
+  url: string,
+  init: RequestInit,
+): Promise<Response> {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  try {
+    return await fetchImpl(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+async function readExpoResponse(response: Response): Promise<ExpoPushResponse> {
+  const body = await response.json().catch(() => null);
+  return (readRecord(body) ?? {}) as ExpoPushResponse;
+}
+
+function responseFailure(
+  status: number,
+  body: ExpoPushResponse,
+): DeliveryOutcome {
+  const code = boundedString(body.errors?.[0]?.code, 120);
+  if (status === 429 || status >= 500) {
+    return { kind: "retry", errorCode: code ?? `expo_http_${status}` };
+  }
+  return { kind: "failed", errorCode: code ?? `expo_http_${status}` };
+}
+
+function expoResultFailure(
+  result: ExpoResult,
+  fromReceipt: boolean,
+): DeliveryOutcome {
+  const code = boundedString(result.details?.error, 120) ?? "expo_push_error";
+  if (code === "DeviceNotRegistered") {
+    return { kind: "failed", errorCode: code, deactivate: true };
+  }
+  if (code === "MessageRateExceeded") {
+    return { kind: "retry", errorCode: code, resend: fromReceipt };
+  }
+  return { kind: "failed", errorCode: code };
+}
+
+function retryDelayMs(attempt: number): number {
+  return Math.min(60 * 60_000, 5_000 * 2 ** Math.max(0, attempt - 1));
+}
+
+function classifyTransportError(error: unknown): string {
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return "expo_request_timeout";
+  }
+  return "expo_transport_error";
+}
+
+function isExpoPushToken(value: string): boolean {
+  return /^(Expo(nent)?PushToken)\[[A-Za-z0-9_-]+\]$/.test(value);
+}
+
+function isExpoResult(value: unknown): value is ExpoResult {
+  return value !== null && typeof value === "object" && "status" in value;
+}
+
+function readRecord(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+function boundedString(value: unknown, maxLength: number): string | null {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed ? trimmed.slice(0, maxLength) : null;
+}