whats-mcp 0.1.0

package/src/connection.js

@@ -0,0 +1,334 @@
+/**
+ * whats-mcp — Baileys connection manager.
+ *
+ * Manages the WhatsApp Web socket: authentication, QR handling,
+ * auto-reconnect with exponential backoff, and connection state.
+ */
+
+"use strict";
+
+const {
+  default: makeWASocket,
+  useMultiFileAuthState,
+  makeCacheableSignalKeyStore,
+  fetchLatestBaileysVersion,
+  DisconnectReason,
+  Browsers,
+} = require("@whiskeysockets/baileys");
+const pino = require("pino");
+const path = require("path");
+const os   = require("os");
+const fs   = require("fs");
+const qrcode = require("qrcode-terminal");
+const { ALL_WA_PATCH_NAMES } = require("@whiskeysockets/baileys");
+const Store = require("./store");
+
+// ── State ────────────────────────────────────────────────────────────────────
+
+/** @type {import("@whiskeysockets/baileys").WASocket | null} */
+let sock = null;
+
+/** @type {'disconnected' | 'connecting' | 'open' | 'closing'} */
+let connectionState = "disconnected";
+
+/** @type {Store} */
+let store = null;
+
+/** @type {number} */
+let reconnectAttempts = 0;
+
+/** @type {any} */
+let config = null;
+let persistStoreTimer = null;
+let currentAuthPath = null;
+
+// ── Logging (stderr only — stdout is MCP JSON-RPC) ──────────────────────────
+
+const logger = pino({ level: "silent" });
+const log = (...args) => process.stderr.write(args.join(" ") + "\n");
+
+// ── Public API ───────────────────────────────────────────────────────────────
+
+/**
+ * Initialise and connect to WhatsApp.
+ * @param {object} cfg - Parsed config.json
+ * @returns {{ sock: import("@whiskeysockets/baileys").WASocket, store: Store }}
+ */
+async function connect(cfg) {
+  config = cfg;
+
+  const stateDir = (cfg.server?.state_directory || "~/.mcps/whatsapp").replace(
+    /^~/,
+    os.homedir()
+  );
+  const authPath = path.join(stateDir, "auth");
+  currentAuthPath = authPath;
+  const pidFile  = path.join(stateDir, "whats-mcp.pid");
+  const storeFile = path.join(stateDir, "store.json");
+
+  fs.mkdirSync(stateDir,  { recursive: true });
+  fs.mkdirSync(authPath, { recursive: true });
+
+  // PID lifecycle
+  fs.writeFileSync(pidFile, String(process.pid));
+  const clearPid = () => {
+    try {
+      const current = fs.readFileSync(pidFile, "utf-8").trim();
+      if (current === String(process.pid)) {
+        fs.unlinkSync(pidFile);
+      }
+    } catch (_) {
+      /* ignore */
+    }
+  };
+  process.on("exit",    clearPid);
+  process.on("SIGTERM", () => process.exit(0));
+  process.on("SIGINT",  () => process.exit(0));
+
+  // Store
+  store = new Store({
+    ...(cfg.store || {}),
+    onChange: () => {
+      if (cfg.store?.persist === false) return;
+      if (persistStoreTimer) clearTimeout(persistStoreTimer);
+      persistStoreTimer = setTimeout(() => {
+        try {
+          store.saveSnapshot(storeFile);
+        } catch (err) {
+          logger.warn({ err }, "Failed to persist store snapshot");
+        }
+      }, 500);
+    },
+  });
+
+  if (cfg.store?.persist !== false) {
+    try {
+      if (store.loadSnapshot(storeFile)) {
+        log(`[WA] Restored store snapshot from ${storeFile}`);
+      }
+    } catch (err) {
+      logger.warn({ err }, "Failed to restore store snapshot");
+    }
+  }
+
+  // Bootstrap dynamic watchlists from config (non-destructive: only imports missing names)
+  if (cfg.watchlists && Object.keys(cfg.watchlists).length > 0) {
+    const imported = store.importWatchlistsFromConfig(cfg.watchlists);
+    if (imported > 0) {
+      log(`[WA] Seeded ${imported} watchlist(s) from config into store`);
+    }
+  }
+
+  // Connect
+  await _createSocket(authPath, cfg);
+
+  return { sock, store };
+}
+
+/**
+ * Request an explicit reconnect of the live WhatsApp socket without restarting
+ * the container. This keeps admin pollers and in-memory state stable.
+ */
+async function requestReconnect() {
+  if (!config || !currentAuthPath) {
+    throw new Error("WhatsApp runtime is not initialized yet.");
+  }
+  log("[WA] Admin reconnect requested.");
+  await _createSocket(currentAuthPath, config);
+  return getConnectionInfo();
+}
+
+/**
+ * Get the current socket.  Throws if not connected.
+ * @returns {import("@whiskeysockets/baileys").WASocket}
+ */
+function getSocket() {
+  if (!sock || connectionState !== "open") {
+    const { WhatsAppError } = require("./helpers");
+    throw new WhatsAppError(
+      "WhatsApp is not connected. " +
+      (connectionState === "connecting"
+        ? "Connection in progress — please wait or scan the QR code."
+        : "Run the server and scan the QR code to connect."),
+      "NOT_CONNECTED"
+    );
+  }
+  return sock;
+}
+
+/** Get the current store. */
+function getStore() {
+  if (!store) {
+    store = new Store();
+  }
+  return store;
+}
+
+/** Get connection state info. */
+function getConnectionInfo() {
+  return {
+    state: connectionState,
+    user: sock?.user
+      ? {
+          id: sock.user.id,
+          name: sock.user.name || sock.user.verifiedName || undefined,
+          phone: sock.user.id?.split(":")[0] || undefined,
+        }
+      : null,
+    store_stats: store?.stats() || null,
+    reconnect_attempts: reconnectAttempts,
+  };
+}
+
+// ── Internal ─────────────────────────────────────────────────────────────────
+
+/** Whether a reconnect is already in flight (prevents concurrent reconnects). */
+let reconnecting = false;
+
+/**
+ * Gracefully close existing socket before creating a new one.
+ */
+function _cleanupSocket() {
+  if (sock) {
+    try {
+      sock.ev.removeAllListeners();
+      sock.end(undefined);        // graceful close (no error)
+    } catch (_) { /* socket may already be dead */ }
+    sock = null;
+  }
+}
+
+async function _createSocket(authPath, cfg) {
+  // Prevent parallel reconnection races
+  if (reconnecting) return;
+  reconnecting = true;
+
+  try {
+    connectionState = "connecting";
+
+    // Clean up old socket FIRST to avoid 440 (connectionReplaced)
+    _cleanupSocket();
+
+    // Fetch latest WA Web version to avoid 405 errors
+    const { version } = await fetchLatestBaileysVersion();
+    log(`[WA] Using WA Web version: ${version.join(".")}`);
+
+    const { state, saveCreds } = await useMultiFileAuthState(authPath);
+
+    sock = makeWASocket({
+      version,
+      auth: {
+        creds: state.creds,
+        keys: makeCacheableSignalKeyStore(state.keys, logger),
+      },
+      browser: Browsers.ubuntu("Chrome"),
+      logger,
+      markOnlineOnConnect: cfg.connection?.mark_online_on_connect ?? false,
+      generateHighQualityLinkPreview: true,
+      syncFullHistory: cfg.connection?.sync_full_history ?? true,
+    });
+
+    // Bind store events
+    store.bind(sock);
+
+    // Credential persistence
+    sock.ev.on("creds.update", saveCreds);
+
+    // Connection state handling
+    sock.ev.on("connection.update", async (update) => {
+      const { connection, lastDisconnect, qr } = update;
+
+      if (qr) {
+        log("\n[WA] Scan this QR code with WhatsApp (Linked Devices):\n");
+        qrcode.generate(qr, { small: true }, (code) => {
+          process.stderr.write(code + "\n");
+        });
+      }
+
+      if (connection === "open") {
+        connectionState = "open";
+        reconnectAttempts = 0;
+        const user = sock.user;
+        log(
+          `[WA] Connected as ${user?.name || "?"} (${user?.id || "?"}) — PID ${process.pid}`
+        );
+
+        try {
+          if (cfg.connection?.refresh_app_state_on_open ?? true) {
+            await sock.resyncAppState(ALL_WA_PATCH_NAMES, true);
+            const lastAccountSyncTimestamp = sock.authState?.creds?.lastAccountSyncTimestamp;
+            if (lastAccountSyncTimestamp) {
+              await sock.cleanDirtyBits("account_sync", lastAccountSyncTimestamp);
+            }
+            log("[WA] App state refreshed on open.");
+          }
+
+          const groups = await sock.groupFetchAllParticipating();
+          for (const meta of Object.values(groups || {})) {
+            if (meta?.id) {
+              store.setGroupMeta(meta.id, meta);
+            }
+          }
+          log(`[WA] Preloaded ${Object.keys(groups || {}).length} groups into store.`);
+        } catch (err) {
+          logger.warn({ err }, "Failed to preload groups after connect");
+        }
+      }
+
+      if (connection === "close") {
+        connectionState = "disconnected";
+        const statusCode =
+          lastDisconnect?.error?.output?.statusCode;
+        const maxAttempts = cfg.connection?.max_reconnect_attempts ?? 10;
+
+        // 440 = connectionReplaced — another session took over, don't fight it
+        // 401 = loggedOut — need re-pairing
+        const noReconnectCodes = new Set([
+          DisconnectReason.loggedOut,           // 401
+          DisconnectReason.connectionReplaced,  // 440
+        ]);
+        const shouldReconnect = !noReconnectCodes.has(statusCode);
+
+        log(
+          `[WA] Disconnected (code=${statusCode}). ` +
+          (shouldReconnect
+            ? "Will reconnect..."
+            : statusCode === DisconnectReason.loggedOut
+              ? "Logged out — delete auth to re-pair."
+              : "Connection replaced by another session.")
+        );
+
+        if (shouldReconnect && reconnectAttempts < maxAttempts) {
+          reconnectAttempts++;
+          const delay = Math.min(
+            (cfg.connection?.reconnect_interval_ms || 3000) * Math.pow(1.5, reconnectAttempts - 1),
+            30000
+          );
+          log(`[WA] Reconnect attempt ${reconnectAttempts}/${maxAttempts} in ${Math.round(delay)}ms...`);
+          await new Promise((r) => setTimeout(r, delay));
+          await _createSocket(authPath, cfg);
+        } else if (!shouldReconnect) {
+          if (statusCode === DisconnectReason.loggedOut) {
+            log("[WA] Session logged out. Remove auth folder and restart to re-pair.");
+          } else {
+            log("[WA] Connection replaced. Restart the server if needed.");
+          }
+        } else {
+          log("[WA] Max reconnect attempts reached. Restart the server manually.");
+        }
+      }
+    });
+  } finally {
+    reconnecting = false;
+  }
+}
+
+// ── Exports ──────────────────────────────────────────────────────────────────
+
+module.exports = {
+  connect,
+  getSocket,
+  getStore,
+  getConnectionInfo,
+  requestReconnect,
+};

