@agent-native/core 0.109.2 → 0.109.3

package/corpus/core/src/db/request-telemetry.ts

@@ -0,0 +1,154 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+export type DatabaseOperationKind = "connect" | "query";
+
+export interface DatabaseRequestTelemetry {
+  operationCount: number;
+  queryCount: number;
+  connectCount: number;
+  retryCount: number;
+  errorCount: number;
+  timeoutCount: number;
+  operationTotalMs: number;
+  operationWallMs: number;
+  queryTotalMs: number;
+  connectTotalMs: number;
+  slowestOperationMs: number;
+  activeOperationCount: number;
+  activeWindowStartedAt?: number;
+}
+
+const STORAGE_KEY = Symbol.for(
+  "@agent-native/core/db.request-telemetry-storage",
+);
+const STARTUP_STATE_KEY = Symbol.for(
+  "@agent-native/core/db.startup-telemetry-state",
+);
+const STARTUP_CAPTURE_WINDOW_MS = 120_000;
+interface StartupDatabaseTelemetryState {
+  captureUntil: number;
+  claimed: boolean;
+  telemetry: DatabaseRequestTelemetry;
+}
+type GlobalWithDatabaseTelemetry = typeof globalThis & {
+  [STORAGE_KEY]?: AsyncLocalStorage<DatabaseRequestTelemetry>;
+  [STARTUP_STATE_KEY]?: StartupDatabaseTelemetryState;
+};
+
+const globalRef = globalThis as GlobalWithDatabaseTelemetry;
+const storage =
+  globalRef[STORAGE_KEY] ??
+  (globalRef[STORAGE_KEY] = new AsyncLocalStorage<DatabaseRequestTelemetry>());
+
+export function createDatabaseRequestTelemetry(): DatabaseRequestTelemetry {
+  return {
+    operationCount: 0,
+    queryCount: 0,
+    connectCount: 0,
+    retryCount: 0,
+    errorCount: 0,
+    timeoutCount: 0,
+    operationTotalMs: 0,
+    operationWallMs: 0,
+    queryTotalMs: 0,
+    connectTotalMs: 0,
+    slowestOperationMs: 0,
+    activeOperationCount: 0,
+  };
+}
+
+const startupState =
+  globalRef[STARTUP_STATE_KEY] ??
+  (globalRef[STARTUP_STATE_KEY] = {
+    captureUntil: Date.now() + STARTUP_CAPTURE_WINDOW_MS,
+    claimed: false,
+    telemetry: createDatabaseRequestTelemetry(),
+  });
+
+function currentDatabaseTelemetry(): DatabaseRequestTelemetry | undefined {
+  const requestTelemetry = storage.getStore();
+  if (requestTelemetry) return requestTelemetry;
+  if (!startupState.claimed && Date.now() <= startupState.captureUntil) {
+    return startupState.telemetry;
+  }
+  return undefined;
+}
+
+export function claimStartupDatabaseTelemetry():
+  | DatabaseRequestTelemetry
+  | undefined {
+  if (startupState.claimed) return undefined;
+  startupState.claimed = true;
+  return startupState.telemetry;
+}
+
+export function runWithDatabaseRequestTelemetry<T>(
+  telemetry: DatabaseRequestTelemetry,
+  fn: () => T,
+): T {
+  return storage.run(telemetry, fn);
+}
+
+export function enterDatabaseRequestTelemetry(
+  telemetry: DatabaseRequestTelemetry,
+): void {
+  storage.enterWith(telemetry);
+}
+
+export function beginDatabaseOperation(
+  operation: DatabaseOperationKind,
+): (outcome: "success" | "error" | "timeout") => void {
+  const telemetry = currentDatabaseTelemetry();
+  if (!telemetry) return () => {};
+
+  const startedAt = Date.now();
+  if (telemetry.activeOperationCount === 0) {
+    telemetry.activeWindowStartedAt = startedAt;
+  }
+  telemetry.activeOperationCount += 1;
+  let completed = false;
+
+  return (outcome) => {
+    if (completed) return;
+    completed = true;
+    const completedAt = Date.now();
+    const duration = Math.max(0, completedAt - startedAt);
+    telemetry.operationCount += 1;
+    telemetry.operationTotalMs += duration;
+    telemetry.slowestOperationMs = Math.max(
+      telemetry.slowestOperationMs,
+      duration,
+    );
+
+    if (operation === "connect") {
+      telemetry.connectCount += 1;
+      telemetry.connectTotalMs += duration;
+    } else {
+      telemetry.queryCount += 1;
+      telemetry.queryTotalMs += duration;
+    }
+
+    if (outcome !== "success") telemetry.errorCount += 1;
+    if (outcome === "timeout") telemetry.timeoutCount += 1;
+
+    telemetry.activeOperationCount = Math.max(
+      0,
+      telemetry.activeOperationCount - 1,
+    );
+    if (
+      telemetry.activeOperationCount === 0 &&
+      telemetry.activeWindowStartedAt !== undefined
+    ) {
+      telemetry.operationWallMs += Math.max(
+        0,
+        completedAt - telemetry.activeWindowStartedAt,
+      );
+      telemetry.activeWindowStartedAt = undefined;
+    }
+  };
+}
+
+export function recordDatabaseRetry(): void {
+  const telemetry = currentDatabaseTelemetry();
+  if (telemetry) telemetry.retryCount += 1;
+}

