OpenCode

OpenCode es un asistente de codificación de IA de código abierto para la terminal. Aprende cómo usar EmailVerify para verificación de correos en tus flujos de trabajo de OpenCode.

¿Qué es OpenCode?

OpenCode es un asistente de codificación de IA de código abierto impulsado por la comunidad que proporciona:

Generación de código en lenguaje natural
Ejecución de comandos de shell
Revisión y depuración de código
Integración con LLMs locales y en la nube

Configuración

Instalar el CLI de EmailVerify

npm install -g @emailverify/cli
bv config set api-key YOUR_API_KEY

Configurar el Entorno

Agrega a tu configuración de shell:

export EMAILVERIFY_API_KEY=your-api-key

Uso con OpenCode

Verificación Básica

Tú: Verifica si user@company.com es un correo válido usando el comando bv

OpenCode:

Ejecutaré el CLI de EmailVerify para verificar ese correo.

$ bv verify user@company.com

Email: user@company.com
Status: valid
Score: 0.92
Deliverable: yes
Disposable: no
Role: no

El correo es válido y seguro de usar.

Generar Código de Verificación

Tú: Crea una función TypeScript para verificar correos con EmailVerify

OpenCode:

async function verifyEmail(email: string): Promise<VerificationResult> {
  const response = await fetch('https://api.emailverify.ai/v1/verify', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.EMAILVERIFY_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ email }),
  });

  if (!response.ok) {
    throw new Error(`Verification failed: ${response.statusText}`);
  }

  return response.json();
}

interface VerificationResult {
  email: string;
  status: 'valid' | 'invalid' | 'unknown';
  score: number;
  result: {
    deliverable: boolean;
    disposable: boolean;
    role: boolean;
  };
}

Procesamiento de Datos

Tú: Escribe un script para limpiar mi base de datos de usuarios verificando todos los correos

OpenCode:

#!/usr/bin/env python3
"""
Limpiar base de datos de usuarios verificando direcciones de correo.
Mueve correos inválidos a una tabla separada para revisión.
"""
import os
import requests
import sqlite3
from typing import List, Tuple

API_KEY = os.environ['EMAILVERIFY_API_KEY']
API_URL = 'https://api.emailverify.ai/v1/verify'

def verify_email(email: str) -> dict:
    """Verificar una sola dirección de correo."""
    response = requests.post(
        API_URL,
        headers={
            'Authorization': f'Bearer {API_KEY}',
            'Content-Type': 'application/json',
        },
        json={'email': email}
    )
    return response.json()

def process_users(db_path: str) -> Tuple[int, int, int]:
    """Procesar todos los usuarios y categorizar por validez del correo."""
    conn = sqlite3.connect(db_path)
    cursor = conn.cursor()

    # Crear tabla para correos inválidos si no existe
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS invalid_emails (
            user_id INTEGER,
            email TEXT,
            reason TEXT,
            verified_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )
    ''')

    # Obtener todos los usuarios
    cursor.execute('SELECT id, email FROM users')
    users = cursor.fetchall()

    valid = 0
    invalid = 0
    unknown = 0

    for user_id, email in users:
        result = verify_email(email)

        if result['status'] == 'valid':
            valid += 1
        elif result['status'] == 'invalid':
            invalid += 1
            cursor.execute(
                'INSERT INTO invalid_emails (user_id, email, reason) VALUES (?, ?, ?)',
                (user_id, email, 'invalid')
            )
        else:
            unknown += 1

        # Limitación de tasa
        import time
        time.sleep(0.1)

    conn.commit()
    conn.close()

    return valid, invalid, unknown

if __name__ == '__main__':
    valid, invalid, unknown = process_users('users.db')
    print(f'Results: {valid} valid, {invalid} invalid, {unknown} unknown')

Integración CI/CD

Tú: Agrega verificación de correos a mi flujo de trabajo de GitHub Actions

OpenCode:

# .github/workflows/verify-test-emails.yml
name: Verify Test Emails

on:
  pull_request:
    paths:
      - 'test/**'
      - 'fixtures/**'

jobs:
  verify-emails:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install EmailVerify CLI
        run: npm install -g @emailverify/cli

      - name: Extract and verify emails
        env:
          EMAILVERIFY_API_KEY: ${{ secrets.EMAILVERIFY_API_KEY }}
        run: |
          # Encontrar todas las direcciones de correo en archivos de prueba
          emails=$(grep -rhoE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' test/ fixtures/ | sort -u)

          echo "Found emails to verify:"
          echo "$emails"

          # Verificar cada correo
          failed=0
          for email in $emails; do
            # Omitir dominios example.com y de prueba
            if [[ "$email" =~ @(example\.(com|org|net)|test\.com)$ ]]; then
              echo "⏭️ Skipping test domain: $email"
              continue
            fi

            result=$(bv verify "$email" --json 2>/dev/null)
            status=$(echo "$result" | jq -r '.status')

            if [ "$status" = "valid" ]; then
              echo "⚠️ Real email found in tests: $email"
              failed=1
            fi
          done

          if [ $failed -eq 1 ]; then
            echo "::error::Real email addresses found in test files!"
            exit 1
          fi

          echo "✅ No real emails in test files"

Recetas de Automatización

Script de Procesamiento por Lotes

#!/bin/bash
# verify-list.sh - Verificar una lista de correos y generar resultados como CSV

input_file="${1:-emails.txt}"
output_file="${2:-results.csv}"

echo "email,status,score,disposable,role" > "$output_file"

while IFS= read -r email; do
    [ -z "$email" ] && continue

    result=$(bv verify "$email" --json 2>/dev/null)

    status=$(echo "$result" | jq -r '.status')
    score=$(echo "$result" | jq -r '.score')
    disposable=$(echo "$result" | jq -r '.result.disposable')
    role=$(echo "$result" | jq -r '.result.role')

    echo "$email,$status,$score,$disposable,$role" >> "$output_file"

    # Indicador de progreso
    echo -n "."
done < "$input_file"

echo ""
echo "Results saved to $output_file"

Manejador de Webhook

// webhook-handler.js - Verificar correos desde eventos de webhook

const express = require('express');
const app = express();

app.use(express.json());

app.post('/webhook/new-signup', async (req, res) => {
  const { email, userId } = req.body;

  // Verificar el correo
  const verifyResponse = await fetch('https://api.emailverify.ai/v1/verify', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.EMAILVERIFY_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ email }),
  });

  const result = await verifyResponse.json();

  if (result.status === 'invalid' || result.result.disposable) {
    // Marcar el usuario para revisión
    console.log(`Flagged user ${userId}: ${email} - ${result.status}`);
    // await flagUser(userId, 'suspicious_email');
  }

  res.json({ verified: true, result });
});

app.listen(3000);

Próximos Pasos

Droid

Asistente terminal Droid

Claude Code

Integración con Claude Code

Referencia de API

Documentación completa de la API

OpenCode

Droid

Claude Code

Referencia de API

On this page