mercury-agent 0.4.5

package/src/bridges/whatsapp.ts

@@ -0,0 +1,290 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { proto, WAMessage } from "@whiskeysockets/baileys";
+import type { Message } from "chat";
+import type { WhatsAppBaileysAdapter } from "../adapters/whatsapp.js";
+import {
+  detectWhatsAppMedia,
+  downloadQuotedMedia,
+  downloadWhatsAppMedia,
+} from "../adapters/whatsapp-media.js";
+import { logger } from "../logger.js";
+import { normalizeChatMarkdown } from "../text/markdown.js";
+import { applyRtlDirection } from "../text/rtl.js";
+import type {
+  EgressFile,
+  IngressMessage,
+  MessageAttachment,
+  NormalizeContext,
+  PlatformBridge,
+} from "../types.js";
+
+export class WhatsAppBridge implements PlatformBridge {
+  readonly platform = "whatsapp";
+
+  constructor(private readonly adapter: WhatsAppBaileysAdapter) {}
+
+  parseThread(threadId: string): { externalId: string; isDM: boolean } {
+    const parts = threadId.split(":");
+    const externalId = parts.slice(1).join(":");
+    const isDM = !threadId.includes("@g.us");
+    return { externalId, isDM };
+  }
+
+  async normalize(
+    threadId: string,
+    message: unknown,
+    ctx: NormalizeContext,
+    spaceId: string,
+  ): Promise<IngressMessage | null> {
+    const msg = message as Message<proto.IWebMessageInfo>;
+    if (msg.author.isMe) return null;
+
+    const text = msg.text.trim();
+    const metadata = msg.metadata as {
+      isReplyToBot?: boolean;
+      replyToMessageId?: string;
+    };
+    const isReplyToBot = metadata?.isReplyToBot ?? false;
+
+    // Download media in the bridge layer (like Discord/Slack) so it lands
+    // in the resolved space workspace, not the raw conversation directory.
+    const attachments: MessageAttachment[] = [];
+    const rawMsg = msg.raw as WAMessage | undefined;
+    const sock = this.adapter.socket;
+
+    if (rawMsg && sock && ctx.media.enabled) {
+      const mediaInfo = detectWhatsAppMedia(rawMsg.message);
+      if (mediaInfo) {
+        if (await ctx.isOverQuota()) {
+          logger.warn("Skipping media download — storage quota exceeded", {
+            spaceId,
+          });
+        } else {
+          const workspace = ctx.getWorkspace(spaceId);
+          try {
+            const attachment = await downloadWhatsAppMedia(rawMsg, sock, {
+              maxSizeBytes: ctx.media.maxSizeBytes,
+              outputDir: workspace,
+            });
+            if (attachment) {
+              attachments.push(attachment);
+            }
+          } catch (error) {
+            logger.error("Failed to download media in bridge", {
+              error: error instanceof Error ? error.message : String(error),
+            });
+          }
+        }
+      }
+
+      if (attachments.length === 0) {
+        const contextInfo =
+          rawMsg.message?.extendedTextMessage?.contextInfo ||
+          rawMsg.message?.audioMessage?.contextInfo ||
+          rawMsg.message?.imageMessage?.contextInfo ||
+          rawMsg.message?.videoMessage?.contextInfo ||
+          rawMsg.message?.documentMessage?.contextInfo ||
+          rawMsg.message?.stickerMessage?.contextInfo;
+        if (contextInfo?.quotedMessage) {
+          if (await ctx.isOverQuota()) {
+            logger.warn(
+              "Skipping quoted media download — storage quota exceeded",
+              { spaceId },
+            );
+          } else {
+            const workspace = ctx.getWorkspace(spaceId);
+            try {
+              const attachment = await downloadQuotedMedia(contextInfo, sock, {
+                maxSizeBytes: ctx.media.maxSizeBytes,
+                outputDir: workspace,
+              });
+              if (attachment) {
+                attachments.push(attachment);
+              }
+            } catch (error) {
+              logger.warn("Failed to download quoted media in bridge", {
+                error: error instanceof Error ? error.message : String(error),
+              });
+            }
+          }
+        }
+      }
+    }
+
+    if (!text && attachments.length === 0) return null;
+
+    const { externalId, isDM } = this.parseThread(threadId);
+
+    return {
+      platform: "whatsapp",
+      spaceId,
+      conversationExternalId: externalId,
+      callerId: `whatsapp:${msg.author.userId || "unknown"}`,
+      authorName: msg.author.userName,
+      text,
+      isDM,
+      isReplyToBot,
+      attachments,
+      replyToPlatformMessageId: metadata?.replyToMessageId ?? undefined,
+      platformMessageId:
+        (metadata as { platformMessageId?: string })?.platformMessageId ??
+        undefined,
+    };
+  }
+
+  async sendReply(
+    threadId: string,
+    text: string,
+    files?: EgressFile[],
+  ): Promise<string | undefined> {
+    if (files && files.length > 0) {
+      return this.sendFiles(threadId, text, files);
+    } else if (text) {
+      const sent = await this.adapter.postMessage(threadId, text);
+      return sent.id;
+    }
+    return undefined;
+  }
+
+  async editMessage(
+    threadId: string,
+    messageId: string,
+    text: string,
+  ): Promise<boolean> {
+    const sock = this.adapter.socket;
+    if (!sock) return false;
+    const { chatJid } = this.adapter.decodeThreadId(threadId);
+    try {
+      const isGroup = chatJid.endsWith("@g.us");
+      const participant = isGroup ? sock.user?.id : undefined;
+      await sock.sendMessage(chatJid, {
+        text: applyRtlDirection(normalizeChatMarkdown(text)),
+        edit: {
+          remoteJid: chatJid,
+          id: messageId,
+          fromMe: true,
+          ...(participant ? { participant } : {}),
+        },
+      });
+      return true;
+    } catch (err) {
+      logger.warn("WhatsApp editMessage failed", {
+        threadId,
+        messageId,
+        error: err instanceof Error ? err.message : String(err),
+      });
+      return false;
+    }
+  }
+
+  async deleteMessages(threadId: string, messageIds: string[]): Promise<void> {
+    const sock = this.adapter.socket;
+    if (!sock) return;
+    const { chatJid } = this.adapter.decodeThreadId(threadId);
+    for (const id of messageIds) {
+      try {
+        await sock.sendMessage(chatJid, {
+          delete: { remoteJid: chatJid, id, fromMe: true },
+        });
+      } catch {
+        // best-effort
+      }
+    }
+  }
+
+  private async sendFiles(
+    threadId: string,
+    text: string,
+    files: EgressFile[],
+  ): Promise<string | undefined> {
+    const { chatJid } = this.adapter.decodeThreadId(threadId);
+    const sock = this.adapter.socket;
+
+    if (!sock) {
+      logger.warn("WhatsApp socket unavailable, falling back to text-only");
+      if (text) {
+        const sent = await this.adapter.postMessage(threadId, text);
+        return sent.id;
+      }
+      return undefined;
+    }
+
+    let textSent = !text;
+    let lastSentId: string | undefined;
+
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+      const isLast = i === files.length - 1;
+      const caption =
+        isLast && !textSent
+          ? applyRtlDirection(normalizeChatMarkdown(text))
+          : undefined;
+
+      let buffer: Buffer;
+      try {
+        buffer = fs.readFileSync(file.path);
+      } catch (err) {
+        logger.error("Failed to read egress file", {
+          path: file.path,
+          error: err instanceof Error ? err.message : String(err),
+        });
+        continue;
+      }
+
+      try {
+        const mime = file.mimeType;
+        let sent: WAMessage | undefined;
+
+        if (mime.startsWith("image/")) {
+          sent = await sock.sendMessage(chatJid, {
+            image: buffer,
+            caption,
+            mimetype: mime,
+          });
+        } else if (mime.startsWith("video/")) {
+          sent = await sock.sendMessage(chatJid, {
+            video: buffer,
+            caption,
+            mimetype: mime,
+          });
+        } else if (mime.startsWith("audio/")) {
+          const base = path.basename(file.filename);
+          const ptt =
+            base.toLowerCase().endsWith(".ogg") && /^voice-/i.test(base);
+          sent = await sock.sendMessage(chatJid, {
+            audio: buffer,
+            mimetype: mime,
+            ptt,
+          });
+          if (caption) {
+            sent = await sock.sendMessage(chatJid, { text: caption });
+          }
+        } else {
+          sent = await sock.sendMessage(chatJid, {
+            document: buffer,
+            fileName: file.filename,
+            mimetype: mime,
+            caption,
+          });
+        }
+        if (sent?.key?.id) lastSentId = sent.key.id;
+        if (caption) textSent = true;
+      } catch (err) {
+        logger.error("Failed to send file via WhatsApp", {
+          filename: file.filename,
+          error: err instanceof Error ? err.message : String(err),
+        });
+      }
+    }
+
+    if (!textSent) {
+      const sent = await sock.sendMessage(chatJid, {
+        text: applyRtlDirection(normalizeChatMarkdown(text)),
+      });
+      if (sent?.key?.id) lastSentId = sent.key.id;
+    }
+
+    return lastSentId;
+  }
+}

