@stacksjs/ts-cloud-core 0.1.1

package/src/sms/advanced/chatbot.ts

@@ -0,0 +1,224 @@
+/**
+ * SMS Chatbot Integration
+ *
+ * Provides conversational SMS with AI/rule-based responses
+ */
+
+export interface ChatbotConfig {
+  enabled: boolean
+  provider: 'rules' | 'bedrock' | 'openai' | 'custom'
+  welcomeMessage?: string
+  fallbackMessage?: string
+  sessionTimeout?: number
+  maxTurns?: number
+}
+
+export interface ChatSession {
+  sessionId: string
+  phoneNumber: string
+  startedAt: string
+  lastMessageAt: string
+  turnCount: number
+  context: Record<string, any>
+  status: 'active' | 'ended' | 'timeout'
+}
+
+export interface ChatRule {
+  id: string
+  priority: number
+  patterns: string[]
+  response: string
+  action?: 'respond' | 'transfer' | 'end' | 'webhook'
+  actionParams?: Record<string, any>
+}
+
+/**
+ * SMS Chatbot Module
+ */
+export class SmsChatbot {
+  /**
+   * Lambda code for chatbot processing
+   */
+  static ChatbotProcessorCode: string = [
+    `const { DynamoDBClient, GetItemCommand, PutItemCommand, UpdateItemCommand, ScanCommand } = require('@aws-sdk/client-dynamodb');`,
+    "const { BedrockRuntimeClient, InvokeModelCommand } = require('@aws-sdk/client-bedrock-runtime');",
+    "const { SNSClient, PublishCommand } = require('@aws-sdk/client-sns');",
+    "",
+    "const dynamodb = new DynamoDBClient({});",
+    "const bedrock = new BedrockRuntimeClient({});",
+    "const sns = new SNSClient({});",
+    "",
+    "const SESSIONS_TABLE = process.env.SESSIONS_TABLE;",
+    "const RULES_TABLE = process.env.RULES_TABLE;",
+    "const CHATBOT_CONFIG = JSON.parse(process.env.CHATBOT_CONFIG || '{}');",
+    "",
+    "exports.handler = async (event) => {",
+    "  console.log('Chatbot event:', JSON.stringify(event, null, 2));",
+    "  for (const record of event.Records) {",
+    "    try {",
+    "      const message = JSON.parse(record.Sns?.Message || record.body || '{}');",
+    "      const { originationNumber, messageBody } = message;",
+    "      if (!originationNumber || !messageBody) continue;",
+    "      const response = await processMessage(originationNumber, messageBody.trim());",
+    "      await sendResponse(originationNumber, response);",
+    "    } catch (error) {",
+    "      console.error('Error:', error);",
+    "    }",
+    "  }",
+    "  return { statusCode: 200 };",
+    "};",
+    "",
+    "async function processMessage(phoneNumber, message) {",
+    "  const rules = await getRules();",
+    "  const lowerMessage = message.toLowerCase();",
+    "  for (const rule of rules) {",
+    "    for (const pattern of rule.patterns) {",
+    "      if (new RegExp(pattern, 'i').test(lowerMessage)) {",
+    "        return rule.response;",
+    "      }",
+    "    }",
+    "  }",
+    "  return CHATBOT_CONFIG.fallbackMessage || 'Sorry, I did not understand. Please try again.';",
+    "}",
+    "",
+    "async function getRules() {",
+    "  const result = await dynamodb.send(new ScanCommand({ TableName: RULES_TABLE }));",
+    "  return (result.Items || []).map(item => ({",
+    "    patterns: JSON.parse(item.patterns?.S || '[]'),",
+    "    response: item.response?.S || '',",
+    "  })).sort((a, b) => (a.priority || 0) - (b.priority || 0));",
+    "}",
+    "",
+    "async function sendResponse(phoneNumber, message) {",
+    "  await sns.send(new PublishCommand({",
+    "    PhoneNumber: phoneNumber,",
+    "    Message: message.substring(0, 1600),",
+    "    MessageAttributes: {",
+    "      'AWS.SNS.SMS.SMSType': { DataType: 'String', StringValue: 'Transactional' },",
+    "    },",
+    "  }));",
+    "}",
+  ].join('\n')
+
+  /**
+   * Create sessions DynamoDB table
+   */
+  static createSessionsTable(config: { slug: string }): Record<string, any> {
+    return {
+      [`${config.slug}ChatbotSessionsTable`]: {
+        Type: 'AWS::DynamoDB::Table',
+        Properties: {
+          TableName: `${config.slug}-chatbot-sessions`,
+          BillingMode: 'PAY_PER_REQUEST',
+          AttributeDefinitions: [
+            { AttributeName: 'phoneNumber', AttributeType: 'S' },
+          ],
+          KeySchema: [
+            { AttributeName: 'phoneNumber', KeyType: 'HASH' },
+          ],
+          TimeToLiveSpecification: {
+            AttributeName: 'ttl',
+            Enabled: true,
+          },
+        },
+      },
+    }
+  }
+
+  /**
+   * Create chatbot rules table
+   */
+  static createRulesTable(config: { slug: string }): Record<string, any> {
+    return {
+      [`${config.slug}ChatbotRulesTable`]: {
+        Type: 'AWS::DynamoDB::Table',
+        Properties: {
+          TableName: `${config.slug}-chatbot-rules`,
+          BillingMode: 'PAY_PER_REQUEST',
+          AttributeDefinitions: [
+            { AttributeName: 'id', AttributeType: 'S' },
+          ],
+          KeySchema: [
+            { AttributeName: 'id', KeyType: 'HASH' },
+          ],
+        },
+      },
+    }
+  }
+
+  /**
+   * Create chatbot processor Lambda
+   */
+  static createChatbotProcessorLambda(config: {
+    slug: string
+    roleArn: string
+    sessionsTable: string
+    rulesTable: string
+    chatbotConfig: ChatbotConfig
+    originationNumber?: string
+  }): Record<string, any> {
+    return {
+      [`${config.slug}ChatbotProcessorLambda`]: {
+        Type: 'AWS::Lambda::Function',
+        Properties: {
+          FunctionName: `${config.slug}-chatbot-processor`,
+          Runtime: 'nodejs20.x',
+          Handler: 'index.handler',
+          Role: config.roleArn,
+          Timeout: 30,
+          MemorySize: 256,
+          Code: {
+            ZipFile: SmsChatbot.ChatbotProcessorCode,
+          },
+          Environment: {
+            Variables: {
+              SESSIONS_TABLE: config.sessionsTable,
+              RULES_TABLE: config.rulesTable,
+              CHATBOT_CONFIG: JSON.stringify(config.chatbotConfig),
+              ORIGINATION_NUMBER: config.originationNumber || '',
+            },
+          },
+        },
+      },
+    }
+  }
+
+  /**
+   * Built-in chatbot rules
+   */
+  static readonly DefaultRules: ChatRule[] = [
+    {
+      id: 'greeting',
+      priority: 1,
+      patterns: ['^(hi|hello|hey|howdy)$', '^good (morning|afternoon|evening)'],
+      response: 'Hello! How can I help you today?',
+    },
+    {
+      id: 'help',
+      priority: 2,
+      patterns: ['^help$', 'what can you do', 'how does this work'],
+      response: 'I can help with: 1) Account info 2) Support 3) Hours. Reply with a number.',
+    },
+    {
+      id: 'hours',
+      priority: 3,
+      patterns: ['hours', 'open', 'when are you'],
+      response: 'We are open Mon-Fri 9am-5pm EST. Closed weekends.',
+    },
+    {
+      id: 'thanks',
+      priority: 4,
+      patterns: ['^(thanks|thank you|thx)'],
+      response: "You're welcome! Is there anything else I can help with?",
+    },
+    {
+      id: 'bye',
+      priority: 5,
+      patterns: ['^(bye|goodbye|quit|exit|stop)$'],
+      response: 'Goodbye! Text us anytime if you need help.',
+      action: 'end',
+    },
+  ]
+}
+
+export default SmsChatbot

