@wraps.dev/cli 2.2.6 → 2.2.8

package/dist/lambda/event-processor/.bundled

@@ -0,0 +1 @@
+Built at: 2026-01-16T21:29:27.587Z

package/dist/lambda/event-processor/index.mjs

@@ -0,0 +1 @@
+import{randomUUID as w}from"node:crypto";import{DynamoDBClient as k,PutItemCommand as I}from"@aws-sdk/client-dynamodb";var A=new k({});async function E(m,y){let l=y.awsRequestId,d=w().slice(0,8),a=(s,o)=>{console.log(JSON.stringify({requestId:l,batchId:d,msg:s,...o}))},T=(s,o,e)=>{console.error(JSON.stringify({requestId:l,batchId:d,msg:s,error:String(o),...e}))};a("Processing SES batch",{recordCount:m.Records.length});let u=process.env.TABLE_NAME;if(!u)throw new Error("TABLE_NAME environment variable not set");let g=Number.parseInt(process.env.RETENTION_DAYS||"90",10);for(let s of m.Records)try{let e=JSON.parse(s.body).detail,t=e.eventType||e.notificationType,r=e.mail,p=r.messageId,f=new Date(r.timestamp).getTime(),S=r.source,b=r.destination||[],v=r.commonHeaders?.subject||"";a("Processing email event",{messageId:p,eventType:t,recipientCount:b.length});let n={},i=f;if(t==="Send"&&e.send)n={tags:r.tags||{}};else if(t==="Delivery"&&e.delivery)i=new Date(e.delivery.timestamp).getTime(),n={timestamp:e.delivery.timestamp,processingTimeMillis:e.delivery.processingTimeMillis,recipients:e.delivery.recipients,smtpResponse:e.delivery.smtpResponse,remoteMtaIp:e.delivery.remoteMtaIp};else if(t==="Open"&&e.open)i=new Date(e.open.timestamp).getTime(),n={timestamp:e.open.timestamp,userAgent:e.open.userAgent,ipAddress:e.open.ipAddress};else if(t==="Click"&&e.click)i=new Date(e.click.timestamp).getTime(),n={timestamp:e.click.timestamp,link:e.click.link,linkTags:e.click.linkTags||{},userAgent:e.click.userAgent,ipAddress:e.click.ipAddress};else if(t==="Bounce"&&e.bounce){let c=e.bounce.bounceSubType;c==="Suppressed"||c==="OnAccountSuppressionList"?(t="Suppressed",i=new Date(e.bounce.timestamp).getTime(),n={reason:c,suppressedRecipients:e.bounce.bouncedRecipients,timestamp:e.bounce.timestamp,feedbackId:e.bounce.feedbackId}):(i=new Date(e.bounce.timestamp).getTime(),n={bounceType:e.bounce.bounceType,bounceSubType:e.bounce.bounceSubType,bouncedRecipients:e.bounce.bouncedRecipients,timestamp:e.bounce.timestamp,feedbackId:e.bounce.feedbackId})}else t==="Complaint"&&e.complaint?(i=new Date(e.complaint.timestamp).getTime(),n={complainedRecipients:e.complaint.complainedRecipients,timestamp:e.complaint.timestamp,feedbackId:e.complaint.feedbackId,complaintFeedbackType:e.complaint.complaintFeedbackType,userAgent:e.complaint.userAgent}):t==="Reject"&&e.reject?n={reason:e.reject.reason}:t==="Rendering Failure"&&e.failure?n={errorMessage:e.failure.errorMessage,templateName:e.failure.templateName}:t==="DeliveryDelay"&&e.deliveryDelay?(i=new Date(e.deliveryDelay.timestamp).getTime(),n={timestamp:e.deliveryDelay.timestamp,delayType:e.deliveryDelay.delayType,expirationTime:e.deliveryDelay.expirationTime,delayedRecipients:e.deliveryDelay.delayedRecipients}):t==="Subscription"&&e.subscription&&(i=new Date(e.subscription.timestamp).getTime(),n={contactList:e.subscription.contactList,timestamp:e.subscription.timestamp,source:e.subscription.source,newTopicPreferences:e.subscription.newTopicPreferences,oldTopicPreferences:e.subscription.oldTopicPreferences});let D=g>0?Date.now()+g*24*60*60*1e3:Date.now()+365*24*60*60*1e3;await A.send(new I({TableName:u,Item:{messageId:{S:p},sentAt:{N:i.toString()},accountId:{S:process.env.AWS_ACCOUNT_ID||"unknown"},from:{S},to:{L:b.map(c=>({S:c}))},subject:{S:v},eventType:{S:t},eventData:{S:JSON.stringify(e)},additionalData:{S:JSON.stringify(n)},createdAt:{N:Date.now().toString()},expiresAt:{N:D.toString()}}})),a("Stored event",{eventType:t,messageId:p})}catch(o){T("Error processing record",o,{sqsMessageId:s.messageId})}return{statusCode:200,body:JSON.stringify({message:"Events processed successfully"})}}export{E as handler};

