cli-whatsapp 0.1.5 → 0.1.12

package/dist/cli/commands/filepicker.js

@@ -210,7 +210,7 @@ export function pickFromList(title, allItems, initialFilter = '') {
             return void ((index = Math.min(items.length - 1, index + 1)), render());
         if (key.name === 'return') {
             const it = items[index];
-            return done(it ? it.value : null);
+            return done(it ? (it.id ?? it.value) : null);
         }
         if (key.name === 'backspace') {
             if (!filter)

package/dist/cli/commands/media.js

@@ -1,8 +1,9 @@
-import { writeFileSync } from 'node:fs';
+import { writeFileSync, existsSync } 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 { openFile } from "../../utils/open.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";
@@ -22,7 +23,8 @@ const TYPE_ALIASES = {
     stickers: ['sticker'],
     all: [],
 };
-/** wa media [type] [--limit N] — list media messages from the cache. */
+/** wa media [type] [--limit N] — list media messages from the cache. In the
+ *  interactive app, `opts.chat` scopes it to the open chat. */
 export function media(type, opts) {
     const limit = Math.min(parseInt(opts.limit ?? '30', 10) || 30, 1000);
     let types = null;
@@ -33,11 +35,15 @@ export function media(type, opts) {
         }
         types = mapped.length ? mapped : null;
     }
-    const rows = listMedia(types, limit);
+    const rows = listMedia(types, limit, opts.chat?.jid);
     if (rows.length === 0) {
-        print(c.dim('No media cached. Run `wa sync` after logging in.'));
+        print(c.dim(opts.chat
+            ? `No media in this chat with ${opts.chat.name}.`
+            : 'No media cached. Run `wa sync` after logging in.'));
         return;
     }
+    if (opts.chat)
+        print(c.dim(`Media with ${c.bold(opts.chat.name)}:`));
     const cfg = loadConfig();
     const width = String(rows[rows.length - 1].id).length;
     for (const m of rows) {
@@ -52,7 +58,32 @@ export function media(type, opts) {
     print();
     info('Download one with `wa download <id>`.');
 }
-/** wa download <id> [--out FILE] — fetch & decrypt a cached media message. */
+/**
+ * Fetch & decrypt a cached media message over an already-open socket, save it,
+ * and return the file path. Reused by the CLI `download` and the interactive
+ * `/download` (which reuses the live connection). Returns null if #id has no
+ * downloadable media; caches an already-downloaded file's path.
+ */
+export async function downloadWithSocket(sock, id, out) {
+    const row = getMessageById(id);
+    if (!row || !row.raw)
+        return null;
+    if (!out && row.mediaPath && existsSync(row.mediaPath))
+        return row.mediaPath; // already saved
+    ensureDirs();
+    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 downloadMediaMessage(waMsg, 'buffer', {}, { logger: logger, reuploadRequest: sock.updateMediaMessage }));
+    const ext = extensionFor(content, row.type);
+    const file = out ?? join(PATHS.media, `${id}${ext}`);
+    writeFileSync(file, buffer);
+    setMediaPath(id, file);
+    return file;
+}
+/** wa download <id> [--out FILE] [--open] — fetch & decrypt a cached media message. */
 export async function download(idRaw, opts) {
     const id = parseInt(idRaw, 10);
     if (!Number.isFinite(id))
@@ -62,23 +93,13 @@ export async function download(idRaw, opts) {
         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)`);
+    const file = await runWithConnection((conn) => downloadWithSocket(conn.sock, id, opts.out), { requireSession: true }).catch((err) => fail(`Download failed: ${err.message}`));
+    if (!file)
+        fail('Nothing to download.');
+    ok(`Saved → ${file}`);
+    if (opts.open)
+        openFile(file);
 }
 function extensionFor(content, type) {
     const mime = content.imageMessage?.mimetype ||

package/dist/cli/commands/shell.js

@@ -1,19 +1,20 @@
 import readline, { createInterface } from 'node:readline';
 import { readdirSync, statSync, existsSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { join, basename } from 'node:path';
 import { chats, contacts, search, history } from "./read.js";
 import { reply, buildMediaContent, sendContent } from "./send.js";
-import { media } from "./media.js";
+import { media, downloadWithSocket } from "./media.js";
 import { pickFile, pickFromList } from "./filepicker.js";
+import { openFile } from "../../utils/open.js";
 import { recent, pin, unpin, archive, unarchive } from "./manage.js";
 import { status } from "./auth.js";
 import { connect, hasSession } from "../../whatsapp/client.js";
-import { registerPersistence, extractText, isGroupJid } from "../../whatsapp/events.js";
-import { listChats, listContacts, findChat, upsertChat, getMessages, countMessages, } from "../../db/sqlite.js";
+import { registerPersistence, extractText, isGroupJid, messageType } from "../../whatsapp/events.js";
+import { listChats, listContacts, listMedia, findChat, upsertChat, getMessages, getMessageById, localIdForWaMessage, countMessages, } from "../../db/sqlite.js";
 import { resolveTarget } from "../../utils/jid.js";
 import { loadConfig, saveConfig } from "../../config/index.js";
-import { c, displayName, chatNumber, formatTime, truncate, renderMessages } from "../../utils/format.js";
+import { c, displayName, chatNumber, cleanSender, formatTime, truncate, renderMessages } from "../../utils/format.js";
 import { print, warn, printError } from "../../utils/ui.js";
 import { notify } from "../../utils/notify.js";
 // ---- tab completion --------------------------------------------------------
@@ -28,7 +29,8 @@ const SLASH_ITEMS = [
     { value: '/send', desc: 'send a message to a chat', args: true },
     { value: '/sendfile', desc: 'send a file (media)', args: true },
     { value: '/reply', desc: 'reply to a message by #id', args: true },
-    { value: '/media', desc: 'list cached media' },
+    { value: '/media', desc: 'list cached media (this chat, or all)' },
+    { value: '/dl', desc: 'pick recent media to download & open' },
     { value: '/pin', desc: 'pin a chat to the top', args: true },
     { value: '/unpin', desc: 'unpin a chat', args: true },
     { value: '/archive', desc: 'archive (hide) a chat', args: true },
@@ -187,7 +189,16 @@ function onIncoming(state, msg) {
     const jid = msg.key.remoteJid;
     if (!jid || jid === 'status@broadcast')
         return;
-    const text = extractText(msg.message) || c.dim('[media]');
+    let text = extractText(msg.message);
+    if (!text) {
+        // Media: show its kind and a one-liner to download & open it.
+        const kind = messageType(msg.message);
+        const localId = msg.key.id ? localIdForWaMessage(jid, msg.key.id) : null;
+        text =
+            localId != null
+                ? c.dim(`[${kind}] `) + c.green(`/dl ${localId}`) + c.dim(' to open')
+                : c.dim(`[${kind}]`);
+    }
     const chat = findChat(jid);
     const who = isGroupJid(jid) && msg.pushName
         ? `${chat ? displayName(chat) : jid.split('@')[0]}/${msg.pushName}`
@@ -253,7 +264,20 @@ async function sendTo(state, jid, name, content, meta, replaceInput = false) {
         return;
     try {
         await sendContent(conn.sock, jid, content, meta);
-        const echo = meta.type === 'text' ? meta.previewText : `[${meta.type}] ${meta.previewText}`;
+        // Build the echo: text → the message; media → "[type] filename" plus any
+        // caption (never "[image] [image]"). The filename tells you which file.
+        let echo;
+        if (meta.type === 'text') {
+            echo = meta.previewText;
+        }
+        else {
+            const fname = meta.mediaPath ? basename(meta.mediaPath) : '';
+            const caption = meta.previewText.startsWith('[') ? '' : meta.previewText;
+            echo =
+                `${c.dim(`[${meta.type}]`)}` +
+                    (fname ? ` ${fname}` : '') +
+                    (caption ? ` ${c.dim('—')} ${caption}` : '');
+        }
         // Replace the just-typed input with the bubble so it shows once — but only
         // when we were already live (no "connecting…" lines were printed in between).
         if (replaceInput && wasLive)
@@ -266,6 +290,59 @@ async function sendTo(state, jid, name, content, meta, replaceInput = false) {
         warn(`Send failed: ${err.message}`);
     }
 }
+/** Download a media message by #id over the live connection, then open it. */
+async function downloadAndOpen(state, idRaw) {
+    const id = parseInt(idRaw, 10);
+    if (!Number.isFinite(id))
+        return warn(`Invalid id "${idRaw}".`);
+    const row = getMessageById(id);
+    if (!row)
+        return warn(`No message #${id}.`);
+    if (!row.raw)
+        return warn(`#${id} isn't a downloadable media message.`);
+    const conn = await ensureConnected(state);
+    if (!conn)
+        return;
+    printAbove(state, c.dim(`Downloading #${id}…`));
+    try {
+        const file = await downloadWithSocket(conn.sock, id);
+        if (!file)
+            return warn(`Couldn't download #${id}.`);
+        openFile(file);
+        printAbove(state, `${c.green('✓')} Opened ${c.dim(file)}`);
+    }
+    catch (err) {
+        warn(`Download failed: ${err.message}`);
+    }
+}
+/** `/dl` with no id: pick from recent, not-yet-downloaded media (this chat if
+ *  open, else all), newest first — arrow-select, no id to type. */
+async function pickMediaToDownload(state) {
+    const rows = listMedia(null, 100, state.active?.jid, true); // undownloaded only
+    if (!rows.length) {
+        warn(state.active ? 'No new media in this chat to download.' : 'No new media to download.');
+        return;
+    }
+    const time24h = loadConfig().preferences.time24h;
+    const items = rows.map((m) => {
+        const label = m.text
+            ? truncate(m.text.replace(/\s+/g, ' '), 32)
+            : m.mediaPath
+                ? basename(m.mediaPath)
+                : '';
+        return {
+            value: `[${m.type}]${label ? ' ' + label : ''}`,
+            desc: `${m.fromMe ? 'you' : cleanSender(m.sender)} · ${formatTime(m.timestamp, time24h)}`,
+            id: String(m.id),
+        };
+    });
+    const title = state.active
+        ? `Media with ${displayName(state.active)} — ⏎ download & open`
+        : 'All media — ⏎ download & open';
+    const picked = await pickFromList(title, items, '');
+    if (picked)
+        await downloadAndOpen(state, picked);
+}
 // ---- chat context ----------------------------------------------------------
 function openChat(state, target) {
     // Resolve against chats, contacts, or a raw number/jid.
@@ -342,6 +419,7 @@ const HELP = `${c.bold('Commands')} ${c.dim('(slash optional for the first word)
   ${c.cyan('/sendfile')} <chat> <path> [caption]   send media
   ${c.cyan('/reply')} <id> <msg>     reply to a message by #id
   ${c.cyan('/media')} [type]         list media
+  ${c.cyan('/dl')} <id>              download a media message and open it
   ${c.cyan('/pin')} · ${c.cyan('/unpin')} · ${c.cyan('/archive')} · ${c.cyan('/unarchive')} <chat>
   ${c.cyan('/connect')} · ${c.cyan('/disconnect')}     go live (receive) / drop connection
   ${c.cyan('/status')} · ${c.cyan('/settings')} · ${c.cyan('/set')} <k> <v>   status / settings
@@ -435,7 +513,16 @@ async function handle(state, raw) {
                 search(args.join(' '), {});
             return;
         case 'media':
-            media(args[0], {});
+            // Inside a chat → only that chat's media; outside → everything.
+            media(args[0], state.active ? { chat: { jid: state.active.jid, name: displayName(state.active) } } : {});
+            return;
+        case 'download':
+        case 'dl':
+        case 'open-media':
+            if (args[0])
+                await downloadAndOpen(state, args[0]);
+            else
+                await pickMediaToDownload(state); // no id → pick from recent media
             return;
         case 'status':
             status();

package/dist/cli/index.js

@@ -126,6 +126,7 @@ program
     .command('download <id>')
     .description('Download & decrypt a cached media message by #id')
     .option('-o, --out <file>', 'output file')
+    .option('--open', 'open the file after downloading')
     .action(run(download));
 // ---- Organize (local) ------------------------------------------------------
 program

package/dist/db/sqlite.js

@@ -249,20 +249,21 @@ export function importLidMappings() {
     return n;
 }
 /** Media messages, optionally filtered by type (image/video/audio/document/sticker). */
-export function listMedia(types, limit = 50) {
-    const dbc = getDb();
-    if (types && types.length) {
-        const placeholders = types.map(() => '?').join(',');
-        return dbc
-            .prepare(`SELECT * FROM messages WHERE type IN (${placeholders})
-         ORDER BY timestamp DESC LIMIT ?`)
-            .all(...types, limit);
+export function listMedia(types, limit = 50, chatJid, undownloadedOnly = false) {
+    const kinds = types && types.length ? types : ['image', 'video', 'audio', 'document', 'sticker'];
+    const placeholders = kinds.map(() => '?').join(',');
+    const params = [...kinds];
+    let where = `type IN (${placeholders})`;
+    if (chatJid) {
+        where += ' AND chatJid = ?';
+        params.push(chatJid);
     }
-    return dbc
-        .prepare(`SELECT * FROM messages
-       WHERE type IN ('image','video','audio','document','sticker')
-       ORDER BY timestamp DESC LIMIT ?`)
-        .all(limit);
+    if (undownloadedOnly)
+        where += " AND (mediaPath IS NULL OR mediaPath = '')";
+    params.push(limit);
+    return getDb()
+        .prepare(`SELECT * FROM messages WHERE ${where} ORDER BY timestamp DESC LIMIT ?`)
+        .all(...params);
 }
 /** Recent chats by activity, ignoring pin priority. */
 export function recentChats(limit = 15) {
@@ -286,6 +287,13 @@ export function findContact(query) {
         .get(likePattern(query), query);
     return row ?? null;
 }
+/** Local numeric id for a WhatsApp message (by chat + WA message id). */
+export function localIdForWaMessage(chatJid, waId) {
+    const row = getDb()
+        .prepare('SELECT id FROM messages WHERE chatJid = ? AND messageId = ?')
+        .get(chatJid, waId);
+    return row?.id ?? null;
+}
 export function getMessageById(id) {
     const row = getDb()
         .prepare('SELECT * FROM messages WHERE id = ?')

package/dist/utils/format.js

@@ -79,13 +79,16 @@ export function renderChatList(chats, time24h = true) {
 export function renderMessages(messages, time24h = true) {
     if (messages.length === 0)
         return c.dim('No messages.');
+    const MEDIA = ['image', 'video', 'audio', 'document', 'sticker'];
     return messages
         .map((m) => {
         const time = c.gray(formatTime(m.timestamp, time24h));
         const who = m.fromMe ? c.green('me') : c.cyan(cleanSender(m.sender));
+        const isMedia = m.type ? MEDIA.includes(m.type) : false;
         const body = m.text ?? (m.type ? c.dim(`[${m.type}]`) : c.dim('[no text]'));
-        const id = c.dim(`#${m.id}`);
-        return `${time} ${who}: ${body} ${id}`;
+        // Media → an actionable "/dl <id>"; text → a dim #id (for /reply).
+        const tail = isMedia && !m.fromMe ? c.green(`/dl ${m.id}`) : c.dim(`#${m.id}`);
+        return `${time} ${who}: ${body} ${tail}`;
     })
         .join('\n');
 }