package/src/sms/advanced/index.ts

@@ -0,0 +1,10 @@
+/**
+ * SMS Advanced Features
+ */
+
+export * from './campaigns'
+export * from './analytics'
+export * from './mms'
+export * from './chatbot'
+export * from './link-tracking'
+export * from './ab-testing'

package/src/sms/advanced/link-tracking.ts

@@ -0,0 +1,248 @@
+/**
+ * Link Shortening and Tracking
+ *
+ * Provides URL shortening and click tracking for SMS
+ */
+
+export interface ShortenedLink {
+  id: string
+  originalUrl: string
+  shortUrl: string
+  campaignId?: string
+  messageId?: string
+  clicks: number
+  uniqueClicks: number
+  createdAt: string
+  expiresAt?: string
+}
+
+export interface LinkClick {
+  linkId: string
+  clickedAt: string
+  userAgent?: string
+  ipAddress?: string
+  country?: string
+  device?: string
+}
+
+/**
+ * Link Tracking Module
+ */
+export class LinkTracking {
+  /**
+   * Lambda code for link shortening
+   */
+  static LinkShortenerCode = `
+const { DynamoDBClient, PutItemCommand, GetItemCommand, UpdateItemCommand } = require('@aws-sdk/client-dynamodb');
+const crypto = require('crypto');
+
+const dynamodb = new DynamoDBClient({});
+const LINKS_TABLE = process.env.LINKS_TABLE;
+const SHORT_DOMAIN = process.env.SHORT_DOMAIN;
+
+exports.handler = async (event) => {
+  console.log('Link shortener event:', JSON.stringify(event, null, 2));
+
+  const { httpMethod, body, pathParameters } = event;
+
+  try {
+    if (httpMethod === 'POST') {
+      // Create short link
+      const data = JSON.parse(body || '{}');
+      return await createShortLink(data);
+    } else if (httpMethod === 'GET' && pathParameters?.id) {
+      // Redirect to original URL
+      return await handleRedirect(pathParameters.id, event);
+    }
+
+    return { statusCode: 405, body: 'Method not allowed' };
+  } catch (error) {
+    console.error('Error:', error);
+    return { statusCode: 500, body: JSON.stringify({ error: error.message }) };
+  }
+};
+
+async function createShortLink(data) {
+  const { url, campaignId, messageId, expiresIn } = data;
+
+  if (!url) {
+    return { statusCode: 400, body: JSON.stringify({ error: 'URL is required' }) };
+  }
+
+  // Generate short ID
+  const id = generateShortId();
+  const now = new Date().toISOString();
+  const expiresAt = expiresIn
+    ? new Date(Date.now() + expiresIn * 1000).toISOString()
+    : null;
+
+  await dynamodb.send(new PutItemCommand({
+    TableName: LINKS_TABLE,
+    Item: {
+      id: { S: id },
+      originalUrl: { S: url },
+      campaignId: { S: campaignId || '' },
+      messageId: { S: messageId || '' },
+      clicks: { N: '0' },
+      uniqueClicks: { N: '0' },
+      visitors: { SS: ['_placeholder'] }, // DynamoDB requires non-empty set
+      createdAt: { S: now },
+      ...(expiresAt && { expiresAt: { S: expiresAt } }),
+      ttl: { N: String(Math.floor(Date.now() / 1000) + 90 * 24 * 60 * 60) },
+    },
+  }));
+
+  const shortUrl = SHORT_DOMAIN ? 'https://' + SHORT_DOMAIN + '/l/' + id : '/l/' + id;
+
+  return {
+    statusCode: 201,
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      id,
+      shortUrl,
+      originalUrl: url,
+      createdAt: now,
+    }),
+  };
+}
+
+async function handleRedirect(id, event) {
+  const result = await dynamodb.send(new GetItemCommand({
+    TableName: LINKS_TABLE,
+    Key: { id: { S: id } },
+  }));
+
+  if (!result.Item) {
+    return { statusCode: 404, body: 'Link not found' };
+  }
+
+  const link = result.Item;
+
+  // Check expiration
+  if (link.expiresAt?.S && new Date(link.expiresAt.S) < new Date()) {
+    return { statusCode: 410, body: 'Link has expired' };
+  }
+
+  const originalUrl = link.originalUrl.S;
+
+  // Track click
+  const ipAddress = event.requestContext?.identity?.sourceIp || 'unknown';
+  const userAgent = event.headers?.['user-agent'] || '';
+  const visitorId = crypto.createHash('md5').update(ipAddress + userAgent).digest('hex').substring(0, 8);
+
+  try {
+    await dynamodb.send(new UpdateItemCommand({
+      TableName: LINKS_TABLE,
+      Key: { id: { S: id } },
+      UpdateExpression: 'SET clicks = clicks + :one, visitors = list_append(if_not_exists(visitors, :empty), :visitor)',
+      ExpressionAttributeValues: {
+        ':one': { N: '1' },
+        ':empty': { L: [] },
+        ':visitor': { L: [{ S: visitorId }] },
+      },
+    }));
+  } catch (e) {
+    console.error('Error tracking click:', e);
+  }
+
+  return {
+    statusCode: 302,
+    headers: {
+      'Location': originalUrl,
+      'Cache-Control': 'no-store',
+    },
+    body: '',
+  };
+}
+
+function generateShortId() {
+  const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+  let id = '';
+  for (let i = 0; i < 6; i++) {
+    id += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return id;
+}
+`
+
+  /**
+   * Create links DynamoDB table
+   */
+  static createLinksTable(config: { slug: string }): Record<string, any> {
+    return {
+      [`${config.slug}ShortLinksTable`]: {
+        Type: 'AWS::DynamoDB::Table',
+        Properties: {
+          TableName: `${config.slug}-short-links`,
+          BillingMode: 'PAY_PER_REQUEST',
+          AttributeDefinitions: [
+            { AttributeName: 'id', AttributeType: 'S' },
+          ],
+          KeySchema: [
+            { AttributeName: 'id', KeyType: 'HASH' },
+          ],
+          TimeToLiveSpecification: {
+            AttributeName: 'ttl',
+            Enabled: true,
+          },
+        },
+      },
+    }
+  }
+
+  /**
+   * Create link shortener Lambda
+   */
+  static createLinkShortenerLambda(config: {
+    slug: string
+    roleArn: string
+    linksTable: string
+    shortDomain?: string
+  }): Record<string, any> {
+    return {
+      [`${config.slug}LinkShortenerLambda`]: {
+        Type: 'AWS::Lambda::Function',
+        Properties: {
+          FunctionName: `${config.slug}-link-shortener`,
+          Runtime: 'nodejs20.x',
+          Handler: 'index.handler',
+          Role: config.roleArn,
+          Timeout: 10,
+          MemorySize: 128,
+          Code: {
+            ZipFile: LinkTracking.LinkShortenerCode,
+          },
+          Environment: {
+            Variables: {
+              LINKS_TABLE: config.linksTable,
+              SHORT_DOMAIN: config.shortDomain || '',
+            },
+          },
+        },
+      },
+    }
+  }
+
+  /**
+   * Shorten URLs in message text
+   */
+  static shortenUrlsInMessage(message: string, shortDomain: string, linkIdPrefix: string): {
+    message: string
+    links: Array<{ original: string; short: string; id: string }>
+  } {
+    const urlRegex = /(https?:\/\/[^\s]+)/g
+    const links: Array<{ original: string; short: string; id: string }> = []
+    let index = 0
+
+    const shortenedMessage = message.replace(urlRegex, (url) => {
+      const id = `${linkIdPrefix}-${index++}`
+      const shortUrl = `https://${shortDomain}/l/${id}`
+      links.push({ original: url, short: shortUrl, id })
+      return shortUrl
+    })
+
+    return { message: shortenedMessage, links }
+  }
+}
+
+export default LinkTracking