talon-agent 3.24.1 → 3.25.0

package/src/frontend/whatsapp/actions/messaging.ts

@@ -0,0 +1,281 @@
+/**
+ * Messaging actions — text sends, replies, reactions, edits, deletes,
+ * forwards, pins, presence, and scheduled sends.
+ *
+ * Every message-addressed action goes through the message store: the
+ * model names a message by Talon's numeric id, WhatsApp needs the whole
+ * key, and `resolveKey` is the single place that translation happens.
+ */
+
+import { randomUUID } from "node:crypto";
+import { proto } from "baileys";
+import { log } from "../../../util/log.js";
+import { toWhatsAppText } from "../formatting.js";
+import {
+  lookupMessage,
+  rememberMessage,
+  resolveKey,
+} from "../message-store.js";
+import { recordPin, listPins, forgetPin } from "../pins.js";
+import { resolveQuoted, sendContent, sendText, tryAction } from "./shared.js";
+import type { WhatsAppActionHandlers } from "./types.js";
+
+/** WhatsApp keeps a pin for 24h, 7d, or 30d — no indefinite option. */
+const PIN_DURATIONS = [86_400, 604_800, 2_592_000] as const;
+
+/** Presence strings the `send_chat_action` verbs map onto. */
+const PRESENCE_BY_ACTION: Record<string, "composing" | "recording" | "paused"> =
+  {
+    typing: "composing",
+    upload_photo: "composing",
+    upload_document: "composing",
+    upload_video: "composing",
+    record_voice: "recording",
+    record_audio: "recording",
+    upload_voice: "recording",
+    upload_audio: "recording",
+    cancel: "paused",
+  };
+
+export const messagingHandlers: WhatsAppActionHandlers = {
+  send_message: (body, _chatId, ctx) =>
+    tryAction("send_message", async () => {
+      const text = String(body.text ?? "");
+      if (!text.trim()) return { ok: true };
+      return sendText(
+        ctx,
+        ctx.chat!,
+        text,
+        resolveQuoted(body, ctx.chat!.chatId),
+      );
+    }),
+
+  /**
+   * WhatsApp reserves interactive buttons for Business API senders, so a
+   * personal account renders the choices as a numbered list. The user can
+   * still answer ("2"), which is what the buttons were for.
+   */
+  send_message_with_buttons: (body, _chatId, ctx) =>
+    tryAction("send_message_with_buttons", async () => {
+      const text = String(body.text ?? "");
+      const rows = (body.rows ?? body.buttons) as
+        | Array<Array<{ text?: string; url?: string; callback_data?: string }>>
+        | undefined;
+      const options = (rows ?? [])
+        .flat()
+        .map((button, index) => {
+          const label = String(button.text ?? "").trim();
+          if (!label) return null;
+          return button.url
+            ? `${index + 1}. ${label} — ${button.url}`
+            : `${index + 1}. ${label}`;
+        })
+        .filter((line): line is string => line !== null);
+      const composed = options.length
+        ? `${text}\n\n${options.join("\n")}`
+        : text;
+      if (!composed.trim()) return { ok: true };
+      return sendText(
+        ctx,
+        ctx.chat!,
+        composed,
+        resolveQuoted(body, ctx.chat!.chatId),
+      );
+    }),
+
+  react: (body, _chatId, ctx) =>
+    tryAction("react", async () => {
+      const resolved = resolveKey(body.message_id, ctx.chat!.chatId);
+      if ("error" in resolved) return { ok: false, error: resolved.error };
+      // An empty emoji clears the reaction — WhatsApp's own semantics,
+      // and the only way to take one back.
+      await ctx.sock.sendMessage(ctx.chat!.jid, {
+        react: { text: String(body.emoji ?? ""), key: resolved.key },
+      });
+      return { ok: true };
+    }),
+
+  edit_message: (body, _chatId, ctx) =>
+    tryAction("edit_message", async () => {
+      const resolved = resolveKey(body.message_id, ctx.chat!.chatId);
+      if ("error" in resolved) return { ok: false, error: resolved.error };
+      const text = String(body.text ?? "");
+      if (!text.trim()) {
+        return { ok: false, error: "edit_message: text is required" };
+      }
+      await ctx.sock.sendMessage(ctx.chat!.jid, {
+        text: toWhatsAppText(text),
+        edit: resolved.key,
+      });
+      return { ok: true, message_id: resolved.stored.msgId };
+    }),
+
+  delete_message: (body, _chatId, ctx) =>
+    tryAction("delete_message", async () => {
+      const resolved = resolveKey(body.message_id, ctx.chat!.chatId);
+      if ("error" in resolved) return { ok: false, error: resolved.error };
+      await ctx.sock.sendMessage(ctx.chat!.jid, { delete: resolved.key });
+      forgetPin(ctx.chat!.chatId, resolved.stored.msgId);
+      return { ok: true };
+    }),
+
+  forward_message: (body, _chatId, ctx) =>
+    tryAction("forward_message", async () => {
+      const resolved = resolveKey(
+        body.message_id ?? body.from_message_id,
+        ctx.chat!.chatId,
+      );
+      if ("error" in resolved) return { ok: false, error: resolved.error };
+      const message = resolved.stored.message;
+      if (!message) {
+        return {
+          ok: false,
+          error: `Message ${resolved.stored.msgId} is no longer retained in full — cannot forward`,
+        };
+      }
+      return sendContent(ctx, ctx.chat!, { forward: message });
+    }),
+
+  /**
+   * WhatsApp has no server-side copy, so a copy is a fresh send of the
+   * stored text — which is what "copy without attribution" means anyway.
+   */
+  copy_message: (body, _chatId, ctx) =>
+    tryAction("copy_message", async () => {
+      const resolved = resolveKey(
+        body.message_id ?? body.from_message_id,
+        ctx.chat!.chatId,
+      );
+      if ("error" in resolved) return { ok: false, error: resolved.error };
+      const text = String(body.caption ?? resolved.stored.text ?? "");
+      if (!text.trim()) {
+        return {
+          ok: false,
+          error: `Message ${resolved.stored.msgId} has no text to copy`,
+        };
+      }
+      return sendText(ctx, ctx.chat!, text);
+    }),
+
+  pin_message: (body, _chatId, ctx) =>
+    tryAction("pin_message", async () => {
+      const resolved = resolveKey(body.message_id, ctx.chat!.chatId);
+      if ("error" in resolved) return { ok: false, error: resolved.error };
+      // WhatsApp pins expire; pick the longest window unless asked for less.
+      const requested = Number(body.seconds ?? 0);
+      const time =
+        PIN_DURATIONS.find((d) => d >= requested) ??
+        PIN_DURATIONS[PIN_DURATIONS.length - 1];
+      await ctx.sock.sendMessage(ctx.chat!.jid, {
+        pin: resolved.key,
+        type: proto.PinInChat.Type.PIN_FOR_ALL,
+        time,
+      });
+      recordPin(ctx.chat!.chatId, resolved.stored);
+      return { ok: true };
+    }),
+
+  unpin_message: (body, _chatId, ctx) =>
+    tryAction("unpin_message", async () => {
+      const resolved = resolveKey(body.message_id, ctx.chat!.chatId);
+      if ("error" in resolved) return { ok: false, error: resolved.error };
+      await ctx.sock.sendMessage(ctx.chat!.jid, {
+        pin: resolved.key,
+        type: proto.PinInChat.Type.UNPIN_FOR_ALL,
+      });
+      forgetPin(ctx.chat!.chatId, resolved.stored.msgId);
+      return { ok: true };
+    }),
+
+  /**
+   * WhatsApp exposes no "list pinned" query, so this reports the pins
+   * this process placed — the ones the model itself is responsible for.
+   */
+  get_pinned_messages: (_body, _chatId, ctx) => {
+    const pins = listPins(ctx.chat!.chatId);
+    return {
+      ok: true,
+      text: pins.length
+        ? pins
+            .map(
+              (pin) =>
+                `[${pin.senderName || "?"}] msg_id:${pin.msgId}: ${pin.text.slice(0, 200)}`,
+            )
+            .join("\n")
+        : "No messages pinned by Talon in this chat.",
+    };
+  },
+
+  send_chat_action: (body, _chatId, ctx) =>
+    tryAction("send_chat_action", async () => {
+      const requested = String(
+        body.action_type ?? body.chat_action ?? "typing",
+      );
+      const presence = PRESENCE_BY_ACTION[requested] ?? "composing";
+      await ctx.sock.sendPresenceUpdate(presence, ctx.chat!.jid);
+      return { ok: true };
+    }),
+
+  // ── Scheduled sends ──────────────────────────────────────────────────
+  // WhatsApp has no server-side scheduling, so the daemon holds the timer
+  // (same shape as the telegram/discord frontends).
+  schedule_message: (body, _chatId, ctx) =>
+    tryAction("schedule_message", async () => {
+      const text = String(body.text ?? "");
+      const seconds = Number(body.delay_seconds ?? 0);
+      if (!text.trim()) {
+        return { ok: false, error: "schedule_message: text is required" };
+      }
+      if (!Number.isFinite(seconds) || seconds <= 0) {
+        return {
+          ok: false,
+          error: "schedule_message: delay_seconds must be a positive number",
+        };
+      }
+      const id = randomUUID();
+      const chat = ctx.chat!;
+      const timer = setTimeout(() => {
+        ctx.scheduledMessages.delete(id);
+        void sendText(ctx, chat, text).catch(() => {});
+      }, seconds * 1000);
+      timer.unref?.();
+      ctx.scheduledMessages.set(id, timer);
+      log(
+        "whatsapp",
+        `Scheduled message ${id} for ${chat.chatId} in ${seconds}s`,
+      );
+      return { ok: true, id, text: `Scheduled in ${seconds}s (id ${id})` };
+    }),
+
+  cancel_scheduled: (body, _chatId, ctx) => {
+    const id = String(body.id ?? "");
+    const timer = ctx.scheduledMessages.get(id);
+    if (!timer) return { ok: false, error: `No scheduled message ${id}` };
+    clearTimeout(timer);
+    ctx.scheduledMessages.delete(id);
+    return { ok: true };
+  },
+
+  list_scheduled: (_body, _chatId, ctx) => ({
+    ok: true,
+    text: ctx.scheduledMessages.size
+      ? [...ctx.scheduledMessages.keys()].join("\n")
+      : "No scheduled messages.",
+  }),
+
+  /** Served from the message store — WhatsApp has no fetch-by-id API. */
+  get_message_by_id: (body, _chatId, ctx) => {
+    const raw = body.message_id;
+    const msgId = typeof raw === "number" ? raw : Number(raw);
+    const stored = Number.isFinite(msgId) ? lookupMessage(msgId) : undefined;
+    if (!stored || stored.chatId !== ctx.chat!.chatId) {
+      return { ok: false, error: `Unknown message_id ${String(raw)}` };
+    }
+    return {
+      ok: true,
+      text: `[${stored.senderName || "?"}] msg_id:${stored.msgId}: ${stored.text}`,
+    };
+  },
+};
+
+export { rememberMessage };

