@agent-native/core 0.144.1 → 0.144.3

package/corpus/templates/clips/desktop/src/app.tsx

@@ -427,6 +427,24 @@ function serverUrlForPendingUpload(
 // already-connected user to the setup flow.
 type VideoStorageProbe = "configured" | "missing" | "unknown";
 
+// Poll cadence for the caller's re-check loop is 5s; bound each probe request
+// well above that so a hung request can't wedge the poll's in-flight guard.
+const VIDEO_STORAGE_PROBE_TIMEOUT_MS = Math.max(10_000, 5000 * 4);
+
+async function fetchWithAbortTimeout(
+  url: string,
+  init: RequestInit,
+  timeoutMs: number,
+): Promise<Response> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 async function hasConfiguredVideoStorage(
   serverUrl: string,
 ): Promise<VideoStorageProbe> {
@@ -437,12 +455,13 @@ async function hasConfiguredVideoStorage(
   let sawDefinitiveAnswer = false;
 
   try {
-    const uploadStatus = await fetch(
+    const uploadStatus = await fetchWithAbortTimeout(
       `${base}/_agent-native/file-upload/status`,
       {
         credentials: "include",
         cache: "no-store",
       },
+      VIDEO_STORAGE_PROBE_TIMEOUT_MS,
     );
     if (uploadStatus.ok) {
       const body = (await uploadStatus.json().catch(() => null)) as {
@@ -458,10 +477,14 @@ async function hasConfiguredVideoStorage(
   }
 
   try {
-    const builderStatus = await fetch(`${base}/_agent-native/builder/status`, {
-      credentials: "include",
-      cache: "no-store",
-    });
+    const builderStatus = await fetchWithAbortTimeout(
+      `${base}/_agent-native/builder/status`,
+      {
+        credentials: "include",
+        cache: "no-store",
+      },
+      VIDEO_STORAGE_PROBE_TIMEOUT_MS,
+    );
     if (builderStatus.ok) {
       const body = (await builderStatus.json().catch(() => null)) as {
         configured?: boolean;
@@ -1143,10 +1166,23 @@ export function App() {
       return;
     }
 
-    const interval = window.setInterval(() => {
-      void refreshVideoStorageStatus();
-    }, 5000);
-    return () => window.clearInterval(interval);
+    let inFlight = false;
+    const tick = () => {
+      if (document.hidden || inFlight) return;
+      inFlight = true;
+      void refreshVideoStorageStatus().finally(() => {
+        inFlight = false;
+      });
+    };
+    const interval = window.setInterval(tick, 5000);
+    const onVisibilityChange = () => {
+      if (!document.hidden) tick();
+    };
+    document.addEventListener("visibilitychange", onVisibilityChange);
+    return () => {
+      window.clearInterval(interval);
+      document.removeEventListener("visibilitychange", onVisibilityChange);
+    };
   }, [
     authStatus,
     localRecordingMode,
@@ -1630,22 +1666,45 @@ export function App() {
       return;
     }
     let cancelled = false;
+    let inFlight = false;
     const poll = async () => {
-      const result = await callClipsAction<{
-        requests?: RewindExtensionRequest[];
-      }>("list-rewind-extension-requests", {}, { method: "GET" }).catch(
-        () => null,
+      if (document.hidden || inFlight) return;
+      inFlight = true;
+      const controller = new AbortController();
+      const abortTimer = setTimeout(
+        () => controller.abort(),
+        Math.max(10_000, 3_000 * 4),
       );
-      if (cancelled) return;
-      for (const request of result?.requests ?? []) {
-        void processRewindExtension(request);
+      try {
+        const result = await callClipsAction<{
+          requests?: RewindExtensionRequest[];
+        }>(
+          "list-rewind-extension-requests",
+          {},
+          { method: "GET", signal: controller.signal },
+        )
+          // coercion-ok: nothing to process this sweep either way; the next
+          // tick re-reads the pending requests.
+          .catch(() => null);
+        if (cancelled) return;
+        for (const request of result?.requests ?? []) {
+          void processRewindExtension(request);
+        }
+      } finally {
+        clearTimeout(abortTimer);
+        inFlight = false;
       }
     };
     void poll();
     const timer = window.setInterval(() => void poll(), 3_000);
+    const onVisibilityChange = () => {
+      if (!document.hidden) void poll();
+    };
+    document.addEventListener("visibilitychange", onVisibilityChange);
     return () => {
       cancelled = true;
       window.clearInterval(timer);
+      document.removeEventListener("visibilitychange", onVisibilityChange);
     };
   }, [
     authStatus,
@@ -1702,41 +1761,63 @@ export function App() {
   useEffect(() => {
     if (featureConfig?.screenMemory?.enabled !== true) return;
     let cancelled = false;
+    let inFlight = false;
     const sweep = async () => {
-      const due = await invoke<DueRewindAgentHandoff[]>(
-        "screen_memory_due_agent_handoffs",
-      ).catch(() => []);
-      if (cancelled) return;
-      for (const item of due) {
-        try {
-          const cleanup = await callClipsAction<{
-            deleted: boolean;
-            reason: string;
-          }>("delete-agent-recording-if-unpromoted", {
-            id: item.recordingId,
-          });
-          if (cleanup.deleted) {
-            await invoke("screen_memory_mark_agent_handoff_deleted", {
-              requestId: item.requestId,
-            });
-          } else if (cleanup.reason === "promoted") {
-            await invoke("screen_memory_cancel_agent_handoff_cleanup", {
-              requestId: item.requestId,
-            });
+      if (document.hidden || inFlight) return;
+      inFlight = true;
+      try {
+        const due = await invoke<DueRewindAgentHandoff[]>(
+          "screen_memory_due_agent_handoffs",
+        )
+          // coercion-ok: handoffs stay due in the local store, so an empty
+          // sweep and a failed one both retry on the next tick.
+          .catch(() => []);
+        if (cancelled) return;
+        for (const item of due) {
+          try {
+            const controller = new AbortController();
+            const abortTimer = setTimeout(
+              () => controller.abort(),
+              Math.max(10_000, 60_000 * 4),
+            );
+            const cleanup = await callClipsAction<{
+              deleted: boolean;
+              reason: string;
+            }>(
+              "delete-agent-recording-if-unpromoted",
+              { id: item.recordingId },
+              { signal: controller.signal },
+            ).finally(() => clearTimeout(abortTimer));
+            if (cleanup.deleted) {
+              await invoke("screen_memory_mark_agent_handoff_deleted", {
+                requestId: item.requestId,
+              });
+            } else if (cleanup.reason === "promoted") {
+              await invoke("screen_memory_cancel_agent_handoff_cleanup", {
+                requestId: item.requestId,
+              });
+            }
+          } catch (error) {
+            console.warn(
+              "[clips-tray] agent-created Clip cleanup failed:",
+              error,
+            );
           }
-        } catch (error) {
-          console.warn(
-            "[clips-tray] agent-created Clip cleanup failed:",
-            error,
-          );
         }
+      } finally {
+        inFlight = false;
       }
     };
     void sweep();
     const timer = window.setInterval(() => void sweep(), 60_000);
+    const onVisibilityChange = () => {
+      if (!document.hidden) void sweep();
+    };
+    document.addEventListener("visibilitychange", onVisibilityChange);
     return () => {
       cancelled = true;
       window.clearInterval(timer);
+      document.removeEventListener("visibilitychange", onVisibilityChange);
     };
   }, [callClipsAction, featureConfig?.screenMemory?.enabled]);
 
@@ -1967,11 +2048,18 @@ export function App() {
     if (signInInflightRef.current) return;
     signInInflightRef.current = true;
 
+    let tickInFlight = false;
+    let onVisibilityChange: (() => void) | null = null;
+
     function stopPolling() {
       if (pollIntervalRef.current !== null) {
         clearInterval(pollIntervalRef.current);
         pollIntervalRef.current = null;
       }
+      if (onVisibilityChange) {
+        document.removeEventListener("visibilitychange", onVisibilityChange);
+        onVisibilityChange = null;
+      }
     }
 
     function finishWithError(message: string) {
@@ -2000,11 +2088,16 @@ export function App() {
       // Poll the exchange endpoint for the session token.
       const start = Date.now();
       const TIMEOUT_MS = 180_000; // 3 minutes
-      pollIntervalRef.current = setInterval(async () => {
+      const POLL_ABORT_MS = Math.max(10_000, 1500 * 4);
+      const tick = async () => {
+        if (document.hidden || tickInFlight) return;
+        tickInFlight = true;
+        const controller = new AbortController();
+        const abortTimer = setTimeout(() => controller.abort(), POLL_ABORT_MS);
         try {
           const xr = await fetch(
             `${base}/_agent-native/auth/desktop-exchange?flow_id=${flowId}`,
-            { credentials: "include" },
+            { credentials: "include", signal: controller.signal },
           );
           if (!xr.ok) {
             if (Date.now() - start > TIMEOUT_MS) {
@@ -2030,7 +2123,7 @@ export function App() {
             // bearer token above is the reliable desktop auth path.
             await fetch(
               `${base}/_agent-native/auth/session?_session=${xd.token}`,
-              { credentials: "include" },
+              { credentials: "include", signal: controller.signal },
             );
             signInInflightRef.current = false;
             setSignInPending(false);
@@ -2047,8 +2140,16 @@ export function App() {
           if (Date.now() - start > TIMEOUT_MS) {
             finishWithError("Google sign-in timed out. Please try again.");
           }
+        } finally {
+          clearTimeout(abortTimer);
+          tickInFlight = false;
         }
-      }, 1500);
+      };
+      pollIntervalRef.current = setInterval(() => void tick(), 1500);
+      onVisibilityChange = () => {
+        if (!document.hidden) void tick();
+      };
+      document.addEventListener("visibilitychange", onVisibilityChange);
     } catch (err) {
       console.error("[clips-tray] signInExternal failed:", err);
       signInInflightRef.current = false;

package/corpus/templates/clips/server/jobs/brain-export.ts

@@ -18,6 +18,7 @@ const SWEEP_LIMIT = 4;
 const DISCOVERY_LIMIT = 20;
 const BACKFILL_DAYS = 7;
 let skippingLogged = false;
+let running = false;
 
 async function seedRecentBrainExports(): Promise<void> {
   const now = new Date();
@@ -173,12 +174,18 @@ export default function registerBrainExportJob(): void {
     return;
   }
   setInterval(() => {
-    reapExpiredUploads().catch((error) =>
-      console.error("[uploads] lease reaper interval failed:", error),
-    );
-    runBrainExportSweepOnce().catch((error) =>
-      console.error("[brain-export] interval failed:", error),
-    );
+    if (running) return;
+    running = true;
+    Promise.allSettled([
+      reapExpiredUploads().catch((error) =>
+        console.error("[uploads] lease reaper interval failed:", error),
+      ),
+      runBrainExportSweepOnce().catch((error) =>
+        console.error("[brain-export] interval failed:", error),
+      ),
+    ]).finally(() => {
+      running = false;
+    });
   }, SWEEP_INTERVAL_MS);
   console.log(
     `[brain-export] Recurring recovery sweep every ${SWEEP_INTERVAL_MS / 1000}s.`,

package/corpus/templates/clips/server/jobs/builder-media-compression.ts

@@ -13,6 +13,7 @@ import { runBuilderMediaCompressionSweepOnce } from "../lib/builder-media-compre
 
 const SWEEP_INTERVAL_MS = 5 * 60 * 1000;
 let skippingLogged = false;
+let running = false;
 
 export { runBuilderMediaCompressionSweepOnce };
 
@@ -31,9 +32,15 @@ export default function registerBuilderMediaCompressionJob(): void {
   }
 
   setInterval(() => {
-    runBuilderMediaCompressionSweepOnce().catch((err) =>
-      console.error("[builder-media-compression] interval failed:", err),
-    );
+    if (running) return;
+    running = true;
+    runBuilderMediaCompressionSweepOnce()
+      .catch((err) =>
+        console.error("[builder-media-compression] interval failed:", err),
+      )
+      .finally(() => {
+        running = false;
+      });
   }, SWEEP_INTERVAL_MS);
   console.log(
     `[builder-media-compression] Recurring compression sweep every ${SWEEP_INTERVAL_MS / 1000}s.`,

package/corpus/templates/clips/server/jobs/meeting-reminders.ts

@@ -29,6 +29,7 @@ import { getDb, schema } from "../db/index.js";
 const REMINDER_INTERVAL_MS = 60 * 1000;
 const REMINDER_WINDOW_MS = 5 * 60 * 1000;
 let skippingLogged = false;
+let running = false;
 
 const meetingReminderSchema = z.object({
   meetingId: z.string(),
@@ -114,9 +115,15 @@ export default function registerMeetingRemindersJob(): void {
     return;
   }
   setInterval(() => {
-    runMeetingRemindersOnce().catch((err) =>
-      console.error("[meeting-reminders] interval failed:", err),
-    );
+    if (running) return;
+    running = true;
+    runMeetingRemindersOnce()
+      .catch((err) =>
+        console.error("[meeting-reminders] interval failed:", err),
+      )
+      .finally(() => {
+        running = false;
+      });
   }, REMINDER_INTERVAL_MS);
   console.log(
     `[meeting-reminders] Recurring meeting reminders every ${REMINDER_INTERVAL_MS / 1000}s.`,

package/corpus/templates/clips/server/jobs/poll-calendars.ts

@@ -2,15 +2,16 @@
  * poll-calendars — recurring job (every 5 min).
  *
  * Sweeps every connected calendar_accounts row and refreshes its events.
- * Runs as a Nitro plugin via `setInterval` (matches the mail-jobs pattern
- * — works on every host that keeps a long-lived process; on serverless
- * the deployment plugin should call `runPollCalendarsOnce` from a
- * scheduled function instead).
+ * Runs as a Nitro plugin via `startIntervalJob` (matches the mail-jobs
+ * pattern — works on every host that keeps a long-lived process; on
+ * serverless the deployment plugin should call `runPollCalendarsOnce` from
+ * a scheduled function instead).
  *
  * Token refresh + per-account error capture happens inside the
  * `sync-calendars` action; this job is just a thin scheduler.
  */
 
+import { startIntervalJob } from "@agent-native/core/server/interval-job";
 import { runWithRequestContext } from "@agent-native/core/server/request-context";
 
 import syncCalendars from "../../actions/sync-calendars.js";
@@ -21,24 +22,21 @@ let skippingLogged = false;
 /**
  * Run a single poll pass. Exported so deployment-specific schedulers
  * (e.g. Netlify Scheduled Functions) can invoke it directly without
- * relying on a long-lived process.
+ * relying on a long-lived process. Throws on failure so a scheduled
+ * invocation records a failed run rather than a silent empty one.
  */
 export async function runPollCalendarsOnce(): Promise<void> {
   // No request context — this job runs as the system. The sync-calendars
   // action accepts `allAccounts: true` to skip the per-user accessFilter.
   await runWithRequestContext({}, async () => {
-    try {
-      const result = await syncCalendars.run(
-        { allAccounts: true } as any,
-        {} as any,
+    const result = await syncCalendars.run(
+      { allAccounts: true } as any,
+      {} as any,
+    );
+    if (result?.synced) {
+      console.log(
+        `[poll-calendars] synced ${result.synced} accounts, ${result.events ?? 0} events, ${result.meetings ?? 0} meetings`,
       );
-      if (result?.synced) {
-        console.log(
-          `[poll-calendars] synced ${result.synced} accounts, ${result.events ?? 0} events, ${result.meetings ?? 0} meetings`,
-        );
-      }
-    } catch (err: any) {
-      console.error(`[poll-calendars] sync failed:`, err?.message ?? err);
     }
   });
 }
@@ -62,11 +60,15 @@ export default function registerPollCalendarsJob(): void {
     }
     return;
   }
-  setInterval(() => {
-    runPollCalendarsOnce().catch((err) =>
-      console.error("[poll-calendars] interval failed:", err),
-    );
-  }, POLL_INTERVAL_MS);
+  // sync-calendars calls Google's Calendar API with no fetch-level timeout of
+  // its own, so the overlap guard and the hung-sweep timeout both come from
+  // startIntervalJob rather than a module-level `running` flag here.
+  startIntervalJob(() => runPollCalendarsOnce(), {
+    intervalMs: POLL_INTERVAL_MS,
+    leading: false,
+    onError: (err: any) =>
+      console.error("[poll-calendars] sync failed:", err?.message ?? err),
+  });
   console.log(
     `[poll-calendars] Recurring calendar sync every ${POLL_INTERVAL_MS / 1000}s.`,
   );

package/corpus/templates/clips/server/jobs/stale-meeting-sweeper.ts

@@ -46,6 +46,7 @@ const STALE_THRESHOLD_MS = 60 * 60 * 1000; // 60 min of zero transcript activity
 // a slow Gemini call. Mirrors finalize-meeting.ts's force-takeover window.
 const PENDING_STALE_MS = 2 * 60 * 1000; // 2 min
 let skippingLogged = false;
+let running = false;
 
 /**
  * Close out a single stranded-live meeting row: stamp actualEnd, set
@@ -284,9 +285,15 @@ export default function registerStaleMeetingSweeperJob(): void {
     return;
   }
   setInterval(() => {
-    runStaleMeetingSweepOnce().catch((err) =>
-      console.error("[stale-meeting-sweeper] interval failed:", err),
-    );
+    if (running) return;
+    running = true;
+    runStaleMeetingSweepOnce()
+      .catch((err) =>
+        console.error("[stale-meeting-sweeper] interval failed:", err),
+      )
+      .finally(() => {
+        running = false;
+      });
   }, SWEEP_INTERVAL_MS);
   console.log(
     `[stale-meeting-sweeper] Recurring stale-meeting reconciliation every ${SWEEP_INTERVAL_MS / 1000}s.`,

package/corpus/templates/clips/server/jobs/transactional-emails.ts

@@ -49,6 +49,7 @@ const SENDING_LEASE_MS = 2 * 60 * 1000;
 const MAX_ATTEMPTS = 3;
 const RETRY_BASE_DELAY_MS = 60_000;
 let skippingLogged = false;
+let running = false;
 
 type DirectShare = {
   id: string;
@@ -1304,9 +1305,15 @@ export default function registerTransactionalEmailsJob(): void {
     return;
   }
   setInterval(() => {
-    runTransactionalEmailsOnce().catch((error) =>
-      console.error("[transactional-emails] interval failed:", error),
-    );
+    if (running) return;
+    running = true;
+    runTransactionalEmailsOnce()
+      .catch((error) =>
+        console.error("[transactional-emails] interval failed:", error),
+      )
+      .finally(() => {
+        running = false;
+      });
   }, JOB_INTERVAL_MS);
   console.log(
     `[transactional-emails] Recurring reconciliation and delivery every ${JOB_INTERVAL_MS / 1000}s.`,

package/corpus/templates/content/app/components/sidebar/NotionButton.tsx

@@ -167,6 +167,7 @@ export function NotionButton() {
 
     // Poll for connection
     pollRef.current = setInterval(async () => {
+      if (document.hidden) return;
       const result = await refetch();
       if (result.data?.connected) {
         clearInterval(pollRef.current);

package/corpus/templates/design/app/components/design/FusionAppBanner.tsx

@@ -83,11 +83,24 @@ export function FusionAppBanner({
   // ── Building: poll sync-fusion-app on mount + every ~8s while building ────
   const syncMutateRef = useRef(syncMutation.mutate);
   syncMutateRef.current = syncMutation.mutate;
+  const syncInFlightRef = useRef(false);
   useEffect(() => {
     if (status !== "building") return;
-    syncMutateRef.current({ designId } as any);
+    // The leading sync goes through the same guard as the interval ticks: a
+    // container check still pending at the first tick would otherwise let a
+    // second status sync start and race the provisioning/screen-upsert work.
+    const runSync = (): void => {
+      if (syncInFlightRef.current) return;
+      syncInFlightRef.current = true;
+      syncMutateRef.current(
+        { designId } as any,
+        { onSettled: () => (syncInFlightRef.current = false) } as any,
+      );
+    };
+    runSync();
     const interval = window.setInterval(() => {
-      syncMutateRef.current({ designId } as any);
+      if (document.hidden) return;
+      runSync();
     }, SYNC_POLL_INTERVAL_MS);
     return () => window.clearInterval(interval);
   }, [designId, status]);