path: root/src/cli.js

import { parseArgs } from 'node:util';
import qrcode from 'qrcode-terminal';
import { METHODS, getMethod, resources, schema, validate } from './api/index.js';
import { accountName, paths, VERSION } from './config.js';
import { FORMATS } from './format/index.js';
import { HELPERS } from './helpers.js';
import { parseJsonArg, print } from './output.js';
import { WaError, call, ping } from './rpc.js';
import { Session } from './session.js';

// Same exit codes as gws, plus 4 = daemon.
const EXIT = { EAPI: 1, ENOTFOUND: 1, ETIMEOUT: 1, EAUTH: 2, EINVAL: 3, EAMBIGUOUS: 3, EDAEMON: 4, EINTERNAL: 5 };

const GLOBAL_OPTIONS = {
    account: { type: 'string', short: 'a' },
    format: { type: 'string' },
    params: { type: 'string' },
    json: { type: 'string' },
    output: { type: 'string', short: 'o' },
    'no-autostart': { type: 'boolean' },
    help: { type: 'boolean', short: 'h' },
    version: { type: 'boolean' },
};

// CLI commands that are not daemon methods.
const LOCAL_COMMANDS = {
    'auth.login': 'Link this device (QR in the terminal, or --phone for a code)',
    'daemon.start': 'Start the daemon in the background (--foreground for systemd)',
};
const LOCAL_ONLY = [
    '    wa format <FMT> < data.json',
];

const out = (s = '') => process.stdout.write(`${s}\n`);
const err = (s = '') => process.stderr.write(`${s}\n`);

export async function main(argv) {
    process.stdout.on('error', (e) => {
        if (e.code === 'EPIPE') process.exit(0);
    });
    try {
        return await run(argv);
    } catch (e) {
        return fail(e);
    }
}

function fail(e) {
    const known = e.code in EXIT;
    err(`wa: ${e.message}`);
    if (Array.isArray(e.data)) for (const c of e.data) err(`  ${c.name ?? ''} <${c.id}>`);
    if (!known && process.env.WA_CLI_DEBUG) err(e.stack);
    return known ? EXIT[e.code] : (e.name === 'TypeError' || e.name === 'ReferenceError' ? 5 : 1);
}

function parse(argv, extra = {}) {
    try {
        return parseArgs({ args: argv, options: { ...GLOBAL_OPTIONS, ...extra }, strict: true, allowPositionals: true });
    } catch (e) {
        throw new WaError('EINVAL', e.message);
    }
}

async function run(argv) {
    const pre = parseArgs({ args: argv, options: GLOBAL_OPTIONS, strict: false, allowPositionals: true });
    const [cmd, sub] = pre.positionals;

    if (pre.values.version) return out(VERSION), 0;
    if (!cmd || cmd === 'help') {
        if (sub && resources()[sub]) return resourceHelp(sub), 0;
        return mainHelp(), 0;
    }
    if (pre.values.format && !FORMATS[pre.values.format]) {
        throw new WaError('EINVAL', `unknown format: ${pre.values.format} (${Object.keys(FORMATS).join(', ')})`);
    }

    // ---- helpers
    if (cmd.startsWith('+')) {
        const helper = HELPERS[cmd];
        if (!helper) throw new WaError('EINVAL', `unknown helper: ${cmd} (${Object.keys(HELPERS).join(', ')})`);
        const spec = Object.fromEntries(Object.entries(helper.options || {}).map(([k, { description, ...o }]) => [k, o]));
        const { values, positionals } = parse(argv, spec);
        if (values.help) return helperHelp(cmd), 0;
        return helper.run(sessionFor(values), positionals.slice(1), values);
    }

    // ---- schema
    if (cmd === 'schema') {
        const { positionals } = parse(argv);
        if (positionals[1]) return print(schema(positionals[1]), pre.values.format || 'json'), 0;
        const all = Object.fromEntries(Object.entries(METHODS).map(([k, d]) => [k, d.description]));
        return print(all, pre.values.format || 'json'), 0;
    }

    // ---- format: JSON on stdin -> another format, without the daemon (e.g. in hooks)
    if (cmd === 'format') {
        const { values, positionals } = parse(argv, { columns: { type: 'string' } });
        const fmt = positionals[1] || values.format;
        if (!fmt || values.help) {
            out('Usage: wa format <FMT> [--columns a,b.c] < data.json\n');
            out('Converts JSON (the output of another `wa`) to another format without talking to the daemon.');
            out('E.g.: jq .data | wa format eml    (inside a hook)');
            return fmt || values.help ? 0 : 3;
        }
        const columns = values.columns?.split(',');
        print(parseJsonArg('-', 'stdin'), fmt, { columns, output: values.output });
        return 0;
    }

    // ---- auth login
    if (cmd === 'auth' && sub === 'login') {
        const { values } = parse(argv, { phone: { type: 'string' } });
        if (values.help) {
            out('Links this device to WhatsApp.\n');
            out('Usage: wa auth login [--phone NUMBER]\n');
            out('Without --phone it shows a QR: WhatsApp > Settings > Linked devices > Link a device.');
            out('With --phone (e.g. 5491122334455) it shows an 8-character code for');
            out('"Link with phone number instead" on that same screen.');
            return 0;
        }
        return authLogin(sessionFor(values), values.phone);
    }

    // ---- daemon
    if (cmd === 'daemon') return daemonCommand(argv, sub);

    // ---- generic API: wa <resource> <method>
    const res = resources()[cmd];
    if (!res) throw new WaError('EINVAL', `unknown resource: ${cmd} (see \`wa --help\`)`);
    if (!sub) return resourceHelp(cmd), pre.values.help ? 0 : 3;
    const method = `${cmd}.${sub}`;
    const def = getMethod(method);
    const { values, positionals } = parse(argv);
    if (values.help) return methodHelp(method), 0;
    if (positionals.length > 2) {
        throw new WaError('EINVAL', `unexpected argument: ${positionals[2]} (parameters go in --params '{...}')`);
    }
    const params = validate(method, {
        ...parseJsonArg(values.params, '--params'),
        ...parseJsonArg(values.json, '--json'),
    }, { cwd: process.cwd() });
    const session = sessionFor(values);

    if (def.stream) {
        await session.call(method, params, { onEvent: (ev) => print(ev, values.format || 'ndjson') });
        return 0;
    }
    const result = await session.call(method, params);
    print(result, values.format || 'json', { columns: def.columns, output: values.output });
    return 0;
}

function sessionFor(values) {
    return new Session(accountName(values.account), values['no-autostart'] ?