@open-workspace/email 0.0.0-stage → 0.1.1

package/worker/mail/push-notifications.ts

@@ -0,0 +1,484 @@
+import {
+  sendPushNotification,
+  topicFromString,
+  WebPushError,
+} from "@mmmike/web-push/send";
+import {
+  createVapidJwt,
+  urlBase64ToUint8Array,
+} from "@mmmike/web-push/vapid";
+import { zValidator } from "@hono/zod-validator";
+import { and, desc, eq, isNull, or } from "drizzle-orm";
+import { Hono } from "hono";
+import { z } from "zod";
+import type { MailboxPushJob } from "../../shared/mail";
+import { requireSessionAuth } from "@open-workspace/core/worker/auth/middleware.ts";
+import { createDb } from "@open-workspace/core/worker/db/client.ts";
+import { domains, mailboxAccess, mailboxes, pushSubscriptions, users } from "@open-workspace/core/worker/db/schema.ts";
+import { mailboxNotificationPreferences } from "../db/schema";
+import { mailboxAddressSql, mailboxKindOrderSql } from "@open-workspace/core/worker/db/mailboxes.ts";
+import type { AppEnv, PushBindings } 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 { mailboxStub } from "../mailbox";
+import { getMailboxAccess } from "./access";
+
+export const PUSH_NOTIFICATION_QUEUE = "openworkspace-push-notifications";
+
+const pushSubscriptionSchema = z.object({
+  endpoint: z.url().max(4_096).refine(
+    (value) => new URL(value).protocol === "https:",
+    "Push endpoint must use HTTPS",
+  ),
+  keys: z.object({
+    p256dh: z.string().min(1).max(512).refine((value) => {
+      try {
+        const key = urlBase64ToUint8Array(value);
+        return key.length === 65 && key[0] === 4;
+      } catch {
+        return false;
+      }
+    }, "p256dh must be an uncompressed P-256 public key"),
+    auth: z.string().min(1).max(512).refine((value) => {
+      try {
+        return urlBase64ToUint8Array(value).length >= 16;
+      } catch {
+        return false;
+      }
+    }, "auth must contain at least 16 bytes"),
+  }),
+});
+
+const subscriptionEndpointSchema = z.object({
+  endpoint: z.string().url().max(4_096),
+});
+
+const notificationPreferenceSchema = z.object({ enabled: z.boolean() });
+
+const pushJobBaseSchema = z.object({
+  mailboxId: z.string().min(1),
+  conversationId: z.string().min(1),
+  messageId: z.string().min(1),
+  occurredAt: z.number().int().nonnegative(),
+  sender: z.string().min(1).max(500),
+  subject: z.string().max(998),
+});
+
+const pushJobSchema = z.discriminatedUnion("type", [
+  pushJobBaseSchema.extend({ type: z.literal("dispatch") }),
+  pushJobBaseSchema.extend({
+    type: z.literal("deliver"),
+    targetSubscriptionId: z.string().min(1),
+    mailboxDisplayName: z.string().min(1).max(500),
+  }),
+]) satisfies z.ZodType<MailboxPushJob>;
+
+const MAX_PUSH_JOB_AGE_MS = 15 * 60 * 1_000;
+const MAX_QUEUE_SEND_BATCH_SIZE = 100;
+
+type PushConfiguration = {
+  publicKey: string;
+  privateKey: string;
+  subject: string;
+};
+
+type PushConfigurationStatus = {
+  configuration: PushConfiguration | null;
+  error: string | null;
+};
+
+let cachedPushConfiguration: {
+  source: string;
+  status: Promise<PushConfigurationStatus>;
+} | null = null;
+
+class RetryablePushError extends Error {
+  constructor(
+    readonly delaySeconds: number,
+    cause: unknown,
+  ) {
+    super("Push delivery should be retried", { cause });
+  }
+}
+
+function retryDelaySeconds(error: unknown) {
+  if (
+    error instanceof WebPushError
+    && error.statusCode !== 408
+    && error.statusCode !== 429
+    && error.statusCode < 500
+  ) {
+    return null;
+  }
+  const timedOut = error instanceof DOMException
+    && (error.name === "AbortError" || error.name === "TimeoutError");
+  if (
+    !(error instanceof WebPushError)
+    && !(error instanceof TypeError)
+    && !timedOut
+  ) {
+    return null;
+  }
+  const delayMs = error instanceof WebPushError
+    ? error.retryAfterMs ?? 30_000
+    : 30_000;
+  return Math.max(1, Math.min(12 * 60 * 60, Math.ceil(delayMs / 1_000)));
+}
+
+function pushFailureDetails(error: unknown) {
+  if (error instanceof WebPushError) {
+    return {
+      name: error.name,
+      message: error.message,
+      statusCode: error.statusCode,
+      retryAfterMs: error.retryAfterMs,
+    };
+  }
+  return error instanceof Error
+    ? { name: error.name, message: error.message }
+    : { message: String(error) };
+}
+
+function pushConfiguration(env: PushBindings) {
+  const publicKey = env.VAPID_PUBLIC_KEY;
+  const privateKey = env.VAPID_PRIVATE_KEY;
+  const subject = env.VAPID_SUBJECT;
+  if (!publicKey || !privateKey || !subject) {
+    return Promise.resolve({
+      configuration: null,
+      error: null,
+    } satisfies PushConfigurationStatus);
+  }
+
+  const source = `${publicKey}\0${privateKey}\0${subject}`;
+  if (cachedPushConfiguration?.source === source) {
+    return cachedPushConfiguration.status;
+  }
+  const configuration = { publicKey, privateKey, subject };
+  const status = createVapidJwt({
+    audience: "https://push.invalid",
+    expiration: 60,
+    ...configuration,
+  }).then(() => ({
+    configuration,
+    error: null,
+  })).catch((error: unknown) => {
+    console.error("Invalid Web Push configuration", pushFailureDetails(error));
+    return {
+      configuration: null,
+      error: "Web Push server configuration is invalid.",
+    };
+  });
+  cachedPushConfiguration = { source, status };
+  return status;
+}
+
+export const pushNotificationRoutes = new Hono<AppEnv>()
+  .use("*", requireSessionAuth)
+  .get("/config", async (c) => {
+    const status = await pushConfiguration(c.env);
+    return c.json({
+      ok: true as const,
+      enabled: Boolean(status.configuration),
+      publicKey: status.configuration?.publicKey ?? null,
+      error: status.error,
+    });
+  })
+  .get("/preferences", async (c) => {
+    const userId = c.get("user").id;
+    const rows = await createDb(c.env.DB)
+      .select({
+        mailboxId: mailboxes.id,
+        displayName: mailboxes.displayName,
+        address: mailboxAddressSql,
+        enabled: mailboxNotificationPreferences.enabled,
+      })
+      .from(mailboxAccess)
+      .innerJoin(mailboxes, eq(mailboxAccess.mailboxId, mailboxes.id))
+      .innerJoin(domains, eq(mailboxes.domainId, domains.id))
+      .leftJoin(
+        mailboxNotificationPreferences,
+        and(
+          eq(mailboxNotificationPreferences.mailboxId, mailboxAccess.mailboxId),
+          eq(mailboxNotificationPreferences.userId, mailboxAccess.userId),
+        ),
+      )
+      .where(eq(mailboxAccess.userId, userId))
+      .orderBy(
+        mailboxKindOrderSql,
+        desc(mailboxes.isPrimary),
+        mailboxes.displayName,
+      );
+    return c.json({
+      ok: true as const,
+      preferences: rows.map((row) => ({ ...row, enabled: row.enabled ?? true })),
+    });
+  })
+  .put(
+    "/preferences/:mailboxId",
+    zValidator("json", notificationPreferenceSchema),
+    async (c) => {
+      const userId = c.get("user").id;
+      const mailboxId = c.req.param("mailboxId");
+      if (!await getMailboxAccess(createDb(c.env.DB), userId, mailboxId)) {
+        return apiError(c, 403, "FORBIDDEN", "Mailbox access is required");
+      }
+      const now = new Date();
+      await createDb(c.env.DB)
+        .insert(mailboxNotificationPreferences)
+        .values({ mailboxId, userId, enabled: c.req.valid("json").enabled, updatedAt: now })
+        .onConflictDoUpdate({
+          target: [
+            mailboxNotificationPreferences.mailboxId,
+            mailboxNotificationPreferences.userId,
+          ],
+          set: { enabled: c.req.valid("json").enabled, updatedAt: now },
+        });
+      return c.json({ ok: true as const });
+    },
+  )
+  .put(
+    "/subscriptions",
+    zValidator("json", pushSubscriptionSchema),
+    async (c) => {
+      const input = c.req.valid("json");
+      const now = new Date();
+      await createDb(c.env.DB)
+        .insert(pushSubscriptions)
+        .values({
+          id: createId("push"),
+          userId: c.get("user").id,
+          endpoint: input.endpoint,
+          p256dh: input.keys.p256dh,
+          auth: input.keys.auth,
+          createdAt: now,
+          updatedAt: now,
+        })
+        .onConflictDoUpdate({
+          target: pushSubscriptions.endpoint,
+          set: {
+            userId: c.get("user").id,
+            p256dh: input.keys.p256dh,
+            auth: input.keys.auth,
+            updatedAt: now,
+          },
+        });
+      return c.json({ ok: true as const });
+    },
+  )
+  .delete(
+    "/subscriptions",
+    zValidator("json", subscriptionEndpointSchema),
+    async (c) => {
+      await createDb(c.env.DB)
+        .delete(pushSubscriptions)
+        .where(and(
+          eq(pushSubscriptions.userId, c.get("user").id),
+          eq(pushSubscriptions.endpoint, c.req.valid("json").endpoint),
+        ));
+      return c.json({ ok: true as const });
+    },
+  );
+
+async function subscriptionsForMailbox(
+  env: Env & PushBindings,
+  mailboxId: string,
+) {
+  const db = createDb(env.DB);
+  return db.select({
+    id: pushSubscriptions.id,
+  })
+    .from(pushSubscriptions)
+    .innerJoin(users, eq(pushSubscriptions.userId, users.id))
+    .innerJoin(
+      mailboxAccess,
+      and(
+        eq(mailboxAccess.userId, pushSubscriptions.userId),
+        eq(mailboxAccess.mailboxId, mailboxId),
+      ),
+    )
+    .leftJoin(
+      mailboxNotificationPreferences,
+      and(
+        eq(mailboxNotificationPreferences.userId, pushSubscriptions.userId),
+        eq(mailboxNotificationPreferences.mailboxId, mailboxId),
+      ),
+    )
+    .where(and(
+      eq(users.status, "active"),
+      or(
+        isNull(mailboxNotificationPreferences.enabled),
+        eq(mailboxNotificationPreferences.enabled, true),
+      ),
+    ));
+}
+
+async function dispatchPushJob(
+  env: Env & PushBindings,
+  job: Extract<MailboxPushJob, { type: "dispatch" }>,
+) {
+  const db = createDb(env.DB);
+  const [mailbox, subscriptions] = await Promise.all([
+    db.select({ displayName: mailboxes.displayName })
+      .from(mailboxes)
+      .where(eq(mailboxes.id, job.mailboxId))
+      .limit(1)
+      .then((rows) => rows[0]),
+    subscriptionsForMailbox(env, job.mailboxId),
+  ]);
+  if (!mailbox || !subscriptions.length) return;
+
+  const requests: MessageSendRequest<MailboxPushJob>[] = subscriptions.map(
+    (subscription) => ({
+      body: {
+        ...job,
+        type: "deliver",
+        targetSubscriptionId: subscription.id,
+        mailboxDisplayName: mailbox.displayName,
+      },
+    }),
+  );
+  for (let index = 0; index < requests.length; index += MAX_QUEUE_SEND_BATCH_SIZE) {
+    await env.PUSH_NOTIFICATIONS.sendBatch(
+      requests.slice(index, index + MAX_QUEUE_SEND_BATCH_SIZE),
+    );
+  }
+}
+
+async function targetSubscription(
+  env: Env & PushBindings,
+  job: Extract<MailboxPushJob, { type: "deliver" }>,
+) {
+  return createDb(env.DB).select({
+    id: pushSubscriptions.id,
+    userId: pushSubscriptions.userId,
+    endpoint: pushSubscriptions.endpoint,
+    p256dh: pushSubscriptions.p256dh,
+    auth: pushSubscriptions.auth,
+  })
+    .from(pushSubscriptions)
+    .innerJoin(users, eq(pushSubscriptions.userId, users.id))
+    .innerJoin(
+      mailboxAccess,
+      and(
+        eq(mailboxAccess.userId, pushSubscriptions.userId),
+        eq(mailboxAccess.mailboxId, job.mailboxId),
+      ),
+    )
+    .leftJoin(
+      mailboxNotificationPreferences,
+      and(
+        eq(mailboxNotificationPreferences.userId, pushSubscriptions.userId),
+        eq(mailboxNotificationPreferences.mailboxId, job.mailboxId),
+      ),
+    )
+    .where(and(
+      eq(users.status, "active"),
+      or(
+        isNull(mailboxNotificationPreferences.enabled),
+        eq(mailboxNotificationPreferences.enabled, true),
+      ),
+      eq(pushSubscriptions.id, job.targetSubscriptionId),
+    ))
+    .limit(1)
+    .then((rows) => rows[0]);
+}
+
+async function removeSubscription(
+  env: Env & PushBindings,
+  subscriptionId: string,
+) {
+  try {
+    await createDb(env.DB)
+      .delete(pushSubscriptions)
+      .where(eq(pushSubscriptions.id, subscriptionId));
+  } catch (error) {
+    console.error("Could not remove invalid push subscription", error);
+  }
+}
+
+async function deliverPushJob(
+  env: Env & PushBindings,
+  job: Extract<MailboxPushJob, { type: "deliver" }>,
+  configuration: PushConfiguration,
+  ageMs: number,
+) {
+  const subscription = await targetSubscription(env, job);
+  if (!subscription) return;
+  const suppressed = await mailboxStub(env, job.mailboxId).shouldSuppressPush(
+    job.messageId,
+    subscription.userId,
+  );
+  if (suppressed) return;
+
+  try {
+    const delivered = await sendPushNotification(
+      {
+        endpoint: subscription.endpoint,
+        keys: { p256dh: subscription.p256dh, auth: subscription.auth },
+      },
+      {
+        title: `New email in ${job.mailboxDisplayName}`,
+        body: `${job.sender} · ${job.subject || "(no subject)"}`,
+        url: `/mail/${encodeURIComponent(job.mailboxId)}?folder=inbox&conversation=${encodeURIComponent(job.conversationId)}`,
+        tag: `message-${job.messageId}`,
+      },
+      configuration,
+      {
+        ttl: Math.max(1, Math.ceil((MAX_PUSH_JOB_AGE_MS - ageMs) / 1_000)),
+        urgency: "high",
+        topic: await topicFromString(`message:${job.messageId}`),
+      },
+    );
+    if (!delivered) await removeSubscription(env, subscription.id);
+  } catch (error) {
+    const delaySeconds = retryDelaySeconds(error);
+    if (delaySeconds === null) {
+      console.error(
+        "Push notification delivery was rejected",
+        pushFailureDetails(error),
+      );
+      return;
+    }
+    throw new RetryablePushError(delaySeconds, error);
+  }
+}
+
+async function processPushJob(env: Env & PushBindings, job: MailboxPushJob) {
+  const ageMs = Math.max(0, Date.now() - job.occurredAt);
+  if (ageMs >= MAX_PUSH_JOB_AGE_MS) return;
+  const configuration = (await pushConfiguration(env)).configuration;
+  if (!configuration) return;
+  if (job.type === "dispatch") await dispatchPushJob(env, job);
+  else await deliverPushJob(env, job, configuration, ageMs);
+}
+
+export async function consumePushNotifications(
+  batch: MessageBatch<unknown>,
+  env: Env & PushBindings,
+) {
+  await Promise.all(batch.messages.map(async (message) => {
+    const parsed = pushJobSchema.safeParse(message.body);
+    if (!parsed.success) {
+      console.error("Ignoring invalid push notification job", parsed.error);
+      message.ack();
+      return;
+    }
+    try {
+      await processPushJob(env, parsed.data);
+      message.ack();
+    } catch (error) {
+      console.error(
+        "Could not deliver push notification job",
+        pushFailureDetails(
+          error instanceof RetryablePushError ? error.cause : error,
+        ),
+      );
+      message.retry({
+        delaySeconds: error instanceof RetryablePushError
+          ? error.delaySeconds
+          : 30,
+      });
+    }
+  }));
+}

