@novacraft-engineering/mailbox 0.4.24 → 0.4.26

package/.env.example

@@ -58,9 +58,15 @@ AWS_SES_REGION=eu-north-1
 RESEND_API_KEY=
 RESEND_WEBHOOK_SECRET=
 
-# Optional: copy inbound mail to an outside address. Leave empty to forward
-# nothing — pointing this at an address this app receives would loop.
+# Optional: where a copy goes when inbound mail belongs to no account. Pointing this
+# at an address this app receives would loop.
 MAIL_FORWARD_TO=
+# Set to off to stop copying inbound mail to account owners' login addresses.
+MAIL_FORWARDING=on
+
+# SES delivery events arrive through SNS at /api/mail/events/ses. Only this topic is
+# accepted; leave unset and every notification is refused.
+MAIL_SES_EVENTS_TOPIC_ARN=
 
 # ─── Attachments ────────────────────────────────────────────────────────────
 # Any S3-compatible bucket: AWS S3, Cloudflare R2, Backblaze B2, MinIO, Wasabi.

package/app/api/mail/company-dictionary/route.ts

@@ -0,0 +1,36 @@
+import { NextResponse } from 'next/server'
+import { mailAuthGuard, resolveAccount } from '@/lib/dev-auth'
+import { getSettings, setSettings } from '@/lib/mailbox'
+
+export const runtime = 'nodejs'
+
+const COMPANY = '__company__'
+
+const wordsFrom = (value: unknown): string[] =>
+  Array.isArray(value)
+    ? [...new Set(value.filter((word): word is string => typeof word === 'string').map(word => word.trim()).filter(word => word && word.length <= 60))].slice(0, 5000)
+    : []
+
+/** Words everyone's spelling check accepts: client, insurer and product names. */
+export async function GET(req: Request) {
+  const guard = await mailAuthGuard(req)
+  if (guard) return guard
+  const stored = await getSettings(COMPANY)
+  return NextResponse.json({ ok: true, words: wordsFrom(stored.dictionary) })
+}
+
+export async function PUT(req: Request) {
+  const guard = await mailAuthGuard(req)
+  if (guard) return guard
+  const account = await resolveAccount(req)
+  if (account.role !== 'admin') return NextResponse.json({ ok: false, error: 'Admin access required' }, { status: 403 })
+  let body: { words?: unknown }
+  try {
+    body = await req.json()
+  } catch {
+    return NextResponse.json({ ok: false, error: 'Invalid JSON' }, { status: 400 })
+  }
+  const words = wordsFrom(body.words)
+  await setSettings(COMPANY, { ...(await getSettings(COMPANY)), dictionary: words })
+  return NextResponse.json({ ok: true, words })
+}

package/app/api/mail/company-signature/route.ts

@@ -31,6 +31,6 @@ export async function PUT(req: Request) {
   }
   const signature = typeof body.signature === 'string' ? body.signature : ''
   const logo = typeof body.logo === 'string' ? body.logo : ''
-  await setSettings(COMPANY, { signature, logo })
+  await setSettings(COMPANY, { ...(await getSettings(COMPANY)), signature, logo })
   return NextResponse.json({ ok: true })
 }

package/app/api/mail/events/ses/route.ts

