wagent 1.0.0

package/dist/channels/baileys/baileys.auth.js

@@ -0,0 +1,96 @@
+// ============================================================
+// WA MCP — Baileys SQLite Auth State
+// Implements Baileys' AuthenticationState using SQLite via
+// Drizzle ORM, persisting Signal protocol keys in auth_keys.
+// ============================================================
+import { proto } from "@whiskeysockets/baileys";
+import { initAuthCreds, BufferJSON } from "@whiskeysockets/baileys";
+import { eq, and } from "drizzle-orm";
+import { db } from "../../db/client.js";
+import { authKeys } from "../../db/schema.js";
+const CREDS_KEY = "creds";
+/**
+ * Creates a Baileys-compatible AuthenticationState backed by SQLite.
+ * Equivalent to useMultiFileAuthState but stores everything in the auth_keys table.
+ */
+export async function useSqliteAuthState(instanceId) {
+    // ---- Helpers ----
+    const readData = async (key) => {
+        const row = db
+            .select({ keyData: authKeys.keyData })
+            .from(authKeys)
+            .where(and(eq(authKeys.instanceId, instanceId), eq(authKeys.keyId, key)))
+            .get();
+        return row?.keyData ?? null;
+    };
+    const writeData = async (key, data) => {
+        db.insert(authKeys)
+            .values({ instanceId, keyId: key, keyData: data })
+            .onConflictDoUpdate({
+            target: [authKeys.instanceId, authKeys.keyId],
+            set: { keyData: data },
+        })
+            .run();
+    };
+    const removeData = async (key) => {
+        db.delete(authKeys)
+            .where(and(eq(authKeys.instanceId, instanceId), eq(authKeys.keyId, key)))
+            .run();
+    };
+    // ---- Load or initialize creds ----
+    let creds;
+    const credsJson = await readData(CREDS_KEY);
+    if (credsJson) {
+        creds = JSON.parse(credsJson, BufferJSON.reviver);
+    }
+    else {
+        creds = initAuthCreds();
+        await writeData(CREDS_KEY, JSON.stringify(creds, BufferJSON.replacer));
+    }
+    // ---- Build keys interface ----
+    const state = {
+        creds,
+        keys: {
+            get: async (type, ids) => {
+                const result = {};
+                for (const id of ids) {
+                    const keyId = `${type}-${id}`;
+                    const raw = await readData(keyId);
+                    if (raw) {
+                        let parsed = JSON.parse(raw, BufferJSON.reviver);
+                        if (type === "app-state-sync-key" && parsed) {
+                            parsed = proto.Message.AppStateSyncKeyData.create(parsed);
+                        }
+                        result[id] = parsed;
+                    }
+                }
+                return result;
+            },
+            set: async (data) => {
+                for (const [type, entries] of Object.entries(data)) {
+                    for (const [id, value] of Object.entries(entries)) {
+                        const keyId = `${type}-${id}`;
+                        if (value) {
+                            await writeData(keyId, JSON.stringify(value, BufferJSON.replacer));
+                        }
+                        else {
+                            await removeData(keyId);
+                        }
+                    }
+                }
+            },
+        },
+    };
+    return {
+        state,
+        saveCreds: async () => {
+            await writeData(CREDS_KEY, JSON.stringify(creds, BufferJSON.replacer));
+        },
+    };
+}
+/**
+ * Clears all auth state for an instance (used after logout).
+ */
+export async function clearAuthState(instanceId) {
+    db.delete(authKeys).where(eq(authKeys.instanceId, instanceId)).run();
+}

package/dist/channels/baileys/baileys.events.js

