cli-whatsapp 0.1.1 → 0.1.3

package/dist/utils/notify.js

@@ -0,0 +1,29 @@
+import { execFile } from 'node:child_process';
+import { platform } from 'node:os';
+/**
+ * Fire a native desktop notification. Best-effort and non-blocking: shells out
+ * to the platform notifier (macOS `osascript`, Linux `notify-send`). Any
+ * failure (tool missing, no display) is silently ignored — notifications must
+ * never break the CLI.
+ */
+export function notify(title, body) {
+    try {
+        const p = platform();
+        if (p === 'darwin') {
+            const esc = (s) => s.replace(/[\\"]/g, '\\$&');
+            const script = `display notification "${esc(clip(body))}" with title "${esc(clip(title))}"`;
+            execFile('osascript', ['-e', script], () => { });
+        }
+        else if (p === 'linux') {
+            execFile('notify-send', ['-a', 'WhatsApp CLI', clip(title), clip(body)], () => { });
+        }
+        // Windows: no reliable dependency-free path; skipped intentionally.
+    }
+    catch {
+        /* notifications are best-effort */
+    }
+}
+function clip(s) {
+    const oneLine = s.replace(/\s+/g, ' ').trim();
+    return oneLine.length > 120 ? oneLine.slice(0, 119) + '…' : oneLine;
+}

package/dist/utils/ui.js

@@ -0,0 +1,29 @@
+import { c } from "./format.js";
+export function ok(msg) {
+    process.stdout.write(`${c.green('✓')} ${msg}\n`);
+}
+export function info(msg) {
+    process.stdout.write(`${c.cyan('›')} ${msg}\n`);
+}
+export function warn(msg) {
+    process.stderr.write(`${c.yellow('!')} ${msg}\n`);
+}
+/** A user-facing, expected error (bad input, no session, etc.). */
+export class AppError extends Error {
+}
+/**
+ * Abort the current command with a user-facing message. Throws an AppError so
+ * callers decide how to handle it: the CLI prints it and exits non-zero; the
+ * interactive shell prints it and keeps the session alive.
+ */
+export function fail(msg) {
+    throw new AppError(msg);
+}
+/** Render an error the way the CLI/shell should display it. */
+export function printError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`${c.red('✗')} ${msg}\n`);
+}
+export function print(msg = '') {
+    process.stdout.write(msg + '\n');
+}

package/dist/whatsapp/client.js

