@agent-native/core 0.141.2 → 0.141.4

package/corpus/templates/analytics/server/plugins/db.ts

@@ -1,15 +1,18 @@
 import {
+  deferMigration,
   ensureAdditiveColumns,
   getDialect,
   getDbExec,
   isPostgres,
   runMigrations,
 } from "@agent-native/core/db";
+import { isInBackgroundFunctionRuntime } from "@agent-native/core/server";
 
 // Side-effect import: ensures registerShareableResource runs on server
 // startup so the dashboard / analysis share actions know where to dispatch.
 import "../db/index.js";
 import * as schema from "../db/schema.js";
+import { FIRST_PARTY_ANALYTICS_ROLLUP_LOCK_KEY } from "../lib/first-party-analytics-rollups.js";
 import { repairPersistedFirstPartyDashboardQueries } from "../lib/first-party-dashboard-repair.js";
 
 /**
@@ -141,7 +144,17 @@ const ANALYTICS_ROLLUP_BACKFILL_STATEMENTS = {
   ],
 } as const;
 
-async function runHistoricalAnalyticsRollupBackfill(): Promise<void> {
+async function runHistoricalAnalyticsRollupBackfill() {
+  // Durable agent workers share this plugin bundle with the regular server,
+  // but they must not become a second migration runner for an expensive
+  // historical scan. The keep-warm/regular server path owns this work.
+  if (isInBackgroundFunctionRuntime()) {
+    console.info(
+      "[db] Deferring historical Analytics rollup backfill from durable background runtime",
+    );
+    return deferMigration();
+  }
+
   const db = getDbExec();
 
   if (isPostgres()) {
@@ -151,27 +164,30 @@ async function runHistoricalAnalyticsRollupBackfill(): Promise<void> {
       );
     }
 
-    await db.transaction(async (tx) => {
+    const result = await db.transaction(async (tx) => {
       // Only one serverless instance should perform the expensive scan. A
-      // try-lock is intentional: competing cold starts fail fast instead of
-      // holding pooled Neon connections while waiting for the winner. The
-      // monotonic rollup upsert below keeps a live increment from being
-      // overwritten if ingest commits during the historical snapshot.
+      // A try-lock keeps competing cold starts from holding pooled Neon
+      // connections while waiting for the winner. A lock loser defers without
+      // recording the migration so a failed winner can be retried safely.
+      // The monotonic rollup upsert below keeps a live increment from being
+      // overwritten if ingest commits during the historical snapshot. Live
+      // ingest takes this same lock before inserting its raw event.
       const lockResult = await tx.execute({
         sql: "SELECT pg_try_advisory_xact_lock(hashtextextended(?, 0::bigint)) AS acquired",
-        args: ["agent-native:analytics-rollup-backfill"],
+        args: [FIRST_PARTY_ANALYTICS_ROLLUP_LOCK_KEY],
       });
       const acquired = lockResult.rows[0]?.acquired;
       if (acquired !== true && acquired !== "t") {
-        throw new Error(
-          "Analytics rollup backfill is already running on another instance",
+        console.info(
+          "[db] Deferring historical Analytics rollup backfill; another instance owns the advisory lock",
         );
+        return deferMigration();
       }
       for (const statement of ANALYTICS_ROLLUP_BACKFILL_STATEMENTS.postgres) {
         await tx.execute(statement);
       }
     });
-    return;
+    return result;
   }
 
   const statements = ANALYTICS_ROLLUP_BACKFILL_STATEMENTS.sqlite;
@@ -1556,6 +1572,15 @@ const runAnalyticsMigrations = runMigrations(
  * swallowed so it can never fail boot.
  */
 export default async (nitroApp: any): Promise<void> => {
+  if (isInBackgroundFunctionRuntime()) {
+    // Durable workers execute signed internal routes against a schema owned by
+    // the regular server. A second migration runner only adds a Neon pool
+    // probe to every worker cold start.
+    console.info(
+      "[db] Skipping Analytics migrations in durable background runtime",
+    );
+    return;
+  }
   await runAnalyticsMigrations(nitroApp);
   try {
     if (await repairPersistedFirstPartyDashboardQueries()) {

package/corpus/templates/analytics/server/plugins/transactional-emails.ts

@@ -0,0 +1,5 @@
+import { registerAnalyticsEmails } from "../lib/emails";
+
+export default function registerTransactionalEmails(): void {
+  registerAnalyticsEmails();
+}

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

@@ -36,7 +36,7 @@ function formatTimeValue(value: string) {
   const period = hourValue >= 12 ? "PM" : "AM";
   const hour = hourValue % 12 || 12;
   return minuteValue === 0
-    ? `${hour} ${period}`
+    ? `${hour}:00 ${period}`
     : `${hour}:${String(minuteValue).padStart(2, "0")} ${period}`;
 }
 
@@ -118,12 +118,17 @@ export function TimePickerPopover({
                 }}
               >
                 <span>{formatTimeValue(option)}</span>
-                {getOptionMeta?.(option) && (
-                  <span className="text-muted-foreground">
-                    {getOptionMeta(option)}
+                <span className="ml-3 flex min-w-0 items-center gap-2 text-muted-foreground">
+                  {getOptionMeta?.(option) && (
+                    <span className="truncate">{getOptionMeta(option)}</span>
+                  )}
+                  <span
+                    aria-hidden="true"
+                    className="flex size-3.5 shrink-0 items-center justify-center"
+                  >
+                    {selected && <IconCheck className="size-3.5" />}
                   </span>
-                )}
-                {selected && <IconCheck className="ml-2 size-3.5 shrink-0" />}
+                </span>
               </button>
             );
           })}
