wehub-resource-sync
429 lines
15 KiB
TypeScript
429 lines
15 KiB
TypeScript
import * as sdk from '@botpress/sdk'
|
|
import { Buffer } from 'node:buffer'
|
|
import { timingSafeEqual } from 'node:crypto'
|
|
import * as pm from 'postmark'
|
|
import { type Attachment, postmarkInboundWebhookSchema } from './inbound-webhook'
|
|
import { messages, textToHtml } from './messages'
|
|
import { formatRecipients, generateRfcMessageId, send } from './send-email'
|
|
import * as bp from '.botpress'
|
|
|
|
const MAX_INBOUND_ATTACHMENT_SIZE = 10 * 1024 * 1024 // 10MB — matches outbound cap
|
|
|
|
const getMessageType = (contentType: string): 'image' | 'audio' | 'video' | 'file' => {
|
|
if (contentType.startsWith('image/')) {
|
|
return 'image'
|
|
}
|
|
if (contentType.startsWith('audio/')) {
|
|
return 'audio'
|
|
}
|
|
if (contentType.startsWith('video/')) {
|
|
return 'video'
|
|
}
|
|
return 'file'
|
|
}
|
|
|
|
const sanitizeFilename = (name: string): string => name.replace(/[^\w.\-]/g, '_').slice(0, 120) || 'attachment'
|
|
|
|
const extractParentHeaders = (
|
|
references: string | undefined,
|
|
inReplyTo: string | undefined
|
|
): { root?: string; parent?: string } => {
|
|
if (references) {
|
|
const first = references.trim().split(/\s+/)[0]?.replace(/[<>]/g, '')
|
|
if (first) {
|
|
return { root: first }
|
|
}
|
|
}
|
|
if (inReplyTo) {
|
|
const parent = inReplyTo.trim().replace(/[<>]/g, '')
|
|
if (parent) {
|
|
return { parent }
|
|
}
|
|
}
|
|
return {}
|
|
}
|
|
|
|
const extractThreadRoot = (headers: Array<{ Name: string; Value: string }>, fallbackId: string): string => {
|
|
const { root, parent } = extractParentHeaders(
|
|
headers.find((h) => h.Name === 'References')?.Value,
|
|
headers.find((h) => h.Name === 'In-Reply-To')?.Value
|
|
)
|
|
return root ?? parent ?? fallbackId
|
|
}
|
|
|
|
const extractMessageIdHeader = (headers: Array<{ Name: string; Value: string }>): string | undefined => {
|
|
const raw = headers.find((h) => h.Name.toLowerCase() === 'message-id')?.Value
|
|
const trimmed = raw?.trim().replace(/^<|>$/g, '')
|
|
return trimmed || undefined
|
|
}
|
|
|
|
type ConversationInformation = NonNullable<
|
|
bp.actions.getOrCreateReplyThreadConversation.input.Input['conversation']['conversationInformation']
|
|
>
|
|
|
|
const findConversationByThreadRoot = async (bpClient: bp.Client, threadRootMessageId: string) => {
|
|
const { conversations } = await bpClient.listConversations({ tags: { threadRootMessageId } })
|
|
return conversations[0]
|
|
}
|
|
|
|
const findConversationByMessageId = async (bpClient: bp.Client, emailMessageId: string) => {
|
|
const { messages } = await bpClient.listMessages({ tags: { emailMessageId } })
|
|
const match = messages[0]
|
|
if (!match) return undefined
|
|
const { conversation } = await bpClient.getConversation({ id: match.conversationId })
|
|
return conversation
|
|
}
|
|
|
|
const resolveExistingConversation = async (bpClient: bp.Client, info: ConversationInformation | undefined) => {
|
|
if (!info) return undefined
|
|
if (info.rootEmailId) {
|
|
return findConversationByThreadRoot(bpClient, info.rootEmailId)
|
|
}
|
|
if (info.lastEmailId) {
|
|
const byRoot = await findConversationByThreadRoot(bpClient, info.lastEmailId)
|
|
if (byRoot) return byRoot
|
|
return findConversationByMessageId(bpClient, info.lastEmailId)
|
|
}
|
|
return undefined
|
|
}
|
|
|
|
const uploadAttachment = async (attachment: Attachment, emailMessageId: string, index: number, client: bp.Client) => {
|
|
const buffer = Buffer.from(attachment.Content, 'base64')
|
|
if (buffer.byteLength > MAX_INBOUND_ATTACHMENT_SIZE) {
|
|
throw new sdk.RuntimeError(
|
|
`Inbound attachment "${attachment.Name}" exceeds maximum size of ${MAX_INBOUND_ATTACHMENT_SIZE} bytes`
|
|
)
|
|
}
|
|
|
|
const { file } = await client.upsertFile({
|
|
key: `postmark-attachment_${emailMessageId}_${index}_${sanitizeFilename(attachment.Name)}`,
|
|
contentType: attachment.ContentType,
|
|
size: buffer.byteLength,
|
|
accessPolicies: ['public_content'],
|
|
publicContentImmediatelyAccessible: true,
|
|
tags: {
|
|
source: 'integration',
|
|
integration: 'postmark',
|
|
channel: 'mail',
|
|
},
|
|
})
|
|
|
|
const uploadResponse = await fetch(file.uploadUrl, {
|
|
method: 'PUT',
|
|
body: buffer,
|
|
headers: {
|
|
'Content-Type': attachment.ContentType,
|
|
'Content-Length': String(buffer.byteLength),
|
|
'x-amz-tagging': 'public=true',
|
|
},
|
|
})
|
|
|
|
if (!uploadResponse.ok) {
|
|
throw new sdk.RuntimeError(
|
|
`Failed to upload attachment "${attachment.Name}" to storage: ${uploadResponse.status} ${uploadResponse.statusText}`
|
|
)
|
|
}
|
|
|
|
return file.url
|
|
}
|
|
|
|
export default new bp.Integration({
|
|
register: async ({ ctx, webhookUrl }) => {
|
|
const client = new pm.ServerClient(ctx.configuration.serverToken)
|
|
|
|
const server = await client.getServer().catch((thrown) => {
|
|
const statusCode = (thrown as { statusCode?: number } | null)?.statusCode
|
|
if (statusCode === 401 || statusCode === 403) {
|
|
throw new sdk.RuntimeError('Invalid Postmark Server Token. Please check your configuration.')
|
|
}
|
|
const errorMessage = thrown instanceof Error ? thrown.message : String(thrown)
|
|
throw new sdk.RuntimeError(`Failed to verify Postmark Server Token: ${errorMessage}`)
|
|
})
|
|
|
|
const InboundHookUrl = ctx.configuration.webhookSecret
|
|
? `${webhookUrl}?secret=${encodeURIComponent(ctx.configuration.webhookSecret)}`
|
|
: webhookUrl
|
|
|
|
if (server.InboundHookUrl && !server.InboundHookUrl.startsWith(webhookUrl)) {
|
|
const displayUrl = server.InboundHookUrl.split('?')[0]
|
|
throw new sdk.RuntimeError(
|
|
`Postmark server already has an Inbound Hook URL set to "${displayUrl}". Clear it in the Postmark dashboard before installing this integration.`
|
|
)
|
|
}
|
|
|
|
if (server.InboundHookUrl === InboundHookUrl) {
|
|
return
|
|
}
|
|
|
|
await client
|
|
.editServer({
|
|
InboundHookUrl,
|
|
})
|
|
.catch((thrown) => {
|
|
const errorMessage = thrown instanceof Error ? thrown.message : String(thrown)
|
|
throw new sdk.RuntimeError(`Failed to set Postmark Inbound Hook URL: ${errorMessage}`)
|
|
})
|
|
},
|
|
unregister: async ({ ctx, webhookUrl }) => {
|
|
const finalUrl = ctx.configuration.webhookSecret
|
|
? `${webhookUrl}?secret=${encodeURIComponent(ctx.configuration.webhookSecret)}`
|
|
: webhookUrl
|
|
const client = new pm.ServerClient(ctx.configuration.serverToken)
|
|
try {
|
|
const { InboundHookUrl } = await client.getServer()
|
|
if (InboundHookUrl === finalUrl) {
|
|
await client.editServer({ InboundHookUrl: '' })
|
|
}
|
|
} catch (thrown) {
|
|
const errorMessage = thrown instanceof Error ? thrown.message : String(thrown)
|
|
throw new sdk.RuntimeError(`Failed to clear Postmark Inbound Hook URL: ${errorMessage}`)
|
|
}
|
|
},
|
|
actions: {
|
|
sendEmail: async (props) => {
|
|
const { client: bpClient, ctx, logger, input } = props
|
|
const { userEmailAddress, userName, cc, bcc, subject, text, conversationInformation } = input
|
|
|
|
const subjectLine = subject || '(No subject)'
|
|
const pmClient = new pm.ServerClient(ctx.configuration.serverToken)
|
|
|
|
await bpClient.getOrCreateUser({
|
|
name: userName || userEmailAddress,
|
|
tags: { emailAddress: userEmailAddress },
|
|
discriminateByTags: ['emailAddress'],
|
|
})
|
|
|
|
const { id: conversationId, messageId } = await (async () => {
|
|
const existing = await resolveExistingConversation(bpClient, conversationInformation)
|
|
|
|
if (existing) {
|
|
logger.forBotOnly().debug(`Resolved existing reply thread conversation "${existing.id}"`)
|
|
const id = await send({
|
|
configuration: ctx.configuration,
|
|
conversation: {
|
|
id: existing.id,
|
|
tags: {
|
|
postmarkEmailAddress: existing.tags.postmarkEmailAddress,
|
|
userEmailAddress: existing.tags.userEmailAddress,
|
|
},
|
|
},
|
|
client: bpClient,
|
|
input: { Subject: subjectLine, TextBody: text, HtmlBody: textToHtml(text), Cc: cc, Bcc: bcc },
|
|
})
|
|
return { id: existing.id, messageId: id }
|
|
}
|
|
|
|
if (conversationInformation?.rootEmailId || conversationInformation?.lastEmailId) {
|
|
throw new sdk.RuntimeError(
|
|
`No Botpress conversation found for thread root "${conversationInformation.rootEmailId ?? conversationInformation.lastEmailId}"`
|
|
)
|
|
}
|
|
|
|
logger.forBotOnly().debug(`Opening a new reply thread with user email "${userEmailAddress}"`)
|
|
const threadRootMessageId = generateRfcMessageId(ctx.configuration.fromEmail)
|
|
await pmClient
|
|
.sendEmail({
|
|
From: ctx.configuration.fromEmail,
|
|
To: userEmailAddress,
|
|
Cc: formatRecipients(cc),
|
|
Bcc: formatRecipients(bcc),
|
|
Subject: subjectLine,
|
|
TextBody: text,
|
|
HtmlBody: textToHtml(text),
|
|
Headers: [{ Name: 'Message-ID', Value: `<${threadRootMessageId}>` }],
|
|
})
|
|
.catch((thrown) => {
|
|
if (thrown instanceof sdk.RuntimeError) throw thrown
|
|
throw new sdk.RuntimeError(
|
|
`Failed to send email via Postmark: ${thrown instanceof Error ? thrown.message : String(thrown)}`
|
|
)
|
|
})
|
|
|
|
const { conversation } = await bpClient.getOrCreateConversation({
|
|
channel: 'mail',
|
|
tags: {
|
|
threadRootMessageId,
|
|
postmarkEmailAddress: ctx.configuration.fromEmail,
|
|
userEmailAddress,
|
|
},
|
|
discriminateByTags: ['threadRootMessageId'],
|
|
})
|
|
return { id: conversation.id, messageId: threadRootMessageId }
|
|
})()
|
|
|
|
await bpClient.getOrCreateMessage({
|
|
type: 'text',
|
|
conversationId,
|
|
userId: ctx.botId,
|
|
origin: 'synthetic',
|
|
tags: {
|
|
id: messageId,
|
|
emailMessageId: messageId,
|
|
subject: subjectLine,
|
|
cc: formatRecipients(cc) ?? '',
|
|
bcc: formatRecipients(bcc) ?? '',
|
|
},
|
|
payload: { text, subject: subjectLine },
|
|
discriminateByTags: ['id'],
|
|
})
|
|
logger.forBotOnly().debug(`Sent email message "${messageId}" in conversation "${conversationId}"`)
|
|
return { conversationId }
|
|
},
|
|
getOrCreateReplyThreadConversation: async (props) => {
|
|
const { client: bpClient, logger, input } = props
|
|
const { conversationInformation } = input.conversation
|
|
|
|
const conversation = await resolveExistingConversation(bpClient, conversationInformation)
|
|
if (!conversation) {
|
|
throw new sdk.RuntimeError('No existing conversation found for the provided conversation information')
|
|
}
|
|
|
|
logger.forBotOnly().debug(`Resolved existing reply thread conversation "${conversation.id}"`)
|
|
return { conversationId: conversation.id }
|
|
},
|
|
getOrCreateUser: async (props) => {
|
|
const { client: bpClient, logger, input } = props
|
|
const { name, email } = input
|
|
if (!email || email.trim() === '') {
|
|
throw new sdk.RuntimeError('Email address is required to get or create a user')
|
|
}
|
|
|
|
const { user } = await bpClient.getOrCreateUser({
|
|
name: name || email,
|
|
tags: { emailAddress: email },
|
|
discriminateByTags: ['emailAddress'],
|
|
})
|
|
|
|
logger.forBotOnly().debug(`Resolved user with email "${email}" to user ID "${user.id}"`)
|
|
return { userId: user.id }
|
|
},
|
|
},
|
|
channels: {
|
|
mail: { messages },
|
|
},
|
|
handler: async (props) => {
|
|
const { client, ctx, logger, req } = props
|
|
|
|
if (ctx.configuration.webhookSecret) {
|
|
const queryParams = new URLSearchParams(req.query)
|
|
const provided = Buffer.from(queryParams.get('secret') || '', 'utf8')
|
|
const expected = Buffer.from(ctx.configuration.webhookSecret, 'utf8')
|
|
if (provided.byteLength !== expected.byteLength || !timingSafeEqual(provided, expected)) {
|
|
return { status: 401, body: 'Unauthorized' }
|
|
}
|
|
}
|
|
|
|
if (!req.body) {
|
|
return { status: 400, body: 'No body found in the request' }
|
|
}
|
|
|
|
let parsedBody: unknown
|
|
try {
|
|
parsedBody = JSON.parse(req.body)
|
|
} catch {
|
|
logger.forBot().error('Failed to parse request body as JSON')
|
|
return { status: 400, body: 'Invalid JSON payload' }
|
|
}
|
|
|
|
const parseResult = postmarkInboundWebhookSchema.safeParse(parsedBody)
|
|
if (!parseResult.success) {
|
|
logger
|
|
.forBot()
|
|
.error(
|
|
`Failed to parse Postmark webhook payload: ${parseResult.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join('; ')}`
|
|
)
|
|
return { status: 400, body: 'Invalid payload' }
|
|
}
|
|
|
|
const email = parseResult.data
|
|
|
|
const { user } = await client.getOrCreateUser({
|
|
name: email.FromName || email.From,
|
|
tags: {
|
|
emailAddress: email.From,
|
|
},
|
|
discriminateByTags: ['emailAddress'],
|
|
})
|
|
|
|
for (const recipient of [...email.ToFull, ...email.CcFull, ...email.BccFull]) {
|
|
await client.getOrCreateUser({
|
|
name: recipient.Name || recipient.Email,
|
|
tags: {
|
|
emailAddress: recipient.Email,
|
|
},
|
|
discriminateByTags: ['emailAddress'],
|
|
})
|
|
}
|
|
|
|
const rfcMessageId = extractMessageIdHeader(email.Headers) ?? email.MessageID
|
|
const threadRootMessageId = extractThreadRoot(email.Headers, rfcMessageId)
|
|
|
|
const { conversation } = await client.getOrCreateConversation({
|
|
channel: 'mail',
|
|
tags: {
|
|
threadRootMessageId,
|
|
postmarkEmailAddress: email.To,
|
|
userEmailAddress: email.From,
|
|
},
|
|
discriminateByTags: ['threadRootMessageId'],
|
|
})
|
|
|
|
await client.getOrCreateMessage({
|
|
type: 'text',
|
|
conversationId: conversation.id,
|
|
tags: {
|
|
id: rfcMessageId,
|
|
emailMessageId: rfcMessageId,
|
|
bcc: email.Bcc,
|
|
cc: email.Cc,
|
|
subject: email.Subject,
|
|
spamScore: email.Headers.find((h) => h.Name.toLowerCase() === 'x-spam-score')?.Value || '',
|
|
},
|
|
userId: user.id,
|
|
payload: {
|
|
text: email.TextBody.length > 0 ? email.TextBody : email.HtmlBody,
|
|
subject: email.Subject,
|
|
},
|
|
discriminateByTags: ['id'],
|
|
})
|
|
|
|
await Promise.all(
|
|
email.Attachments.map(async (attachment, index) => {
|
|
try {
|
|
const fileUrl = await uploadAttachment(attachment, email.MessageID, index, client)
|
|
const messageType = getMessageType(attachment.ContentType)
|
|
|
|
const payload =
|
|
messageType === 'image'
|
|
? { imageUrl: fileUrl }
|
|
: messageType === 'audio'
|
|
? { audioUrl: fileUrl }
|
|
: messageType === 'video'
|
|
? { videoUrl: fileUrl }
|
|
: { fileUrl, filename: attachment.Name }
|
|
|
|
await client.getOrCreateMessage({
|
|
type: messageType,
|
|
conversationId: conversation.id,
|
|
tags: {
|
|
id: `${rfcMessageId}_attachment_${index}`,
|
|
subject: email.Subject,
|
|
cc: email.Cc,
|
|
bcc: email.Bcc,
|
|
spamScore: email.Headers.find((h) => h.Name.toLowerCase() === 'x-spam-score')?.Value || '',
|
|
},
|
|
userId: user.id,
|
|
payload,
|
|
discriminateByTags: ['id'],
|
|
})
|
|
} catch (error) {
|
|
const message = error instanceof Error ? error.message : String(error)
|
|
logger.forBot().warn(`Failed to process inbound attachment "${attachment.Name}": ${message}`)
|
|
}
|
|
})
|
|
)
|
|
|
|
return { status: 200, body: 'OK' }
|
|
},
|
|
})
|