cli-whatsapp 0.1.1 → 0.1.2

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.2",
   "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"

package/src/cli/commands/auth.ts

@@ -1,236 +0,0 @@
-import { rmSync, existsSync } from 'node:fs';
-import { createInterface } from 'node:readline/promises';
-import qrcode from 'qrcode-terminal';
-import { connect, hasSession, clearSession } from '../../whatsapp/client.ts';
-import { registerPersistence } from '../../whatsapp/events.ts';
-import { loadConfig, saveConfig, PATHS } from '../../config/index.ts';
-import { countMessages, listChats } from '../../db/sqlite.ts';
-import { ok, info, warn, fail, print } from '../../utils/ui.ts';
-import { c } from '../../utils/format.ts';
-
-/** Default country code prepended to bare 10-digit numbers. */
-const DEFAULT_CC = '91';
-
-/** Normalize user input to an international number (digits only), or null. */
-function normalizePhone(raw: string): string | null {
-  let d = (raw || '').replace(/[^\d]/g, '');
-  if (d.length === 11 && d.startsWith('0')) d = d.slice(1); // drop trunk 0
-  if (d.length === 10) d = DEFAULT_CC + d; // bare local → add country code
-  return d.length >= 11 ? d : null;
-}
-
-/** Prompt for a phone number (used by the default pairing-code login). */
-async function promptPhone(): Promise<string> {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    const ans = await rl.question(
-      `${c.cyan('?')} Enter your WhatsApp number ${c.dim(`(10-digit; +${DEFAULT_CC} added automatically)`)}: `,
-    );
-    return ans.trim();
-  } finally {
-    rl.close();
-  }
-}
-
-/**
- * wa login            → prompt for number, link with a pairing code (default)
- * wa login --phone N  → pairing code for N (skips the prompt)
- * wa login qr         → link by scanning a QR code
- */
-export async function login(
-  mode?: string,
-  opts: { phone?: string } = {},
-): Promise<void> {
-  const useQR = (mode ?? '').toLowerCase() === 'qr';
-  const hadSession = hasSession();
-
-  // Resolve the number for pairing (prompt if needed). QR mode skips this.
-  const resolvePhone = async (): Promise<string> => {
-    const raw = opts.phone ?? (await promptPhone());
-    const norm = normalizePhone(raw);
-    if (!norm) {
-      fail('Enter a valid WhatsApp number — 10 digits (e.g. 9371432334) or full international (e.g. 919371432334).');
-    }
-    return norm;
-  };
-
-  let pairingPhone: string | undefined;
-  if (!hadSession && !useQR) pairingPhone = await resolvePhone();
-
-  if (hadSession) {
-    info('A session already exists. Verifying…');
-  } else if (pairingPhone) {
-    info(`Requesting a pairing code for +${pairingPhone}…`);
-  } else {
-    info('A QR code will appear — scan it in WhatsApp:');
-    print(c.dim('  Phone → Settings → Linked Devices → Link a Device'));
-  }
-
-  let shownQR = false;
-  const onQR = (qr: string) => {
-    if (!shownQR && hadSession) {
-      warn('Your saved session has expired or was unlinked — re-scan to link again:');
-      print(c.dim('  Phone → Settings → Linked Devices → Link a Device'));
-    }
-    shownQR = true;
-    print();
-    qrcode.generate(qr, { small: true });
-    print(c.dim('Scan it — this window will confirm and close automatically. (Ctrl+C to cancel)'));
-  };
-
-  const onPairingCode = (code: string) => {
-    shownQR = true; // a fresh link is happening (drives history sync below)
-    print();
-    print(`  ${c.dim('Pairing code:')}  ${c.bold(c.green(code))}`);
-    print(c.dim('  On your phone: Linked Devices → Link a Device →'));
-    print(c.dim('  "Link with phone number instead" → enter this code.'));
-    print(c.dim('  Waiting… (Ctrl+C to cancel)'));
-  };
-
-  // No valid session but stale files may linger (corrupt/partial creds from an
-  // interrupted attempt). Clear them so we always start a fresh link cleanly.
-  if (!hadSession) clearSession();
-
-  const mkOpts = () => ({
-    syncFullHistory: true,
-    onQR,
-    pairingPhone,
-    onPairingCode,
-  });
-
-  const linkKind = () => (pairingPhone ? 'pairing code' : 'QR code');
-  const retryCmd = () => (pairingPhone ? `wa login --phone ${pairingPhone}` : 'wa login qr');
-  const retryHint = () => `Run \`${retryCmd()}\` to get a new ${linkKind()}.`;
-
-  // Establish the connection, tolerating the post-pairing "restart required"
-  // (code 515) that WhatsApp sends immediately after a fresh link.
-  let conn = await connect(mkOpts());
-  registerPersistence(conn.sock); // persist history WhatsApp streams after link
-
-  const MAX_RESTARTS = 4;
-  let healedLogout = false;
-  for (let restart = 0; ; restart++) {
-    // A pairing code / QR is only valid for a short window; don't wait forever.
-    const timeout = pairingPhone ? 90_000 : 120_000;
-    try {
-      await withTimeout(conn.ready, timeout, 'LINK_TIMEOUT');
-      break; // connection open
-    } catch (err) {
-      conn.close();
-      const msg = (err as Error).message;
-      if (msg === 'LOGGED_OUT') {
-        // The stored session is dead server-side. Wipe it and re-link fresh
-        // once, so the user doesn't have to run `wa logout` manually.
-        if (!healedLogout) {
-          healedLogout = true;
-          clearSession();
-          warn('Previous session was logged out — starting a fresh link…');
-          if (!useQR && !pairingPhone) pairingPhone = await resolvePhone();
-          conn = await connect(mkOpts());
-          registerPersistence(conn.sock);
-          continue;
-        }
-        fail(`This device was logged out. ${retryHint()}`);
-      }
-      if (msg.startsWith('PAIRING_FAILED')) {
-        const reason = msg.split(':').slice(1).join(':') || 'unknown error';
-        fail(
-          `Pairing failed (${reason}). Make sure ${pairingPhone ? `+${pairingPhone}` : 'the number'} is your own WhatsApp number, then run \`${retryCmd()}\`.`,
-        );
-      }
-      // 515 = restart required (normal right after linking): reconnect silently.
-      if (msg.endsWith(':515') && restart < MAX_RESTARTS) {
-        conn = await connect(mkOpts());
-        registerPersistence(conn.sock);
-        continue;
-      }
-      // Timed out, or the code/QR expired or was rejected before pairing.
-      if (msg === 'LINK_TIMEOUT') {
-        fail(`Your ${linkKind()} expired — no device linked in time. ${retryHint()}`);
-      }
-      if (msg.startsWith('CONNECTION_CLOSED')) {
-        fail(`Your ${linkKind()} expired or was rejected. ${retryHint()}`);
-      }
-      fail(msg);
-    }
-  }
-
-  ok('Logged in successfully.');
-  const cfg = loadConfig();
-  cfg.session.loggedIn = true;
-
-  // Give WhatsApp a moment to stream initial history into the cache.
-  if (shownQR) {
-    info('Syncing initial history…');
-    await new Promise((r) => setTimeout(r, 6000));
-    const chats = listChats().length;
-    const msgs = countMessages();
-    // The initial history capture is a sync — record it so `status` is accurate.
-    cfg.session.lastSyncAt = Date.now();
-    ok(`Cached ${chats} chats and ${msgs} messages so far.`);
-    info('Run `wa sync` any time to pull more, `wa chats` to browse.');
-  }
-
-  saveConfig(cfg);
-  conn.close();
-}
-
-/** wa logout — end the session and delete local credentials. */
-export async function logout(): Promise<void> {
-  if (!hasSession()) {
-    warn('No active session found.');
-  } else {
-    // Best-effort: tell WhatsApp to unlink this device, then wipe creds.
-    try {
-      const conn = await connect({ requireSession: true });
-      await withTimeout(conn.ready, 15_000, 'timeout').catch(() => {});
-      try {
-        await conn.sock.logout();
-      } catch {
-        /* server-side logout best effort */
-      }
-      conn.close();
-    } catch {
-      /* offline logout still wipes local creds below */
-    }
-    rmSync(PATHS.sessions, { recursive: true, force: true });
-    ok('Logged out and removed local session.');
-  }
-
-  const cfg = loadConfig();
-  cfg.session.loggedIn = false;
-  saveConfig(cfg);
-}
-
-/** wa status — show login and cache state without a network round-trip. */
-export function status(): void {
-  const cfg = loadConfig();
-  const session = hasSession();
-  print(c.bold('WhatsApp CLI status'));
-  print();
-  // Connection: whether the live link to WhatsApp is established.
-  print(c.dim('  Connection'));
-  print(`    Session:   ${session ? c.green('● linked') : c.red('○ not linked')}`);
-  if (!session) {
-    print(c.dim('               (sending & syncing new messages need a link)'));
-  }
-  print();
-  // Local cache: your data on disk — readable offline, independent of the link.
-  print(c.dim('  Local cache') + c.dim('  — readable offline, even when not linked'));
-  print(`    Messages:  ${countMessages()} in ${listChats(100000).length} chats`);
-  if (cfg.session.lastSyncAt) {
-    print(`    Last sync: ${new Date(cfg.session.lastSyncAt).toLocaleString()}`);
-  }
-  print(`    Config:    ${existsSync(PATHS.config) ? PATHS.config : c.dim('defaults')}`);
-  if (!session) {
-    print();
-    info('Your cached chats still work (`wa chats`, `wa search`). Run `wa login` to send/receive again.');
-  }
-}
-
-function withTimeout<T>(p: Promise<T>, ms: number, message: string): Promise<T> {
-  return Promise.race([
-    p,
-    new Promise<T>((_, rej) => setTimeout(() => rej(new Error(message)), ms)),
-  ]);
-}