@@ -338,7 +343,12 @@ export function RepeatPicker({
               <span>{option.label}</span>
               <span className="ml-3 flex items-center gap-2 text-muted-foreground">
                 {option.meta}
-                {selected && <IconCheck className="size-3.5 shrink-0" />}
+                <span
+                  aria-hidden="true"
+                  className="flex size-3.5 shrink-0 items-center justify-center"
+                >
+                  {selected && <IconCheck className="size-3.5" />}
+                </span>
               </span>
             </button>
           );

package/corpus/templates/calendar/server/lib/booking-emails.ts

@@ -11,6 +11,12 @@ import {
   DEFAULT_BOOKING_TIMEZONE,
   safeBookingTimeZone,
 } from "./booking-timezone.js";
+import {
+  CALENDAR_BOOKING_CANCELLED_EMAIL_ID,
+  CALENDAR_BOOKING_CANCELLED_HOST_EMAIL_ID,
+  CALENDAR_BOOKING_CONFIRMED_EMAIL_ID,
+  CALENDAR_BOOKING_RECEIVED_EMAIL_ID,
+} from "./emails.js";
 
 function stripCrlf(value: string | undefined): string {
   return (value ?? "").replace(/[\r\n]+/g, " ").trim();
@@ -57,6 +63,128 @@ async function sendBestEffort(
   }
 }
 
+export function renderBookingConfirmedEmail({
+  title,
+  when,
+  host,
+  manageUrl,
+  meetingLink,
+}: {
+  title: string;
+  when: string;
+  host: string;
+  manageUrl: string;
+  meetingLink?: string | null;
+}) {
+  const paragraphs = [
+    `You're booked for ${emailStrong(title)} with ${emailStrong(host)}.`,
+    `Time: ${emailStrong(when)}.`,
+  ];
+  if (meetingLink) {
+    paragraphs.push(`Meeting link: ${emailLink("Join meeting", meetingLink)}.`);
+  }
+
+  return {
+    subject: `Confirmed: ${title}`,
+    ...renderEmail({
+      preheader: `You're booked for ${title} on ${when}.`,
+      heading: "Your meeting is booked",
+      paragraphs,
+      cta: { label: "Manage booking", url: manageUrl },
+      footer:
+        "Use the manage link if you need to cancel or reschedule this meeting.",
+    }),
+  };
+}
+
+export function renderBookingReceivedEmail({
+  title,
+  when,
+  attendeeName,
+  attendee,
+  manageUrl,
+  meetingLink,
+}: {
+  title: string;
+  when: string;
+  attendeeName: string;
+  attendee: string;
+  manageUrl: string;
+  meetingLink?: string | null;
+}) {
+  return {
+    subject: `New booking: ${title}`,
+    ...renderEmail({
+      preheader: `${attendeeName} booked ${title} on ${when}.`,
+      heading: "New booking",
+      paragraphs: [
+        `${emailStrong(attendeeName)} booked ${emailStrong(title)}.`,
+        `Time: ${emailStrong(when)}.`,
+        `Guest: ${emailStrong(attendee)}.`,
+        ...(meetingLink
+          ? [`Meeting link: ${emailLink("Join meeting", meetingLink)}.`]
+          : []),
+      ],
+      cta: { label: "View booking", url: manageUrl },
+      footer: "This booking was created from your calendar booking link.",
+    }),
+  };
+}
+
+export function renderBookingCancelledEmail({
+  title,
+  when,
+  host,
+  bookAgainUrl,
+}: {
+  title: string;
+  when: string;
+  host: string;
+  bookAgainUrl?: string;
+}) {
+  return {
+    subject: `Cancelled: ${title}`,
+    ...renderEmail({
+      preheader: `${title} on ${when} was cancelled.`,
+      heading: "Your meeting was cancelled",
+      paragraphs: [
+        `${emailStrong(title)} with ${emailStrong(host || "the host")} has been cancelled.`,
+        `Original time: ${emailStrong(when)}.`,
+      ],
+      cta: bookAgainUrl
+        ? { label: "Book another time", url: bookAgainUrl }
+        : undefined,
+      footer: "If this was unexpected, contact the meeting host.",
+    }),
+  };
+}
+
+export function renderBookingCancelledHostEmail({
+  title,
+  when,
+  attendeeName,
+  attendee,
+}: {
+  title: string;
+  when: string;
+  attendeeName: string;
+  attendee: string;
+}) {
+  return {
+    subject: `Cancelled booking: ${title}`,
+    ...renderEmail({
+      preheader: `${attendeeName}'s booking for ${title} was cancelled.`,
+      heading: "Booking cancelled",
+      paragraphs: [
+        `${emailStrong(attendeeName)}'s booking for ${emailStrong(title)} was cancelled.`,
+        `Original time: ${emailStrong(when)}.`,
+        `Guest: ${emailStrong(attendee)}.`,
+      ],
+      footer: "No further action is needed.",
+    }),
+  };
+}
+
 export async function sendBookingConfirmationEmails({
   booking,
   hostEmail,
@@ -74,54 +202,31 @@ export async function sendBookingConfirmationEmails({
   const attendee = stripCrlf(booking.email);
   const attendeeName = stripCrlf(booking.name) || "there";
 
-  const attendeeParagraphs = [
-    `You're booked for ${emailStrong(title)} with ${emailStrong(host)}.`,
-    `Time: ${emailStrong(when)}.`,
-  ];
-  if (booking.meetingLink) {
-    attendeeParagraphs.push(
-      `Meeting link: ${emailLink("Join meeting", booking.meetingLink)}.`,
-    );
-  }
-
-  const attendeeEmail = renderEmail({
-    preheader: `You're booked for ${title} on ${when}.`,
-    heading: "Your meeting is booked",
-    paragraphs: attendeeParagraphs,
-    cta: { label: "Manage booking", url: manageUrl },
-    footer:
-      "Use the manage link if you need to cancel or reschedule this meeting.",
-  });
-
   await sendBestEffort("attendee confirmation", {
     to: attendee,
-    subject: `Confirmed: ${title}`,
-    html: attendeeEmail.html,
-    text: attendeeEmail.text,
+    ...renderBookingConfirmedEmail({
+      title,
+      when,
+      host,
+      manageUrl,
+      meetingLink: booking.meetingLink,
+    }),
     replyTo: host,
-  });
-
-  const hostEmailMessage = renderEmail({
-    preheader: `${attendeeName} booked ${title} on ${when}.`,
-    heading: "New booking",
-    paragraphs: [
-      `${emailStrong(attendeeName)} booked ${emailStrong(title)}.`,
-      `Time: ${emailStrong(when)}.`,
-      `Guest: ${emailStrong(attendee)}.`,
-      ...(booking.meetingLink
-        ? [`Meeting link: ${emailLink("Join meeting", booking.meetingLink)}.`]
-        : []),
-    ],
-    cta: { label: "View booking", url: manageUrl },
-    footer: "This booking was created from your calendar booking link.",
+    templateId: CALENDAR_BOOKING_CONFIRMED_EMAIL_ID,
   });
 
   await sendBestEffort("host notification", {
     to: host,
-    subject: `New booking: ${title}`,
-    html: hostEmailMessage.html,
-    text: hostEmailMessage.text,
+    ...renderBookingReceivedEmail({
+      title,
+      when,
+      attendeeName,
+      attendee,
+      manageUrl,
+      meetingLink: booking.meetingLink,
+    }),
     replyTo: attendee,
+    templateId: CALENDAR_BOOKING_RECEIVED_EMAIL_ID,
   });
 }
 
@@ -142,45 +247,24 @@ export async function sendBookingCancellationEmails({
   const attendee = stripCrlf(booking.email);
   const attendeeName = stripCrlf(booking.name) || "The guest";
 
-  const attendeeEmail = renderEmail({
-    preheader: `${title} on ${when} was cancelled.`,
-    heading: "Your meeting was cancelled",
-    paragraphs: [
-      `${emailStrong(title)} with ${emailStrong(host || "the host")} has been cancelled.`,
-      `Original time: ${emailStrong(when)}.`,
-    ],
-    cta: bookAgainUrl
-      ? { label: "Book another time", url: bookAgainUrl }
-      : undefined,
-    footer: "If this was unexpected, contact the meeting host.",
-  });
-
   await sendBestEffort("attendee cancellation", {
     to: attendee,
-    subject: `Cancelled: ${title}`,
-    html: attendeeEmail.html,
-    text: attendeeEmail.text,
+    ...renderBookingCancelledEmail({ title, when, host, bookAgainUrl }),
     replyTo: host || undefined,
+    templateId: CALENDAR_BOOKING_CANCELLED_EMAIL_ID,
   });
 
   if (!host) return;
 
-  const hostEmailMessage = renderEmail({
-    preheader: `${attendeeName}'s booking for ${title} was cancelled.`,
-    heading: "Booking cancelled",
-    paragraphs: [
-      `${emailStrong(attendeeName)}'s booking for ${emailStrong(title)} was cancelled.`,
-      `Original time: ${emailStrong(when)}.`,
-      `Guest: ${emailStrong(attendee)}.`,
-    ],
-    footer: "No further action is needed.",
-  });
-
   await sendBestEffort("host cancellation notification", {
     to: host,
-    subject: `Cancelled booking: ${title}`,
-    html: hostEmailMessage.html,
-    text: hostEmailMessage.text,
+    ...renderBookingCancelledHostEmail({
+      title,
+      when,
+      attendeeName,
+      attendee,
+    }),
     replyTo: attendee,
+    templateId: CALENDAR_BOOKING_CANCELLED_HOST_EMAIL_ID,
   });
 }

package/corpus/templates/calendar/server/lib/emails.ts

@@ -0,0 +1,167 @@
+/**
+ * Catalog entries for the transactional emails Calendar sends.
+ *
+ * Registered from `server/plugins/transactional-emails.ts` so Dispatch can list
+ * and preview them without the app having sent anything yet.
+ */
+
+import { defineTransactionalEmail } from "@agent-native/core/email-catalog";
+
+import {
+  renderBookingCancelledEmail,
+  renderBookingCancelledHostEmail,
+  renderBookingConfirmedEmail,
+  renderBookingReceivedEmail,
+} from "./booking-emails.js";
+import { renderEventGuestNote } from "./event-guest-notifications.js";
+
+/** Obviously-fake sample data — these render in a preview pane, never send. */
+const SAMPLE_TITLE = "Intro call";
+const SAMPLE_WHEN = "Tuesday, March 4, 2025, 10:00 AM - 10:30 AM PST";
+const SAMPLE_HOST = "dana.hill@example.com";
+const SAMPLE_GUEST = "sam.rivera@example.com";
+const SAMPLE_GUEST_NAME = "Sam Rivera";
+const SAMPLE_MANAGE_URL = "https://example.com/book/dana/manage/sample-token";
+const SAMPLE_BOOK_AGAIN_URL = "https://example.com/book/dana/intro-call";
+const SAMPLE_MEETING_LINK = "https://meet.example.com/sample-intro-call";
+
+export const CALENDAR_BOOKING_CONFIRMED_EMAIL_ID = "calendar.booking-confirmed";
+export const CALENDAR_BOOKING_RECEIVED_EMAIL_ID = "calendar.booking-received";
+export const CALENDAR_BOOKING_CANCELLED_EMAIL_ID = "calendar.booking-cancelled";
+export const CALENDAR_BOOKING_CANCELLED_HOST_EMAIL_ID =
+  "calendar.booking-cancelled-host";
+export const CALENDAR_EVENT_UPDATE_NOTE_EMAIL_ID = "calendar.event-update-note";
+export const CALENDAR_EVENT_CANCELLATION_NOTE_EMAIL_ID =
+  "calendar.event-cancellation-note";
+
+let registered = false;
+
+export function registerCalendarEmails(): void {
+  if (registered) return;
+  registered = true;
+
+  defineTransactionalEmail({
+    id: CALENDAR_BOOKING_CONFIRMED_EMAIL_ID,
+    name: "Booking confirmed (guest)",
+    trigger:
+      "A guest completes a booking on a public `/book/{username}/{slug}` page and the booking row is created.",
+    recipientLabel: "Booking guest",
+    recipient:
+      "The email address the guest typed into the booking form (`booking.email`).",
+    senderLabel: "Default, reply-to host",
+    sender:
+      "The configured EMAIL_FROM, with reply-to set to the booking link owner's address.",
+    preview: () =>
+      renderBookingConfirmedEmail({
+        title: SAMPLE_TITLE,
+        when: SAMPLE_WHEN,
+        host: SAMPLE_HOST,
+        manageUrl: SAMPLE_MANAGE_URL,
+        meetingLink: SAMPLE_MEETING_LINK,
+      }),
+  });
+
+  defineTransactionalEmail({
+    id: CALENDAR_BOOKING_RECEIVED_EMAIL_ID,
+    name: "New booking (host)",
+    trigger:
+      "Sent alongside the guest confirmation, immediately after a public booking is created.",
+    recipientLabel: "Booking link owner",
+    recipient:
+      "The owner of the booking link, looked up from the link's slug at send time.",
+    senderLabel: "Default, reply-to guest",
+    sender:
+      "The configured EMAIL_FROM, with reply-to set to the guest so the host can reply directly.",
+    preview: () =>
+      renderBookingReceivedEmail({
+        title: SAMPLE_TITLE,
+        when: SAMPLE_WHEN,
+        attendeeName: SAMPLE_GUEST_NAME,
+        attendee: SAMPLE_GUEST,
+        manageUrl: SAMPLE_MANAGE_URL,
+        meetingLink: SAMPLE_MEETING_LINK,
+      }),
+  });
+
+  defineTransactionalEmail({
+    id: CALENDAR_BOOKING_CANCELLED_EMAIL_ID,
+    name: "Booking cancelled (guest)",
+    trigger:
+      "A booking that was not already cancelled is cancelled, either by the guest through the manage/cancel token link or by someone with access to the booking link.",
+    recipientLabel: "Booking guest",
+    recipient: "The guest address stored on the booking row.",
+    senderLabel: "Default, reply-to host",
+    sender:
+      "The configured EMAIL_FROM, with reply-to set to the host when a host address could be resolved from the link slug.",
+    preview: () =>
+      renderBookingCancelledEmail({
+        title: SAMPLE_TITLE,
+        when: SAMPLE_WHEN,
+        host: SAMPLE_HOST,
+        bookAgainUrl: SAMPLE_BOOK_AGAIN_URL,
+      }),
+  });
+
+  defineTransactionalEmail({
+    id: CALENDAR_BOOKING_CANCELLED_HOST_EMAIL_ID,
+    name: "Booking cancelled (host)",
+    trigger:
+      "Sent after the guest cancellation notice, and only when a host address could be resolved from the booking link slug.",
+    recipientLabel: "Booking link owner",
+    recipient: "The booking link owner's address.",
+    senderLabel: "Default, reply-to guest",
+    sender:
+      "The configured EMAIL_FROM, with reply-to set to the guest who was booked.",
+    preview: () =>
+      renderBookingCancelledHostEmail({
+        title: SAMPLE_TITLE,
+        when: SAMPLE_WHEN,
+        attendeeName: SAMPLE_GUEST_NAME,
+        attendee: SAMPLE_GUEST,
+      }),
+  });
+
+  defineTransactionalEmail({
+    id: CALENDAR_EVENT_UPDATE_NOTE_EMAIL_ID,
+    name: "Event update note",
+    trigger:
+      "`update-event` runs with a non-empty guest notification message. Google Calendar still sends its own update invite; this carries only the organizer's note.",
+    recipientLabel: "Event attendees",
+    recipient:
+      "Every attendee on the event with a syntactically valid address, excluding the organizer's own `self` attendee row. One email per address.",
+    senderLabel: "Default, reply-to organizer",
+    sender:
+      "The configured EMAIL_FROM, with reply-to set to the organizer running the update.",
+    preview: () =>
+      renderEventGuestNote({
+        title: "Design review",
+        organizer: "Dana Hill",
+        message: "Moving this an hour later so the whole team can join.",
+        when: SAMPLE_WHEN,
+        kind: "update",
+        htmlLink: "https://calendar.example.com/event/sample",
+      }),
+  });
+
+  defineTransactionalEmail({
+    id: CALENDAR_EVENT_CANCELLATION_NOTE_EMAIL_ID,
+    name: "Event cancellation note",
+    trigger:
+      "`delete-event` runs with guest notification requested and a non-empty message. Google Calendar sends the cancellation itself; this carries only the organizer's note.",
+    recipientLabel: "Event attendees",
+    recipient:
+      "Every attendee on the deleted event with a syntactically valid address, excluding the organizer's own `self` attendee row. One email per address.",
+    senderLabel: "Default, reply-to organizer",
+    sender:
+      "The configured EMAIL_FROM, with reply-to set to the organizer running the deletion.",
+    preview: () =>
+      renderEventGuestNote({
+        title: "Design review",
+        organizer: "Dana Hill",
+        message: "Cancelling this week — we will pick it up after the launch.",
+        when: SAMPLE_WHEN,
+        kind: "cancellation",
+        appliesTo: "all events in the series",
+      }),
+  });
+}