@@ -0,0 +1,284 @@
+// ============================================================
+// WA MCP — Baileys Event Normalization
+// Maps raw Baileys events to normalized ChannelEvent types.
+// ============================================================
+/**
+ * Extract the message type from a Baileys WAMessage.
+ */
+export function extractMessageType(msg) {
+    const m = msg.message;
+    if (!m)
+        return "text";
+    if (m.conversation || m.extendedTextMessage)
+        return "text";
+    if (m.imageMessage ||
+        m.viewOnceMessage?.message?.imageMessage ||
+        m.viewOnceMessageV2?.message?.imageMessage)
+        return "image";
+    if (m.videoMessage ||
+        m.viewOnceMessage?.message?.videoMessage ||
+        m.viewOnceMessageV2?.message?.videoMessage)
+        return "video";
+    if (m.audioMessage)
+        return "audio";
+    if (m.documentMessage || m.documentWithCaptionMessage)
+        return "document";
+    if (m.locationMessage || m.liveLocationMessage)
+        return "location";
+    if (m.contactMessage || m.contactsArrayMessage)
+        return "contact";
+    if (m.pollCreationMessage || m.pollCreationMessageV2 || m.pollCreationMessageV3)
+        return "poll";
+    if (m.reactionMessage)
+        return "reaction";
+    if (m.stickerMessage)
+        return "sticker";
+    return "text";
+}
+/**
+ * Extract text content from a Baileys WAMessage.
+ */
+export function extractTextContent(msg) {
+    const m = msg.message;
+    if (!m)
+        return null;
+    if (m.conversation)
+        return m.conversation;
+    if (m.extendedTextMessage?.text)
+        return m.extendedTextMessage.text;
+    if (m.imageMessage?.caption)
+        return m.imageMessage.caption;
+    if (m.videoMessage?.caption)
+        return m.videoMessage.caption;
+    if (m.documentMessage?.caption)
+        return m.documentMessage.caption;
+    if (m.documentWithCaptionMessage?.message?.documentMessage?.caption) {
+        return m.documentWithCaptionMessage.message.documentMessage.caption;
+    }
+    return null;
+}
+/**
+ * Extract quoted message ID from a Baileys WAMessage.
+ */
+export function extractQuotedMessageId(msg) {
+    const ctx = msg.message?.extendedTextMessage?.contextInfo ??
+        msg.message?.imageMessage?.contextInfo ??
+        msg.message?.videoMessage?.contextInfo ??
+        msg.message?.audioMessage?.contextInfo ??
+        msg.message?.documentMessage?.contextInfo;
+    return ctx?.stanzaId ?? null;
+}
+/**
+ * Swap LID/PN in message keys: when remoteJid is a LID and remoteJidAlt has the PN, use the PN.
+ * This follows the Evolution API pattern for Baileys v7.
+ */
+export function normalizeLidInMessage(msg) {
+    const key = msg.key;
+    if (key.remoteJid &&
+        typeof key.remoteJid === "string" &&
+        key.remoteJid.endsWith("@lid") &&
+        key.remoteJidAlt) {
+        const lid = key.remoteJid;
+        key.remoteJid = key.remoteJidAlt;
+        key.remoteJidAlt = lid;
+    }
+}
+/**
+ * Get the chat JID for a message (group or individual).
+ */
+export function getChatJid(msg) {
+    return msg.key.remoteJid ?? "";
+}
+/**
+ * Get the sender JID for a message.
+ */
+export function getSenderJid(msg) {
+    // In group chats, participant holds the actual sender
+    if (msg.key.participant)
+        return msg.key.participant;
+    // In individual chats, remoteJid is the sender (if not from me)
+    if (!msg.key.fromMe)
+        return msg.key.remoteJid ?? "";
+    return "me";
+}
+// ---- Normalizers ----
+/**
+ * Normalize a Baileys messages.upsert event to NormalizedMessageEvent[].
+ */
+export function normalizeMessagesUpsert(instanceId, data) {
+    // Only process notify-type messages (not history sync)
+    if (data.type !== "notify")
+        return [];
+    return data.messages.map((msg) => {
+        normalizeLidInMessage(msg);
+        return {
+            instanceId,
+            chatId: getChatJid(msg),
+            message: {
+                id: msg.key.id ?? "",
+                sender: getSenderJid(msg),
+                timestamp: typeof msg.messageTimestamp === "number"
+                    ? msg.messageTimestamp
+                    : Number(msg.messageTimestamp ?? 0),
+                type: extractMessageType(msg),
+                content: extractTextContent(msg),
+                mediaUrl: null,
+                quotedMessageId: extractQuotedMessageId(msg),
+                isFromMe: msg.key.fromMe ?? false,
+            },
+        };
+    });
+}
+/**
+ * Normalize a Baileys messages.update event.
+ */
+export function normalizeMessagesUpdate(instanceId, updates) {
+    return updates
+        .filter((u) => u.update.status !== undefined)
+        .map((u) => {
+        const statusMap = {
+            0: "received",
+            1: "sent",
+            2: "delivered",
+            3: "read",
+            4: "played",
+        };
+        return {
+            instanceId,
+            chatId: u.key.remoteJid ?? "",
+            messageId: u.key.id ?? "",
+            status: statusMap[u.update.status ?? 0] ?? "received",
+        };
+    });
+}
+/**
+ * Normalize a Baileys messages.delete event.
+ */
+export function normalizeMessagesDelete(instanceId, data) {
+    if ("keys" in data) {
+        return data.keys.map((key) => ({
+            instanceId,
+            chatId: key.remoteJid ?? "",
+            messageId: key.id ?? "",
+            deletedBy: key.participant ?? key.remoteJid ?? "",
+        }));
+    }
+    return [];
+}
+/**
+ * Normalize a Baileys messages.reaction event.
+ */
+export function normalizeMessagesReaction(instanceId, reactions) {
+    return reactions.map((r) => ({
+        instanceId,
+        chatId: r.key.remoteJid ?? "",
+        messageId: r.key.id ?? "",
+        emoji: r.reaction?.text ?? "",
+        reactedBy: r.reaction?.key?.participant ?? r.reaction?.key?.remoteJid ?? "",
+    }));
+}
+/**
+ * Normalize a Baileys message edit event.
+ */
+export function normalizeMessageEdit(instanceId, msg, chatId) {
+    const editedContent = msg.message?.protocolMessage?.editedMessage?.conversation ??
+        msg.message?.protocolMessage?.editedMessage?.extendedTextMessage?.text ??
+        "";
+    return {
+        instanceId,
+        chatId,
+        messageId: msg.message?.protocolMessage?.key?.id ?? msg.key.id ?? "",
+        newContent: editedContent,
+        editedAt: typeof msg.messageTimestamp === "number"
+            ? msg.messageTimestamp
+            : Number(msg.messageTimestamp ?? Date.now() / 1000),
+    };
+}
+/**
+ * Normalize a Baileys presence.update event.
+ */
+export function normalizePresenceUpdate(instanceId, data) {
+    const results = [];
+    const chatId = data.id;
+    for (const [participant, presence] of Object.entries(data.presences)) {
+        const statusMap = {
+            composing: "composing",
+            recording: "recording",
+            paused: "paused",
+            available: "available",
+            unavailable: "unavailable",
+        };
+        results.push({
+            instanceId,
+            chatId,
+            participant,
+            status: statusMap[presence.lastKnownPresence] ?? "unavailable",
+        });
+    }
+    return results;
+}
+/**
+ * Normalize a Baileys groups.update event.
+ */
+export function normalizeGroupsUpdate(instanceId, updates) {
+    return updates.map((update) => ({
+        instanceId,
+        groupId: update.id ?? "",
+        changes: { ...update },
+    }));
+}
+/**
+ * Normalize a Baileys group-participants.update event.
+ */
+export function normalizeGroupParticipantsUpdate(instanceId, data) {
+    const actionMap = {
+        add: "add",
+        remove: "remove",
+        promote: "promote",
+        demote: "demote",
+    };
+    return {
+        instanceId,
+        groupId: data.id,
+        action: actionMap[data.action] ?? "add",
+        participants: data.participants.map((p) => (typeof p === "string" ? p : p.id)),
+    };
+}
+/**
+ * Normalize a Baileys contacts.update event.
+ */
+export function normalizeContactsUpdate(instanceId, contacts) {
+    return contacts.map((contact) => ({
+        instanceId,
+        contactId: contact.id ?? "",
+        changes: { ...contact },
+    }));
+}
+/**
+ * Normalize a Baileys connection.update event.
+ */
+export function normalizeConnectionUpdate(instanceId, data) {
+    if (data.connection === undefined && data.qr === undefined)
+        return null;
+    const statusMap = {
+        open: "open",
+        close: "close",
+        connecting: "connecting",
+    };
+    return {
+        instanceId,
+        status: data.connection ? (statusMap[data.connection] ?? "connecting") : "connecting",
+        qrCode: data.qr,
+    };
+}
+/**
+ * Normalize a Baileys call event.
+ */
+export function normalizeCallEvent(instanceId, calls) {
+    return calls.map((call) => ({
+        instanceId,
+        callerId: call.from ?? "",
+        isVideo: call.isVideo ?? false,
+        callId: call.id ?? "",
+    }));
+}

