veryfront 0.0.48 → 0.0.50

package/dist/integrations/twilio/files/ai/tools/send-sms.ts

@@ -0,0 +1,75 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { sendSMS, formatPhoneNumber } from "../../lib/twilio-client.ts";
+
+export default tool({
+  id: "send-sms",
+  description: "Send an SMS text message to a phone number using Twilio",
+  inputSchema: z.object({
+    to: z
+      .string()
+      .describe("Recipient phone number in E.164 format (e.g., +14155552671) or 10-digit US format"),
+    body: z
+      .string()
+      .min(1)
+      .max(1600)
+      .describe("Message text to send (max 1600 characters)"),
+    mediaUrl: z
+      .array(z.string().url())
+      .optional()
+      .describe("Optional array of media URLs to send as MMS (images, videos, etc.)"),
+  }),
+  execute: async ({ to, body, mediaUrl }) => {
+    try {
+      // Format phone number to E.164 if needed
+      const formattedPhone = formatPhoneNumber(to);
+
+      const message = await sendSMS(formattedPhone, body, {
+        mediaUrl,
+      });
+
+      return {
+        success: true,
+        messageSid: message.sid,
+        status: message.status,
+        to: message.to,
+        from: message.from,
+        body: message.body,
+        numSegments: message.num_segments,
+        price: message.price,
+        priceUnit: message.price_unit,
+        message: `SMS sent successfully to ${message.to}. Status: ${message.status}`,
+      };
+    } catch (error) {
+      if (error instanceof Error) {
+        // Check for common errors
+        if (error.message.includes("not configured")) {
+          return {
+            error: "Twilio not configured. Please set TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, and TWILIO_PHONE_NUMBER.",
+            setupUrl: "https://console.twilio.com/",
+          };
+        }
+
+        // Twilio API errors
+        if (error.message.includes("21211")) {
+          return {
+            error: `Invalid phone number: ${to}. Please use E.164 format (e.g., +14155552671).`,
+          };
+        }
+
+        if (error.message.includes("21608")) {
+          return {
+            error: `Unverified number. Trial accounts can only send to verified numbers. Verify at: https://console.twilio.com/us1/develop/phone-numbers/manage/verified`,
+          };
+        }
+
+        if (error.message.includes("21610")) {
+          return {
+            error: `Unverified 'To' number. This number must be verified before you can send messages to it during trial.`,
+          };
+        }
+      }
+      throw error;
+    }
+  },
+});

package/dist/integrations/twilio/files/ai/tools/send-whatsapp.ts

@@ -0,0 +1,81 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { sendWhatsApp, formatPhoneNumber } from "../../lib/twilio-client.ts";
+
+export default tool({
+  id: "send-whatsapp",
+  description: "Send a WhatsApp message to a phone number using Twilio. Note: Recipients must have opted in to receive messages.",
+  inputSchema: z.object({
+    to: z
+      .string()
+      .describe("Recipient phone number in E.164 format (e.g., +14155552671). The 'whatsapp:' prefix is optional."),
+    body: z
+      .string()
+      .min(1)
+      .describe("Message text to send"),
+    mediaUrl: z
+      .array(z.string().url())
+      .optional()
+      .describe("Optional array of media URLs to send (images, videos, PDFs, etc.)"),
+  }),
+  execute: async ({ to, body, mediaUrl }) => {
+    try {
+      // Format phone number to E.164 if needed
+      const formattedPhone = formatPhoneNumber(to);
+
+      const message = await sendWhatsApp(formattedPhone, body, {
+        mediaUrl,
+      });
+
+      return {
+        success: true,
+        messageSid: message.sid,
+        status: message.status,
+        to: message.to,
+        from: message.from,
+        body: message.body,
+        numSegments: message.num_segments,
+        price: message.price,
+        priceUnit: message.price_unit,
+        message: `WhatsApp message sent successfully to ${message.to}. Status: ${message.status}`,
+      };
+    } catch (error) {
+      if (error instanceof Error) {
+        // Check for common errors
+        if (error.message.includes("not configured")) {
+          return {
+            error: "Twilio not configured. Please set TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, and TWILIO_PHONE_NUMBER.",
+            setupUrl: "https://console.twilio.com/",
+          };
+        }
+
+        // Twilio WhatsApp-specific errors
+        if (error.message.includes("63007")) {
+          return {
+            error: "Recipient has not opted in to receive WhatsApp messages. They must send a message to your WhatsApp sandbox first.",
+            sandboxUrl: "https://console.twilio.com/us1/develop/sms/try-it-out/whatsapp-learn",
+          };
+        }
+
+        if (error.message.includes("63016")) {
+          return {
+            error: "WhatsApp message failed: Recipient phone number is not a WhatsApp user.",
+          };
+        }
+
+        if (error.message.includes("63030")) {
+          return {
+            error: "Message body is required for WhatsApp messages unless media is included.",
+          };
+        }
+
+        if (error.message.includes("63003")) {
+          return {
+            error: "Message exceeds maximum allowed length for WhatsApp.",
+          };
+        }
+      }
+      throw error;
+    }
+  },
+});

