@agent-native/core 0.144.2 → 0.145.0

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 7847
+- template files: 7848

package/corpus/templates/analytics/app/pages/DataSources.tsx

@@ -166,10 +166,24 @@ async function testConnection(
   return res.json();
 }
 
+// Bounds the GitHub status fetch so a hang can't leave the connect poll's
+// `inFlight` guard stuck and stall the interval forever.
+const GITHUB_OAUTH_STATUS_ABORT_MS = 10_000;
+
 async function fetchGitHubOAuthStatus(): Promise<GitHubOAuthStatus> {
-  const res = await fetch(
-    agentNativePath("/_agent-native/oauth/github/status"),
+  const controller = new AbortController();
+  const abortTimer = setTimeout(
+    () => controller.abort(),
+    GITHUB_OAUTH_STATUS_ABORT_MS,
   );
+  let res: Response;
+  try {
+    res = await fetch(agentNativePath("/_agent-native/oauth/github/status"), {
+      signal: controller.signal,
+    });
+  } finally {
+    clearTimeout(abortTimer);
+  }
   if (!res.ok) {
     const data = await res.json().catch(() => ({}));
     throw new Error(data.error || "Failed to load GitHub status");
@@ -374,8 +388,18 @@ function GitHubOAuthView({
     },
     onSuccess: () => {
       const startedAt = Date.now();
-      const pollId = window.setInterval(() => {
-        refresh();
+      let inFlight = false;
+      const pollId = window.setInterval(async () => {
+        if (document.hidden || inFlight) return;
+        inFlight = true;
+        try {
+          await queryClient.invalidateQueries({
+            queryKey: ["github-oauth-status"],
+          });
+          onSaved();
+        } finally {
+          inFlight = false;
+        }
         if (Date.now() - startedAt > 120_000) {
           window.clearInterval(pollId);
         }

package/corpus/templates/analytics/server/jobs/dashboard-report.ts

@@ -15,6 +15,11 @@ declare global {
 
 let running = false;
 const DEFAULT_MAX_REPORTS_PER_SWEEP = 5;
+// Bounds snapshot/panel/render work per subscription. Originally only applied
+// in serverless mode to fit the function's execution limit; it now also
+// backstops the long-running in-process cron, where a hung query or render
+// call would otherwise leave `running` stuck forever instead of just
+// delaying the next sweep.
 const SERVERLESS_REPORT_DELIVERY_BUDGET_MS = 220_000;
 const SERVERLESS_MAX_REPORTS_PER_SWEEP = 1;
 
@@ -131,9 +136,8 @@ export async function runDashboardReportsOnce(): Promise<{
     remaining = batch.length >= sweepLimit ? 1 : 0;
     for (const sub of batch) {
       processed++;
-      const deliveryDeadlineAt = serverlessDashboardReportRuntime()
-        ? Date.now() + SERVERLESS_REPORT_DELIVERY_BUDGET_MS
-        : undefined;
+      const deliveryDeadlineAt =
+        Date.now() + SERVERLESS_REPORT_DELIVERY_BUDGET_MS;
       const retryAt = dashboardReportRetryAt(sub);
       try {
         const result = await runWithRequestContext(

package/corpus/templates/analytics/server/plugins/dashboard-report-jobs.ts

@@ -1,7 +1,7 @@
 import { runDashboardReportsOnce } from "../jobs/dashboard-report";
 import { isProductionServerlessRuntime } from "../lib/production-serverless-runtime";
 
-const INTERVAL_MS = 60_000;
+const DEFAULT_INTERVAL_MS = 60_000;
 let skippingLogged = false;
 
 declare global {
@@ -15,6 +15,15 @@ function platformSchedulerOwnsReports(): boolean {
   );
 }
 
+function intervalMs(): number {
+  const raw = process.env.DASHBOARD_REPORT_INTERVAL_MS?.trim();
+  if (!raw) return DEFAULT_INTERVAL_MS;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed >= 10_000
+    ? parsed
+    : DEFAULT_INTERVAL_MS;
+}
+
 export default function registerDashboardReportJobs(): void {
   const isProd = process.env.NODE_ENV === "production";
   const flag =
@@ -36,13 +45,14 @@ export default function registerDashboardReportJobs(): void {
     return;
   }
 
+  const ms = intervalMs();
   setInterval(() => {
     runDashboardReportsOnce().catch((err) =>
       console.error("[dashboard-report] interval failed:", err),
     );
-  }, INTERVAL_MS);
+  }, ms);
 
   console.log(
-    `[dashboard-report] Recurring dashboard report sweep every ${INTERVAL_MS / 1000}s.`,
+    `[dashboard-report] Recurring dashboard report sweep every ${ms / 1000}s.`,
   );
 }

package/corpus/templates/calendar/app/components/calendar/GoogleConnectBanner.tsx

@@ -73,6 +73,11 @@ function getSetupSteps(t: CalendarT) {
   ];
 }
 
+const STATUS_POLL_INTERVAL_MS = 2000;
+// Bounds each status poll so a hung fetch can't leave the in-flight guard
+// permanently stuck and stall the interval forever.
+const STATUS_POLL_ABORT_MS = Math.max(10_000, STATUS_POLL_INTERVAL_MS * 4);
+
 interface GoogleConnectBannerProps {
   variant?: "banner" | "hero";
 }
@@ -99,6 +104,8 @@ export function GoogleConnectBanner({
   const isBuilderFrame = useMemo(() => isInBuilderFrame(), []);
   const authPollRef = useRef<ReturnType<typeof setInterval> | null>(null);
   const addAccountPollRef = useRef<ReturnType<typeof setInterval> | null>(null);
+  const authPollInFlightRef = useRef(false);
+  const addAccountPollInFlightRef = useRef(false);
   const {
     isDesktopGoogleAuth,
     isGoogleDesktopAuthPending,
@@ -165,21 +172,38 @@ export function GoogleConnectBanner({
 
     if (authPollRef.current) clearInterval(authPollRef.current);
     authPollRef.current = setInterval(async () => {
-      const res = await fetch(
-        agentNativePath("/_agent-native/google/status"),
-      ).catch(() => null);
-      if (res?.ok) {
-        const data = await res.json();
-        if (data.connected) {
-          if (authPollRef.current) {
-            clearInterval(authPollRef.current);
-            authPollRef.current = null;
+      if (document.hidden || authPollInFlightRef.current) return;
+      authPollInFlightRef.current = true;
+      const controller = new AbortController();
+      const abortTimer = setTimeout(
+        () => controller.abort(),
+        STATUS_POLL_ABORT_MS,
+      );
+      try {
+        const res = await fetch(
+          agentNativePath("/_agent-native/google/status"),
+          { signal: controller.signal },
+        )
+          // coercion-ok: a failed probe and a not-yet-connected response both
+          // mean "stay on the connect banner"; this loop only ever acts on an
+          // observed success, and credential errors surface via authUrl.error.
+          .catch(() => null);
+        if (res?.ok) {
+          const data = await res.json();
+          if (data.connected) {
+            if (authPollRef.current) {
+              clearInterval(authPollRef.current);
+              authPollRef.current = null;
+            }
+            setDismissed(true);
+            window.location.reload();
           }
-          setDismissed(true);
-          window.location.reload();
         }
+      } finally {
+        clearTimeout(abortTimer);
+        authPollInFlightRef.current = false;
       }
-    }, 2000);
+    }, STATUS_POLL_INTERVAL_MS);
   }, [wantAuthUrl, authUrl.data, isBuilderFrame]);
 
   // When auth URL fails with missing credentials, show wizard
@@ -242,20 +266,37 @@ export function GoogleConnectBanner({
     const prevCount = accounts.length;
     if (addAccountPollRef.current) clearInterval(addAccountPollRef.current);
     addAccountPollRef.current = setInterval(async () => {
-      const res = await fetch(
-        agentNativePath("/_agent-native/google/status"),
-      ).catch(() => null);
-      if (res?.ok) {
-        const data = await res.json();
-        if (data.accounts?.length > prevCount) {
-          if (addAccountPollRef.current) {
-            clearInterval(addAccountPollRef.current);
-            addAccountPollRef.current = null;
+      if (document.hidden || addAccountPollInFlightRef.current) return;
+      addAccountPollInFlightRef.current = true;
+      const controller = new AbortController();
+      const abortTimer = setTimeout(
+        () => controller.abort(),
+        STATUS_POLL_ABORT_MS,
+      );
+      try {
+        const res = await fetch(
+          agentNativePath("/_agent-native/google/status"),
+          { signal: controller.signal },
+        )
+          // coercion-ok: a failed probe and a not-yet-connected response both
+          // mean "stay on the connect banner"; this loop only ever acts on an
+          // observed success, and credential errors surface via authUrl.error.
+          .catch(() => null);
+        if (res?.ok) {
+          const data = await res.json();
+          if (data.accounts?.length > prevCount) {
+            if (addAccountPollRef.current) {
+              clearInterval(addAccountPollRef.current);
+              addAccountPollRef.current = null;
+            }
+            window.location.reload();
           }
-          window.location.reload();
         }
+      } finally {
+        clearTimeout(abortTimer);
+        addAccountPollInFlightRef.current = false;
       }
-    }, 2000);
+    }, STATUS_POLL_INTERVAL_MS);
     // accounts.length is captured into prevCount above; including it in deps
     // would tear down and recreate the interval whenever the count changes.
     // eslint-disable-next-line react-hooks/exhaustive-deps

package/corpus/templates/calendar/app/hooks/use-google-auth.ts

@@ -37,6 +37,14 @@ interface DesktopGlobals {
   electronAPI?: unknown;
 }
 
+const DESKTOP_AUTH_POLL_INTERVAL_MS = 1500;
+// Bounds each poll tick's fetches so a hung request can't leave
+// pollInFlightRef stuck and stall the interval forever.
+const DESKTOP_AUTH_POLL_ABORT_MS = Math.max(
+  10_000,
+  DESKTOP_AUTH_POLL_INTERVAL_MS * 4,
+);
+
 function bodyError(
   body: any,
   raw: string | undefined,
@@ -188,6 +196,7 @@ export function useGoogleAddAccountUrl(enabled = false) {
 export function useGoogleDesktopAuth(options: DesktopAuthOptions = {}) {
   const { onError, onSuccess, timeoutMs = 120_000 } = options;
   const pollRef = useRef<ReturnType<typeof setInterval> | null>(null);
+  const pollInFlightRef = useRef(false);
   const [isPending, setIsPending] = useState(false);
   const isDesktopGoogleAuth = useMemo(() => {
     if (typeof window === "undefined" || typeof navigator === "undefined") {
@@ -285,62 +294,76 @@ export function useGoogleDesktopAuth(options: DesktopAuthOptions = {}) {
       })();
 
       pollRef.current = setInterval(async () => {
+        if (document.hidden || pollInFlightRef.current) return;
+        pollInFlightRef.current = true;
+        const controller = new AbortController();
+        const abortTimer = setTimeout(
+          () => controller.abort(),
+          DESKTOP_AUTH_POLL_ABORT_MS,
+        );
         try {
-          const exchangeRes = await fetch(
-            agentNativePath(
-              `/_agent-native/auth/desktop-exchange?flow_id=${flowId}`,
-            ),
-            { credentials: "include" },
-          );
-          const exchange = await exchangeRes.json();
-          if (exchange?.error) {
-            clearPoll();
-            setIsPending(false);
-            onError?.(exchange);
-            return;
-          }
-          if (exchange?.token) {
-            await fetch(
+          try {
+            const exchangeRes = await fetch(
               agentNativePath(
-                `/_agent-native/auth/session?_session=${exchange.token}`,
+                `/_agent-native/auth/desktop-exchange?flow_id=${flowId}`,
               ),
-              { credentials: "include" },
+              { credentials: "include", signal: controller.signal },
             );
-            await finish({ token: exchange.token, email: exchange.email });
-            return;
+            const exchange = await exchangeRes.json();
+            if (exchange?.error) {
+              clearPoll();
+              setIsPending(false);
+              onError?.(exchange);
+              return;
+            }
+            if (exchange?.token) {
+              await fetch(
+                agentNativePath(
+                  `/_agent-native/auth/session?_session=${exchange.token}`,
+                ),
+                { credentials: "include", signal: controller.signal },
+              );
+              await finish({ token: exchange.token, email: exchange.email });
+              return;
+            }
+          } catch {
+            // coercion-ok: keep polling; the status endpoint below may still
+            // observe success, and the timeout below reports desktop_auth_timeout.
           }
-        } catch {
-          // Keep polling; the status endpoint below may still observe success.
-        }
 
-        try {
-          const statusRes = await fetch(
-            agentNativePath("/_agent-native/google/status"),
-            { credentials: "include" },
-          );
-          if (statusRes.ok) {
-            const status = (await statusRes.json()) as GoogleAuthStatus;
-            const connected = startOptions.addAccount
-              ? (status.accounts?.length ?? 0) >
-                (startOptions.previousAccountCount ?? 0)
-              : status.connected;
-            if (connected) {
-              await finish();
-              return;
+          try {
+            const statusRes = await fetch(
+              agentNativePath("/_agent-native/google/status"),
+              { credentials: "include", signal: controller.signal },
+            );
+            if (statusRes.ok) {
+              const status = (await statusRes.json()) as GoogleAuthStatus;
+              const connected = startOptions.addAccount
+                ? (status.accounts?.length ?? 0) >
+                  (startOptions.previousAccountCount ?? 0)
+                : status.connected;
+              if (connected) {
+                await finish();
+                return;
+              }
             }
+          } catch {
+            // coercion-ok: keep polling until the bounded timeout below, which
+            // reports desktop_auth_timeout rather than failing silently.
           }
-        } catch {
-          // Keep polling until the timeout.
-        }
 
-        if (Date.now() - startedAt > timeoutMs) {
-          reportError({
-            code: "desktop_auth_timeout",
-            message:
-              "Google sign-in timed out. Finish sign-in in the browser or try again.",
-          });
+          if (Date.now() - startedAt > timeoutMs) {
+            reportError({
+              code: "desktop_auth_timeout",
+              message:
+                "Google sign-in timed out. Finish sign-in in the browser or try again.",
+            });
+          }
+        } finally {
+          clearTimeout(abortTimer);
+          pollInFlightRef.current = false;
         }
-      }, 1500);
+      }, DESKTOP_AUTH_POLL_INTERVAL_MS);
 
       return true;
     },

package/corpus/templates/calendar/app/hooks/use-view-preferences.ts

@@ -104,12 +104,25 @@ function save(prefs: CalendarViewPreferences) {
   } catch {}
 }
 
+const REFRESH_INTERVAL_MS = 2_000;
+// Bounds the refresh fetch so a hung request can't stall the self-rescheduling
+// setTimeout loop forever.
+const REFRESH_ABORT_MS = Math.max(10_000, REFRESH_INTERVAL_MS * 4);
+
 async function readAppStatePreferences(): Promise<CalendarViewPreferences | null> {
-  const res = await fetch(
-    agentNativePath(
-      `/_agent-native/application-state/${CALENDAR_VIEW_PREFERENCES_KEY}`,
-    ),
-  );
+  const controller = new AbortController();
+  const abortTimer = setTimeout(() => controller.abort(), REFRESH_ABORT_MS);
+  let res: Response;
+  try {
+    res = await fetch(
+      agentNativePath(
+        `/_agent-native/application-state/${CALENDAR_VIEW_PREFERENCES_KEY}`,
+      ),
+      { signal: controller.signal },
+    );
+  } finally {
+    clearTimeout(abortTimer);
+  }
   if (res.status === 404) return null;
   if (!res.ok) throw new Error(`${res.status}`);
   return normalizeCalendarViewPreferences(await res.json());
@@ -141,6 +154,11 @@ export function useViewPreferences() {
     let timeout: number | undefined;
 
     async function refresh() {
+      if (document.hidden) {
+        if (!cancelled)
+          timeout = window.setTimeout(refresh, REFRESH_INTERVAL_MS);
+        return;
+      }
       try {
         const remote = await readAppStatePreferences();
         if (!cancelled && remote) {
@@ -182,13 +200,24 @@ export function useViewPreferences() {
         // Preferences are a UI convenience; keep the local copy if app-state
         // is temporarily unavailable.
       } finally {
-        if (!cancelled) timeout = window.setTimeout(refresh, 2_000);
+        if (!cancelled)
+          timeout = window.setTimeout(refresh, REFRESH_INTERVAL_MS);
+      }
+    }
+
+    function handleVisibilityChange() {
+      if (!document.hidden && timeout) {
+        window.clearTimeout(timeout);
+        timeout = undefined;
+        void refresh();
       }
     }
+    document.addEventListener("visibilitychange", handleVisibilityChange);
 
     void refresh();
     return () => {
       cancelled = true;
+      document.removeEventListener("visibilitychange", handleVisibilityChange);
       if (timeout) window.clearTimeout(timeout);
     };
   }, []);

package/corpus/templates/calendar/app/hooks/use-zoom-auth.ts

@@ -9,8 +9,22 @@ export interface ZoomAuthStatus {
   accounts: Array<{ id: string; email?: string; displayName?: string }>;
 }
 
+// Bounds every zoom fetch so a hung request can't leave the status poll's
+// `inFlight` guard stuck forever.
+const FETCH_ABORT_MS = 10_000;
+
 async function fetchJson<T>(input: string, init?: RequestInit): Promise<T> {
-  const res = await fetch(input, init);
+  const controller = new AbortController();
+  const abortTimer = setTimeout(() => controller.abort(), FETCH_ABORT_MS);
+  let res: Response;
+  try {
+    res = await fetch(input, {
+      ...init,
+      signal: init?.signal ?? controller.signal,
+    });
+  } finally {
+    clearTimeout(abortTimer);
+  }
   if (!res.ok) {
     let message = `${input} -> ${res.status}`;
     try {
@@ -124,8 +138,15 @@ export function useConnectZoom() {
       queryClient.invalidateQueries({ queryKey: ["zoom-status"] });
 
       const startedAt = Date.now();
-      const pollId = window.setInterval(() => {
-        queryClient.invalidateQueries({ queryKey: ["zoom-status"] });
+      let inFlight = false;
+      const pollId = window.setInterval(async () => {
+        if (document.hidden || inFlight) return;
+        inFlight = true;
+        try {
+          await queryClient.invalidateQueries({ queryKey: ["zoom-status"] });
+        } finally {
+          inFlight = false;
+        }
         if (Date.now() - startedAt > 120_000) {
           window.clearInterval(pollId);
         }

package/corpus/templates/clips/app/components/player/transcript-panel.tsx

@@ -594,6 +594,8 @@ function TranscriptSetupCard({
   const [connectError, setConnectError] = useState<string | null>(null);
   const pollRef = useRef<ReturnType<typeof setInterval> | null>(null);
   const mountedRef = useRef(true);
+  const inFlightRef = useRef(false);
+  const visibilityHandlerRef = useRef<(() => void) | null>(null);
 
   const autoRetryRef = useRef(false);
   const onRetryRef = useRef(onRetry);
@@ -602,6 +604,16 @@ function TranscriptSetupCard({
     onRetryRef.current = onRetry;
   }, [onRetry]);
 
+  const stopVisibilityHandler = useCallback(() => {
+    if (visibilityHandlerRef.current) {
+      document.removeEventListener(
+        "visibilitychange",
+        visibilityHandlerRef.current,
+      );
+      visibilityHandlerRef.current = null;
+    }
+  }, []);
+
   useEffect(() => {
     mountedRef.current = true;
     fetch(agentNativePath("/_agent-native/builder/status"))
@@ -617,8 +629,9 @@ function TranscriptSetupCard({
     return () => {
       mountedRef.current = false;
       if (pollRef.current) clearInterval(pollRef.current);
+      stopVisibilityHandler();
     };
-  }, []);
+  }, [stopVisibilityHandler]);
 
   useEffect(() => {
     if (!builderConfigured || autoRetryRef.current) return;
@@ -630,36 +643,62 @@ function TranscriptSetupCard({
 
   const handleConnect = useCallback(() => {
     if (pollRef.current) clearInterval(pollRef.current);
+    stopVisibilityHandler();
+    inFlightRef.current = false;
     setConnecting(true);
     setConnectError(null);
 
     openBuilderConnectPopup({ source: "clips_transcript_panel" });
 
     const start = Date.now();
-    pollRef.current = setInterval(async () => {
+    const tick = async () => {
+      if (document.hidden || inFlightRef.current) return;
+      inFlightRef.current = true;
+      const controller = new AbortController();
+      const abortTimer = setTimeout(
+        () => controller.abort(),
+        Math.max(10_000, 2000 * 4),
+      );
       try {
-        const r = await fetch(agentNativePath("/_agent-native/builder/status"));
+        const r = await fetch(
+          agentNativePath("/_agent-native/builder/status"),
+          {
+            signal: controller.signal,
+          },
+        );
         if (!r.ok) return;
         const s = (await r.json()) as { configured: boolean };
         if (!mountedRef.current) {
           clearInterval(pollRef.current!);
+          stopVisibilityHandler();
           return;
         }
         if (s.configured) {
           clearInterval(pollRef.current!);
+          stopVisibilityHandler();
           setBuilderConfigured(true);
           setConnecting(false);
           onRetry?.();
         } else if (Date.now() - start > 5 * 60 * 1000) {
           clearInterval(pollRef.current!);
+          stopVisibilityHandler();
           setConnecting(false);
           setConnectError(t("transcriptPanel.builderNoResponse"));
         }
       } catch {
-        // transient poll error — keep trying
+        // coercion-ok: a transient poll error keeps the loop running; the
+        // 5-minute bound above surfaces builderNoResponse if it never succeeds.
+      } finally {
+        clearTimeout(abortTimer);
+        inFlightRef.current = false;
       }
-    }, 2000);
-  }, [onRetry]);
+    };
+    pollRef.current = setInterval(() => void tick(), 2000);
+    visibilityHandlerRef.current = () => {
+      if (!document.hidden) void tick();
+    };
+    document.addEventListener("visibilitychange", visibilityHandlerRef.current);
+  }, [onRetry, stopVisibilityHandler]);
 
   const isProviderError =
     !isBuilderCreditsExhaustedMessage(failureReason) &&