@@ -0,0 +1,88 @@
+import { NextResponse } from 'next/server'
+import { appendEvent, claimWebhookEvent, completeWebhookEvent, releaseWebhookEvent } from '@/lib/mailbox'
+import { awsSnsUrl, verifySns, type SnsEnvelope } from '@/lib/sns'
+
+export const runtime = 'nodejs'
+
+type SesEvent = {
+  eventType?: string
+  mail?: { messageId?: string; timestamp?: string; destination?: string[]; commonHeaders?: { subject?: string } }
+  bounce?: { bounceType?: string; bounceSubType?: string; timestamp?: string; bouncedRecipients?: Array<{ emailAddress?: string; diagnosticCode?: string }> }
+  complaint?: { timestamp?: string; complaintFeedbackType?: string }
+  delivery?: { timestamp?: string }
+  deliveryDelay?: { timestamp?: string; delayType?: string }
+  reject?: { reason?: string }
+  failure?: { errorMessage?: string }
+}
+
+// The same names Resend's webhooks use, so the Sent list reads either provider the same way.
+const EVENT_TYPES: Record<string, string> = {
+  Send: 'email.sent',
+  Delivery: 'email.delivered',
+  DeliveryDelay: 'email.delivery_delayed',
+  Bounce: 'email.bounced',
+  Complaint: 'email.complained',
+  Reject: 'email.failed',
+  RenderingFailure: 'email.failed',
+}
+
+/** SES delivery events, fanned out through an SNS topic this deployment pins by ARN. */
+export async function POST(req: Request) {
+  let envelope: SnsEnvelope
+  try {
+    envelope = JSON.parse(await req.text()) as SnsEnvelope
+  } catch {
+    return NextResponse.json({ ok: false, error: 'Invalid JSON' }, { status: 400 })
+  }
+  if (!(await verifySns(envelope, process.env.MAIL_SES_EVENTS_TOPIC_ARN))) {
+    return NextResponse.json({ ok: false, error: 'Unverified' }, { status: 403 })
+  }
+
+  if (envelope.Type === 'SubscriptionConfirmation') {
+    if (!envelope.SubscribeURL || !awsSnsUrl(envelope.SubscribeURL, '/')) {
+      return NextResponse.json({ ok: false, error: 'Unexpected subscribe URL' }, { status: 400 })
+    }
+    const confirmed = await fetch(envelope.SubscribeURL).then(response => response.ok).catch(() => false)
+    return NextResponse.json({ ok: confirmed })
+  }
+  if (envelope.Type !== 'Notification') return NextResponse.json({ ok: true, ignored: envelope.Type })
+
+  let event: SesEvent
+  try {
+    event = JSON.parse(envelope.Message ?? '{}') as SesEvent
+  } catch {
+    return NextResponse.json({ ok: false, error: 'Notification carried no JSON' }, { status: 400 })
+  }
+  const type = EVENT_TYPES[event.eventType ?? '']
+  const emailId = event.mail?.messageId
+  if (!type || !emailId) return NextResponse.json({ ok: true, ignored: event.eventType ?? 'unknown' })
+
+  const claimKey = `ses:${envelope.MessageId ?? ''}`
+  if ((await claimWebhookEvent(claimKey)) !== 'claimed') return NextResponse.json({ ok: true, duplicate: true })
+
+  const meta: Record<string, string> = {}
+  if (event.mail?.commonHeaders?.subject) meta.subject = event.mail.commonHeaders.subject
+  if (event.mail?.destination?.length) meta.to = event.mail.destination.join(', ')
+  if (event.bounce) {
+    meta.bounceType = [event.bounce.bounceType, event.bounce.bounceSubType].filter(Boolean).join(' / ')
+    const reasons = (event.bounce.bouncedRecipients ?? [])
+      .map(recipient => [recipient.emailAddress, recipient.diagnosticCode].filter(Boolean).join(': '))
+      .filter(Boolean)
+    if (reasons.length) meta.bounceMessage = reasons.join('; ')
+  }
+  if (event.complaint?.complaintFeedbackType) meta.complaint = event.complaint.complaintFeedbackType
+  if (event.deliveryDelay?.delayType) meta.delayType = event.deliveryDelay.delayType
+  if (event.reject?.reason) meta.failReason = event.reject.reason
+  if (event.failure?.errorMessage) meta.failReason = event.failure.errorMessage
+
+  const at = event.delivery?.timestamp ?? event.bounce?.timestamp ?? event.complaint?.timestamp
+    ?? event.deliveryDelay?.timestamp ?? event.mail?.timestamp ?? new Date().toISOString()
+  try {
+    await appendEvent({ emailId, type, at, meta: Object.keys(meta).length ? meta : undefined })
+  } catch (err) {
+    await releaseWebhookEvent(claimKey)
+    throw err
+  }
+  await completeWebhookEvent(claimKey)
+  return NextResponse.json({ ok: true })
+}

package/app/api/mail/grammar/route.ts