package/worker/mail/quote-parser.ts

@@ -0,0 +1,50 @@
+export type ParsedReplyText = {
+  bodyText: string;
+  quotedText: string | null;
+};
+
+const ATTRIBUTION_LINE = [
+  /^on .+wrote:\s*$/iu,
+  /^am .+schrieb .+:\s*$/iu,
+  /^le .+a écrit\s*:\s*$/iu,
+  /^в .+написал(?:а)?:\s*$/iu,
+  /^-----\s*original message\s*-----$/iu,
+  /^-----\s*исходное сообщение\s*-----$/iu,
+];
+
+const OUTLOOK_HEADER = /^from:\s+.+$/iu;
+const OUTLOOK_FOLLOWUP = /^(?:sent|date|to|subject):\s+.+$/iu;
+
+function isAttribution(lines: string[], index: number) {
+  const line = lines[index]!.trim();
+  if (ATTRIBUTION_LINE.some((pattern) => pattern.test(line))) return true;
+  if (!OUTLOOK_HEADER.test(line)) return false;
+  return lines
+    .slice(index + 1, index + 5)
+    .some((candidate) => OUTLOOK_FOLLOWUP.test(candidate.trim()));
+}
+
+function quotedBlockStart(lines: string[]) {
+  for (let index = 0; index < lines.length; index += 1) {
+    if (isAttribution(lines, index)) return index;
+  }
+  for (let index = 0; index < lines.length; index += 1) {
+    if (!/^\s*>/u.test(lines[index]!)) continue;
+    const remaining = lines.slice(index).filter((line) => line.trim());
+    const quoted = remaining.filter((line) => /^\s*>/u.test(line)).length;
+    if (remaining.length && quoted / remaining.length >= 0.6) return index;
+  }
+  return -1;
+}
+
+export function parseReplyText(value: string | undefined | null): ParsedReplyText {
+  const normalized = (value ?? "").replaceAll("\r\n", "\n").trim();
+  if (!normalized) return { bodyText: "", quotedText: null };
+  const lines = normalized.split("\n");
+  const splitAt = quotedBlockStart(lines);
+  if (splitAt < 0) return { bodyText: normalized, quotedText: null };
+  const bodyText = lines.slice(0, splitAt).join("\n").trim();
+  const quotedText = lines.slice(splitAt).join("\n").trim();
+  return { bodyText, quotedText: quotedText || null };
+}
+

