@nodium.io/cli 0.0.0-stage → 0.2.0

package/dist/listen.js

@@ -0,0 +1,200 @@
+import { NodiumError, WEBHOOK_EVENTS } from '@nodium.io/whatsapp';
+import { signWebhook } from '@nodium.io/whatsapp/server';
+import { UsageError } from './args.js';
+import { clock, paint } from './output.js';
+/**
+ * `nodium listen` : les événements de votre compte, rejoués vers une adresse
+ * locale, signés comme en production. Aucun tunnel : c'est la commande qui
+ * interroge Nodium, jamais l'inverse.
+ *
+ * Elle lit le JOURNAL D'ÉVÉNEMENTS (`GET /events`, depuis un curseur) : chaque
+ * ligne est l'enveloppe exacte d'un webhook, plus son `seq`. Le direct du
+ * journal de la console (`GET /events/stream`) porte d'autres lignes (messages,
+ * livraisons, appels) et non ces enveloppes : il ne sert pas ici.
+ *
+ * ⚠️ Le corps envoyé est l'enveloppe SANS `seq`, sérialisée une fois ; la
+ *    signature est calculée sur ces octets (`t=<s>,v1=hmac-sha256(secret, "<t>.<corps>")`,
+ *    la même fonction que `signWebhook` de `@nodium.io/whatsapp/server`). Un récepteur qui vérifie sur
+ *    le corps brut accepte l'appel comme en production.
+ * ⚠️ Le curseur avance après chaque page rejouée, que l'adresse locale ait
+ *    répondu ou non : un échec local n'est pas rejoué (production le fait ;
+ *    ici, relancez avec `--from <seq>` ou rejouez depuis la console).
+ * ⚠️ `message.imported` ne sonne jamais en production : il n'est rejoué que si
+ *    `--events` le nomme.
+ */
+/** Le délai d'attente de l'adresse locale : celui de Nodium en production. */
+export const FORWARD_TIMEOUT_MS = 10_000;
+/** Événements lus par appel (le défaut de l'API est 100, son plafond 500). */
+const PAGE = 100;
+/** Attente entre deux lectures du journal quand il n'y a rien de neuf, en millisecondes. */
+export const DEFAULT_INTERVAL_MS = 1000;
+const MIN_INTERVAL_MS = 250;
+/** L'attente maximale entre deux essais quand Nodium est injoignable. */
+const BACKOFF_CAP_MS = 15_000;
+/**
+ * L'appel que Nodium ferait : le corps (l'enveloppe, sans `seq`) et les
+ * en-têtes. Sans `secret`, pas d'en-tête de signature.
+ */
+export function buildDelivery(entry, secret, nowSeconds = Math.floor(Date.now() / 1000)) {
+    const envelope = Object.fromEntries(Object.entries(entry).filter(([key]) => key !== 'seq'));
+    const body = JSON.stringify(envelope);
+    return {
+        body,
+        headers: {
+            'Content-Type': 'application/json',
+            'User-Agent': 'Nodium-Webhooks/1',
+            'X-Nodium-Event': entry.event,
+            'X-Nodium-Delivery': `local-${entry.id}`,
+            ...(secret ? { 'X-Nodium-Signature': signWebhook(secret, nowSeconds, body) } : {})
+        }
+    };
+}
+/**
+ * `--events message.received,message.failed` → l'ensemble voulu ; `null` pour
+ * « tous ceux qui sonnent ». `*` veut dire tous, comme dans un abonnement.
+ */
+export function parseEventFilter(text) {
+    if (text === undefined)
+        return null;
+    const names = text.split(',').map(name => name.trim()).filter(Boolean);
+    if (!names.length)
+        throw new UsageError('--events needs at least one event name.');
+    if (names.includes('*'))
+        return null;
+    const known = new Set(WEBHOOK_EVENTS);
+    const unknown = names.filter(name => !known.has(name));
+    if (unknown.length)
+        throw new UsageError(`Unknown event ${unknown.map(n => `"${n}"`).join(', ')}. Known: ${WEBHOOK_EVENTS.join(', ')}.`);
+    return new Set(names);
+}
+/** Cet événement est-il rejoué ? Sans filtre : tous, sauf l'historique importé. */
+export function wanted(filter, event) {
+    return filter ? filter.has(event) : event !== 'message.imported';
+}
+/** L'adresse locale : http ou https, rien d'autre. */
+export function parseForwardUrl(text) {
+    if (!text)
+        throw new UsageError('--forward <url> is required, for example --forward http://localhost:3000/webhook.');
+    let url;
+    try {
+        url = new URL(text);
+    }
+    catch {
+        throw new UsageError(`--forward "${text}" is not a valid URL. Example: http://localhost:3000/webhook.`);
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:')
+        throw new UsageError('--forward must be an http:// or https:// URL.');
+    return url.toString();
+}
+async function forwardOne(url, delivery, fetchImpl) {
+    const started = performance.now();
+    try {
+        const response = await fetchImpl(url, {
+            method: 'POST',
+            headers: delivery.headers,
+            body: delivery.body,
+            redirect: 'manual',
+            signal: AbortSignal.timeout(FORWARD_TIMEOUT_MS)
+        });
+        await response.arrayBuffer().catch(() => { });
+        return { status: response.status, ms: Math.round(performance.now() - started), error: null };
+    }
+    catch (cause) {
+        const ms = Math.round(performance.now() - started);
+        if (cause?.name === 'TimeoutError' || cause?.name === 'AbortError') {
+            return { status: null, ms, error: `no answer within ${FORWARD_TIMEOUT_MS / 1000} s (Nodium waits as long in production)` };
+        }
+        const code = cause?.cause?.code ?? cause?.code;
+        if (code === 'ECONNREFUSED')
+            return { status: null, ms, error: `connection refused: is your server listening on ${new URL(url).host}?` };
+        return { status: null, ms, error: String(cause?.cause?.message ?? cause?.message ?? cause) };
+    }
+}
+/** Une attente que l'arrêt interrompt. */
+export function pause(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal.aborted)
+            return resolve();
+        const done = () => {
+            clearTimeout(timer);
+            signal.removeEventListener('abort', done);
+            resolve();
+        };
+        const timer = setTimeout(done, ms);
+        signal.addEventListener('abort', done, { once: true });
+    });
+}
+/** Ce qui ne se réessaie pas : la clé, un appel interdit, le client visé. */
+function isFatal(error) {
+    return error instanceof NodiumError && (error.status === 401 || error.status === 403 || error.status === 404);
+}
+export async function listen(options) {
+    const { scope, signal, output } = options;
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    const sleep = options.sleep ?? pause;
+    const intervalMs = Math.max(MIN_INTERVAL_MS, options.intervalMs);
+    const summary = { forwarded: 0, failed: 0, after: 0 };
+    // Un premier appel sans `after` rend la tête du journal : le curseur du « maintenant ».
+    summary.after = options.from ?? (await scope.events.list()).next_after;
+    output.out(`${paint(output, 'bold', 'Listening')} ${options.from === null ? 'from now' : `after event #${options.from}`} → ${options.forward}`);
+    output.out(paint(output, 'dim', options.secret
+        ? 'Calls are signed with your secret: verify X-Nodium-Signature as in production.'
+        : 'No --secret: calls carry no X-Nodium-Signature header.'));
+    output.out(paint(output, 'dim', 'Press Ctrl+C to stop.'));
+    let failures = 0;
+    while (!signal.aborted) {
+        let full;
+        try {
+            const page = await scope.events.list(summary.after, PAGE);
+            if (failures) {
+                output.out(paint(output, 'green', 'Connection with Nodium restored.'));
+                failures = 0;
+            }
+            for (const entry of page.data) {
+                if (signal.aborted)
+                    break;
+                if (wanted(options.events, entry.event))
+                    await deliver(entry, options, fetchImpl, summary);
+                summary.after = entry.seq;
+            }
+            // Une page rejouée en entier : tout ce qui précède `next_after` est rendu ou n'est pas à vous.
+            if (!signal.aborted)
+                summary.after = page.next_after;
+            full = page.data.length >= PAGE;
+        }
+        catch (error) {
+            if (error instanceof NodiumError && error.code === 'cursor_expired') {
+                // Le journal garde 30 jours : un curseur plus vieux est repris à la tête.
+                summary.after = (await scope.events.list()).next_after;
+                output.err(paint(output, 'yellow', 'The cursor is older than the event log (30 days): restarting from now.'));
+                continue;
+            }
+            if (isFatal(error))
+                throw error;
+            failures++;
+            const wait = Math.min(BACKOFF_CAP_MS, intervalMs * 2 ** failures);
+            output.err(paint(output, 'yellow', `Nodium is unreachable (${error instanceof NodiumError ? error.code : 'error'}); retrying in ${Math.round(wait / 1000)} s from event #${summary.after}.`));
+            await sleep(wait, signal);
+            continue;
+        }
+        if (!full)
+            await sleep(intervalMs, signal);
+    }
+    return summary;
+}
+/** Rejoue un événement et en écrit la ligne. */
+async function deliver(entry, options, fetchImpl, summary) {
+    const { output } = options;
+    const result = await forwardOne(options.forward, buildDelivery(entry, options.secret), fetchImpl);
+    summary.forwarded++;
+    const ok = result.status !== null && result.status >= 200 && result.status < 300;
+    if (!ok)
+        summary.failed++;
+    const client = entry.external_id ? ` [${entry.external_id}]` : '';
+    const status = paint(output, ok ? 'green' : 'red', result.status === null ? 'ERR' : String(result.status));
+    output.out(`${paint(output, 'dim', clock())}  ${entry.event.padEnd(24)} ${status}  ${String(result.ms).padStart(5)} ms  ${paint(output, 'dim', entry.id + client)}`);
+    if (result.error)
+        output.out(`          ${paint(output, 'red', result.error)}`);
+    if (options.verbose)
+        output.out(paint(output, 'dim', JSON.stringify(entry.data, null, 2).replace(/^/gm, '          ')));
+}

package/dist/output.js

@@ -0,0 +1,65 @@
+import { NodiumError } from '@nodium.io/whatsapp';
+import { UsageError } from './args.js';
+const CODES = { dim: 2, red: 31, green: 32, yellow: 33, cyan: 36, bold: 1 };
+export function paint(output, style, text) {
+    return output.color ? `\u001b[${CODES[style]}m${text}\u001b[0m` : text;
+}
+/** L'heure locale, `HH:MM:SS`. */
+export function clock(date = new Date()) {
+    return date.toTimeString().slice(0, 8);
+}
+/** Les codes qui n'ont pas de ligne dans le guide des erreurs. */
+const NO_GUIDE = new Set(['unknown_error', 'network_error', 'timeout']);
+/**
+ * Une erreur en quelques lignes : le statut et le `code` (stable, c'est lui
+ * qu'on cherche dans la documentation), le texte, l'identifiant à donner au
+ * support, et la ligne du guide des erreurs.
+ */
+export function describeError(error, baseUrl) {
+    if (error instanceof UsageError)
+        return error.message;
+    if (!(error instanceof NodiumError))
+        return error instanceof Error ? error.message : String(error);
+    const lines = [`${error.status ? `Error ${error.status}` : 'Error'} ${error.code}: ${error.message}`];
+    if (error.status === 401)
+        lines.push('The key is missing, malformed, expired or revoked: check --key, NODIUM_KEY, or run `nodium login` again.');
+    if (error.retryAfter !== null)
+        lines.push(`Retry in ${error.retryAfter} s.`);
+    if (error.requestId)
+        lines.push(`Request id: ${error.requestId}`);
+    if (error.status > 0 && !NO_GUIDE.has(error.code)) {
+        try {
+            lines.push(`More: ${new URL(baseUrl).origin}/en/docs/api/guide/responses#${error.code}`);
+        }
+        catch { /* adresse illisible : pas de lien */ }
+    }
+    return lines.join('\n');
+}
+/**
+ * Le refus en JSON, sur la sortie d'erreur : `{ "error": { status, code,
+ * message, requestId } }`. Une faute d'usage a `status` 0 et le code `usage_error`.
+ */
+export function errorJson(error) {
+    const body = error instanceof NodiumError
+        ? { status: error.status, code: error.code, message: error.message, requestId: error.requestId }
+        : { status: 0, code: error instanceof UsageError ? 'usage_error' : 'cli_error', message: error instanceof Error ? error.message : String(error), requestId: null };
+    return JSON.stringify({ error: body }, null, 2);
+}
+/** Des colonnes alignées, une ligne par entrée ; la dernière colonne n'est pas complétée. */
+export function table(rows) {
+    const widths = [];
+    for (const row of rows)
+        row.forEach((cell, i) => { widths[i] = Math.max(widths[i] ?? 0, cell.length); });
+    return rows.map(row => row.map((cell, i) => (i === row.length - 1 ? cell : cell.padEnd(widths[i]))).join('  ').trimEnd());
+}
+/** Une date ISO en `AAAA-MM-JJ HH:MM`, ou `—`. */
+export function when(iso) {
+    return iso ? iso.slice(0, 16).replace('T', ' ') : '—';
+}
+/** Un objet en lignes `clé  valeur` ; ce qui est imbriqué s'écrit en JSON compact. */
+export function details(object) {
+    return table(Object.entries(object).map(([key, value]) => [
+        key,
+        value === null || value === undefined ? '—' : typeof value === 'object' ? JSON.stringify(value) : String(value)
+    ]));
+}

package/dist/run.js

@@ -0,0 +1,161 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { DEFAULT_BASE_URL, Nodium } from '@nodium.io/whatsapp';
+import { UsageError, flag, hasFlag, parseArgs, rejectUnknown } from './args.js';
+import { COMMANDS, findCommands } from './commands/index.js';
+import { configPath as defaultConfigPath, readConfig, resolveKey } from './config.js';
+import { confirmWrite, outputMode } from './context.js';
+import { pause } from './listen.js';
+import { describeError, errorJson, paint, table } from './output.js';
+/**
+ * La commande `nodium` : lit la ligne de commande, cherche la commande dans la
+ * table (`commands/index.ts`), branche le client, rend le code de sortie
+ * (0 réussi, 1 refusé par Nodium ou par Meta, 2 mal appelé).
+ *
+ * ⚠️ La clé se donne de préférence par `nodium login` ou `NODIUM_KEY` :
+ *    `--key` reste dans l'historique du terminal.
+ */
+/** Les drapeaux qu'accepte toute commande. */
+const COMMON = ['key', 'tenant', 'base-url', 'output', 'yes', 'no-color', 'help'];
+const COMMON_HELP = `Options for every command
+  --key <nod_…>          API key. Default: $NODIUM_KEY, then the key saved by \`nodium login\`.
+  --tenant <id>          Act for one client: its id or your own externalId.
+  --output <json|human>  json: the API's object, for scripts and agents. Default: human in a
+                         terminal, json when piped.
+  -y, --yes              Approve a command that sends or changes something, without asking.
+                         Required when not in a terminal.
+  --base-url <url>       API address. Default: ${DEFAULT_BASE_URL} ($NODIUM_BASE_URL).
+  --no-color             No colors (also: $NO_COLOR).
+  -h, --help             This help, or the help of a command.
+  -v, --version          The version.`;
+function usage(command) {
+    return ['nodium', ...command.path, ...(command.args ?? [])].join(' ');
+}
+export function globalHelp() {
+    return `nodium: the Nodium WhatsApp API from your terminal.
+
+Commands
+${table(COMMANDS.map(c => [`  ${usage(c)}`, c.summary])).join('\n')}
+
+${COMMON_HELP}
+
+Exit codes: 0 done, 1 refused by Nodium or Meta, 2 wrong command line.
+More: nodium help <command>, for example \`nodium help templates wait\`.
+`;
+}
+export function commandHelp(command) {
+    return `${usage(command)}: ${command.summary}
+
+Usage
+  ${usage(command)}${command.flags?.length ? ' [options]' : ''}
+${command.help ? `\nOptions\n${command.help}\n` : ''}
+Options for every command: \`nodium --help\`.
+`;
+}
+function groupHelp(noun, commands) {
+    return `nodium ${noun}
+
+${table(commands.map(c => [`  ${usage(c)}`, c.summary])).join('\n')}
+
+More: nodium help ${noun} <${commands.map(c => c.path[1]).join('|')}>
+`;
+}
+function packageVersion() {
+    try {
+        const file = fileURLToPath(new URL('../package.json', import.meta.url));
+        return String(JSON.parse(readFileSync(file, 'utf8')).version);
+    }
+    catch {
+        return 'unknown';
+    }
+}
+const NO_IO = {
+    ask: async () => '',
+    readSecret: async () => '',
+    readStdin: async () => ''
+};
+/**
+ * La commande nommée par les mots de la ligne : `templates wait` ou `send`.
+ * Rend aussi les mots qui restent (ses arguments).
+ */
+export function resolveCommand(words) {
+    const [noun, verb, ...more] = words;
+    if (!noun)
+        return { command: null, rest: [], group: [] };
+    const group = findCommands([noun]);
+    const exact = group.find(c => c.path.length === 1);
+    if (exact)
+        return { command: exact, rest: words.slice(1), group };
+    const command = verb ? group.find(c => c.path[1] === verb) ?? null : null;
+    return { command, rest: command ? more : [], group };
+}
+export async function run(argv, context) {
+    const { output, env } = context;
+    let baseUrl = env.NODIUM_BASE_URL || DEFAULT_BASE_URL;
+    let json = false;
+    try {
+        const args = parseArgs(argv);
+        json = outputMode(flag(args, 'output'), Boolean(context.stdoutIsTty)) === 'json';
+        if (hasFlag(args, 'version')) {
+            output.out(packageVersion());
+            return 0;
+        }
+        // `nodium help templates wait` vaut `nodium templates wait --help`.
+        const asksHelp = args.command === 'help' || hasFlag(args, 'help');
+        const words = args.command === 'help' ? args.positionals : [args.command ?? '', ...args.positionals].filter(Boolean);
+        if (!words.length) {
+            output.out(globalHelp());
+            return asksHelp ? 0 : 2;
+        }
+        const { command, rest, group } = resolveCommand(words);
+        if (!command) {
+            if (!group.length)
+                throw new UsageError(`Unknown command "${words[0]}". Try \`nodium --help\`.`);
+            if (asksHelp || words.length === 1) {
+                output.out(groupHelp(words[0], group));
+                return asksHelp ? 0 : 2;
+            }
+            throw new UsageError(`Unknown command "${words.slice(0, 2).join(' ')}". Try \`nodium help ${words[0]}\`.`);
+        }
+        if (asksHelp) {
+            output.out(commandHelp(command));
+            return 0;
+        }
+        const name = command.path.join(' ');
+        const commandArgs = { ...args, command: name, positionals: rest };
+        rejectUnknown(commandArgs, [...COMMON, ...(command.flags ?? [])], name, command.args?.length ?? 0);
+        const path = context.configPath ?? defaultConfigPath(env);
+        const config = readConfig(path);
+        baseUrl = flag(args, 'base-url') ?? (env.NODIUM_BASE_URL || config.baseUrl || DEFAULT_BASE_URL);
+        let client = null;
+        const nodium = () => {
+            if (!client) {
+                const { key } = resolveKey(flag(args, 'key'), env, config);
+                client = new Nodium(key, { baseUrl, ...(context.fetch ? { fetch: context.fetch } : {}) });
+            }
+            return client;
+        };
+        const io = context.io ?? NO_IO;
+        const interactive = Boolean(context.interactive);
+        const ctx = {
+            args: commandArgs, output, json, interactive, env, signal: context.signal, io,
+            ...(context.fetch ? { fetch: context.fetch } : {}),
+            sleep: context.sleep ?? pause,
+            baseUrl, configPath: path, config,
+            nodium,
+            scope: () => {
+                const tenant = flag(args, 'tenant');
+                return tenant ? nodium().as(tenant) : nodium();
+            },
+            print: (data, human) => (json ? output.out(JSON.stringify(data, null, 2)) : human()),
+            confirm: what => confirmWrite(what, { yes: hasFlag(args, 'yes'), interactive, ask: io.ask })
+        };
+        if (command.needsKey !== false)
+            nodium();
+        return await command.run(ctx);
+    }
+    catch (error) {
+        output.err(json ? errorJson(error) : paint(output, 'red', describeError(error, baseUrl)));
+        return error instanceof UsageError ? 2 : 1;
+    }
+}

package/dist/send.js

@@ -0,0 +1,113 @@
+import { UsageError, flag, flagAll, hasFlag } from './args.js';
+import { readJsonInput } from './input.js';
+import { paint } from './output.js';
+/**
+ * `nodium send` : un message. Du texte libre (dans les 24 h qui suivent le
+ * dernier message de la personne) ou un modèle approuvé (le seul envoi
+ * possible pour écrire en premier) par drapeaux ; tout autre message (fichier,
+ * boutons, liste…) en JSON, par `--input` ou `--stdin`.
+ *
+ * ⚠️ Un envoi refusé par Meta répond HTTP 200 : la commande lit
+ *    `message.status` et sort en erreur (code 1) quand il vaut `failed`.
+ */
+/** Ce que la commande a lu de la ligne de commande, vérifié. */
+export function readSendInput(args) {
+    const channelId = flag(args, 'channel');
+    if (!channelId)
+        throw new UsageError('--channel <id> is required: the number to send from (`GET /channels`).');
+    const to = flag(args, 'to');
+    const recipient = flag(args, 'recipient');
+    if (!to && !recipient)
+        throw new UsageError('--to <+33612345678> is required (or --recipient wa:… for a contact without a number).');
+    if (to && recipient)
+        throw new UsageError('Give --to or --recipient, never both.');
+    const address = to ? { to } : { recipient: recipient };
+    const text = flag(args, 'text');
+    const template = flag(args, 'template');
+    if (text !== undefined && template)
+        throw new UsageError('Give --text or --template, not both.');
+    if (text === undefined && !template)
+        throw new UsageError('Nothing to send: give --text "…" or --template <name>.');
+    const idempotencyKey = flag(args, 'idempotency-key');
+    const base = { channelId, ...(idempotencyKey ? { idempotencyKey } : {}) };
+    if (text !== undefined)
+        return { ...base, ...address, type: 'text', text };
+    const variables = {};
+    for (const pair of flagAll(args, 'var')) {
+        const eq = pair.indexOf('=');
+        if (eq <= 0)
+            throw new UsageError(`--var "${pair}" must look like 1=Karim (the number of the {{variable}}, then its value).`);
+        variables[pair.slice(0, eq)] = pair.slice(eq + 1);
+    }
+    const language = flag(args, 'language');
+    return {
+        ...base, ...address, type: 'template', templateName: template,
+        ...(language ? { templateLanguage: language } : {}),
+        ...(Object.keys(variables).length ? { variables } : {})
+    };
+}
+/** Les drapeaux qui décrivent le message ; avec `--input` ou `--stdin`, aucun ne se donne. */
+const MESSAGE_FLAGS = ['channel', 'to', 'recipient', 'text', 'template', 'language', 'var', 'idempotency-key'];
+/** Le message à envoyer : le JSON de `--input`/`--stdin` (un `SendInput`), sinon les drapeaux. */
+async function readMessage(ctx) {
+    const json = await readJsonInput(ctx);
+    if (!json)
+        return readSendInput(ctx.args);
+    const mixed = MESSAGE_FLAGS.find(name => hasFlag(ctx.args, name));
+    if (mixed)
+        throw new UsageError(`--${mixed} cannot be mixed with --input or --stdin: put everything in the JSON.`);
+    if (typeof json.channelId !== 'string' || (typeof json.to !== 'string' && typeof json.recipient !== 'string')) {
+        throw new UsageError('The JSON needs "channelId" and "to" (or "recipient"), plus "type" and its fields.');
+    }
+    return json;
+}
+/** Envoie, écrit le résultat, rend le code de sortie. */
+async function send(ctx) {
+    const input = await readMessage(ctx);
+    const target = input.to ?? input.recipient;
+    await ctx.confirm(`Send a ${input.type ?? 'message'} to ${target} from number ${input.channelId}`);
+    const result = await ctx.scope().messages.send(input);
+    const message = result.message;
+    const failed = message?.status === 'failed';
+    ctx.print(result, () => {
+        const { output } = ctx;
+        if (!message)
+            return output.out(`Sent to ${target}.`);
+        if (failed) {
+            output.err(paint(output, 'red', `Message ${message.id} to ${target} failed.`));
+            if (message.errorInfo) {
+                output.err(`${message.errorInfo.title}`);
+                output.err(`What to do (${message.errorInfo.actor}): ${message.errorInfo.action}`);
+            }
+            else if (message.error) {
+                output.err(message.error);
+            }
+            return;
+        }
+        output.out(`${paint(output, 'green', message.status)}  message ${message.id} to ${target}${result.duplicate ? ' (already sent with this idempotency key: nothing left again)' : ''}`);
+        output.out(paint(output, 'dim', `Follow it: nodium messages get ${message.id}`));
+    });
+    return failed ? 1 : 0;
+}
+export const SEND_COMMAND = {
+    path: ['send'], summary: 'Send a WhatsApp message. Asks first.',
+    flags: [...MESSAGE_FLAGS, 'input', 'stdin'],
+    help: `  --channel <id>          The number to send from (\`nodium numbers list\`). Required.
+  --to <number>           The recipient, in international format. Or --recipient wa:… for a
+                          contact who shows no number.
+  --text <text>           Free text: only within 24 hours of the person's last message.
+  --template <name>       An approved template: the only way to write first.
+  --language <code>       The template language, for example en or fr.
+  --var <n=value>         A template variable (repeat it): --var 1=Karim --var 2=Friday.
+  --idempotency-key <k>   Your own anti-duplicate key (8 to 200 characters).
+  --input <file.json>     Any message as JSON (image, buttons, list, location…), or --stdin.
+                          The fields of POST /messages: channelId, to, type and its fields.
+
+Examples
+  nodium send --channel <id> --to +33612345678 --text "Hello"
+  nodium send --channel <id> --to +33612345678 --template order_ready --language en --var 1=Karim
+  echo '{"channelId":"<id>","to":"+33612345678","type":"image","mediaId":"<id>"}' | nodium send --stdin --yes
+
+A send Meta refuses answers HTTP 200: the command reads the message status and exits 1.`,
+    run: send
+};

package/package.json

@@ -1,6 +1,26 @@
 {
   "name": "@nodium.io/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "The nodium command: the Nodium WhatsApp API from your terminal — numbers, conversations, templates, webhooks, clients, Flows — and your webhooks replayed to your local server, signed like production.",
+  "keywords": ["nodium", "cli", "whatsapp", "whatsapp-api", "whatsapp-cloud-api", "webhooks", "local-development"],
+  "homepage": "https://nodium.io/en/docs/api",
+  "license": "MIT",
+  "author": "By-Tech.io",
+  "type": "module",
+  "engines": { "node": ">=20" },
+  "bin": { "nodium": "./dist/index.js" },
+  "files": ["dist", "README.md", "LICENSE"],
+  "publishConfig": { "access": "public" },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "typecheck": "node scripts/build.mjs --check",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@nodium.io/whatsapp": "^0.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.4.0",
+    "typescript": "^5.9.2"
+  }
+}