Creating an AI-Powered Agent Integrated With an Email System

	
#!/usr/bin/env node
/**
 * Email validation script using Xeams API
 * Validates an email address using the /email/validate endpoint
 */

import * as readline from 'readline';

interface ValidationResponse {
  code: number;
  description: string;
}

async function prompt(question: string): Promise {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });

  return new Promise((resolve) => {
    rl.question(question, (answer) => {
      rl.close();
      resolve(answer.trim());
    });
  });
}

async function validateEmail(): Promise {
  // Read configuration from environment variables
  const apiUrl = process.env.XEAMS_URL;
  const authKey = process.env.XEAMS_AUTH_KEY;
  const secret = process.env.XEAMS_SECRET;

  // Validate environment variables
  if (!apiUrl) {
    console.error('Error: XEAMS_URL environment variable is not set');
    process.exit(1);
  }
  if (!authKey) {
    console.error('Error: XEAMS_AUTH_KEY environment variable is not set');
    process.exit(1);
  }
  if (!secret) {
    console.error('Error: XEAMS_SECRET environment variable is not set');
    process.exit(1);
  }

  // Prompt user for recipient's email address
  const recipientEmail = await prompt("Enter recipient's email address (re): ");
  if (!recipientEmail) {
    console.error("Error: Recipient's email address cannot be empty");
    process.exit(1);
  }

  // Prompt for sender's email address (required by API)
  const senderEmail = await prompt("Enter sender's email address (se): ");
  if (!senderEmail) {
    console.error("Error: Sender's email address cannot be empty");
    process.exit(1);
  }

  // Optional: prompt for deep check
  const deepCheckInput = await prompt('Perform deep check? (y/n, default: y): ');
  const deep = deepCheckInput.toLowerCase() !== 'n';

  // Construct the API endpoint URL
  const endpoint = `${apiUrl.replace(/\/$/, '')}/email/validate`;

  // Prepare query parameters
  const params = new URLSearchParams({
    'auth-key': authKey,
    'secret': secret,
    're': recipientEmail,
    'se': senderEmail,
    'deep': String(deep)
  });

  try {
    // Make the API request
    console.log(`\nValidating email: ${recipientEmail}...`);
    const response = await fetch(`${endpoint}?${params.toString()}`);

    // Parse response
    if (response.status === 200) {
      const data: ValidationResponse = await response.json();
      const code = data.code || 0;
      const description = data.description || 'No description';

      console.log('\nValidation Result:');
      console.log(`  Code: ${code}`);
      console.log(`  Description: ${description}`);

      // Interpret the code
      switch (code) {
        case 1:
          console.log('  Status: ? Email is valid');
          break;
        case 2:
          console.log('  Status: ? Email address is invalid');
          break;
        case 3:
          console.log('  Status: ? Domain is invalid');
          break;
        case 4:
          console.log('  Status: ? User does not exist');
          break;
        case 5:
          console.log('  Status: ? Inconclusive (server not listening or greylisted)');
          break;
        default:
          console.log('  Status: Unknown code');
      }
    } else if (response.status === 400) {
      const data: ValidationResponse = await response.json();
      console.error(`Error: Bad request - ${data.description || 'Invalid input'}`);
      process.exit(1);
    } else if (response.status === 401) {
      console.error('Error: Invalid auth-key or secret');
      process.exit(1);
    } else {
      console.error(`Error: Unexpected response (HTTP ${response.status})`);
      console.error(await response.text());
      process.exit(1);
    }
  } catch (error) {
    if (error instanceof Error) {
      console.error(`Error: Failed to connect to API - ${error.message}`);
    } else {
      console.error(`Error: ${error}`);
    }
    process.exit(1);
  }
}

// Run the script
validateEmail();
	
	

	
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

/**
 * Email validation script using Xeams API
 * Validates an email address using the /email/validate endpoint
 * Compatible with JRE 21
 */
public class validate {
    
    private static final HttpClient httpClient = HttpClient.newHttpClient();
    
    public static void main(String[] args) {
        try {
            validateEmail();
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            System.exit(1);
        }
    }
    