package/dist/channels/baileys/baileys.version.js

@@ -0,0 +1,86 @@
+// ============================================================
+// WA MCP — Baileys WA Web Version Management
+// Fetches and caches the latest WhatsApp Web version.
+// Falls back to bundled version on failure.
+// ============================================================
+import { fetchLatestBaileysVersion } from "@whiskeysockets/baileys";
+import { eq } from "drizzle-orm";
+import { db } from "../../db/client.js";
+import { waVersionCache } from "../../db/schema.js";
+import { createChildLogger } from "../../utils/logger.js";
+const logger = createChildLogger({ service: "baileys-version" });
+// Cache duration: 24 hours
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+/**
+ * Get the WhatsApp Web version, using cached value when fresh.
+ * Falls back to bundled version on network failure.
+ */
+export async function getWaVersion() {
+    // Check cache first
+    const cached = db.select().from(waVersionCache).where(eq(waVersionCache.id, 1)).get();
+    if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
+        return {
+            version: JSON.parse(cached.versionJson),
+            isLatest: cached.isLatest === 1,
+        };
+    }
+    // Fetch from network
+    try {
+        const { version, isLatest } = await fetchLatestBaileysVersion();
+        // Upsert cache
+        db.insert(waVersionCache)
+            .values({
+            id: 1,
+            versionJson: JSON.stringify(version),
+            fetchedAt: Date.now(),
+            isLatest: isLatest ? 1 : 0,
+        })
+            .onConflictDoUpdate({
+            target: waVersionCache.id,
+            set: {
+                versionJson: JSON.stringify(version),
+                fetchedAt: Date.now(),
+                isLatest: isLatest ? 1 : 0,
+            },
+        })
+            .run();
+        logger.info({ version, isLatest }, "Fetched latest WA Web version");
+        return { version, isLatest };
+    }
+    catch (err) {
+        logger.warn({ err }, "Failed to fetch WA version, using cached/bundled");
+        // Return cached if available, even if stale
+        if (cached) {
+            return {
+                version: JSON.parse(cached.versionJson),
+                isLatest: false,
+            };
+        }
+        // Final fallback: let Baileys use its bundled version
+        const { version, isLatest } = await fetchLatestBaileysVersion();
+        return { version, isLatest };
+    }
+}
+/**
+ * Force refresh the version cache (used by maintenance job).
+ */
+export async function refreshWaVersion() {
+    const { version, isLatest } = await fetchLatestBaileysVersion();
+    db.insert(waVersionCache)
+        .values({
+        id: 1,
+        versionJson: JSON.stringify(version),
+        fetchedAt: Date.now(),
+        isLatest: isLatest ? 1 : 0,
+    })
+        .onConflictDoUpdate({
+        target: waVersionCache.id,
+        set: {
+            versionJson: JSON.stringify(version),
+            fetchedAt: Date.now(),
+            isLatest: isLatest ? 1 : 0,
+        },
+    })
+        .run();
+    return { version, isLatest };
+}

