wazap-mcp 0.9.0

package/dist/cli.js

@@ -0,0 +1,372 @@
+import { mkdirSync, rmSync } from "node:fs";
+import { createInterface } from "node:readline/promises";
+import { setTimeout as sleep } from "node:timers/promises";
+import makeWASocket, { DisconnectReason, } from "baileys";
+import qrcode from "qrcode";
+import qrcodeTerminal from "qrcode-terminal";
+import { clearAuth, readLinkedAccount, useAtomicAuthState } from "./auth-state.js";
+import { BANNER } from "./banner.js";
+import { BAILEYS_VERSION, WAZAP_VERSION, paths } from "./config.js";
+import { CONNECT_HINT } from "./connect.js";
+import { checkLine, runChecks } from "./doctor.js";
+import { RELINK_FIX, WazapError, asWazapError } from "./errors.js";
+import { normalizePhone } from "./ids.js";
+import { lockHolder, releaseLock, writeLock } from "./lock.js";
+import { log, logError, say } from "./logger.js";
+import { formatAge } from "./messages.js";
+import { runHttp, runStdio } from "./server.js";
+import { applyWrites } from "./settings.js";
+import { WA_BROWSER, WhatsAppService } from "./whatsapp.js";
+const LOGIN_TIMEOUT_MS = 120_000;
+const LIVE_TIMEOUT_MS = 15_000;
+/** Connection states the probe stops waiting on. */
+const SETTLED_STATUSES = [
+    "connected",
+    "not_linked",
+    "logged_out",
+    "session_corrupt",
+    "auth_failure",
+];
+const LOGOUT_TIMEOUT_MS = 10_000;
+const LOOPBACK_HOSTS = ["127.0.0.1", "::1", "localhost"];
+const SILENT_LOGGER = {
+    level: "silent",
+    child: () => SILENT_LOGGER,
+    trace: () => { },
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+export async function runStatus(config) {
+    const p = paths(config.dataDir);
+    let account = null;
+    let unreadable = false;
+    try {
+        account = readLinkedAccount(p.authDir);
+    }
+    catch {
+        unreadable = true;
+    }
+    const report = {
+        data_dir: config.dataDir,
+        linked: account !== null,
+        credentials_readable: !unreadable,
+        account,
+        wazap_version: WAZAP_VERSION,
+        baileys_version: BAILEYS_VERSION,
+        server_pid: lockHolder(p.lockFile),
+        checks: await runChecks(config),
+    };
+    if (config.live)
+        report.live = await runLiveProbe(config);
+    if (config.json) {
+        process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+        if (config.live)
+            process.exit(0);
+        return report;
+    }
+    say(`data dir: ${report.data_dir}`);
+    if (unreadable) {
+        say("linked: no (credentials unreadable — run `wazap logout` then `wazap login`)");
+    }
+    else if (account) {
+        say("linked: yes");
+        say(`account: ${describeAccount(account)}`);
+    }
+    else {
+        say("linked: no");
+    }
+    say(`wazap: ${report.wazap_version}`);
+    say(`baileys: ${report.baileys_version}`);
+    say(report.server_pid === null ? "server: not running" : `server: running (pid ${report.server_pid})`);
+    say("");
+    say("checks:");
+    for (const check of report.checks)
+        say(checkLine(check));
+    if (report.live) {
+        say("");
+        for (const line of liveLines(report.live))
+            say(line);
+        process.exit(0);
+    }
+    return report;
+}
+function liveLines(live) {
+    if (!live.reachable)
+        return [`live: no connection (${live.reason ?? "unknown"})`];
+    return [
+        "live: phone reachable",
+        `live: ${live.chats === null ? "chats not synced in time" : `${live.chats} chats synced`}`,
+        `live: last message ${live.last_message_age ?? "unknown"}`,
+    ];
+}
+/** One process owns the session, so a probe only runs when no server holds the lock. */
+async function runLiveProbe(config) {
+    const p = paths(config.dataDir);
+    const running = lockHolder(p.lockFile);
+    if (running !== null) {
+        throw new WazapError("WHATSAPP_ERROR", `A server (pid ${running}) already owns this session.`, "Ask it through your MCP client instead: call get_status");
+    }
+    // The probe owns the session for as long as it runs, exactly like the server.
+    writeLock(p.lockFile);
+    const wa = new WhatsAppService(config);
+    const deadline = Date.now() + LIVE_TIMEOUT_MS;
+    try {
+        await wa.start();
+        let info = wa.getStatus();
+        while (!SETTLED_STATUSES.includes(info.status) && Date.now() < deadline) {
+            await sleep(250);
+            info = wa.getStatus();
+        }
+        if (info.status !== "connected") {
+            return { reachable: false, chats: null, last_message_age: null, reason: info.last_error ?? info.status };
+        }
+        // listChats waits on its own sync gate, which would outlast the deadline.
+        const chats = await Promise.race([
+            wa.listChats("all", 100_000).then((synced) => synced.data),
+            sleep(Math.max(0, deadline - Date.now()), null, { ref: false }),
+        ]).catch(() => null);
+        const newest = (chats ?? [])
+            .map((chat) => (chat.last_message === null ? 0 : Date.parse(chat.last_message.timestamp)))
+            .reduce((a, b) => Math.max(a, b), 0);
+        return {
+            reachable: true,
+            chats: chats === null ? null : chats.length,
+            last_message_age: newest === 0 ? null : formatAge(newest),
+            reason: null,
+        };
+    }
+    finally {
+        await wa.stop();
+        releaseLock(p.lockFile);
+    }
+}
+/** Bare `wazap` at a terminal: where you stand, and the one command to run next. */
+export async function runGreet(config) {
+    say(BANNER);
+    say("");
+    const report = await runStatus(config);
+    say("");
+    if (report.server_pid !== null) {
+        say(`A server is already running (pid ${report.server_pid}).`);
+        return;
+    }
+    if (!report.credentials_readable) {
+        say("Next: wazap logout   (then wazap login)");
+        return;
+    }
+    say(report.linked
+        ? 'Next: wazap connect claude-code   (then ask your agent: "what did I miss on WhatsApp today?")'
+        : "Next: wazap login");
+}
+export async function runServe(config) {
+    const p = paths(config.dataDir);
+    const running = lockHolder(p.lockFile);
+    if (running !== null) {
+        say(`wazap is already running (pid ${running}) using ${config.dataDir}. Stop it first or use --data-dir.`);
+        process.exit(2);
+    }
+    // Loopback with no token only gets runHttp's warning; off-loopback is refused.
+    if (config.transport === "http" && !config.readToken && !LOOPBACK_HOSTS.includes(config.httpHost)) {
+        say(`Refusing to serve ${config.httpHost} without a token. Set WAZAP_READ_TOKEN, or bind 127.0.0.1.`);
+        process.exit(1);
+    }
+    mkdirSync(config.dataDir, { recursive: true, mode: 0o700 });
+    writeLock(p.lockFile);
+    process.on("exit", () => releaseLock(p.lockFile));
+    const wa = new WhatsAppService(config);
+    const shutdown = (signal) => {
+        log(`received ${signal}, shutting down`);
+        // A wedged socket must not cost the user a kill -9; the lock goes on "exit".
+        setTimeout(() => process.exit(0), 3_000).unref();
+        void wa.stop().finally(() => process.exit(0));
+    };
+    process.on("SIGINT", () => shutdown("SIGINT"));
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+    // Connecting in the background: MCP startup never waits on WhatsApp, and the
+    // tools answer NOT_LINKED until a session exists.
+    wa.start().catch((err) => logError("whatsapp start", err));
+    if (config.transport === "http")
+        await runHttp(wa, config);
+    else
+        await runStdio(wa, config);
+}
+export async function runLogin(config) {
+    const p = paths(config.dataDir);
+    const linked = readLinkedAccount(p.authDir);
+    if (linked) {
+        say(`Already linked as ${describeAccount(linked)}. Run \`wazap logout\` to relink.`);
+        return;
+    }
+    const phone = config.loginQr ? null : normalizePhone(config.loginPhone ?? (await askPhone()));
+    let requested = false;
+    const onQr = async (qr, sock) => {
+        if (phone === null) {
+            qrcodeTerminal.generate(qr, { small: true }, (art) => say(art));
+            await qrcode.toFile(p.qrFile, qr);
+            say(`WhatsApp → Settings → Linked devices → Link a device, then scan the code above (also saved to ${p.qrFile}).`);
+            return;
+        }
+        if (requested)
+            return;
+        requested = true;
+        const code = await sock.requestPairingCode(phone);
+        say("");
+        say("WhatsApp → Settings → Linked devices → Link a device → Link with phone number instead");
+        say("");
+        say(`    ${code.slice(0, 4)}-${code.slice(4)}`);
+        say("");
+    };
+    const sock = await linkSession(p.authDir, { deadline: Date.now() + LOGIN_TIMEOUT_MS, onQr });
+    const account = await settledAccount(sock, p.authDir);
+    say(`Linked ✅ as ${describeAccount(account)}`);
+    await sock.end(undefined);
+    await offerWrites(config);
+    say(CONNECT_HINT);
+    process.exit(0);
+}
+export async function runLogout(config) {
+    const p = paths(config.dataDir);
+    const running = lockHolder(p.lockFile);
+    if (running !== null) {
+        say(`wazap is running (pid ${running}). Stop it first, then run \`wazap logout\`.`);
+        process.exit(1);
+    }
+    let linked = null;
+    let unreadable = false;
+    try {
+        linked = readLinkedAccount(p.authDir);
+    }
+    catch {
+        // Unreadable creds are exactly what logout exists to clear, so keep going.
+        unreadable = true;
+    }
+    if (!linked && !unreadable) {
+        say("Not linked.");
+        return;
+    }
+    if (linked) {
+        const deadline = Date.now() + LOGOUT_TIMEOUT_MS;
+        try {
+            const sock = await linkSession(p.authDir, { deadline });
+            await withDeadline(sock.logout(), deadline, "WhatsApp did not confirm the unlink in time.");
+        }
+        catch (err) {
+            logError("unlink from WhatsApp", err);
+            say("Could not tell WhatsApp to unlink; remove this device from your phone if it is still listed.");
+        }
+    }
+    clearAuth(p.authDir);
+    rmSync(p.storeFile, { force: true });
+    say("Logged out. Local credentials deleted.");
+    process.exit(0);
+}
+function describeAccount(account) {
+    return account.name ? `${account.name} (${account.number})` : account.number;
+}
+/**
+ * Writes stay off unless the user says otherwise, so a fresh link cannot message
+ * anyone. A non-interactive login leaves the setting alone rather than guessing.
+ */
+export async function offerWrites(config) {
+    if (config.writesAnswer !== null) {
+        applyWrites(config, config.writesAnswer);
+        return;
+    }
+    if (config.assumeYes || !process.stdin.isTTY)
+        return;
+    const answer = await ask("Allow the agent to send messages, react and manage chats? [y/N] ");
+    applyWrites(config, /^y(es)?$/i.test(answer.trim()));
+}
+async function ask(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        return await rl.question(question);
+    }
+    finally {
+        rl.close();
+    }
+}
+function askPhone() {
+    return ask("Phone number in international format (e.g. +40722123456): ");
+}
+/**
+ * A socket run until it is open, retrying across the restart WhatsApp demands
+ * right after a successful pairing. The returned socket is the caller's to end.
+ */
+async function linkSession(authDir, opts) {
+    let current = null;
+    let expired = false;
+    const timer = setTimeout(() => {
+        expired = true;
+        void current?.end(undefined);
+    }, Math.max(0, opts.deadline - Date.now()));
+    try {
+        for (;;) {
+            // Also checked here: a restart landing just before the deadline would
+            // otherwise open a socket the timer can no longer reach.
+            if (expired)
+                throw timedOut();
+            const { state, saveCreds } = await useAtomicAuthState(authDir);
+            const sock = makeWASocket({
+                auth: state,
+                browser: WA_BROWSER,
+                markOnlineOnConnect: false,
+                logger: SILENT_LOGGER,
+            });
+            current = sock;
+            sock.ev.on("creds.update", () => void saveCreds());
+            const attempt = await new Promise((resolve) => {
+                sock.ev.on("connection.update", (update) => {
+                    if (update.qr && opts.onQr) {
+                        void opts.onQr(update.qr, sock).catch((error) => resolve({ kind: "failed", error }));
+                    }
+                    if (update.connection === "open")
+                        resolve({ kind: "open" });
+                    if (update.connection === "close") {
+                        const statusCode = update.lastDisconnect?.error
+                            ?.output?.statusCode;
+                        resolve(statusCode === DisconnectReason.restartRequired ? { kind: "restart" } : { kind: "closed", statusCode });
+                    }
+                });
+            });
+            if (attempt.kind === "open")
+                return sock;
+            await sock.end(undefined);
+            current = null;
+            if (attempt.kind === "restart")
+                continue;
+            if (expired)
+                throw timedOut();
+            if (attempt.kind === "failed")
+                throw asWazapError(attempt.error);
+            if (attempt.statusCode === DisconnectReason.loggedOut) {
+                throw new WazapError("SESSION_EXPIRED", "WhatsApp rejected the link. The code may have expired or been entered wrong.", RELINK_FIX);
+            }
+            throw new WazapError("WHATSAPP_ERROR", `WhatsApp closed the connection (code ${attempt.statusCode ?? "unknown"}).`);
+        }
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function timedOut() {
+    return new WazapError("TIMEOUT", "WhatsApp did not answer in time.", "Check your connection and try again");
+}
+function withDeadline(work, deadline, message) {
+    let timer;
+    const guard = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new WazapError("TIMEOUT", message)), Math.max(0, deadline - Date.now()));
+    });
+    return Promise.race([work, guard]).finally(() => clearTimeout(timer));
+}
+/** The freshly linked account. `creds.update` can land a beat after the connection opens. */
+async function settledAccount(sock, authDir) {
+    const number = (sock.user?.id ?? "").split(":")[0].split("@")[0];
+    const fromSocket = { id: `${number}@s.whatsapp.net`, name: sock.user?.name ?? "", number };
+    if (fromSocket.name)
+        return fromSocket;
+    await sleep(750);
+    return readLinkedAccount(authDir) ?? fromSocket;
+}