package/dist/integrations/twilio/files/lib/token-store.ts

@@ -0,0 +1,60 @@
+// Helper for Cross-Platform environment access
+function getEnv(key: string): string | undefined {
+  // @ts-ignore - Deno global
+  if (typeof Deno !== "undefined") {
+    // @ts-ignore - Deno global
+    return Deno.env.get(key);
+  } // @ts-ignore - process global
+  else if (typeof process !== "undefined" && process.env) {
+    // @ts-ignore - process global
+    return process.env[key];
+  }
+  return undefined;
+}
+
+/**
+ * Get Twilio credentials from environment variables
+ */
+export function getTwilioCredentials(): {
+  accountSid: string;
+  authToken: string;
+  phoneNumber: string;
+} | null {
+  const accountSid = getEnv("TWILIO_ACCOUNT_SID");
+  const authToken = getEnv("TWILIO_AUTH_TOKEN");
+  const phoneNumber = getEnv("TWILIO_PHONE_NUMBER");
+
+  if (!accountSid || !authToken || !phoneNumber) {
+    return null;
+  }
+
+  return { accountSid, authToken, phoneNumber };
+}
+
+/**
+ * Check if Twilio is authenticated
+ */
+export function isAuthenticated(): boolean {
+  return getTwilioCredentials() !== null;
+}
+
+/**
+ * Get Twilio Account SID
+ */
+export function getAccountSid(): string | null {
+  return getEnv("TWILIO_ACCOUNT_SID") || null;
+}
+
+/**
+ * Get Twilio Auth Token
+ */
+export function getAuthToken(): string | null {
+  return getEnv("TWILIO_AUTH_TOKEN") || null;
+}
+
+/**
+ * Get Twilio Phone Number
+ */
+export function getPhoneNumber(): string | null {
+  return getEnv("TWILIO_PHONE_NUMBER") || null;
+}

package/dist/integrations/twilio/files/lib/twilio-client.ts

