@open-workspace/email 0.0.0-stage → 0.1.1

package/worker/mail/safety-routes.ts

@@ -0,0 +1,350 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono, type Context } from "hono";
+import { normalizeBlockPattern, type ReportKind } from "../../shared/mail-feedback";
+import { createDb } from "@open-workspace/core/worker/db/client.ts";
+import type { AppEnv } from "@open-workspace/core/worker/env.ts";
+import { apiError } from "@open-workspace/core/worker/lib/http.ts";
+import { createId } from "@open-workspace/core/worker/lib/ids.ts";
+import { checkRateLimit } from "@open-workspace/core/worker/lib/rate-limit.ts";
+import { mailboxStub } from "../mailbox";
+import { MAIL_RULE_LIMIT_MESSAGE } from "../mailbox/rules";
+import type { Email } from "../mailbox/schema";
+import { getMailboxAccess } from "./access";
+import { oneClickFetcher } from "./demo-routes";
+import { withHeaderMetadata } from "./header-metadata";
+import { emailListKey, emailSecurity } from "./message-view";
+import { submitOutgoing } from "./outbound-service";
+import { recordReportedMessage, reportSnapshot } from "./reported-messages";
+import {
+  blockPatternQuerySchema,
+  blockSenderSchema,
+  bulkReportSchema,
+  mailboxQuerySchema,
+  mailRuleSchema,
+  reorderRulesSchema,
+  reportMessageSchema,
+  trustSenderSchema,
+  unsubscribeSchema,
+} from "./schemas";
+import { workspaceIdentity } from "./security-settings";
+import { storedSenderIntel } from "./sender-intel";
+import { oneClickHost, parseMailtoUnsubscribe, postOneClick } from "./unsubscribe";
+import { recordWorkspaceFeedback, workspaceBlockPatterns } from "./workspace-safety";
+
+async function mailboxAccess(env: Env, userId: string, mailboxId: string) {
+  return getMailboxAccess(createDb(env.DB), userId, mailboxId);
+}
+
+function forbidden(c: Context<AppEnv>) {
+  return apiError(c, 403, "FORBIDDEN", "Mailbox access is required");
+}
+
+/** Report spam or phishing for one message. Phishing also opens an admin report. */
+async function reportOne(input: {
+  env: Env;
+  mailboxId: string;
+  userId: string;
+  email: Email;
+  kind: ReportKind;
+}) {
+  const mailbox = mailboxStub(input.env, input.mailboxId);
+  const result = await mailbox.reportMessage({ emailId: input.email.id, kind: input.kind, userId: input.userId });
+  if (!result) return null;
+  const sender = result.email.fromJson[0]?.address;
+  if (sender) {
+    await recordWorkspaceFeedback(input.env.DB, {
+      mailboxId: input.mailboxId,
+      emailId: result.email.id,
+      address: sender,
+      label: input.kind,
+    }).catch((error) => console.error(`Could not share the report for ${result.email.id}`, error));
+  }
+  let reportId: string | null = null;
+  if (input.kind === "phishing") {
+    const email = await withHeaderMetadata(input.env, mailbox, result.email);
+    const address = email.fromJson[0]?.address ?? "";
+    const [identity, history, bodyHtml] = await Promise.all([
+      workspaceIdentity(input.env.DB),
+      mailbox.getSenderHistory(address ? [address] : []),
+      email.bodyHtmlR2Key
+        ? input.env.MAIL_STORAGE.get(email.bodyHtmlR2Key).then((object) => object?.text() ?? null)
+        : Promise.resolve(null),
+    ]);
+    reportId = await recordReportedMessage(input.env.DB, {
+      mailboxId: input.mailboxId,
+      email,
+      reporterUserId: input.userId,
+      snapshot: reportSnapshot({
+        email,
+        security: emailSecurity(email, identity, history),
+        intel: storedSenderIntel(email.senderIntelJson),
+        bodyHtml,
+      }),
+    });
+  }
+  return { moved: result.moved, reportId };
+}
+
+export const mailSafetyRoutes = new Hono<AppEnv>()
+  .post(
+    "/messages/:id/unsubscribe",
+    zValidator("query", mailboxQuerySchema),
+    zValidator("json", unsubscribeSchema),
+    async (c) => {
+      const { mailboxId } = c.req.valid("query");
+      const user = c.get("user");
+      const access = await mailboxAccess(c.env, user.id, mailboxId);
+      if (!access) return forbidden(c);
+      const mailbox = mailboxStub(c.env, mailboxId);
+      const stored = await mailbox.getEmail(c.req.param("id"));
+      if (!stored || stored.direction !== "incoming") return apiError(c, 404, "NOT_FOUND", "Message not found");
+      // Stored at ingestion from the original; never taken from the client.
+      const email = await withHeaderMetadata(c.env, mailbox, stored);
+      const methods = email.listUnsubscribeJson;
+      const listKey = emailListKey(email);
+      if (!methods || !listKey || (!methods.httpsUrl && !methods.mailto)) {
+        return apiError(c, 409, "CONFLICT", "This message has no unsubscribe option");
+      }
+      const limit = await checkRateLimit(c.env.DB, {
+        action: "mail-unsubscribe",
+        identifier: user.id,
+        limit: 20,
+        windowMs: 60_000,
+      });
+      if (!limit.allowed) {
+        c.header("retry-after", String(limit.retryAfterSeconds));
+        return apiError(c, 429, "RATE_LIMITED", "Too many unsubscribe requests");
+      }
+      const record = (
+        method: "one_click" | "mailto" | "link",
+        status: "done" | "requested" | "opened" | "failed",
+        target: string | null,
+        detail: string | null,
+      ) => mailbox.recordUnsubscription({ listKey, emailId: email.id, method, status, target, detail, userId: user.id });
+
+      if (c.req.valid("json").method === "link") {
+        if (!methods.httpsUrl) return apiError(c, 409, "CONFLICT", "This message has no unsubscribe page");
+        const unsubscription = await record("link", "opened", oneClickHost(methods.httpsUrl), null);
+        return c.json({ ok: true as const, outcome: "opened" as const, unsubscription, url: methods.httpsUrl, detail: null });
+      }
+
+      let detail: string | null = null;
+      if (methods.oneClick && methods.httpsUrl) {
+        const result = await postOneClick(methods.httpsUrl, oneClickFetcher(c.env));
+        if (result.ok) {
+          const unsubscription = await record(
+            "one_click",
+            "done",
+            oneClickHost(methods.httpsUrl),
+            result.redirected ? `Answered ${result.status} instead of 2xx` : null,
+          );
+          return c.json({ ok: true as const, outcome: "done" as const, unsubscription, url: null, detail: null });
+        }
+        detail = result.detail;
+      }
+
+      const mailto = methods.mailto ? parseMailtoUnsubscribe(methods.mailto) : null;
+      if (mailto && access.canSend) {
+        const submission = await submitOutgoing({
+          env: c.env,
+          requestUrl: c.req.url,
+          compose: {
+            requestId: crypto.randomUUID(),
+            mailboxId,
+            userId: user.id,
+            to: [mailto.to],
+            cc: [],
+            bcc: [],
+            subject: mailto.subject,
+            bodyText: mailto.body,
+            attachments: [],
+          },
+          conversationId: createId("conv"),
+          related: null,
+          forwarded: null,
+          includeRelatedContext: false,
+          fromAddress: access.address,
+          fromName: access.displayName,
+          defer: (task) => c.executionCtx.waitUntil(task),
+        });
+        const failed = submission.email.transportState === "failed";
+        const unsubscription = await record(
+          "mailto",
+          failed ? "failed" : "requested",
+          mailto.to,
+          failed ? submission.email.transportError : detail,
+        );
+        if (!failed) {
+          return c.json({ ok: true as const, outcome: "requested" as const, unsubscription, url: null, detail });
+        }
+        detail = submission.email.transportError ?? "The unsubscribe email could not be sent";
+      }
+      if (methods.httpsUrl) {
+        // Opening the page is left to the person, in a new tab, after this answer.
+        return c.json({ ok: true as const, outcome: "link" as const, unsubscription: null, url: methods.httpsUrl, detail });
+      }
+      if (mailto && !access.canSend) {
+        return apiError(c, 403, "FORBIDDEN", "Unsubscribing by email requires send access to this mailbox");
+      }
+      const unsubscription = await record(methods.oneClick ? "one_click" : "mailto", "failed", null, detail);
+      return c.json({ ok: true as const, outcome: "failed" as const, unsubscription, url: null, detail });
+    },
+  )
+  .post(
+    "/messages/:id/report",
+    zValidator("query", mailboxQuerySchema),
+    zValidator("json", reportMessageSchema),
+    async (c) => {
+      const { mailboxId } = c.req.valid("query");
+      const user = c.get("user");
+      const access = await mailboxAccess(c.env, user.id, mailboxId);
+      if (!access) return forbidden(c);
+      const input = c.req.valid("json");
+      const email = await mailboxStub(c.env, mailboxId).getEmail(c.req.param("id"));
+      if (!email || email.direction !== "incoming") return apiError(c, 404, "NOT_FOUND", "Message not found");
+      const result = await reportOne({
+        env: c.env,
+        mailboxId,
+        userId: user.id,
+        email,
+        kind: input.kind,
+      });
+      if (!result) return apiError(c, 404, "NOT_FOUND", "Message not found");
+      return c.json({ ok: true as const, ...result });
+    },
+  )
+  .post(
+    "/conversations/report",
+    zValidator("query", mailboxQuerySchema),
+    zValidator("json", bulkReportSchema),
+    async (c) => {
+      const { mailboxId } = c.req.valid("query");
+      const user = c.get("user");
+      const access = await mailboxAccess(c.env, user.id, mailboxId);
+      if (!access) return forbidden(c);
+      const input = c.req.valid("json");
+      const messages = await mailboxStub(c.env, mailboxId).latestIncomingEmails(input.conversationIds);
+      let reported = 0;
+      for (const email of messages) {
+        const result = await reportOne({
+          env: c.env,
+          mailboxId,
+          userId: user.id,
+          email,
+          kind: input.kind,
+        });
+        if (result) reported += 1;
+      }
+      return c.json({ ok: true as const, reportedCount: reported });
+    },
+  )
+  .post("/messages/:id/not-spam", zValidator("query", mailboxQuerySchema), async (c) => {
+    const { mailboxId } = c.req.valid("query");
+    const user = c.get("user");
+    if (!await mailboxAccess(c.env, user.id, mailboxId)) return forbidden(c);
+    const emailId = c.req.param("id");
+    const result = await mailboxStub(c.env, mailboxId).markNotSpam({ emailId, userId: user.id });
+    if (!result) return apiError(c, 404, "NOT_FOUND", "Message not found");
+    if (result.address) {
+      await recordWorkspaceFeedback(c.env.DB, { mailboxId, emailId, address: result.address, label: "not_spam" })
+        .catch((error) => console.error(`Could not share the not-spam verdict for ${emailId}`, error));
+    }
+    return c.json({ ok: true as const, restored: result.restored });
+  })
+  .get("/mailboxes/:id/blocked-senders", async (c) => {
+    const mailboxId = c.req.param("id");
+    if (!await mailboxAccess(c.env, c.get("user").id, mailboxId)) return forbidden(c);
+    const [blocked, workspace] = await Promise.all([
+      mailboxStub(c.env, mailboxId).listBlockedSenders(),
+      workspaceBlockPatterns(c.env.DB),
+    ]);
+    return c.json({
+      ok: true as const,
+      blocked,
+      workspace: [...workspace].map(([pattern, at]) => ({ pattern, blockedAt: at })),
+    });
+  })
+  .post("/mailboxes/:id/blocked-senders", zValidator("json", blockSenderSchema), async (c) => {
+    const mailboxId = c.req.param("id");
+    const access = await mailboxAccess(c.env, c.get("user").id, mailboxId);
+    if (!access) return forbidden(c);
+    const input = c.req.valid("json");
+    const pattern = normalizeBlockPattern(input.pattern);
+    if (!pattern) return apiError(c, 400, "BAD_REQUEST", "Enter an email address or a domain");
+    const own = access.address.toLocaleLowerCase();
+    if (pattern === own || own.endsWith(pattern)) {
+      return apiError(c, 400, "BAD_REQUEST", "This mailbox cannot block its own address or domain");
+    }
+    const result = await mailboxStub(c.env, mailboxId).blockSender(pattern, input.moveExisting);
+    return c.json({ ok: true as const, ...result });
+  })
+  .delete(
+    "/mailboxes/:id/blocked-senders",
+    zValidator("query", blockPatternQuerySchema),
+    async (c) => {
+      const mailboxId = c.req.param("id");
+      if (!await mailboxAccess(c.env, c.get("user").id, mailboxId)) return forbidden(c);
+      const pattern = normalizeBlockPattern(c.req.valid("query").pattern);
+      if (!pattern || !await mailboxStub(c.env, mailboxId).unblockSender(pattern)) {
+        return apiError(c, 404, "NOT_FOUND", "Blocked sender not found");
+      }
+      return c.json({ ok: true as const });
+    },
+  )
+  .put("/mailboxes/:id/trusted-senders", zValidator("json", trustSenderSchema), async (c) => {
+    const mailboxId = c.req.param("id");
+    if (!await mailboxAccess(c.env, c.get("user").id, mailboxId)) return forbidden(c);
+    const input = c.req.valid("json");
+    await mailboxStub(c.env, mailboxId).setSenderTrusted(input.address, input.trusted);
+    return c.json({ ok: true as const });
+  })
+  .get("/mailboxes/:id/rules", async (c) => {
+    const mailboxId = c.req.param("id");
+    if (!await mailboxAccess(c.env, c.get("user").id, mailboxId)) return forbidden(c);
+    return c.json({ ok: true as const, rules: await mailboxStub(c.env, mailboxId).listRules() });
+  })
+  .post("/mailboxes/:id/rules", zValidator("json", mailRuleSchema), async (c) => {
+    const mailboxId = c.req.param("id");
+    if (!await mailboxAccess(c.env, c.get("user").id, mailboxId)) return forbidden(c);
+    try {
+      const rule = await mailboxStub(c.env, mailboxId).createRule(c.req.valid("json"));
+      return c.json({ ok: true as const, rule }, 201);
+    } catch (error) {
+      // Errors cross the Durable Object boundary without their class.
+      if (error instanceof Error && error.message.startsWith(MAIL_RULE_LIMIT_MESSAGE)) {
+        return apiError(c, 409, "CONFLICT", error.message);
+      }
+      throw error;
+    }
+  })
+  .put("/mailboxes/:id/rules/:ruleId", zValidator("json", mailRuleSchema), async (c) => {
+    const mailboxId = c.req.param("id");
+    if (!await mailboxAccess(c.env, c.get("user").id, mailboxId)) return forbidden(c);
+    const rule = await mailboxStub(c.env, mailboxId).updateRule(c.req.param("ruleId"), c.req.valid("json"));
+    if (!rule) return apiError(c, 404, "NOT_FOUND", "Rule not found");
+    return c.json({ ok: true as const, rule });
+  })
+  .delete("/mailboxes/:id/rules/:ruleId", async (c) => {
+    const mailboxId = c.req.param("id");
+    if (!await mailboxAccess(c.env, c.get("user").id, mailboxId)) return forbidden(c);
+    if (!await mailboxStub(c.env, mailboxId).deleteRule(c.req.param("ruleId"))) {
+      return apiError(c, 404, "NOT_FOUND", "Rule not found");
+    }
+    return c.json({ ok: true as const });
+  })
+  .put("/mailboxes/:id/rules-order", zValidator("json", reorderRulesSchema), async (c) => {
+    const mailboxId = c.req.param("id");
+    if (!await mailboxAccess(c.env, c.get("user").id, mailboxId)) return forbidden(c);
+    if (!await mailboxStub(c.env, mailboxId).reorderRules(c.req.valid("json").ruleIds)) {
+      return apiError(c, 409, "CONFLICT", "Rules changed; refresh and try again");
+    }
+    return c.json({ ok: true as const });
+  })
+  .post("/mailboxes/:id/rules/:ruleId/apply", async (c) => {
+    const mailboxId = c.req.param("id");
+    const user = c.get("user");
+    if (!await mailboxAccess(c.env, user.id, mailboxId)) return forbidden(c);
+    const result = await mailboxStub(c.env, mailboxId).applyRuleToExisting(c.req.param("ruleId"), user.id);
+    if (!result) return apiError(c, 404, "NOT_FOUND", "Rule not found");
+    return c.json({ ok: true as const, ...result });
+  });

