talon-agent 3.24.1 → 3.25.1

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

@@ -0,0 +1,248 @@
+/**
+ * Media actions — images, video, GIFs, voice notes, audio, documents,
+ * stickers, round video notes, albums, polls, locations, venues,
+ * contacts, and dice.
+ *
+ * Every Telegram/Discord send type has a WhatsApp equivalent except the
+ * two noted inline (dice is synthesised, albums are sent as a run of
+ * messages because WhatsApp groups them client-side by timing).
+ */
+
+import type { AnyMessageContent } from "baileys";
+import { toWhatsAppText } from "../formatting.js";
+import {
+  guessMimetype,
+  resolveMediaUpload,
+  resolveQuoted,
+  sendContent,
+  sendText,
+  tryAction,
+} from "./shared.js";
+import type { WhatsAppActionHandlers } from "./types.js";
+
+/** Optional caption, translated to WhatsApp's dialect. */
+function caption(body: Record<string, unknown>): { caption?: string } {
+  const raw = body.caption ?? body.text;
+  const text = raw === undefined || raw === null ? "" : String(raw);
+  return text.trim() ? { caption: toWhatsAppText(text) } : {};
+}
+
+/**
+ * Build the media payload for one send action. Returns an error string
+ * when the source can't be resolved, so callers report it verbatim.
+ */
+function buildMediaContent(
+  action: string,
+  body: Record<string, unknown>,
+): AnyMessageContent | { error: string } {
+  const resolved = resolveMediaUpload(body, action);
+  if ("error" in resolved) return resolved;
+  const { media, fileName } = resolved;
+
+  switch (action) {
+    case "send_photo":
+      return { image: media, ...caption(body) };
+    case "send_video":
+      return { video: media, ...caption(body) };
+    case "send_animation":
+      // WhatsApp has no GIF type — a looping muted video is what its own
+      // client sends when you pick a GIF.
+      return { video: media, gifPlayback: true, ...caption(body) };
+    case "send_video_note":
+      // ptv = "picture-in-video": the round bubble.
+      return { video: media, ptv: true };
+    case "send_voice":
+      return {
+        audio: media,
+        ptt: true,
+        mimetype: guessMimetype(fileName, "audio/ogg; codecs=opus"),
+      };
+    case "send_audio":
+      return {
+        audio: media,
+        ptt: false,
+        mimetype: guessMimetype(fileName, "audio/mpeg"),
+      };
+    case "send_sticker":
+      return { sticker: media };
+    case "send_file":
+    default:
+      return {
+        document: media,
+        mimetype: guessMimetype(fileName, "application/octet-stream"),
+        fileName: String(body.file_name ?? fileName),
+        ...caption(body),
+      };
+  }
+}
+
+const sendMedia: WhatsAppActionHandlers[string] = (body, _chatId, ctx) => {
+  const action = String(body.action);
+  return tryAction(action, async () => {
+    const content = buildMediaContent(action, body);
+    if ("error" in content) return { ok: false, error: content.error };
+    const quoted = resolveQuoted(body, ctx.chat!.chatId);
+    return sendContent(ctx, ctx.chat!, content, quoted ? { quoted } : {});
+  });
+};
+
+export const mediaHandlers: WhatsAppActionHandlers = {
+  send_photo: sendMedia,
+  send_video: sendMedia,
+  send_animation: sendMedia,
+  send_video_note: sendMedia,
+  send_voice: sendMedia,
+  send_audio: sendMedia,
+  send_file: sendMedia,
+
+  /**
+   * A sticker needs a WhatsApp-format .webp, addressed by file_path or
+   * url. Talon's saved sticker packs are Telegram file ids, which this
+   * account cannot upload, so an emoji-only request sends the emoji as
+   * its own message instead — WhatsApp renders a lone emoji large, which
+   * is the native form of the same gesture.
+   */
+  send_sticker: (body, _chatId, ctx) =>
+    tryAction("send_sticker", async () => {
+      if (!body.file_path && !body.url) {
+        const emoji = String(body.emoji ?? "").trim();
+        if (!emoji) {
+          return {
+            ok: false,
+            error:
+              "send_sticker: provide file_path or url to a .webp sticker, or an emoji",
+          };
+        }
+        return sendText(ctx, ctx.chat!, emoji);
+      }
+      const content = buildMediaContent("send_sticker", body);
+      if ("error" in content) return { ok: false, error: content.error };
+      return sendContent(ctx, ctx.chat!, content);
+    }),
+
+  /**
+   * WhatsApp has no album envelope on the send path — its client groups
+   * consecutive media from one sender itself, so a run of sends is the
+   * native shape. The first item's id is reported, matching how the other
+   * frontends treat a media group.
+   */
+  send_media_group: (body, _chatId, ctx) =>
+    tryAction("send_media_group", async () => {
+      const items = (body.media ?? []) as Array<Record<string, unknown>>;
+      if (!Array.isArray(items) || items.length === 0) {
+        return { ok: false, error: "send_media_group: media[] is required" };
+      }
+      let first: Awaited<ReturnType<typeof sendContent>> | undefined;
+      for (const item of items) {
+        const action =
+          String(item.type ?? "photo") === "video"
+            ? "send_video"
+            : "send_photo";
+        const content = buildMediaContent(action, item);
+        if ("error" in content) return { ok: false, error: content.error };
+        const result = await sendContent(ctx, ctx.chat!, content);
+        first ??= result;
+      }
+      return first ?? { ok: true };
+    }),
+
+  send_poll: (body, _chatId, ctx) =>
+    tryAction("send_poll", async () => {
+      const values = (body.options ?? []) as unknown[];
+      const question = String(body.question ?? "");
+      if (!question || !Array.isArray(values) || values.length < 2) {
+        return {
+          ok: false,
+          error: "send_poll: question and at least 2 options are required",
+        };
+      }
+      return sendContent(ctx, ctx.chat!, {
+        poll: {
+          name: question,
+          values: values.map((v) => String(v)),
+          selectableCount: body.allows_multiple_answers ? values.length : 1,
+        },
+      });
+    }),
+
+  send_location: (body, _chatId, ctx) =>
+    tryAction("send_location", async () => {
+      const latitude = Number(body.latitude);
+      const longitude = Number(body.longitude);
+      if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) {
+        return {
+          ok: false,
+          error: "send_location: latitude and longitude are required",
+        };
+      }
+      return sendContent(ctx, ctx.chat!, {
+        location: { degreesLatitude: latitude, degreesLongitude: longitude },
+      });
+    }),
+
+  send_venue: (body, _chatId, ctx) =>
+    tryAction("send_venue", async () => {
+      const latitude = Number(body.latitude);
+      const longitude = Number(body.longitude);
+      if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) {
+        return {
+          ok: false,
+          error: "send_venue: latitude and longitude are required",
+        };
+      }
+      // A venue is a location carrying a name and address — WhatsApp's
+      // location message has both fields.
+      return sendContent(ctx, ctx.chat!, {
+        location: {
+          degreesLatitude: latitude,
+          degreesLongitude: longitude,
+          name: body.title ? String(body.title) : undefined,
+          address: body.address ? String(body.address) : undefined,
+        },
+      });
+    }),
+
+  send_contact: (body, _chatId, ctx) =>
+    tryAction("send_contact", async () => {
+      const phone = String(body.phone_number ?? "").replace(/[^0-9+]/g, "");
+      const first = String(body.first_name ?? "").trim();
+      const last = String(body.last_name ?? "").trim();
+      const displayName = [first, last].filter(Boolean).join(" ") || phone;
+      if (!phone) {
+        return { ok: false, error: "send_contact: phone_number is required" };
+      }
+      // vCard 3.0 is what WhatsApp's own client emits for a shared contact.
+      const vcard = [
+        "BEGIN:VCARD",
+        "VERSION:3.0",
+        `FN:${displayName}`,
+        `TEL;type=CELL;waid=${phone.replace(/\D/g, "")}:${phone}`,
+        "END:VCARD",
+      ].join("\n");
+      return sendContent(ctx, ctx.chat!, {
+        contacts: { displayName, contacts: [{ vcard }] },
+      });
+    }),
+
+  /**
+   * WhatsApp has no dice message. Rolling here and sending the result
+   * keeps the tool honest — the model asked for a random throw and gets
+   * one, rendered the way a person would type it.
+   */
+  send_dice: (body, _chatId, ctx) =>
+    tryAction("send_dice", async () => {
+      const emoji = String(body.emoji ?? "🎲");
+      const faces: Record<string, number> = {
+        "🎲": 6,
+        "🎯": 6,
+        "🏀": 5,
+        "⚽": 5,
+        "🎳": 6,
+        "🎰": 64,
+      };
+      const max = faces[emoji] ?? 6;
+      const value = 1 + Math.floor(Math.random() * max);
+      const result = await sendText(ctx, ctx.chat!, `${emoji} ${value}`);
+      return { ...result, value };
+    }),
+};

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 };