    private static void validateEmail() throws IOException, InterruptedException {
        // Read configuration from environment variables
        String apiUrl = System.getenv("XEAMS_URL");
        String authKey = System.getenv("XEAMS_AUTH_KEY");
        String secret = System.getenv("XEAMS_SECRET");
        
        // Validate environment variables
        if (apiUrl == null || apiUrl.isEmpty()) {
            System.err.println("Error: XEAMS_URL environment variable is not set");
            System.exit(1);
        }
        if (authKey == null || authKey.isEmpty()) {
            System.err.println("Error: XEAMS_AUTH_KEY environment variable is not set");
            System.exit(1);
        }
        if (secret == null || secret.isEmpty()) {
            System.err.println("Error: XEAMS_SECRET environment variable is not set");
            System.exit(1);
        }
        
        Scanner scanner = new Scanner(System.in);
        
        // Prompt user for recipient's email address
        System.out.print("Enter recipient's email address (re): ");
        String recipientEmail = scanner.nextLine().trim();
        if (recipientEmail.isEmpty()) {
            System.err.println("Error: Recipient's email address cannot be empty");
            System.exit(1);
        }
        
        // Prompt for sender's email address (required by API)
        System.out.print("Enter sender's email address (se): ");
        String senderEmail = scanner.nextLine().trim();
        if (senderEmail.isEmpty()) {
            System.err.println("Error: Sender's email address cannot be empty");
            System.exit(1);
        }
        
        // Optional: prompt for deep check
        System.out.print("Perform deep check? (y/n, default: y): ");
        String deepCheckInput = scanner.nextLine().trim().toLowerCase();
        boolean deep = !deepCheckInput.equals("n");
        
        scanner.close();
        
        // Construct the API endpoint URL
        String endpoint = apiUrl.replaceAll("/$", "") + "/email/validate";
        
        // Build query parameters
        String queryParams = String.format(
            "auth-key=%s&secret=%s&re=%s&se=%s&deep=%s",
            URLEncoder.encode(authKey, StandardCharsets.UTF_8),
            URLEncoder.encode(secret, StandardCharsets.UTF_8),
            URLEncoder.encode(recipientEmail, StandardCharsets.UTF_8),
            URLEncoder.encode(senderEmail, StandardCharsets.UTF_8),
            String.valueOf(deep)
        );
        
        String fullUrl = endpoint + "?" + queryParams;
        
        // Create HTTP request
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(fullUrl))
            .GET()
            .build();
        
        try {
            // Make the API request
            System.out.println("\nValidating email: " + recipientEmail + "...");
            HttpResponse response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
            
            // Parse response
            int statusCode = response.statusCode();
            String responseBody = response.body();
            
            if (statusCode == 200) {
                ValidationResponse data = parseResponse(responseBody);
                int code = data.code;
                String description = data.description;
                
                System.out.println("\nValidation Result:");
                System.out.println("  Code: " + code);
                System.out.println("  Description: " + description);
                
                // Interpret the code
                switch (code) {
                    case 1:
                        System.out.println("  Status: ? Email is valid");
                        break;
                    case 2:
                        System.out.println("  Status: ? Email address is invalid");
                        break;
                    case 3:
                        System.out.println("  Status: ? Domain is invalid");
                        break;
                    case 4:
                        System.out.println("  Status: ? User does not exist");
                        break;
                    case 5:
                        System.out.println("  Status: ? Inconclusive (server not listening or greylisted)");
                        break;
                    default:
                        System.out.println("  Status: Unknown code");
                }
            } else if (statusCode == 400) {
                ValidationResponse data = parseResponse(responseBody);
                System.err.println("Error: Bad request - " + data.description);
                System.exit(1);
            } else if (statusCode == 401) {
                System.err.println("Error: Invalid auth-key or secret");
                System.exit(1);
            } else {
                System.err.println("Error: Unexpected response (HTTP " + statusCode + ")");
                System.err.println(responseBody);
                System.exit(1);
            }
        } catch (IOException | InterruptedException e) {
            System.err.println("Error: Failed to connect to API - " + e.getMessage());
            System.exit(1);
        }
    }
    
    private static ValidationResponse parseResponse(String json) {
        // Simple JSON parsing for code and description
        ValidationResponse response = new ValidationResponse();
        
        // Extract code
        int codeIndex = json.indexOf("\"code\"");
        if (codeIndex != -1) {
            int colonIndex = json.indexOf(":", codeIndex);
            int commaIndex = json.indexOf(",", colonIndex);
            if (commaIndex == -1) {
                commaIndex = json.indexOf("}", colonIndex);
            }
            String codeStr = json.substring(colonIndex + 1, commaIndex).trim();
            response.code = Integer.parseInt(codeStr);
        }
        
        // Extract description
        int descIndex = json.indexOf("\"description\"");
        if (descIndex != -1) {
            int colonIndex = json.indexOf(":", descIndex);
            int quoteStart = json.indexOf("\"", colonIndex);
            int quoteEnd = json.indexOf("\"", quoteStart + 1);
            response.description = json.substring(quoteStart + 1, quoteEnd);
        } else {
            response.description = "No description";
        }
        
        return response;
    }
    
    private static class ValidationResponse {
        int code = 0;
        String description = "No description";
    }
}