package/dist/utils/notify.js

@@ -1,23 +1,73 @@
-import { execFile } from 'node:child_process';
+import { execFile, execFileSync } from 'node:child_process';
 import { platform } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { existsSync } from 'node:fs';
+// The branded "wa" icon, shipped in assets/. Two levels up works from both
+// dist/utils (published) and src/utils (dev).
+const ICON = (() => {
+    try {
+        const p = fileURLToPath(new URL('../../assets/wa-icon.png', import.meta.url));
+        return existsSync(p) ? p : null;
+    }
+    catch {
+        return null;
+    }
+})();
+let cached = null;
+/** Pick the best available notifier once. terminal-notifier lets us show the
+ *  branded icon on macOS; osascript is the zero-dependency fallback. */
+function detect() {
+    if (cached)
+        return cached;
+    const p = platform();
+    if (p === 'darwin') {
+        try {
+            execFileSync('which', ['terminal-notifier'], { stdio: 'ignore' });
+            cached = 'terminal-notifier';
+        }
+        catch {
+            cached = 'osascript';
+        }
+    }
+    else if (p === 'linux') {
+        cached = 'notify-send';
+    }
+    else {
+        cached = 'none';
+    }
+    return cached;
+}
 /**
- * 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.
+ * Fire a native desktop notification. Best-effort and non-blocking. Uses the
+ * branded icon where the platform allows it (terminal-notifier on macOS,
+ * notify-send on Linux); plain macOS `osascript` can't set a custom icon and
+ * shows the terminal's.
  */
 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)], () => { });