@@ -0,0 +1,52 @@
+import { NextResponse } from 'next/server'
+import { mailAuthGuard } from '@/lib/dev-auth'
+
+export const runtime = 'nodejs'
+
+const server = () => process.env.LANGUAGETOOL_URL?.trim().replace(/\/+$/, '') || ''
+
+// Spelling is checked in the browser against the company's own dictionaries; LanguageTool's
+// spell rule would flag every client and insurer name a second time. The whitespace rule
+// fires on the no-break spaces the Tab key inserts.
+const SKIPPED_RULES = /^(MORFOLOGIK_RULE|HUNSPELL_RULE|WHITESPACE_RULE|CONSECUTIVE_SPACES|EN_QUOTES|DASH_RULE|UPPERCASE_SENTENCE_START|ENGLISH_WORD_REPEAT_RULE)/
+
+export async function GET(req: Request) {
+  const guard = await mailAuthGuard(req)
+  if (guard) return guard
+  return NextResponse.json({ ok: true, available: Boolean(server()) })
+}
+
+export async function POST(req: Request) {
+  const guard = await mailAuthGuard(req)
+  if (guard) return guard
+  const base = server()
+  if (!base) return NextResponse.json({ ok: false, error: 'Grammar checking is not set up' }, { status: 503 })
+  let body: { text?: unknown; language?: unknown }
+  try {
+    body = await req.json()
+  } catch {
+    return NextResponse.json({ ok: false, error: 'Invalid JSON' }, { status: 400 })
+  }
+  const text = typeof body.text === 'string' ? body.text.slice(0, 20000) : ''
+  const language = body.language === 'en-US' ? 'en-US' : 'en-GB'
+  if (!text.trim()) return NextResponse.json({ ok: true, matches: [] })
+  const upstream = await fetch(`${base}/v2/check`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: new URLSearchParams({ text, language, level: 'default' }),
+    signal: AbortSignal.timeout(15000),
+  }).catch(() => null)
+  if (!upstream?.ok) return NextResponse.json({ ok: false, error: 'The grammar server did not answer' }, { status: 502 })
+  const data = (await upstream.json()) as {
+    matches?: Array<{ offset: number; length: number; message: string; replacements?: Array<{ value: string }>; rule?: { id?: string } }>
+  }
+  const matches = (data.matches ?? [])
+    .filter(match => !SKIPPED_RULES.test(match.rule?.id ?? ''))
+    .map(match => ({
+      offset: match.offset,
+      length: match.length,
+      message: match.message,
+      replacements: (match.replacements ?? []).slice(0, 5).map(entry => entry.value),
+    }))
+  return NextResponse.json({ ok: true, matches })
+}

package/app/api/mail/scheduled/route.ts

@@ -1,7 +1,7 @@
 import { NextResponse } from 'next/server'
 import { mailAuthGuard, resolveAccount } from '@/lib/dev-auth'
 import { scopeFor } from '@/lib/scope'
-import { listScheduled, cancelScheduled, rescheduleSend } from '@/lib/scheduled'
+import { listScheduled, cancelScheduled, dispatchNow, rescheduleSend } from '@/lib/scheduled'
 
 export const runtime = 'nodejs'
 export const dynamic = 'force-dynamic'
@@ -46,3 +46,17 @@ export async function PATCH(req: Request) {
   }
   return NextResponse.json({ ok: true, scheduledAt: when.toISOString() })
 }
+
+/** Send a waiting message of the caller's now — the page calls this as its undo window closes. */
+export async function POST(req: Request) {
+  const guard = await mailAuthGuard(req)
+  if (guard) return guard
+  const account = await resolveAccount(req)
+  const body = (await req.json().catch(() => null)) as { id?: string } | null
+  const id = body?.id ?? ''
+  if (!id) return NextResponse.json({ ok: false, error: 'id is required' }, { status: 400 })
+  const outcome = await dispatchNow(id, account.address ?? '')
+  if (outcome === 'sent' || outcome === 'already-sent') return NextResponse.json({ ok: true, outcome })
+  const status = outcome === 'missing' ? 404 : outcome === 'not-due' ? 409 : 502
+  return NextResponse.json({ ok: false, outcome }, { status })
+}