package/dist/lambda/event-processor/index.ts

@@ -0,0 +1,214 @@
+import { randomUUID } from "node:crypto";
+import { DynamoDBClient, PutItemCommand } from "@aws-sdk/client-dynamodb";
+import type { Context, SQSEvent } from "aws-lambda";
+
+const dynamodb = new DynamoDBClient({});
+
+/**
+ * Lambda handler for processing SES events from SQS (via EventBridge)
+ * Stores all SES events in DynamoDB:
+ * - Send: Email sent from SES
+ * - Delivery: Email delivered to recipient
+ * - Open: Email opened by recipient
+ * - Click: Link clicked in email
+ * - Bounce: Email bounced (permanent or transient)
+ * - Suppressed: Email blocked due to recipient on suppression list
+ * - Complaint: Recipient marked email as spam
+ * - Reject: Email rejected before sending
+ * - Rendering Failure: Template rendering failed
+ * - DeliveryDelay: Temporary delivery delay
+ * - Subscription: Recipient unsubscribed/changed preferences
+ */
+export async function handler(event: SQSEvent, context: Context) {
+  const requestId = context.awsRequestId;
+  const batchId = randomUUID().slice(0, 8);
+
+  const log = (msg: string, data?: Record<string, unknown>) => {
+    console.log(JSON.stringify({ requestId, batchId, msg, ...data }));
+  };
+  const logError = (
+    msg: string,
+    error: unknown,
+    data?: Record<string, unknown>
+  ) => {
+    console.error(
+      JSON.stringify({ requestId, batchId, msg, error: String(error), ...data })
+    );
+  };
+
+  log("Processing SES batch", { recordCount: event.Records.length });
+
+  const tableName = process.env.TABLE_NAME;
+  if (!tableName) {
+    throw new Error("TABLE_NAME environment variable not set");
+  }
+
+  // Get retention days from environment, default to 90
+  const retentionDays = Number.parseInt(process.env.RETENTION_DAYS || "90", 10);
+
+  for (const record of event.Records) {
+    try {
+      // Parse the SQS message body (which contains the EventBridge event)
+      const eventBridgeEvent = JSON.parse(record.body);
+
+      // The actual SES event is in the 'detail' field of the EventBridge event
+      const message = eventBridgeEvent.detail;
+      let eventType = message.eventType || message.notificationType;
+
+      // Extract email details
+      const mail = message.mail;
+      const messageId = mail.messageId;
+      const mailTimestamp = new Date(mail.timestamp).getTime();
+      const from = mail.source;
+      const to = mail.destination || [];
+      const subject = mail.commonHeaders?.subject || "";
+
+      log("Processing email event", {
+        messageId,
+        eventType,
+        recipientCount: to.length,
+      });
+
+      // Extract additional data and event-specific timestamp based on event type
+      let additionalData: Record<string, unknown> = {};
+      let eventTimestamp = mailTimestamp; // Default to mail timestamp
+
+      if (eventType === "Send" && message.send) {
+        // Send event uses mail timestamp
+        additionalData = {
+          tags: mail.tags || {},
+        };
+      } else if (eventType === "Delivery" && message.delivery) {
+        eventTimestamp = new Date(message.delivery.timestamp).getTime();
+        additionalData = {
+          timestamp: message.delivery.timestamp,
+          processingTimeMillis: message.delivery.processingTimeMillis,
+          recipients: message.delivery.recipients,
+          smtpResponse: message.delivery.smtpResponse,
+          remoteMtaIp: message.delivery.remoteMtaIp,
+        };
+      } else if (eventType === "Open" && message.open) {
+        eventTimestamp = new Date(message.open.timestamp).getTime();
+        additionalData = {
+          timestamp: message.open.timestamp,
+          userAgent: message.open.userAgent,
+          ipAddress: message.open.ipAddress,
+        };
+      } else if (eventType === "Click" && message.click) {
+        eventTimestamp = new Date(message.click.timestamp).getTime();
+        additionalData = {
+          timestamp: message.click.timestamp,
+          link: message.click.link,
+          linkTags: message.click.linkTags || {},
+          userAgent: message.click.userAgent,
+          ipAddress: message.click.ipAddress,
+        };
+      } else if (eventType === "Bounce" && message.bounce) {
+        const bounceSubType = message.bounce.bounceSubType;
+
+        // Treat suppression as a distinct event type, not a bounce
+        // SES sends suppressions as bounces with bounceSubType of "Suppressed" or "OnAccountSuppressionList"
+        if (
+          bounceSubType === "Suppressed" ||
+          bounceSubType === "OnAccountSuppressionList"
+        ) {
+          eventType = "Suppressed";
+          eventTimestamp = new Date(message.bounce.timestamp).getTime();
+          additionalData = {
+            reason: bounceSubType,
+            suppressedRecipients: message.bounce.bouncedRecipients,
+            timestamp: message.bounce.timestamp,
+            feedbackId: message.bounce.feedbackId,
+          };
+        } else {
+          // Regular bounce handling
+          eventTimestamp = new Date(message.bounce.timestamp).getTime();
+          additionalData = {
+            bounceType: message.bounce.bounceType,
+            bounceSubType: message.bounce.bounceSubType,
+            bouncedRecipients: message.bounce.bouncedRecipients,
+            timestamp: message.bounce.timestamp,
+            feedbackId: message.bounce.feedbackId,
+          };
+        }
+      } else if (eventType === "Complaint" && message.complaint) {
+        eventTimestamp = new Date(message.complaint.timestamp).getTime();
+        additionalData = {
+          complainedRecipients: message.complaint.complainedRecipients,
+          timestamp: message.complaint.timestamp,
+          feedbackId: message.complaint.feedbackId,
+          complaintFeedbackType: message.complaint.complaintFeedbackType,
+          userAgent: message.complaint.userAgent,
+        };
+      } else if (eventType === "Reject" && message.reject) {
+        // Reject doesn't have a specific timestamp, use mail timestamp
+        additionalData = {
+          reason: message.reject.reason,
+        };
+      } else if (eventType === "Rendering Failure" && message.failure) {
+        // Rendering failure doesn't have a specific timestamp, use mail timestamp
+        additionalData = {
+          errorMessage: message.failure.errorMessage,
+          templateName: message.failure.templateName,
+        };
+      } else if (eventType === "DeliveryDelay" && message.deliveryDelay) {
+        eventTimestamp = new Date(message.deliveryDelay.timestamp).getTime();
+        additionalData = {
+          timestamp: message.deliveryDelay.timestamp,
+          delayType: message.deliveryDelay.delayType,
+          expirationTime: message.deliveryDelay.expirationTime,
+          delayedRecipients: message.deliveryDelay.delayedRecipients,
+        };
+      } else if (eventType === "Subscription" && message.subscription) {
+        eventTimestamp = new Date(message.subscription.timestamp).getTime();
+        additionalData = {
+          contactList: message.subscription.contactList,
+          timestamp: message.subscription.timestamp,
+          source: message.subscription.source,
+          newTopicPreferences: message.subscription.newTopicPreferences,
+          oldTopicPreferences: message.subscription.oldTopicPreferences,
+        };
+      }
+
+      // Calculate TTL based on retention days (0 or negative means no TTL)
+      const expiresAt =
+        retentionDays > 0
+          ? Date.now() + retentionDays * 24 * 60 * 60 * 1000
+          : Date.now() + 365 * 24 * 60 * 60 * 1000; // Default 1 year if not specified
+
+      // Store event in DynamoDB
+      // Use eventTimestamp as sort key to ensure each event type creates a unique record
+      // Note: DynamoDB String Sets (SS) cannot be empty, so we use a List (L) for recipients
+      await dynamodb.send(
+        new PutItemCommand({
+          TableName: tableName,
+          Item: {
+            messageId: { S: messageId },
+            sentAt: { N: eventTimestamp.toString() },
+            accountId: { S: process.env.AWS_ACCOUNT_ID || "unknown" },
+            from: { S: from },
+            to: { L: to.map((email: string) => ({ S: email })) },
+            subject: { S: subject },
+            eventType: { S: eventType },
+            eventData: { S: JSON.stringify(message) },
+            additionalData: { S: JSON.stringify(additionalData) },
+            createdAt: { N: Date.now().toString() },
+            expiresAt: { N: expiresAt.toString() },
+          },
+        })
+      );
+
+      log("Stored event", { eventType, messageId });
+    } catch (error) {
+      logError("Error processing record", error, {
+        sqsMessageId: record.messageId,
+      });
+      // Don't throw - continue processing other records
+    }
+  }
+
+  return {
+    statusCode: 200,
+    body: JSON.stringify({ message: "Events processed successfully" }),
+  };
+}

