@lofa199419/waha-v2 2026.3.2

package/src/webhook.ts

@@ -0,0 +1,264 @@
+import { randomUUID } from "node:crypto";
+import { writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { extname, join } from "node:path";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { readJsonBodyWithLimit } from "openclaw/plugin-sdk";
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import { resolveWahaV2Account, resolveWahaV2AccountBySession } from "./accounts.js";
+import { getWahaV2Logger, getWahaV2Runtime, requireWahaV2Client } from "./runtime.js";
+import {
+  WAHA_V2_CHANNEL_ID,
+  type WahaV2MediaInfo,
+  type WahaV2WebhookEvent,
+  type WahaV2WebhookPayload,
+} from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** WAHA chatId can be a plain string or `{ _serialized: "..." }` (WEBJS engine). */
+function parseChatId(chatId: WahaV2WebhookPayload["chatId"]): string | undefined {
+  if (!chatId) return undefined;
+  if (typeof chatId === "string") return chatId;
+  return chatId._serialized;
+}
+
+/** Normalize E.164-ish numbers to `<digits>@c.us`. */
+function normalizeSenderId(raw: string): string {
+  if (raw.includes("@")) return raw;
+  return `${raw.replace(/\D+/g, "")}@c.us`;
+}
+
+/** Map MIME type to a file extension. */
+function mimeToExt(mime: string): string {
+  const map: Record<string, string> = {
+    "image/jpeg": ".jpg",
+    "image/png": ".png",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+    "video/mp4": ".mp4",
+    "video/webm": ".webm",
+    "audio/ogg": ".ogg",
+    "audio/mpeg": ".mp3",
+    "audio/mp4": ".m4a",
+    "audio/webm": ".webm",
+    "audio/ogg; codecs=opus": ".ogg",
+    "application/pdf": ".pdf",
+  };
+  const base = mime.split(";")[0]?.trim() ?? mime;
+  return map[base] ?? map[mime] ?? ".bin";
+}
+
+/** Human-readable media type label for BodyForAgent. */
+function mediaTypeLabel(type?: string, mime?: string): string {
+  if (type === "ptt" || type === "audio" || mime?.startsWith("audio/")) return "voice message";
+  if (type === "image" || mime?.startsWith("image/")) return "image";
+  if (type === "video" || mime?.startsWith("video/")) return "video";
+  if (type === "document") return "document";
+  if (type === "sticker") return "sticker";
+  return "media file";
+}
+
+/**
+ * Resolve inbound media to a local temp file path.
+ * Tries base64 `data` first (already embedded), then downloads from `url`.
+ * Returns the temp file path and MIME type, or undefined if no media.
+ */
+async function resolveInboundMedia(
+  media: WahaV2MediaInfo,
+  accountId: string,
+): Promise<{ path: string; mimeType: string } | undefined> {
+  const client = requireWahaV2Client(accountId);
+  let buffer: Buffer | undefined;
+  let mimeType = media.mimetype ?? "application/octet-stream";
+
+  if (media.data) {
+    // Some engines embed base64 data directly in the webhook payload.
+    buffer = Buffer.from(media.data, "base64");
+  } else if (media.url) {
+    try {
+      const downloaded = await client.downloadMediaBuffer(media.url);
+      buffer = downloaded.buffer;
+      // Prefer server-reported content-type over the webhook field.
+      if (downloaded.contentType && downloaded.contentType !== "application/octet-stream") {
+        mimeType = downloaded.contentType;
+      }
+    } catch (err) {
+      getWahaV2Logger().warn(`waha-v2: media download failed (${media.url}): ${String(err)}`);
+      return undefined;
+    }
+  }
+
+  if (!buffer || buffer.length === 0) return undefined;
+
+  // Pick a filename: use original or derive from MIME type.
+  const origExt = media.filename ? extname(media.filename) : "";
+  const ext = origExt || mimeToExt(mimeType);
+  const tmpPath = join(tmpdir(), `openclaw-waha-v2-${randomUUID()}${ext}`);
+  await writeFile(tmpPath, buffer);
+  return { path: tmpPath, mimeType };
+}
+
+// ---------------------------------------------------------------------------
+// Inbound event processor (runs async, after 200 is sent)
+// ---------------------------------------------------------------------------
+
+async function handleWahaV2Event(
+  event: WahaV2WebhookEvent,
+  cfg: OpenClawConfig,
+  accountId?: string,
+): Promise<void> {
+  const core = getWahaV2Runtime();
+
+  // Only handle inbound messages — skip ack, reaction, status, and self-sent events.
+  if (event.event !== "message" && event.event !== "message.any") return;
+  const payload = event.payload;
+  if (!payload || payload.fromMe) return;
+
+  const text = payload.body?.trim() ?? "";
+  // Resolve media from the payload (checking both top-level and _data).
+  const rawMedia: WahaV2MediaInfo | undefined = payload.media ?? payload._data?.media;
+  const hasMedia = Boolean(payload.hasMedia || rawMedia);
+
+  // Skip if no text and no media — nothing to dispatch.
+  if (!text && !hasMedia) return;
+
+  // Find the account that owns this session.
+  const account = accountId
+    ? resolveWahaV2Account(cfg, accountId)
+    : (resolveWahaV2AccountBySession(cfg, event.session) ?? resolveWahaV2Account(cfg, undefined));
+
+  const isGroup = Boolean(payload.isGroupMsg);
+  const senderId = payload.from ? normalizeSenderId(payload.from) : "";
+  const chatId = parseChatId(payload.chatId) ?? senderId;
+
+  // Download/decode media to a local temp file so the agent can inspect it.
+  let mediaPath: string | undefined;
+  let mediaMime: string | undefined;
+  if (hasMedia && rawMedia) {
+    const resolved = await resolveInboundMedia(rawMedia, account.accountId).catch((err) => {
+      getWahaV2Logger().warn(`waha-v2: media resolution error: ${String(err)}`);
+      return undefined;
+    });
+    mediaPath = resolved?.path;
+    mediaMime = resolved?.mimeType;
+  }
+
+  // Build a descriptive body when there's media but no caption text.
+  const mediaLabel = mediaPath ? mediaTypeLabel(payload.type, mediaMime) : undefined;
+  const bodyForAgent = text || (mediaLabel ? `[${mediaLabel}]` : "");
+
+  // If we have both caption text and media, surface both in Body.
+  const combinedBody = text && mediaLabel ? `${text}\n[${mediaLabel}]` : bodyForAgent;
+
+  const route = core.channel.routing.resolveAgentRoute({
+    cfg,
+    channel: WAHA_V2_CHANNEL_ID,
+    accountId: account.accountId,
+    peer: { kind: isGroup ? "group" : "direct", id: chatId },
+  });
+
+  const storePath = core.channel.session.resolveStorePath(cfg.session?.store, {
+    agentId: route.agentId,
+  });
+
+  const ctx = core.channel.reply.finalizeInboundContext({
+    Body: combinedBody,
+    BodyForAgent: bodyForAgent,
+    RawBody: text,
+    CommandBody: text,
+    From: `${WAHA_V2_CHANNEL_ID}:${senderId}`,
+    To: `${WAHA_V2_CHANNEL_ID}:${account.session}`,
+    SessionKey: route.sessionKey,
+    AccountId: route.accountId,
+    ChatType: isGroup ? ("group" as const) : ("direct" as const),
+    Provider: WAHA_V2_CHANNEL_ID,
+    Surface: WAHA_V2_CHANNEL_ID,
+    SenderId: senderId,
+    MessageSid: payload.id,
+    Timestamp: payload.timestamp ? payload.timestamp * 1000 : Date.now(),
+    // Media fields — consumed by the agent framework to send the file to the AI.
+    MediaUrl: mediaPath,
+    MediaPath: mediaPath,
+    MediaType: mediaMime,
+    MediaUrls: mediaPath ? [mediaPath] : undefined,
+    MediaPaths: mediaPath ? [mediaPath] : undefined,
+    MediaTypes: mediaMime ? [mediaMime] : undefined,
+  });
+
+  await core.channel.session.recordInboundSession({
+    storePath,
+    sessionKey: ctx.SessionKey ?? route.sessionKey,
+    ctx,
+    onRecordError: (err) => {
+      getWahaV2Logger().warn(`waha-v2: session record error: ${String(err)}`);
+    },
+  });
+
+  const client = requireWahaV2Client(account.accountId);
+
+  const { dispatcher, replyOptions, markDispatchIdle } =
+    core.channel.reply.createReplyDispatcherWithTyping({
+      deliver: async (replyPayload) => {
+        const replyText = replyPayload.text?.trim() ?? "";
+        if (!replyText) return;
+        await client.sendText(account.session, chatId, replyText);
+      },
+    });
+
+  try {
+    await core.channel.reply.dispatchReplyFromConfig({ ctx, cfg, dispatcher, replyOptions });
+  } finally {
+    markDispatchIdle();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// HTTP handler — registered via api.registerHttpHandler
+// ---------------------------------------------------------------------------
+
+/**
+ * Handles inbound WAHA webhook POSTs.
+ * Responds 200 immediately, then processes the event asynchronously.
+ */
+export async function handleWahaV2WebhookRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  cfg: OpenClawConfig,
+  /** accountId extracted from the URL path — makes routing unambiguous. */
+  accountId?: string,
+): Promise<void> {
+  if (req.method !== "POST") {
+    res.statusCode = 405;
+    res.end("Method Not Allowed");
+    return;
+  }
+
+  const body = await readJsonBodyWithLimit(req, {
+    maxBytes: 10 * 1024 * 1024, // 10 MB — some engines embed base64 media in webhook body
+    timeoutMs: 30_000,
+    emptyObjectOnEmpty: true,
+  });
+
+  if (!body.ok) {
+    res.statusCode = body.code === "PAYLOAD_TOO_LARGE" ? 413 : 400;
+    res.end(body.error ?? "Bad Request");
+    return;
+  }
+
+  // Acknowledge immediately — WAHA expects a fast 200.
+  res.statusCode = 200;
+  res.setHeader("Content-Type", "application/json");
+  res.end('{"ok":true}');
+
+  // Process asynchronously so WAHA's retry logic isn't triggered by agent latency.
+  handleWahaV2Event(body.value as WahaV2WebhookEvent, cfg, accountId).catch((err) => {
+    try {
+      getWahaV2Logger().warn(`waha-v2 webhook error: ${String(err)}`);
+    } catch {
+      // Runtime may not be initialized in edge cases; swallow.
+    }
+  });
+}