mercury-agent 0.4.5

package/src/adapters/setup.ts

@@ -0,0 +1,89 @@
+import { createSlackAdapter } from "@chat-adapter/slack";
+import { createTeamsAdapter } from "@chat-adapter/teams";
+import { createTelegramAdapter } from "@chat-adapter/telegram";
+import type { Adapter } from "chat";
+import type { AppConfig } from "../config.js";
+import { resolveProjectPath } from "../config.js";
+import { createDiscordNativeAdapter } from "./discord-native.js";
+import { createWhatsAppBaileysAdapter } from "./whatsapp.js";
+
+export function setupAdapters(config: AppConfig): Record<string, Adapter> {
+  const adapters: Record<string, Adapter> = {};
+
+  if (config.enableSlack) {
+    if (!process.env.MERCURY_SLACK_BOT_TOKEN) {
+      throw new Error(
+        "MERCURY_ENABLE_SLACK=true but MERCURY_SLACK_BOT_TOKEN is not set",
+      );
+    }
+    if (!process.env.MERCURY_SLACK_SIGNING_SECRET) {
+      throw new Error(
+        "MERCURY_ENABLE_SLACK=true but MERCURY_SLACK_SIGNING_SECRET is not set",
+      );
+    }
+    adapters.slack = createSlackAdapter({
+      botToken: process.env.MERCURY_SLACK_BOT_TOKEN,
+      signingSecret: process.env.MERCURY_SLACK_SIGNING_SECRET,
+    });
+  }
+
+  if (config.enableTeams) {
+    const appId = process.env.MERCURY_TEAMS_APP_ID;
+    const appPassword = process.env.MERCURY_TEAMS_APP_PASSWORD;
+    if (!appId) {
+      throw new Error(
+        "MERCURY_ENABLE_TEAMS=true but MERCURY_TEAMS_APP_ID is not set",
+      );
+    }
+    if (!appPassword) {
+      throw new Error(
+        "MERCURY_ENABLE_TEAMS=true but MERCURY_TEAMS_APP_PASSWORD is not set",
+      );
+    }
+    adapters.teams = createTeamsAdapter({
+      appId,
+      appPassword,
+      appType:
+        (process.env.MERCURY_TEAMS_APP_TYPE as
+          | "SingleTenant"
+          | "MultiTenant"
+          | undefined) ?? "SingleTenant",
+      appTenantId: process.env.MERCURY_TEAMS_APP_TENANT_ID,
+      userName: config.botUsername,
+    });
+  }
+
+  if (config.enableDiscord) {
+    if (!process.env.MERCURY_DISCORD_BOT_TOKEN) {
+      throw new Error(
+        "MERCURY_ENABLE_DISCORD=true but MERCURY_DISCORD_BOT_TOKEN is not set",
+      );
+    }
+    adapters.discord = createDiscordNativeAdapter({
+      userName: config.botUsername,
+    });
+  }
+
+  if (config.enableWhatsApp) {
+    adapters.whatsapp = createWhatsAppBaileysAdapter({
+      userName: config.botUsername,
+      authDir: resolveProjectPath(config.whatsappAuthDir),
+    });
+  }
+
+  if (config.enableTelegram) {
+    if (!process.env.MERCURY_TELEGRAM_BOT_TOKEN) {
+      throw new Error(
+        "MERCURY_ENABLE_TELEGRAM=true but MERCURY_TELEGRAM_BOT_TOKEN is not set",
+      );
+    }
+    adapters.telegram = createTelegramAdapter({
+      botToken: process.env.MERCURY_TELEGRAM_BOT_TOKEN,
+      userName: config.botUsername,
+      mode: "auto",
+      secretToken: process.env.MERCURY_TELEGRAM_WEBHOOK_SECRET_TOKEN,
+    });
+  }
+
+  return adapters;
+}

package/src/adapters/slack.ts

@@ -0,0 +1,9 @@
+/**
+ * Slack adapter integration layer.
+ *
+ * The adapter itself is created by @chat-adapter/slack in setup.ts.
+ * This module is kept for potential direct adapter factory use.
+ *
+ * All message handling logic has moved to src/bridges/slack.ts (SlackBridge)
+ * and src/core/handler.ts (createMessageHandler).
+ */

package/src/adapters/whatsapp-media.ts