package/dist/lambda/sms-event-processor/.bundled

@@ -0,0 +1 @@
+Built at: 2026-01-16T21:29:27.591Z

package/dist/lambda/sms-event-processor/index.mjs

@@ -0,0 +1 @@
+import{DynamoDBClient as N,PutItemCommand as E}from"@aws-sdk/client-dynamodb";var u=new N({});async function v(r){console.log("Processing SMS event from SQS:",JSON.stringify(r,null,2));let a=process.env.TABLE_NAME;if(!a)throw new Error("TABLE_NAME environment variable not set");let i=Number.parseInt(process.env.RETENTION_DAYS||"90",10);for(let m of r.Records)try{let e=JSON.parse(m.body),t=e.eventType||e.messageStatus||"UNKNOWN",n=e.messageId,d=e.destinationPhoneNumber,c=e.originationPhoneNumber,o=e.messageBody||"",T=e.isoCountryCode||"US",S=e.messageType||"TRANSACTIONAL",p=e.eventTimestamp?new Date(e.eventTimestamp).getTime():Date.now();console.log("Processing SMS event:",{messageId:n,eventType:t,destinationNumber:d,originationNumber:c});let s={isoCountryCode:T,messageType:S};t==="TEXT_DELIVERED"||t==="TEXT_SUCCESSFUL"?s={...s,deliveryTimestamp:e.deliveryTimestamp,carrierName:e.carrierName,providerResponse:e.providerResponse}:t==="TEXT_FAILED"||t==="TEXT_INVALID"||t==="TEXT_CARRIER_UNREACHABLE"||t==="TEXT_BLOCKED"?s={...s,failureReason:e.failureReason||e.statusMessage,failureCode:e.failureCode||e.statusCode,providerResponse:e.providerResponse}:t==="TEXT_QUEUED"||t==="TEXT_SENT"?s={...s,queuedTimestamp:e.queuedTimestamp,sentTimestamp:e.sentTimestamp}:t==="TEXT_TTL_EXPIRED"&&(s={...s,expirationTimestamp:e.expirationTimestamp,ttlSeconds:e.ttlSeconds});let l=o?Math.ceil(o.length/160):1,g=i>0?Date.now()+i*24*60*60*1e3:Date.now()+365*24*60*60*1e3;await u.send(new E({TableName:a,Item:{messageId:{S:n},sentAt:{N:p.toString()},accountId:{S:process.env.AWS_ACCOUNT_ID||"unknown"},destinationNumber:{S:d||""},originationNumber:{S:c||""},messageBody:{S:o},eventType:{S:t},segments:{N:l.toString()},eventData:{S:JSON.stringify(e)},additionalData:{S:JSON.stringify(s)},createdAt:{N:Date.now().toString()},expiresAt:{N:g.toString()}}})),console.log(`Stored ${t} event for message ${n}`,s)}catch(e){console.error("Error processing record:",e),console.error("Record:",JSON.stringify(m,null,2))}return{statusCode:200,body:JSON.stringify({message:"SMS events processed successfully"})}}export{v as handler};