@@ -0,0 +1,375 @@
+/**
+ * Twilio API Client
+ *
+ * Provides a type-safe interface to Twilio API operations for SMS, WhatsApp, and voice calls.
+ * Documentation: https://www.twilio.com/docs/api
+ */
+
+import { getTwilioCredentials } from "./token-store.ts";
+
+const TWILIO_API_VERSION = "2010-04-01";
+
+// Types
+export interface TwilioMessage {
+  sid: string;
+  account_sid: string;
+  from: string;
+  to: string;
+  body: string;
+  status: "queued" | "sending" | "sent" | "failed" | "delivered" | "undelivered" | "receiving" | "received";
+  direction: "inbound" | "outbound-api" | "outbound-call" | "outbound-reply";
+  date_created: string;
+  date_updated: string;
+  date_sent: string | null;
+  price: string | null;
+  price_unit: string | null;
+  error_code: number | null;
+  error_message: string | null;
+  uri: string;
+  num_segments: string;
+  num_media: string;
+  messaging_service_sid: string | null;
+}
+
+export interface TwilioCall {
+  sid: string;
+  account_sid: string;
+  from: string;
+  to: string;
+  status: "queued" | "ringing" | "in-progress" | "completed" | "busy" | "failed" | "no-answer" | "canceled";
+  direction: "inbound" | "outbound-api" | "outbound-dial";
+  date_created: string;
+  date_updated: string;
+  start_time: string | null;
+  end_time: string | null;
+  duration: string | null;
+  price: string | null;
+  price_unit: string | null;
+  uri: string;
+  answered_by: string | null;
+}
+
+export interface TwilioListResponse<T> {
+  messages?: T[];
+  calls?: T[];
+  first_page_uri: string;
+  next_page_uri: string | null;
+  previous_page_uri: string | null;
+  uri: string;
+  page: number;
+  page_size: number;
+}
+
+interface TwilioErrorResponse {
+  code: number;
+  message: string;
+  more_info: string;
+  status: number;
+}
+
+/**
+ * Helper function for Twilio API calls
+ */
+async function twilioFetch<T>(
+  endpoint: string,
+  options: RequestInit & { params?: Record<string, string | number> } = {},
+): Promise<T> {
+  const credentials = getTwilioCredentials();
+  if (!credentials) {
+    throw new Error(
+      "Twilio not configured. Please set TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, and TWILIO_PHONE_NUMBER environment variables.",
+    );
+  }
+
+  const { accountSid, authToken } = credentials;
+
+  // Build base URL
+  const baseUrl = `https://api.twilio.com/${TWILIO_API_VERSION}/Accounts/${accountSid}`;
+  let url = `${baseUrl}${endpoint}`;
+
+  // Build authorization header (Basic Auth)
+  const authString = btoa(`${accountSid}:${authToken}`);
+
+  // For POST requests, use form-urlencoded body
+  let body: string | undefined;
+  const headers: Record<string, string> = {
+    "Authorization": `Basic ${authString}`,
+  };
+
+  if (options.method === "POST" && options.params) {
+    const formData = new URLSearchParams();
+    Object.entries(options.params).forEach(([key, value]) => {
+      formData.append(key, String(value));
+    });
+    body = formData.toString();
+    headers["Content-Type"] = "application/x-www-form-urlencoded";
+  } else if (options.params) {
+    // For GET requests, add query parameters
+    const queryParams = new URLSearchParams();
+    Object.entries(options.params).forEach(([key, value]) => {
+      queryParams.append(key, String(value));
+    });
+    url += `?${queryParams.toString()}`;
+  }
+
+  const response = await fetch(url, {
+    ...options,
+    headers,
+    body,
+  });
+
+  const data = await response.json();
+
+  if (!response.ok) {
+    const error = data as TwilioErrorResponse;
+    throw new Error(
+      `Twilio API error (${error.code}): ${error.message}\nMore info: ${error.more_info}`,
+    );
+  }
+
+  return data as T;
+}
+
+/**
+ * Send an SMS message
+ * @param to - Recipient phone number in E.164 format (e.g., +14155552671)
+ * @param body - Message text (max 1600 characters)
+ * @param options - Optional parameters like MediaUrl for MMS
+ */
+export async function sendSMS(
+  to: string,
+  body: string,
+  options?: {
+    mediaUrl?: string[];
+    statusCallback?: string;
+  },
+): Promise<TwilioMessage> {
+  const credentials = getTwilioCredentials();
+  if (!credentials) {
+    throw new Error("Twilio credentials not configured");
+  }
+
+  const params: Record<string, string> = {
+    To: to,
+    From: credentials.phoneNumber,
+    Body: body,
+  };
+
+  if (options?.mediaUrl && options.mediaUrl.length > 0) {
+    options.mediaUrl.forEach((url, index) => {
+      params[`MediaUrl[${index}]`] = url;
+    });
+  }
+
+  if (options?.statusCallback) {
+    params.StatusCallback = options.statusCallback;
+  }
+
+  return twilioFetch<TwilioMessage>("/Messages.json", {
+    method: "POST",
+    params,
+  });
+}
+
+/**
+ * Send a WhatsApp message
+ * @param to - Recipient phone number in E.164 format with 'whatsapp:' prefix (e.g., whatsapp:+14155552671)
+ * @param body - Message text
+ */
+export async function sendWhatsApp(
+  to: string,
+  body: string,
+  options?: {
+    mediaUrl?: string[];
+    statusCallback?: string;
+  },
+): Promise<TwilioMessage> {
+  const credentials = getTwilioCredentials();
+  if (!credentials) {
+    throw new Error("Twilio credentials not configured");
+  }
+
+  // Ensure 'whatsapp:' prefix
+  const whatsappTo = to.startsWith("whatsapp:") ? to : `whatsapp:${to}`;
+  const whatsappFrom = credentials.phoneNumber.startsWith("whatsapp:")
+    ? credentials.phoneNumber
+    : `whatsapp:${credentials.phoneNumber}`;
+
+  const params: Record<string, string> = {
+    To: whatsappTo,
+    From: whatsappFrom,
+    Body: body,
+  };
+
+  if (options?.mediaUrl && options.mediaUrl.length > 0) {
+    options.mediaUrl.forEach((url, index) => {
+      params[`MediaUrl[${index}]`] = url;
+    });
+  }
+
+  if (options?.statusCallback) {
+    params.StatusCallback = options.statusCallback;
+  }
+
+  return twilioFetch<TwilioMessage>("/Messages.json", {
+    method: "POST",
+    params,
+  });
+}
+
+/**
+ * List messages
+ * @param options - Filter options for listing messages
+ */
+export async function listMessages(options?: {
+  to?: string;
+  from?: string;
+  dateSent?: string;
+  limit?: number;
+}): Promise<TwilioMessage[]> {
+  const params: Record<string, string | number> = {};
+
+  if (options?.to) params.To = options.to;
+  if (options?.from) params.From = options.from;
+  if (options?.dateSent) params.DateSent = options.dateSent;
+  if (options?.limit) params.PageSize = options.limit;
+
+  const response = await twilioFetch<TwilioListResponse<TwilioMessage>>(
+    "/Messages.json",
+    { params },
+  );
+
+  return response.messages || [];
+}
+
+/**
+ * Get a specific message by SID
+ * @param messageSid - The unique identifier for the message
+ */
+export function getMessage(messageSid: string): Promise<TwilioMessage> {
+  return twilioFetch<TwilioMessage>(`/Messages/${messageSid}.json`);
+}
+
+/**
+ * List calls
+ * @param options - Filter options for listing calls
+ */
+export async function listCalls(options?: {
+  to?: string;
+  from?: string;
+  status?: "queued" | "ringing" | "in-progress" | "completed" | "busy" | "failed" | "no-answer" | "canceled";
+  startTime?: string;
+  limit?: number;
+}): Promise<TwilioCall[]> {
+  const params: Record<string, string | number> = {};
+
+  if (options?.to) params.To = options.to;
+  if (options?.from) params.From = options.from;
+  if (options?.status) params.Status = options.status;
+  if (options?.startTime) params.StartTime = options.startTime;
+  if (options?.limit) params.PageSize = options.limit;
+
+  const response = await twilioFetch<TwilioListResponse<TwilioCall>>(
+    "/Calls.json",
+    { params },
+  );
+
+  return response.calls || [];
+}
+
+/**
+ * Get a specific call by SID
+ * @param callSid - The unique identifier for the call
+ */
+export function getCall(callSid: string): Promise<TwilioCall> {
+  return twilioFetch<TwilioCall>(`/Calls/${callSid}.json`);
+}
+
+/**
+ * Make an outbound call
+ * @param to - Recipient phone number in E.164 format
+ * @param twiml - TwiML instructions for the call (or URL to TwiML)
+ */
+export async function makeCall(
+  to: string,
+  twiml: string,
+  options?: {
+    twimlUrl?: string;
+    statusCallback?: string;
+    statusCallbackMethod?: "GET" | "POST";
+    timeout?: number;
+  },
+): Promise<TwilioCall> {
+  const credentials = getTwilioCredentials();
+  if (!credentials) {
+    throw new Error("Twilio credentials not configured");
+  }
+
+  const params: Record<string, string | number> = {
+    To: to,
+    From: credentials.phoneNumber,
+  };
+
+  // Use either Twiml or Url
+  if (options?.twimlUrl) {
+    params.Url = options.twimlUrl;
+  } else {
+    params.Twiml = twiml;
+  }
+
+  if (options?.statusCallback) {
+    params.StatusCallback = options.statusCallback;
+  }
+
+  if (options?.statusCallbackMethod) {
+    params.StatusCallbackMethod = options.statusCallbackMethod;
+  }
+
+  if (options?.timeout) {
+    params.Timeout = options.timeout;
+  }
+
+  return twilioFetch<TwilioCall>("/Calls.json", {
+    method: "POST",
+    params,
+  });
+}
+
+/**
+ * Format phone number to E.164 format
+ * Note: This is a simple helper. For production, use libphonenumber-js
+ */
+export function formatPhoneNumber(phone: string, defaultCountryCode = "+1"): string {
+  // Remove all non-digit characters
+  const digits = phone.replace(/\D/g, "");
+
+  // If it doesn't start with +, add country code
+  if (!phone.startsWith("+")) {
+    // If it's 10 digits (US), add +1
+    if (digits.length === 10) {
+      return `${defaultCountryCode}${digits}`;
+    }
+    // If it's 11 digits starting with 1, add +
+    if (digits.length === 11 && digits.startsWith("1")) {
+      return `+${digits}`;
+    }
+    // Otherwise, just add +
+    return `+${digits}`;
+  }
+
+  return phone;
+}
+
+/**
+ * Format date for Twilio API queries (YYYY-MM-DD)
+ */
+export function formatDate(date: Date): string {
+  return date.toISOString().split("T")[0];
+}
+
+/**
+ * Parse Twilio date strings to Date objects
+ */
+export function parseDate(dateString: string): Date {
+  return new Date(dateString);
+}

