@laburen/openclaw-plugin-whatsapp-api 0.1.0 → 0.2.1

package/src/utils/media/mime.ts

@@ -1,74 +0,0 @@
-import path from "node:path";
-
-const MIME_BY_EXT: Record<string, string> = {
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".png": "image/png",
-  ".webp": "image/webp",
-  ".gif": "image/gif",
-  ".mp4": "video/mp4",
-  ".mov": "video/quicktime",
-  ".webm": "video/webm",
-  ".mp3": "audio/mpeg",
-  ".wav": "audio/wav",
-  ".ogg": "audio/ogg",
-  ".opus": "audio/ogg",
-  ".m4a": "audio/mp4",
-  ".pdf": "application/pdf",
-  ".txt": "text/plain",
-  ".csv": "text/csv",
-  ".json": "application/json",
-  ".zip": "application/zip",
-};
-
-function normalizeMime(value?: string): string | undefined {
-  const trimmed = value?.trim();
-  if (!trimmed) {
-    return undefined;
-  }
-  return trimmed.split(";")[0]?.trim().toLowerCase();
-}
-
-export function mediaKindFromMimeOrName(params: {
-  mimeType?: string;
-  fileNameOrUrl?: string;
-}): "image" | "video" | "audio" | "document" {
-  const mime = normalizeMime(params.mimeType);
-  if (mime?.startsWith("image/")) {
-    return "image";
-  }
-  if (mime?.startsWith("video/")) {
-    return "video";
-  }
-  if (mime?.startsWith("audio/")) {
-    return "audio";
-  }
-
-  const ext = path.extname(params.fileNameOrUrl ?? "").toLowerCase();
-  const extMime = MIME_BY_EXT[ext];
-  if (extMime?.startsWith("image/")) {
-    return "image";
-  }
-  if (extMime?.startsWith("video/")) {
-    return "video";
-  }
-  if (extMime?.startsWith("audio/")) {
-    return "audio";
-  }
-  return "document";
-}
-
-export function mimeFromFileName(fileNameOrPath: string): string | undefined {
-  const ext = path.extname(fileNameOrPath).toLowerCase();
-  return MIME_BY_EXT[ext];
-}
-
-export function extensionFromMime(mimeType?: string): string {
-  const mime = normalizeMime(mimeType);
-  if (!mime) {
-    return ".bin";
-  }
-  const found = Object.entries(MIME_BY_EXT).find(([, value]) => value === mime)?.[0];
-  return found ?? ".bin";
-}
-

package/src/utils/outbound/payload.ts

