cli-whatsapp 0.1.0 → 0.1.2

package/dist/cli/commands/manage.js

@@ -0,0 +1,41 @@
+import { findChat, setPinned, setArchived, recentChats } from "../../db/sqlite.js";
+import { loadConfig } from "../../config/index.js";
+import { renderChatList, displayName } from "../../utils/format.js";
+import { print, ok, fail } from "../../utils/ui.js";
+/** wa recent [--limit N] — most recently active chats (ignores pins). */
+export function recent(opts) {
+    const limit = Math.min(parseInt(opts.limit ?? '15', 10) || 15, 200);
+    const cfg = loadConfig();
+    print(renderChatList(recentChats(limit), cfg.preferences.time24h));
+}
+/**
+ * Pin/archive toggles update the local cache so listings reflect your
+ * preference immediately. (They are local-only; they do not change the flag
+ * on WhatsApp itself.)
+ */
+export function pin(target) {
+    const chat = requireChat(target);
+    setPinned(chat.jid, true);
+    ok(`Pinned ${displayName(chat)}.`);
+}
+export function unpin(target) {
+    const chat = requireChat(target);
+    setPinned(chat.jid, false);
+    ok(`Unpinned ${displayName(chat)}.`);
+}
+export function archive(target) {
+    const chat = requireChat(target);
+    setArchived(chat.jid, true);
+    ok(`Archived ${displayName(chat)}. (Hidden from \`wa chats\`; use \`-a\` to show.)`);
+}
+export function unarchive(target) {
+    const chat = requireChat(target);
+    setArchived(chat.jid, false);
+    ok(`Unarchived ${displayName(chat)}.`);
+}
+function requireChat(target) {
+    const chat = findChat(target);
+    if (!chat)
+        fail(`No chat matching "${target}". Try \`wa chats\`.`);
+    return chat;
+}

package/dist/cli/commands/media.js

