@ossy/platform 3.20.2 → 3.22.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/platform",
-  "version": "3.20.2",
+  "version": "3.22.1",
   "description": "Ossy application server runtime",
   "repository": {
     "type": "git",
@@ -43,11 +43,13 @@
   "dependencies": {
     "@aws-sdk/client-s3": "^3.1057.0",
     "@aws-sdk/client-ses": "^3.0.0",
+    "@aws-sdk/client-sqs": "^3.1103.0",
     "@aws-sdk/s3-request-presigner": "^3.1057.0",
     "@aws-sdk/util-create-request": "^3.972.26",
     "@aws-sdk/util-format-url": "^3.972.17",
     "@modelcontextprotocol/sdk": "^1.12.1",
     "@ossy/config": "^3.0.9",
+    "@ossy/email": "^3.22.1",
     "@ossy/event-store": "^3.20.1",
     "@ossy/locale": "^3.4.0",
     "@ossy/manifest": "^3.20.1",
@@ -58,7 +60,7 @@
     "@ossy/sdk": "^3.20.1",
     "@ossy/tokens": "^3.11.1",
     "@ossy/users": "^3.20.1",
-    "@ossy/workspaces": "^3.20.1",
+    "@ossy/workspaces": "^3.22.0",
     "cookie-parser": "^1.4.7",
     "dotenv": ">=16.0.0 <18.0.0",
     "express": ">=5.0.0 <6.0.0",
@@ -79,5 +81,5 @@
     "Dockerfile",
     "docker-healthcheck.js"
   ],
-  "gitHead": "d0e5d69906917105609af4bb8bbdd2340d9fbaf1"
+  "gitHead": "b90c38bb41c552f9050067c6518e8a27cabf9827"
 }

package/src/email-preview.js

@@ -0,0 +1,34 @@
+import { createTranslatorForBuild } from './locale.js'
+
+/**
+ * Give API handlers a way to load a discovered `*.email.jsx` and translate it.
+ * Email bundles are server entries, so the browser cannot render them itself.
+ *
+ * @param {import('express').Request} req
+ * @param {{
+ *   manifest: { emails?: Array<{ id?: string, entry?: string }>, config?: { defaultLanguage?: string, supportedLanguages?: string[] } }
+ *   loadEntry: (entryUrl: string) => Promise<any>
+ *   buildDir: string
+ * }} context
+ */
+export function attachEmailPreview (req, { manifest, loadEntry, buildDir }) {
+  const config = manifest?.config || {}
+  const supported = new Set(
+    Array.isArray(config.supportedLanguages) && config.supportedLanguages.length
+      ? config.supportedLanguages
+      : ['en', 'sv'],
+  )
+  const defaultLanguage = config.defaultLanguage || 'en'
+
+  req.loadEmailTemplate = async (id) => {
+    const email = (manifest?.emails || []).find((entry) => entry?.id === id)
+    if (!email?.entry) return null
+    return loadEntry(email.entry)
+  }
+
+  req.emailTranslator = (language) => {
+    const requested = typeof language === 'string' ? language : ''
+    const active = supported.has(requested) ? requested : defaultLanguage
+    return createTranslatorForBuild(buildDir, active, { ...config, warnOnMissingKey: false })
+  }
+}

package/src/runtime.js

@@ -6,6 +6,7 @@ import morgan from 'morgan'
 import { Router as OssyRouter } from '@ossy/router'
 import { loadManifest, resolveEntryUrl, loadLayoutsById, resolvePageLayoutRender } from './server.js'
 import { resolveRequestLocale } from './locale.js'
+import { attachEmailPreview } from './email-preview.js'
 import { buildManifestSummary } from '@ossy/manifest/build-manifest-summary'
 import { ProxyInternal } from './proxy-internal.js'
 import { loadSite, invalidateSite } from './site-loader.js'
