@open-mercato/channel-resend 0.7.1-develop.7151.1.00d0391847

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@open-mercato/channel-resend",
+  "version": "0.7.1-develop.7151.1.00d0391847",
+  "type": "module",
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "node build.mjs",
+    "watch": "node watch.mjs",
+    "test": "jest --config jest.config.cjs",
+    "typecheck": "tsc --noEmit"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./*.ts": {
+      "types": "./src/*.ts",
+      "default": "./dist/*.js"
+    },
+    "./*.tsx": {
+      "types": "./src/*.tsx",
+      "default": "./dist/*.js"
+    },
+    "./*": {
+      "types": [
+        "./src/*.ts",
+        "./src/*.tsx"
+      ],
+      "default": "./dist/*.js"
+    },
+    "./*/*": {
+      "types": [
+        "./src/*/*.ts",
+        "./src/*/*.tsx"
+      ],
+      "default": "./dist/*/*.js"
+    },
+    "./*/*/*": {
+      "types": [
+        "./src/*/*/*.ts",
+        "./src/*/*/*.tsx"
+      ],
+      "default": "./dist/*/*/*.js"
+    },
+    "./*/*/*/*": {
+      "types": [
+        "./src/*/*/*/*.ts",
+        "./src/*/*/*/*.tsx"
+      ],
+      "default": "./dist/*/*/*/*.js"
+    }
+  },
+  "dependencies": {
+    "@open-mercato/core": "0.7.1-develop.7151.1.00d0391847",
+    "resend": "^6.12.4"
+  },
+  "peerDependencies": {
+    "@mikro-orm/postgresql": "^7.0.14",
+    "@open-mercato/ai-assistant": "0.7.1-develop.7151.1.00d0391847",
+    "@open-mercato/shared": "0.7.1-develop.7151.1.00d0391847",
+    "@open-mercato/ui": "0.7.1-develop.7151.1.00d0391847",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "devDependencies": {
+    "@open-mercato/ai-assistant": "0.7.1-develop.7151.1.00d0391847",
+    "@open-mercato/shared": "0.7.1-develop.7151.1.00d0391847",
+    "@open-mercato/ui": "0.7.1-develop.7151.1.00d0391847",
+    "@types/jest": "^30.0.0",
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "esbuild": "^0.28.0",
+    "glob": "^13.0.6",
+    "jest": "^30.4.2",
+    "react": "19.2.7",
+    "react-dom": "19.2.7",
+    "ts-jest": "^29.4.11",
+    "typescript": "7.0.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/open-mercato/open-mercato",
+    "directory": "packages/channel-resend"
+  },
+  "stableVersion": "0.7.0"
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { metadata } from './modules/channel_resend/index'

package/src/modules/channel_resend/__tests__/contracts.test.ts

@@ -0,0 +1,27 @@
+import { features } from '../acl'
+import { resendCapabilities } from '../capabilities'
+import { integration } from '../integration'
+import { metadata } from '../index'
+
+describe('channel_resend contracts', () => {
+  it('declares supported module metadata and coordinated versions', () => {
+    expect(metadata).toEqual(expect.objectContaining({
+      id: 'channel_resend',
+      version: '0.1.0',
+      requires: ['communication_channels', 'integrations'],
+    }))
+    expect(integration).toEqual(expect.objectContaining({
+      version: '0.1.0',
+      healthCheck: { service: 'channelResendHealthCheck' },
+    }))
+    expect(metadata).not.toHaveProperty('dependencies')
+  })
+
+  it('exports catalog-compatible ACL features and honest capabilities', () => {
+    expect(features).toEqual([
+      { id: 'channel_resend.view', title: expect.any(String), module: 'channel_resend' },
+      { id: 'channel_resend.configure', title: expect.any(String), module: 'channel_resend' },
+    ])
+    expect(resendCapabilities.fileSharing).toBe(false)
+  })
+})

package/src/modules/channel_resend/acl.ts

@@ -0,0 +1,6 @@
+export const features = [
+  { id: 'channel_resend.view', title: 'View Resend channel configuration', module: 'channel_resend' },
+  { id: 'channel_resend.configure', title: 'Configure Resend channel defaults', module: 'channel_resend' },
+]
+
+export default features

package/src/modules/channel_resend/capabilities.ts

@@ -0,0 +1,8 @@
+import { baseEmailCapabilities } from '@open-mercato/core/modules/communication_channels/lib/email-capabilities'
+import type { ChannelCapabilities } from '@open-mercato/core/modules/communication_channels/lib/adapter'
+
+export const resendCapabilities: ChannelCapabilities = {
+  ...baseEmailCapabilities,
+  fileSharing: false,
+  conversationHistory: false,
+}

package/src/modules/channel_resend/di.ts

@@ -0,0 +1,20 @@
+import { asValue } from 'awilix'
+import type { AppContainer } from '@open-mercato/shared/lib/di/container'
+import {
+  hasChannelAdapter,
+  registerChannelAdapter,
+} from '@open-mercato/core/modules/communication_channels/lib/adapter-registry-singleton'
+import { getResendChannelAdapter } from './lib/adapter'
+import { registerResendSystemEmailConfigResolver } from './lib/system-email-config'
+import { channelResendHealthCheck } from './lib/health'
+
+export function register(container: AppContainer): void {
+  registerResendSystemEmailConfigResolver()
+  if (!hasChannelAdapter('resend')) {
+    registerChannelAdapter(getResendChannelAdapter())
+  }
+  container.register({
+    channelResendAdapter: asValue(getResendChannelAdapter()),
+    channelResendHealthCheck: asValue(channelResendHealthCheck),
+  })
+}

package/src/modules/channel_resend/index.ts

@@ -0,0 +1,9 @@
+export const metadata = {
+  id: 'channel_resend',
+  name: 'Resend Email Channel',
+  description: 'Outbound Resend email channel provider for the Communications Hub.',
+  version: '0.1.0',
+  requires: ['communication_channels', 'integrations'],
+}
+
+export default metadata

package/src/modules/channel_resend/integration.ts

@@ -0,0 +1,56 @@
+import { buildIntegrationDetailWidgetSpotId, type IntegrationBundle, type IntegrationDefinition } from '@open-mercato/shared/modules/integrations/types'
+
+export const channelResendDetailWidgetSpotId = buildIntegrationDetailWidgetSpotId('channel_resend')
+
+export const integration: IntegrationDefinition = {
+  id: 'channel_resend',
+  title: 'Resend Email',
+  description: 'Send transactional email through Resend using the Communications Hub.',
+  category: 'communication',
+  hub: 'communication_channels',
+  providerKey: 'resend',
+  icon: 'mail',
+  docsUrl: 'https://resend.com/docs',
+  package: '@open-mercato/channel-resend',
+  version: '0.1.0',
+  author: 'Open Mercato Team',
+  company: 'Open Mercato',
+  license: 'MIT',
+  tags: ['email', 'resend', 'transactional', 'communication'],
+  detailPage: {
+    widgetSpotId: channelResendDetailWidgetSpotId,
+  },
+  apiVersions: [
+    {
+      id: 'resend-v2',
+      label: 'Resend Email API',
+      status: 'stable',
+      default: true,
+      changelog: 'Initial outbound transactional email adapter.',
+    },
+  ],
+  healthCheck: { service: 'channelResendHealthCheck' },
+  credentials: {
+    fields: [
+      {
+        key: 'apiKey',
+        label: 'API key',
+        type: 'secret',
+        required: true,
+        helpText: 'Resend API key used for outbound transactional email.',
+      },
+      {
+        key: 'fromAddress',
+        label: 'From address',
+        type: 'text',
+        required: true,
+        placeholder: 'no-reply@example.com',
+        helpText: 'Verified sender address or domain identity in Resend.',
+      },
+    ],
+  },
+}
+
+export const integrations: IntegrationDefinition[] = [integration]
+export const bundles: IntegrationBundle[] = []
+export const bundle: IntegrationBundle | undefined = undefined

package/src/modules/channel_resend/lib/__tests__/adapter.test.ts

@@ -0,0 +1,70 @@
+import { getResendChannelAdapter } from '../adapter'
+
+var sendMock: jest.Mock
+var ResendMock: jest.Mock
+
+jest.mock('resend', () => {
+  sendMock = jest.fn().mockResolvedValue({ data: { id: 'email-1' } })
+  ResendMock = jest.fn().mockImplementation(() => ({
+    emails: { send: sendMock },
+  }))
+  return { Resend: ResendMock }
+})
+
+describe('ResendChannelAdapter', () => {
+  beforeEach(() => {
+    sendMock.mockClear()
+    ResendMock.mockClear()
+  })
+
+  it('sends html email with replyTo and attachments', async () => {
+    const adapter = getResendChannelAdapter()
+    const converted = await adapter.convertOutbound({
+      body: '<p>Hello</p>',
+      bodyFormat: 'html',
+      channelMetadata: {
+        to: 'user@example.com',
+        subject: 'Hello',
+        from: 'from@example.com',
+        replyTo: 'reply@example.com',
+        attachments: [{ filename: 'a.txt', content: 'dGVzdA==', contentType: 'text/plain' }],
+      },
+    })
+
+    const result = await adapter.sendMessage({
+      content: converted.content,
+      credentials: { apiKey: 'key', fromAddress: 'fallback@example.com' },
+      scope: { tenantId: 'tenant', organizationId: 'org' },
+      metadata: converted.metadata,
+    })
+
+    expect(result).toEqual(expect.objectContaining({ status: 'sent', externalMessageId: 'email-1' }))
+    expect(ResendMock).toHaveBeenCalledWith('key')
+    expect(sendMock).toHaveBeenCalledWith(expect.objectContaining({
+      from: 'from@example.com',
+      to: ['user@example.com'],
+      subject: 'Hello',
+      html: '<p>Hello</p>',
+      text: 'Hello',
+      replyTo: 'reply@example.com',
+      attachments: [{ filename: 'a.txt', content: 'dGVzdA==', contentType: 'text/plain' }],
+    }))
+  })
+
+  it('returns a failed result when Resend reports an error', async () => {
+    sendMock.mockResolvedValueOnce({ error: { message: 'bad domain' } })
+    const adapter = getResendChannelAdapter()
+
+    const result = await adapter.sendMessage({
+      content: { text: 'Hello' },
+      credentials: { apiKey: 'key', fromAddress: 'from@example.com' },
+      scope: { tenantId: 'tenant', organizationId: 'org' },
+      metadata: { to: ['user@example.com'], subject: 'Hello' },
+    })
+
+    expect(result).toEqual(expect.objectContaining({
+      status: 'failed',
+      error: 'RESEND_SEND_FAILED: bad domain',
+    }))
+  })
+})

package/src/modules/channel_resend/lib/__tests__/health.test.ts

@@ -0,0 +1,38 @@
+import { channelResendHealthCheck } from '../health'
+
+describe('channelResendHealthCheck', () => {
+  const originalFetch = global.fetch
+
+  afterEach(() => {
+    global.fetch = originalFetch
+  })
+
+  it('performs a bounded provider API probe', async () => {
+    global.fetch = jest.fn().mockResolvedValue(new Response('{}', { status: 200 }))
+
+    const result = await channelResendHealthCheck.check(
+      { apiKey: 're_test', fromAddress: 'from@example.com' },
+      { tenantId: 'tenant-1', organizationId: 'organization-1' },
+    )
+
+    expect(result.status).toBe('healthy')
+    expect(global.fetch).toHaveBeenCalledWith(
+      'https://api.resend.com/domains?limit=1',
+      expect.objectContaining({ signal: expect.any(AbortSignal) }),
+    )
+  })
+
+  it('reports rejected credentials as unhealthy', async () => {
+    global.fetch = jest.fn().mockResolvedValue(new Response('{}', { status: 401 }))
+
+    const result = await channelResendHealthCheck.check(
+      { apiKey: 're_bad', fromAddress: 'from@example.com' },
+      { tenantId: 'tenant-1', organizationId: 'organization-1' },
+    )
+
+    expect(result).toEqual(expect.objectContaining({
+      status: 'unhealthy',
+      details: expect.objectContaining({ status: 401 }),
+    }))
+  })
+})

package/src/modules/channel_resend/lib/__tests__/preset.test.ts

@@ -0,0 +1,179 @@
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { applyResendEnvPreset, readResendEnvPreset } from '../preset'
+
+jest.mock('@open-mercato/shared/lib/encryption/find', () => ({
+  findOneWithDecryption: jest.fn(),
+}))
+
+const mockedFindOneWithDecryption = findOneWithDecryption as jest.MockedFunction<typeof findOneWithDecryption>
+
+function createContainer(overrides: { save?: jest.Mock; upsert?: jest.Mock } = {}) {
+  const save = overrides.save ?? jest.fn().mockResolvedValue(undefined)
+  const upsert = overrides.upsert ?? jest.fn().mockResolvedValue(undefined)
+  const container = {
+    resolve: (key: string) => (key === 'integrationStateService' ? { upsert } : { save }),
+  } as never
+  return { container, save, upsert }
+}
+
+describe('channel_resend env preset', () => {
+  const originalEnv = process.env
+
+  beforeEach(() => {
+    process.env = {
+      ...originalEnv,
+      RESEND_API_KEY: 're_test',
+      EMAIL_FROM: 'from@example.com',
+    }
+    mockedFindOneWithDecryption.mockReset()
+  })
+
+  afterEach(() => {
+    process.env = originalEnv
+  })
+
+  it('creates a tenant-scoped credential row and system channel', async () => {
+    mockedFindOneWithDecryption.mockResolvedValue(null)
+    const channel = { id: 'channel-1' }
+    const flush = jest.fn().mockResolvedValue(undefined)
+    const persist = jest.fn().mockReturnValue({ flush })
+    const em = { create: jest.fn().mockReturnValue(channel), persist }
+    const { container, save } = createContainer()
+
+    await applyResendEnvPreset({
+      em: em as never,
+      container,
+      tenantId: 'tenant-1',
+      organizationId: 'organization-1',
+    })
+
+    expect(save).toHaveBeenCalledWith(
+      'channel_resend',
+      { apiKey: 're_test', fromAddress: 'from@example.com' },
+      { tenantId: 'tenant-1', organizationId: 'organization-1', userId: null },
+    )
+    expect(em.create).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({
+      tenantId: 'tenant-1',
+      organizationId: 'organization-1',
+      userId: null,
+      providerKey: 'resend',
+    }))
+    expect(persist).toHaveBeenCalledWith(channel)
+  })
+
+  it('enables the integration state so Integrations does not read Disabled while email is live', async () => {
+    mockedFindOneWithDecryption.mockResolvedValue(null)
+    const flush = jest.fn().mockResolvedValue(undefined)
+    const em = { create: jest.fn().mockReturnValue({ id: 'channel-1' }), persist: jest.fn().mockReturnValue({ flush }) }
+    const { container, upsert } = createContainer()
+
+    await applyResendEnvPreset({
+      em: em as never,
+      container,
+      tenantId: 'tenant-1',
+      organizationId: 'organization-1',
+    })
+
+    expect(upsert).toHaveBeenCalledWith(
+      'channel_resend',
+      { isEnabled: true },
+      { tenantId: 'tenant-1', organizationId: 'organization-1' },
+    )
+  })
+
+  it('still seeds the system channel when the integration state cannot be written', async () => {
+    mockedFindOneWithDecryption.mockResolvedValue(null)
+    const channel = { id: 'channel-1' }
+    const flush = jest.fn().mockResolvedValue(undefined)
+    const persist = jest.fn().mockReturnValue({ flush })
+    const em = { create: jest.fn().mockReturnValue(channel), persist }
+    const { container } = createContainer({ upsert: jest.fn().mockRejectedValue(new Error('connection terminated')) })
+
+    await expect(applyResendEnvPreset({
+      em: em as never,
+      container,
+      tenantId: 'tenant-1',
+      organizationId: 'organization-1',
+    })).resolves.toBeUndefined()
+
+    expect(persist).toHaveBeenCalledWith(channel)
+  })
+
+  it('reactivates the exactly scoped existing system channel', async () => {
+    const existing = { isActive: false, status: 'error', lastError: 'failed' }
+    mockedFindOneWithDecryption.mockResolvedValue(existing as never)
+    const flush = jest.fn().mockResolvedValue(undefined)
+    const em = { flush }
+
+    await applyResendEnvPreset({
+      em: em as never,
+      container: createContainer().container,
+      tenantId: 'tenant-1',
+      organizationId: 'organization-1',
+    })
+
+    expect(mockedFindOneWithDecryption).toHaveBeenCalledWith(
+      em,
+      expect.anything(),
+      expect.objectContaining({ tenantId: 'tenant-1', organizationId: 'organization-1', userId: null }),
+      undefined,
+      { tenantId: 'tenant-1', organizationId: 'organization-1' },
+    )
+    expect(existing).toEqual(expect.objectContaining({ isActive: true, status: 'connected', lastError: null }))
+    expect(flush).toHaveBeenCalledTimes(1)
+  })
+
+  it('still completes tenant seeding when the channel row cannot be written', async () => {
+    mockedFindOneWithDecryption.mockRejectedValue(new Error('connection terminated'))
+    const { container, save } = createContainer()
+
+    await expect(applyResendEnvPreset({
+      em: { flush: jest.fn() } as never,
+      container,
+      tenantId: 'tenant-1',
+      organizationId: 'organization-1',
+    })).resolves.toBeUndefined()
+
+    expect(save).toHaveBeenCalledTimes(1)
+  })
+
+  it('requires both an API key and sender address', () => {
+    delete process.env.RESEND_API_KEY
+    expect(readResendEnvPreset()).toBeNull()
+  })
+
+  it('still seeds when no provider is selected, because Resend is the documented default', async () => {
+    delete process.env.SYSTEM_EMAIL_PROVIDER
+    mockedFindOneWithDecryption.mockResolvedValue(null)
+    const flush = jest.fn().mockResolvedValue(undefined)
+    const em = { create: jest.fn().mockReturnValue({ id: 'channel-1' }), persist: jest.fn().mockReturnValue({ flush }) }
+    const { container, save } = createContainer()
+
+    await applyResendEnvPreset({
+      em: em as never,
+      container,
+      tenantId: 'tenant-1',
+      organizationId: 'organization-1',
+    })
+
+    expect(save).toHaveBeenCalledTimes(1)
+  })
+
+  it('seeds nothing when SES is the selected provider, even with a leftover RESEND_API_KEY', async () => {
+    process.env.SYSTEM_EMAIL_PROVIDER = 'ses'
+    const em = { create: jest.fn(), persist: jest.fn(), flush: jest.fn() }
+    const { container, save, upsert } = createContainer()
+
+    await applyResendEnvPreset({
+      em: em as never,
+      container,
+      tenantId: 'tenant-1',
+      organizationId: 'organization-1',
+    })
+
+    expect(save).not.toHaveBeenCalled()
+    expect(upsert).not.toHaveBeenCalled()
+    expect(em.create).not.toHaveBeenCalled()
+    expect(mockedFindOneWithDecryption).not.toHaveBeenCalled()
+  })
+})

