wazap-mcp 0.9.0

package/dist/messages.js

@@ -0,0 +1,281 @@
+/**
+ * Message shaping. Pure: no socket, no store, no I/O — everything the store
+ * knows (display names, lid→pn) arrives through MessageViewContext.
+ */
+import { getContentType, proto } from "baileys";
+export function protoNumber(value) {
+    if (value === null || value === undefined)
+        return undefined;
+    if (typeof value === "number")
+        return value;
+    return typeof value.toNumber === "function" ? value.toNumber() : undefined;
+}
+export function messageTimestampMs(raw) {
+    const seconds = protoNumber(raw.messageTimestamp);
+    return seconds === undefined ? Date.now() : seconds * 1000;
+}
+/** Stable across restarts, and stable under lid→pn remapping of the chat. */
+export function messageIdFor(key, chatId) {
+    return `${key.fromMe ? "true" : "false"}_${chatId}_${key.id ?? ""}`;
+}
+function coords(lat, lng) {
+    const a = protoNumber(lat);
+    const b = protoNumber(lng);
+    return a === undefined || b === undefined ? undefined : `${a.toFixed(2)}, ${b.toFixed(2)}`;
+}
+function pollName(m) {
+    const inner = m.pollCreationMessageV4?.message;
+    return (m.pollCreationMessage?.name ??
+        m.pollCreationMessageV2?.name ??
+        m.pollCreationMessageV3?.name ??
+        m.pollCreationMessageV5?.name ??
+        inner?.pollCreationMessage?.name ??
+        undefined);
+}
+const POLL = { type: "poll", tag: "[poll]", detail: pollName };
+function viewOnceInner(m) {
+    return (m.viewOnceMessage?.message ?? m.viewOnceMessageV2?.message ?? m.viewOnceMessageV2Extension?.message ?? undefined);
+}
+const VIEW_ONCE = {
+    type: "view_once",
+    tag: (m) => (viewOnceInner(m)?.videoMessage ? "[view-once video]" : "[view-once photo]"),
+};
+const SYSTEM_TEXT = "[system message]";
+const DELETED_TEXT = "[deleted]";
+function isRevoke(m) {
+    return m.protocolMessage?.type === proto.Message.ProtocolMessage.Type.REVOKE;
+}
+const PROTOCOL = {
+    type: (m) => (isRevoke(m) ? "deleted" : "system"),
+    tag: (m) => (isRevoke(m) ? DELETED_TEXT : SYSTEM_TEXT),
+};
+const SYSTEM = { type: "system", tag: SYSTEM_TEXT };
+const UNKNOWN = { type: "unknown", tag: "[unsupported message]" };
+/**
+ * One table drives both messageType and messageText, so the reported type and
+ * the placeholder can never disagree.
+ */
+const RULES = {
+    conversation: { type: "text", tag: "[text]", text: (m) => m.conversation },
+    extendedTextMessage: { type: "text", tag: "[text]", text: (m) => m.extendedTextMessage?.text },
+    imageMessage: { type: "image", tag: "[image]", caption: (m) => m.imageMessage?.caption },
+    videoMessage: { type: "video", tag: "[video]", caption: (m) => m.videoMessage?.caption },
+    ptvMessage: { type: "video", tag: "[video]", caption: (m) => m.ptvMessage?.caption },
+    audioMessage: {
+        type: (m) => (m.audioMessage?.ptt ? "voice" : "audio"),
+        tag: (m) => (m.audioMessage?.ptt ? "[voice message]" : "[audio]"),
+    },
+    documentMessage: {
+        type: "document",
+        tag: "[document]",
+        caption: (m) => m.documentMessage?.caption,
+        detail: (m) => m.documentMessage?.fileName,
+    },
+    stickerMessage: { type: "sticker", tag: "[sticker]" },
+    locationMessage: {
+        type: "location",
+        tag: "[location]",
+        detail: (m) => m.locationMessage?.name ?? coords(m.locationMessage?.degreesLatitude, m.locationMessage?.degreesLongitude),
+    },
+    liveLocationMessage: {
+        type: "location",
+        tag: "[location]",
+        detail: (m) => m.liveLocationMessage?.caption ??
+            coords(m.liveLocationMessage?.degreesLatitude, m.liveLocationMessage?.degreesLongitude),
+    },
+    contactMessage: { type: "contact", tag: "[contact]", detail: (m) => m.contactMessage?.displayName },
+    contactsArrayMessage: { type: "contact", tag: "[contact]", detail: (m) => m.contactsArrayMessage?.displayName },
+    pollCreationMessage: POLL,
+    pollCreationMessageV2: POLL,
+    pollCreationMessageV3: POLL,
+    pollCreationMessageV4: POLL,
+    pollCreationMessageV5: POLL,
+    reactionMessage: { type: "reaction", tag: "[reaction]", detail: (m) => m.reactionMessage?.text },
+    viewOnceMessage: VIEW_ONCE,
+    viewOnceMessageV2: VIEW_ONCE,
+    viewOnceMessageV2Extension: VIEW_ONCE,
+    protocolMessage: PROTOCOL,
+    senderKeyDistributionMessage: SYSTEM,
+    messageContextInfo: SYSTEM,
+};
+const MEDIA_KEYS = [
+    "imageMessage",
+    "videoMessage",
+    "ptvMessage",
+    "audioMessage",
+    "documentMessage",
+    "stickerMessage",
+];
+/** Envelopes that only wrap another message; the inner one is the real content. */
+function unwrapEnvelopes(content) {
+    let current = content ?? undefined;
+    for (let depth = 0; depth < 5 && current; depth++) {
+        const inner = current.deviceSentMessage?.message ??
+            current.ephemeralMessage?.message ??
+            current.documentWithCaptionMessage?.message;
+        if (!inner)
+            break;
+        current = inner;
+    }
+    return current;
+}
+function ruleFor(content) {
+    if (!content)
+        return { rule: UNKNOWN, content: {} };
+    const key = getContentType(content);
+    const rule = key ? RULES[key] : undefined;
+    if (rule)
+        return { rule, content };
+    if (content.messageContextInfo || content.senderKeyDistributionMessage)
+        return { rule: SYSTEM, content };
+    return { rule: UNKNOWN, content };
+}
+function stubKind(raw) {
+    const stub = raw.messageStubType;
+    if (stub === null || stub === undefined)
+        return undefined;
+    if (stub === proto.WebMessageInfo.StubType.REVOKE)
+        return "deleted";
+    return stub === proto.WebMessageInfo.StubType.UNKNOWN ? undefined : "system";
+}
+function resolve(value, content) {
+    return typeof value === "function" ? value(content) : value;
+}
+export function messageType(raw) {
+    const stub = stubKind(raw);
+    if (stub === "deleted")
+        return "deleted";
+    const content = unwrapEnvelopes(raw.message);
+    const { rule, content: node } = ruleFor(content);
+    if (rule === UNKNOWN && stub)
+        return stub;
+    return resolve(rule.type, node);
+}
+/** Never empty: media and system messages get a placeholder like "[sticker]". */
+export function messageText(raw) {
+    const content = unwrapEnvelopes(raw.message);
+    const { rule, content: node } = ruleFor(content);
+    if (rule === UNKNOWN) {
+        const stub = stubKind(raw);
+        if (stub === "deleted")
+            return DELETED_TEXT;
+        if (stub === "system")
+            return SYSTEM_TEXT;
+    }
+    const text = rule.text?.(node)?.trim();
+    if (text)
+        return text;
+    const tag = resolve(rule.tag, node);
+    const caption = rule.caption?.(node)?.trim();
+    if (caption)
+        return `${tag} ${caption}`;
+    const detail = rule.detail?.(node)?.trim();
+    return detail ? `${tag} ${detail}` : tag;
+}
+export function mediaInfo(raw) {
+    const outer = unwrapEnvelopes(raw.message);
+    const content = outer ? (viewOnceInner(outer) ?? outer) : undefined;
+    if (!content)
+        return undefined;
+    for (const key of MEDIA_KEYS) {
+        const node = content[key];
+        if (!node)
+            continue;
+        return {
+            mime: node.mimetype ?? "application/octet-stream",
+            size: protoNumber(node.fileLength),
+            filename: node.fileName ?? undefined,
+        };
+    }
+    return undefined;
+}
+function contextInfo(raw) {
+    const content = unwrapEnvelopes(raw.message);
+    if (!content)
+        return undefined;
+    const key = getContentType(content);
+    if (!key)
+        return undefined;
+    const node = content[key];
+    return node?.contextInfo ?? undefined;
+}
+/** "just now", "5m ago", "2h ago", "3d ago" — largest whole unit. */
+export function formatAge(fromMs, nowMs = Date.now()) {
+    const elapsed = Math.max(0, nowMs - fromMs);
+    const days = Math.floor(elapsed / 86_400_000);
+    if (days >= 1)
+        return `${days}d ago`;
+    const hours = Math.floor(elapsed / 3_600_000);
+    if (hours >= 1)
+        return `${hours}h ago`;
+    const minutes = Math.floor(elapsed / 60_000);
+    return minutes >= 1 ? `${minutes}m ago` : "just now";
+}
+/** Local-time ISO 8601 with a numeric offset, e.g. 2026-08-22T21:30:00+03:00. */
+export function isoWithOffset(ms) {
+    const at = new Date(ms);
+    const pad = (value, width = 2) => String(Math.abs(value)).padStart(width, "0");
+    const offsetMinutes = -at.getTimezoneOffset();
+    const sign = offsetMinutes < 0 ? "-" : "+";
+    const date = `${pad(at.getFullYear(), 4)}-${pad(at.getMonth() + 1)}-${pad(at.getDate())}`;
+    const time = `${pad(at.getHours())}:${pad(at.getMinutes())}:${pad(at.getSeconds())}`;
+    const offset = `${pad(Math.floor(Math.abs(offsetMinutes) / 60))}:${pad(Math.abs(offsetMinutes) % 60)}`;
+    return `${date}T${time}${sign}${offset}`;
+}
+function senderJid(raw, ctx) {
+    if (raw.key.fromMe)
+        return ctx.ownId;
+    const from = raw.key.participant ?? raw.participant ?? raw.key.remoteJid ?? "";
+    return from ? ctx.canonical(from) : ctx.ownId;
+}
+function phoneOf(jid) {
+    const [user = "", domain] = jid.split("@");
+    return domain === "s.whatsapp.net" && /^\d+$/.test(user) ? user : undefined;
+}
+export function buildMessageView(raw, ctx) {
+    const timestamp = messageTimestampMs(raw);
+    const sender = senderJid(raw, ctx);
+    const media = mediaInfo(raw);
+    const context = contextInfo(raw);
+    const quoted = context?.quotedMessage ? quotedView(context, ctx) : undefined;
+    const view = {
+        message_id: messageIdFor(raw.key, ctx.chatId),
+        chat_id: ctx.chatId,
+        from_me: Boolean(raw.key.fromMe),
+        sender: {
+            id: sender,
+            name: ctx.nameFor(sender) || raw.pushName || phoneOf(sender) || sender,
+            ...(phoneOf(sender) ? { phone: phoneOf(sender) } : {}),
+        },
+        type: messageType(raw),
+        text: messageText(raw),
+        timestamp: isoWithOffset(timestamp),
+        age: formatAge(timestamp, ctx.now),
+        has_media: media !== undefined,
+        forwarded: Boolean(context?.isForwarded) || (protoNumber(context?.forwardingScore) ?? 0) > 0,
+        edited: ctx.edited,
+    };
+    if (media)
+        view.media = media;
+    if (quoted)
+        view.quoted = quoted;
+    if (ctx.reactions.length > 0)
+        view.reactions = ctx.reactions;
+    return view;
+}
+function quotedView(context, ctx) {
+    if (!context.quotedMessage || !context.stanzaId)
+        return undefined;
+    const participant = context.participant ? ctx.canonical(context.participant) : ctx.ownId;
+    const key = {
+        id: context.stanzaId,
+        fromMe: participant === ctx.ownId,
+        remoteJid: ctx.chatId,
+    };
+    const inner = { key, message: context.quotedMessage };
+    return {
+        message_id: messageIdFor(key, ctx.chatId),
+        text: messageText(inner),
+        sender: participant,
+    };
+}