package/dist/config.js

@@ -0,0 +1,138 @@
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { parseArgs } from "node:util";
+import dotenv from "dotenv";
+import { WazapError } from "./errors.js";
+const require = createRequire(import.meta.url);
+export const WAZAP_VERSION = require("../package.json").version;
+export const BAILEYS_VERSION = require("baileys/package.json").version;
+export function paths(dataDir) {
+    return {
+        dataDir,
+        authDir: join(dataDir, "auth"),
+        mediaDir: join(dataDir, "media"),
+        historyDir: join(dataDir, "history"),
+        storeFile: join(dataDir, "store.json"),
+        lockFile: join(dataDir, "server.lock"),
+        envFile: join(dataDir, ".env"),
+        qrFile: join(dataDir, "qr.png"),
+    };
+}
+/** How many positionals each command takes after its own name. */
+const COMMAND_ARGS = {
+    serve: [0],
+    login: [0],
+    status: [0],
+    logout: [0],
+    connect: [1],
+    config: [0, 2],
+};
+const COMMANDS = Object.keys(COMMAND_ARGS);
+export function defaultDataDir() {
+    return resolve(join(homedir(), ".wazap"));
+}
+function asBool(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+}
+function asInt(value, fallback) {
+    const n = Number.parseInt((value ?? "").trim(), 10);
+    return Number.isFinite(n) ? n : fallback;
+}
+/**
+ * A human at a terminal running bare `wazap` wants to see where they stand, not
+ * a silent MCP server on stdin. Everything else serves, including `wazap serve`.
+ */
+export function pickDefaultAction(config, stdinTTY, stderrTTY) {
+    const human = config.command === "serve" && !config.explicitCommand && config.transport === "stdio" && stdinTTY && stderrTTY;
+    return human ? "greet" : "serve";
+}
+export function parseCli(argv = process.argv.slice(2)) {
+    let parsed;
+    try {
+        parsed = parseArgs({
+            args: argv,
+            allowPositionals: true,
+            options: {
+                "data-dir": { type: "string" },
+                "read-only": { type: "boolean" },
+                http: { type: "boolean" },
+                host: { type: "string" },
+                port: { type: "string" },
+                phone: { type: "string" },
+                qr: { type: "boolean" },
+                "dry-run": { type: "boolean" },
+                live: { type: "boolean" },
+                json: { type: "boolean" },
+                writes: { type: "boolean" },
+                "no-writes": { type: "boolean" },
+                yes: { type: "boolean", short: "y" },
+                help: { type: "boolean", short: "h" },
+                version: { type: "boolean", short: "v" },
+            },
+        });
+    }
+    catch (err) {
+        throw new WazapError("INVALID_ID", err instanceof Error ? err.message : String(err), "Run `wazap --help`");
+    }
+    const { values, positionals } = parsed;
+    if (values.help)
+        return { kind: "help" };
+    if (values.version)
+        return { kind: "version" };
+    const [first, ...args] = positionals;
+    if (first !== undefined && !COMMANDS.includes(first)) {
+        throw new WazapError("INVALID_ID", `Unknown command "${first}".`, "Run `wazap --help`");
+    }
+    const command = first ?? "serve";
+    if (!COMMAND_ARGS[command].includes(args.length)) {
+        throw new WazapError("INVALID_ID", `Wrong arguments for \`wazap ${command}\`.`, "Run `wazap --help`");
+    }
+    const dataDir = resolve(values["data-dir"] ?? process.env.WAZAP_DATA_DIR ?? defaultDataDir());
+    // Snapshot before dotenv, which fills process.env from the data dir's .env
+    // without overriding what the real environment already set.
+    const shell = new Set(Object.keys(process.env).filter((key) => key.startsWith("WAZAP_")));
+    dotenv.config({ path: paths(dataDir).envFile, quiet: true });
+    const sourceOf = (key, flagged) => {
+        if (flagged)
+            return "flag";
+        if (shell.has(key))
+            return "env";
+        return process.env[key] === undefined ? "default" : ".env";
+    };
+    const httpFromEnv = process.env.WAZAP_TRANSPORT?.trim().toLowerCase() === "http";
+    return {
+        kind: "run",
+        config: {
+            dataDir,
+            readOnly: values["read-only"] === true || asBool(process.env.WAZAP_READ_ONLY, false),
+            syncFullHistory: asBool(process.env.WAZAP_SYNC_FULL_HISTORY, false),
+            persistHistory: asBool(process.env.WAZAP_PERSIST_HISTORY, true),
+            transport: values.http === true || httpFromEnv ? "http" : "stdio",
+            httpHost: values.host ?? (process.env.WAZAP_HOST?.trim() || "127.0.0.1"),
+            httpPort: values.port ? asInt(values.port, 8766) : asInt(process.env.WAZAP_PORT, 8766),
+            readToken: (process.env.WAZAP_READ_TOKEN ?? "").trim() || null,
+            writeToken: (process.env.WAZAP_WRITE_TOKEN ?? "").trim() || null,
+            rateLimitPerMinute: asInt(process.env.WAZAP_RATE_LIMIT, 20),
+            sources: {
+                // Resolved before dotenv runs, so the data dir's own .env cannot name it.
+                dataDir: values["data-dir"] !== undefined ? "flag" : shell.has("WAZAP_DATA_DIR") ? "env" : "default",
+                readOnly: sourceOf("WAZAP_READ_ONLY", values["read-only"] === true),
+                transport: sourceOf("WAZAP_TRANSPORT", values.http === true),
+                rateLimit: sourceOf("WAZAP_RATE_LIMIT", false),
+            },
+            command,
+            explicitCommand: first !== undefined,
+            args,
+            dryRun: values["dry-run"] === true,
+            live: values.live === true,
+            json: values.json === true,
+            loginPhone: values.phone,
+            loginQr: values.qr === true,
+            writesAnswer: values.writes === true ? true : values["no-writes"] === true ? false : null,
+            assumeYes: values.yes === true,
+        },
+    };
+}