package/dist/lambda/sms-event-processor/index.ts

@@ -0,0 +1,145 @@
+import { DynamoDBClient, PutItemCommand } from "@aws-sdk/client-dynamodb";
+import type { SQSEvent } from "aws-lambda";
+
+const dynamodb = new DynamoDBClient({});
+
+/**
+ * Lambda handler for processing SMS events from SQS (via SNS)
+ * Events come from AWS End User Messaging via SNS → SQS (raw message delivery)
+ *
+ * Stores all SMS events in DynamoDB:
+ * - TEXT_QUEUED: Message queued for delivery
+ * - TEXT_SENT: Message sent to carrier
+ * - TEXT_DELIVERED: Message delivered to device
+ * - TEXT_PENDING: Delivery pending
+ * - TEXT_SUCCESSFUL: Delivery confirmed
+ * - TEXT_INVALID: Invalid destination number
+ * - TEXT_CARRIER_UNREACHABLE: Carrier unavailable
+ * - TEXT_TTL_EXPIRED: Message TTL expired
+ * - TEXT_BLOCKED: Blocked by carrier/opted-out
+ * - TEXT_UNKNOWN: Unknown status
+ */
+export async function handler(event: SQSEvent) {
+  console.log("Processing SMS event from SQS:", JSON.stringify(event, null, 2));
+
+  const tableName = process.env.TABLE_NAME;
+  if (!tableName) {
+    throw new Error("TABLE_NAME environment variable not set");
+  }
+
+  // Get retention days from environment, default to 90
+  const retentionDays = Number.parseInt(process.env.RETENTION_DAYS || "90", 10);
+
+  for (const record of event.Records) {
+    try {
+      // Parse the SQS message body
+      // With raw message delivery from SNS, this is the actual SMS event
+      const detail = JSON.parse(record.body);
+
+      // Extract SMS event details
+      // AWS End User Messaging event structure
+      const eventType = detail.eventType || detail.messageStatus || "UNKNOWN";
+      const messageId = detail.messageId;
+      const destinationNumber = detail.destinationPhoneNumber;
+      const originationNumber = detail.originationPhoneNumber;
+      const messageBody = detail.messageBody || "";
+      const isoCountryCode = detail.isoCountryCode || "US";
+      const messageType = detail.messageType || "TRANSACTIONAL";
+
+      // Event timestamp
+      const eventTimestamp = detail.eventTimestamp
+        ? new Date(detail.eventTimestamp).getTime()
+        : Date.now();
+
+      console.log("Processing SMS event:", {
+        messageId,
+        eventType,
+        destinationNumber,
+        originationNumber,
+      });
+
+      // Extract additional data based on event type
+      let additionalData: Record<string, unknown> = {
+        isoCountryCode,
+        messageType,
+      };
+
+      if (eventType === "TEXT_DELIVERED" || eventType === "TEXT_SUCCESSFUL") {
+        additionalData = {
+          ...additionalData,
+          deliveryTimestamp: detail.deliveryTimestamp,
+          carrierName: detail.carrierName,
+          providerResponse: detail.providerResponse,
+        };
+      } else if (
+        eventType === "TEXT_FAILED" ||
+        eventType === "TEXT_INVALID" ||
+        eventType === "TEXT_CARRIER_UNREACHABLE" ||
+        eventType === "TEXT_BLOCKED"
+      ) {
+        additionalData = {
+          ...additionalData,
+          failureReason: detail.failureReason || detail.statusMessage,
+          failureCode: detail.failureCode || detail.statusCode,
+          providerResponse: detail.providerResponse,
+        };
+      } else if (eventType === "TEXT_QUEUED" || eventType === "TEXT_SENT") {
+        additionalData = {
+          ...additionalData,
+          queuedTimestamp: detail.queuedTimestamp,
+          sentTimestamp: detail.sentTimestamp,
+        };
+      } else if (eventType === "TEXT_TTL_EXPIRED") {
+        additionalData = {
+          ...additionalData,
+          expirationTimestamp: detail.expirationTimestamp,
+          ttlSeconds: detail.ttlSeconds,
+        };
+      }
+
+      // Calculate message segments (SMS is 160 chars for GSM, 70 for Unicode)
+      const segments = messageBody ? Math.ceil(messageBody.length / 160) : 1;
+
+      // Calculate TTL based on retention days (0 or negative means no TTL)
+      const expiresAt =
+        retentionDays > 0
+          ? Date.now() + retentionDays * 24 * 60 * 60 * 1000
+          : Date.now() + 365 * 24 * 60 * 60 * 1000; // Default 1 year if not specified
+
+      // Store event in DynamoDB
+      await dynamodb.send(
+        new PutItemCommand({
+          TableName: tableName,
+          Item: {
+            messageId: { S: messageId },
+            sentAt: { N: eventTimestamp.toString() },
+            accountId: { S: process.env.AWS_ACCOUNT_ID || "unknown" },
+            destinationNumber: { S: destinationNumber || "" },
+            originationNumber: { S: originationNumber || "" },
+            messageBody: { S: messageBody },
+            eventType: { S: eventType },
+            segments: { N: segments.toString() },
+            eventData: { S: JSON.stringify(detail) },
+            additionalData: { S: JSON.stringify(additionalData) },
+            createdAt: { N: Date.now().toString() },
+            expiresAt: { N: expiresAt.toString() },
+          },
+        })
+      );
+
+      console.log(
+        `Stored ${eventType} event for message ${messageId}`,
+        additionalData
+      );
+    } catch (error) {
+      console.error("Error processing record:", error);
+      console.error("Record:", JSON.stringify(record, null, 2));
+      // Don't throw - continue processing other records
+    }
+  }
+
+  return {
+    statusCode: 200,
+    body: JSON.stringify({ message: "SMS events processed successfully" }),
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wraps.dev/cli",
-  "version": "2.2.6",
+  "version": "2.2.8",
   "description": "CLI for deploying Wraps email infrastructure to your AWS account",
   "type": "module",
   "main": "./dist/cli.js",