@@ -1,173 +0,0 @@
-export type NormalizedOutboundPayload = {
-  text: string;
-  mediaUrls: string[];
-  location?: {
-    latitude: number;
-    longitude: number;
-    name?: string;
-    address?: string;
-  };
-  contacts: Array<{
-    name: {
-      formatted_name: string;
-      first_name?: string;
-      last_name?: string;
-    };
-    phones?: Array<{
-      phone: string;
-      type?: string;
-      wa_id?: string;
-    }>;
-  }>;
-};
-
-function toTrimmedString(value: unknown): string {
-  if (typeof value !== "string") {
-    return "";
-  }
-  return value.trim();
-}
-
-function asRecord(value: unknown): Record<string, unknown> | null {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return null;
-  }
-  return value as Record<string, unknown>;
-}
-
-function parseNumber(value: unknown): number | undefined {
-  const numeric = Number(value);
-  return Number.isFinite(numeric) ? numeric : undefined;
-}
-
-function getWhatsAppPayload(record: Record<string, unknown>): Record<string, unknown> {
-  const whatsapp = asRecord(record.whatsapp) ?? {};
-  const channelData = asRecord(record.channelData) ?? {};
-  const channelDataWhatsapp = asRecord(channelData.whatsapp) ?? {};
-  return {
-    ...channelDataWhatsapp,
-    ...whatsapp,
-  };
-}
-
-function normalizeOutboundLocation(record: Record<string, unknown>): NormalizedOutboundPayload["location"] {
-  const whatsapp = getWhatsAppPayload(record);
-  const raw = asRecord(record.location) ?? asRecord(whatsapp.location);
-  if (!raw) {
-    return undefined;
-  }
-  const latitude = parseNumber(raw.latitude ?? raw.lat);
-  const longitude = parseNumber(raw.longitude ?? raw.lng ?? raw.lon);
-  if (latitude === undefined || longitude === undefined) {
-    return undefined;
-  }
-  return {
-    latitude,
-    longitude,
-    name: toTrimmedString(raw.name || raw.title) || undefined,
-    address: toTrimmedString(raw.address) || undefined,
-  };
-}
-
-function normalizeSingleContact(value: unknown): NormalizedOutboundPayload["contacts"][number] | undefined {
-  const raw = asRecord(value);
-  if (!raw) {
-    return undefined;
-  }
-  const nameRecord = asRecord(raw.name);
-  const firstName = toTrimmedString(nameRecord?.first_name ?? raw.first_name ?? raw.firstName);
-  const lastName = toTrimmedString(nameRecord?.last_name ?? raw.last_name ?? raw.lastName);
-  const formattedName =
-    toTrimmedString(nameRecord?.formatted_name) ||
-    toTrimmedString(raw.formatted_name || raw.formattedName || raw.display_name || raw.displayName) ||
-    [firstName, lastName].filter(Boolean).join(" ") ||
-    toTrimmedString(raw.phone || raw.msisdn);
-  if (!formattedName) {
-    return undefined;
-  }
-  const phones = new Set<string>();
-  const directPhone = toTrimmedString(raw.phone || raw.msisdn);
-  if (directPhone) {
-    phones.add(directPhone);
-  }
-  const rawPhones = Array.isArray(raw.phones) ? raw.phones : [];
-  for (const rawPhone of rawPhones) {
-    if (typeof rawPhone === "string") {
-      const cleaned = toTrimmedString(rawPhone);
-      if (cleaned) {
-        phones.add(cleaned);
-      }
-      continue;
-    }
-    const phoneRecord = asRecord(rawPhone);
-    const cleaned = toTrimmedString(phoneRecord?.phone);
-    if (cleaned) {
-      phones.add(cleaned);
-    }
-  }
-  return {
-    name: {
-      formatted_name: formattedName,
-      first_name: firstName || undefined,
-      last_name: lastName || undefined,
-    },
-    phones:
-      phones.size > 0
-        ? [...phones].map((phone) => ({
-            phone,
-          }))
-        : undefined,
-  };
-}
-
-function normalizeOutboundContacts(record: Record<string, unknown>): NormalizedOutboundPayload["contacts"] {
-  const whatsapp = getWhatsAppPayload(record);
-  const rawContacts =
-    (Array.isArray(record.contacts) && record.contacts) ||
-    (Array.isArray(whatsapp.contacts) && whatsapp.contacts) ||
-    [];
-  const contacts: NormalizedOutboundPayload["contacts"] = [];
-  for (const rawContact of rawContacts) {
-    const normalized = normalizeSingleContact(rawContact);
-    if (normalized) {
-      contacts.push(normalized);
-    }
-  }
-  const singleContact =
-    normalizeSingleContact(record.contact) ??
-    normalizeSingleContact(whatsapp.contact);
-  if (singleContact) {
-    contacts.push(singleContact);
-  }
-  return contacts;
-}
-
-export function normalizeOutboundPayload(payload: unknown): NormalizedOutboundPayload {
-  if (!payload || typeof payload !== "object") {
-    return { text: "", mediaUrls: [], contacts: [] };
-  }
-  const record = payload as Record<string, unknown>;
-  const text = toTrimmedString(record.text) || toTrimmedString(record.body);
-
-  const mediaUrls = new Set<string>();
-  const mediaUrl = toTrimmedString(record.mediaUrl);
-  if (mediaUrl) {
-    mediaUrls.add(mediaUrl);
-  }
-  if (Array.isArray(record.mediaUrls)) {
-    for (const value of record.mediaUrls) {
-      const url = toTrimmedString(value);
-      if (url) {
-        mediaUrls.add(url);
-      }
-    }
-  }
-
-  return {
-    text,
-    mediaUrls: [...mediaUrls],
-    location: normalizeOutboundLocation(record),
-    contacts: normalizeOutboundContacts(record),
-  };
-}
-