package/src/frontend/whatsapp/actions/moderation.ts

@@ -0,0 +1,231 @@
+/**
+ * Group administration — the `moderate` tool's op switch.
+ *
+ * WhatsApp's admin model is narrower than Telegram's: there is no ban
+ * list (removal is the only eviction), no per-member mute (a group is
+ * either open or admins-only), and no forum topics. Ops that have a
+ * faithful WhatsApp equivalent are mapped to it; the rest report what
+ * WhatsApp actually offers instead, so the model can pick another route
+ * rather than retrying something the platform cannot do.
+ */
+
+import { toUserJid, tryAction } from "./shared.js";
+import type { WhatsAppActionHandlers } from "./types.js";
+
+/** Ops that act on one member. */
+const PARTICIPANT_OPS: Record<string, "remove" | "add" | "promote" | "demote"> =
+  {
+    ban: "remove",
+    kick: "remove",
+    remove: "remove",
+    unban: "add",
+    add: "add",
+    promote: "promote",
+    demote: "demote",
+  };
+
+export const moderationHandlers: WhatsAppActionHandlers = {
+  moderate: (body, _chatId, ctx) =>
+    tryAction("moderate", async () => {
+      const op = String(body.op ?? "");
+      const chat = ctx.chat!;
+      const { sock } = ctx;
+
+      const participantOp = PARTICIPANT_OPS[op];
+      if (participantOp) {
+        if (!chat.isGroup) {
+          return { ok: false, error: `moderate(${op}) only applies to groups` };
+        }
+        const jid = toUserJid(body.user_id);
+        if (!jid) {
+          return { ok: false, error: `moderate(${op}) requires user_id` };
+        }
+        const [result] = await sock.groupParticipantsUpdate(
+          chat.jid,
+          [jid],
+          participantOp,
+        );
+        // Baileys reports per-participant status codes rather than throwing:
+        // 403 is "privacy settings blocked the add", 408 "not on WhatsApp".
+        const status = String(result?.status ?? "200");
+        if (status !== "200") {
+          return {
+            ok: false,
+            error: `WhatsApp refused ${op} for ${jid} (status ${status})`,
+          };
+        }
+        return {
+          ok: true,
+          text:
+            op === "ban"
+              ? `Removed ${jid} — WhatsApp has no ban list, so they can rejoin via an invite.`
+              : `${op} applied to ${jid}`,
+        };
+      }
+
+      switch (op) {
+        case "mute":
+        case "set_permissions": {
+          if (!chat.isGroup) {
+            return {
+              ok: false,
+              error: `moderate(${op}) only applies to groups`,
+            };
+          }
+          if (body.user_id) {
+            return {
+              ok: false,
+              error:
+                "WhatsApp has no per-member mute — mute the whole group " +
+                "(admins-only mode) or remove the member.",
+            };
+          }
+          // Announcement mode is WhatsApp's whole-group mute.
+          const permissions = (body.permissions ?? {}) as {
+            send_messages?: boolean;
+          };
+          const open =
+            op === "mute" ? false : permissions.send_messages !== false;
+          await sock.groupSettingUpdate(
+            chat.jid,
+            open ? "not_announcement" : "announcement",
+          );
+          return {
+            ok: true,
+            text: open
+              ? "All members can send messages."
+              : "Only admins can send messages.",
+          };
+        }
+
+        case "unmute": {
+          if (!chat.isGroup) {
+            return {
+              ok: false,
+              error: "moderate(unmute) only applies to groups",
+            };
+          }
+          await sock.groupSettingUpdate(chat.jid, "not_announcement");
+          return { ok: true, text: "All members can send messages." };
+        }
+
+        case "create_invite_link": {
+          if (!chat.isGroup) {
+            return { ok: false, error: "Only groups have invite links" };
+          }
+          const code = await sock.groupInviteCode(chat.jid);
+          return { ok: true, text: `https://chat.whatsapp.com/${code}` };
+        }
+
+        case "revoke_invite_link": {
+          if (!chat.isGroup) {
+            return { ok: false, error: "Only groups have invite links" };
+          }
+          const code = await sock.groupRevokeInvite(chat.jid);
+          return {
+            ok: true,
+            text: `Old link revoked. New link: https://chat.whatsapp.com/${code}`,
+          };
+        }
+
+        case "list_join_requests": {
+          if (!chat.isGroup) {
+            return { ok: false, error: "Only groups have join requests" };
+          }
+          const requests = await sock.groupRequestParticipantsList(chat.jid);
+          return {
+            ok: true,
+            text: requests.length
+              ? requests
+                  .map(
+                    (r) =>
+                      `${String(r.jid).split("@")[0]} (${r.request_method ?? "?"})`,
+                  )
+                  .join("\n")
+              : "No pending join requests.",
+          };
+        }
+
+        case "approve_join_request":
+        case "decline_join_request": {
+          if (!chat.isGroup) {
+            return { ok: false, error: "Only groups have join requests" };
+          }
+          const jid = toUserJid(body.user_id);
+          if (!jid) {
+            return { ok: false, error: `moderate(${op}) requires user_id` };
+          }
+          await sock.groupRequestParticipantsUpdate(
+            chat.jid,
+            [jid],
+            op === "approve_join_request" ? "approve" : "reject",
+          );
+          return { ok: true };
+        }
+
+        case "set_chat_photo": {
+          const source = body.file_path ?? body.url;
+          if (!source) {
+            return {
+              ok: false,
+              error: "moderate(set_chat_photo) requires file_path or url",
+            };
+          }
+          await sock.updateProfilePicture(chat.jid, { url: String(source) });
+          return { ok: true };
+        }
+
+        case "delete_chat_photo":
+          await sock.removeProfilePicture(chat.jid);
+          return { ok: true };
+
+        case "leave_chat": {
+          if (!chat.isGroup) {
+            return {
+              ok: false,
+              error:
+                "Cannot leave a direct message — block the contact instead",
+            };
+          }
+          await sock.groupLeave(chat.jid);
+          return { ok: true };
+        }
+
+        case "unpin_all": {
+          // WhatsApp unpins individually; clear the ones Talon placed.
+          const { listPins } = await import("../pins.js");
+          const pins = listPins(chat.chatId);
+          return {
+            ok: true,
+            text:
+              pins.length === 0
+                ? "No Talon-placed pins to clear."
+                : `WhatsApp unpins one message at a time — call unpin_message for: ${pins
+                    .map((p) => p.msgId)
+                    .join(", ")}`,
+          };
+        }
+
+        case "set_admin_title":
+          return {
+            ok: false,
+            error: "WhatsApp has no custom admin titles",
+          };
+
+        case "create_topic":
+        case "edit_topic":
+        case "close_topic":
+        case "reopen_topic":
+        case "delete_topic":
+          return {
+            ok: false,
+            error:
+              "WhatsApp groups have no topics — use separate groups, or a " +
+              "community with sub-groups (not manageable from this account).",
+          };
+
+        default:
+          return { ok: false, error: `Unknown moderate op: ${op}` };
+      }
+    }),
+};

