@gakr-gakr/whatsapp 0.1.0

package/src/normalize-target.ts

@@ -0,0 +1,148 @@
+import { normalizeE164 } from "autobot/plugin-sdk/account-resolution";
+import { normalizeLowercaseStringOrEmpty } from "autobot/plugin-sdk/string-coerce-runtime";
+
+const WHATSAPP_USER_JID_RE = /^(\d+)(?::\d+)?@s\.whatsapp\.net$/i;
+const WHATSAPP_LEGACY_USER_JID_RE = /^(\d+)@c\.us$/i;
+const WHATSAPP_LID_RE = /^(\d+)@lid$/i;
+const NON_WHATSAPP_PROVIDER_PREFIX_RE = /^[a-z][a-z0-9-]*:/i;
+const WHATSAPP_NEWSLETTER_JID_RE = /^([0-9]+)@newsletter$/i;
+
+function stripWhatsAppTargetPrefixes(value: string): string {
+  let candidate = value.trim();
+  for (;;) {
+    const before = candidate;
+    candidate = candidate.replace(/^whatsapp:/i, "").trim();
+    if (candidate === before) {
+      return candidate;
+    }
+  }
+}
+
+function normalizeWhatsAppGroupJid(value: string): string | null {
+  const candidate = stripWhatsAppTargetPrefixes(value)
+    .replace(/^group:/i, "")
+    .trim();
+  const lower = normalizeLowercaseStringOrEmpty(candidate);
+  if (!lower.endsWith("@g.us")) {
+    return null;
+  }
+  const localPart = candidate.slice(0, candidate.length - "@g.us".length);
+  if (!localPart || localPart.includes("@")) {
+    return null;
+  }
+  return /^[0-9]+(-[0-9]+)*$/.test(localPart) ? `${localPart}@g.us` : null;
+}
+
+export function isWhatsAppGroupJid(value: string): boolean {
+  return normalizeWhatsAppGroupJid(value) !== null;
+}
+
+export function isWhatsAppNewsletterJid(value: string): boolean {
+  const candidate = stripWhatsAppTargetPrefixes(value);
+  return WHATSAPP_NEWSLETTER_JID_RE.test(candidate);
+}
+
+export function isWhatsAppUserTarget(value: string): boolean {
+  const candidate = stripWhatsAppTargetPrefixes(value);
+  return (
+    WHATSAPP_USER_JID_RE.test(candidate) ||
+    WHATSAPP_LEGACY_USER_JID_RE.test(candidate) ||
+    WHATSAPP_LID_RE.test(candidate)
+  );
+}
+
+function extractUserJidPhone(jid: string): string | null {
+  const userMatch = jid.match(WHATSAPP_USER_JID_RE);
+  if (userMatch) {
+    return userMatch[1];
+  }
+  const legacyUserMatch = jid.match(WHATSAPP_LEGACY_USER_JID_RE);
+  if (legacyUserMatch) {
+    return legacyUserMatch[1];
+  }
+  const lidMatch = jid.match(WHATSAPP_LID_RE);
+  if (lidMatch) {
+    return lidMatch[1];
+  }
+  return null;
+}
+
+export function normalizeWhatsAppTarget(value: string): string | null {
+  const candidate = stripWhatsAppTargetPrefixes(value);
+  if (!candidate) {
+    return null;
+  }
+  const groupJid = normalizeWhatsAppGroupJid(candidate);
+  if (groupJid) {
+    return groupJid;
+  }
+  if (isWhatsAppNewsletterJid(candidate)) {
+    const match = candidate.match(WHATSAPP_NEWSLETTER_JID_RE);
+    return match ? `${match[1]}@newsletter` : null;
+  }
+  if (isWhatsAppUserTarget(candidate)) {
+    const phone = extractUserJidPhone(candidate);
+    if (!phone) {
+      return null;
+    }
+    const normalized = normalizeE164(phone);
+    return normalized.length > 1 ? normalized : null;
+  }
+  if (candidate.includes("@")) {
+    return null;
+  }
+  if (NON_WHATSAPP_PROVIDER_PREFIX_RE.test(candidate)) {
+    return null;
+  }
+  const normalized = normalizeE164(candidate);
+  return normalized.length > 1 ? normalized : null;
+}
+
+export function normalizeWhatsAppMessagingTarget(raw: string): string | undefined {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+  return normalizeWhatsAppTarget(trimmed) ?? undefined;
+}
+
+export function normalizeWhatsAppAllowFromEntries(allowFrom: Array<string | number>): string[] {
+  const seen = new Set<string>();
+  const normalized = allowFrom
+    .map((entry) => String(entry).trim())
+    .filter((entry): entry is string => Boolean(entry))
+    .map(normalizeWhatsAppAllowFromEntry)
+    .filter((entry): entry is string => Boolean(entry));
+  return normalized.filter((entry) => {
+    if (seen.has(entry)) {
+      return false;
+    }
+    seen.add(entry);
+    return true;
+  });
+}
+
+export function normalizeWhatsAppAllowFromEntry(entry: string): string | null {
+  if (entry === "*") {
+    return entry;
+  }
+  const normalized = normalizeWhatsAppTarget(entry);
+  if (!normalized) {
+    return null;
+  }
+  return normalized.startsWith("+") ? normalized.slice(1) : normalized;
+}
+
+export function looksLikeWhatsAppTargetId(raw: string): boolean {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return false;
+  }
+  return (
+    /^whatsapp:/i.test(trimmed) ||
+    isWhatsAppGroupJid(trimmed) ||
+    isWhatsAppNewsletterJid(trimmed) ||
+    isWhatsAppUserTarget(trimmed) ||
+    normalizeWhatsAppTarget(trimmed) !== null
+  );
+}