@@ -0,0 +1,337 @@
+/**
+ * WhatsApp media download and processing.
+ *
+ * Downloads media attachments from WhatsApp messages and saves them to
+ * the group workspace. Implements generic MediaType classification that
+ * can be reused by other adapters.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import {
+  downloadMediaMessage,
+  type proto,
+  type WAMessage,
+  type WASocket,
+} from "@whiskeysockets/baileys";
+import { mimeToExt } from "../core/media.js";
+import { logger } from "../logger.js";
+import type { MediaType, MessageAttachment } from "../types.js";
+
+const silentBaileysLogger: {
+  level: string;
+  child: () => typeof silentBaileysLogger;
+  trace: () => void;
+  debug: () => void;
+  info: () => void;
+  warn: () => void;
+  error: () => void;
+  fatal: () => void;
+} = {
+  level: "silent",
+  child: () => silentBaileysLogger,
+  trace: () => undefined,
+  debug: () => undefined,
+  info: () => undefined,
+  warn: () => undefined,
+  error: () => undefined,
+  fatal: () => undefined,
+};
+
+/**
+ * Media info extracted from a WhatsApp message.
+ * Used internally before download.
+ */
+interface WhatsAppMediaInfo {
+  type: MediaType;
+  mimeType: string;
+  fileLength?: number;
+  filename?: string;
+}
+
+/**
+ * Options for media download.
+ */
+export interface MediaDownloadOptions {
+  /** Maximum file size in bytes. Files larger than this are skipped. */
+  maxSizeBytes: number;
+  /** Base directory for media storage (group workspace) */
+  outputDir: string;
+}
+
+/**
+ * Detect media type and extract metadata from a WhatsApp message.
+ * Returns null if the message has no media.
+ */
+export function detectWhatsAppMedia(
+  message: proto.IMessage | null | undefined,
+): WhatsAppMediaInfo | null {
+  if (!message) return null;
+
+  // Voice note (push-to-talk)
+  if (message.audioMessage?.ptt) {
+    return {
+      type: "voice",
+      mimeType: message.audioMessage.mimetype || "audio/ogg",
+      fileLength: message.audioMessage.fileLength
+        ? Number(message.audioMessage.fileLength)
+        : undefined,
+    };
+  }
+
+  // Regular audio
+  if (message.audioMessage) {
+    return {
+      type: "audio",
+      mimeType: message.audioMessage.mimetype || "audio/mpeg",
+      fileLength: message.audioMessage.fileLength
+        ? Number(message.audioMessage.fileLength)
+        : undefined,
+    };
+  }
+
+  // Image
+  if (message.imageMessage) {
+    return {
+      type: "image",
+      mimeType: message.imageMessage.mimetype || "image/jpeg",
+      fileLength: message.imageMessage.fileLength
+        ? Number(message.imageMessage.fileLength)
+        : undefined,
+    };
+  }
+
+  // Video
+  if (message.videoMessage) {
+    return {
+      type: "video",
+      mimeType: message.videoMessage.mimetype || "video/mp4",
+      fileLength: message.videoMessage.fileLength
+        ? Number(message.videoMessage.fileLength)
+        : undefined,
+    };
+  }
+
+  // Document
+  if (message.documentMessage) {
+    return {
+      type: "document",
+      mimeType: message.documentMessage.mimetype || "application/octet-stream",
+      fileLength: message.documentMessage.fileLength
+        ? Number(message.documentMessage.fileLength)
+        : undefined,
+      filename: message.documentMessage.fileName || undefined,
+    };
+  }
+
+  // Sticker (treat as image)
+  if (message.stickerMessage) {
+    return {
+      type: "image",
+      mimeType: message.stickerMessage.mimetype || "image/webp",
+      fileLength: message.stickerMessage.fileLength
+        ? Number(message.stickerMessage.fileLength)
+        : undefined,
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Download media from a WhatsApp message and save to the group workspace.
+ *
+ * @param msg - The WhatsApp message containing media
+ * @param sock - The WhatsApp socket connection
+ * @param options - Download options (max size, output directory)
+ * @returns Attachment metadata if successful, null if skipped or failed
+ */
+export async function downloadWhatsAppMedia(
+  msg: WAMessage,
+  sock: WASocket,
+  options: MediaDownloadOptions,
+): Promise<MessageAttachment | null> {
+  const mediaInfo = detectWhatsAppMedia(msg.message);
+  if (!mediaInfo) return null;
+
+  const messageId = msg.key.id || `${Date.now()}`;
+
+  // Check file size before downloading
+  if (mediaInfo.fileLength && mediaInfo.fileLength > options.maxSizeBytes) {
+    logger.warn("Skipping large media file", {
+      messageId,
+      type: mediaInfo.type,
+      sizeBytes: mediaInfo.fileLength,
+      maxBytes: options.maxSizeBytes,
+    });
+    return null;
+  }
+
+  try {
+    const buffer = (await downloadMediaMessage(
+      msg,
+      "buffer",
+      {},
+      {
+        // biome-ignore lint/suspicious/noExplicitAny: Baileys logger type is complex
+        logger: silentBaileysLogger as any,
+        reuploadRequest: sock.updateMediaMessage,
+      },
+    )) as Buffer;
+
+    if (!buffer || buffer.length === 0) {
+      logger.error("Failed to download media: empty buffer", { messageId });
+      return null;
+    }
+
+    // Check actual size after download (in case fileLength was missing)
+    if (buffer.length > options.maxSizeBytes) {
+      logger.warn("Downloaded media exceeds size limit, discarding", {
+        messageId,
+        type: mediaInfo.type,
+        sizeBytes: buffer.length,
+        maxBytes: options.maxSizeBytes,
+      });
+      return null;
+    }
+
+    // Ensure inbox directory exists
+    const mediaDir = path.join(options.outputDir, "inbox");
+    fs.mkdirSync(mediaDir, { recursive: true });
+
+    // Generate filename: {timestamp}-{type}.{ext}
+    const ext = mimeToExt(mediaInfo.mimeType);
+    const filename = mediaInfo.filename
+      ? `${Date.now()}-${mediaInfo.filename}`
+      : `${Date.now()}-${mediaInfo.type}.${ext}`;
+
+    const filePath = path.join(mediaDir, filename);
+
+    // Write file
+    fs.writeFileSync(filePath, buffer);
+
+    logger.info("Downloaded media", {
+      messageId,
+      type: mediaInfo.type,
+      mimeType: mediaInfo.mimeType,
+      sizeBytes: buffer.length,
+      path: filePath,
+    });
+
+    return {
+      path: filePath,
+      type: mediaInfo.type,
+      mimeType: mediaInfo.mimeType,
+      filename: mediaInfo.filename,
+      sizeBytes: buffer.length,
+    };
+  } catch (error) {
+    logger.error("Failed to download media", {
+      messageId,
+      type: mediaInfo.type,
+      error: error instanceof Error ? error.message : String(error),
+    });
+    return null;
+  }
+}
+
+/**
+ * Download audio from a quoted (replied-to) WhatsApp message.
+ * Only downloads voice/audio types — other media types are skipped.
+ */
+export async function downloadQuotedMedia(
+  contextInfo: proto.IContextInfo,
+  sock: WASocket,
+  options: MediaDownloadOptions,
+): Promise<MessageAttachment | null> {
+  const quotedMessage = contextInfo.quotedMessage;
+  if (!quotedMessage) return null;
+
+  const mediaInfo = detectWhatsAppMedia(quotedMessage);
+  if (!mediaInfo) return null;
+
+  if (mediaInfo.type !== "voice" && mediaInfo.type !== "audio") return null;
+
+  const syntheticMsg: WAMessage = {
+    key: {
+      id: contextInfo.stanzaId || `quoted-${Date.now()}`,
+      remoteJid: contextInfo.remoteJid || undefined,
+      participant: contextInfo.participant || undefined,
+      fromMe: false,
+    },
+    message: quotedMessage,
+  };
+
+  const messageId = syntheticMsg.key.id || `${Date.now()}`;
+
+  if (mediaInfo.fileLength && mediaInfo.fileLength > options.maxSizeBytes) {
+    logger.warn("Skipping large quoted media file", {
+      messageId,
+      type: mediaInfo.type,
+      sizeBytes: mediaInfo.fileLength,
+      maxBytes: options.maxSizeBytes,
+    });
+    return null;
+  }
+
+  try {
+    const buffer = (await downloadMediaMessage(
+      syntheticMsg,
+      "buffer",
+      {},
+      {
+        // biome-ignore lint/suspicious/noExplicitAny: Baileys logger type is complex
+        logger: silentBaileysLogger as any,
+        reuploadRequest: sock.updateMediaMessage,
+      },
+    )) as Buffer;
+
+    if (!buffer || buffer.length === 0) {
+      logger.warn("Failed to download quoted media: empty buffer", {
+        messageId,
+      });
+      return null;
+    }
+
+    if (buffer.length > options.maxSizeBytes) {
+      logger.warn("Downloaded quoted media exceeds size limit, discarding", {
+        messageId,
+        type: mediaInfo.type,
+        sizeBytes: buffer.length,
+        maxBytes: options.maxSizeBytes,
+      });
+      return null;
+    }
+
+    const mediaDir = path.join(options.outputDir, "inbox");
+    fs.mkdirSync(mediaDir, { recursive: true });
+
+    const ext = mimeToExt(mediaInfo.mimeType);
+    const filename = `${Date.now()}-${mediaInfo.type}.${ext}`;
+    const filePath = path.join(mediaDir, filename);
+
+    fs.writeFileSync(filePath, buffer);
+
+    logger.info("Downloaded quoted media", {
+      messageId,
+      type: mediaInfo.type,
+      mimeType: mediaInfo.mimeType,
+      sizeBytes: buffer.length,
+      path: filePath,
+    });
+
+    return {
+      path: filePath,
+      type: mediaInfo.type,
+      mimeType: mediaInfo.mimeType,
+      sizeBytes: buffer.length,
+    };
+  } catch (error) {
+    logger.warn("Failed to download quoted media", {
+      messageId,
+      type: mediaInfo.type,
+      error: error instanceof Error ? error.message : String(error),
+    });
+    return null;
+  }
+}