cdp-edge 1.23.3 → 1.24.0

package/server-edge-tracker/modules/dispatch/{platforms.js → platforms.ts}

@@ -5,9 +5,11 @@
 
 import { sha256, normalizePhone } from '../utils.js';
 import { logApiFailure } from '../db.js';
+import { Env, TrackPayload } from '../../types.js';
+import { ExecutionContext } from '@cloudflare/workers-types';
 
 // ── Pinterest Conversions API v5 ──────────────────────────────────────────────
-export async function sendPinterestCapi(env, eventName, payload, request, ctx) {
+export async function sendPinterestCapi(env: Env, eventName: string, payload: TrackPayload, request: Request | null, ctx: ExecutionContext | null): Promise<any> {
   if (!env.PINTEREST_ACCESS_TOKEN || !env.PINTEREST_AD_ACCOUNT_ID) {
     return { skipped: 'Pinterest credentials not set' };
   }
@@ -15,19 +17,19 @@ export async function sendPinterestCapi(env, eventName, payload, request, ctx) {
   const { email, phone, userId, eventId, pageUrl, value, currency, contentIds, contentName } = payload;
   const phoneNorm = normalizePhone(phone);
 
-  const pinterestEventMap = {
+  const pinterestEventMap: Record<string, string> = {
     PageView: 'pagevisit', ViewContent: 'pagevisit', Lead: 'lead', Purchase: 'checkout',
     AddToCart: 'addtocart', InitiateCheckout: 'checkout', CompleteRegistration: 'signup',
     Search: 'search', Contact: 'lead',
   };
   const pEvent = pinterestEventMap[eventName] || 'custom';
 
-  const userData = {
-    ...(email     && { em: [await sha256(email)] }),
-    ...(phoneNorm && { ph: [await sha256(phoneNorm)] }),
-    ...(userId    && { external_id: [await sha256(String(userId))] }),
-    client_ip_address: request.headers.get('CF-Connecting-IP') || '',
-    client_user_agent: request.headers.get('User-Agent') || '',
+  const userData: Record<string, string | string[]> = {
+    ...(email     && { em: [await sha256(email) || ''] }),
+    ...(phoneNorm && { ph: [await sha256(phoneNorm) || ''] }),
+    ...(userId    && { external_id: [await sha256(String(userId)) || ''] }),
+    client_ip_address: request?.headers.get('CF-Connecting-IP') || '',
+    client_user_agent: request?.headers.get('User-Agent') || '',
   };
 
   const body = {
@@ -40,8 +42,8 @@ export async function sendPinterestCapi(env, eventName, payload, request, ctx) {
       user_data:        userData,
       custom_data: {
         currency:     (currency || 'BRL').toUpperCase(),
-        value:        value ? String(parseFloat(value)) : '0',
-        ...(contentIds?.length > 0 && { content_ids: contentIds.map(String) }),
+        value:        value ? String(parseFloat(String(value))) : '0',
+        ...(contentIds && contentIds.length > 0 && { content_ids: contentIds.map(String) }),
         ...(contentName            && { content_name: contentName }),
         content_type: 'product',
       },
@@ -55,20 +57,20 @@ export async function sendPinterestCapi(env, eventName, payload, request, ctx) {
     );
     const data = await res.json();
     if (!res.ok) {
-      const msg = data.message || data.code || String(res.status);
+      const msg = (data as any).message || (data as any).code || String(res.status);
       console.error('Pinterest CAPI error:', res.status, msg);
-      if (env.DB && ctx) ctx.waitUntil(logApiFailure(env.DB, 'pinterest', eventName, String(res.status), msg, body.data[0].event_id, JSON.stringify(body)));
+      if (env.DB && ctx) ctx.waitUntil(logApiFailure(env.DB, 'pinterest', eventName, String(res.status), msg, (body.data as any)[0].event_id, JSON.stringify(body)));
     }
     return data;
-  } catch (err) {
-    console.error('Pinterest CAPI fetch failed:', err.message);
-    if (env.DB && ctx) ctx.waitUntil(logApiFailure(env.DB, 'pinterest', eventName, 'FETCH_ERROR', err.message, null, JSON.stringify(body)));
-    return { error: err.message };
+  } catch (err: any) {
+    console.error('Pinterest CAPI fetch failed:', err?.message || String(err));
+    if (env.DB && ctx) ctx.waitUntil(logApiFailure(env.DB, 'pinterest', eventName, 'FETCH_ERROR', err?.message || String(err), '', JSON.stringify(body)));
+    return { error: err?.message || String(err) };
   }
 }
 
 // ── Reddit Conversions API v2.0 ───────────────────────────────────────────────
-export async function sendRedditCapi(env, eventName, payload, request, ctx) {
+export async function sendRedditCapi(env: Env, eventName: string, payload: TrackPayload, request: Request | null, ctx: ExecutionContext | null): Promise<any> {
   if (!env.REDDIT_ACCESS_TOKEN || !env.REDDIT_AD_ACCOUNT_ID) {
     return { skipped: 'Reddit credentials not set' };
   }
@@ -76,25 +78,25 @@ export async function sendRedditCapi(env, eventName, payload, request, ctx) {
   const { email, phone, userId, eventId, pageUrl, value, currency } = payload;
   const phoneNorm = normalizePhone(phone);
 
-  const redditEventMap = {
+  const redditEventMap: Record<string, string> = {
     PageView: 'PageVisit', ViewContent: 'ViewContent', Lead: 'Lead', Purchase: 'Purchase',
     AddToCart: 'AddToCart', InitiateCheckout: 'Purchase', CompleteRegistration: 'SignUp',
     Search: 'Search', Contact: 'Lead',
   };
   const rEvent = redditEventMap[eventName] || 'Custom';
 
-  const user = {
-    ...(email     && { email:       { value: await sha256(email) } }),
-    ...(phoneNorm && { phoneNumber: { value: await sha256(phoneNorm) } }),
-    ...(userId    && { externalId:  { value: await sha256(String(userId)) } }),
-    ipAddress: { value: request.headers.get('CF-Connecting-IP') || '' },
-    userAgent: { value: request.headers.get('User-Agent') || '' },
+  const user: Record<string, { value: string }> = {
+    ...(email     && { email:       { value: await sha256(email) || '' } }),
+    ...(phoneNorm && { phoneNumber: { value: await sha256(phoneNorm) || '' } }),
+    ...(userId    && { externalId:  { value: await sha256(String(userId)) || '' } }),
+    ipAddress: { value: request?.headers.get('CF-Connecting-IP') || '' },
+    userAgent: { value: request?.headers.get('User-Agent') || '' },
   };
 
-  const event = {
+  const event: Record<string, any> = {
     event_at:   new Date().toISOString(),
     event_type: { tracking_type: rEvent, ...(eventName === 'InitiateCheckout' && { conversion_type: 'BEGIN_CHECKOUT' }) },
-    click_id:   payload.rdtClid || '',
+    click_id:   (payload as any).rdtClid || '',
     event_metadata: {
       currency:      (currency || 'BRL').toUpperCase(),
       value_decimal: String(value || 0),
@@ -118,15 +120,15 @@ export async function sendRedditCapi(env, eventName, payload, request, ctx) {
       return { error: `HTTP ${res.status}` };
     }
     return await res.json();
-  } catch (err) {
-    console.error('Reddit CAPI fetch failed:', err.message);
-    if (env.DB && ctx) ctx.waitUntil(logApiFailure(env.DB, 'reddit', eventName, 'FETCH_ERROR', err.message, null, JSON.stringify(body)));
-    return { error: err.message };
+  } catch (err: any) {
+    console.error('Reddit CAPI fetch failed:', err?.message || String(err));
+    if (env.DB && ctx) ctx.waitUntil(logApiFailure(env.DB, 'reddit', eventName, 'FETCH_ERROR', err?.message || String(err), '', JSON.stringify(body)));
+    return { error: err?.message || String(err) };
   }
 }
 
 // ── LinkedIn Conversions API (LinkedIn-Version: 202401) ───────────────────────
-export async function sendLinkedInCapi(env, eventName, payload, request, ctx) {
+export async function sendLinkedInCapi(env: Env, eventName: string, payload: TrackPayload, request: Request | null, ctx: ExecutionContext | null): Promise<any> {
   if (!env.LINKEDIN_ACCESS_TOKEN || !env.LINKEDIN_CONVERSION_ID) {
     return { skipped: 'LinkedIn credentials not set' };
   }
@@ -134,23 +136,23 @@ export async function sendLinkedInCapi(env, eventName, payload, request, ctx) {
   const { email, phone, firstName, lastName, userId, eventId, pageUrl, value, currency } = payload;
   const phoneNorm = normalizePhone(phone);
 
-  const linkedInEventMap = {
+  const linkedInEventMap: Record<string, string> = {
     Lead: 'LEAD', Purchase: 'PURCHASE', CompleteRegistration: 'REGISTRATION',
     AddToCart: 'ADD_TO_CART', InitiateCheckout: 'OTHER', ViewContent: 'OTHER',
     PageView: 'OTHER', Contact: 'LEAD',
   };
 
-  const userInfo = {
-    ...(email     && { 'SHA256_EMAIL':      await sha256(email) }),
-    ...(phoneNorm && { 'SHA256_PHONE':      await sha256(phoneNorm) }),
-    ...(firstName && { 'SHA256_FIRST_NAME': await sha256(firstName.toLowerCase().trim()) }),
-    ...(lastName  && { 'SHA256_LAST_NAME':  await sha256(lastName.toLowerCase().trim()) }),
+  const userInfo: Record<string, string> = {
+    ...(email     && { 'SHA256_EMAIL':      await sha256(email) || '' }),
+    ...(phoneNorm && { 'SHA256_PHONE':      await sha256(phoneNorm) || '' }),
+    ...(firstName && { 'SHA256_FIRST_NAME': await sha256(firstName.toLowerCase().trim()) || '' }),
+    ...(lastName  && { 'SHA256_LAST_NAME':  await sha256(lastName.toLowerCase().trim()) || '' }),
   };
 
-  const body = {
+  const body: Record<string, any> = {
     conversion:    `urn:li:conversion:${env.LINKEDIN_CONVERSION_ID}`,
     conversionHappenedAt: Date.now(),
-    conversionValue: value ? { currencyCode: (currency || 'BRL').toUpperCase(), amount: String(parseFloat(value)) } : undefined,
+    conversionValue: value ? { currencyCode: (currency || 'BRL').toUpperCase(), amount: String(parseFloat(String(value))) } : undefined,
     eventId: eventId || `cdp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
     ...(Object.keys(userInfo).length > 0 && { user: { userIds: Object.entries(userInfo).map(([idType, idValue]) => ({ idType, idValue })) } }),
   };
@@ -173,15 +175,15 @@ export async function sendLinkedInCapi(env, eventName, payload, request, ctx) {
       return { error: `HTTP ${res.status}` };
     }
     return { ok: true };
-  } catch (err) {
-    console.error('LinkedIn CAPI fetch failed:', err.message);
-    if (env.DB && ctx) ctx.waitUntil(logApiFailure(env.DB, 'linkedin', eventName, 'FETCH_ERROR', err.message, null, JSON.stringify(body)));
-    return { error: err.message };
+  } catch (err: any) {
+    console.error('LinkedIn CAPI fetch failed:', err?.message || String(err));
+    if (env.DB && ctx) ctx.waitUntil(logApiFailure(env.DB, 'linkedin', eventName, 'FETCH_ERROR', err?.message || String(err), '', JSON.stringify(body)));
+    return { error: err?.message || String(err) };
   }
 }
 
 // ── Spotify Conversions API v1 ────────────────────────────────────────────────
-export async function sendSpotifyCapi(env, eventName, payload, request, ctx) {
+export async function sendSpotifyCapi(env: Env, eventName: string, payload: TrackPayload, request: Request | null, ctx: ExecutionContext | null): Promise<any> {
   if (!env.SPOTIFY_ACCESS_TOKEN || !env.SPOTIFY_AD_ACCOUNT_ID) {
     return { skipped: 'Spotify credentials not set' };
   }
@@ -189,19 +191,19 @@ export async function sendSpotifyCapi(env, eventName, payload, request, ctx) {
   const { email, phone, userId, eventId, pageUrl, value, currency } = payload;
   const phoneNorm = normalizePhone(phone);
 
-  const spotifyEventMap = {
+  const spotifyEventMap: Record<string, string> = {
     Purchase: 'PURCHASE', Lead: 'LEAD', CompleteRegistration: 'SIGN_UP',
     AddToCart: 'ADD_TO_CART', InitiateCheckout: 'INITIATE_CHECKOUT',
     ViewContent: 'VIEW_CONTENT', PageView: 'PAGE_VIEW', Contact: 'LEAD',
   };
   const spEvent = spotifyEventMap[eventName] || 'CUSTOM';
 
-  const user = {
-    ...(email     && { hashed_email: await sha256(email) }),
-    ...(phoneNorm && { hashed_phone: await sha256(phoneNorm) }),
+  const user: Record<string, string> = {
+    ...(email     && { hashed_email: await sha256(email) || '' }),
+    ...(phoneNorm && { hashed_phone: await sha256(phoneNorm) || '' }),
     ...(userId    && { user_id: userId }),
-    ip_address: request.headers.get('CF-Connecting-IP') || '',
-    user_agent: request.headers.get('User-Agent') || '',
+    ip_address: request?.headers.get('CF-Connecting-IP') || '',
+    user_agent: request?.headers.get('User-Agent') || '',
   };
 
   const body = {
@@ -212,7 +214,7 @@ export async function sendSpotifyCapi(env, eventName, payload, request, ctx) {
       url:        pageUrl || '',
       user,
       ...(value !== undefined && {
-        value: { currency: (currency || 'BRL').toUpperCase(), amount: parseFloat(value) },
+        value: { currency: (currency || 'BRL').toUpperCase(), amount: parseFloat(String(value)) },
       }),
     }],
   };
@@ -225,13 +227,13 @@ export async function sendSpotifyCapi(env, eventName, payload, request, ctx) {
     if (!res.ok) {
       const txt = await res.text();
       console.error('Spotify CAPI error:', txt);
-      if (env.DB && ctx) ctx.waitUntil(logApiFailure(env.DB, 'spotify', eventName, String(res.status), txt, body.data[0].event_id, JSON.stringify(body)));
+      if (env.DB && ctx) ctx.waitUntil(logApiFailure(env.DB, 'spotify', eventName, String(res.status), txt, (body.data as any)[0].event_id, JSON.stringify(body)));
       return { error: `HTTP ${res.status}` };
     }
     return await res.json();
-  } catch (err) {
-    console.error('Spotify CAPI fetch failed:', err.message);
-    if (env.DB && ctx) ctx.waitUntil(logApiFailure(env.DB, 'spotify', eventName, 'FETCH_ERROR', err.message, null, JSON.stringify(body)));
-    return { error: err.message };
+  } catch (err: any) {
+    console.error('Spotify CAPI fetch failed:', err?.message || String(err));
+    if (env.DB && ctx) ctx.waitUntil(logApiFailure(env.DB, 'spotify', eventName, 'FETCH_ERROR', err?.message || String(err), '', JSON.stringify(body)));
+    return { error: err?.message || String(err) };
   }
 }

package/server-edge-tracker/modules/dispatch/{tiktok.js → tiktok.ts}

@@ -5,8 +5,10 @@
 
 import { sha256, normalizePhone } from '../utils.js';
 import { logApiFailure } from '../db.js';
+import { Env, TrackPayload } from '../../types.js';
+import { ExecutionContext } from '@cloudflare/workers-types';
 
-export async function sendTikTokApi(env, eventName, payload, request, ctx) {
+export async function sendTikTokApi(env: Env, eventName: string, payload: TrackPayload, request: Request | null, ctx: ExecutionContext | null): Promise<any> {
   if (!env.TIKTOK_ACCESS_TOKEN) return { skipped: 'TIKTOK_ACCESS_TOKEN not set' };
 
   const pixelId = env.TIKTOK_PIXEL_ID;
@@ -22,41 +24,41 @@ export async function sendTikTokApi(env, eventName, payload, request, ctx) {
 
   const phoneNorm = normalizePhone(phone);
 
-  const user = {
-    ...(email      && { email:        await sha256(email) }),
-    ...(phoneNorm  && { phone_number: await sha256(phoneNorm) }),
-    ...(userId     && { external_id:  await sha256(String(userId)) }),
+  const user: Record<string, string> = {
+    ...(email      && { email:        await sha256(email) || '' }),
+    ...(phoneNorm  && { phone_number: await sha256(phoneNorm) || '' }),
+    ...(userId     && { external_id:  await sha256(String(userId)) || '' }),
     ...(ttp        && { ttp }),
     ...(ttclid     && { ttclid }),
   };
 
-  const properties = {
-    ...(value       !== undefined && { value: parseFloat(value) }),
+  const properties: Record<string, any> = {
+    ...(value       !== undefined && { value: parseFloat(String(value)) }),
     ...(currency    && { currency: String(currency).toUpperCase() }),
-    ...(contentIds  && contentIds.length > 0 && {
+    ...(contentIds  && contentIds && contentIds.length > 0 && {
       contents: contentIds.map(id => ({
         content_id:   String(id),
         content_name: contentName || '',
         content_type: contentType || 'product',
         quantity:     1,
-        price:        value ? parseFloat(value) : 0,
+        price:        value ? parseFloat(String(value)) : 0,
       })),
     }),
   };
 
-  const event = {
+  const event: Record<string, any> = {
     event:      eventName,
     event_time: Math.floor(Date.now() / 1000),
     event_id:   eventId || `cdp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
     user,
     page: {
       url:      pageUrl || `https://${env.SITE_DOMAIN}`,
-      referrer: request.headers.get('Referer') || '',
+      referrer: request?.headers.get('Referer') || '',
     },
     ...(Object.keys(properties).length > 0 && { properties }),
     context: {
-      ip:         request.headers.get('CF-Connecting-IP') || '',
-      user_agent: request.headers.get('User-Agent') || '',
+      ip:         request?.headers.get('CF-Connecting-IP') || '',
+      user_agent: request?.headers.get('User-Agent') || '',
     },
   };
 
@@ -80,21 +82,21 @@ export async function sendTikTokApi(env, eventName, payload, request, ctx) {
     });
 
     const data = await res.json();
-    if (!res.ok || data.code !== 0) {
-      console.error('TikTok Events API error:', res.status, data.message || data.code || 'unknown');
+    if (!res.ok || (data as any).code !== 0) {
+      console.error('TikTok Events API error:', res.status, (data as any).message || (data as any).code || 'unknown');
 
       if (env.DB && ctx) {
-        ctx.waitUntil(logApiFailure(env.DB, 'tiktok', eventName, String(data.code || res.status), data.message || 'TikTok API error', event.event_id, JSON.stringify(body)));
+        ctx.waitUntil(logApiFailure(env.DB, 'tiktok', eventName, String((data as any).code || res.status), (data as any).message || 'TikTok API error', event.event_id, JSON.stringify(body)));
       }
     }
     return data;
-  } catch (err) {
-    console.error('TikTok Events API fetch failed:', err.message);
+  } catch (err: any) {
+    console.error('TikTok Events API fetch failed:', err?.message || String(err));
 
     if (env.DB && ctx) {
-      ctx.waitUntil(logApiFailure(env.DB, 'tiktok', eventName, 'FETCH_ERROR', err.message, null, JSON.stringify(body)));
+      ctx.waitUntil(logApiFailure(env.DB, 'tiktok', eventName, 'FETCH_ERROR', err?.message || String(err), '', JSON.stringify(body)));
     }
 
-    return { error: err.message };
+    return { error: err?.message || String(err) };
   }
 }

package/server-edge-tracker/modules/dispatch/{whatsapp.js → whatsapp.ts}

@@ -5,9 +5,43 @@
 
 import { sha256, normalizePhone } from '../utils.js';
 import { saveLead, logApiFailure } from '../db.js';
+import { Env, TrackPayload } from '../../types.js';
+import { ExecutionContext } from '@cloudflare/workers-types';
+
+// ── Tipos ───────────────────────────────────────────────────────────────────────
+interface WhatsAppOptions {
+  to?: string;
+  template?: {
+    name: string;
+    language?: string;
+    components?: any[];
+  };
+  mediaType?: 'image' | 'document' | 'video' | 'audio';
+  mediaUrl?: string;
+  caption?: string;
+  filename?: string;
+  interactive?: 'buttons' | 'list';
+  bodyText?: string;
+  buttons?: Array<{ id: string; title: string }>;
+  listButton?: string;
+  rows?: Array<{ id: string; title: string; description?: string }>;
+}
+
+interface WhatsAppMessage {
+  from: string;
+  id: string;
+  type: string;
+  text?: { body: string };
+  referral?: {
+    ctwa_clid?: string;
+    source_id?: string;
+    source_url?: string;
+    headline?: string;
+  };
+}
 
 // ── sendWhatsApp — envia mensagem via Meta Cloud API ──────────────────────────
-export async function sendWhatsApp(env, tipo, payload, options = {}) {
+export async function sendWhatsApp(env: Env, tipo: string, payload: TrackPayload, options: WhatsAppOptions = {}): Promise<any> {
   if (!env.WHATSAPP_PHONE_NUMBER_ID || !env.WHATSAPP_ACCESS_TOKEN || !env.WA_NOTIFY_NUMBER) {
     return { skipped: 'WhatsApp não configurado' };
   }
@@ -21,14 +55,14 @@ export async function sendWhatsApp(env, tipo, payload, options = {}) {
   }
 
   if (options.mediaType && options.mediaUrl) {
-    const mediaPayload = { link: options.mediaUrl };
+    const mediaPayload: Record<string, string> = { link: options.mediaUrl };
     if (options.caption) mediaPayload.caption = options.caption;
     if (options.filename) mediaPayload.filename = options.filename;
     const body = { messaging_product: 'whatsapp', to, type: options.mediaType, [options.mediaType]: mediaPayload };
     return _sendWARequest(env, body);
   }
 
-  if (options.interactive === 'buttons' && options.buttons?.length) {
+  if (options.interactive === 'buttons' && options.buttons && options.buttons.length > 0) {
     const body = {
       messaging_product: 'whatsapp', to, type: 'interactive',
       interactive: {
@@ -42,7 +76,7 @@ export async function sendWhatsApp(env, tipo, payload, options = {}) {
     return _sendWARequest(env, body);
   }
 
-  if (options.interactive === 'list' && options.rows?.length) {
+  if (options.interactive === 'list' && options.rows && options.rows.length > 0) {
     const body = {
       messaging_product: 'whatsapp', to, type: 'interactive',
       interactive: {
@@ -56,7 +90,7 @@ export async function sendWhatsApp(env, tipo, payload, options = {}) {
 
   // Text fallback (dentro da janela de 24h)
   const nome    = [payload.firstName, payload.lastName].filter(Boolean).join(' ') || 'sem nome';
-  const valor   = payload.value ? `R$ ${parseFloat(payload.value).toFixed(2)}` : '—';
+  const valor   = payload.value ? `R$ ${parseFloat(String(payload.value)).toFixed(2)}` : '—';
   const utm     = payload.utmSource || 'direto';
   const produto = payload.contentName || '';
 
@@ -80,7 +114,7 @@ export async function sendWhatsApp(env, tipo, payload, options = {}) {
 }
 
 // ── _sendWARequest — executor interno ─────────────────────────────────────────
-async function _sendWARequest(env, body) {
+async function _sendWARequest(env: Env, body: Record<string, any>): Promise<any> {
   try {
     const res = await fetch(`https://graph.facebook.com/v22.0/${env.WHATSAPP_PHONE_NUMBER_ID}/messages`, {
       method: 'POST',
@@ -88,16 +122,16 @@ async function _sendWARequest(env, body) {
       body: JSON.stringify(body),
     });
     const data = await res.json();
-    if (!res.ok) console.error('WhatsApp Meta API error:', res.status, data.error?.message || 'unknown');
+    if (!res.ok) console.error('WhatsApp Meta API error:', res.status, (data as any).error?.message || 'unknown');
     return { ok: res.ok, status: res.status, data };
-  } catch (err) {
-    console.error('WhatsApp Meta API failed:', err.message);
-    return { ok: false, error: err.message };
+  } catch (err: any) {
+    console.error('WhatsApp Meta API failed:', err?.message || String(err));
+    return { ok: false, error: err?.message || String(err) };
   }
 }
 
 // ── sendCallMeBot — alertas de sistema via WhatsApp ───────────────────────────
-export async function sendCallMeBot(env, mensagem) {
+export async function sendCallMeBot(env: Env, mensagem: string): Promise<any> {
   if (!env.CALLMEBOT_PHONE || !env.CALLMEBOT_APIKEY) {
     return { skipped: 'CallMeBot não configurado' };
   }
@@ -105,22 +139,22 @@ export async function sendCallMeBot(env, mensagem) {
     const url = `https://api.callmebot.com/whatsapp.php?phone=${encodeURIComponent(env.CALLMEBOT_PHONE)}&text=${encodeURIComponent(mensagem)}&apikey=${env.CALLMEBOT_APIKEY}`;
     const res = await fetch(url);
     return { ok: res.ok, status: res.status };
-  } catch (err) {
-    console.error('CallMeBot failed:', err.message);
-    return { ok: false, error: err.message };
+  } catch (err: any) {
+    console.error('CallMeBot failed:', err?.message || String(err));
+    return { ok: false, error: err?.message || String(err) };
   }
 }
 
 // ── processWhatsAppWebhook — CTWA (Click to WhatsApp) ────────────────────────
-export async function processWhatsAppWebhook(env, body, request, ctx) {
-  const entry  = body?.entry?.[0];
-  const change = entry?.changes?.find(c => c.field === 'messages');
+export async function processWhatsAppWebhook(env: Env, body: any, request: Request, ctx: ExecutionContext): Promise<any> {
+  const entry: any = body?.entry?.[0];
+  const change = entry?.changes?.find((c: any) => c.field === 'messages');
   if (!change) return { skipped: 'no messages field' };
 
   const messages = change.value?.messages;
   if (!messages || messages.length === 0) return { skipped: 'no messages' };
 
-  const results = [];
+  const results: any[] = [];
 
   for (const message of messages) {
     const phone       = message.from;
@@ -155,7 +189,7 @@ export async function processWhatsAppWebhook(env, body, request, ctx) {
       );
     }
 
-    const capiEvent = {
+    const capiEvent: Record<string, any> = {
       event_name:    'Contact',
       event_time:    Math.floor(Date.now() / 1000),
       event_id:      eventId,
@@ -172,7 +206,7 @@ export async function processWhatsAppWebhook(env, body, request, ctx) {
     ctx.waitUntil(
       (async () => {
         try {
-          const requestBody = { data: [capiEvent], access_token: env.META_ACCESS_TOKEN };
+          const requestBody: Record<string, any> = { data: [capiEvent], access_token: env.META_ACCESS_TOKEN };
           if (env.META_TEST_CODE) requestBody.test_event_code = env.META_TEST_CODE;
 
           const res = await fetch(
@@ -184,13 +218,13 @@ export async function processWhatsAppWebhook(env, body, request, ctx) {
           if (res.ok && env.DB && wamid) {
             await env.DB.prepare('UPDATE whatsapp_contacts SET capi_sent = 1 WHERE wamid = ?').bind(wamid).run();
           } else if (!res.ok) {
-            console.error('[CTWA] Meta CAPI error:', res.status, data.error?.message || 'unknown');
+            console.error('[CTWA] Meta CAPI error:', res.status, (data as any).error?.message || 'unknown');
             if (env.DB) {
-              await logApiFailure(env.DB, 'meta', 'Contact', data.error?.code || res.status, data.error?.message || 'CTWA CAPI error', eventId, JSON.stringify(requestBody));
+              await logApiFailure(env.DB, 'meta', 'Contact', (data as any).error?.code || res.status, (data as any).error?.message || 'CTWA CAPI error', eventId, JSON.stringify(requestBody));
             }
           }
-        } catch (err) {
-          console.error('[CTWA] Meta CAPI fetch failed:', err.message);
+        } catch (err: any) {
+          console.error('[CTWA] Meta CAPI fetch failed:', err?.message || String(err));
         }
       })()
     );
@@ -209,7 +243,7 @@ export async function processWhatsAppWebhook(env, body, request, ctx) {
 }
 
 // ── verifyHmac — validação constant-time de assinatura HMAC-SHA256 ─────────────
-export async function verifyHmac(secret, rawBody, receivedSignature) {
+export async function verifyHmac(secret: string, rawBody: string, receivedSignature: string): Promise<boolean> {
   if (!secret || !receivedSignature) return false;
   try {
     const key = await crypto.subtle.importKey(