package/src/normalize.ts

@@ -0,0 +1,8 @@
+export {
+  looksLikeWhatsAppTargetId,
+  normalizeWhatsAppAllowFromEntry,
+  normalizeWhatsAppMessagingTarget,
+  isWhatsAppGroupJid,
+  isWhatsAppNewsletterJid,
+  normalizeWhatsAppTarget,
+} from "./normalize-target.js";

package/src/outbound-adapter.ts

@@ -0,0 +1,36 @@
+import { type ChannelOutboundAdapter } from "autobot/plugin-sdk/channel-send-result";
+import { chunkText } from "autobot/plugin-sdk/reply-chunking";
+import { shouldLogVerbose } from "autobot/plugin-sdk/runtime-env";
+import { createWhatsAppOutboundBase } from "./outbound-base.js";
+import { normalizeWhatsAppPayloadText } from "./outbound-media-contract.js";
+import { resolveWhatsAppOutboundTarget } from "./resolve-outbound-target.js";
+
+type WhatsAppSendModule = typeof import("./send.js");
+
+let whatsAppSendModulePromise: Promise<WhatsAppSendModule> | undefined;
+
+function loadWhatsAppSendModule(): Promise<WhatsAppSendModule> {
+  whatsAppSendModulePromise ??= import("./send.js");
+  return whatsAppSendModulePromise;
+}
+
+function normalizeOutboundText(text: string | undefined): string {
+  return normalizeWhatsAppPayloadText(text);
+}
+
+export const whatsappOutbound: ChannelOutboundAdapter = createWhatsAppOutboundBase({
+  chunker: chunkText,
+  sendMessageWhatsApp: async (to, text, options) =>
+    await (
+      await loadWhatsAppSendModule()
+    ).sendMessageWhatsApp(to, normalizeOutboundText(text), {
+      ...options,
+    }),
+  sendPollWhatsApp: async (to, poll, options) =>
+    await (await loadWhatsAppSendModule()).sendPollWhatsApp(to, poll, options),
+  shouldLogVerbose: () => shouldLogVerbose(),
+  resolveTarget: ({ to, allowFrom, mode }) =>
+    resolveWhatsAppOutboundTarget({ to, allowFrom, mode }),
+  normalizeText: normalizeOutboundText,
+  skipEmptyText: true,
+});

package/src/outbound-base.ts