@@ -0,0 +1,105 @@
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { proto, downloadMediaMessage } from '@whiskeysockets/baileys';
+import { runWithConnection } from "../../whatsapp/client.js";
+import { logger } from "../../whatsapp/logger.js";
+import { listMedia, getMessageById, setMediaPath, findChat, } from "../../db/sqlite.js";
+import { PATHS, ensureDirs, loadConfig } from "../../config/index.js";
+import { c, formatTime, displayName, truncate } from "../../utils/format.js";
+import { print, ok, fail, info } from "../../utils/ui.js";
+const TYPE_ALIASES = {
+    photos: ['image'],
+    photo: ['image'],
+    images: ['image'],
+    image: ['image'],
+    videos: ['video'],
+    video: ['video'],
+    audio: ['audio'],
+    voice: ['audio'],
+    docs: ['document'],
+    documents: ['document'],
+    document: ['document'],
+    stickers: ['sticker'],
+    all: [],
+};
+/** wa media [type] [--limit N] — list media messages from the cache. */
+export function media(type, opts) {
+    const limit = Math.min(parseInt(opts.limit ?? '30', 10) || 30, 1000);
+    let types = null;
+    if (type) {
+        const mapped = TYPE_ALIASES[type.toLowerCase()];
+        if (mapped === undefined) {
+            fail(`Unknown media type "${type}". Try: photos, videos, audio, documents, stickers, all.`);
+        }
+        types = mapped.length ? mapped : null;
+    }
+    const rows = listMedia(types, limit);
+    if (rows.length === 0) {
+        print(c.dim('No media cached. Run `wa sync` after logging in.'));
+        return;
+    }
+    const cfg = loadConfig();
+    const width = String(rows[rows.length - 1].id).length;
+    for (const m of rows) {
+        const chat = findChat(m.chatJid);
+        const where = c.magenta(chat ? displayName(chat) : m.chatJid.split('@')[0]);
+        const time = c.gray(formatTime(m.timestamp, cfg.preferences.time24h));
+        const kind = c.cyan(`[${m.type}]`);
+        const caption = m.text ? ' ' + c.dim(truncate(m.text, 40)) : '';
+        const saved = m.mediaPath ? c.green(' ✓saved') : '';
+        print(`${c.dim('#' + String(m.id).padStart(width))} ${kind} ${where} ${time}${caption}${saved}`);
+    }
+    print();
+    info('Download one with `wa download <id>`.');
+}
+/** wa download <id> [--out FILE] — fetch & decrypt a cached media message. */
+export async function download(idRaw, opts) {
+    const id = parseInt(idRaw, 10);
+    if (!Number.isFinite(id))
+        fail(`Invalid id "${idRaw}".`);
+    const row = getMessageById(id);
+    if (!row)
+        fail(`No cached message with id #${id}.`);
+    if (!row.raw)
+        fail(`Message #${id} has no downloadable media (text message?).`);
+    ensureDirs();
+    info(`Downloading media from #${id}…`);
+    const content = proto.Message.decode(Buffer.from(row.raw, 'base64'));
+    const waMsg = {
+        key: {
+            remoteJid: row.chatJid,
+            id: row.messageId,
+            fromMe: !!row.fromMe,
+        },
+        message: content,
+    };
+    const buffer = await runWithConnection(async (conn) => (await downloadMediaMessage(waMsg, 'buffer', {}, { logger: logger, reuploadRequest: conn.sock.updateMediaMessage })), { requireSession: true }).catch((err) => fail(`Download failed: ${err.message}`));
+    const ext = extensionFor(content, row.type);
+    const file = opts.out ?? join(PATHS.media, `${id}${ext}`);
+    writeFileSync(file, buffer);
+    setMediaPath(id, file);
+    ok(`Saved → ${file} (${(buffer.length / 1024).toFixed(1)} KB)`);
+}
+function extensionFor(content, type) {
+    const mime = content.imageMessage?.mimetype ||
+        content.videoMessage?.mimetype ||
+        content.audioMessage?.mimetype ||
+        content.documentMessage?.mimetype ||
+        content.stickerMessage?.mimetype ||
+        '';
+    const fromMime = mime.split(';')[0].split('/')[1];
+    if (fromMime)
+        return '.' + fromMime.replace('jpeg', 'jpg');
+    switch (type) {
+        case 'image':
+            return '.jpg';
+        case 'video':
+            return '.mp4';
+        case 'audio':
+            return '.ogg';
+        case 'sticker':
+            return '.webp';
+        default:
+            return '.bin';
+    }
+}

package/dist/cli/commands/misc.js