package/src/helpers.js

@@ -0,0 +1,264 @@
+/**
+ * whats-mcp — Helpers & utilities.
+ *
+ * JID formatting, error wrapping, media resolution, common constants.
+ */
+
+"use strict";
+
+const path = require("path");
+const fs   = require("fs");
+
+// ── JID helpers ──────────────────────────────────────────────────────────────
+
+/** Normalise a phone number to a WhatsApp personal JID. */
+function phoneToJid(phone) {
+  const str = String(phone);
+  // If it's already a JID (contains @), return as-is — preserve legacy group JIDs like 1234-5678@g.us
+  if (str.includes("@")) return str;
+  // Strip +, spaces, dashes, parens from plain phone numbers
+  const clean = str.replace(/[+\s\-()]/g, "");
+  return `${clean}@s.whatsapp.net`;
+}
+
+/** Normalise a group JID. */
+function groupJid(jid) {
+  if (jid.includes("@g.us")) return jid;
+  return `${jid}@g.us`;
+}
+
+/** Normalise a newsletter/channel JID. */
+function newsletterJid(jid) {
+  if (jid.includes("@newsletter")) return jid;
+  return `${jid}@newsletter`;
+}
+
+/** Extract the raw number from a JID. */
+function jidToPhone(jid) {
+  return (jid || "").split("@")[0].split(":")[0];
+}
+
+/** Check if JID is a group. */
+function isGroupJid(jid) {
+  return (jid || "").endsWith("@g.us");
+}
+
+/** Check if JID is a newsletter/channel. */
+function isNewsletterJid(jid) {
+  return (jid || "").includes("@newsletter");
+}
+
+/** Status broadcast JID. */
+const STATUS_BROADCAST = "status@broadcast";
+
+// ── Error helpers ────────────────────────────────────────────────────────────
+
+class WhatsAppError extends Error {
+  /**
+   * @param {string} message
+   * @param {string} [code]
+   */
+  constructor(message, code) {
+    super(message);
+    this.name = "WhatsAppError";
+    this.code = code || "WA_ERROR";
+  }
+}
+
+/** Format an MCP error result. */
+function errResult(message) {
+  return {
+    content: [{ type: "text", text: `❌ ${message}` }],
+    isError: true,
+  };
+}
+
+/** Format an MCP success result. */
+function okResult(data) {
+  const text = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+  return { content: [{ type: "text", text }] };
+}
+
+// ── Media helpers ────────────────────────────────────────────────────────────
+
+/**
+ * Resolve a media source — supports:
+ * - file:///absolute/path
+ * - http(s)://url
+ * - base64 data string
+ * - local file path
+ *
+ * Returns an object suitable for Baileys `WAMediaUpload`.
+ */
+function resolveMedia(source) {
+  if (!source) throw new WhatsAppError("Media source is required.");
+
+  // Base64
+  if (source.startsWith("data:")) {
+    const match = source.match(/^data:[^;]+;base64,(.+)$/);
+    if (match) return Buffer.from(match[1], "base64");
+    throw new WhatsAppError("Invalid base64 data URI.");
+  }
+
+  // Raw base64 (no data: prefix, heuristic)
+  if (/^[A-Za-z0-9+/=]{100,}$/.test(source)) {
+    return Buffer.from(source, "base64");
+  }
+
+  // URL
+  if (/^https?:\/\//.test(source)) {
+    return { url: source };
+  }
+
+  // file:// protocol
+  if (source.startsWith("file://")) {
+    const filePath = source.replace("file://", "");
+    return fs.readFileSync(filePath);
+  }
+
+  // Local file path
+  if (fs.existsSync(source)) {
+    return fs.readFileSync(source);
+  }
+
+  throw new WhatsAppError(`Cannot resolve media source: ${source}`);
+}
+
+/**
+ * Parse a message key from tool arguments.
+ * Accepts either a full key object or individual fields.
+ */
+function parseMessageKey(args) {
+  if (args.key) return args.key;
+  const { remote_jid, id, from_me, participant } = args;
+  if (!remote_jid || !id) {
+    throw new WhatsAppError("Message key requires remote_jid and id.");
+  }
+  return {
+    remoteJid: remote_jid,
+    id,
+    fromMe: from_me ?? false,
+    participant: participant || undefined,
+  };
+}
+
+/**
+ * Format a WAMessage for display.
+ */
+function formatMessage(msg) {
+  if (!msg) return null;
+  const key = msg.key || {};
+  const content = msg.message || {};
+
+  // Determine message type and text
+  let type = "unknown";
+  let text = "";
+  if (content.conversation) {
+    type = "text";
+    text = content.conversation;
+  } else if (content.extendedTextMessage) {
+    type = "text";
+    text = content.extendedTextMessage.text || "";
+  } else if (content.imageMessage) {
+    type = "image";
+    text = content.imageMessage.caption || "[image]";
+  } else if (content.videoMessage) {
+    type = "video";
+    text = content.videoMessage.caption || "[video]";
+  } else if (content.audioMessage) {
+    type = content.audioMessage.ptt ? "voice_note" : "audio";
+    text = "[audio]";
+  } else if (content.documentMessage) {
+    type = "document";
+    text = content.documentMessage.fileName || "[document]";
+  } else if (content.stickerMessage) {
+    type = "sticker";
+    text = "[sticker]";
+  } else if (content.locationMessage) {
+    type = "location";
+    const loc = content.locationMessage;
+    text = `[location: ${loc.degreesLatitude}, ${loc.degreesLongitude}]`;
+  } else if (content.contactMessage || content.contactsArrayMessage) {
+    type = "contact";
+    text = "[contact card]";
+  } else if (content.reactionMessage) {
+    type = "reaction";
+    text = content.reactionMessage.text || "";
+  } else if (content.pollCreationMessage || content.pollCreationMessageV3) {
+    type = "poll";
+    const poll = content.pollCreationMessage || content.pollCreationMessageV3;
+    text = poll.name || "[poll]";
+  } else if (content.protocolMessage) {
+    const proto = content.protocolMessage;
+    if (proto.type === 0 || proto.type === "REVOKE") {
+      type = "deleted";
+      text = "[message deleted]";
+    } else if (proto.editedMessage) {
+      type = "edited";
+      text = "[message edited]";
+    } else {
+      type = "protocol";
+      text = "[system message]";
+    }
+  } else {
+    // Try to find any message type
+    const keys = Object.keys(content);
+    if (keys.length > 0) {
+      type = keys[0].replace("Message", "");
+      text = `[${type}]`;
+    }
+  }
+
+  return {
+    id: key.id,
+    from: key.remoteJid,
+    from_me: key.fromMe || false,
+    participant: key.participant || undefined,
+    timestamp: msg.messageTimestamp
+      ? typeof msg.messageTimestamp === "number"
+        ? msg.messageTimestamp
+        : Number(msg.messageTimestamp)
+      : undefined,
+    type,
+    text,
+    push_name: msg.pushName || undefined,
+  };
+}
+
+/**
+ * Format a chat object for display.
+ */
+function formatChat(chat) {
+  return {
+    jid: chat.id,
+    name: chat.name || chat.subject || jidToPhone(chat.id),
+    unread_count: chat.unreadCount || 0,
+    is_group: isGroupJid(chat.id),
+    is_newsletter: isNewsletterJid(chat.id),
+    archived: chat.archived || false,
+    pinned: chat.pinned ? true : false,
+    muted: chat.mute ? true : false,
+    timestamp: chat.conversationTimestamp
+      ? Number(chat.conversationTimestamp)
+      : undefined,
+  };
+}
+
+// ── Exports ──────────────────────────────────────────────────────────────────
+
+module.exports = {
+  phoneToJid,
+  groupJid,
+  newsletterJid,
+  jidToPhone,
+  isGroupJid,
+  isNewsletterJid,
+  STATUS_BROADCAST,
+  WhatsAppError,
+  errResult,
+  okResult,
+  resolveMedia,
+  parseMessageKey,
+  formatMessage,
+  formatChat,
+};