whats-mcp 0.1.0

package/src/tools/contacts.js

@@ -0,0 +1,259 @@
+/**
+ * whats-mcp — Contact tools (5 tools).
+ *
+ * check_phone_number, get_contact_info, get_profile_picture,
+ * manage_block, get_business_profile
+ */
+
+"use strict";
+
+const { phoneToJid, jidToPhone, isGroupJid, okResult, errResult } = require("../helpers");
+
+module.exports = [
+  // 1. check_phone_number
+  {
+    definition: {
+      name: "check_phone_number",
+      description:
+        "Check if one or more phone numbers are registered on WhatsApp." +
+        " Returns the JID for each number that is on WhatsApp.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          phones: {
+            type: "array",
+            items: { type: "string" },
+            description: "Array of phone numbers to check (e.g. ['33612345678', '+1555000123']).",
+          },
+        },
+        required: ["phones"],
+      },
+    },
+    handler: async ({ phones }, { sock }) => {
+      if (!phones || phones.length === 0) {
+        return errResult("At least one phone number is required.");
+      }
+      // Normalize phone numbers to JIDs
+      const ids = phones.map((p) => phoneToJid(p));
+      const result = await sock.onWhatsApp(...ids);
+      const formatted = result.map((r) => ({
+        phone: jidToPhone(r.jid),
+        jid: r.jid,
+        exists: r.exists,
+      }));
+      return okResult({
+        total: phones.length,
+        on_whatsapp: formatted.filter((r) => r.exists).length,
+        results: formatted,
+      });
+    },
+  },
+
+  // 2. get_contact_info
+  {
+    definition: {
+      name: "get_contact_info",
+      description:
+        "Get info about a contact: name, about/status text, and profile picture URL." +
+        " Combines data from the local store and live API calls.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          jid: { type: "string", description: "Contact JID or phone number." },
+        },
+        required: ["jid"],
+      },
+    },
+    handler: async ({ jid }, { sock, store }) => {
+      const contactJid = phoneToJid(jid);
+      const info = { jid: contactJid };
+
+      // From store
+      const storeContact = store.getContact(contactJid);
+      if (storeContact) {
+        info.name = storeContact.name || storeContact.notify || storeContact.verifiedName || null;
+        info.short_name = storeContact.short || null;
+      }
+
+      // Live: status/about
+      try {
+        const status = await sock.fetchStatus(contactJid);
+        info.about = status?.status || null;
+        info.about_set_at = status?.setAt ? Number(status.setAt) : null;
+      } catch {
+        info.about = null;
+      }
+
+      // Live: profile picture
+      try {
+        info.profile_picture_url = await sock.profilePictureUrl(contactJid, "image");
+      } catch {
+        info.profile_picture_url = null;
+      }
+
+      return okResult(info);
+    },
+  },
+
+  // 3. get_profile_picture
+  {
+    definition: {
+      name: "get_profile_picture",
+      description: "Get the profile picture URL for any JID (contact, group, or your own).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          jid:  { type: "string", description: "JID or phone number. Use 'me' for your own picture." },
+          type: {
+            type: "string",
+            enum: ["image", "preview"],
+            description: "Resolution: 'image' for full size, 'preview' for thumbnail. Default 'image'.",
+          },
+        },
+        required: ["jid"],
+      },
+    },
+    handler: async ({ jid, type }, { sock }) => {
+      let targetJid;
+      if (jid === "me") {
+        const { user } = sock;
+        targetJid = user?.id;
+        if (!targetJid) return errResult("Cannot determine own JID. Are you connected?");
+      } else {
+        targetJid = phoneToJid(jid);
+      }
+      try {
+        const url = await sock.profilePictureUrl(targetJid, type || "image");
+        return okResult({ jid: targetJid, profile_picture_url: url });
+      } catch (err) {
+        if (err.message?.includes("404") || err.message?.includes("not-authorized")) {
+          return okResult({ jid: targetJid, profile_picture_url: null, note: "No profile picture or not authorized." });
+        }
+        throw err;
+      }
+    },
+  },
+
+  // 4. manage_block
+  {
+    definition: {
+      name: "manage_block",
+      description: "Block, unblock a contact, or list blocked contacts.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["block", "unblock", "list"],
+            description: "Action to perform.",
+          },
+          jid: {
+            type: "string",
+            description: "Contact JID or phone number (required for block/unblock).",
+          },
+        },
+        required: ["action"],
+      },
+    },
+    handler: async ({ action, jid }, { sock }) => {
+      if (action === "list") {
+        const blocked = await sock.fetchBlocklist();
+        return okResult({
+          count: blocked.length,
+          blocked: blocked.map((b) => ({ jid: b, phone: jidToPhone(b) })),
+        });
+      }
+      if (!jid) return errResult(`JID is required for ${action} action.`);
+      const contactJid = phoneToJid(jid);
+      if (action === "block") {
+        await sock.updateBlockStatus(contactJid, "block");
+        return okResult({ status: "blocked", jid: contactJid });
+      }
+      if (action === "unblock") {
+        await sock.updateBlockStatus(contactJid, "unblock");
+        return okResult({ status: "unblocked", jid: contactJid });
+      }
+      return errResult(`Unknown action: ${action}`);
+    },
+  },
+
+  // 5. get_business_profile
+  {
+    definition: {
+      name: "get_business_profile",
+      description:
+        "Get the WhatsApp Business profile of a contact." +
+        " Returns business info: description, category, website, email, etc.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          jid: { type: "string", description: "Business contact JID or phone number." },
+        },
+        required: ["jid"],
+      },
+    },
+    handler: async ({ jid }, { sock }) => {
+      const contactJid = phoneToJid(jid);
+      try {
+        const profile = await sock.getBusinessProfile(contactJid);
+        return okResult({
+          jid: contactJid,
+          business_profile: profile || null,
+        });
+      } catch (err) {
+        return okResult({
+          jid: contactJid,
+          business_profile: null,
+          note: "Could not retrieve business profile. Contact may not be a business account.",
+        });
+      }
+    },
+  },
+
+  // 6. list_contacts
+  {
+    definition: {
+      name: "list_contacts",
+      description:
+        "List contacts from the local store with optional filtering by name, tag, or type." +
+        " Returns contact info including custom tags if any are assigned.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          limit: { type: "integer", description: "Max contacts to return (default 100, max 1000)." },
+          offset: { type: "integer", description: "Offset for pagination (default 0)." },
+          name: { type: "string", description: "Filter by name (case-insensitive substring match)." },
+          tag: { type: "string", description: "Filter to contacts with this custom tag." },
+          has_tags: { type: "boolean", description: "If true, only contacts with tags; if false, only without tags." },
+          exclude_groups: { type: "boolean", description: "Exclude group JIDs from results (default true)." },
+        },
+      },
+    },
+    handler: async ({ limit, offset, name, tag, has_tags, exclude_groups }, { store }) => {
+      let contacts = store.listContacts({ name, tag, has_tags });
+
+      // Exclude groups by default
+      if (exclude_groups !== false) {
+        contacts = contacts.filter((c) => !isGroupJid(c.id));
+      }
+
+      const total = contacts.length;
+      const off = offset || 0;
+      const lim = Math.min(limit || 100, 1000);
+      const page = contacts.slice(off, off + lim);
+
+      return okResult({
+        total,
+        offset: off,
+        count: page.length,
+        contacts: page.map((c) => ({
+          jid: c.id,
+          phone: jidToPhone(c.id),
+          name: c.name || c.notify || c.verifiedName || null,
+          short_name: c.short || null,
+          tags: store.getContactTags(c.id),
+        })),
+      });
+    },
+  },
+];