@@ -0,0 +1,157 @@
+import makeWASocket, { useMultiFileAuthState, fetchLatestBaileysVersion, makeCacheableSignalKeyStore, Browsers, DisconnectReason, } from '@whiskeysockets/baileys';
+import { existsSync, readFileSync, rmSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { PATHS, ensureDirs } from "../config/index.js";
+import { logger } from "./logger.js";
+/** Extract the numeric status code from a Baileys disconnect error. */
+function statusCode(err) {
+    return err?.output?.statusCode;
+}
+/**
+ * Serialized chain of pending credential writes. WhatsApp streams `creds.update`
+ * events whose `saveCreds()` writes to disk asynchronously; exiting the process
+ * mid-write corrupts the session. Callers must `await whenWritesSettled()`
+ * before `process.exit()`.
+ */
+let pendingWrites = Promise.resolve();
+export function whenWritesSettled() {
+    return pendingWrites;
+}
+/**
+ * A session counts as linked when creds.json exists, parses, and carries the
+ * account identity (`me.id`) — that's set only after a device is fully linked
+ * and it persists. (The `registered` flag is unreliable: it can remain false
+ * after a successful QR link due to write ordering across the 515 reconnect.)
+ * A missing, corrupt, or half-written creds file has no `me.id` → "not linked".
+ */
+export function hasSession() {
+    const p = join(PATHS.sessions, 'creds.json');
+    if (!existsSync(p))
+        return false;
+    try {
+        const creds = JSON.parse(readFileSync(p, 'utf8'));
+        return !!creds?.me?.id || creds?.registered === true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Delete the local session (used when it's dead / logged out server-side). */
+export function clearSession() {
+    rmSync(PATHS.sessions, { recursive: true, force: true });
+    mkdirSync(PATHS.sessions, { recursive: true });
+}
+/**
+ * Establish a connection with a single QR/open lifecycle. Reconnection on
+ * transient drops is handled by callers via {@link runWithConnection}, which
+ * recreates the connection when appropriate.
+ */
+export async function connect(opts = {}) {
+    ensureDirs();
+    if (opts.requireSession && !hasSession()) {
+        throw new Error('Not logged in. Run `wa login` first.');
+    }
+    const { state, saveCreds } = await useMultiFileAuthState(PATHS.sessions);
+    const { version } = await fetchLatestBaileysVersion();
+    const sock = makeWASocket({
+        version,
+        logger: logger,
+        printQRInTerminal: false,
+        auth: {
+            creds: state.creds,
+            keys: makeCacheableSignalKeyStore(state.keys, logger),
+        },
+        browser: Browsers.macOS('WhatsApp CLI'),
+        syncFullHistory: opts.syncFullHistory ?? false,
+        markOnlineOnConnect: false,
+        generateHighQualityLinkPreview: false,
+    });
+    // Serialize creds writes and track them so the process never exits mid-write.
+    sock.ev.on('creds.update', () => {
+        pendingWrites = pendingWrites.then(() => saveCreds()).catch(() => { });
+    });
+    let resolveReady;
+    let rejectReady;
+    const ready = new Promise((res, rej) => {
+        resolveReady = res;
+        rejectReady = rej;
+    });
+    let pairingRequested = false;
+    sock.ev.on('connection.update', (update) => {
+        const { connection, lastDisconnect, qr } = update;
+        if (qr) {
+            if (opts.pairingPhone) {
+                // Pairing-code mode: request the code once on the first `qr` (which
+                // signals the socket is ready to pair). Ignore all later qr refreshes —
+                // never render a QR, and never re-request (that would change the code).
+                if (!pairingRequested) {
+                    pairingRequested = true;
+                    void sock
+                        .requestPairingCode(opts.pairingPhone)
+                        .then((code) => opts.onPairingCode?.(code))
+                        .catch((e) => rejectReady(new Error(`PAIRING_FAILED:${e.message}`)));
+                }
+            }
+            else if (opts.onQR) {
+                opts.onQR(qr);
+            }
+        }
+        if (connection === 'open') {
+            resolveReady();
+        }
+        else if (connection === 'close') {
+            const code = statusCode(lastDisconnect?.error);
+            const loggedOut = code === DisconnectReason.loggedOut;
+            const err = new Error(loggedOut
+                ? 'LOGGED_OUT'
+                : `CONNECTION_CLOSED:${code ?? 'unknown'}`);
+            rejectReady(err);
+        }
+    });
+    return {
+        sock,
+        saveCreds,
+        ready,
+        close: () => {
+            try {
+                sock.end(undefined);
+            }
+            catch {
+                /* already closed */
+            }
+        },
+    };
+}
+/**
+ * Run a task with an open connection, auto-reconnecting on transient drops.
+ * Rejects on logout or after exhausting retries. Always closes the socket.
+ */
+export async function runWithConnection(task, opts = {}) {
+    const maxRetries = opts.maxRetries ?? 3;
+    let attempt = 0;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const conn = await connect(opts);
+        try {
+            await conn.ready;
+            const result = await task(conn);
+            return result;
+        }
+        catch (err) {
+            const msg = err.message ?? '';
+            if (msg === 'LOGGED_OUT') {
+                conn.close();
+                throw new Error('Session logged out. Run `wa logout` then `wa login` again.');
+            }
+            if (attempt++ >= maxRetries) {
+                conn.close();
+                throw err;
+            }
+            // brief backoff before reconnecting
+            await new Promise((r) => setTimeout(r, 1000 * attempt));
+        }
+        finally {
+            conn.close();
+        }
+    }
+}

package/dist/whatsapp/events.js

@@ -0,0 +1,161 @@
+import { proto } from '@whiskeysockets/baileys';
+import { insertMessage, upsertChat, upsertContact } from "../db/sqlite.js";
+/** Baileys timestamps are seconds (sometimes Long); normalize to ms. */
+export function toMs(ts) {
+    if (ts == null)
+        return 0;
+    const n = typeof ts === 'number' ? ts : ts.toNumber();
+    if (!Number.isFinite(n) || n <= 0)
+        return 0;
+    return n < 1e12 ? n * 1000 : n; // treat >=1e12 as already-ms
+}
+export function isGroupJid(jid) {
+    return !!jid && jid.endsWith('@g.us');
+}
+/** Best-effort plain-text extraction from any WhatsApp message content. */
+export function extractText(message) {
+    if (!message)
+        return '';
+    return (message.conversation ||
+        message.extendedTextMessage?.text ||
+        message.imageMessage?.caption ||
+        message.videoMessage?.caption ||
+        message.documentMessage?.caption ||
+        message.documentWithCaptionMessage?.message?.documentMessage?.caption ||
+        message.buttonsResponseMessage?.selectedDisplayText ||
+        message.listResponseMessage?.title ||
+        message.templateButtonReplyMessage?.selectedDisplayText ||
+        (message.reactionMessage?.text
+            ? `reacted ${message.reactionMessage.text}`
+            : '') ||
+        '');
+}
+/** Classify a message by its dominant content type (for filtering/media). */
+export function messageType(message) {
+    if (!message)
+        return 'unknown';
+    if (message.conversation || message.extendedTextMessage)
+        return 'text';
+    if (message.imageMessage)
+        return 'image';
+    if (message.videoMessage)
+        return 'video';
+    if (message.audioMessage)
+        return 'audio';
+    if (message.documentMessage || message.documentWithCaptionMessage)
+        return 'document';
+    if (message.stickerMessage)
+        return 'sticker';
+    if (message.locationMessage)
+        return 'location';
+    if (message.contactMessage)
+        return 'contact';
+    if (message.reactionMessage)
+        return 'reaction';
+    return 'other';
+}
+/** Persist a single Baileys message into the local cache. */
+export function persistMessage(msg) {
+    const jid = msg.key.remoteJid;
+    if (!jid || jid === 'status@broadcast')
+        return;
+    const text = extractText(msg.message);
+    const type = messageType(msg.message);
+    const ts = toMs(msg.messageTimestamp);
+    const fromMe = !!msg.key.fromMe;
+    const sender = fromMe ? 'me' : msg.pushName || msg.key.participant || jid;
+    // For media, keep the raw content so `wa download` can decrypt it later.
+    const isMedia = ['image', 'video', 'audio', 'document', 'sticker'].includes(type);
+    let raw = null;
+    if (isMedia && msg.message) {
+        try {
+            // Protobuf-encode so binary fields (mediaKey, etc.) survive round-trips.
+            raw = Buffer.from(proto.Message.encode(msg.message).finish()).toString('base64');
+        }
+        catch {
+            raw = null;
+        }
+    }
+    insertMessage({
+        chatJid: jid,
+        messageId: msg.key.id ?? `${ts}`,
+        sender,
+        text: text || null,
+        timestamp: ts,
+        status: undefined,
+        type,
+        fromMe,
+        raw,
+    });
+    // Keep the chat row's "last message" preview fresh.
+    upsertChat({
+        jid,
+        name: isGroupJid(jid) ? undefined : !fromMe ? msg.pushName || undefined : undefined,
+        lastMessage: text || `[${type}]`,
+        lastTimestamp: ts,
+        isGroup: isGroupJid(jid) ? 1 : 0,
+    });
+    // Record the direct contact's push name when we learn it.
+    if (!isGroupJid(jid) && !fromMe && msg.pushName) {
+        upsertContact({ jid, name: msg.pushName });
+    }
+}
+/**
+ * Register all persistence handlers on a live socket. Used by `sync` (batch
+ * history) and `watch` (live stream). Returns nothing; handlers persist to DB.
+ */
+export function registerPersistence(sock, hooks = {}) {
+    // Live + recent messages.
+    sock.ev.on('messages.upsert', ({ messages }) => {
+        for (const msg of messages) {
+            persistMessage(msg);
+            hooks.onMessage?.(msg);
+        }
+    });
+    // Bulk history sync delivered after login / on demand.
+    sock.ev.on('messaging-history.set', ({ chats, contacts, messages }) => {
+        for (const c of chats) {
+            if (!c.id)
+                continue;
+            upsertChat({
+                jid: c.id,
+                name: c.name ?? undefined,
+                unreadCount: c.unreadCount ?? 0,
+                archived: c.archived ? 1 : 0,
+                pinned: c.pinned ? 1 : 0,
+                lastTimestamp: toMs(c.conversationTimestamp),
+                isGroup: isGroupJid(c.id) ? 1 : 0,
+            });
+        }
+        for (const ct of contacts) {
+            if (ct.id)
+                upsertContact({ jid: ct.id, name: ct.name ?? ct.notify ?? undefined });
+        }
+        for (const msg of messages)
+            persistMessage(msg);
+    });
+    // Chat metadata updates.
+    sock.ev.on('chats.upsert', (chats) => {
+        for (const c of chats) {
+            if (!c.id)
+                continue;
+            upsertChat({
+                jid: c.id,
+                name: c.name ?? undefined,
+                unreadCount: c.unreadCount ?? 0,
+                archived: c.archived ? 1 : 0,
+                pinned: c.pinned ? 1 : 0,
+                isGroup: isGroupJid(c.id) ? 1 : 0,
+            });
+        }
+    });
+    // Contact names.
+    const onContacts = (contacts) => {
+        for (const ct of contacts) {
+            if (ct.id)
+                upsertContact({ jid: ct.id, name: ct.name ?? ct.notify ?? undefined });
+        }
+    };
+    sock.ev.on('contacts.upsert', onContacts);
+    sock.ev.on('contacts.update', onContacts);
+}

package/dist/whatsapp/logger.js

@@ -0,0 +1,52 @@
+const DEBUG = !!process.env.WA_DEBUG;
+function make(level) {
+    const emit = (tag) => (...args) => {
+        if (!DEBUG)
+            return;
+        // Baileys calls logger.error(obj, msg); print compactly.
+        process.stderr.write(`[wa:${tag}] ${args.map(fmt).join(' ')}\n`);
+    };
+    return {
+        level,
+        trace: emit('trace'),
+        debug: emit('debug'),
+        info: emit('info'),
+        warn: emit('warn'),
+        error: emit('error'),
+        fatal: emit('fatal'),
+        child: () => make(level),
+    };
+}
+function fmt(v) {
+    if (typeof v === 'string')
+        return v;
+    try {
+        return JSON.stringify(v);
+    }
+    catch {
+        return String(v);
+    }
+}
+export const logger = make(DEBUG ? 'debug' : 'silent');
+/**
+ * Baileys' vendored libsignal logs session churn via `console.log`/`console.error`
+ * directly, bypassing the logger above and cluttering the terminal (e.g.
+ * "Closing session: SessionEntry { … }"). Filter those specific lines out
+ * unless debugging. Call once at startup.
+ */
+// libsignal (node_modules/libsignal/src/session_record.js) logs session churn
+// directly via console.info/warn/error, bypassing the logger above.
+const NOISE = /^(Closing (open |stale )?session|Opening session|Session already (closed|open)|Migrating session|Removing old closed session|V1 session storage migration|Session error|Bad MAC|SessionEntry)/;
+export function installConsoleFilter() {
+    if (DEBUG)
+        return;
+    for (const method of ['log', 'info', 'error', 'warn']) {
+        const original = console[method].bind(console);
+        console[method] = (...args) => {
+            const first = args[0];
+            if (typeof first === 'string' && NOISE.test(first))
+                return;
+            original(...args);
+        };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cli-whatsapp",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "A lightweight, fast, terminal-first WhatsApp client. Read, search, send, media, groups, and live notifications — from your terminal.",
   "type": "module",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "files": [
     "bin/",
-    "src/",
+    "dist/",
     "README.md",
     "COMMANDS.md",
     "LICENSE"
@@ -25,10 +25,12 @@
     "local-first"
   ],
   "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "dev": "node src/cli/index.ts",
     "wa": "node bin/wa.js",
     "typecheck": "tsc --noEmit",
     "test": "node --test tests/",
-    "prepublishOnly": "npm run typecheck"
+    "prepublishOnly": "npm run typecheck && npm run build"
   },
   "engines": {
     "node": ">=22.6.0"