@@ -0,0 +1,112 @@
+import { existsSync, accessSync, constants, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadConfig, saveConfig, PATHS, ensureDirs } from "../../config/index.js";
+import { hasSession } from "../../whatsapp/client.js";
+import { countMessages, listChats, getDb } from "../../db/sqlite.js";
+import { print, ok, warn, info, fail } from "../../utils/ui.js";
+import { c } from "../../utils/format.js";
+function pkgVersion() {
+    try {
+        const p = join(new URL('../../../', import.meta.url).pathname, 'package.json');
+        return JSON.parse(readFileSync(p, 'utf8')).version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+export function version() {
+    print(`wa ${pkgVersion()}`);
+}
+/** wa config [set <key> <value>] — view or edit preferences. */
+export function config(action, key, value) {
+    const cfg = loadConfig();
+    if (!action) {
+        print(c.bold('Config') + c.dim(`  (${PATHS.config})`));
+        print(JSON.stringify(cfg, null, 2));
+        return;
+    }
+    if (action !== 'set' || !key || value === undefined) {
+        fail('Usage: wa config set <openLimit|time24h|notifications|autoConnect|ai.enabled> <value>');
+    }
+    switch (key) {
+        case 'openLimit':
+            cfg.preferences.openLimit = Math.max(1, parseInt(value, 10) || cfg.preferences.openLimit);
+            break;
+        case 'time24h':
+            cfg.preferences.time24h = value === 'true' || value === '1';
+            break;
+        case 'notifications':
+            cfg.preferences.notifications = value === 'true' || value === '1';
+            break;
+        case 'autoConnect':
+            cfg.preferences.autoConnect = value === 'true' || value === '1';
+            break;
+        case 'ai.enabled':
+            cfg.ai.enabled = value === 'true' || value === '1';
+            break;
+        default:
+            fail(`Unknown key "${key}". Editable: openLimit, time24h, notifications, autoConnect, ai.enabled`);
+    }
+    saveConfig(cfg);
+    ok(`Set ${key} = ${value}`);
+}
+/** wa doctor — self-diagnostics for a healthy install. */
+export function doctor() {
+    print(c.bold('WhatsApp CLI — doctor'));
+    let problems = 0;
+    const nodeOk = satisfiesNode(process.versions.node, 22, 5);
+    line(nodeOk, `Node.js ${process.versions.node}`, 'Needs Node >= 22.5 (built-in node:sqlite + TS).');
+    if (!nodeOk)
+        problems++;
+    ensureDirs();
+    for (const [label, dir] of [
+        ['sessions dir', PATHS.sessions],
+        ['data dir', PATHS.data],
+        ['media dir', PATHS.media],
+    ]) {
+        const writable = isWritable(dir);
+        line(writable, `${label} writable  ${c.dim(dir)}`);
+        if (!writable)
+            problems++;
+    }
+    let dbOk = true;
+    try {
+        getDb();
+        print(`  ${c.green('✓')} database ok  ${c.dim(`${countMessages()} messages, ${listChats(5000).length} chats`)}`);
+    }
+    catch (e) {
+        dbOk = false;
+        problems++;
+        print(`  ${c.red('✗')} database error: ${e.message}`);
+    }
+    if (hasSession())
+        line(true, 'session linked');
+    else
+        print(`  ${c.dim('○')} no session ${c.dim('(run `wa login` to link)')}`);
+    print();
+    if (problems === 0)
+        ok('All systems go.');
+    else
+        warn(`${problems} issue${problems === 1 ? '' : 's'} found.`);
+    void dbOk;
+}
+function line(good, msg, hint) {
+    print(`  ${good ? c.green('✓') : c.red('✗')} ${msg}`);
+    if (!good && hint)
+        print(`      ${c.dim(hint)}`);
+}
+function satisfiesNode(v, major, minor) {
+    const [maj, min] = v.split('.').map((x) => parseInt(x, 10));
+    return maj > major || (maj === major && min >= minor);
+}
+function isWritable(dir) {
+    try {
+        if (!existsSync(dir))
+            return false;
+        accessSync(dir, constants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/cli/commands/read.js

@@ -0,0 +1,79 @@
+import { listChats, listContacts, getMessages, searchMessages, findChat, } from "../../db/sqlite.js";
+import { loadConfig } from "../../config/index.js";
+import { renderChatList, renderMessages, displayName, formatTime, truncate, c, } from "../../utils/format.js";
+import { print, info, fail } from "../../utils/ui.js";
+/** wa chats [--all] [--limit N] */
+export function chats(opts) {
+    const limit = clampLimit(opts.limit, 50);
+    const rows = listChats(limit, !!opts.all);
+    const cfg = loadConfig();
+    print(renderChatList(rows, cfg.preferences.time24h));
+}
+/** wa contacts [--limit N] */
+export function contacts(opts) {
+    const limit = clampLimit(opts.limit, 500);
+    const rows = listContacts(limit);
+    if (rows.length === 0) {
+        print(c.dim('No contacts cached yet. Run `wa sync`.'));
+        return;
+    }
+    const width = String(rows.length).length;
+    print(rows
+        .map((r, i) => {
+        const idx = c.dim(String(i + 1).padStart(width) + '.');
+        const num = c.gray(r.jid.split('@')[0]);
+        return `${idx} ${c.bold(r.name ?? '(unknown)')}  ${num}`;
+    })
+        .join('\n'));
+}
+/** wa open <chat> [--limit N] */
+export function open(target, opts) {
+    const chat = findChat(target);
+    if (!chat) {
+        fail(`No chat matching "${target}". Try \`wa chats\` or \`wa sync\`.`);
+    }
+    const cfg = loadConfig();
+    const limit = clampLimit(opts.limit, cfg.preferences.openLimit);
+    print(c.bold(displayName(chat)) + c.dim(`  ${chat.jid}`));
+    print(c.dim('─'.repeat(40)));
+    print(renderMessages(getMessages(chat.jid, limit), cfg.preferences.time24h));
+}
+/** wa history <chat> [--limit N] — alias of open with a larger default. */
+export function history(target, opts) {
+    open(target, { limit: opts.limit ?? '200' });
+}
+/** wa search <text> [--limit N] */
+export function search(term, opts) {
+    const limit = clampLimit(opts.limit, 50);
+    const results = searchMessages(term, limit);
+    const cfg = loadConfig();
+    if (results.length === 0) {
+        print(c.dim(`No messages matching "${term}".`));
+        return;
+    }
+    info(`${results.length} match${results.length === 1 ? '' : 'es'} for "${term}":`);
+    print();
+    for (const m of results) {
+        const chat = findChat(m.chatJid);
+        const where = c.magenta(chat ? displayName(chat) : m.chatJid.split('@')[0]);
+        const time = c.gray(formatTime(m.timestamp, cfg.preferences.time24h));
+        const who = m.fromMe ? c.green('me') : c.cyan(m.sender ?? '');
+        const body = highlight(truncate(m.text ?? '', 80), term);
+        print(`${where} ${time} ${who}: ${body} ${c.dim(`#${m.id}`)}`);
+    }
+}
+function highlight(text, term) {
+    try {
+        const re = new RegExp(`(${term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')})`, 'ig');
+        return text.replace(re, (m) => c.yellow(m));
+    }
+    catch {
+        return text;
+    }
+}
+function clampLimit(raw, fallback) {
+    const n = raw ? parseInt(raw, 10) : fallback;
+    if (!Number.isFinite(n) || n <= 0)
+        return fallback;
+    return Math.min(n, 2000);
+}

package/dist/cli/commands/send.js

@@ -0,0 +1,137 @@
+import { existsSync, statSync } from 'node:fs';
+import { basename, extname, resolve } from 'node:path';
+import { runWithConnection } from "../../whatsapp/client.js";
+import { resolveTarget } from "../../utils/jid.js";
+import { getMessageById, insertMessage, upsertChat, findChat } from "../../db/sqlite.js";
+import { toMs } from "../../whatsapp/events.js";
+import { ok, fail, info } from "../../utils/ui.js";
+import { displayName } from "../../utils/format.js";
+/** wa send <chat> [message] [--file <path>] */
+export async function send(target, message, opts = {}) {
+    const resolved = resolveTarget(target);
+    if (!resolved) {
+        fail(`Could not resolve "${target}". Use a known chat name or a phone number.`);
+    }
+    if (opts.file) {
+        const built = buildMediaContent(opts.file, message);
+        info(`Sending ${built.kind} to ${resolved.name}…`);
+        await deliver(resolved.jid, built.content, resolved.name, {
+            previewText: message?.trim() || `[${built.kind}]`,
+            type: built.kind,
+            mediaPath: built.path,
+        });
+        return;
+    }
+    if (!message || !message.trim()) {
+        fail('Nothing to send. Provide a message, or --file <path> for media.');
+    }
+    info(`Sending to ${resolved.name}…`);
+    await deliver(resolved.jid, { text: message }, resolved.name, {
+        previewText: message,
+        type: 'text',
+    });
+}
+/** wa reply <id> <message> — reply into the chat of message #id, quoting it. */
+export async function reply(idRaw, message) {
+    const id = parseInt(idRaw, 10);
+    if (!Number.isFinite(id))
+        fail(`Invalid message id "${idRaw}".`);
+    const original = getMessageById(id);
+    if (!original)
+        fail(`No cached message with id #${id}. Open the chat first.`);
+    if (!message || !message.trim())
+        fail('Message text is empty.');
+    const chat = findChat(original.chatJid);
+    const name = chat ? displayName(chat) : original.chatJid;
+    info(`Replying in ${name}…`);
+    // Reconstruct a minimal quoted message for the reply context.
+    const quoted = {
+        key: {
+            remoteJid: original.chatJid,
+            id: original.messageId,
+            fromMe: !!original.fromMe,
+        },
+        message: { conversation: original.text ?? '' },
+    };
+    await deliver(original.chatJid, { text: message }, name, { previewText: message, type: 'text' }, quoted);
+}
+const EXT_KIND = {
+    '.jpg': 'image', '.jpeg': 'image', '.png': 'image', '.gif': 'image',
+    '.mp4': 'video', '.mov': 'video', '.mkv': 'video', '.webm': 'video',
+    '.mp3': 'audio', '.ogg': 'audio', '.m4a': 'audio', '.opus': 'audio', '.wav': 'audio',
+    '.webp': 'sticker',
+    '.pdf': 'document', '.doc': 'document', '.docx': 'document',
+    '.xls': 'document', '.xlsx': 'document', '.ppt': 'document', '.pptx': 'document',
+    '.txt': 'document', '.zip': 'document', '.csv': 'document',
+};
+const EXT_MIME = {
+    '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.png': 'image/png', '.gif': 'image/gif',
+    '.mp4': 'video/mp4', '.mov': 'video/quicktime', '.webm': 'video/webm',
+    '.mp3': 'audio/mpeg', '.ogg': 'audio/ogg', '.m4a': 'audio/mp4', '.opus': 'audio/ogg; codecs=opus',
+    '.webp': 'image/webp', '.pdf': 'application/pdf', '.zip': 'application/zip',
+    '.txt': 'text/plain', '.csv': 'text/csv',
+};
+export function buildMediaContent(file, caption) {
+    const path = resolve(file);
+    if (!existsSync(path) || !statSync(path).isFile()) {
+        fail(`File not found: ${file}`);
+    }
+    const ext = extname(path).toLowerCase();
+    const kind = EXT_KIND[ext] ?? 'document';
+    const mimetype = EXT_MIME[ext];
+    const cap = caption?.trim() || undefined;
+    let content;
+    switch (kind) {
+        case 'image':
+            content = { image: { url: path }, caption: cap };
+            break;
+        case 'video':
+            content = { video: { url: path }, caption: cap };
+            break;
+        case 'audio':
+            content = { audio: { url: path }, mimetype: mimetype ?? 'audio/mp4' };
+            break;
+        case 'sticker':
+            // Stickers can't carry a caption; if one was given, send as an image.
+            content = cap
+                ? { image: { url: path }, caption: cap }
+                : { sticker: { url: path } };
+            break;
+        default:
+            content = {
+                document: { url: path },
+                mimetype: mimetype ?? 'application/octet-stream',
+                fileName: basename(path),
+                caption: cap,
+            };
+    }
+    return { content, kind: kind === 'sticker' && cap ? 'image' : kind, path };
+}
+// ---- delivery --------------------------------------------------------------
+/** Send content over an already-open socket and cache it locally. Reusable by
+ *  both the one-shot CLI path and the persistent interactive session. */
+export async function sendContent(sock, jid, content, meta, quoted) {
+    const sent = (await sock.sendMessage(jid, content, quoted ? { quoted: quoted } : undefined));
+    cacheOutgoing(jid, content, sent, meta);
+}
+/** Optimistically cache an outgoing message we just sent. */
+export function cacheOutgoing(jid, content, sent, meta) {
+    const ts = toMs(sent?.messageTimestamp ?? Date.now() / 1000);
+    insertMessage({
+        chatJid: jid,
+        messageId: sent?.key?.id ?? `local-${ts}`,
+        sender: 'me',
+        text: meta.type === 'text' ? meta.previewText : content.caption ?? null,
+        timestamp: ts,
+        fromMe: true,
+        type: meta.type,
+        status: 'sent',
+        mediaPath: meta.mediaPath ?? null,
+    });
+    upsertChat({ jid, lastMessage: meta.previewText, lastTimestamp: ts });
+}
+/** One-shot delivery for the CLI: opens a connection, sends, closes. */
+async function deliver(jid, content, name, meta, quoted) {
+    await runWithConnection(async (conn) => sendContent(conn.sock, jid, content, meta, quoted), { requireSession: true }).catch((err) => fail(err.message));
+    ok(`Sent to ${name}.`);
+}