@agent-native/core 0.109.1 → 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/deploy/build.ts

@@ -138,6 +138,14 @@ export const CLOUDFLARE_WORKER_STUB_MODULES: Record<string, string> = {
     "export default { Resvg };",
     "",
   ].join("\n"),
+  playwright: [
+    "const unavailable = async () => { throw new Error('playwright unavailable in Cloudflare Pages worker'); };",
+    "export const chromium = { launch: unavailable, connect: unavailable, connectOverCDP: unavailable };",
+    "export const firefox = { launch: unavailable, connect: unavailable };",
+    "export const webkit = { launch: unavailable, connect: unavailable };",
+    "export default { chromium, firefox, webkit };",
+    "",
+  ].join("\n"),
   "playwright-core": [
     "const unavailable = async () => { throw new Error('playwright-core unavailable in Cloudflare Pages worker'); };",
     "export const chromium = { launch: unavailable };",
@@ -187,6 +195,50 @@ export const CLOUDFLARE_WORKER_STUB_MODULES: Record<string, string> = {
     "export default async () => ({ elements: [], files: {} });\n",
 };
 
+export const CLOUDFLARE_WORKER_STUB_SUBPATH_MODULES: Record<string, string> = {
+  "pdf-parse/worker": [
+    "const unavailable = async () => { throw new Error('pdf-parse/worker unavailable in Cloudflare Pages worker'); };",
+    "export class CanvasFactory {}",
+    "export const getData = unavailable;",
+    "export default { CanvasFactory, getData };",
+    "",
+  ].join("\n"),
+};
+
+export function cloudflareWorkerStubAliasArgs(stubDir: string): string[] {
+  const subpathAliases = Object.keys(CLOUDFLARE_WORKER_STUB_SUBPATH_MODULES)
+    .sort((a, b) => b.length - a.length)
+    .map(
+      (mod) =>
+        `--alias:${mod}=${path.join(stubDir, `${mod.replace(/\//g, "__")}.js`)}`,
+    );
+  const packageAliases = Object.keys(CLOUDFLARE_WORKER_STUB_MODULES)
+    .sort((a, b) => b.length - a.length)
+    .map((mod) => `--alias:${mod}=${path.join(stubDir, mod, "index.js")}`);
+  return [...subpathAliases, ...packageAliases];
+}
+
+export function assertNoCloudflareWorkerStubDynamicImports(
+  code: string,
+  sourceName: string,
+): void {
+  const stubbedModules = [
+    ...Object.keys(CLOUDFLARE_WORKER_STUB_SUBPATH_MODULES),
+    ...Object.keys(CLOUDFLARE_WORKER_STUB_MODULES),
+  ];
+  const pattern = stubbedModules
+    .sort((a, b) => b.length - a.length)
+    .map((moduleName) => moduleName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+    .join("|");
+  const unresolvedImport = code.match(
+    new RegExp(`\\bimport\\s*\\(\\s*(["'])(${pattern})\\1\\s*\\)`),
+  );
+  if (!unresolvedImport) return;
+  throw new Error(
+    `Cloudflare worker output ${sourceName} retained a dynamic import for stubbed module "${unresolvedImport[2]}". Use a literal import so the worker bundler can apply its fail-closed stub.`,
+  );
+}
+
 function cloudflareNodeBuiltinStubSource(
   moduleName: string,
   namedExports: string[],
@@ -1666,9 +1718,15 @@ async function buildCloudflarePages() {
       JSON.stringify({ name: mod, main: "index.js", type: "module" }),
     );
   }
-  const stubAliases = Object.keys(CLOUDFLARE_WORKER_STUB_MODULES).map(
-    (mod) => `--alias:${mod}=${path.join(stubDir, mod, "index.js")}`,
-  );
+  for (const [mod, source] of Object.entries(
+    CLOUDFLARE_WORKER_STUB_SUBPATH_MODULES,
+  )) {
+    fs.writeFileSync(
+      path.join(stubDir, `${mod.replace(/\//g, "__")}.js`),
+      source,
+    );
+  }
+  const stubAliases = cloudflareWorkerStubAliasArgs(stubDir);
   const nodeBuiltinStubDir = path.join(tmpDir, "node-builtin-stubs");
   fs.mkdirSync(nodeBuiltinStubDir, { recursive: true });
   const nodeBuiltinStubAliases: string[] = [];
@@ -1850,6 +1908,8 @@ async function buildCloudflarePages() {
       );
     }
 
+    assertNoCloudflareWorkerStubDynamicImports(code, jsFile);
+
     fs.writeFileSync(jsFile, code);
   }
 

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?.();
+}