SMS Automation Workflow

Fresh

Automate SMS verification and messaging operations.

Overview

Workflow 1: SMS Verification Receiver

Automatically receive and parse verification codes.

Complete Implementation

class SMSVerificationReceiver {
  constructor(serverIP, apiToken, modemIndex) {
    this.baseURL = `http://${serverIP}`;
    this.token = apiToken;
    this.modemIndex = modemIndex;
  }

  async getMessages() {
    const response = await fetch(
      `${this.baseURL}/api/sms/get?index=${this.modemIndex}`,
      { headers: { 'Authorization': `Token ${this.token}` } }
    );
    return response.json();
  }

  async waitForCode(pattern, timeoutMs = 60000) {
    const startTime = Date.now();
    const seenIds = new Set();

    // Get existing messages to ignore
    const existing = await this.getMessages();
    existing.sms_messages?.forEach(m => seenIds.add(m.sms_id));

    while (Date.now() - startTime < timeoutMs) {
      const data = await this.getMessages();

      for (const msg of data.sms_messages || []) {
        if (seenIds.has(msg.sms_id)) continue;
        seenIds.add(msg.sms_id);

        const match = msg.content.match(pattern);
        if (match) {
          return {
            code: match[1] || match[0],
            fullMessage: msg.content,
            from: msg.phone,
            timestamp: msg.timestamp
          };
        }
      }

      // Wait before next poll
      await new Promise(r => setTimeout(r, 2000));
    }

    throw new Error('Timeout waiting for verification code');
  }
}

// Usage
const receiver = new SMSVerificationReceiver('192.168.1.100', 'token123', 1);

// Wait for 6-digit code
const result = await receiver.waitForCode(/(\d{6})/);
console.log(`Received code: ${result.code}`);

Python Implementation

import requests
import re
import time

class SMSVerificationReceiver:
    def __init__(self, server_ip, api_token, modem_index):
        self.base_url = f"http://{server_ip}"
        self.token = api_token
        self.modem_index = modem_index
        self.headers = {"Authorization": f"Token {api_token}"}

    def get_messages(self):
        url = f"{self.base_url}/api/sms/get?index={self.modem_index}"
        response = requests.get(url, headers=self.headers)
        return response.json()

    def wait_for_code(self, pattern, timeout=60):
        start_time = time.time()
        seen_ids = set()

        # Get existing messages
        existing = self.get_messages()
        for msg in existing.get("sms_messages", []):
            seen_ids.add(msg["sms_id"])

        while time.time() - start_time < timeout:
            data = self.get_messages()

            for msg in data.get("sms_messages", []):
                if msg["sms_id"] in seen_ids:
                    continue
                seen_ids.add(msg["sms_id"])

                match = re.search(pattern, msg["content"])
                if match:
                    return {
                        "code": match.group(1) if match.groups() else match.group(0),
                        "full_message": msg["content"],
                        "from": msg["phone"]
                    }

            time.sleep(2)

        raise TimeoutError("Timeout waiting for verification code")

# Usage
receiver = SMSVerificationReceiver("192.168.1.100", "token123", 1)
result = receiver.wait_for_code(r"(\d{6})")
print(f"Code: {result['code']}")

---

Workflow 2: Outbound SMS Sender

Send messages programmatically.

async function sendSMS(modemIndex, phone, message) {
  // URL encode the message
  const encodedMessage = encodeURIComponent(message).replace(/%20/g, '_');

  const url = `http://${SERVER_IP}/api/sms/send?` +
    `index=${modemIndex}&phone=${phone}&message=${encodedMessage}`;

  const response = await fetch(url, {
    headers: { 'Authorization': `Token ${API_TOKEN}` }
  });

  return response.ok;
}

// Send message
await sendSMS(1, '+15551234567', 'Hello from Proxidize API!');

---

Workflow 3: SMS Cleanup

Maintain inbox by deleting old messages.

async function cleanupOldSMS(modemIndex, maxAge = 7 * 24 * 60 * 60) {
  // Get all messages
  const response = await fetch(
    `http://${SERVER_IP}/api/sms/get?index=${modemIndex}`,
    { headers: { 'Authorization': `Token ${API_TOKEN}` } }
  );
  const data = await response.json();

  const now = Date.now() / 1000;
  const oldMessages = data.sms_messages
    .filter(msg => now - msg.timestamp > maxAge)
    .map(msg => msg.sms_id);

  if (oldMessages.length === 0) {
    console.log('No old messages to delete');
    return;
  }

  // Batch delete
  const deleteUrl = `http://${SERVER_IP}/api/delete_sms?` +
    `sms_id=${oldMessages.join(',')}&modem_index=${modemIndex}`;

  await fetch(deleteUrl, {
    headers: { 'Authorization': `Token ${API_TOKEN}` }
  });

  console.log(`Deleted ${oldMessages.length} old messages`);
}

Common Verification Code Patterns

Service Type	Regex Pattern
6-digit code	/(\d{6})/
4-digit code	/(\d{4})/
Alphanumeric	/([A-Z0-9]{6})/i
With prefix	/code[:\s]+(\d{6})/i

Related SOPs

• SOP-004: SMS Operations
• SOP-002: Get Modem Info