package/dist/ratelimit.js

@@ -0,0 +1,35 @@
+import { WazapError } from "./errors.js";
+/**
+ * Token bucket over the write tools. An agent that loops on send_message would
+ * otherwise burn through WhatsApp's own spam thresholds and get the number
+ * banned, which is not recoverable from this side.
+ */
+export class RateLimiter {
+    perMinute;
+    now;
+    tokens;
+    last;
+    constructor(perMinute, now = Date.now) {
+        this.perMinute = perMinute;
+        this.now = now;
+        this.tokens = perMinute;
+        this.last = now();
+    }
+    get enabled() {
+        return this.perMinute > 0;
+    }
+    /** Consume one token, or throw RATE_LIMITED with the wait in the fix. */
+    take() {
+        if (!this.enabled)
+            return;
+        const now = this.now();
+        this.tokens = Math.min(this.perMinute, this.tokens + ((now - this.last) * this.perMinute) / 60_000);
+        this.last = now;
+        if (this.tokens >= 1) {
+            this.tokens -= 1;
+            return;
+        }
+        const seconds = Math.max(1, Math.ceil(((1 - this.tokens) * 60_000) / this.perMinute / 1000));
+        throw new WazapError("RATE_LIMITED", `Write rate limit reached (${this.perMinute}/minute).`, `Wait ${seconds} seconds`);
+    }
+}

