cli-whatsapp 0.1.1 → 0.1.2

package/bin/wa.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
-// Thin launcher. Node (>=22.5 with --experimental-strip-types, default in >=23.6)
-// strips TypeScript types at runtime, so no build step is required.
-import '../src/cli/index.ts';
+// Entry point. Runs the compiled JavaScript from dist/ (Node does not strip
+// TypeScript types for files under node_modules, so published installs must ship
+// compiled JS). Build with `npm run build`.
+import '../dist/cli/index.js';

package/dist/cli/commands/auth.js

@@ -0,0 +1,220 @@
+import { rmSync, existsSync } from 'node:fs';
+import { createInterface } from 'node:readline/promises';
+import qrcode from 'qrcode-terminal';
+import { connect, hasSession, clearSession } from "../../whatsapp/client.js";
+import { registerPersistence } from "../../whatsapp/events.js";
+import { loadConfig, saveConfig, PATHS } from "../../config/index.js";
+import { countMessages, listChats } from "../../db/sqlite.js";
+import { ok, info, warn, fail, print } from "../../utils/ui.js";
+import { c } from "../../utils/format.js";
+/** 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) {
+    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() {
+    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, opts = {}) {
+    const useQR = (mode ?? '').toLowerCase() === 'qr';
+    const hadSession = hasSession();
+    // Resolve the number for pairing (prompt if needed). QR mode skips this.
+    const resolvePhone = async () => {
+        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;
+    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) => {
+        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) => {
+        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.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() {
+    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() {
+    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(p, ms, message) {
+    return Promise.race([
+        p,
+        new Promise((_, rej) => setTimeout(() => rej(new Error(message)), ms)),
+    ]);
+}

package/dist/cli/commands/export.js

@@ -0,0 +1,51 @@
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { findChat, getMessages } from "../../db/sqlite.js";
+import { displayName, formatTime } from "../../utils/format.js";
+import { ok, fail, print } from "../../utils/ui.js";
+/** wa export <chat> [--format md|txt|json] [--limit N] [--out FILE] */
+export function exportChat(target, opts) {
+    const chat = findChat(target);
+    if (!chat)
+        fail(`No chat matching "${target}".`);
+    const fmt = normalizeFmt(opts.format);
+    const limit = Math.min(parseInt(opts.limit ?? '1000', 10) || 1000, 100000);
+    const msgs = getMessages(chat.jid, limit);
+    const name = displayName(chat);
+    let body;
+    if (fmt === 'json') {
+        body = JSON.stringify({ chat: { jid: chat.jid, name }, messages: msgs }, null, 2);
+    }
+    else if (fmt === 'txt') {
+        body = msgs
+            .map((m) => `[${formatTime(m.timestamp)}] ${m.fromMe ? 'me' : m.sender ?? '?'}: ${m.text ?? '[' + (m.type ?? 'media') + ']'}`)
+            .join('\n');
+    }
+    else {
+        body =
+            `# ${name}\n\n` +
+                msgs
+                    .map((m) => `**${m.fromMe ? 'me' : m.sender ?? '?'}** _(${formatTime(m.timestamp)})_  \n${m.text ?? '`[' + (m.type ?? 'media') + ']`'}\n`)
+                    .join('\n');
+    }
+    if (opts.out === '-') {
+        print(body);
+        return;
+    }
+    const file = opts.out ?? join(process.cwd(), `${slug(name)}.${fmt === 'md' ? 'md' : fmt}`);
+    writeFileSync(file, body + '\n', 'utf8');
+    ok(`Exported ${msgs.length} messages → ${file}`);
+}
+function normalizeFmt(f) {
+    const v = (f ?? 'md').toLowerCase();
+    if (v === 'markdown' || v === 'md')
+        return 'md';
+    if (v === 'txt' || v === 'text')
+        return 'txt';
+    if (v === 'json')
+        return 'json';
+    return 'md';
+}
+function slug(s) {
+    return s.replace(/[^a-z0-9]+/gi, '-').replace(/^-+|-+$/g, '').toLowerCase() || 'chat';
+}

package/dist/cli/commands/filepicker.js