package/dist/channels/channel.interface.js

@@ -0,0 +1,6 @@
+// ============================================================
+// WA MCP — Channel Adapter Interface
+// All channel implementations (Baileys, Cloud API) must
+// implement this interface to provide a unified API surface.
+// ============================================================
+export {};

package/dist/config.js

@@ -0,0 +1,120 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+export function getConfigDir() {
+    if (process.env.WAGENT_HOME)
+        return process.env.WAGENT_HOME;
+    if (process.platform === "win32")
+        return join(process.env.APPDATA ?? homedir(), "wagent");
+    return join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "wagent");
+}
+export function ensureConfigDir() {
+    const dir = getConfigDir();
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+export function getConfigPath() {
+    return join(ensureConfigDir(), "config.json");
+}
+export function defaultPolicy() {
+    return {
+        autoReplyEnabled: false,
+        readPolicy: "self_only",
+        replyPolicy: "self_only",
+        sendPolicy: "everyone_except_blacklist",
+        allowGroups: false,
+        whitelistedContacts: [],
+        blacklistedContacts: [],
+        whitelistedGroups: [],
+        mentionBypass: "@wagent",
+    };
+}
+export function defaultAgentState() {
+    return {
+        mode: "bootstrap",
+        bootstrapStarted: false,
+        bootstrapNotes: [],
+        policy: defaultPolicy(),
+    };
+}
+export function defaultConfig() {
+    return {
+        provider: "gemini",
+        apiKey: "",
+        model: "gemini-3.1-flash-lite",
+        fallbackModels: ["gemma-4-31b", "gemma-4-27b"],
+        replyDelayMinMs: 2000,
+        replyDelayMaxMs: 8000,
+        agent: defaultAgentState(),
+    };
+}
+export function loadConfig() {
+    const path = getConfigPath();
+    const fromDisk = existsSync(path) ? JSON.parse(readFileSync(path, "utf8")) : {};
+    const merged = {
+        ...defaultConfig(),
+        ...fromDisk,
+        agent: {
+            ...defaultAgentState(),
+            ...(fromDisk.agent ?? {}),
+            policy: { ...defaultPolicy(), ...(fromDisk.agent?.policy ?? {}) },
+            bootstrapNotes: fromDisk.agent?.bootstrapNotes ?? [],
+        },
+    };
+    if (process.env.GROQ_API_KEY) {
+        merged.provider = "groq";
+        merged.apiKey = process.env.GROQ_API_KEY;
+        merged.baseUrl = process.env.GROQ_BASE_URL ?? merged.baseUrl;
+        merged.model = process.env.GROQ_MODEL ?? "openai/gpt-oss-120b";
+        merged.fallbackModels = ["llama-3.3-70b-versatile", "llama-3.1-8b-instant"];
+    }
+    return merged;
+}
+export function saveConfig(config) {
+    writeFileSync(getConfigPath(), `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+}
+function mask(value) {
+    if (value.length <= 8)
+        return "********";
+    return `${value.slice(0, 4)}...${value.slice(-4)}`;
+}
+export async function ensureAiConfig(config) {
+    if (config.apiKey)
+        return config;
+    const rl = readline.createInterface({ input, output });
+    try {
+        console.log("\nChoose AI provider:");
+        console.log("1. Google Gemini + Web Search (recommended)");
+        console.log("2. Groq");
+        console.log("3. Other OpenAI-compatible endpoint");
+        const choice = (await rl.question("Provider [1]: ")).trim() || "1";
+        if (choice === "2") {
+            config.provider = "groq";
+            config.baseUrl = "https://api.groq.com/openai/v1";
+            config.model = "openai/gpt-oss-120b";
+            config.fallbackModels = ["llama-3.3-70b-versatile", "llama-3.1-8b-instant"];
+        }
+        else if (choice === "3") {
+            config.provider = "openai-compatible";
+            config.baseUrl = (await rl.question("Base URL: ")).trim();
+            config.model = (await rl.question("Model: ")).trim();
+            config.fallbackModels = [];
+        }
+        else {
+            config.provider = "gemini";
+            config.model = "gemini-3.1-flash-lite";
+            config.fallbackModels = ["gemma-4-31b", "gemma-4-27b"];
+        }
+        config.apiKey = (await rl.question("API key: ")).trim();
+        if (!config.apiKey)
+            throw new Error("API key is required");
+        saveConfig(config);
+        console.log(`Saved ${config.provider} config (${mask(config.apiKey)}).`);
+        return config;
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/constants.js

@@ -0,0 +1,59 @@
+// ============================================================
+// WA MCP — Constants & Defaults
+// ============================================================
+export const VERSION = "1.0.0";
+export const SERVER_NAME = "wa-mcp";
+// Transport
+export const DEFAULT_TRANSPORT = "http";
+export const DEFAULT_PORT = 3000;
+// Redis
+export const DEFAULT_REDIS_URL = "redis://localhost:6379";
+// Logging
+export const DEFAULT_LOG_LEVEL = "warn";
+// Rate Limits (messages per minute)
+export const DEFAULT_BAILEYS_RATE_LIMIT = 20;
+export const DEFAULT_CLOUD_RATE_LIMIT = 80;
+// Message Retention
+export const DEFAULT_MESSAGE_RETENTION_DAYS = 30;
+// Media
+export const DEFAULT_MEDIA_CACHE_MAX_MB = 500;
+// Cloud API Webhook
+export const DEFAULT_CLOUD_WEBHOOK_PORT = 3001;
+// Auto-reconnect
+export const DEFAULT_AUTO_RECONNECT = true;
+// Version check
+export const DEFAULT_VERSION_CHECK = true;
+// Queue settings
+export const QUEUE_RETRY_ATTEMPTS = 3;
+export const QUEUE_RETRY_DELAY_MS = 2000;
+export const QUEUE_COMPLETED_AGE_S = 3600; // 1 hour
+export const QUEUE_FAILED_AGE_S = 86400; // 24 hours
+export const DEFAULT_JOB_PRIORITY = 5;
+// Reconnect settings
+export const RECONNECT_INITIAL_DELAY_MS = 1000;
+export const RECONNECT_MAX_DELAY_MS = 30000;
+export const RECONNECT_MAX_ATTEMPTS = 10;
+// Dedup
+export const DEDUP_TTL_HOURS = 24;
+// Maintenance schedules
+export const PRUNE_MESSAGES_CRON = "0 3 * * *"; // Daily at 3 AM
+export const PRUNE_DEDUP_CRON = "0 * * * *"; // Hourly
+export const CHECK_VERSION_CRON = "0 6 * * *"; // Daily at 6 AM
+export const HEALTH_CHECK_INTERVAL_MS = 300_000; // 5 minutes
+// Instance ID prefix
+export const INSTANCE_ID_PREFIX = "inst_";
+// Message limits
+export const MAX_TEXT_LENGTH = 65536;
+// Media size limits (bytes)
+export const MEDIA_LIMITS = {
+    image: 16 * 1024 * 1024, // 16 MB
+    video: 16 * 1024 * 1024, // 16 MB
+    audio: 16 * 1024 * 1024, // 16 MB
+    document: 100 * 1024 * 1024, // 100 MB
+    sticker: 500 * 1024, // 500 KB
+};
+// MCP endpoint
+export const MCP_ENDPOINT = "/mcp";
+export const HEALTH_ENDPOINT = "/health";
+// Max base64 media size (bytes)
+export const MAX_BASE64_MEDIA_BYTES = 100 * 1024 * 1024; // 100 MB