package/dist/server.js

@@ -0,0 +1,133 @@
+import { randomUUID, timingSafeEqual } from "node:crypto";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import express from "express";
+import { WAZAP_VERSION } from "./config.js";
+import { RateLimiter } from "./ratelimit.js";
+import { registerTools } from "./tools.js";
+import { log, logError } from "./logger.js";
+function isAuthorized(header, expected) {
+    const prefix = "Bearer ";
+    if (!header || !header.startsWith(prefix))
+        return false;
+    const got = Buffer.from(header.slice(prefix.length).trim());
+    const want = Buffer.from(expected);
+    return got.length === want.length && timingSafeEqual(got, want);
+}
+function buildMcpServer(wa, config, allowWrite, limiter) {
+    const server = new McpServer({ name: "wazap", version: WAZAP_VERSION });
+    registerTools(server, wa, { allowWrite: allowWrite && !config.readOnly, limiter });
+    return server;
+}
+export async function runStdio(wa, config) {
+    const limiter = new RateLimiter(config.rateLimitPerMinute);
+    const server = buildMcpServer(wa, config, true, limiter);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    log("MCP server ready on stdio.");
+}
+export async function runHttp(wa, config) {
+    // One bucket for the whole process. A per-session bucket would let an HTTP
+    // client bypass the write limit by reconnecting.
+    const limiter = new RateLimiter(config.rateLimitPerMinute);
+    const app = express();
+    app.use(express.json());
+    app.use((req, res, next) => {
+        const start = Date.now();
+        const rpc = (req.body && typeof req.body === "object" ? req.body.method : undefined) ?? "-";
+        const hasAuth = req.headers.authorization ? "auth" : "noauth";
+        res.on("finish", () => {
+            log(`HTTP ${req.method} ${req.url} rpc=${rpc} ${hasAuth} accept="${req.headers.accept ?? ""}" -> ${res.statusCode} (${Date.now() - start}ms)`);
+        });
+        res.on("close", () => {
+            if (!res.writableEnded) {
+                log(`HTTP ${req.method} ${req.url} rpc=${rpc} -> client closed before response (${Date.now() - start}ms)`);
+            }
+        });
+        next();
+    });
+    if (!config.readToken) {
+        log("WARNING: no WAZAP_READ_TOKEN set, the /mcp endpoint is UNAUTHENTICATED. " +
+            "Set WAZAP_READ_TOKEN before exposing this server beyond localhost.");
+    }
+    // Two tokens: the read token (WAZAP_READ_TOKEN) and the write token
+    // (WAZAP_WRITE_TOKEN). A write-token request also unlocks the mutating tools,
+    // so a leaked read token can never message anyone.
+    const requireAuth = (req, res, next) => {
+        const auth = req.headers.authorization;
+        const writeOk = config.writeToken ? isAuthorized(auth, config.writeToken) : false;
+        const readOk = !config.readToken || isAuthorized(auth, config.readToken);
+        if (readOk || writeOk) {
+            req.mcpWrite = writeOk;
+            next();
+            return;
+        }
+        res.status(401).json({
+            jsonrpc: "2.0",
+            error: { code: -32001, message: "Unauthorized: missing or invalid bearer token" },
+            id: null,
+        });
+    };
+    // Session-based Streamable HTTP (the SDK's canonical pattern). It serves the
+    // GET SSE stream and DELETE that full MCP clients open; a stateless server
+    // 404s the GET and makes such clients hang until they time out.
+    const transports = new Map();
+    const handleMcp = async (req, res) => {
+        try {
+            const sessionId = req.headers["mcp-session-id"];
+            let transport = typeof sessionId === "string" ? transports.get(sessionId) : undefined;
+            if (!transport && req.method === "POST" && isInitializeRequest(req.body)) {
+                const newTransport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => randomUUID(),
+                    onsessioninitialized: (sid) => {
+                        transports.set(sid, newTransport);
+                    },
+                });
+                newTransport.onclose = () => {
+                    const sid = newTransport.sessionId;
+                    if (sid)
+                        transports.delete(sid);
+                };
+                // The session's tools are fixed at init by the token it authenticated with.
+                const server = buildMcpServer(wa, config, req.mcpWrite === true, limiter);
+                await server.connect(newTransport);
+                transport = newTransport;
+            }
+            if (!transport) {
+                res.status(400).json({
+                    jsonrpc: "2.0",
+                    error: { code: -32000, message: "Bad Request: no valid session ID (send initialize first)" },
+                    id: null,
+                });
+                return;
+            }
+            await transport.handleRequest(req, res, req.body);
+        }
+        catch (err) {
+            logError("http request", err);
+            if (!res.headersSent) {
+                res.status(500).json({
+                    jsonrpc: "2.0",
+                    error: { code: -32603, message: "Internal server error" },
+                    id: null,
+                });
+            }
+        }
+    };
+    app.post("/mcp", requireAuth, handleMcp);
+    app.get("/mcp", requireAuth, handleMcp);
+    app.delete("/mcp", requireAuth, handleMcp);
+    // Unauthenticated, so it carries liveness only; the account and data dir
+    // stay behind the token in get_status.
+    app.get("/healthz", (_req, res) => {
+        res.json({ ok: true, status: wa.getStatus().status });
+    });
+    await new Promise((resolve) => {
+        app.listen(config.httpPort, config.httpHost, () => {
+            log(`MCP server (Streamable HTTP) on http://${config.httpHost}:${config.httpPort}/mcp`);
+            resolve();
+        });
+    });
+}

