woloski · July 21, 2025 21:01
diff --git a/README.md b/README.md
diff --git a/gmail-client.ts b/gmail-client.ts
 import { google } from "googleapis"

 const SCOPES = ["https://www.googleapis.com/auth/gmail.send"]

 export interface EmailData {
  from: string
  to: string
  subject: string
  body: string
 }

 export interface EmailResponse {
  success: boolean
  messageId?: string
  message: string
  error?: string
 }

 export interface FromField {
  email: string
  name?: string
 }

 /**
 * Configuración de variables de entorno para Gmail
 */
 export const config = {
  gmail: {
    privateKey: process.env.GOOGLE_PRIVATE_KEY,
    clientEmail: process.env.GOOGLE_CLIENT_EMAIL,
  }
 }

 /**
 * Valida que todas las variables de entorno requeridas estén configuradas
 */
 export function validateConfig() {
  const missingVars = []
  
  if (!config.gmail.privateKey) {
    missingVars.push("GOOGLE_PRIVATE_KEY")
  }
  
  if (!config.gmail.clientEmail) {
    missingVars.push("GOOGLE_CLIENT_EMAIL")
  }
  
  if (missingVars.length > 0) {
    throw new Error(`Variables de entorno faltantes: ${missingVars.join(", ")}`)
  }
 }

 /**
 * Limpia y formatea la clave privada de Google
 */
 export function cleanPrivateKey(privateKey: string): string {
  let cleanKey = privateKey.trim()

  // Remover comillas dobles extra del inicio y final si existen
  if (cleanKey.startsWith('""') && cleanKey.endsWith('""')) {
    cleanKey = cleanKey.slice(2, -2)
  } else if (cleanKey.startsWith('"') && cleanKey.endsWith('"')) {
    cleanKey = cleanKey.slice(1, -1)
  }

  // Reemplazar \n literales con saltos de línea reales
  if (cleanKey.includes("\\n")) {
    cleanKey = cleanKey.replace(/\\n/g, "\n")
  }

  // Si la clave no tiene el formato PEM correcto, intentar formatearla
  if (!cleanKey.includes("-----BEGIN PRIVATE KEY-----")) {
    // Si es una clave en formato base64 sin formato PEM, agregar los headers
    if (cleanKey.length > 100 && !cleanKey.includes("-----")) {
      const chunks = []
      for (let i = 0; i < cleanKey.length; i += 64) {
        chunks.push(cleanKey.slice(i, i + 64))
      }
      cleanKey = `-----BEGIN PRIVATE KEY-----\n${chunks.join("\n")}\n-----END PRIVATE KEY-----`
    }
  }

  // Asegurar que termina con un salto de línea
  if (!cleanKey.endsWith("\n")) {
    cleanKey += "\n"
  }

  return cleanKey
 }

 /**
 * Parsea el campo "from" para extraer email y nombre
 */
 export function parseFromField(from: string): FromField {
  const nameEmailRegex = /^(.+?)\s*<(.+?)>$/
  const match = from.match(nameEmailRegex)

  if (match) {
    return {
      name: match[1].trim(),
      email: match[2].trim(),
    }
  }

  return { email: from.trim() }
 }

 /**
 * Valida el formato de email
 */
 export function isValidEmail(email: string): boolean {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
  return emailRegex.test(email)
 }

 /**
 * Crea el cliente de Gmail autenticado
 */
 export async function createGmailClient(userEmail: string) {
  validateConfig()
  
  const privateKey = cleanPrivateKey(config.gmail.privateKey!)

  const jwtClient = new google.auth.JWT({
    email: config.gmail.clientEmail!,
    key: privateKey,
    scopes: SCOPES,
    subject: userEmail,
  })

  await jwtClient.authorize()
  return google.gmail({ version: "v1", auth: jwtClient })
 }

 /**
 * Crea el mensaje de email en formato base64
 */
 export function createEmailMessage(from: string, to: string, subject: string, body: string): string {
  const parsedFrom = parseFromField(from)
  const htmlBody = body.replace(/\n/g, "<br>")
  const fromHeader = parsedFrom.name ? `${parsedFrom.name} <${parsedFrom.email}>` : parsedFrom.email

  const emailLines = [
    `From: ${fromHeader}`,
    `To: ${to}`,
    `Subject: ${subject}`,
    "MIME-Version: 1.0",
    "Content-Type: text/html; charset=utf-8",
    "",
    htmlBody,
  ]

  const email = emailLines.join("\r\n")
  return Buffer.from(email).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "")
 }

 /**
 * Envía un email usando Gmail API
 */
 export async function sendEmail(emailData: EmailData): Promise<EmailResponse> {
  try {
    const { from, to, subject, body } = emailData

    // Validaciones básicas
    if (!from || !to || !subject || !body) {
      return {
        success: false,
        message: "Todos los campos son requeridos",
        error: "MISSING_FIELDS"
      }
    }

    const parsedFrom = parseFromField(from)

    if (!isValidEmail(parsedFrom.email) || !isValidEmail(to)) {
      return {
        success: false,
        message: "Formato de email inválido",
        error: "INVALID_EMAIL_FORMAT"
      }
    }

    const gmail = await createGmailClient(parsedFrom.email)
    const encodedMessage = createEmailMessage(from, to, subject, body)

    const result = await gmail.users.messages.send({
      userId: "me",
      requestBody: { raw: encodedMessage },
    })

    return {
      success: true,
      messageId: result.data.id || undefined,
      message: "Email enviado exitosamente"
    }

  } catch (error: any) {
    console.error("Error sending email:", error)

    let errorMessage = "Error interno del servidor"
    let errorCode = "INTERNAL_ERROR"

    if (error.message?.includes("invalid_grant")) {
      errorMessage = "Credenciales inválidas o domain delegation no configurado"
      errorCode = "INVALID_CREDENTIALS"
    } else if (error.message?.includes("access_denied")) {
      errorMessage = "Acceso denegado. Verifica la configuración de domain-wide delegation"
      errorCode = "ACCESS_DENIED"
    } else if (error.message?.includes("unauthorized_client")) {
      errorMessage = "Cliente no autorizado. Verifica los permisos del service account"
      errorCode = "UNAUTHORIZED_CLIENT"
    } else if (error.message?.includes("DECODER routines") || error.message?.includes("unsupported")) {
      errorMessage = "Error en el formato de la clave privada. Verifica que GOOGLE_PRIVATE_KEY esté correctamente configurada"
      errorCode = "INVALID_PRIVATE_KEY"
    } else if (error.message?.includes("ERR_OSSL_UNSUPPORTED")) {
      errorMessage = "Formato de clave privada no soportado. Asegúrate de que la clave esté en formato PEM correcto"
      errorCode = "UNSUPPORTED_KEY_FORMAT"
    }

    return {
      success: false,
      message: errorMessage,
      error: errorCode
    }
  }
 }

 /**
 * Configura las credenciales de Gmail
 */
 export function configureGmail(credentials: { privateKey: string; clientEmail: string }) {
  config.gmail.privateKey = credentials.privateKey
  config.gmail.clientEmail = credentials.clientEmail
 }

 /**
 * Verifica si la configuración está completa
 */
 export function isConfigured(): boolean {
  return !!(config.gmail.privateKey && config.gmail.clientEmail)
 }
	import { google } from "googleapis"

	const SCOPES = ["https://www.googleapis.com/auth/gmail.send"]

	export interface EmailData {
	from: string
	to: string
	subject: string
	body: string
	}

	export interface EmailResponse {
	success: boolean
	messageId?: string
	message: string
	error?: string
	}

	export interface FromField {
	email: string
	name?: string
	}

	/**
	* Configuración de variables de entorno para Gmail
	*/
	export const config = {
	gmail: {
	privateKey: process.env.GOOGLE_PRIVATE_KEY,
	clientEmail: process.env.GOOGLE_CLIENT_EMAIL,
	}
	}

	/**
	* Valida que todas las variables de entorno requeridas estén configuradas
	*/
	export function validateConfig() {
	const missingVars = []

	if (!config.gmail.privateKey) {
	missingVars.push("GOOGLE_PRIVATE_KEY")
	}

	if (!config.gmail.clientEmail) {
	missingVars.push("GOOGLE_CLIENT_EMAIL")
	}

	if (missingVars.length > 0) {
	throw new Error(`Variables de entorno faltantes: ${missingVars.join(", ")}`)
	}
	}

	/**
	* Limpia y formatea la clave privada de Google
	*/
	export function cleanPrivateKey(privateKey: string): string {
	let cleanKey = privateKey.trim()

	// Remover comillas dobles extra del inicio y final si existen
	if (cleanKey.startsWith('""') && cleanKey.endsWith('""')) {
	cleanKey = cleanKey.slice(2, -2)
	} else if (cleanKey.startsWith('"') && cleanKey.endsWith('"')) {
	cleanKey = cleanKey.slice(1, -1)
	}

	// Reemplazar \n literales con saltos de línea reales
	if (cleanKey.includes("\\n")) {
	cleanKey = cleanKey.replace(/\\n/g, "\n")
	}

	// Si la clave no tiene el formato PEM correcto, intentar formatearla
	if (!cleanKey.includes("-----BEGIN PRIVATE KEY-----")) {
	// Si es una clave en formato base64 sin formato PEM, agregar los headers
	if (cleanKey.length > 100 && !cleanKey.includes("-----")) {
	const chunks = []
	for (let i = 0; i < cleanKey.length; i += 64) {
	chunks.push(cleanKey.slice(i, i + 64))
	}
	cleanKey = `-----BEGIN PRIVATE KEY-----\n${chunks.join("\n")}\n-----END PRIVATE KEY-----`
	}
	}

	// Asegurar que termina con un salto de línea
	if (!cleanKey.endsWith("\n")) {
	cleanKey += "\n"
	}

	return cleanKey
	}

	/**
	* Parsea el campo "from" para extraer email y nombre
	*/
	export function parseFromField(from: string): FromField {
	const nameEmailRegex = /^(.+?)\s*<(.+?)>$/
	const match = from.match(nameEmailRegex)

	if (match) {
	return {
	name: match[1].trim(),
	email: match[2].trim(),
	}
	}

	return { email: from.trim() }
	}

	/**
	* Valida el formato de email
	*/
	export function isValidEmail(email: string): boolean {
	const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
	return emailRegex.test(email)
	}

	/**
	* Crea el cliente de Gmail autenticado
	*/
	export async function createGmailClient(userEmail: string) {
	validateConfig()

	const privateKey = cleanPrivateKey(config.gmail.privateKey!)

	const jwtClient = new google.auth.JWT({
	email: config.gmail.clientEmail!,
	key: privateKey,
	scopes: SCOPES,
	subject: userEmail,
	})

	await jwtClient.authorize()
	return google.gmail({ version: "v1", auth: jwtClient })
	}

	/**
	* Crea el mensaje de email en formato base64
	*/
	export function createEmailMessage(from: string, to: string, subject: string, body: string): string {
	const parsedFrom = parseFromField(from)
	const htmlBody = body.replace(/\n/g, "<br>")
	const fromHeader = parsedFrom.name ? `${parsedFrom.name} <${parsedFrom.email}>` : parsedFrom.email

	const emailLines = [
	`From: ${fromHeader}`,
	`To: ${to}`,
	`Subject: ${subject}`,
	"MIME-Version: 1.0",
	"Content-Type: text/html; charset=utf-8",
	"",
	htmlBody,
	]

	const email = emailLines.join("\r\n")
	return Buffer.from(email).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "")
	}

	/**
	* Envía un email usando Gmail API
	*/
	export async function sendEmail(emailData: EmailData): Promise<EmailResponse> {
	try {
	const { from, to, subject, body } = emailData

	// Validaciones básicas
	if (!from \|\| !to \|\| !subject \|\| !body) {
	return {
	success: false,
	message: "Todos los campos son requeridos",
	error: "MISSING_FIELDS"
	}
	}

	const parsedFrom = parseFromField(from)

	if (!isValidEmail(parsedFrom.email) \|\| !isValidEmail(to)) {
	return {
	success: false,
	message: "Formato de email inválido",
	error: "INVALID_EMAIL_FORMAT"
	}
	}

	const gmail = await createGmailClient(parsedFrom.email)
	const encodedMessage = createEmailMessage(from, to, subject, body)

	const result = await gmail.users.messages.send({
	userId: "me",
	requestBody: { raw: encodedMessage },
	})

	return {
	success: true,
	messageId: result.data.id \|\| undefined,
	message: "Email enviado exitosamente"
	}

	} catch (error: any) {
	console.error("Error sending email:", error)

	let errorMessage = "Error interno del servidor"
	let errorCode = "INTERNAL_ERROR"

	if (error.message?.includes("invalid_grant")) {
	errorMessage = "Credenciales inválidas o domain delegation no configurado"
	errorCode = "INVALID_CREDENTIALS"
	} else if (error.message?.includes("access_denied")) {
	errorMessage = "Acceso denegado. Verifica la configuración de domain-wide delegation"
	errorCode = "ACCESS_DENIED"
	} else if (error.message?.includes("unauthorized_client")) {
	errorMessage = "Cliente no autorizado. Verifica los permisos del service account"
	errorCode = "UNAUTHORIZED_CLIENT"
	} else if (error.message?.includes("DECODER routines") \|\| error.message?.includes("unsupported")) {
	errorMessage = "Error en el formato de la clave privada. Verifica que GOOGLE_PRIVATE_KEY esté correctamente configurada"
	errorCode = "INVALID_PRIVATE_KEY"
	} else if (error.message?.includes("ERR_OSSL_UNSUPPORTED")) {
	errorMessage = "Formato de clave privada no soportado. Asegúrate de que la clave esté en formato PEM correcto"
	errorCode = "UNSUPPORTED_KEY_FORMAT"
	}

	return {
	success: false,
	message: errorMessage,
	error: errorCode
	}
	}
	}

	/**
	* Configura las credenciales de Gmail
	*/
	export function configureGmail(credentials: { privateKey: string; clientEmail: string }) {
	config.gmail.privateKey = credentials.privateKey
	config.gmail.clientEmail = credentials.clientEmail
	}

	/**
	* Verifica si la configuración está completa
	*/
	export function isConfigured(): boolean {
	return !!(config.gmail.privateKey && config.gmail.clientEmail)
	}
No results found