@agent-native/core 0.168.7 → 0.168.10

package/corpus/README.md

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

package/corpus/templates/analytics/actions/mutate-dashboard.ts

@@ -49,6 +49,13 @@ const mutationTargetSchema = {
     .describe("Where in rowNumber to place the panel. Defaults to end."),
 };
 
+const insertPanelSchema = z
+  .record(z.string(), z.unknown())
+  .refine(
+    (panel) => typeof panel.id === "string" && panel.id.trim().length > 0,
+    { message: "panel.id must be a non-empty string" },
+  );
+
 const mutationOperationSchema = z.discriminatedUnion("op", [
   z.object({
     op: z.literal("movePanels"),
@@ -72,7 +79,7 @@ const mutationOperationSchema = z.discriminatedUnion("op", [
   }),
   z.object({
     op: z.literal("insertPanel"),
-    panel: z.record(z.string(), z.unknown()),
+    panel: insertPanelSchema,
     ...mutationTargetSchema,
   }),
   z.object({

package/corpus/templates/calendar/actions/delete-event.ts

@@ -5,6 +5,7 @@ import {
   normalizeGuestNotificationMessage,
   sendEventGuestNotificationNote,
 } from "../server/lib/event-guest-notifications.js";
+import { isGoogleNotFoundError } from "../server/lib/google-api.js";
 import * as googleCalendar from "../server/lib/google-calendar.js";
 import {
   cliBoolean,
@@ -71,25 +72,39 @@ export default defineAction({
         ? "none"
         : (args.sendUpdates ?? (shouldNotifyGuests ? "all" : "none")),
     };
-    const eventForNotification = shouldNotifyGuests
-      ? await googleCalendar.getEvent(googleEventId, {
-          ownerEmail,
-          accountEmail,
-        })
-      : undefined;
+    let eventForNotification;
+    try {
+      eventForNotification = shouldNotifyGuests
+        ? await googleCalendar.getEvent(googleEventId, {
+            ownerEmail,
+            accountEmail,
+          })
+        : undefined;
 
-    if (args.removeOnly) {
-      await googleCalendar.removeEventFromCalendar(
-        googleEventId,
-        { ownerEmail, accountEmail },
-        options,
-      );
-    } else {
-      await googleCalendar.deleteEvent(
-        googleEventId,
-        { ownerEmail, accountEmail },
-        options,
-      );
+      if (args.removeOnly) {
+        await googleCalendar.removeEventFromCalendar(
+          googleEventId,
+          { ownerEmail, accountEmail },
+          options,
+        );
+      } else {
+        await googleCalendar.deleteEvent(
+          googleEventId,
+          { ownerEmail, accountEmail },
+          options,
+        );
+      }
+    } catch (error) {
+      if (!isGoogleNotFoundError(error)) throw error;
+
+      return {
+        success: true,
+        alreadyAbsent: true,
+        id: `google-${googleEventId}`,
+        accountEmail,
+        scope: args.scope,
+        removedOnly: args.removeOnly ?? false,
+      };
     }
 
     const guestNotification =
@@ -105,6 +120,7 @@ export default defineAction({
 
     return {
       success: true,
+      alreadyAbsent: false,
       id: `google-${googleEventId}`,
       accountEmail,
       scope: args.scope,

package/corpus/templates/calendar/actions/delete-events.ts

@@ -10,6 +10,7 @@ import {
   type WeekdayName,
 } from "../server/lib/event-weekday.js";
 import { zonedDateTimeToUtcIso } from "../server/lib/find-time.js";
+import { isGoogleNotFoundError } from "../server/lib/google-api.js";
 import * as googleCalendar from "../server/lib/google-calendar.js";
 import type { CalendarEvent } from "../shared/api.js";
 import {
@@ -36,7 +37,7 @@ const MAX_MATCHED_EVENTS = 200;
  *  firing every delete at once and turning a clean batch into retries. */
 const DELETE_CONCURRENCY = 4;
 
-type Outcome = "deleted" | "matched" | "skipped" | "failed";
+type Outcome = "deleted" | "already_absent" | "matched" | "skipped" | "failed";
 
 interface EventResult {
   id: string;
@@ -449,6 +450,7 @@ export default defineAction({
         ...summaryBase,
         dryRun: true,
         deleted: 0,
+        alreadyAbsent: 0,
         failed: 0,
         skipped: results.length,
         events: [...targets.map((target) => target.display), ...results],
@@ -483,6 +485,13 @@ export default defineAction({
           }
           return { ...target.display, outcome: "deleted" };
         } catch (error) {
+          if (isGoogleNotFoundError(error)) {
+            return {
+              ...target.display,
+              outcome: "already_absent",
+              reason: "Already absent from Google Calendar",
+            };
+          }
           return {
             ...target.display,
             outcome: "failed",
@@ -498,6 +507,9 @@ export default defineAction({
       dryRun: false,
       deleted: deleteResults.filter((entry) => entry.outcome === "deleted")
         .length,
+      alreadyAbsent: deleteResults.filter(
+        (entry) => entry.outcome === "already_absent",
+      ).length,
       failed: deleteResults.filter((entry) => entry.outcome === "failed")
         .length,
       skipped: results.length,

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

@@ -35,6 +35,7 @@ import {
 } from "@/components/ui/tooltip";
 import { useUpdateEvent } from "@/hooks/use-events";
 import { useViewPreferences } from "@/hooks/use-view-preferences";
+import { getDisplayDateInTimezone } from "@/lib/calendar-timezone";
 import { getEditableEventTitle } from "@/lib/event-form-utils";
 import { isOutOfOfficeEvent } from "@/lib/out-of-office";
 import { cn } from "@/lib/utils";
@@ -447,15 +448,33 @@ export function EventDetailPanel({
                     ) : (
                       <>
                         <span className="text-foreground">
-                          {format(parseISO(event.start), "h:mm a")}
+                          {format(
+                            getDisplayDateInTimezone(
+                              event.start,
+                              event.startTimeZone ?? event.endTimeZone,
+                            ),
+                            "h:mm a",
+                          )}
                           {" → "}
-                          {format(parseISO(event.end), "h:mm a")}
+                          {format(
+                            getDisplayDateInTimezone(
+                              event.end,
+                              event.endTimeZone ?? event.startTimeZone,
+                            ),
+                            "h:mm a",
+                          )}
                         </span>
                         <span className="ml-2 text-muted-foreground/70">
                           {formatDuration(event.start, event.end)}
                         </span>
                         <div className="mt-0.5 text-muted-foreground">
-                          {format(parseISO(event.start), "EEE MMM d")}
+                          {format(
+                            getDisplayDateInTimezone(
+                              event.start,
+                              event.startTimeZone ?? event.endTimeZone,
+                            ),
+                            "EEE MMM d",
+                          )}
                         </div>
                       </>
                     )}

package/corpus/templates/calendar/app/lib/calendar-timezone.ts

@@ -118,6 +118,25 @@ export function getDateTimePartsInTimezone(
   return dateTimeParts(value, normalizeTimezone(timezone));
 }
 
+/**
+ * Build a local Date carrying an event's wall-clock fields so date-fns can
+ * format those fields without converting them through the browser timezone.
+ * The result is for display only; it must not be used for date arithmetic.
+ */
+export function getDisplayDateInTimezone(
+  value: Date | string,
+  timezone?: string | null,
+): Date {
+  const parsed = value instanceof Date ? value : new Date(value);
+  if (!timezone) return parsed;
+
+  const parts = getDateTimePartsInTimezone(value, timezone);
+  if (!parts) return parsed;
+
+  const [year, month, day] = parts.date.split("-").map(Number);
+  return new Date(year, month - 1, day, parts.hour, parts.minute, parts.second);
+}
+
 export function getDateKeyInTimezone(
   value: Date | string,
   timezone: string,

package/corpus/templates/calendar/server/lib/google-api.ts

@@ -113,6 +113,23 @@ export function createOAuth2Client(
 // Authenticated fetch helper
 // ---------------------------------------------------------------------------
 
+export class GoogleApiError extends Error {
+  readonly status: number;
+
+  constructor(status: number, message: string) {
+    super(`Google API error (${status}): ${message}`);
+    this.name = "GoogleApiError";
+    this.status = status;
+  }
+}
+
+export function isGoogleNotFoundError(error: unknown): boolean {
+  return (
+    (error instanceof GoogleApiError && error.status === 404) ||
+    (error instanceof Error && /^Google API error \(404\):/.test(error.message))
+  );
+}
+
 export async function googleFetch(
   url: string,
   accessToken: string,
@@ -133,7 +150,7 @@ export async function googleFetch(
       (data as any)?.error?.message ||
       (data as any)?.error_description ||
       res.statusText;
-    throw new Error(`Google API error (${res.status}): ${msg}`);
+    throw new GoogleApiError(res.status, msg);
   }
 
   return data;

package/corpus/templates/clips/actions/finalize-meeting.ts

@@ -27,6 +27,17 @@ import { loadAgentsMdContext } from "./lib/agents-md-context.js";
 // handles crashed processes without stealing an active text-model run.
 const PENDING_STALE_MS = 2 * 60 * 1000;
 
+export function skippedFinalizeResult(meetingId: string) {
+  return {
+    meetingId,
+    summaryMd: "",
+    bullets: [],
+    actionItems: [],
+    provider: null,
+    skipped: "no-transcript" as const,
+  };
+}
+
 function trimContextValue(value: string, maxChars: number): string {
   const trimmed = value.replace(/\0/g, "").trim();
   if (trimmed.length <= maxChars) return trimmed;
@@ -80,6 +91,11 @@ export default defineAction({
           updatedAt: nowIso,
         })
         .where(eq(schema.meetings.id, args.meetingId));
+      // The desktop stop path can finish before its final transcript flush
+      // lands. That is a completed recording without notes, not an action
+      // failure worth returning as HTTP 500; the explicit regenerate flow
+      // still receives the actionable error below.
+      if (!args.force) return skippedFinalizeResult(args.meetingId);
       throw new Error(
         `Cannot finalize meeting ${args.meetingId} — no transcript text available yet.`,
       );

package/corpus/templates/clips/actions/list-meetings.ts

@@ -372,6 +372,7 @@ export default defineAction({
               await recordCalendarFetchError(
                 account,
                 new Error("Token refresh failed"),
+                { needsReauth: true },
               ),
             );
             continue;

package/corpus/templates/clips/actions/sync-calendars.ts

@@ -23,6 +23,8 @@ import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
 import {
+  recordCalendarFetchError,
+  recordCalendarFetchSuccess,
   resolveCalendarAccessToken,
   shouldMarkNeedsReauth,
 } from "../server/lib/calendar-event-meetings.js";
@@ -98,24 +100,11 @@ export default defineAction({
         // sync error via shouldMarkNeedsReauth without flipping status.
         const accessToken = await resolveCalendarAccessToken(account);
         if (!accessToken) {
-          // Fix 10: isolate this account's needs-reauth write in its own
-          // try/catch so a downstream throw on a different account doesn't
-          // leave the flag unpersisted.
-          try {
-            await db
-              .update(schema.calendarAccounts)
-              .set({
-                status: "needs-reauth",
-                lastSyncError: "Token refresh failed — reconnect required.",
-                updatedAt: new Date().toISOString(),
-              })
-              .where(eq(schema.calendarAccounts.id, account.id));
-          } catch (writeErr: any) {
-            console.warn(
-              `[sync-calendars] failed to flag account ${account.id} as needs-reauth:`,
-              writeErr?.message ?? writeErr,
-            );
-          }
+          await recordCalendarFetchError(
+            account,
+            new Error("Token refresh failed"),
+            { needsReauth: true },
+          );
           errors.push({
             accountId: account.id,
             error: "needs-reauth",
@@ -206,18 +195,10 @@ export default defineAction({
           perAccountEvents += 1;
         }
 
-        // Fix 10: isolate the success-path status write so other accounts'
-        // needs-reauth flags can't be wiped by a later account-level throw.
+        // Keep the success write isolated and guarded so an in-flight sweep
+        // cannot overwrite a concurrent needs-reauth decision.
         try {
-          await db
-            .update(schema.calendarAccounts)
-            .set({
-              lastSyncedAt: new Date().toISOString(),
-              lastSyncError: null,
-              status: "connected",
-              updatedAt: new Date().toISOString(),
-            })
-            .where(eq(schema.calendarAccounts.id, account.id));
+          await recordCalendarFetchSuccess(account);
         } catch (writeErr: any) {
           console.warn(
             `[sync-calendars] failed to update account ${account.id} after success:`,

package/corpus/templates/clips/desktop/src/hooks/useMeetingTranscription.ts

@@ -4,6 +4,7 @@ import { open as openExternal } from "@tauri-apps/plugin-shell";
 import { useCallback, useEffect, useMemo, useRef } from "react";
 
 import { callAppBundleIdsForJoinUrl } from "../lib/meeting-call-app";
+import { stopMeetingBeforeTranscriptFlush } from "../lib/meeting-stop";
 import {
   appendFinalTranscript,
   onFinalTranscript,
@@ -195,18 +196,33 @@ export function useMeetingTranscription({
           }
         });
         await invoke("silence_detector_stop").catch(() => {});
-        if (reason !== "app-quit") {
-          await session.historyInFlight?.catch(() => {});
-        }
-        // Final flush waits for any in-flight flush first (flushTranscript's
-        // single-flight coalescing) then sends the definitive snapshot.
-        await flushTranscript().catch((err) => {
-          console.warn("[clips-popover] meeting transcript save failed:", err);
-        });
-        await callClipsAction("stop-meeting-recording", {
-          meetingId: session.meetingId,
-        }).catch((err) => {
-          console.warn("[clips-popover] stop meeting action failed:", err);
+        await stopMeetingBeforeTranscriptFlush({
+          // Stamp actualEnd as soon as capture is torn down. Transcript
+          // history and network flushes may be slow or unavailable, but they
+          // must not leave the meeting looking live in the meantime.
+          stopRecording: async () => {
+            await callClipsAction("stop-meeting-recording", {
+              meetingId: session.meetingId,
+            }).catch((err) => {
+              console.warn("[clips-popover] stop meeting action failed:", err);
+            });
+          },
+          waitForHistory: async () => {
+            if (reason !== "app-quit") {
+              await session.historyInFlight?.catch(() => {});
+            }
+          },
+          // Final flush waits for any in-flight flush first
+          // (flushTranscript's single-flight coalescing) and sends the
+          // definitive snapshot.
+          flushTranscript: async () => {
+            await flushTranscript().catch((err) => {
+              console.warn(
+                "[clips-popover] meeting transcript save failed:",
+                err,
+              );
+            });
+          },
         });
         if (session.lines.length) {
           const finalizePromise = callClipsAction("finalize-meeting", {

package/corpus/templates/clips/desktop/src/lib/meeting-stop.ts

@@ -0,0 +1,16 @@
+interface StopMeetingBeforeTranscriptFlushOptions {
+  stopRecording: () => Promise<void>;
+  waitForHistory: () => Promise<void>;
+  flushTranscript: () => Promise<void>;
+}
+
+/** Persist the terminal meeting state before waiting on transcript work. */
+export async function stopMeetingBeforeTranscriptFlush({
+  stopRecording,
+  waitForHistory,
+  flushTranscript,
+}: StopMeetingBeforeTranscriptFlushOptions): Promise<void> {
+  await stopRecording();
+  await waitForHistory();
+  await flushTranscript();
+}

package/corpus/templates/clips/server/lib/calendar-event-meetings.ts

@@ -23,6 +23,8 @@ import {
 
 export const CALENDAR_MEETING_ID_PREFIX = "gcal";
 
+const CALENDAR_REQUEST_SAFETY_MARGIN_MS = 60 * 1000;
+
 export interface CalendarAccountForEvents {
   id: string;
   provider: string;
@@ -74,8 +76,7 @@ export function shouldMarkNeedsReauth(message: string): boolean {
     lower.includes("google calendar event failed (401)") ||
     lower.includes("invalid_grant") ||
     lower.includes("invalid_token") ||
-    lower.includes("insufficient_scope") ||
-    lower.includes("token refresh failed")
+    lower.includes("insufficient_scope")
   );
 }
 
@@ -122,10 +123,16 @@ export async function resolveCalendarAccessToken(
     });
   } catch (err) {
     // Only a permanent failure (dead refresh token / bad OAuth client) means
-    // "needs-reauth" — collapse those to `null` as before. A transient
-    // failure (network error, 429, 5xx, timeout) is rethrown so callers can
-    // record it as a soft sync error without flipping account status.
+    // "needs-reauth" — collapse those to `null` as before. During the refresh
+    // buffer, a transient failure can safely reuse the still-valid token.
     if (isPermanentRefreshFailure(err)) return null;
+    if (
+      bundle?.accessToken &&
+      bundle.expiresAt &&
+      bundle.expiresAt > Date.now() + CALENDAR_REQUEST_SAFETY_MARGIN_MS
+    ) {
+      return bundle.accessToken;
+    }
     throw err;
   }
   if (!refreshed.access_token) return null;
@@ -158,13 +165,13 @@ export async function recordCalendarFetchSuccess(
     .set({
       lastSyncedAt: now,
       lastSyncError: null,
-      status: "connected",
       updatedAt: now,
     })
     .where(
       and(
         eq(schema.calendarAccounts.id, account.id),
         eq(schema.calendarAccounts.ownerEmail, account.ownerEmail),
+        eq(schema.calendarAccounts.status, "connected"),
       ),
     );
 }
@@ -172,10 +179,11 @@ export async function recordCalendarFetchSuccess(
 export async function recordCalendarFetchError(
   account: CalendarAccountForEvents,
   error: unknown,
+  options: { needsReauth?: boolean } = {},
 ): Promise<CalendarFetchError> {
   const message =
     error instanceof Error ? error.message : String(error || "Calendar failed");
-  const needsReauth = shouldMarkNeedsReauth(message);
+  const needsReauth = options.needsReauth ?? shouldMarkNeedsReauth(message);
   if (!account.ownerEmail) {
     return { accountId: account.id, error: message, needsReauth };
   }
@@ -183,7 +191,7 @@ export async function recordCalendarFetchError(
   await db
     .update(schema.calendarAccounts)
     .set({
-      status: needsReauth ? "needs-reauth" : "connected",
+      ...(needsReauth ? { status: "needs-reauth" as const } : {}),
       lastSyncError: needsReauth
         ? "Google Calendar needs to be reconnected."
         : message,
@@ -320,7 +328,9 @@ export async function fetchLiveCalendarEventFromId(virtualId: string) {
     return null;
   }
   if (!accessToken) {
-    await recordCalendarFetchError(account, new Error("Token refresh failed"));
+    await recordCalendarFetchError(account, new Error("Token refresh failed"), {
+      needsReauth: true,
+    });
     return null;
   }
 

package/corpus/templates/content/app/components/editor/SlashCommandMenu.tsx

@@ -1042,6 +1042,7 @@ export function SlashCommandMenu({
 
     const handleKeyDown = (e: KeyboardEvent) => {
       if (
+        !isOpen &&
         e.key === "Enter" &&
         !e.shiftKey &&
         !e.metaKey &&

package/corpus/templates/content/app/global.css

@@ -729,6 +729,11 @@
   background: hsl(var(--muted));
   border-radius: 0 0 6px 6px;
 }
+.notion-editor .notion-code-block {
+  background: hsl(var(--muted));
+  border-radius: 6px;
+  margin: 0.6em 0;
+}
 .notion-editor pre code {
   font-family: inherit;
   background: none;