package/worker/mail/r2-presigned-urls.ts

@@ -0,0 +1,69 @@
+import { AwsClient } from "aws4fetch";
+import type { AppEnv } from "@open-workspace/core/worker/env.ts";
+
+type Bindings = AppEnv["Bindings"];
+
+const PRESIGN_TTL_SECONDS = 15 * 60;
+
+function r2S3Credentials(env: Bindings) {
+  const accessKeyId = env.R2_ACCESS_KEY_ID?.trim();
+  const secretAccessKey = env.R2_SECRET_ACCESS_KEY?.trim();
+  const accountId = env.R2_ACCOUNT_ID?.trim();
+  const bucketName = env.R2_BUCKET_NAME?.trim() || "openworkspace";
+  if (!accessKeyId || !secretAccessKey || !accountId) return null;
+  return { accessKeyId, secretAccessKey, accountId, bucketName };
+}
+
+function r2Signer(env: Bindings, r2Key: string) {
+  const credentials = r2S3Credentials(env);
+  if (!credentials) return null;
+  return {
+    client: new AwsClient({
+      accessKeyId: credentials.accessKeyId,
+      secretAccessKey: credentials.secretAccessKey,
+      service: "s3",
+      region: "auto",
+    }),
+    url: new URL(
+      `https://${credentials.accountId}.r2.cloudflarestorage.com/${credentials.bucketName}/${r2Key}`,
+    ),
+  };
+}
+
+export async function signR2PutUrl(input: {
+  env: Bindings;
+  r2Key: string;
+  contentType: string;
+}) {
+  const signer = r2Signer(input.env, input.r2Key);
+  if (!signer) return null;
+  signer.url.searchParams.set("X-Amz-Expires", String(PRESIGN_TTL_SECONDS));
+  const signed = await signer.client.sign(signer.url, {
+    method: "PUT",
+    headers: {
+      "content-type": input.contentType,
+    },
+    aws: {
+      allHeaders: true,
+      signQuery: true,
+    },
+  });
+  return signed.url;
+}
+
+export async function signR2GetUrl(input: {
+  env: Bindings;
+  r2Key: string;
+}) {
+  const signer = r2Signer(input.env, input.r2Key);
+  if (!signer) return null;
+  signer.url.searchParams.set("X-Amz-Expires", String(PRESIGN_TTL_SECONDS));
+  const signed = await signer.client.sign(signer.url, {
+    method: "GET",
+    aws: { signQuery: true },
+  });
+  return {
+    url: signed.url,
+    expiresAt: Date.now() + PRESIGN_TTL_SECONDS * 1_000,
+  };
+}