+        const t = clip(title);
+        const b = clip(body);
+        switch (detect()) {
+            case 'terminal-notifier': {
+                const args = ['-title', t, '-message', b, '-group', 'cli-whatsapp'];
+                if (ICON)
+                    args.push('-appIcon', ICON, '-contentImage', ICON);
+                execFile('terminal-notifier', args, () => { });
+                break;
+            }
+            case 'osascript': {
+                const esc = (s) => s.replace(/[\\"]/g, '\\$&');
+                execFile('osascript', ['-e', `display notification "${esc(b)}" with title "${esc(t)}"`], () => { });
+                break;
+            }
+            case 'notify-send': {
+                const args = ['-a', 'WhatsApp CLI'];
+                if (ICON)
+                    args.push('-i', ICON);
+                execFile('notify-send', [...args, t, b], () => { });
+                break;
+            }
         }
-        // Windows: no reliable dependency-free path; skipped intentionally.
     }
     catch {
         /* notifications are best-effort */

package/dist/utils/open.js

@@ -0,0 +1,17 @@
+import { execFile } from 'node:child_process';
+import { platform } from 'node:os';
+/** Open a file with the OS default application (best-effort, non-blocking). */
+export function openFile(path) {
+    try {
+        const p = platform();
+        if (p === 'darwin')
+            execFile('open', [path], () => { });
+        else if (p === 'win32')
+            execFile('cmd', ['/c', 'start', '', path], () => { });
+        else
+            execFile('xdg-open', [path], () => { });
+    }
+    catch {
+        /* best-effort */
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cli-whatsapp",
-  "version": "0.1.5",
+  "version": "0.1.12",
   "description": "A lightweight, fast, terminal-first WhatsApp client. Read, search, send, media, groups, and live notifications — from your terminal.",
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
   "files": [
     "bin/",
     "dist/",
+    "assets/",
     "README.md",
     "COMMANDS.md",
     "LICENSE"