@agent-native/core 0.109.2 → 0.109.4

package/corpus/core/src/collab/agent-identity.ts

@@ -1,22 +1,5 @@
-/**
- * Canonical agent identity constants for collaborative editing.
- *
- * Centralizes the agent's client ID, name, email, and cursor color
- * so templates don't hardcode these values.
- */
-
-export const AGENT_CLIENT_ID = 2147483647; // Max 32-bit signed int, reserved for agent
-
-export interface AgentIdentity {
-  clientId: number;
-  name: string;
-  email: string;
-  color: string;
-}
-
-export const DEFAULT_AGENT_IDENTITY: AgentIdentity = {
-  clientId: AGENT_CLIENT_ID,
-  name: "AI Assistant",
-  email: "agent@system",
-  color: "#00B5FF", // agent-native blue
-};
+export {
+  AGENT_CLIENT_ID,
+  DEFAULT_AGENT_IDENTITY,
+  type AgentIdentity,
+} from "@agent-native/toolkit/collab-ui";

package/corpus/core/src/collab/client.ts

@@ -45,12 +45,11 @@ import * as Y from "yjs";
 
 import { agentNativePath } from "../client/api-path.js";
 import { subscribeSyncEvents, type SyncEvent } from "../client/use-db-sync.js";
-import { AGENT_CLIENT_ID } from "./agent-identity.js";
-
 export {
   dedupeCollabUsersByEmail,
   emailToColor,
   emailToName,
+  isReconcileLeadClient,
   type CollabUser,
 } from "@agent-native/toolkit/collab-ui";
 
@@ -119,57 +118,6 @@ function collabUsersEqual(a: CollabUser[], b: CollabUser[]): boolean {
   return true;
 }
 
-/**
- * Leader election for applying authoritative external snapshots into a shared
- * collaborative document.
- *
- * When the agent (or a Notion pull, or any full-document rewrite) writes new
- * content to SQL, the open editor reconciles it into the live Y.Doc with
- * `setContent`. If EVERY connected client did that independently, each would
- * diff the same snapshot into the CRDT and the changed region would be inserted
- * N times (concurrent inserts at the same position → duplicated text). So only
- * ONE client — the "lead" — applies the snapshot; every other client receives
- * the result through normal Yjs sync.
- *
- * The lead is the present client with the lowest Yjs `clientID`. The agent's
- * awareness entry uses `AGENT_CLIENT_ID` (max int) so it can never be the lead,
- * and a client editing alone is always the lead. This is deterministic across
- * clients with no coordination round-trip.
- */
-export function isReconcileLeadClient(
-  awareness: Awareness | null | undefined,
-  localClientId: number | null | undefined,
-): boolean {
-  if (localClientId == null) return false;
-  if (!awareness) return true; // standalone / tests — act alone
-
-  let hasPeer = false;
-  let minVisible = localClientId;
-  awareness.getStates().forEach((state, clientId) => {
-    if (clientId === AGENT_CLIENT_ID) return; // agent never leads
-    if (clientId === localClientId) return;
-    const s = state as { user?: unknown; visible?: boolean };
-    if (!s || !s.user) return; // skip empty/stale entries
-    hasPeer = true;
-    // Only VISIBLE peers can act; a peer published `visible: false` (backgrounded)
-    // is skipped. A peer that hasn't published the field is treated as visible.
-    if (s.visible !== false && clientId < minVisible) minVisible = clientId;
-  });
-
-  // Sole client: always the applier — no other client can duplicate the edit,
-  // so single-user agent edits apply even if this tab reports hidden.
-  if (!hasPeer) return true;
-
-  // With peers present, exactly one VISIBLE client applies (the lowest clientId
-  // among visible ones). A backgrounded tab pauses its poll and can't reliably
-  // act, so it yields — otherwise an agent edit would never reach the tab the
-  // user is actually looking at. The caller re-elects on visibility change.
-  const localHidden =
-    typeof document !== "undefined" && document.visibilityState === "hidden";
-  if (localHidden) return false;
-  return localClientId <= minVisible;
-}
-
 export interface RemoteAwarenessSnapshot {
   clientId: number;
   state: unknown;

package/corpus/core/src/db/client.ts

@@ -10,6 +10,11 @@
  */
 import path from "path";
 
+import {
+  beginDatabaseOperation,
+  recordDatabaseRetry,
+} from "./request-telemetry.js";
+
 const recyclingPostgresPools = new WeakSet<object>();
 const loggedNeonPools = new WeakSet<object>();
 
@@ -735,6 +740,7 @@ export async function retryOnConnectionError<T>(
     } catch (e) {
       last = e;
       if (!isConnectionError(e) || attempt === maxAttempts - 1) throw e;
+      recordDatabaseRetry();
       await new Promise((r) => setTimeout(r, 100 * (attempt + 1)));
     }
   }