package/src/modules/channel_resend/lib/adapter.ts

@@ -0,0 +1,139 @@
+import { Resend } from 'resend'
+import type {
+  ChannelAdapter,
+  ChannelNativeContent,
+  ConvertOutboundInput,
+  GetMessageStatusInput,
+  InboundMessage,
+  MessageStatus,
+  NormalizedInboundMessage,
+  SendMessageInput,
+  SendMessageResult,
+  VerifyWebhookInput,
+} from '@open-mercato/core/modules/communication_channels/lib/adapter'
+import {
+  htmlToText,
+  sanitizeHeaderValue,
+  stringOrUndefined,
+  toAddressList,
+} from '@open-mercato/core/modules/communication_channels/lib/email-mime'
+import { resendCapabilities } from '../capabilities'
+import { resendCredentialsSchema } from './credentials'
+
+type ResendAttachment = {
+  filename: string
+  content: string
+  contentType?: string
+}
+
+type ResendSendResult = {
+  data?: { id?: string | null } | null
+  error?: unknown
+}
+
+function resolveResendErrorMessage(result: unknown): string | null {
+  const value = result as ResendSendResult
+  if (typeof value.error === 'string') return value.error
+  if (value.error && typeof value.error === 'object' && 'message' in value.error) {
+    const message = (value.error as { message?: unknown }).message
+    return typeof message === 'string' ? message : null
+  }
+  return null
+}
+
+function attachmentsFromMeta(value: unknown): ResendAttachment[] | undefined {
+  if (!Array.isArray(value)) return undefined
+  const attachments = value.flatMap((item): ResendAttachment[] => {
+    if (!item || typeof item !== 'object') return []
+    const record = item as Record<string, unknown>
+    const filename = stringOrUndefined(record.filename)
+    const content = stringOrUndefined(record.content)
+    if (!filename || !content) return []
+    const contentType = stringOrUndefined(record.contentType)
+    return [{ filename, content, ...(contentType ? { contentType } : {}) }]
+  })
+  return attachments.length ? attachments : undefined
+}
+
+class ResendChannelAdapter implements ChannelAdapter {
+  readonly providerKey = 'resend'
+  readonly channelType = 'email'
+  readonly capabilities = resendCapabilities
+
+  async sendMessage(input: SendMessageInput): Promise<SendMessageResult> {
+    const credentials = resendCredentialsSchema.parse(input.credentials)
+    const meta = (input.metadata ?? {}) as Record<string, unknown>
+    const to = Array.isArray(meta.to) ? (meta.to as string[]) : []
+    if (to.length === 0) {
+      return { externalMessageId: '', status: 'failed', error: '[internal] Email send requires at least one recipient' }
+    }
+    const subject = stringOrUndefined(meta.subject)
+    if (!subject) {
+      return { externalMessageId: '', status: 'failed', error: '[internal] Email send requires a subject' }
+    }
+
+    const client = new Resend(credentials.apiKey)
+    const resendAttachments = attachmentsFromMeta(meta.attachments)
+    const basePayload = {
+      from: stringOrUndefined(meta.from) ?? credentials.fromAddress,
+      to,
+      subject,
+      ...(stringOrUndefined(meta.replyTo) ? { replyTo: stringOrUndefined(meta.replyTo) } : {}),
+      ...(resendAttachments?.length ? { attachments: resendAttachments } : {}),
+    }
+    const payload: Parameters<typeof client.emails.send>[0] = input.content.html
+      ? { ...basePayload, html: input.content.html, ...(input.content.text ? { text: input.content.text } : {}) }
+      : { ...basePayload, text: input.content.text ?? '' }
+    const result = await client.emails.send(payload)
+    const errorMessage = resolveResendErrorMessage(result)
+    if (errorMessage) {
+      return { externalMessageId: '', status: 'failed', error: `RESEND_SEND_FAILED: ${errorMessage}` }
+    }
+    const sentId = (result as ResendSendResult).data?.id
+    return {
+      externalMessageId: sentId || `resend:${Date.now()}`,
+      conversationId: input.conversationId,
+      status: 'sent',
+    }
+  }
+
+  async verifyWebhook(_input: VerifyWebhookInput): Promise<InboundMessage> {
+    return { raw: {}, eventType: 'other', metadata: { reason: 'resend-system-email-outbound-only' } }
+  }
+
+  async getStatus(_input: GetMessageStatusInput): Promise<MessageStatus> {
+    return { status: 'sent' }
+  }
+
+  async normalizeInbound(_raw: InboundMessage): Promise<NormalizedInboundMessage> {
+    throw new Error('[internal] Resend system email adapter is outbound-only')
+  }
+
+  async convertOutbound(input: ConvertOutboundInput): Promise<ChannelNativeContent> {
+    const meta = (input.channelMetadata ?? {}) as Record<string, unknown>
+    const to = toAddressList(meta.to).map(sanitizeHeaderValue)
+    const subject = stringOrUndefined(meta.subject)
+    const html = input.bodyFormat === 'html' ? input.body : undefined
+    const text = input.bodyFormat === 'html' ? htmlToText(input.body) : input.body
+    return {
+      content: {
+        text,
+        html,
+        bodyFormat: input.bodyFormat,
+      },
+      metadata: {
+        to,
+        subject,
+        from: stringOrUndefined(meta.from),
+        replyTo: stringOrUndefined(meta.replyTo),
+        attachments: attachmentsFromMeta(meta.attachments),
+      },
+    }
+  }
+}
+
+const adapter = new ResendChannelAdapter()
+
+export function getResendChannelAdapter(): ChannelAdapter {
+  return adapter
+}

package/src/modules/channel_resend/lib/credentials.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod'
+
+export const resendCredentialsSchema = z.object({
+  apiKey: z.string().min(1),
+  fromAddress: z.string().email(),
+})
+
+export type ResendCredentials = z.infer<typeof resendCredentialsSchema>