package/corpus/core/src/integrations/index.ts

@@ -84,6 +84,7 @@ export {
   unregisterRemotePushRegistrationForOwner,
   upsertRemotePushRegistration,
 } from "./remote-push-store.js";
+export { deliverPendingRemotePushNotifications } from "./remote-push-delivery.js";
 export type {
   ComputerApprovalScope,
   ComputerCommandAction,

package/corpus/core/src/integrations/plugin.ts

@@ -109,6 +109,7 @@ import {
   unregisterRemoteDevice,
   updateRemoteDeviceDetails,
 } from "./remote-devices-store.js";
+import { startRemotePushDeliveryJob } from "./remote-push-delivery-job.js";
 import {
   listRemotePushNotificationsForOwner,
   listRemotePushRegistrationsForOwner,
@@ -579,7 +580,6 @@ function mountedPathParts(event: any, mountSuffix: string): string[] {
 function remoteCommandPushPayload(
   command: RemoteCommand,
 ): Record<string, unknown> {
-  const result = readObject(command.result);
   const status = command.status;
   const title =
     status === "completed"
@@ -587,14 +587,19 @@ function remoteCommandPushPayload(
       : status === "failed"
         ? "Remote run failed"
         : "Remote run updated";
+  const body =
+    status === "completed"
+      ? "Open Agent Native to review the result."
+      : status === "failed"
+        ? "Open Agent Native to review the failure."
+        : "Open Agent Native to review the latest status.";
   return {
     title,
-    body: command.errorMessage ?? readString(result?.message),
+    body,
     commandId: command.id,
     hostId: command.deviceId,
     kind: command.kind,
     status,
-    result: command.result,
     updatedAt: command.updatedAt,
   };
 }
@@ -2897,6 +2902,7 @@ export function createIntegrationsPlugin(
     });
     startA2AContinuationRetryJob(adapterMap);
     startRemoteCommandsRetryJob();
+    startRemotePushDeliveryJob();
 
     // ─── Start Google Docs poller/push ────────────────────────────
     if (adapterMap.has("google-docs")) {

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

@@ -0,0 +1,48 @@
+import { deliverPendingRemotePushNotifications } from "./remote-push-delivery.js";
+
+const DELIVERY_INTERVAL_MS = 60_000;
+
+let retryInterval: ReturnType<typeof setInterval> | null = null;
+let initialTimer: ReturnType<typeof setTimeout> | null = null;
+let running = false;
+
+export async function runRemotePushDelivery(): Promise<void> {
+  if (running) return;
+  running = true;
+  try {
+    await deliverPendingRemotePushNotifications();
+  } catch (error) {
+    console.error("[integrations] Remote push delivery failed", {
+      error: error instanceof Error ? error.name : "UnknownError",
+    });
+  } finally {
+    running = false;
+  }
+}
+
+export function startRemotePushDeliveryJob(): void {
+  if (retryInterval) return;
+  initialTimer = setTimeout(() => void runRemotePushDelivery(), 10_000);
+  unrefTimer(initialTimer);
+  retryInterval = setInterval(
+    () => void runRemotePushDelivery(),
+    DELIVERY_INTERVAL_MS,
+  );
+  unrefTimer(retryInterval);
+}
+
+export function stopRemotePushDeliveryJob(): void {
+  if (initialTimer) {
+    clearTimeout(initialTimer);
+    initialTimer = null;
+  }
+  if (retryInterval) {
+    clearInterval(retryInterval);
+    retryInterval = null;
+  }
+  running = false;
+}
+
+function unrefTimer(timer: ReturnType<typeof setInterval>): void {
+  (timer as unknown as { unref?: () => void }).unref?.();
+}

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;
+}