package/worker/mail/receive.ts

@@ -0,0 +1,59 @@
+import { createDb } from "@open-workspace/core/worker/db/client.ts";
+import { mailboxAddressPredicate } from "@open-workspace/core/worker/db/mailboxes.ts";
+import { domains, mailboxes } from "@open-workspace/core/worker/db/schema.ts";
+import { normalizeMailboxAddress } from "@open-workspace/core/worker/lib/ids.ts";
+import { mailboxStub } from "../mailbox";
+import { inboundDeliveryId } from "./inbound-delivery";
+import { deliverToList } from "./mailing-list";
+
+/** Stores incoming mail for a workspace address, or fans a list's mail out. */
+export async function receiveEmail(message: ForwardableEmailMessage, env: Env) {
+  const receivedAt = Date.now();
+  const recipient = normalizeMailboxAddress(message.to);
+  const [mailbox] = await createDb(env.DB)
+    .select({
+      id: mailboxes.id,
+      teamId: mailboxes.teamId,
+      delivery: mailboxes.delivery,
+      listPosting: mailboxes.listPosting,
+    })
+    .from(mailboxes)
+    .innerJoin(domains, mailboxAddressPredicate(recipient))
+    .limit(1);
+  if (!mailbox) {
+    message.setReject(`Mailbox ${recipient} does not exist`);
+    return;
+  }
+
+  const raw = await new Response(message.raw).arrayBuffer();
+  if (mailbox.delivery === "list" && mailbox.teamId) {
+    await deliverToList({
+      env,
+      list: { id: mailbox.id, teamId: mailbox.teamId, listPosting: mailbox.listPosting },
+      message,
+      raw,
+      receivedAt,
+    });
+    return;
+  }
+  const deliveryId = await inboundDeliveryId({
+    mailboxId: mailbox.id,
+    envelopeFrom: message.from,
+    envelopeTo: message.to,
+    raw,
+  });
+  const objectKey = `mailboxes/${mailbox.id}/raw/${deliveryId}.eml`;
+  await mailboxStub(env, mailbox.id).enqueueInbound({
+    id: deliveryId,
+    mailboxId: mailbox.id,
+    rawObjectKey: objectKey,
+    envelopeFrom: message.from,
+    envelopeTo: message.to,
+    receivedAt,
+  });
+  await env.MAIL_STORAGE.put(
+    objectKey,
+    raw,
+    { httpMetadata: { contentType: "message/rfc822" } },
+  );
+}

package/worker/mail/recipients.ts

@@ -0,0 +1,34 @@
+import { normalizeEmail } from "@open-workspace/core/worker/lib/ids.ts";
+
+export type RecipientFields = {
+  to: string[];
+  cc: string[];
+  bcc: string[];
+};
+
+/**
+ * A destination can occupy only one visible/hidden role. Precedence follows
+ * what recipients can observe: To, then Cc, then Bcc.
+ */
+export function dedupeRecipientFields(input: RecipientFields): RecipientFields {
+  const seen = new Set<string>();
+  const take = (values: string[]) => {
+    const result: string[] = [];
+    for (const value of values) {
+      const normalized = normalizeEmail(value);
+      if (!normalized || seen.has(normalized)) continue;
+      seen.add(normalized);
+      result.push(normalized);
+    }
+    return result;
+  };
+  return {
+    to: take(input.to),
+    cc: take(input.cc),
+    bcc: take(input.bcc),
+  };
+}
+
+export function recipientCount(input: RecipientFields) {
+  return input.to.length + input.cc.length + input.bcc.length;
+}