package/worker/mail/schemas.ts

@@ -0,0 +1,339 @@
+import { z } from "zod";
+import {
+  mailboxStates,
+  MAX_BULK_CONVERSATION_COUNT,
+  MAX_COMPOSER_ATTACHMENT_BYTES,
+  MAX_COMPOSER_ATTACHMENT_COUNT,
+  MAX_CUSTOM_FOLDER_COUNT,
+  MAX_MAIL_RECIPIENTS,
+  replyActionModes,
+} from "../../shared/mail";
+import {
+  MAX_TRANSLATION_CHARACTERS,
+  MAX_TRANSLATION_SEGMENTS,
+} from "../../shared/mail-translation";
+import { emailSchema } from "@open-workspace/core/worker/auth/schemas.ts";
+import { hasActions, hasConditions, MAX_MAIL_RULES } from "../../shared/mail-rules";
+import { dedupeRecipientFields, recipientCount } from "./recipients";
+
+export const folderSchema = z.string().trim().min(1).max(80);
+
+const customFolderNameSchema = z.string().trim().min(1).max(80);
+
+export const createFolderSchema = z.object({
+  name: customFolderNameSchema,
+});
+
+export const renameFolderSchema = createFolderSchema;
+
+export const mailboxAiConfigurationSchema = z.object({
+  instructions: z.string().trim().max(4_000),
+  confidenceThreshold: z.number().int().min(50).max(100),
+});
+
+export const reorderFoldersSchema = z.object({
+  folderIds: z
+    .array(folderSchema)
+    .max(MAX_CUSTOM_FOLDER_COUNT)
+    .refine((ids) => new Set(ids).size === ids.length, {
+      message: "Folder order contains duplicate ids",
+    }),
+});
+
+export const mailboxQuerySchema = z.object({
+  mailboxId: z.string().min(1),
+});
+
+export const recipientSuggestionQuerySchema = z.object({
+  q: z.string().trim().max(200).default(""),
+  limit: z.coerce.number().int().min(1).max(12).default(8),
+});
+
+export const remoteProxyQuerySchema = mailboxQuerySchema.extend({
+  url: z.string().trim().min(1).max(4_096),
+});
+
+export const conversationListQuerySchema = mailboxQuerySchema.extend({
+  folder: folderSchema.default("inbox"),
+  limit: z.coerce.number().int().min(1).max(50).default(25),
+  cursor: z.string().trim().min(1).max(512).optional(),
+  search: z.string().trim().max(200).optional(),
+  unreadOnly: z.literal("true").optional(),
+});
+
+export const conversationMessagesQuerySchema = mailboxQuerySchema.extend({
+  limit: z.coerce.number().int().min(1).max(25).default(25),
+  cursor: z.string().trim().min(1).max(512).optional(),
+});
+
+export const mailboxStateSchema = z.enum(mailboxStates);
+
+export const messageReadSchema = z.object({
+  isRead: z.boolean(),
+});
+
+export const messageTranslationSchema = z.object({
+  language: z.string().trim().min(2).max(35).regex(/^[a-zA-Z]{2,8}(?:-[a-zA-Z0-9]{1,8})*$/u),
+  segments: z.array(z.string().trim().min(1).max(MAX_TRANSLATION_CHARACTERS))
+    .min(1).max(MAX_TRANSLATION_SEGMENTS),
+});
+
+export const createUploadSchema = z.object({
+  filename: z.string().trim().min(1).max(255),
+  contentType: z.string().trim().min(1).max(255),
+  size: z.number().int().positive().max(MAX_COMPOSER_ATTACHMENT_BYTES),
+});
+
+export const uploadIdSchema = z
+  .string()
+  .trim()
+  .min(1)
+  .max(80)
+  .regex(/^upl_[a-f0-9]{32}$/u, "Attachment upload id is invalid");
+
+export const outboundAttachmentSchema = z.object({
+  uploadId: uploadIdSchema,
+  disposition: z.enum(["attachment", "inline"]).default("attachment"),
+  contentId: z
+    .string()
+    .trim()
+    .min(1)
+    .max(255)
+    .regex(/^[a-zA-Z0-9._+-]+@[a-zA-Z0-9.-]+$/u, "Content ID is invalid")
+    .optional(),
+}).superRefine((attachment, context) => {
+  if (attachment.disposition === "inline" && !attachment.contentId) {
+    context.addIssue({
+      code: "custom",
+      path: ["contentId"],
+      message: "Inline attachments require a content ID",
+    });
+  }
+  if (attachment.disposition === "attachment" && attachment.contentId) {
+    context.addIssue({
+      code: "custom",
+      path: ["contentId"],
+      message: "Regular attachments cannot have a content ID",
+    });
+  }
+});
+
+export const outboundMessageContentFields = {
+  bodyText: z.string().max(500_000).default(""),
+  bodyHtml: z.string().max(1_000_000).optional(),
+  attachments: z
+    .array(outboundAttachmentSchema)
+    .max(MAX_COMPOSER_ATTACHMENT_COUNT)
+    .default([])
+    .refine(
+      (attachments) =>
+        new Set(attachments.map((file) => file.uploadId)).size === attachments.length,
+      { message: "Duplicate attachment uploads are not allowed" },
+    )
+    .refine(
+      (attachments) => {
+        const contentIds = attachments.flatMap((file) =>
+          file.contentId ? [file.contentId.toLocaleLowerCase("en-US")] : []
+        );
+        return new Set(contentIds).size === contentIds.length;
+      },
+      { message: "Duplicate attachment content IDs are not allowed" },
+    ),
+};
+
+const hasMessageBody = (value: { bodyText: string; bodyHtml?: string }) =>
+  Boolean(value.bodyText.trim() || value.bodyHtml?.trim());
+
+const missingMessageBody = {
+  path: ["bodyText"],
+  message: "Add text to the message before sending",
+};
+
+export const outboundContentFields = {
+  mailboxId: z.string().min(1),
+  ...outboundMessageContentFields,
+};
+
+const outboundRequestFields = {
+  requestId: z.uuid(),
+  ...outboundContentFields,
+};
+
+export const outboundRecipientFields = {
+  to: z.array(emailSchema).max(MAX_MAIL_RECIPIENTS).default([]),
+  cc: z.array(emailSchema).max(MAX_MAIL_RECIPIENTS).default([]),
+  bcc: z.array(emailSchema).max(MAX_MAIL_RECIPIENTS).default([]),
+};
+
+export const composeSchema = z
+  .object({
+    ...outboundRequestFields,
+    ...outboundRecipientFields,
+    replyTo: emailSchema.optional(),
+    subject: z.string().trim().max(998).default(""),
+  })
+  .transform((value) => ({
+    ...value,
+    ...dedupeRecipientFields(value),
+  }))
+  .refine(hasMessageBody, missingMessageBody)
+  .refine(
+    (value) => recipientCount(value) > 0,
+    { message: "Add at least one recipient in To, Cc, or Bcc" },
+  )
+  .refine(
+    (value) => recipientCount(value) <= MAX_MAIL_RECIPIENTS,
+    { message: `An email can have at most ${MAX_MAIL_RECIPIENTS} recipients across To, Cc, and Bcc` },
+  );
+
+export const replySchema = z.object({
+  ...outboundRequestFields,
+  mode: z.enum(replyActionModes),
+  cc: z.array(emailSchema).max(MAX_MAIL_RECIPIENTS).optional(),
+  bcc: z.array(emailSchema).max(MAX_MAIL_RECIPIENTS).default([]),
+}).refine(hasMessageBody, missingMessageBody);
+
+export const forwardSchema = z
+  .object({
+    ...outboundRequestFields,
+    ...outboundRecipientFields,
+    replyTo: emailSchema.optional(),
+  })
+  .transform((value) => ({
+    ...value,
+    ...dedupeRecipientFields(value),
+  }))
+  .refine(
+    (value) => recipientCount(value) > 0,
+    { message: "Add at least one recipient in To, Cc, or Bcc" },
+  )
+  .refine(
+    (value) => recipientCount(value) <= MAX_MAIL_RECIPIENTS,
+    { message: `An email can have at most ${MAX_MAIL_RECIPIENTS} recipients across To, Cc, and Bcc` },
+  );
+
+export const attachmentPreflightSchema = z.discriminatedUnion("kind", [
+  z.object({
+    ...outboundContentFields,
+    kind: z.literal("compose"),
+    subject: z.string().trim().max(998).default(""),
+  }),
+  z.object({
+    ...outboundContentFields,
+    kind: z.literal("forward"),
+    sourceEmailId: z.string().trim().min(1).max(255),
+  }),
+  z.object({
+    ...outboundContentFields,
+    kind: z.literal("reply"),
+    sourceEmailId: z.string().trim().min(1).max(255),
+    mode: z.enum(replyActionModes),
+    cc: z.array(emailSchema).max(MAX_MAIL_RECIPIENTS).optional(),
+    bcc: z.array(emailSchema).max(MAX_MAIL_RECIPIENTS).default([]),
+  }),
+]);
+
+export const updateConversationSchema = z
+  .object({
+    mailboxState: mailboxStateSchema.optional(),
+    folderId: z.string().min(1).nullable().optional(),
+  })
+  .refine((value) => value.mailboxState !== undefined || value.folderId !== undefined, {
+    message: "No changes supplied",
+  })
+  .refine(
+    (value) =>
+      value.folderId === undefined
+      || value.folderId === null
+      || value.mailboxState === undefined
+      || value.mailboxState === "active",
+    {
+      path: ["mailboxState"],
+      message: "Moving to a custom folder requires the active mailbox state",
+    },
+  );
+
+const bulkConversationIdsSchema = z
+  .array(z.string().trim().min(1).max(255))
+  .min(1)
+  .max(MAX_BULK_CONVERSATION_COUNT)
+  .transform((ids) => [...new Set(ids)]);
+
+export const bulkConversationActionSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("read"),
+    conversationIds: bulkConversationIdsSchema,
+    isRead: z.boolean(),
+  }),
+  z.object({
+    type: z.literal("update"),
+    conversationIds: bulkConversationIdsSchema,
+    sourceFolderId: z.string().trim().min(1).max(255),
+    update: updateConversationSchema,
+  }),
+  z.object({
+    type: z.literal("delete_permanently"),
+    conversationIds: bulkConversationIdsSchema,
+  }),
+]);
+
+const ruleText = z.string().trim().max(200).optional().transform((value) => value || undefined);
+
+export const mailRuleSchema = z.object({
+  name: z.string().trim().min(1).max(80),
+  enabled: z.boolean().default(true),
+  conditions: z.object({
+    from: ruleText,
+    to: ruleText,
+    subjectContains: ruleText,
+    listId: ruleText,
+    hasAttachment: z.boolean().optional().transform((value) => value || undefined),
+  }).refine(hasConditions, { message: "Add at least one condition" }),
+  actions: z.object({
+    folderId: z.string().trim().min(1).max(255).optional(),
+    archive: z.boolean().optional().transform((value) => value || undefined),
+    spam: z.boolean().optional().transform((value) => value || undefined),
+    markRead: z.boolean().optional().transform((value) => value || undefined),
+    neverSpam: z.boolean().optional().transform((value) => value || undefined),
+  })
+    .refine(hasActions, { message: "Choose at least one action" })
+    .refine(
+      (actions) => [actions.folderId, actions.archive, actions.spam].filter(Boolean).length <= 1,
+      { message: "Choose one destination: a folder, Archive, or Spam" },
+    )
+    .refine((actions) => !(actions.spam && actions.neverSpam), {
+      message: "A rule cannot both send to Spam and never send to Spam",
+    }),
+});
+
+export const reorderRulesSchema = z.object({
+  ruleIds: z.array(z.string().min(1).max(255)).max(MAX_MAIL_RULES),
+});
+
+export const blockSenderSchema = z.object({
+  pattern: z.string().trim().min(3).max(320),
+  moveExisting: z.boolean().default(false),
+});
+
+export const blockPatternQuerySchema = z.object({
+  pattern: z.string().trim().min(3).max(320),
+});
+
+export const trustSenderSchema = z.object({
+  address: emailSchema,
+  trusted: z.boolean(),
+});
+
+export const unsubscribeSchema = z.object({
+  /** "link" records that the person opened the sender's page themselves. */
+  method: z.enum(["auto", "link"]).default("auto"),
+});
+
+export const reportMessageSchema = z.object({
+  kind: z.enum(["spam", "phishing"]),
+});
+
+export const bulkReportSchema = z.object({
+  kind: z.enum(["spam", "phishing"]),
+  conversationIds: z.array(z.string().trim().min(1).max(255)).min(1).max(100),
+});