package/src/tools/digest.js

@@ -0,0 +1,249 @@
+/**
+ * whats-mcp — Digest tools (2 tools).
+ *
+ * get_messages_multi, daily_digest
+ */
+
+"use strict";
+
+const { phoneToJid, isGroupJid, okResult, errResult, formatMessage } = require("../helpers");
+
+module.exports = [
+  // 1. get_messages_multi
+  {
+    definition: {
+      name: "get_messages_multi",
+      description:
+        "Get messages from multiple chats in one call." +
+        " Specify JIDs directly or use a named watchlist from config." +
+        " Supports time range and message type filters.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          jids: {
+            type: "array",
+            items: { type: "string" },
+            description: "Array of chat JIDs or phone numbers to fetch messages from.",
+          },
+          watchlist: {
+            type: "string",
+            description: "Name of a watchlist defined in config.json (e.g. 'groups', 'family'). Used if jids is empty.",
+          },
+          limit_per_chat: {
+            type: "integer",
+            description: "Max messages per chat (default 50, max 200).",
+          },
+          since: {
+            type: "integer",
+            description: "Unix timestamp: only include messages at or after this time.",
+          },
+          until: {
+            type: "integer",
+            description: "Unix timestamp: only include messages at or before this time.",
+          },
+          include_types: {
+            type: "array",
+            items: { type: "string" },
+            description: "Only include messages of these types.",
+          },
+          exclude_types: {
+            type: "array",
+            items: { type: "string" },
+            description: "Exclude messages of these types.",
+          },
+        },
+      },
+    },
+    handler: async (
+      { jids, watchlist, limit_per_chat, since, until, include_types, exclude_types },
+      { store, config },
+    ) => {
+      // Resolve JIDs from watchlist or explicit list
+      let resolvedJids;
+      if (jids && jids.length > 0) {
+        resolvedJids = jids.map(phoneToJid);
+      } else if (watchlist) {
+        const wlJids = store.resolveWatchlist(watchlist, config?.watchlists);
+        if (wlJids) {
+          resolvedJids = wlJids.map(phoneToJid);
+        } else {
+          const all = [...new Set([
+            ...Object.keys(store.listWatchlists()),
+            ...Object.keys(config?.watchlists || {}),
+          ])];
+          return errResult(`Watchlist '${watchlist}' not found. Available: ${all.join(", ") || "none"}`);
+        }
+      } else {
+        return errResult("Provide either 'jids' array or a 'watchlist' name.");
+      }
+
+      const lim = Math.min(limit_per_chat || 50, 200);
+      const filterOpts = {
+        since: since || undefined,
+        until: until || undefined,
+        types: include_types || undefined,
+        excludeTypes: exclude_types || undefined,
+      };
+
+      const chats = [];
+      let totalMessages = 0;
+
+      for (const jid of resolvedJids) {
+        const messages = store.getMessages(jid, lim, undefined, filterOpts);
+        const formatted = messages.map(formatMessage).filter(Boolean);
+        const chat = store.getChat(jid);
+        const contact = store.getContact(jid);
+
+        chats.push({
+          jid,
+          name: chat?.name || chat?.subject || contact?.name || contact?.notify || jid,
+          is_group: isGroupJid(jid),
+          count: formatted.length,
+          messages: formatted,
+        });
+        totalMessages += formatted.length;
+      }
+
+      return okResult({
+        total_chats: chats.length,
+        total_messages: totalMessages,
+        filters: { since, until, include_types, exclude_types, limit_per_chat: lim },
+        chats,
+      });
+    },
+  },
+
+  // 2. daily_digest
+  {
+    definition: {
+      name: "daily_digest",
+      description:
+        "Generate a structured daily digest of messages across specified chats." +
+        " Defaults to the last 24 hours if no time range is given." +
+        " Perfect for evening summaries: shows per-chat message counts, active participants, and messages." +
+        " Chats with zero messages in the period are excluded.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          jids: {
+            type: "array",
+            items: { type: "string" },
+            description: "Array of chat JIDs or phone numbers.",
+          },
+          watchlist: {
+            type: "string",
+            description: "Name of a watchlist from config. Used if jids is empty.",
+          },
+          since: {
+            type: "integer",
+            description: "Unix timestamp for period start. Default: 24 hours ago.",
+          },
+          until: {
+            type: "integer",
+            description: "Unix timestamp for period end. Default: now.",
+          },
+          limit_per_chat: {
+            type: "integer",
+            description: "Max messages per chat (default 100, max 500).",
+          },
+          exclude_types: {
+            type: "array",
+            items: { type: "string" },
+            description: "Exclude these message types from the digest (e.g. reaction, protocol).",
+          },
+        },
+      },
+    },
+    handler: async (
+      { jids, watchlist, since, until, limit_per_chat, exclude_types },
+      { store, config },
+    ) => {
+      // Time range defaults: last 24 hours
+      const now = Math.floor(Date.now() / 1000);
+      const effectiveSince = since || (now - 86400);
+      const effectiveUntil = until || now;
+
+      // Resolve JIDs
+      let resolvedJids;
+      if (jids && jids.length > 0) {
+        resolvedJids = jids.map(phoneToJid);
+      } else if (watchlist) {
+        const wlJids = store.resolveWatchlist(watchlist, config?.watchlists);
+        if (wlJids) {
+          resolvedJids = wlJids.map(phoneToJid);
+        } else {
+          const all = [...new Set([
+            ...Object.keys(store.listWatchlists()),
+            ...Object.keys(config?.watchlists || {}),
+          ])];
+          return errResult(`Watchlist '${watchlist}' not found. Available: ${all.join(", ") || "none"}`);
+        }
+      } else {
+        // Default: all chats with messages
+        resolvedJids = Array.from(store.messages.keys());
+      }
+
+      const lim = Math.min(limit_per_chat || 100, 500);
+      const filterOpts = {
+        since: effectiveSince,
+        until: effectiveUntil,
+        excludeTypes: exclude_types || undefined,
+      };
+
+      const chatDigests = [];
+      let totalMessages = 0;
+      let totalFromMe = 0;
+      let totalFromOthers = 0;
+
+      for (const jid of resolvedJids) {
+        const messages = store.getMessages(jid, lim, undefined, filterOpts);
+        const formatted = messages.map(formatMessage).filter(Boolean);
+        if (formatted.length === 0) continue;
+
+        const chat = store.getChat(jid);
+        const contact = store.getContact(jid);
+        const fromMe = formatted.filter((m) => m.from_me).length;
+
+        // Collect unique active participants
+        const participants = new Set();
+        for (const m of formatted) {
+          if (m.sender) participants.add(m.sender);
+        }
+
+        chatDigests.push({
+          jid,
+          name: chat?.name || chat?.subject || contact?.name || contact?.notify || jid,
+          is_group: isGroupJid(jid),
+          message_count: formatted.length,
+          from_me: fromMe,
+          from_others: formatted.length - fromMe,
+          active_participants: participants.size,
+          messages: formatted,
+        });
+
+        totalMessages += formatted.length;
+        totalFromMe += fromMe;
+        totalFromOthers += formatted.length - fromMe;
+      }
+
+      // Sort: most active chats first
+      chatDigests.sort((a, b) => b.message_count - a.message_count);
+
+      return okResult({
+        period: {
+          since: effectiveSince,
+          until: effectiveUntil,
+          since_iso: new Date(effectiveSince * 1000).toISOString(),
+          until_iso: new Date(effectiveUntil * 1000).toISOString(),
+        },
+        summary: {
+          total_chats: chatDigests.length,
+          total_messages: totalMessages,
+          total_from_me: totalFromMe,
+          total_from_others: totalFromOthers,
+        },
+        chats: chatDigests,
+      });
+    },
+  },
+];