OpenCode

OpenCode est un assistant de codage IA open-source pour le terminal. Découvrez comment utiliser EmailVerify pour la vérification d'email dans vos flux de travail OpenCode.

Qu'est-ce qu'OpenCode ?

OpenCode est un assistant de codage IA open-source piloté par la communauté qui fournit :

La génération de code en langage naturel
L'exécution de commandes shell
La révision et le débogage de code
L'intégration avec des LLM locaux et cloud

Configuration

Installer la CLI EmailVerify

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

Configurer l'environnement

Ajoutez à votre configuration shell :

export EMAILVERIFY_API_KEY=your-api-key

Utilisation avec OpenCode

Vérification de base

Vous : Vérifie si user@company.com est un email valide en utilisant la commande bv

OpenCode :

Je vais exécuter la CLI EmailVerify pour vérifier cet email.

$ bv verify user@company.com

Email: user@company.com
Statut: valid
Score: 0.92
Livrable: oui
Jetable: non
Rôle: non

L'email est valide et sûr à utiliser.

Générer du code de vérification

Vous : Crée une fonction TypeScript pour vérifier les emails avec 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;
  };
}

Traitement de données

Vous : Écris un script pour nettoyer ma base de données utilisateur en vérifiant tous les emails

OpenCode :

#!/usr/bin/env python3
"""
Nettoyer la base de données utilisateur en vérifiant les adresses email.
Déplace les emails invalides vers une table séparée pour révision.
"""
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:
    """Vérifier une seule adresse email."""
    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]:
    """Traiter tous les utilisateurs et catégoriser par validité d'email."""
    conn = sqlite3.connect(db_path)
    cursor = conn.cursor()

    # Créer une table pour les emails invalides si elle n'existe pas
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS invalid_emails (
            user_id INTEGER,
            email TEXT,
            reason TEXT,
            verified_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )
    ''')

    # Obtenir tous les utilisateurs
    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

        # Limitation de débit
        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'Résultats : {valid} valides, {invalid} invalides, {unknown} inconnus')

Intégration CI/CD

Vous : Ajoute la vérification d'email à mon workflow 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: |
          # Trouver toutes les adresses email dans les fichiers de test
          emails=$(grep -rhoE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' test/ fixtures/ | sort -u)

          echo "Emails trouvés à vérifier :"
          echo "$emails"

          # Vérifier chaque email
          failed=0
          for email in $emails; do
            # Ignorer example.com et les domaines de test
            if [[ "$email" =~ @(example\.(com|org|net)|test\.com)$ ]]; then
              echo "⏭️ Ignorer le domaine de test : $email"
              continue
            fi

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

            if [ "$status" = "valid" ]; then
              echo "⚠️ Vrai email trouvé dans les tests : $email"
              failed=1
            fi
          done

          if [ $failed -eq 1 ]; then
            echo "::error::Vraies adresses email trouvées dans les fichiers de test !"
            exit 1
          fi

          echo "✅ Pas de vrais emails dans les fichiers de test"

Recettes d'automatisation

Script de traitement par lots

#!/bin/bash
# verify-list.sh - Vérifier une liste d'emails et afficher les résultats en 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"

    # Indicateur de progression
    echo -n "."
done < "$input_file"

echo ""
echo "Résultats enregistrés dans $output_file"

Gestionnaire de webhook

// webhook-handler.js - Vérifier les emails depuis les événements 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;

  // Vérifier l'email
  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) {
    // Signaler l'utilisateur pour révision
    console.log(`Utilisateur signalé ${userId}: ${email} - ${result.status}`);
    // await flagUser(userId, 'suspicious_email');
  }

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

app.listen(3000);

Prochaines étapes

Droid

Assistant terminal Droid

Claude Code

Intégration Claude Code

Référence API

Documentation API complète

OpenCode

Droid

Claude Code

Référence API

On this page