package/src/chat-shim.ts

@@ -0,0 +1,259 @@
+/**
+ * Minimal ChatInstance shim that satisfies the Chat SDK adapter interface
+ * without the full Chat routing pipeline.
+ *
+ * Mercury uses its own message routing (conversation resolution, trigger matching,
+ * space queues). The Chat SDK's subscription/mention routing adds no value here.
+ *
+ * This shim:
+ * - Routes processMessage() directly to Mercury's handler callback
+ * - Provides a minimal in-memory StateAdapter for adapters that need caching
+ *   (e.g., Slack adapter caches user display names)
+ * - Stubs out action/modal/slash-command processing (Mercury doesn't use these)
+ */
+
+import type {
+  Adapter,
+  ChatInstance,
+  Logger,
+  Message,
+  QueueEntry,
+  StateAdapter,
+  WebhookOptions,
+} from "chat";
+import { logger as mercuryLogger } from "./logger.js";
+
+/** Callback invoked when an adapter receives a message */
+export type MessageCallback = (
+  adapter: Adapter,
+  threadId: string,
+  message: Message,
+) => void;
+
+/** Pino-to-Chat SDK logger bridge */
+class PinoLoggerBridge implements Logger {
+  private readonly prefix: string;
+
+  constructor(prefix = "") {
+    this.prefix = prefix;
+  }
+
+  child(childPrefix: string): Logger {
+    const combined = this.prefix
+      ? `${this.prefix}:${childPrefix}`
+      : childPrefix;
+    return new PinoLoggerBridge(combined);
+  }
+
+  debug(message: string, ..._args: unknown[]): void {
+    mercuryLogger.debug(this.prefix ? `[${this.prefix}] ${message}` : message);
+  }
+
+  info(message: string, ..._args: unknown[]): void {
+    mercuryLogger.info(this.prefix ? `[${this.prefix}] ${message}` : message);
+  }
+
+  warn(message: string, ..._args: unknown[]): void {
+    mercuryLogger.warn(this.prefix ? `[${this.prefix}] ${message}` : message);
+  }
+
+  error(message: string, ..._args: unknown[]): void {
+    mercuryLogger.error(this.prefix ? `[${this.prefix}] ${message}` : message);
+  }
+}
+
+/**
+ * Minimal in-memory StateAdapter for adapter-internal caching needs.
+ * NOT used for Mercury's own state (that's in SQLite).
+ */
+class MinimalStateAdapter implements StateAdapter {
+  private readonly cache = new Map<
+    string,
+    { value: unknown; expiresAt: number | null }
+  >();
+
+  async connect(): Promise<void> {}
+  async disconnect(): Promise<void> {
+    this.cache.clear();
+  }
+
+  // Subscriptions — Mercury doesn't use Chat SDK subscriptions
+  async subscribe(_threadId: string): Promise<void> {}
+  async unsubscribe(_threadId: string): Promise<void> {}
+  async isSubscribed(_threadId: string): Promise<boolean> {
+    return false;
+  }
+
+  // Locks — Mercury has its own SpaceQueue
+  async acquireLock(
+    _threadId: string,
+    _ttlMs: number,
+  ): Promise<{ threadId: string; token: string; expiresAt: number } | null> {
+    // Always grant — Mercury handles its own concurrency
+    return {
+      threadId: _threadId,
+      token: `shim_${Date.now()}`,
+      expiresAt: Date.now() + _ttlMs,
+    };
+  }
+
+  async releaseLock(_lock: {
+    threadId: string;
+    token: string;
+    expiresAt: number;
+  }): Promise<void> {}
+
+  async extendLock(
+    _lock: { threadId: string; token: string; expiresAt: number },
+    _ttlMs: number,
+  ): Promise<boolean> {
+    return true;
+  }
+
+  // Cache — used by Slack adapter for user display name caching
+  async get<T = unknown>(key: string): Promise<T | null> {
+    const cached = this.cache.get(key);
+    if (!cached) return null;
+    if (cached.expiresAt !== null && cached.expiresAt <= Date.now()) {
+      this.cache.delete(key);
+      return null;
+    }
+    return cached.value as T;
+  }
+
+  async set<T = unknown>(key: string, value: T, ttlMs?: number): Promise<void> {
+    this.cache.set(key, {
+      value,
+      expiresAt: ttlMs ? Date.now() + ttlMs : null,
+    });
+  }
+
+  async delete(key: string): Promise<void> {
+    this.cache.delete(key);
+  }
+
+  async appendToList(
+    key: string,
+    value: unknown,
+    options?: { maxLength?: number; ttlMs?: number },
+  ): Promise<void> {
+    const existing = (await this.get<unknown[]>(key)) ?? [];
+    existing.push(value);
+    if (options?.maxLength && existing.length > options.maxLength) {
+      existing.splice(0, existing.length - options.maxLength);
+    }
+    await this.set(key, existing, options?.ttlMs);
+  }
+
+  async getList<T = unknown>(key: string): Promise<T[]> {
+    return (await this.get<T[]>(key)) ?? [];
+  }
+
+  async forceReleaseLock(_threadId: string): Promise<void> {}
+
+  async setIfNotExists(
+    key: string,
+    value: unknown,
+    ttlMs?: number,
+  ): Promise<boolean> {
+    const existing = await this.get(key);
+    if (existing !== null) return false;
+    await this.set(key, value, ttlMs);
+    return true;
+  }
+
+  // Message queue — Mercury uses its own SpaceQueue, so these are no-ops
+  private readonly queues = new Map<string, QueueEntry[]>();
+
+  async enqueue(
+    threadId: string,
+    entry: QueueEntry,
+    maxSize: number,
+  ): Promise<number> {
+    const q = this.queues.get(threadId) ?? [];
+    q.push(entry);
+    if (q.length > maxSize) q.splice(0, q.length - maxSize);
+    this.queues.set(threadId, q);
+    return q.length;
+  }
+
+  async dequeue(threadId: string): Promise<QueueEntry | null> {
+    const q = this.queues.get(threadId);
+    if (!q || q.length === 0) return null;
+    return q.shift() ?? null;
+  }
+
+  async queueDepth(threadId: string): Promise<number> {
+    return this.queues.get(threadId)?.length ?? 0;
+  }
+}
+
+/**
+ * Create a minimal ChatInstance shim.
+ *
+ * @param onMessage - Called when any adapter receives a message.
+ *   Mercury's handler is wired here instead of Chat SDK's event routing.
+ */
+export function createChatShim(onMessage: MessageCallback): ChatInstance {
+  const state = new MinimalStateAdapter();
+  const chatLogger = new PinoLoggerBridge("chat-shim");
+
+  return {
+    getLogger(prefix?: string): Logger {
+      return prefix ? chatLogger.child(prefix) : chatLogger;
+    },
+
+    getState(): StateAdapter {
+      return state;
+    },
+
+    getUserName(): string {
+      return "mercury";
+    },
+
+    // Deprecated — but Slack adapter may still call it
+    async handleIncomingMessage(
+      adapter: Adapter,
+      threadId: string,
+      message: Message,
+    ): Promise<void> {
+      onMessage(adapter, threadId, message);
+    },
+
+    processMessage(
+      adapter: Adapter,
+      threadId: string,
+      message: Message | (() => Promise<Message>),
+      _options?: WebhookOptions,
+    ): void {
+      void (async () => {
+        try {
+          const msg = typeof message === "function" ? await message() : message;
+
+          // Skip bot's own messages
+          if (msg.author.isMe) return;
+
+          onMessage(adapter, threadId, msg);
+        } catch (err) {
+          chatLogger.error(
+            "processMessage failed",
+            err instanceof Error ? err.message : String(err),
+          );
+        }
+      })();
+    },
+
+    // Stubs — Mercury doesn't use these Chat SDK features
+    async processAction(_event, _options?): Promise<void> {},
+    processAppHomeOpened(_event, _options?): void {},
+    processAssistantContextChanged(_event, _options?): void {},
+    processAssistantThreadStarted(_event, _options?): void {},
+    processModalClose(_event, _contextId?, _options?): void {},
+    async processModalSubmit(_event, _contextId?, _options?) {
+      return undefined;
+    },
+    processReaction(_event, _options?): void {},
+    processMemberJoinedChannel(_event, _options?): void {},
+    processSlashCommand(_event, _options?): void {},
+  };
+}