Claude Code for Twilio SMS Workflow Guide

// skills/twilio-sms-workflow/index.js
const twilio = require('twilio');

class TwilioSMSService {
  constructor() {
    this.client = new twilio(
      process.env.TWILIO_ACCOUNT_SID,
      process.env.TWILIO_AUTH_TOKEN
    );
    this.fromNumber = process.env.TWILIO_PHONE_NUMBER;
  }

  async sendSMS(to, body, mediaUrl = null) {
    try {
      const message = await this.client.messages.create({
        body: body,
        from: this.fromNumber,
        to: to,
        mediaUrl: mediaUrl
      });
      return { success: true, sid: message.sid, status: message.status };
    } catch (error) {
      return { success: false, error: error.message };
    }
  }

  async sendBulkSMS(recipients, body) {
    const results = [];
    for (const recipient of recipients) {
      const result = await this.sendSMS(recipient.phone, body);
      results.push({ ...result, to: recipient.phone });
      // Rate limiting: wait between messages
      await this.delay(100);
    }
    return results;
  }

  delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

module.exports = TwilioSMSService;

// skills/twilio-sms-workflow/appointment-reminder.js
class AppointmentReminder {
  constructor(smsService) {
    this.smsService = smsService;
  }

  async sendReminder(appointment) {
    const { customerName, phone, dateTime, service } = appointment;
    const formattedDate = new Date(dateTime).toLocaleString('en-US', {
      weekday: 'long',
      month: 'long',
      day: 'numeric',
      hour: 'numeric',
      minute: '2-digit'
    });

    const message = `Hi ${customerName}, this is a reminder for your ${service} appointment on ${formattedDate}. Reply YES to confirm or CANCEL to cancel.`;

    const result = await this.smsService.sendSMS(phone, message);
    
    if (result.success) {
      // Store confirmation status in database
      await this.updateAppointmentStatus(appointment.id, 'reminder_sent');
    }
    
    return result;
  }

  async processConfirmation(phone, response) {
    const appointment = await this.findAppointmentByPhone(phone);
    
    if (response.toUpperCase() === 'YES') {
      await this.updateAppointmentStatus(appointment.id, 'confirmed');
      await this.smsService.sendSMS(
        phone, 
        'Your appointment is confirmed. We look forward to seeing you!'
      );
    } else if (response.toUpperCase() === 'CANCEL') {
      await this.updateAppointmentStatus(appointment.id, 'cancelled');
      await this.smsService.sendSMS(
        phone, 
        'Your appointment has been cancelled. Please call us to reschedule.'
      );
    }
  }
}

// skills/twilio-sms-workflow/two-factor-auth.js
const crypto = require('crypto');

class TwoFactorAuth {
  constructor(smsService) {
    this.smsService = smsService;
    this.verificationCodes = new Map();
  }

  async sendVerificationCode(userId, phone) {
    // Generate 6-digit code
    const code = crypto.randomInt(100000, 999999).toString();
    
    // Store with expiration (5 minutes)
    this.verificationCodes.set(userId, {
      code,
      phone,
      expiresAt: Date.now() + 5 * 60 * 1000
    });

    const message = `Your verification code is: ${code}. This code expires in 5 minutes.`;
    return await this.smsService.sendSMS(phone, message);
  }

  verifyCode(userId, inputCode) {
    const stored = this.verificationCodes.get(userId);
    
    if (!stored) {
      return { valid: false, error: 'No verification code found' };
    }

    if (Date.now() > stored.expiresAt) {
      this.verificationCodes.delete(userId);
      return { valid: false, error: 'Code expired' };
    }

    if (stored.code !== inputCode) {
      return { valid: false, error: 'Invalid code' };
    }

    // Code verified - remove to prevent reuse
    this.verificationCodes.delete(userId);
    return { valid: true };
  }
}

// skills/twilio-sms-workflow/support-notifications.js
class SupportNotificationService {
  constructor(smsService) {
    this.smsService = smsService;
  }

  async notifyTicketCreated(ticket) {
    const message = `Thank you for contacting support. Your ticket #${ticket.id} has been created. We'll respond within 24 hours.`;
    return await this.smsService.sendSMS(ticket.customerPhone, message);
  }

  async notifyTicketUpdated(ticket, update) {
    let message = `Ticket #${ticket.id} update: ${update.status}`;
    
    if (update.assignedTo) {
      message += `. Assigned to: ${update.assignedTo}`;
    }
    
    if (update.response) {
      message += `. Response: ${update.response.substring(0, 100)}...`;
    }

    return await this.smsService.sendSMS(ticket.customerPhone, message);
  }

  async notifyTicketResolved(ticket) {
    const message = `Your support ticket #${ticket.id} has been resolved. Please reply with FEEDBACK followed by your rating (1-5) to help us improve.`;
    return await this.smsService.sendSMS(ticket.customerPhone, message);
  }
}

// Webhook handler for inbound messages
app.post('/webhooks/twilio/inbound', async (req, res) => {
  const { From, Body } = req.body;
  
  // Route message based on content
  const response = new twilio.twiml.MessagingResponse();
  
  if (Body.toUpperCase().includes('HELP')) {
    response.message('For support, visit our website or call 1-800-EXAMPLE. Hours: Mon-Fri 9am-5pm EST.');
  } else if (Body.toUpperCase().includes('STOP')) {
    response.message('You have been unsubscribed from SMS notifications.');
    // Handle opt-out logic
  } else {
    response.message('Thank you for your message. A support agent will respond shortly.');
    // Queue for human review
  }

  res.type('text/xml').send(response.toString());
});

async function validatePhoneNumber(phoneNumber) {
  const client = new twilio(process.env.TWILIO_ACCOUNT_SID, process.env.TWILIO_AUTH_TOKEN);
  try {
    const lookup = await client.lookups.v2.phoneNumbers(phoneNumber).fetch();
    return { valid: true, phoneNumber: lookup.phoneNumber, countryCode: lookup.countryCode };
  } catch (error) {
    return { valid: false, error: error.message };
  }
}