@@ -0,0 +1,256 @@
+import {
+  DEFAULT_ACCOUNT_ID,
+  listCombinedAccountIds,
+  normalizeOptionalAccountId,
+  resolveListedDefaultAccountId,
+} from "autobot/plugin-sdk/account-core";
+import {
+  createAttachedChannelResultAdapter,
+  type ChannelOutboundAdapter,
+} from "autobot/plugin-sdk/channel-send-result";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { resolveOutboundSendDep } from "autobot/plugin-sdk/outbound-send-deps";
+import { sendTextMediaPayload } from "autobot/plugin-sdk/reply-payload";
+import {
+  normalizeWhatsAppOutboundPayload,
+  normalizeWhatsAppPayloadText,
+} from "./outbound-media-contract.js";
+import { WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS } from "./outbound-send-deps.js";
+import { lookupInboundMessageMetaForTarget } from "./quoted-message.js";
+import { toWhatsappJid } from "./text-runtime.js";
+
+type WhatsAppChunker = NonNullable<ChannelOutboundAdapter["chunker"]>;
+type WhatsAppSendTextOptions = {
+  verbose: boolean;
+  cfg: AutoBotConfig;
+  mediaUrl?: string;
+  mediaAccess?: {
+    localRoots?: readonly string[];
+    readFile?: (filePath: string) => Promise<Buffer>;
+  };
+  mediaLocalRoots?: readonly string[];
+  mediaReadFile?: (filePath: string) => Promise<Buffer>;
+  gifPlayback?: boolean;
+  audioAsVoice?: boolean;
+  forceDocument?: boolean;
+  accountId?: string;
+  quotedMessageKey?: {
+    id: string;
+    remoteJid: string;
+    fromMe: boolean;
+    participant?: string;
+    messageText?: string;
+  };
+  preserveLeadingWhitespace?: boolean;
+};
+type WhatsAppSendMessage = (
+  to: string,
+  body: string,
+  options: WhatsAppSendTextOptions,
+) => Promise<{ messageId: string; toJid: string }>;
+type WhatsAppSendPoll = (
+  to: string,
+  poll: Parameters<NonNullable<ChannelOutboundAdapter["sendPoll"]>>[0]["poll"],
+  options: { verbose: boolean; accountId?: string; cfg: AutoBotConfig },
+) => Promise<{ messageId: string; toJid: string }>;
+
+type CreateWhatsAppOutboundBaseParams = {
+  chunker: WhatsAppChunker;
+  sendMessageWhatsApp: WhatsAppSendMessage;
+  sendPollWhatsApp: WhatsAppSendPoll;
+  shouldLogVerbose: () => boolean;
+  resolveTarget: ChannelOutboundAdapter["resolveTarget"];
+  normalizeText?: (text: string | undefined) => string;
+  skipEmptyText?: boolean;
+};
+
+function resolveQuoteLookupAccountId(cfg?: AutoBotConfig, accountId?: string | null): string {
+  const explicitAccountId = normalizeOptionalAccountId(accountId);
+  if (explicitAccountId) {
+    return explicitAccountId;
+  }
+  const channelCfg = cfg?.channels?.whatsapp;
+  const configuredIds = listCombinedAccountIds({
+    configuredAccountIds:
+      channelCfg?.accounts && typeof channelCfg.accounts === "object"
+        ? Object.keys(channelCfg.accounts).filter(Boolean)
+        : [],
+    fallbackAccountIdWhenEmpty: DEFAULT_ACCOUNT_ID,
+  });
+  return resolveListedDefaultAccountId({
+    accountIds: configuredIds,
+    configuredDefaultAccountId: normalizeOptionalAccountId(channelCfg?.defaultAccount),
+  });
+}
+
+type WhatsAppOutboundBaseCore = Pick<
+  ChannelOutboundAdapter,
+  | "deliveryMode"
+  | "chunker"
+  | "chunkerMode"
+  | "textChunkLimit"
+  | "sanitizeText"
+  | "deliveryCapabilities"
+  | "pollMaxOptions"
+  | "resolveTarget"
+  | "sendText"
+  | "sendMedia"
+  | "sendPoll"
+>;
+
+export function createWhatsAppOutboundBase({
+  chunker,
+  sendMessageWhatsApp,
+  sendPollWhatsApp,
+  shouldLogVerbose,
+  resolveTarget,
+  normalizeText = normalizeWhatsAppPayloadText,
+  skipEmptyText = true,
+}: CreateWhatsAppOutboundBaseParams): Pick<
+  ChannelOutboundAdapter,
+  | "deliveryMode"
+  | "chunker"
+  | "chunkerMode"
+  | "textChunkLimit"
+  | "sanitizeText"
+  | "deliveryCapabilities"
+  | "pollMaxOptions"
+  | "resolveTarget"
+  | "sendPayload"
+  | "sendText"
+  | "sendMedia"
+  | "sendPoll"
+> {
+  const resolveQuotedMessageKey = (params: {
+    accountId: string;
+    to: string;
+    replyToId?: string | null;
+  }) => {
+    const replyToId = params.replyToId?.trim();
+    if (!replyToId) {
+      return undefined;
+    }
+    const targetJid = toWhatsappJid(params.to);
+    const cachedMeta = lookupInboundMessageMetaForTarget(params.accountId, targetJid, replyToId);
+    return {
+      id: replyToId,
+      remoteJid: cachedMeta?.remoteJid ?? targetJid,
+      fromMe: cachedMeta?.fromMe ?? false,
+      participant: cachedMeta?.participant,
+      messageText: cachedMeta?.body,
+    };
+  };
+
+  const outbound: WhatsAppOutboundBaseCore = {
+    deliveryMode: "gateway",
+    chunker,
+    chunkerMode: "text",
+    textChunkLimit: 4000,
+    sanitizeText: ({ text }) => normalizeText(text),
+    deliveryCapabilities: {
+      durableFinal: {
+        text: true,
+        replyTo: true,
+        messageSendingHooks: true,
+      },
+    },
+    pollMaxOptions: 12,
+    resolveTarget,
+    ...createAttachedChannelResultAdapter({
+      channel: "whatsapp",
+      sendText: async ({ cfg, to, text, accountId, deps, gifPlayback, replyToId }) => {
+        const normalizedText = normalizeText(text);
+        if (skipEmptyText && !normalizedText) {
+          return { messageId: "" };
+        }
+        const send =
+          resolveOutboundSendDep<WhatsAppSendMessage>(deps, "whatsapp", {
+            legacyKeys: WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS,
+          }) ?? sendMessageWhatsApp;
+        const lookupAccountId = resolveQuoteLookupAccountId(cfg, accountId);
+        const quotedMessageKey = resolveQuotedMessageKey({
+          accountId: lookupAccountId,
+          to,
+          replyToId,
+        });
+        return await send(to, normalizedText, {
+          verbose: false,
+          cfg,
+          accountId: accountId ?? undefined,
+          gifPlayback,
+          quotedMessageKey,
+        });
+      },
+      sendMedia: async ({
+        cfg,
+        to,
+        text,
+        mediaUrl,
+        mediaAccess,
+        mediaLocalRoots,
+        mediaReadFile,
+        audioAsVoice,
+        accountId,
+        deps,
+        gifPlayback,
+        forceDocument,
+        replyToId,
+      }) => {
+        const send =
+          resolveOutboundSendDep<WhatsAppSendMessage>(deps, "whatsapp", {
+            legacyKeys: WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS,
+          }) ?? sendMessageWhatsApp;
+        const lookupAccountId = resolveQuoteLookupAccountId(cfg, accountId);
+        const quotedMessageKey = resolveQuotedMessageKey({
+          accountId: lookupAccountId,
+          to,
+          replyToId,
+        });
+        return await send(to, normalizeText(text), {
+          verbose: false,
+          cfg,
+          mediaUrl,
+          mediaAccess,
+          mediaLocalRoots,
+          mediaReadFile,
+          ...(audioAsVoice === undefined ? {} : { audioAsVoice }),
+          accountId: accountId ?? undefined,
+          gifPlayback,
+          forceDocument,
+          quotedMessageKey,
+        });
+      },
+      sendPoll: async ({ cfg, to, poll, accountId }) =>
+        await sendPollWhatsApp(to, poll, {
+          verbose: shouldLogVerbose(),
+          accountId: accountId ?? undefined,
+          cfg,
+        }),
+    }),
+  };
+  return {
+    ...outbound,
+    sendPayload: async (ctx) => {
+      if (ctx.payload.isError === true) {
+        return { channel: "whatsapp", messageId: "" };
+      }
+      const payload = normalizeWhatsAppOutboundPayload(ctx.payload, { normalizeText });
+      if (!payload.text && !(payload.mediaUrl || payload.mediaUrls?.length)) {
+        if (ctx.payload.interactive || ctx.payload.presentation || ctx.payload.channelData) {
+          throw new Error(
+            "WhatsApp sendPayload does not support structured-only payloads without text or media.",
+          );
+        }
+        return { channel: "whatsapp", messageId: "" };
+      }
+      return await sendTextMediaPayload({
+        channel: "whatsapp",
+        ctx: {
+          ...ctx,
+          payload,
+        },
+        adapter: outbound,
+      });
+    },
+  };
+}