package/src/frontend/whatsapp/actions/shared.ts

@@ -0,0 +1,196 @@
+/**
+ * Shared helpers for the WhatsApp action handlers: uniform error
+ * capture, media-source resolution, quoted-reply resolution, and the
+ * JID coercion the member-facing actions need.
+ */
+
+import { existsSync, statSync } from "node:fs";
+import { basename, extname } from "node:path";
+import type { AnyMessageContent, WAMessage, WASocket } from "baileys";
+import { expandFsPath } from "../../../util/fs-path.js";
+import { log, logError } from "../../../util/log.js";
+import type { ActionResult } from "../../../core/types.js";
+import { toWhatsAppChunks } from "../formatting.js";
+import { lookupMessage, rememberMessage } from "../message-store.js";
+import type { WhatsAppChatInfo } from "../registry.js";
+
+/** WhatsApp's own ceiling for a media upload. */
+const MAX_MEDIA_BYTES = 64 * 1024 * 1024;
+
+/**
+ * Run an action, converting a throw into a structured failure. WhatsApp
+ * errors arrive as Boom objects whose message is the useful part; the
+ * model gets that text so it can adapt rather than retry blindly.
+ */
+export async function tryAction(
+  label: string,
+  fn: () => Promise<ActionResult>,
+): Promise<ActionResult> {
+  try {
+    return await fn();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logError("whatsapp", `${label} failed: ${msg}`);
+    return { ok: false, error: `${label}: ${msg}` };
+  }
+}
+
+/** Baileys accepts a Buffer, a stream, or `{ url }` for local paths and HTTP. */
+export type MediaUpload = { url: string };
+
+/**
+ * Resolve one media input to something Baileys can upload. Two sources:
+ * a public URL (WhatsApp's uploader fetches it) or a workspace file path
+ * (streamed from disk). `file_id` is a Telegram concept with no WhatsApp
+ * equivalent — say so instead of failing obscurely.
+ */
+export function resolveMediaUpload(
+  src: { file_path?: unknown; url?: unknown; file_id?: unknown },
+  label: string,
+): { media: MediaUpload; fileName: string } | { error: string } {
+  if (src.url) {
+    const url = String(src.url);
+    return {
+      media: { url },
+      fileName: basename(new URL(url).pathname) || "file",
+    };
+  }
+  if (src.file_id) {
+    return {
+      error:
+        `${label}: WhatsApp has no file_id — re-send by url (public) or ` +
+        `file_path (workspace file)`,
+    };
+  }
+  if (!src.file_path) {
+    return {
+      error: `${label}: provide file_path (workspace file) or url (public)`,
+    };
+  }
+  const filePath = expandFsPath(String(src.file_path));
+  if (!existsSync(filePath)) {
+    return {
+      error: `File not found: ${filePath} — check the workspace path, or send by url instead`,
+    };
+  }
+  if (statSync(filePath).size > MAX_MEDIA_BYTES) {
+    return { error: `${label}: file exceeds WhatsApp's 64MB limit` };
+  }
+  return { media: { url: filePath }, fileName: basename(filePath) };
+}
+
+/** Extension → mimetype for the document/audio paths that require one. */
+const MIME_BY_EXT: Record<string, string> = {
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".json": "application/json",
+  ".csv": "text/csv",
+  ".zip": "application/zip",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".mp3": "audio/mpeg",
+  ".m4a": "audio/mp4",
+  ".ogg": "audio/ogg",
+  ".opus": "audio/ogg; codecs=opus",
+  ".wav": "audio/wav",
+};
+
+export function guessMimetype(fileName: string, fallback: string): string {
+  return MIME_BY_EXT[extname(fileName).toLowerCase()] ?? fallback;
+}
+
+/**
+ * Resolve a `reply_to` message id into the quoted message Baileys wants.
+ * An unknown id quotes nothing rather than failing the send — the reply
+ * link is a nicety, the message itself is the point.
+ */
+export function resolveQuoted(
+  body: Record<string, unknown>,
+  chatId: string,
+): WAMessage | undefined {
+  const raw = body.reply_to ?? body.reply_to_message_id;
+  if (raw === undefined || raw === null) return undefined;
+  const msgId = typeof raw === "number" ? raw : Number(raw);
+  if (!Number.isFinite(msgId)) return undefined;
+  const stored = lookupMessage(msgId);
+  if (!stored || stored.chatId !== chatId) return undefined;
+  return (
+    stored.message ?? {
+      key: stored.key,
+      message: { conversation: stored.text },
+    }
+  );
+}
+
+/**
+ * Send one content payload, remember the resulting message so later
+ * tool calls can address it, and report its Talon numeric id.
+ */
+export async function sendContent(
+  ctx: { sock: WASocket; gateway: { incrementMessages: (id: number) => void } },
+  chat: WhatsAppChatInfo,
+  content: AnyMessageContent,
+  options: { quoted?: WAMessage } = {},
+): Promise<ActionResult> {
+  const sent = await ctx.sock.sendMessage(chat.jid, content, options);
+  ctx.gateway.incrementMessages(chat.numericChatId);
+  if (!sent?.key) return { ok: true };
+  const msgId = rememberMessage({
+    key: sent.key,
+    chatId: chat.chatId,
+    message: sent,
+    text: "text" in content ? String(content.text ?? "") : "",
+    senderName: "bot",
+  });
+  return { ok: true, message_id: msgId };
+}
+
+/**
+ * Send text, split across bubbles when it exceeds WhatsApp's limit. The
+ * reported message id is the FIRST chunk's: it is the one a reply or
+ * reaction should attach to, and the one Talon's callers treat as "the"
+ * message.
+ */
+export async function sendText(
+  ctx: { sock: WASocket; gateway: { incrementMessages: (id: number) => void } },
+  chat: WhatsAppChatInfo,
+  text: string,
+  quoted?: WAMessage,
+): Promise<ActionResult> {
+  const chunks = toWhatsAppChunks(text);
+  let first: ActionResult | undefined;
+  for (const [index, chunk] of chunks.entries()) {
+    const result = await sendContent(
+      ctx,
+      chat,
+      { text: chunk },
+      // Only the first chunk quotes — a quoted block on every bubble of a
+      // long answer is noise.
+      index === 0 && quoted ? { quoted } : {},
+    );
+    first ??= result;
+  }
+  log(
+    "whatsapp",
+    `Sent ${chunks.length} chunk(s) to ${chat.chatId} (${text.length} chars)`,
+  );
+  return first ?? { ok: true };
+}
+
+/**
+ * Coerce a user reference the model supplied — bare number, JID, or the
+ * numeric id from a member listing — into a WhatsApp user JID.
+ */
+export function toUserJid(value: unknown): string | null {
+  const raw = String(value ?? "").trim();
+  if (!raw) return null;
+  if (raw.includes("@")) return raw;
+  const digits = raw.replace(/[^0-9]/g, "");
+  return digits ? `${digits}@s.whatsapp.net` : null;
+}