@@ -790,6 +796,9 @@ export async function withDbTimeout<T>(
 ): Promise<T> {
   let timer: ReturnType<typeof setTimeout> | undefined;
   let settled = false;
+  const finishTelemetry = beginDatabaseOperation(
+    op === "connect" ? "connect" : "query",
+  );
 
   const runCleanup = async () => {
     if (!onTimeout) return;
@@ -811,12 +820,14 @@ export async function withDbTimeout<T>(
       if (settled) return;
       settled = true;
       if (timer) clearTimeout(timer);
+      finishTelemetry("success");
       complete(value);
     };
     const fail = (err: unknown) => {
       if (settled) return;
       settled = true;
       if (timer) clearTimeout(timer);
+      finishTelemetry("error");
       reject(err);
     };
 
@@ -825,6 +836,7 @@ export async function withDbTimeout<T>(
       settled = true;
       void (async () => {
         await runCleanup();
+        finishTelemetry("timeout");
         reject(new DbTimeoutError(op, ms));
       })();
     }, ms);
@@ -1171,13 +1183,7 @@ async function createDbExecInternal(
             return retryOnConnectionError<{
               rows: unknown[];
               rowsAffected: number;
-            }>(() =>
-              withDbTimeout(
-                "http-query",
-                () => queryNeonClient(pool, sql),
-                dbOpTimeoutMs(),
-              ),
-            );
+            }>(() => queryNeonClient(pool, sql));
           }
           const result = await retryOnConnectionError<{
             rows: unknown[];

package/corpus/core/src/db/create-get-db.ts

@@ -84,23 +84,28 @@ export function isSqlRead(sql: string): boolean {
  * connection the transaction needs. The pool-level error logger still fires
  * on idle-client drops inside transactions.
  */
-export function buildResilientNeonPool(pool: {
-  connect(): Promise<any>;
-  query(
-    sql: string,
-    args?: any[],
-  ): Promise<{ rows: unknown[]; rowCount?: number }>;
-  end(): Promise<void>;
-  on(event: string, listener: (...args: any[]) => void): unknown;
-}): typeof pool {
+export function buildResilientNeonPool<
+  T extends {
+    connect(): Promise<any>;
+    query(...args: any[]): Promise<any>;
+    end(): Promise<void>;
+    on(event: string, listener: (...args: any[]) => void): unknown;
+  },
+>(pool: T): T {
   // Preserve all original pool methods and properties; only override `connect`
   // and `query` at the Pool level (used by drizzle's neon-serverless adapter
   // when it calls pool.query() directly, e.g. outside a transaction).
   const resilientQuery = async (
-    sql: string,
+    sql: string | { text?: unknown },
     args?: any[],
   ): Promise<{ rows: unknown[]; rowCount?: number }> => {
-    const isRead = isSqlRead(sql);
+    const sqlText =
+      typeof sql === "string"
+        ? sql
+        : typeof sql?.text === "string"
+          ? sql.text
+          : "";
+    const isRead = isSqlRead(sqlText);
 
     const runAttempt = async (): Promise<{
       rows: unknown[];
@@ -135,7 +140,9 @@ export function buildResilientNeonPool(pool: {
         const result = await withDbTimeout(
           "query",
           () =>
-            client.query(sql, args ?? []) as Promise<{
+            (args === undefined
+              ? client.query(sql)
+              : client.query(sql, args)) as Promise<{
               rows: unknown[];
               rowCount?: number;
             }>,
@@ -180,7 +187,7 @@ export function buildResilientNeonPool(pool: {
       const val = (target as any)[prop];
       return typeof val === "function" ? val.bind(target) : val;
     },
-  });
+  }) as T;
 }
 
 /**

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