@agent-native/core 0.134.1 → 0.135.1

package/src/server/action-discovery.ts

@@ -625,6 +625,10 @@ export async function mergeCoreSharingActions(
       "manage-recurring-job",
       () => import("../jobs/actions/manage-recurring-job.js"),
     ],
+    [
+      "list-automation-runs",
+      () => import("../jobs/actions/list-automation-runs.js"),
+    ],
     [
       "list-automations",
       () => import("../triggers/actions/list-automations.js"),

package/src/server/activity-notifications.ts

@@ -0,0 +1,174 @@
+/**
+ * Shared plumbing for collaboration emails (comments, replies, reactions,
+ * mentions).
+ *
+ * Two things every app was about to reimplement live here: resolving who
+ * should receive an activity email, and reporting delivery honestly. A
+ * workspace with no email provider is a *different* outcome from "nobody
+ * wanted this email" — collapsing both into an empty success is what let a
+ * dead notification toggle ship unnoticed.
+ */
+
+import { getUserSetting } from "../settings/user-settings.js";
+import { isEmailConfigured } from "./email.js";
+
+export type ActivityDeliveryFailure = { email: string; error: string };
+
+export type ActivityNotificationStatus =
+  | "delivered"
+  | "delivery-failed"
+  | "email-not-configured"
+  | "no-recipients"
+  | "notification-error";
+
+export type ActivityNotificationResult = {
+  status: ActivityNotificationStatus;
+  sent: string[];
+  failed: ActivityDeliveryFailure[];
+  /** Set only on `notification-error`: why recipients could not be resolved. */
+  error?: string;
+};
+
+/** Default field read from an app's per-user preference blob. */
+const DEFAULT_PREFERENCE_FIELD = "emailNotifications";
+
+export interface ResolveActivityRecipientsInput {
+  /** Owner, thread participants, mentions — duplicates and blanks are fine. */
+  candidates: (string | null | undefined)[];
+  /** The person who caused the activity. Never emailed about their own action. */
+  actorEmail?: string | null;
+  /** App-owned user settings key, e.g. `clips-user-prefs`. */
+  preferenceKey: string;
+  /** Field inside that blob. Absent or non-`false` means opted in. */
+  preferenceField?: string;
+}
+
+function normalizeEmail(value: string | null | undefined): string {
+  return (value ?? "").trim().toLowerCase();
+}
+
+async function wantsActivityEmail(
+  email: string,
+  preferenceKey: string,
+  preferenceField: string,
+): Promise<boolean> {
+  const prefs = await getUserSetting(email, preferenceKey);
+  // A user who never opened settings has no stored blob; treat that as opted
+  // in rather than silently dropping their notifications.
+  return prefs?.[preferenceField] !== false;
+}
+
+/**
+ * Normalize, dedupe, drop the actor, and filter by each recipient's stored
+ * preference. Order follows first appearance in `candidates`.
+ */
+export async function resolveActivityRecipients({
+  candidates,
+  actorEmail,
+  preferenceKey,
+  preferenceField = DEFAULT_PREFERENCE_FIELD,
+}: ResolveActivityRecipientsInput): Promise<string[]> {
+  const actor = normalizeEmail(actorEmail);
+  const unique = new Set<string>();
+  for (const candidate of candidates) {
+    const email = normalizeEmail(candidate);
+    if (!email || email === actor || !email.includes("@")) continue;
+    unique.add(email);
+  }
+
+  const decisions = await Promise.all(
+    [...unique].map(async (email) =>
+      (await wantsActivityEmail(email, preferenceKey, preferenceField))
+        ? email
+        : null,
+    ),
+  );
+  return decisions.filter((email): email is string => email !== null);
+}
+
+export interface NotifyActivityInput extends ResolveActivityRecipientsInput {
+  /** Sends one email. Throwing marks that recipient failed, not the batch. */
+  send: (to: string) => Promise<unknown>;
+  /** Prefix for the delivery-failure log line, e.g. `[slides]`. */
+  logLabel?: string;
+}
+
+/**
+ * Resolve recipients and deliver one email each. Returns a status that
+ * distinguishes "no email provider" from "nobody to email" from a real send.
+ */
+export async function notifyActivity({
+  send,
+  logLabel,
+  ...resolve
+}: NotifyActivityInput): Promise<ActivityNotificationResult> {
+  if (!(await isEmailConfigured())) {
+    return { status: "email-not-configured", sent: [], failed: [] };
+  }
+
+  const recipients = await resolveActivityRecipients(resolve);
+  if (recipients.length === 0) {
+    return { status: "no-recipients", sent: [], failed: [] };
+  }
+
+  const sent: string[] = [];
+  const failed: ActivityDeliveryFailure[] = [];
+  for (const to of recipients) {
+    try {
+      await send(to);
+      sent.push(to);
+    } catch (error) {
+      failed.push({
+        email: to,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  if (failed.length > 0) {
+    console.error(
+      `${logLabel ?? "[activity-notifications]"} delivery failed for ${failed
+        .map((failure) => `${failure.email} (${failure.error})`)
+        .join(", ")}`,
+    );
+  }
+
+  // Every recipient failing is an outage, not a delivery. Callers that log or
+  // surface this must not see it as the same outcome as a successful send.
+  return {
+    status: sent.length === 0 ? "delivery-failed" : "delivered",
+    sent,
+    failed,
+  };
+}
+
+/**
+ * Run an activity notification without letting it fail the write that caused
+ * it. The comment/reaction is already persisted by the time notification runs;
+ * rejecting here makes the client roll back and retry, which duplicates the
+ * row. The error still surfaces — as a distinct `notification-error` status,
+ * never as a silent success.
+ */
+export async function runActivityNotification<
+  T extends {
+    status: string;
+    sent: string[];
+    failed: ActivityDeliveryFailure[];
+  },
+>(
+  logLabel: string,
+  resolve: () => Promise<T>,
+): Promise<T | ActivityNotificationResult> {
+  try {
+    return await resolve();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`${logLabel} could not be resolved: ${message}`);
+    return {
+      status: "notification-error",
+      error: message,
+      sent: [],
+      failed: [],
+    };
+  }
+}

package/src/server/app-name.ts

@@ -51,3 +51,34 @@ export function getAppName(): string | undefined {
   cachedFromPkg = name ?? undefined;
   return name;
 }
+
+/**
+ * Resolve the app's slug — the machine-readable identifier used for the
+ * per-app transactional email sender (e.g. `clips@agent-native.com`).
+ *
+ * Only a first-party template name matched by package.json qualifies. A slug
+ * derived from an arbitrary `APP_NAME` must not mint a mailbox on the
+ * agent-native.com domain: a custom app would then send as
+ * `<its-name>@agent-native.com` and route replies to the Builder mailbox.
+ * Returns `undefined` for anything unrecognized, which leaves the deployment's
+ * configured sender in place.
+ */
+export function getAppSlug(): string | undefined {
+  const pkg = readPkg();
+  if (!pkg?.name) return undefined;
+  return TEMPLATES.find((t) => t.name === pkg.name)?.name;
+}
+
+/**
+ * One-line description of the app, used to tailor transactional email bodies
+ * so recipients recognize which app they signed up for. Sourced from the
+ * first-party template metadata; `undefined` for unknown apps.
+ */
+export function getAppDescription(): string | undefined {
+  const pkg = readPkg();
+  if (pkg?.name) {
+    const tmpl = TEMPLATES.find((t) => t.name === pkg.name);
+    if (tmpl) return tmpl.hint;
+  }
+  return undefined;
+}

package/src/server/better-auth-instance.ts

@@ -933,11 +933,11 @@ async function createBetterAuthInstance(
           ""
         ).replace(/\/$/, "");
         const resetUrl = `${appUrl}${appBasePath}/_agent-native/auth/reset?token=${encodeURIComponent(token)}`;
-        const { subject, html, text } = renderResetPasswordEmail({
+        const { subject, html, text, appSender } = renderResetPasswordEmail({
           email: user.email,
           resetUrl,
         });
-        await sendEmail({ to: user.email, subject, html, text });
+        await sendEmail({ to: user.email, subject, html, text, appSender });
       },
     },
     emailVerification: {
@@ -960,11 +960,11 @@ async function createBetterAuthInstance(
         const verifyUrl = verifyBasePath
           ? url.replace(/(\/\/[^/]+)(\/)/, `$1${verifyBasePath}$2`)
           : url;
-        const { subject, html, text } = renderVerifySignupEmail({
+        const { subject, html, text, appSender } = renderVerifySignupEmail({
           email: user.email,
           verifyUrl,
         });
-        await sendEmail({ to: user.email, subject, html, text });
+        await sendEmail({ to: user.email, subject, html, text, appSender });
       },
     },
     socialProviders,

package/src/server/email-templates.ts

@@ -11,13 +11,22 @@
  * site — keeps the transactional look-and-feel consistent.
  */
 
-import { getAppName } from "./app-name.js";
+import { getAppName, getAppSlug, getAppDescription } from "./app-name.js";
 import { renderEmail, emailStrong } from "./email-template.js";
 
+/** Shared reply-to for the framework's transactional emails. */
+export const AGENT_NATIVE_REPLY_TO = "agent-native@builder.io";
+
 export interface RenderedEmailMessage {
   subject: string;
   html: string;
   text: string;
+  /**
+   * Per-app sender branding, applied by `sendEmail` only on first-party
+   * agent-native.com deployments. Self-hosted deployments keep the sender and
+   * reply-to they configured via EMAIL_FROM.
+   */
+  appSender?: { name: string; slug: string; replyTo?: string };
 }
 
 /**
@@ -33,6 +42,17 @@ function resolveAppName(): string {
   return stripCrlf(getAppName() || "Agent Native");
 }
 
+/**
+ * Recipient-facing brand for auth emails. Only a recognized first-party
+ * template is presented as "Agent-Native <App>"; a custom deployment keeps its
+ * own name so its users aren't told they signed up for an Agent Native app.
+ */
+function resolveBrand(slug: string | undefined): string {
+  const appName = getAppName();
+  if (!appName) return "Agent Native";
+  return slug ? `Agent-Native ${stripCrlf(appName)}` : stripCrlf(appName);
+}
+
 // ---------------------------------------------------------------------------
 // Organization invitation
 // ---------------------------------------------------------------------------
@@ -89,28 +109,58 @@ export interface RenderVerifySignupEmailArgs {
   verifyUrl: string;
 }
 
+/**
+ * Customer-facing description overrides for the verification email body. The
+ * default descriptions come from the app-picker hints, which name competitors
+ * for internal positioning; these rewrites frame them as "replacement" for a
+ * customer-facing email without changing the picker copy.
+ */
+const VERIFY_EMAIL_DESCRIPTIONS: Record<string, string> = {
+  calendar:
+    "Agent-native Google Calendar replacement — manage events, sync, and public booking",
+  content:
+    "Open-source Obsidian/Notion replacement for MDX — edit local docs with agent assistance",
+  slides:
+    "Agent-native Google Slides replacement — generate and edit React presentations",
+  analytics:
+    "Agent-native Amplitude/Mixpanel replacement — connect data sources, prompt for charts",
+  mail: "Agent-native Superhuman replacement — email client with keyboard shortcuts and AI triage",
+};
+
 export function renderVerifySignupEmail(
   args: RenderVerifySignupEmailArgs,
 ): RenderedEmailMessage {
   const email = stripCrlf(args.email);
-  const appName = resolveAppName();
+  const slug = getAppSlug();
+  const brand = resolveBrand(slug);
+  const description = slug
+    ? (VERIFY_EMAIL_DESCRIPTIONS[slug] ?? getAppDescription())
+    : undefined;
+
+  const paragraphs = [
+    `Thanks for signing up for ${emailStrong(brand)}. To finish creating your account, confirm that ${emailStrong(email)} is your email address.`,
+  ];
+  if (description) {
+    paragraphs.push(`${stripCrlf(description).replace(/\.\s*$/, "")}.`);
+  }
+  paragraphs.push(`This link expires in 1 hour.`);
 
   const { html, text } = renderEmail({
-    brandName: appName,
-    preheader: `Confirm ${email} to finish setting up your ${appName} account.`,
-    heading: `Verify your email for ${appName}`,
-    paragraphs: [
-      `Thanks for signing up for ${emailStrong(appName)}. To finish creating your account, confirm that ${emailStrong(email)} is your email address.`,
-      `This link expires in 1 hour.`,
-    ],
+    brandName: brand,
+    preheader: `Confirm ${email} to finish setting up your ${brand} account.`,
+    heading: `Verify your email for ${brand}`,
+    paragraphs,
     cta: { label: "Verify email", url: args.verifyUrl },
     footer: `If you didn't sign up, you can safely ignore this email.`,
   });
 
   return {
-    subject: `Verify your email for ${appName}`,
+    subject: `Verify your email for ${brand}`,
     html,
     text,
+    appSender: slug
+      ? { name: brand, slug, replyTo: AGENT_NATIVE_REPLY_TO }
+      : undefined,
   };
 }
 
@@ -129,12 +179,15 @@ export function renderResetPasswordEmail(
   args: RenderResetPasswordEmailArgs,
 ): RenderedEmailMessage {
   const email = stripCrlf(args.email);
-  const appName = resolveAppName();
+  // Match the verification email branding so password resets are clearly tied
+  // to the specific app. No value pitch here — it's a security email.
+  const slug = getAppSlug();
+  const brand = resolveBrand(slug);
 
   const { html, text } = renderEmail({
-    brandName: appName,
+    brandName: brand,
     preheader: `Reset the password for ${email}. This link expires in 1 hour.`,
-    heading: `Reset your ${appName} password`,
+    heading: `Reset your ${brand} password`,
     paragraphs: [
       `Someone requested a password reset for ${emailStrong(email)}. Click the button below to choose a new password.`,
       `This link expires in 1 hour.`,
@@ -144,8 +197,11 @@ export function renderResetPasswordEmail(
   });
 
   return {
-    subject: `Reset your ${appName} password`,
+    subject: `Reset your ${brand} password`,
     html,
     text,
+    appSender: slug
+      ? { name: brand, slug, replyTo: AGENT_NATIVE_REPLY_TO }
+      : undefined,
   };
 }

package/src/server/email.ts

@@ -39,6 +39,14 @@ export interface SendEmailArgs {
   fromName?: string;
   cc?: string | string[];
   replyTo?: string;
+  /**
+   * Per-app branding for first-party agent-native.com deployments. Applied
+   * only when the configured EMAIL_FROM is already on agent-native.com, so a
+   * self-hosted deployment keeps its own verified sender and support mailbox
+   * instead of sending as an unverified address a provider would reject.
+   * An explicit `from` / `replyTo` always wins.
+   */
+  appSender?: { name: string; slug: string; replyTo?: string };
   inReplyTo?: string;
   references?: string;
   attachments?: EmailAttachment[];
@@ -150,6 +158,56 @@ function withDisplayName(from: string, name: string): string {
   return `"${safe}" <${address}>`;
 }
 
+const AGENT_NATIVE_SENDER_DOMAIN = "agent-native.com";
+
+/**
+ * Resolve the per-app sender address, but only for deployments whose
+ * configured sender is already on agent-native.com. Any other (or missing)
+ * EMAIL_FROM means we cannot prove the branded address is a verified sender,
+ * so the deployment's own configuration is left untouched.
+ */
+let warnedAppSenderSuppressed = false;
+
+/**
+ * Suppressing the branding is correct for a sender we cannot prove we own,
+ * but it must not be invisible, or an operator sees generic senders with
+ * nothing pointing at why.
+ *
+ * EMAIL_FROM resolves per user/org/workspace through the scoped secret store,
+ * so the resolved address is tenant data and must never reach shared logs, and
+ * anything keyed by it would grow without bound in a warm worker. The message
+ * therefore carries no tenant values, which also makes it identical for every
+ * suppressed config — so emitting it once per process loses nothing.
+ */
+function warnAppSenderSuppressed(): void {
+  if (warnedAppSenderSuppressed) return;
+  warnedAppSenderSuppressed = true;
+  console.warn(
+    `[agent-native:email] Per-app sender branding is off because the ` +
+      `configured EMAIL_FROM is not on ${AGENT_NATIVE_SENDER_DOMAIN}. ` +
+      `Transactional email keeps the configured sender. Expected when self-hosting.`,
+  );
+}
+
+function resolveAppSender(
+  configuredFrom: string | undefined,
+  appSender: SendEmailArgs["appSender"],
+): { address: string; name: string; replyTo?: string } | undefined {
+  if (!appSender) return undefined;
+  const address = configuredFrom
+    ? parseSendGridFrom(configuredFrom).email.toLowerCase()
+    : undefined;
+  if (!address?.endsWith(`@${AGENT_NATIVE_SENDER_DOMAIN}`)) {
+    warnAppSenderSuppressed();
+    return undefined;
+  }
+  return {
+    address: `${appSender.slug}@${AGENT_NATIVE_SENDER_DOMAIN}`,
+    name: appSender.name,
+    replyTo: appSender.replyTo,
+  };
+}
+
 async function sendEmailWithSignal(
   args: SendEmailArgs,
   signal?: AbortSignal,
@@ -157,7 +215,12 @@ async function sendEmailWithSignal(
   const config = await resolveEmailTransport();
   signal?.throwIfAborted();
   const provider = config.provider;
-  const from = getFromAddress(config, args.from, args.fromName);
+  const branded = resolveAppSender(config.from, args.appSender);
+  const from =
+    branded && !args.from
+      ? withDisplayName(branded.address, args.fromName ?? branded.name)
+      : getFromAddress(config, args.from, args.fromName);
+  const replyTo = args.replyTo ?? branded?.replyTo;
   const attachments = resolveAttachments(args);
 
   if (provider === "resend") {
@@ -169,7 +232,7 @@ async function sendEmailWithSignal(
       text: args.text,
     };
     if (args.cc) payload.cc = Array.isArray(args.cc) ? args.cc : [args.cc];
-    if (args.replyTo) payload.reply_to = args.replyTo;
+    if (replyTo) payload.reply_to = replyTo;
     if (attachments?.length) {
       payload.attachments = attachments.map((a) => ({
         filename: a.filename,
@@ -220,7 +283,7 @@ async function sendEmailWithSignal(
         { type: "text/html", value: args.html },
       ],
     };
-    if (args.replyTo) sgPayload.reply_to = parseSendGridFrom(args.replyTo);
+    if (replyTo) sgPayload.reply_to = parseSendGridFrom(replyTo);
     const sgHeaders: Record<string, string> = {};
     if (args.inReplyTo) sgHeaders["In-Reply-To"] = args.inReplyTo;
     if (args.references) sgHeaders["References"] = args.references;

package/src/server/index.ts

@@ -547,6 +547,16 @@ export {
   type EmailProvider,
   type SendEmailArgs,
 } from "./email.js";
+export {
+  notifyActivity,
+  runActivityNotification,
+  resolveActivityRecipients,
+  type ActivityDeliveryFailure,
+  type ActivityNotificationResult,
+  type ActivityNotificationStatus,
+  type NotifyActivityInput,
+  type ResolveActivityRecipientsInput,
+} from "./activity-notifications.js";
 export {
   renderEmail,
   emailStrong,

package/src/sharing/access.ts

@@ -15,6 +15,7 @@
 
 import { and, eq, or, sql, type SQL } from "drizzle-orm";
 
+import { orgMembers } from "../org/schema.js";
 import {
   getRequestAuthCapability,
   getRequestUserEmail,
@@ -87,6 +88,35 @@ function emailColumnMatches(column: any, email: string): SQL {
   return sql`lower(${column}) = ${email}`;
 }
 
+/**
+ * Real `org_members` membership, independent of the caller's currently
+ * active org (`ctx.orgId`). `org`-visibility access must key off actual
+ * membership — a user's active-org selection is a UI convenience, not a
+ * statement of which orgs they belong to.
+ *
+ * Queries through the resource's own `reg.getDb()` — the same connection
+ * every other lookup in this file uses — not the ambient `getDbExec()`,
+ * since `org_members` lives in that same app database.
+ */
+async function isOrgMember(
+  reg: ShareableResourceRegistration,
+  memberOrgId: string,
+  email: string,
+): Promise<boolean> {
+  const db = reg.getDb() as any;
+  const rows = await db
+    .select({ id: orgMembers.id })
+    .from(orgMembers)
+    .where(
+      and(
+        eq(orgMembers.orgId, memberOrgId),
+        emailColumnMatches(orgMembers.email, email),
+      ),
+    )
+    .limit(1);
+  return rows.length > 0;
+}
+
 /**
  * Build a Drizzle `WHERE` clause that admits rows the current user can see.
  * Pass the ownable resource table and its shares table; optional min role
@@ -470,7 +500,7 @@ async function resolveAccessImpl(
   const resource = await loadResourceForAccess(reg, resourceId, options);
   if (!resource) return null;
 
-  const { userEmail, orgId } = ctx;
+  const { userEmail } = ctx;
   const normalizedUserEmail = normalizeEmailForAccess(userEmail);
 
   if (
@@ -491,7 +521,19 @@ async function resolveAccessImpl(
   // `visibility === "public"` on an `allowPublic: false` resource is treated
   // as private: only owner + explicit shares grant access. Falls through to
   // the explicit-share lookup below.
-  if (resource.visibility === "org" && orgId && resource.orgId === orgId) {
+  //
+  // Membership in the resource's own org, not equality with the caller's
+  // currently active org: a caller can be a genuine member of the
+  // resource's org while a *different* org is their active selection, and
+  // `org` visibility should still admit them. Still requires some active
+  // org to be set at all (`orgId`), matching the pre-existing behavior for
+  // a caller with no active org.
+  if (
+    resource.visibility === "org" &&
+    resource.orgId &&
+    normalizedUserEmail &&
+    (await isOrgMember(reg, resource.orgId, normalizedUserEmail))
+  ) {
     const role = await highestShareRole(reg, resourceId, ctx, resource);
     return { role: role ?? "viewer", resource };
   }

package/src/sharing/index.ts

@@ -34,3 +34,8 @@ export {
   type AccessContext,
   type ResolvedAccess,
 } from "./access.js";
+
+export {
+  filterRecipientsByResourceAccess,
+  type FilterRecipientsInput,
+} from "./recipients.js";

package/src/sharing/recipients.ts

@@ -0,0 +1,67 @@
+import { isOrgMember } from "../org/membership.js";
+import { resolveAccess } from "./access.js";
+import { roleSatisfies, type ShareRole } from "./schema.js";
+
+export interface FilterRecipientsInput {
+  resourceType: string;
+  resourceId: string;
+  emails: Iterable<string>;
+  /** The resource's org, needed to honor `org` visibility. */
+  orgId?: string | null;
+  minimumRole?: ShareRole;
+  /**
+   * Override for resources that are not registered through `registerShareableResource`
+   * (the review registry resolves its own). Must honor `userEmail`/`orgId`
+   * rather than the ambient request, or the filter checks the wrong principal.
+   */
+  resolveRole?: (ctx: {
+    userEmail: string;
+    orgId?: string;
+  }) => Promise<{ role: string } | null>;
+}
+
+/**
+ * Keep only the addresses that can still open the resource *right now*.
+ *
+ * Notification recipient lists are built from historical rows — thread
+ * authors, stored mentions, caller-supplied addresses — none of which are an
+ * access grant. Without this, mentioning an arbitrary address mails it the
+ * comment body, and a collaborator whose share was revoked keeps receiving the
+ * thread. Access is re-resolved per address against the live ACL.
+ */
+export async function filterRecipientsByResourceAccess({
+  resourceType,
+  resourceId,
+  emails,
+  orgId,
+  minimumRole = "viewer",
+  resolveRole,
+}: FilterRecipientsInput): Promise<string[]> {
+  const resolve =
+    resolveRole ??
+    ((ctx: { userEmail: string; orgId?: string }) =>
+      resolveAccess(resourceType, resourceId, ctx));
+  const unique = new Set<string>();
+  for (const raw of emails) {
+    const email = raw.trim().toLowerCase();
+    if (email) unique.add(email);
+  }
+  if (unique.size === 0) return [];
+
+  const decisions = await Promise.all(
+    [...unique].map(async (email) => {
+      // Resolve without an org first: passing the resource's org up front
+      // would hand org-visibility access to anyone who is not in it.
+      const direct = await resolve({ userEmail: email });
+      if (direct && roleSatisfies(direct.role as ShareRole, minimumRole)) {
+        return email;
+      }
+      if (!orgId || !(await isOrgMember(orgId, email))) return null;
+      const viaOrg = await resolve({ userEmail: email, orgId });
+      return viaOrg && roleSatisfies(viaOrg.role as ShareRole, minimumRole)
+        ? email
+        : null;
+    }),
+  );
+  return decisions.filter((email): email is string => email !== null);
+}