@@ -0,0 +1,232 @@
+import readline from 'node:readline';
+import { readdirSync, statSync } from 'node:fs';
+import { resolve, join, relative } from 'node:path';
+import { homedir } from 'node:os';
+import { c } from "../../utils/format.js";
+const VISIBLE = 12; // rows shown at once
+const WIDTH = 58; // inner box width
+const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
+function pad(s, w) {
+    const len = stripAnsi(s).length; // emoji surrogate pairs ≈ 2 cols, matches display
+    return len >= w ? s : s + ' '.repeat(w - len);
+}
+/** Green highlight for the selected row (WhatsApp green bg, dark text). */
+function highlight(s) {
+    return `\x1b[48;2;37;211;102m\x1b[38;2;7;46;36m${stripAnsi(s)}\x1b[0m`;
+}
+const border = (l, r) => c.teal(l + '─'.repeat(WIDTH) + r);
+/**
+ * Generic raw-mode overlay runner: sets up keypress capture (stealing readline's
+ * handlers for the duration), renders below the prompt, and restores everything
+ * on exit. `render` draws the overlay; `makeOnKey(done)` returns the keypress
+ * handler and calls `done(result)` to close. No-op (null) on a non-TTY.
+ */
+function runOverlay(render, makeOnKey) {
+    const input = process.stdin;
+    if (!input.isTTY)
+        return Promise.resolve(null);
+    readline.emitKeypressEvents(input);
+    const wasRaw = !!input.isRaw;
+    input.setRawMode(true);
+    const saved = input.listeners('keypress');
+    input.removeAllListeners('keypress');
+    process.stdout.write('\x1b7'); // save cursor at the prompt
+    render();
+    return new Promise((res) => {
+        let onKey;
+        const done = (result) => {
+            input.removeListener('keypress', onKey);
+            process.stdout.write('\x1b8\x1b[0J'); // restore cursor, wipe overlay
+            if (input.isTTY)
+                input.setRawMode(wasRaw);
+            for (const l of saved)
+                input.on('keypress', l);
+            res(result);
+        };
+        onKey = makeOnKey(done);
+        input.on('keypress', onKey);
+    });
+}
+/** Shared list-window math + scroll clamp. */
+function clampScroll(index, scroll, count) {
+    if (index < scroll)
+        return index;
+    if (index >= scroll + VISIBLE)
+        return index - VISIBLE + 1;
+    return Math.min(scroll, Math.max(0, count - 1));
+}
+/** Interactive file picker: ↑↓ move · type to filter · ⏎ open/pick · ⌫ up · esc. */
+export function pickFile(startDir) {
+    let dir = resolve(startDir);
+    let filter = '';
+    let index = 0;
+    let scroll = 0;
+    const load = () => {
+        let items = [];
+        try {
+            items = readdirSync(dir).map((name) => {
+                let d = false;
+                try {
+                    d = statSync(join(dir, name)).isDirectory();
+                }
+                catch {
+                    /* unstatable */
+                }
+                return { name, dir: d };
+            });
+        }
+        catch {
+            items = [];
+        }
+        const showHidden = filter.startsWith('.');
+        const f = filter.toLowerCase();
+        items = items
+            .filter((e) => (showHidden || !e.name.startsWith('.')) && e.name.toLowerCase().includes(f))
+            .sort((a, b) => (a.dir === b.dir ? a.name.localeCompare(b.name) : a.dir ? -1 : 1));
+        return [{ name: '..', dir: true }, ...items];
+    };
+    let entries = load();
+    const render = () => {
+        if (index >= entries.length)
+            index = Math.max(0, entries.length - 1);
+        scroll = clampScroll(index, scroll, entries.length);
+        const rows = [border('╭', '╮')];
+        rows.push(c.teal('│') + pad(` ${c.dim('📎 attach a file')}   ${c.dim(dir.replace(homedir(), '~'))}`, WIDTH) + c.teal('│'));
+        rows.push(border('├', '┤'));
+        const shown = entries.slice(scroll, scroll + VISIBLE);
+        if (!shown.length)
+            rows.push(c.teal('│') + pad(c.dim('  (no matches)'), WIDTH) + c.teal('│'));
+        shown.forEach((e, i) => {
+            const real = scroll + i;
+            const icon = e.dir ? '📁' : '📄';
+            const label = pad(` ${icon}  ${e.name}${e.dir && e.name !== '..' ? '/' : ''}`, WIDTH);
+            rows.push(c.teal('│') + (real === index ? highlight(label) : label) + c.teal('│'));
+        });
+        rows.push(border('╰', '╯'));
+        rows.push(c.dim(`  @${filter}${c.gray('▏')}   ↑↓ move · ⏎ ${entries[index]?.dir ? 'open' : 'attach'} · ⌫ up · esc cancel`));
+        process.stdout.write('\x1b8\x1b[0J\n' + rows.join('\n'));
+    };
+    return runOverlay(render, (done) => (str, key) => {
+        if (!key)
+            return;
+        if (key.name === 'escape' || (key.ctrl && key.name === 'c'))
+            return done(null);
+        if (key.name === 'up')
+            return void ((index = Math.max(0, index - 1)), render());
+        if (key.name === 'down')
+            return void ((index = Math.min(entries.length - 1, index + 1)), render());
+        if (key.name === 'return') {
+            const e = entries[index];
+            if (!e)
+                return;
+            if (e.name === '..') {
+                dir = resolve(dir, '..');
+                filter = '';
+                index = 0;
+                scroll = 0;
+                entries = load();
+                return render();
+            }
+            const full = join(dir, e.name);
+            if (e.dir) {
+                dir = full;
+                filter = '';
+                index = 0;
+                scroll = 0;
+                entries = load();
+                return render();
+            }
+            const rel = relative(process.cwd(), full);
+            return done(rel && !rel.startsWith('..') ? rel : full);
+        }
+        if (key.name === 'backspace') {
+            if (filter)
+                filter = filter.slice(0, -1);
+            else
+                dir = resolve(dir, '..');
+            index = 0;
+            scroll = 0;
+            entries = load();
+            return render();
+        }
+        if (str && str.length === 1 && str >= ' ' && !key.ctrl && !key.meta) {
+            filter += str;
+            index = 0;
+            scroll = 0;
+            entries = load();
+            return render();
+        }
+    });
+}
+/**
+ * Interactive menu over a flat list: ↑↓ move · type to filter · ⏎ select · esc.
+ * Returns the chosen item's `value`, or null. `initialFilter` pre-seeds the
+ * filter (e.g. what the user already typed after `/`).
+ */
+export function pickFromList(title, allItems, initialFilter = '') {
+    let filter = initialFilter;
+    let index = 0;
+    let scroll = 0;
+    // Match on the command name only (not its description).
+    const match = () => {
+        const f = filter.toLowerCase().replace(/^\//, '');
+        return allItems.filter((it) => it.value.toLowerCase().replace(/^\//, '').includes(f));
+    };
+    let items = match();
+    const LEFT = 14; // width of the value column
+    const render = () => {
+        if (index >= items.length)
+            index = Math.max(0, items.length - 1);
+        scroll = clampScroll(index, scroll, items.length);
+        const rows = [border('╭', '╮')];
+        rows.push(c.teal('│') + pad(` ${c.dim(title)}`, WIDTH) + c.teal('│'));
+        rows.push(border('├', '┤'));
+        const shown = items.slice(scroll, scroll + VISIBLE);
+        if (!shown.length)
+            rows.push(c.teal('│') + pad(c.dim('  (no matches)'), WIDTH) + c.teal('│'));
+        shown.forEach((it, i) => {
+            const real = scroll + i;
+            const left = pad(' ' + it.value, LEFT);
+            let desc = it.desc ?? '';
+            const room = WIDTH - LEFT - 1;
+            if (desc.length > room)
+                desc = desc.slice(0, room - 1) + '…';
+            const display = left + c.dim(desc);
+            const line = display + ' '.repeat(Math.max(0, WIDTH - stripAnsi(display).length));
+            rows.push(c.teal('│') + (real === index ? highlight(line) : line) + c.teal('│'));
+        });
+        rows.push(border('╰', '╯'));
+        rows.push(c.dim(`  ${filter}${c.gray('▏')}   ↑↓ move · ⏎ select · esc cancel`));
+        process.stdout.write('\x1b8\x1b[0J\n' + rows.join('\n'));
+    };
+    return runOverlay(render, (done) => (str, key) => {
+        if (!key)
+            return;
+        if (key.name === 'escape' || (key.ctrl && key.name === 'c'))
+            return done(null);
+        if (key.name === 'up')
+            return void ((index = Math.max(0, index - 1)), render());
+        if (key.name === 'down')
+            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);
+        }
+        if (key.name === 'backspace') {
+            if (!filter)
+                return done(null); // nothing left to delete → close the menu
+            filter = filter.slice(0, -1);
+            index = 0;
+            scroll = 0;
+            items = match();
+            return render();
+        }
+        if (str && str.length === 1 && str >= ' ' && !key.ctrl && !key.meta) {
+            filter += str;
+            index = 0;
+            scroll = 0;
+            items = match();
+            return render();
+        }
+    });
+}

package/dist/cli/commands/group.js

@@ -0,0 +1,139 @@
+import { runWithConnection } from "../../whatsapp/client.js";
+import { findChat, upsertChat } from "../../db/sqlite.js";
+import { phoneToJid } from "../../utils/jid.js";
+import { isGroupJid } from "../../whatsapp/events.js";
+import { print, ok, fail, info } from "../../utils/ui.js";
+import { c } from "../../utils/format.js";
+const USAGE = `Usage:
+  wa group info <group>
+  wa group invite <group>
+  wa group rename <group> <new subject>
+  wa group add <group> <number...>
+  wa group remove <group> <number...>
+  wa group leave <group>
+  wa group create <subject> <number...>`;
+/** wa group <action> [args...] — basic group management. */
+export async function group(action, args = []) {
+    if (!action) {
+        print(USAGE);
+        return;
+    }
+    switch (action.toLowerCase()) {
+        case 'info': return info_(args);
+        case 'invite': return invite(args);
+        case 'rename':
+        case 'subject': return rename(args);
+        case 'add': return participants(args, 'add');
+        case 'remove':
+        case 'kick': return participants(args, 'remove');
+        case 'promote': return participants(args, 'promote');
+        case 'demote': return participants(args, 'demote');
+        case 'leave':
+        case 'exit': return leave(args);
+        case 'create': return create(args);
+        default:
+            fail(`Unknown group action "${action}".\n${USAGE}`);
+    }
+}
+/** Resolve a group target (name or jid) to a group jid. */
+function resolveGroup(target) {
+    if (!target)
+        fail('Missing <group>.');
+    if (isGroupJid(target))
+        return target;
+    const chat = findChat(target);
+    if (!chat)
+        fail(`No chat matching "${target}".`);
+    if (!chat.isGroup)
+        fail(`"${target}" is not a group.`);
+    return chat.jid;
+}
+/** Turn phone-number args into WhatsApp jids. */
+function toJids(numbers) {
+    const jids = [];
+    for (const n of numbers) {
+        const jid = isGroupJid(n) ? null : n.includes('@') ? n : phoneToJid(n);
+        if (!jid)
+            fail(`Invalid phone number: "${n}"`);
+        jids.push(jid);
+    }
+    return jids;
+}
+async function withGroup(fn) {
+    return runWithConnection((conn) => fn(conn.sock), { requireSession: true }).catch((err) => fail(err.message));
+}
+async function info_(args) {
+    const jid = resolveGroup(args[0]);
+    info('Fetching group info…');
+    const meta = await withGroup((sock) => sock.groupMetadata(jid));
+    const admins = meta.participants.filter((p) => p.admin).length;
+    print(c.bold(meta.subject) + c.dim(`  ${meta.id}`));
+    if (meta.desc)
+        print(c.dim(meta.desc));
+    print(`  Participants: ${c.cyan(String(meta.participants.length))}  ·  Admins: ${c.cyan(String(admins))}`);
+    if (meta.owner)
+        print(`  Owner: ${c.dim(meta.owner.split('@')[0])}`);
+    print(c.dim('  Members:'));
+    for (const p of meta.participants.slice(0, 50)) {
+        const tag = p.admin ? c.green(p.admin === 'superadmin' ? ' (owner)' : ' (admin)') : '';
+        print(`    ${p.id.split('@')[0]}${tag}`);
+    }
+    if (meta.participants.length > 50)
+        print(c.dim(`    …and ${meta.participants.length - 50} more`));
+}
+async function invite(args) {
+    const jid = resolveGroup(args[0]);
+    const code = await withGroup((sock) => sock.groupInviteCode(jid));
+    ok(`Invite link: https://chat.whatsapp.com/${code}`);
+}
+async function rename(args) {
+    const jid = resolveGroup(args[0]);
+    const subject = args.slice(1).join(' ').trim();
+    if (!subject)
+        fail('Missing new subject.');
+    await withGroup((sock) => sock.groupUpdateSubject(jid, subject));
+    upsertChat({ jid, name: subject });
+    ok(`Renamed group to "${subject}".`);
+}
+async function participants(args, action) {
+    const jid = resolveGroup(args[0]);
+    const jids = toJids(args.slice(1));
+    if (jids.length === 0)
+        fail('Provide at least one phone number.');
+    info(`${action[0].toUpperCase() + action.slice(1)}ing ${jids.length} participant(s)…`);
+    const res = await withGroup((sock) => sock.groupParticipantsUpdate(jid, jids, action));
+    for (const r of res) {
+        const num = (r.jid ?? '').split('@')[0];
+        if (r.status === '200')
+            ok(`${num}: done`);
+        else
+            print(`  ${c.yellow('!')} ${num}: ${statusHint(r.status ?? '')}`);
+    }
+}
+function statusHint(status) {
+    switch (status) {
+        case '403': return 'not allowed (need admin, or their privacy settings block it)';
+        case '404': return 'not on WhatsApp';
+        case '408': return 'recently left — try later';
+        case '409': return 'already in the group';
+        default: return `failed (${status})`;
+    }
+}
+async function leave(args) {
+    const jid = resolveGroup(args[0]);
+    await withGroup((sock) => sock.groupLeave(jid));
+    upsertChat({ jid, archived: 1 });
+    ok('Left the group.');
+}
+async function create(args) {
+    const subject = args[0];
+    if (!subject)
+        fail('Usage: wa group create <subject> <number...>');
+    const jids = toJids(args.slice(1));
+    if (jids.length === 0)
+        fail('Add at least one participant number to create a group.');
+    info(`Creating group "${subject}" with ${jids.length} member(s)…`);
+    const meta = await withGroup((sock) => sock.groupCreate(subject, jids));
+    upsertChat({ jid: meta.id, name: subject, isGroup: 1, lastTimestamp: Date.now() });
+    ok(`Created "${subject}" — ${meta.id}`);
+}