package/src/webhook.ts

@@ -1,119 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import { parseWhatsAppCloudInbound } from "./inbound.js";
-import type { ResolvedWhatsAppApiAccount, WhatsAppApiInboundMessage } from "./types.js";
-
-type LogLike = {
-  info?: (message: string) => void;
-  warn?: (message: string) => void;
-  error?: (message: string) => void;
-};
-
-const dedupeStore = new Map<string, number>();
-
-function cleanupDedupe(now: number): void {
-  for (const [key, expiresAt] of dedupeStore.entries()) {
-    if (expiresAt <= now) {
-      dedupeStore.delete(key);
-    }
-  }
-}
-
-function isDuplicate(accountId: string, messageId: string, ttlMs: number): boolean {
-  const now = Date.now();
-  cleanupDedupe(now);
-  const key = `${accountId}:${messageId}`;
-  const current = dedupeStore.get(key);
-  if (current && current > now) {
-    return true;
-  }
-  dedupeStore.set(key, now + ttlMs);
-  return false;
-}
-
-async function readBody(req: IncomingMessage, maxBodyBytes: number): Promise<string> {
-  const chunks: Buffer[] = [];
-  let total = 0;
-  for await (const chunk of req) {
-    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
-    total += buf.length;
-    if (total > maxBodyBytes) {
-      throw new Error("Payload exceeds maxBodyBytes");
-    }
-    chunks.push(buf);
-  }
-  return Buffer.concat(chunks).toString("utf8");
-}
-
-function isAuthorized(req: IncomingMessage, account: ResolvedWhatsAppApiAccount): boolean {
-  const required = account.inboundSharedSecret?.trim();
-  if (!required) {
-    return true;
-  }
-  const header = req.headers["x-openclaw-shared-secret"];
-  const value = Array.isArray(header) ? header[0] : header;
-  return value?.trim() === required;
-}
-
-function json(res: ServerResponse, statusCode: number, body: Record<string, unknown>) {
-  res.statusCode = statusCode;
-  res.setHeader("content-type", "application/json; charset=utf-8");
-  res.end(JSON.stringify(body));
-}
-
-export async function handleWhatsAppApiWebhook(params: {
-  req: IncomingMessage;
-  res: ServerResponse;
-  account: ResolvedWhatsAppApiAccount;
-  log?: LogLike;
-  onMessage: (message: WhatsAppApiInboundMessage) => Promise<void>;
-}): Promise<boolean> {
-  const { req, res, account, log, onMessage } = params;
-  if (req.method !== "POST") {
-    json(res, 405, { ok: false, error: "Method not allowed" });
-    return true;
-  }
-
-  if (!isAuthorized(req, account)) {
-    json(res, 403, { ok: false, error: "Forbidden" });
-    return true;
-  }
-
-  let payload: unknown;
-  try {
-    const bodyText = await readBody(req, account.maxBodyBytes);
-    payload = bodyText ? JSON.parse(bodyText) : {};
-  } catch (err) {
-    log?.warn?.(`[whatsapp-api] invalid inbound payload for account ${account.accountId}: ${String(err)}`);
-    json(res, 400, { ok: false, error: "Invalid payload" });
-    return true;
-  }
-
-  const inboundMessages = parseWhatsAppCloudInbound({
-    payload,
-    accountId: account.accountId,
-  });
-
-  // ACK immediately; process asynchronously to keep webhook latency low.
-  json(res, 200, {
-    ok: true,
-    accepted: inboundMessages.length,
-    accountId: account.accountId,
-  });
-
-  void (async () => {
-    for (const message of inboundMessages) {
-      if (isDuplicate(account.accountId, message.messageId, account.dedupeTtlMs)) {
-        continue;
-      }
-      try {
-        await onMessage(message);
-      } catch (err) {
-        log?.error?.(
-          `[whatsapp-api] failed processing message ${message.messageId} for account ${account.accountId}: ${String(err)}`,
-        );
-      }
-    }
-  })();
-
-  return true;
-}