@@ -158,6 +159,7 @@ export async function startRuntime ({ port } = {}) {
         if (apiEntry) {
           const mod = await loadEntry(apiEntry.entry)
           if (typeof mod.handle === 'function') {
+            attachEmailPreview(req, { manifest, loadEntry, buildDir })
             await mod.handle(req, res)
             return
           }

package/src/server.js

@@ -21,6 +21,7 @@ import { ConfigService } from './config.service.js'
 import { UsersMiddleware } from './users.middleware.js'
 import { WorkspacesMiddleware } from './workspaces.middleware.js'
 import { resolveRequestLocale } from './locale.js'
+import { attachEmailPreview } from './email-preview.js'
 import { mountPlatformMcp } from './mcp/mount-platform-mcp.js'
 import {
   assertActionEntitled,
@@ -507,6 +508,7 @@ export async function startServer (options = {}) {
         if (apiEntry) {
           const mod = await loadEntry(apiEntry.entry)
           if (typeof mod.handle === 'function') {
+            attachEmailPreview(req, { manifest, loadEntry, buildDir })
             await mod.handle(req, res)
             return
           }
@@ -667,6 +669,20 @@ export async function startServer (options = {}) {
   log.info(`Running on http://localhost:${port}`)
   log.info('Press Ctrl+C to stop.')
 
+  let stopInboundMail = async () => {}
+  if (process.env.INBOUND_EMAIL_QUEUE_URL && process.env.INBOUND_EMAIL_BUCKET) {
+    try {
+      const { startInboundMailPoller } = await import('./ses/poll-inbound-mail.js')
+      stopInboundMail = startInboundMailPoller({
+        queueUrl: process.env.INBOUND_EMAIL_QUEUE_URL,
+        bucket: process.env.INBOUND_EMAIL_BUCKET,
+        log,
+      })
+    } catch (err) {
+      log.error('Inbound mail poller not started', undefined, err)
+    }
+  }
+
   runStartupRebuild?.()
 
   const closeServer = () => new Promise((resolve) => {
@@ -682,6 +698,7 @@ export async function startServer (options = {}) {
     try {
       TaskService.stop()
       closePushSseConnections()
+      await stopInboundMail()
       await ChangeStream.stop()
       await Mongo.closeConnection()
       await closeServer()

package/src/ses/inbound-aws-credentials.js

@@ -0,0 +1,34 @@
+/**
+ * The website task also has static AWS keys in its environment, and the SDK
+ * uses those before the task role. Inbound mail is granted to the task role,
+ * so the poller has to ask ECS for that role when it is running in a task.
+ *
+ * @param {NodeJS.ProcessEnv} [env]
+ * @param {typeof fetch} [fetchImpl]
+ */
+export function inboundAwsClientConfig (env = process.env, fetchImpl = globalThis.fetch) {
+  const relative = env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI
+  const full = env.AWS_CONTAINER_CREDENTIALS_FULL_URI
+  if (!relative && !full) return {}
+
+  const url = full || `http://169.254.170.2${relative}`
+  return {
+    credentials: async () => {
+      const headers = {}
+      if (env.AWS_CONTAINER_AUTHORIZATION_TOKEN) {
+        headers.Authorization = env.AWS_CONTAINER_AUTHORIZATION_TOKEN
+      }
+      const response = await fetchImpl(url, { headers })
+      if (!response.ok) {
+        throw new Error('Task role credentials could not be read')
+      }
+      const body = await response.json()
+      return {
+        accessKeyId: body.AccessKeyId,
+        secretAccessKey: body.SecretAccessKey,
+        sessionToken: body.Token,
+        expiration: body.Expiration ? new Date(body.Expiration) : undefined,
+      }
+    },
+  }
+}

package/src/ses/inbound-aws-credentials.spec.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from '@jest/globals'
+import { inboundAwsClientConfig } from './inbound-aws-credentials.js'
+
+describe('inboundAwsClientConfig', () => {
+  it('uses the default chain when the process is not in a task', () => {
+    expect(inboundAwsClientConfig({ AWS_ACCESS_KEY_ID: 'static' })).toEqual({})
+  })
+
+  it('reads the task role and ignores static keys', async () => {
+    const fetchImpl = async (url, { headers }) => {
+      expect(url).toBe('http://169.254.170.2/v2/credentials/task')
+      expect(headers.Authorization).toBe('token')
+      return {
+        ok: true,
+        json: async () => ({
+          AccessKeyId: 'task-key',
+          SecretAccessKey: 'task-secret',
+          Token: 'task-token',
+          Expiration: '2026-10-17T20:00:00.000Z',
+        }),
+      }
+    }
+    const config = inboundAwsClientConfig({
+      AWS_ACCESS_KEY_ID: 'cms-prod',
+      AWS_SECRET_ACCESS_KEY: 'static',
+      AWS_CONTAINER_CREDENTIALS_RELATIVE_URI: '/v2/credentials/task',
+      AWS_CONTAINER_AUTHORIZATION_TOKEN: 'token',
+    }, fetchImpl)
+    await expect(config.credentials()).resolves.toEqual({
+      accessKeyId: 'task-key',
+      secretAccessKey: 'task-secret',
+      sessionToken: 'task-token',
+      expiration: new Date('2026-10-17T20:00:00.000Z'),
+    })
+  })
+})

package/src/ses/poll-inbound-mail.js

@@ -0,0 +1,90 @@
+import { DeleteMessageCommand, ReceiveMessageCommand, SQSClient } from '@aws-sdk/client-sqs'
+import { GetObjectCommand, S3Client } from '@aws-sdk/client-s3'
+import { fileSesReceipt, sesReceiptFromBody } from '@ossy/email/ses-inbound'
+import { createInProcessSdk } from '../tasks/in-process-sdk.js'
+import { inboundAwsClientConfig } from './inbound-aws-credentials.js'
+
+const ReceiveInbound = { id: '@ossy/email/actions/receive-inbound' }
+
+async function readObject (client, { bucket, key }) {
+  const response = await client.send(new GetObjectCommand({ Bucket: bucket, Key: key }))
+  return Buffer.from(await response.Body.transformToByteArray())
+}
+
+/**
+ * File each receipt and delete it. A failure leaves the message for SQS to
+ * retry, then the dead-letter queue. A skipped receipt is deleted.
+ *
+ * @param {Array<{ Body?: string, ReceiptHandle?: string }>} messages
+ */
+export async function ackInboundMessages (messages, { file, deleteMessage, log } = {}) {
+  for (const message of messages ?? []) {
+    try {
+      const result = await file(message.Body)
+      if (result?.skipped) log?.info('[ses/inbound] skipped receipt', result)
+      await deleteMessage(message)
+    } catch (error) {
+      if (error?.name === 'NoSuchKey') {
+        log?.info('[ses/inbound] raw message already gone', { key: error.Key })
+        await deleteMessage(message)
+        continue
+      }
+      log?.error('[ses/inbound] receipt failed', undefined, error)
+    }
+  }
+}
+
+/**
+ * Long-poll the inbound queue. Several tasks may poll; SQS delivers each
+ * message to one of them. Returns a stop function for shutdown.
+ */
+export function startInboundMailPoller ({ queueUrl, bucket, log } = {}) {
+  const clientConfig = inboundAwsClientConfig()
+  const sqs = new SQSClient(clientConfig)
+  const objects = new S3Client(clientConfig)
+  const abort = new AbortController()
+
+  const file = (body) => fileSesReceipt(sesReceiptFromBody(body), {
+    bucket,
+    getObject: (location) => readObject(objects, location),
+    invoke: ({ mime, workspaceId }) => createInProcessSdk()
+      .forWorkspace(workspaceId)
+      .invoke(ReceiveInbound, { mime, workspaceId }),
+  })
+
+  const run = (async () => {
+    while (!abort.signal.aborted) {
+      try {
+        const response = await sqs.send(new ReceiveMessageCommand({
+          QueueUrl: queueUrl,
+          MaxNumberOfMessages: 5,
+          WaitTimeSeconds: 20,
+          VisibilityTimeout: 120,
+        }), { abortSignal: abort.signal })
+        await ackInboundMessages(response.Messages, {
+          file,
+          log,
+          deleteMessage: (message) => sqs.send(new DeleteMessageCommand({
+            QueueUrl: queueUrl,
+            ReceiptHandle: message.ReceiptHandle,
+          })),
+        })
+      } catch (error) {
+        if (abort.signal.aborted) return
+        log?.error('[ses/inbound] poll failed', undefined, error)
+        await new Promise((resolve) => {
+          const timer = setTimeout(resolve, 5000)
+          abort.signal.addEventListener('abort', () => {
+            clearTimeout(timer)
+            resolve()
+          }, { once: true })
+        })
+      }
+    }
+  })()
+
+  return async function stopInboundMailPoller () {
+    abort.abort()
+    await run.catch(() => {})
+  }
+}

package/src/ses/poll-inbound-mail.spec.js

@@ -0,0 +1,37 @@
+import { describe, expect, it, jest } from '@jest/globals'
+import { ackInboundMessages } from './poll-inbound-mail.js'
+
+describe('ackInboundMessages', () => {
+  it('deletes a filed receipt and a skipped one', async () => {
+    const deleteMessage = jest.fn()
+    await ackInboundMessages([
+      { Body: 'filed' },
+      { Body: 'skip' },
+    ], {
+      file: async (body) => (body === 'skip' ? { skipped: true, reason: 'no workspace' } : { id: 'res-1' }),
+      deleteMessage,
+    })
+    expect(deleteMessage).toHaveBeenCalledTimes(2)
+  })
+
+  it('leaves a failed receipt on the queue', async () => {
+    const deleteMessage = jest.fn()
+    await ackInboundMessages([{ Body: 'bad' }], {
+      file: async () => { throw new Error('store failed') },
+      deleteMessage,
+      log: { error () {} },
+    })
+    expect(deleteMessage).not.toHaveBeenCalled()
+  })
+
+  it('deletes a receipt whose raw object is already gone', async () => {
+    const deleteMessage = jest.fn()
+    const error = Object.assign(new Error('missing'), { name: 'NoSuchKey' })
+    await ackInboundMessages([{ Body: 'gone' }], {
+      file: async () => { throw error },
+      deleteMessage,
+      log: { info () {} },
+    })
+    expect(deleteMessage).toHaveBeenCalledTimes(1)
+  })
+})