package/dist/settings.js

@@ -0,0 +1,74 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { paths } from "./config.js";
+import { WazapError } from "./errors.js";
+import { lockHolder } from "./lock.js";
+import { say } from "./logger.js";
+/** Replace `KEY=` in place, keeping every other line, or append it. */
+export function setEnvSetting(envFile, key, value) {
+    let text = "";
+    try {
+        text = readFileSync(envFile, "utf8");
+    }
+    catch {
+        /* a data dir without an .env yet */
+    }
+    const line = `${key}=${value}`;
+    const lines = text === "" ? [] : text.split("\n");
+    // dotenv trims around `=` and applies last-wins, so every spelling of the key
+    // has to go: leaving a later duplicate behind would silently outrank the edit.
+    const assignment = new RegExp(`^\\s*(export\\s+)?${key}\\s*=`);
+    const hits = lines.flatMap((existing, index) => (assignment.test(existing) ? [index] : []));
+    if (hits.length === 0) {
+        const body = text.trimEnd();
+        text = body === "" ? `${line}\n` : `${body}\n${line}\n`;
+    }
+    else {
+        lines[hits[0]] = line;
+        text = lines.filter((_, index) => index === hits[0] || !hits.includes(index)).join("\n");
+        if (!text.endsWith("\n"))
+            text += "\n";
+    }
+    mkdirSync(dirname(envFile), { recursive: true, mode: 0o700 });
+    writeFileSync(envFile, text, { mode: 0o600 });
+}
+const SETTINGS = [
+    { label: "data dir", source: "dataDir", value: (config) => config.dataDir },
+    { label: "writes", source: "readOnly", value: (config) => (config.readOnly ? "off" : "on") },
+    {
+        label: "transport",
+        source: "transport",
+        value: (config) => (config.transport === "http" ? `http ${config.httpHost}:${config.httpPort}` : "stdio"),
+    },
+    {
+        label: "rate limit",
+        source: "rateLimit",
+        value: (config) => (config.rateLimitPerMinute === 0 ? "off" : `${config.rateLimitPerMinute} writes/minute`),
+    },
+];
+export function runConfig(config) {
+    if (config.args.length === 0) {
+        for (const row of SETTINGS)
+            say(`${row.label}: ${row.value(config)} (${config.sources[row.source]})`);
+        say("");
+        say("Change writes with `wazap config writes on|off`.");
+        return;
+    }
+    const [setting, value] = config.args;
+    if (setting !== "writes" || (value !== "on" && value !== "off")) {
+        throw new WazapError("INVALID_ID", `Cannot set "${setting} ${value}".`, "Run `wazap config writes on|off`");
+    }
+    applyWrites(config, value === "on");
+}
+/** Persist the writes answer, then say what is now true and how to change it. */
+export function applyWrites(config, allowWrites) {
+    const p = paths(config.dataDir);
+    setEnvSetting(p.envFile, "WAZAP_READ_ONLY", allowWrites ? "0" : "1");
+    say(allowWrites
+        ? `writes: on — the agent can send messages, react and manage chats. Turn it off with \`wazap config writes off\`.`
+        : `writes: off — the agent can only read. Turn it on with \`wazap config writes on\`.`);
+    say(`Stored in ${p.envFile}.`);
+    const running = lockHolder(p.lockFile);
+    if (running !== null)
+        say(`A server is running (pid ${running}); restart it for this to apply.`);
+}