package/dist/integrations/twitter/connector.json

@@ -0,0 +1,87 @@
+{
+  "name": "twitter",
+  "displayName": "Twitter / X",
+  "icon": "twitter.svg",
+  "description": "Post tweets, read timeline, search tweets, and manage Twitter account",
+  "auth": {
+    "type": "oauth2",
+    "provider": "twitter",
+    "authorizationUrl": "https://twitter.com/i/oauth2/authorize",
+    "tokenUrl": "https://api.twitter.com/2/oauth2/token",
+    "scopes": [
+      "tweet.read",
+      "tweet.write",
+      "users.read",
+      "follows.read",
+      "offline.access"
+    ],
+    "callbackPath": "/api/auth/twitter/callback",
+    "usePKCE": true,
+    "requiredApis": [
+      {
+        "name": "Twitter API v2",
+        "enableUrl": "https://developer.twitter.com/en/portal/dashboard"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "TWITTER_CLIENT_ID",
+      "description": "Twitter OAuth 2.0 Client ID",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://developer.twitter.com/en/portal/dashboard"
+    },
+    {
+      "name": "TWITTER_CLIENT_SECRET",
+      "description": "Twitter OAuth 2.0 Client Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://developer.twitter.com/en/portal/dashboard"
+    }
+  ],
+  "tools": [
+    {
+      "id": "search-tweets",
+      "name": "Search Tweets",
+      "description": "Search recent tweets on Twitter/X",
+      "requiresWrite": false
+    },
+    {
+      "id": "post-tweet",
+      "name": "Post Tweet",
+      "description": "Create a new tweet on Twitter/X",
+      "requiresWrite": true
+    },
+    {
+      "id": "get-timeline",
+      "name": "Get Timeline",
+      "description": "Get the authenticated user's home timeline",
+      "requiresWrite": false
+    }
+  ],
+  "prompts": [
+    {
+      "id": "catch-up-twitter",
+      "title": "Catch up on Twitter",
+      "prompt": "Summarize the important tweets from my Twitter timeline today. Highlight trending topics and mentions.",
+      "category": "productivity",
+      "icon": "twitter"
+    },
+    {
+      "id": "compose-tweet",
+      "title": "Compose a tweet",
+      "prompt": "Help me compose and post an engaging tweet about my current work or thoughts.",
+      "category": "productivity",
+      "icon": "message"
+    },
+    {
+      "id": "search-topic",
+      "title": "Search Twitter topic",
+      "prompt": "Search Twitter for recent tweets about a specific topic and summarize the key discussions.",
+      "category": "research",
+      "icon": "search"
+    }
+  ],
+  "suggestedWith": ["slack", "linkedin", "notion"]
+}

package/dist/integrations/twitter/files/_env.example

@@ -0,0 +1,6 @@
+# Twitter / X Integration
+# Create an app at https://developer.twitter.com/en/portal/dashboard
+# Enable OAuth 2.0 and add callback URL: http://localhost:3000/api/auth/twitter/callback
+
+TWITTER_CLIENT_ID=your_client_id_here
+TWITTER_CLIENT_SECRET=your_client_secret_here